Thuban/Model/session.py

# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
# Jan-Oliver Wagner <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

__version__ = "$Revision$"

import os
from tempfile import mktemp
import weakref

from messages import MAPS_CHANGED, EXTENSIONS_CHANGED, FILENAME_CHANGED, \
     MAP_LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
     LAYER_CHANGED, LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED,\
     EXTENSION_CHANGED, EXTENSION_OBJECTS_CHANGED, CHANGED

from Thuban import _

from base import TitledObject, Modifiable
from map import Map
from data import ShapefileStore

from transientdb import TransientDatabase, AutoTransientTable

class AutoRemoveFile:

    """Remove a file once all references go away."""

    def __init__(self, filename, tempdir = None):
        """Initialize the AutoRemoveFile

        Parameters:
           filename -- The name of the file to remove in __del__
           tempdir -- Another object simple stored as an instance variable.

        As the name suggests the tempdir parameter is intended for a
        temporary directory the file might be located in. The intended
        use is that it's an instance of AutoRemoveDir.
        """
        self.filename = filename
        self.tempdir = tempdir

    def __del__(self, remove = os.remove):
        remove(self.filename)

class AutoRemoveDir:

    """Remove a directory once all references go away

    The intended use of this class together with AutoRemoveFile is for
    temporary directories and files containd therein. An AutoRemoveDir
    should be instantiated for the directory and passed as the tempdir
    parameter to every AutoRemoveFile instance created for files in the
    directory. An AutoRemoveFile shold be instantiated for every file
    created in the directory so that the directory is automatically
    removed once the last file is removed.
    """

    def __init__(self, filename):
        """Initialize the AutoRemoveDir

        The parameter is the name of the directory.
        """
        self.filename = filename

    def __del__(self, rmdir = os.rmdir):
        rmdir(self.filename)


# WeakKey dictionary mapping objects like the transient_db to
# AutoRemoveDir or AutoRemoveFile instances to make sure that the
# temporary files and the directory are deleted but not before the
# objects that use them go away.
auto_remover = weakref.WeakKeyDictionary()

class Session(TitledObject, Modifiable):

    """A complete session.

    A Session consists of arbitrary numbers of maps, tables and extensions

    Session objects send the following events:

        TITLE_CHANGED -- The title has changed. Parameters: the session.

        FILENAME_CHANGED -- The filename has changed. No parameters.

        MAPS_CHANGED -- Maps were added, removed.

        EXTENSIONS_CHANGED -- Extensions were added, removed.

        MAP_LAYERS_CHANGED -- Same as the map's event of the same name.
                          It's simply resent from the session to make
                          subscriptions easier.

        CHANGED -- Generic changed event. Parameters: the session. The
                   event is always issued when any other changed event
                   is issused. This is useful for code that needs to be
                   notified whenever something in the session has
                   changed but it's too cumbersome or error-prone to
                   subscribe to all the individual events.
    """

    # message channels that have to be forwarded from maps contained in
    # the session.
    forwarded_channels = (
        # generic channels
        CHANGED,

        # map specific channels
        MAP_PROJECTION_CHANGED,
        MAP_LAYERS_CHANGED,

        # layer channels forwarded by the map
        LAYER_PROJECTION_CHANGED,
        LAYER_CHANGED,
        LAYER_VISIBILITY_CHANGED,

        # channels forwarded by an extension
        EXTENSION_CHANGED,
        EXTENSION_OBJECTS_CHANGED)

    def __init__(self, title):
        TitledObject.__init__(self, title)
        Modifiable.__init__(self)
        self.filename = None
        self.maps = []
        self.tables = []
        self.shapestores = []
        self.extensions = []
        self.temp_dir = None
        self.transient_db = None

    def changed(self, channel = None, *args):
        """Like the inherited version but issue a CHANGED message as well.

        The CHANGED message is only issued if channel given is a
        different channel than CHANGED.
        """
        Modifiable.changed(self, channel, *args)
        if channel != CHANGED:
            self.issue(CHANGED, self)

    def SetFilename(self, filename):
        self.filename = filename
        self.changed(FILENAME_CHANGED)

    def Maps(self):
        return self.maps

    def HasMaps(self):
        return len(self.maps) > 0

    def AddMap(self, map):
        self.maps.append(map)
        for channel in self.forwarded_channels:
            map.Subscribe(channel, self.forward, channel)
        self.changed(MAPS_CHANGED)

    def RemoveMap(self, map):
        for channel in self.forwarded_channels:
            map.Unsubscribe(channel, self.forward, channel)
        self.maps.remove(map)
        self.changed(MAPS_CHANGED)
        map.Destroy()

    def Extensions(self):
        return self.extensions

    def HasExtensions(self):
        return len(self.extensions) > 0

    def AddExtension(self, extension):
        self.extensions.append(extension)
        for channel in self.forwarded_channels:
            extension.Subscribe(channel, self.forward, channel)
        self.changed(EXTENSIONS_CHANGED)

    def ShapeStores(self):
        """Return a list of all ShapeStore objects open in the session"""
        return [store() for store in self.shapestores]

    def _add_shapestore(self, store):
        """Internal: Add the shapestore to the list of shapestores"""
        self.shapestores.append(weakref.ref(store,
                                            self._clean_weak_store_refs))

    def _clean_weak_store_refs(self, weakref):
        """Internal: Remove the weakref from the shapestores list"""
        self.shapestores = [store for store in self.shapestores
                                  if store is not weakref]

    def Tables(self):
        """Return a list of all table objects open in the session

        The list includes all tables that are indirectly opened through
        shape stores and the tables that have been opened explicitly.
        """
        return self.tables + [store.Table() for store in self.ShapeStores()]

    def AddTable(self, table):
        """Add the table to the session

        All tables associated with the session that are not implicitly
        created by the OpenShapefile method (and maybe other Open*
        methods in the future) have to be passed to this method to make
        sure the session knows about it. The session keeps a reference
        to the table. Only tables managed by the session in this way
        should be used for layers contained in one of the session's
        maps.

        The table parameter may be any object implementing the table
        interface. If it's not already one of the transient tables
        instantiate an AutoTransientTable with it and use that instead
        of the original table (note that the AutoTransientTable keeps a
        reference to the original table).

        Return the table object actually used by the session.
        """
        if not hasattr(table, "transient_table"):
            transient_table = AutoTransientTable(self.TransientDB(), table)
        else:
            transient_table = table
        self.tables.append(transient_table)
        return transient_table

    def RemoveTable(self, table):
        """Remove the table from the session.

        The table object must be a table object previously returned by
        the AddTable method. If the table is not part of the session
        raise a ValueError.
        """
        tables = [t for t in self.tables if t is not table]
        if len(tables) == len(self.tables):
            raise ValueError
        self.tables = tables

    def temp_directory(self):
        """
        Return the name of the directory for session specific temporary files

        Create the directory if it doesn't exist yet.
        """
        if self.temp_dir is None:
            temp_dir = mktemp()
            os.mkdir(temp_dir, 0700)
            self.temp_dir = temp_dir
            self.temp_dir_remover = AutoRemoveDir(self.temp_dir)
        return self.temp_dir

    def OpenShapefile(self, filename):
        """Return a shapefile store object for the data in the given file"""
        store = ShapefileStore(self, filename)
        self._add_shapestore(store)
        return store

    def TransientDB(self):
        if self.transient_db is None:
            filename = os.path.join(self.temp_directory(), "transientdb")
            self.transient_db = TransientDatabase(filename)
            #print self.temp_dir_remover
            auto_remover[self.transient_db] = AutoRemoveFile(filename,
                                                        self.temp_dir_remover)
        return self.transient_db

    def Destroy(self):
        for map in self.maps:
            map.Destroy()
        self.maps = []
        self.tables = []
        Modifiable.Destroy(self)

        # Close the transient DB explicitly so that it removes any
        # journal files from the temporary directory
        if self.transient_db is not None:
            self.transient_db.close()

    def forward(self, *args):
        """Reissue events.

        If the channel the event is forwarded to is a changed-channel
        that is not the CHANGED channel issue CHANGED as well. An
        channel is considered to be a changed-channel if it's name ends
        with 'CHANGED'.
        """
        if len(args) > 1:
            args = (args[-1],) + args[:-1]
        apply(self.issue, args)
        channel = args[0]
        # It's a bit of a kludge to rely on the channel name for this.
        if channel.endswith("CHANGED") and channel != CHANGED:
            self.issue(CHANGED, self)

    def WasModified(self):
        """Return true if the session or one of the maps was modified"""
        if self.modified:
            return 1
        else:
            for map in self.maps:
                if map.WasModified():
                    return 1
        return 0

    def UnsetModified(self):
        """Unset the modified flag of the session and the maps"""
        Modifiable.UnsetModified(self)
        for map in self.maps:
            map.UnsetModified()

    def TreeInfo(self):
        items = []
        if self.filename is None:
            items.append(_("Filename:"))
        else:
            items.append(_("Filename: %s") % self.filename)

        if self.WasModified():
            items.append(_("Modified"))
        else:
            items.append(_("Unmodified"))

        items.extend(self.maps)
        items.extend(self.extensions)

        return (_("Session: %s") % self.title, items)


def create_empty_session():
    """Return an empty session useful as a starting point"""
    import os
    session = Session(_('unnamed session'))
    session.SetFilename(None)
    session.AddMap(Map(_('unnamed map')))
    session.UnsetModified()
    return session
1	# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[email protected]>
4	# Jan-Oliver Wagner <[email protected]>
5	#
6	# This program is free software under the GPL (>=v2)
7	# Read the file COPYING coming with Thuban for details.
8
9	__version__ = "$Revision$"
10
11	import os
12	from tempfile import mktemp
13	import weakref
14
15	from messages import MAPS_CHANGED, EXTENSIONS_CHANGED, FILENAME_CHANGED, \
16	MAP_LAYERS_CHANGED, MAP_PROJECTION_CHANGED, \
17	LAYER_CHANGED, LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED,\
18	EXTENSION_CHANGED, EXTENSION_OBJECTS_CHANGED, CHANGED
19
20	from Thuban import _
21
22	from base import TitledObject, Modifiable
23	from map import Map
24	from data import ShapefileStore
25
26	from transientdb import TransientDatabase, AutoTransientTable
27
28	class AutoRemoveFile:
29
30	"""Remove a file once all references go away."""
31
32	def __init__(self, filename, tempdir = None):
33	"""Initialize the AutoRemoveFile
34
35	Parameters:
36	filename -- The name of the file to remove in __del__
37	tempdir -- Another object simple stored as an instance variable.
38
39	As the name suggests the tempdir parameter is intended for a
40	temporary directory the file might be located in. The intended
41	use is that it's an instance of AutoRemoveDir.
42	"""
43	self.filename = filename
44	self.tempdir = tempdir
45
46	def __del__(self, remove = os.remove):
47	remove(self.filename)
48
49	class AutoRemoveDir:
50
51	"""Remove a directory once all references go away
52
53	The intended use of this class together with AutoRemoveFile is for
54	temporary directories and files containd therein. An AutoRemoveDir
55	should be instantiated for the directory and passed as the tempdir
56	parameter to every AutoRemoveFile instance created for files in the
57	directory. An AutoRemoveFile shold be instantiated for every file
58	created in the directory so that the directory is automatically
59	removed once the last file is removed.
60	"""
61
62	def __init__(self, filename):
63	"""Initialize the AutoRemoveDir
64
65	The parameter is the name of the directory.
66	"""
67	self.filename = filename
68
69	def __del__(self, rmdir = os.rmdir):
70	rmdir(self.filename)
71
72
73	# WeakKey dictionary mapping objects like the transient_db to
74	# AutoRemoveDir or AutoRemoveFile instances to make sure that the
75	# temporary files and the directory are deleted but not before the
76	# objects that use them go away.
77	auto_remover = weakref.WeakKeyDictionary()
78
79	class Session(TitledObject, Modifiable):
80
81	"""A complete session.
82
83	A Session consists of arbitrary numbers of maps, tables and extensions
84
85	Session objects send the following events:
86
87	TITLE_CHANGED -- The title has changed. Parameters: the session.
88
89	FILENAME_CHANGED -- The filename has changed. No parameters.
90
91	MAPS_CHANGED -- Maps were added, removed.
92
93	EXTENSIONS_CHANGED -- Extensions were added, removed.
94
95	MAP_LAYERS_CHANGED -- Same as the map's event of the same name.
96	It's simply resent from the session to make
97	subscriptions easier.
98
99	CHANGED -- Generic changed event. Parameters: the session. The
100	event is always issued when any other changed event
101	is issused. This is useful for code that needs to be
102	notified whenever something in the session has
103	changed but it's too cumbersome or error-prone to
104	subscribe to all the individual events.
105	"""
106
107	# message channels that have to be forwarded from maps contained in
108	# the session.
109	forwarded_channels = (
110	# generic channels
111	CHANGED,
112
113	# map specific channels
114	MAP_PROJECTION_CHANGED,
115	MAP_LAYERS_CHANGED,
116
117	# layer channels forwarded by the map
118	LAYER_PROJECTION_CHANGED,
119	LAYER_CHANGED,
120	LAYER_VISIBILITY_CHANGED,
121
122	# channels forwarded by an extension
123	EXTENSION_CHANGED,
124	EXTENSION_OBJECTS_CHANGED)
125
126	def __init__(self, title):
127	TitledObject.__init__(self, title)
128	Modifiable.__init__(self)
129	self.filename = None
130	self.maps = []
131	self.tables = []
132	self.shapestores = []
133	self.extensions = []
134	self.temp_dir = None
135	self.transient_db = None
136
137	def changed(self, channel = None, *args):
138	"""Like the inherited version but issue a CHANGED message as well.
139
140	The CHANGED message is only issued if channel given is a
141	different channel than CHANGED.
142	"""
143	Modifiable.changed(self, channel, *args)
144	if channel != CHANGED:
145	self.issue(CHANGED, self)
146
147	def SetFilename(self, filename):
148	self.filename = filename
149	self.changed(FILENAME_CHANGED)
150
151	def Maps(self):
152	return self.maps
153
154	def HasMaps(self):
155	return len(self.maps) > 0
156
157	def AddMap(self, map):
158	self.maps.append(map)
159	for channel in self.forwarded_channels:
160	map.Subscribe(channel, self.forward, channel)
161	self.changed(MAPS_CHANGED)
162
163	def RemoveMap(self, map):
164	for channel in self.forwarded_channels:
165	map.Unsubscribe(channel, self.forward, channel)
166	self.maps.remove(map)
167	self.changed(MAPS_CHANGED)
168	map.Destroy()
169
170	def Extensions(self):
171	return self.extensions
172
173	def HasExtensions(self):
174	return len(self.extensions) > 0
175
176	def AddExtension(self, extension):
177	self.extensions.append(extension)
178	for channel in self.forwarded_channels:
179	extension.Subscribe(channel, self.forward, channel)
180	self.changed(EXTENSIONS_CHANGED)
181
182	def ShapeStores(self):
183	"""Return a list of all ShapeStore objects open in the session"""
184	return [store() for store in self.shapestores]
185
186	def _add_shapestore(self, store):
187	"""Internal: Add the shapestore to the list of shapestores"""
188	self.shapestores.append(weakref.ref(store,
189	self._clean_weak_store_refs))
190
191	def _clean_weak_store_refs(self, weakref):
192	"""Internal: Remove the weakref from the shapestores list"""
193	self.shapestores = [store for store in self.shapestores
194	if store is not weakref]
195
196	def Tables(self):
197	"""Return a list of all table objects open in the session
198
199	The list includes all tables that are indirectly opened through
200	shape stores and the tables that have been opened explicitly.
201	"""
202	return self.tables + [store.Table() for store in self.ShapeStores()]
203
204	def AddTable(self, table):
205	"""Add the table to the session
206
207	All tables associated with the session that are not implicitly
208	created by the OpenShapefile method (and maybe other Open*
209	methods in the future) have to be passed to this method to make
210	sure the session knows about it. The session keeps a reference
211	to the table. Only tables managed by the session in this way
212	should be used for layers contained in one of the session's
213	maps.
214
215	The table parameter may be any object implementing the table
216	interface. If it's not already one of the transient tables
217	instantiate an AutoTransientTable with it and use that instead
218	of the original table (note that the AutoTransientTable keeps a
219	reference to the original table).
220
221	Return the table object actually used by the session.
222	"""
223	if not hasattr(table, "transient_table"):
224	transient_table = AutoTransientTable(self.TransientDB(), table)
225	else:
226	transient_table = table
227	self.tables.append(transient_table)
228	return transient_table
229
230	def RemoveTable(self, table):
231	"""Remove the table from the session.
232
233	The table object must be a table object previously returned by
234	the AddTable method. If the table is not part of the session
235	raise a ValueError.
236	"""
237	tables = [t for t in self.tables if t is not table]
238	if len(tables) == len(self.tables):
239	raise ValueError
240	self.tables = tables
241
242	def temp_directory(self):
243	"""
244	Return the name of the directory for session specific temporary files
245
246	Create the directory if it doesn't exist yet.
247	"""
248	if self.temp_dir is None:
249	temp_dir = mktemp()
250	os.mkdir(temp_dir, 0700)
251	self.temp_dir = temp_dir
252	self.temp_dir_remover = AutoRemoveDir(self.temp_dir)
253	return self.temp_dir
254
255	def OpenShapefile(self, filename):
256	"""Return a shapefile store object for the data in the given file"""
257	store = ShapefileStore(self, filename)
258	self._add_shapestore(store)
259	return store
260
261	def TransientDB(self):
262	if self.transient_db is None:
263	filename = os.path.join(self.temp_directory(), "transientdb")
264	self.transient_db = TransientDatabase(filename)
265	#print self.temp_dir_remover
266	auto_remover[self.transient_db] = AutoRemoveFile(filename,
267	self.temp_dir_remover)
268	return self.transient_db
269
270	def Destroy(self):
271	for map in self.maps:
272	map.Destroy()
273	self.maps = []
274	self.tables = []
275	Modifiable.Destroy(self)
276
277	# Close the transient DB explicitly so that it removes any
278	# journal files from the temporary directory
279	if self.transient_db is not None:
280	self.transient_db.close()
281
282	def forward(self, *args):
283	"""Reissue events.
284
285	If the channel the event is forwarded to is a changed-channel
286	that is not the CHANGED channel issue CHANGED as well. An
287	channel is considered to be a changed-channel if it's name ends
288	with 'CHANGED'.
289	"""
290	if len(args) > 1:
291	args = (args[-1],) + args[:-1]
292	apply(self.issue, args)
293	channel = args[0]
294	# It's a bit of a kludge to rely on the channel name for this.
295	if channel.endswith("CHANGED") and channel != CHANGED:
296	self.issue(CHANGED, self)
297
298	def WasModified(self):
299	"""Return true if the session or one of the maps was modified"""
300	if self.modified:
301	return 1
302	else:
303	for map in self.maps:
304	if map.WasModified():
305	return 1
306	return 0
307
308	def UnsetModified(self):
309	"""Unset the modified flag of the session and the maps"""
310	Modifiable.UnsetModified(self)
311	for map in self.maps:
312	map.UnsetModified()
313
314	def TreeInfo(self):
315	items = []
316	if self.filename is None:
317	items.append(_("Filename:"))
318	else:
319	items.append(_("Filename: %s") % self.filename)
320
321	if self.WasModified():
322	items.append(_("Modified"))
323	else:
324	items.append(_("Unmodified"))
325
326	items.extend(self.maps)
327	items.extend(self.extensions)
328
329	return (_("Session: %s") % self.title, items)
330
331
332	def create_empty_session():
333	"""Return an empty session useful as a starting point"""
334	import os
335	session = Session(_('unnamed session'))
336	session.SetFilename(None)
337	session.AddMap(Map(_('unnamed map')))
338	session.UnsetModified()
339	return session
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision