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, \
     TABLE_REMOVED

from Thuban import _

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

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 UnreferencedTables(self):
        """Return the tables that are not referenced by other data sources"""
        known = {}
        for table in self.tables:
            known[id(table)] = 0
        for table in self.tables + self.ShapeStores():
            for dep in table.Dependencies():
                known[id(dep)] = 1
        return [table for table in self.tables if known[id(table)] == 0]

    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)
        self.changed()
        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.

        Issue a TABLE_REMOVED message after the table has been removed.
        The message has the removed table as the single parameter.
        """
        tables = [t for t in self.tables if t is not table]
        if len(tables) == len(self.tables):
            raise ValueError
        self.tables = tables
        self.changed(TABLE_REMOVED, table)

    def OpenTableFile(self, filename):
        """Open the table file filename and return the table object.

        The filename argument must be the name of a DBF file.
        """
        return self.AddTable(DBFTable(filename))

    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 AddShapeStore(self, shapestore):
        """Add the shapestore to the session.

        The session only holds a weak reference to the shapestore, so it
        will automatically be removed from the session when the last
        reference goes away.
        """
        self._add_shapestore(shapestore)
        return shapestore

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