Thuban/Model/data.py

# Copyright (C) 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Data source abstractions"""

__version__ = "$Revision$"
# $Source$
# $Id$

import os
import warnings
import weakref

import shapelib
import table
import transientdb

from Thuban import _


class ShapeTable(transientdb.AutoTransientTable):

    """A Table that depends on a ShapefileStore

    Intended use is by the ShapefileStore for the table associated with
    the shapefiles.
    """

    def __init__(self, store, db, table):
        """Initialize the ShapeTable.

        Parameters:
            store -- the ShapefileStore the table is to depend on
            db -- The transient database to use
            table -- the table
        """
        transientdb.AutoTransientTable.__init__(self, db, table)
        self.store = weakref.ref(store)

    def Dependencies(self):
        """Return a tuple containing the shapestore"""
        return (self.store(),)


class ShapefileStore:

    """Combine a shapefile and the corresponding DBF file into one object"""

    def __init__(self, session, filename):
        # Make the filename absolute. The filename will be
        # interpreted relative to that anyway, but when saving a
        # session we need to compare absolute paths and it's usually
        # safer to always work with absolute paths.
        self.filename = os.path.abspath(filename)

        self.shapefile = shapelib.ShapeFile(self.filename)
        self.dbftable = table.DBFTable(filename)
        self.table = ShapeTable(self, session.TransientDB(), self.dbftable)

    def Table(self):
        """Return the table containing the attribute data"""
        return self.table

    def Shapefile(self):
        """Return the shapefile object"""
        return self.shapefile

    def FileName(self):
        """Return the filename used to open the shapefile"""
        return self.filename

    def FileType(self):
        """Return the filetype. This is always the string 'shapefile'"""
        return "shapefile"

    def Dependencies(self):
        """Return the empty tuple.

        The ShapefileStore doesn't depend on anything else.
        """
        return ()

    def OrigShapeStore(self):
        """Return None.

        The ShapefileStore was not derived from another shapestore.
        """
        return None


class DerivedShapeStore:

    """A ShapeStore derived from other shapestores or tables"""

    def __init__(self, shapestore, table):
        """Initialize the derived shapestore.

        The arguments are a shapestore for the shapedata and a table for
        the tabular data.

        Raises ValueError if the number of shapes in the shapestore
        is different from the number of rows in the table.
        """

        numShapes = shapestore.Shapefile().info()[0]
        if numShapes != table.NumRows():
            raise ValueError(_("Table not compatible with shapestore."))

        self.shapestore = shapestore
        self.table = table

    def Table(self):
        """Return the table"""
        return self.table

    def Shapefile(self):
        """Return the shapefile of the underlying shapestore"""
        return self.shapestore.Shapefile()

    def Dependencies(self):
        """Return a tuple containing the shapestore and the table"""
        return (self.shapestore, self.table)

    def OrigShapeStore(self):
        """
        Return the original shapestore the derived store was instantiated with
        """
        return self.shapestore


class SimpleStore:

    """Combine a shapefile and a table object"""

    def __init__(self, shapefile, table):
        warnings.warn("The SimpleStore is deprecated."
                      " Use DerivedShapeStore instead",
                      DeprecationWarning, stacklevel = 2)
        self.shapefile = shapefile
        self.table = table
        self.filename = None

    def Table(self):
        return self.table

    def Shapefile(self):
        return self.shapefile
1	# Copyright (C) 2003 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[email protected]>
4	#
5	# This program is free software under the GPL (>=v2)
6	# Read the file COPYING coming with the software for details.
7
8	"""Data source abstractions"""
9
10	__version__ = "$Revision$"
11	# $Source$
12	# $Id$
13
14	import os
15	import warnings
16	import weakref
17
18	import shapelib
19	import table
20	import transientdb
21
22	from Thuban import _
23
24
25	class ShapeTable(transientdb.AutoTransientTable):
26
27	"""A Table that depends on a ShapefileStore
28
29	Intended use is by the ShapefileStore for the table associated with
30	the shapefiles.
31	"""
32
33	def __init__(self, store, db, table):
34	"""Initialize the ShapeTable.
35
36	Parameters:
37	store -- the ShapefileStore the table is to depend on
38	db -- The transient database to use
39	table -- the table
40	"""
41	transientdb.AutoTransientTable.__init__(self, db, table)
42	self.store = weakref.ref(store)
43
44	def Dependencies(self):
45	"""Return a tuple containing the shapestore"""
46	return (self.store(),)
47
48
49	class ShapefileStore:
50
51	"""Combine a shapefile and the corresponding DBF file into one object"""
52
53	def __init__(self, session, filename):
54	# Make the filename absolute. The filename will be
55	# interpreted relative to that anyway, but when saving a
56	# session we need to compare absolute paths and it's usually
57	# safer to always work with absolute paths.
58	self.filename = os.path.abspath(filename)
59
60	self.shapefile = shapelib.ShapeFile(self.filename)
61	self.dbftable = table.DBFTable(filename)
62	self.table = ShapeTable(self, session.TransientDB(), self.dbftable)
63
64	def Table(self):
65	"""Return the table containing the attribute data"""
66	return self.table
67
68	def Shapefile(self):
69	"""Return the shapefile object"""
70	return self.shapefile
71
72	def FileName(self):
73	"""Return the filename used to open the shapefile"""
74	return self.filename
75
76	def FileType(self):
77	"""Return the filetype. This is always the string 'shapefile'"""
78	return "shapefile"
79
80	def Dependencies(self):
81	"""Return the empty tuple.
82
83	The ShapefileStore doesn't depend on anything else.
84	"""
85	return ()
86
87	def OrigShapeStore(self):
88	"""Return None.
89
90	The ShapefileStore was not derived from another shapestore.
91	"""
92	return None
93
94
95	class DerivedShapeStore:
96
97	"""A ShapeStore derived from other shapestores or tables"""
98
99	def __init__(self, shapestore, table):
100	"""Initialize the derived shapestore.
101
102	The arguments are a shapestore for the shapedata and a table for
103	the tabular data.
104
105	Raises ValueError if the number of shapes in the shapestore
106	is different from the number of rows in the table.
107	"""
108
109	numShapes = shapestore.Shapefile().info()[0]
110	if numShapes != table.NumRows():
111	raise ValueError(_("Table not compatible with shapestore."))
112
113	self.shapestore = shapestore
114	self.table = table
115
116	def Table(self):
117	"""Return the table"""
118	return self.table
119
120	def Shapefile(self):
121	"""Return the shapefile of the underlying shapestore"""
122	return self.shapestore.Shapefile()
123
124	def Dependencies(self):
125	"""Return a tuple containing the shapestore and the table"""
126	return (self.shapestore, self.table)
127
128	def OrigShapeStore(self):
129	"""
130	Return the original shapestore the derived store was instantiated with
131	"""
132	return self.shapestore
133
134
135	class SimpleStore:
136
137	"""Combine a shapefile and a table object"""
138
139	def __init__(self, shapefile, table):
140	warnings.warn("The SimpleStore is deprecated."
141	" Use DerivedShapeStore instead",
142	DeprecationWarning, stacklevel = 2)
143	self.shapefile = shapefile
144	self.table = table
145	self.filename = None
146
147	def Table(self):
148	return self.table
149
150	def Shapefile(self):
151	return self.shapefile
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision