Thuban/Model/load.py

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

"""
Parser for thuban session files.
"""

__version__ = "$Revision$"

import string, os

import xml.sax
import xml.sax.handler
from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException

from Thuban import _

from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
     FIELDTYPE_STRING

from Thuban.Model.color import Color, Transparent

from Thuban.Model.session import Session
from Thuban.Model.map import Map
from Thuban.Model.layer import Layer, RasterLayer
from Thuban.Model.proj import Projection
from Thuban.Model.range import Range
from Thuban.Model.classification import Classification, \
    ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap, \
    ClassGroupProperties
from Thuban.Model.data import DerivedShapeStore, ShapefileStore
from Thuban.Model.table import DBFTable
from Thuban.Model.transientdb import TransientJoinedTable

from Thuban.Model.xmlreader import XMLReader
import resource

import postgisdb

class LoadError(Exception):

    """Exception raised when the thuban file is corrupted

    Not all cases of corrupted thuban files will lead to this exception
    but those that are found by checks in the loading code itself are. 
    """


class LoadCancelled(Exception):

    """Exception raised to indicate that loading was interrupted by the user"""


def parse_color(color):
    """Return the color object for the string color.

    Color may be either 'None' or of the form '#RRGGBB' in the usual
    HTML color notation
    """
    color = string.strip(color)
    if color == "None":
        result = Transparent
    elif color[0] == '#':
        if len(color) == 7:
            r = string.atoi(color[1:3], 16) / 255.0
            g = string.atoi(color[3:5], 16) / 255.0
            b = string.atoi(color[5:7], 16) / 255.0
            result = Color(r, g, b)
        else:
            raise ValueError(_("Invalid hexadecimal color specification %s")
                             % color)
    else:
        raise ValueError(_("Invalid color specification %s") % color)
    return result

class AttrDesc:

    def __init__(self, name, required = False, default = "",
                 conversion = None):
        if not isinstance(name, tuple):
            fullname = (None, name)
        else:
            fullname = name
            name = name[1]
        self.name = name
        self.fullname = fullname
        self.required = required
        self.default = default
        self.conversion = conversion

        # set by the SessionLoader's check_attrs method
        self.value = None


class SessionLoader(XMLReader):

    def __init__(self, db_connection_callback = None):
        """Inititialize the Sax handler."""
        XMLReader.__init__(self)

        self.db_connection_callback = db_connection_callback

        self.theSession = None
        self.aMap = None
        self.aLayer = None

        # Map ids used in the thuban file to the corresponding objects
        # in the session
        self.idmap = {}

        dispatchers = {
            'session'       : ("start_session",        "end_session"),

            'dbconnection': ("start_dbconnection", None),

            'dbshapesource': ("start_dbshapesource", None),
            'fileshapesource': ("start_fileshapesource", None),
            'derivedshapesource': ("start_derivedshapesource", None),
            'filetable': ("start_filetable", None),
            'jointable': ("start_jointable", None),

            'map'           : ("start_map",            "end_map"),
            'projection'    : ("start_projection",     "end_projection"),
            'parameter'     : ("start_parameter",      None),
            'layer'         : ("start_layer",          "end_layer"),
            'rasterlayer'   : ("start_rasterlayer",    "end_rasterlayer"),
            'classification': ("start_classification", "end_classification"),
            'clnull'        : ("start_clnull",         "end_clnull"),
            'clpoint'       : ("start_clpoint",        "end_clpoint"),
            'clrange'       : ("start_clrange",        "end_clrange"),
            'cldata'        : ("start_cldata",         "end_cldata"),
            'table'         : ("start_table",          "end_table"),
            'labellayer'    : ("start_labellayer",     None),
            'label'         : ("start_label",          None)}

        # all dispatchers should be used for the 0.8 and 0.9 namespaces too
        for xmlns in ("http://thuban.intevation.org/dtds/thuban-0.8.dtd",
                      "http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd"):
            for key, value in dispatchers.items():
                dispatchers[(xmlns, key)] = value

        XMLReader.AddDispatchers(self, dispatchers)

    def start_session(self, name, qname, attrs):
        self.theSession = Session(self.encode(attrs.get((None, 'title'),
                                                        None)))

    def end_session(self, name, qname):
        pass

    def check_attrs(self, element, attrs, descr):
        """Check and convert some of the attributes of an element

        Parameters:
           element -- The element name
           attrs -- The attrs mapping as passed to the start_* methods
           descr -- Sequence of attribute descriptions (AttrDesc instances)

        Return a dictionary containig normalized versions of the
        attributes described in descr. The keys of that dictionary are
        the name attributes of the attribute descriptions. The attrs
        dictionary will not be modified.

        If the attribute is required, i.e. the 'required' attribute of
        the descrtiption is true, but it is not in attrs, raise a
        LoadError.

        If the attribute has a default value and it is not present in
        attrs, use that default value as the value in the returned dict.

        If a conversion is specified, convert the value before putting
        it into the returned dict. The following conversions are
        available:

           'filename' -- The attribute is a filename.

                         If the filename is a relative name, interpret
                         it relative to the directory containing the
                         .thuban file and make it an absolute name

           'shapestore' -- The attribute is the ID of a shapestore
                           defined earlier in the .thuban file. Look it
                           up self.idmap

           'table' -- The attribute is the ID of a table or shapestore
                      defined earlier in the .thuban file. Look it up
                      self.idmap. If it's the ID of a shapestore the
                      value will be the table of the shapestore.

           'idref' -- The attribute is the id of an object defined
                      earlier in the .thuban file. Look it up self.idmap

           'ascii' -- The attribute is converted to a bytestring with
                      ascii encoding.
        """
        normalized = {}

        for d in descr:
            if d.required and not attrs.has_key(d.fullname):
                raise LoadError("Element %s requires an attribute %r"
                                % (element, d.name))
            value = attrs.get(d.fullname, d.default)

            if d.conversion in ("idref", "shapesource"):
                if value in self.idmap:
                    value = self.idmap[value]
                else:
                    raise LoadError("Element %s requires an already defined ID"
                                    " in attribute %r"
                                    % (element, d.name))
            elif d.conversion == "table":
                if value in self.idmap:
                    value = self.idmap[value]
                    if isinstance(value, ShapefileStore):
                        value = value.Table()
                else:
                    raise LoadError("Element %s requires an already defined ID"
                                    " in attribute %r"
                                    % (element, d.name))
            elif d.conversion == "filename":
                value = os.path.abspath(os.path.join(self.GetDirectory(),
                                                     value))
            elif d.conversion == "ascii":
                value = value.encode("ascii")
            else:
                if d.conversion:
                    raise ValueError("Unknown attribute conversion %r"
                                     % d.conversion)

            normalized[d.name] = value
        return normalized

    def start_dbconnection(self, name, qname, attrs):
        attrs = self.check_attrs(name, attrs,
                                 [AttrDesc("id", True),
                                  AttrDesc("dbtype", True),
                                  AttrDesc("host", False, ""),
                                  AttrDesc("port", False, ""),
                                  AttrDesc("user", False, ""),
                                  AttrDesc("dbname", True)])
        ID = attrs["id"]
        dbtype = attrs["dbtype"]
        if dbtype != "postgis":
            raise LoadError("dbtype %r not supported" % filetype)

        del attrs["id"]
        del attrs["dbtype"]

        # Try to open the connection and if it fails ask the user for
        # the correct parameters repeatedly.
        # FIXME: it would be better not to insist on getting a
        # connection here. We should handle this more like the raster
        # images where the layers etc still are created but are not
        # drawn in case Thuban can't use the data for various reasons
        while 1:
            try:
                conn = postgisdb.PostGISConnection(**attrs)
                break
            except postgisdb.ConnectionError, val:
                if self.db_connection_callback is not None:
                    attrs = self.db_connection_callback(attrs, str(val))
                    if attrs is None:
                        raise LoadCancelled
                else:
                    raise

        self.idmap[ID] = conn
        self.theSession.AddDBConnection(conn)

    def start_dbshapesource(self, name, qname, attrs):
        attrs = self.check_attrs(name, attrs,
                                 [AttrDesc("id", True),
                                  AttrDesc("dbconn", True,
                                           conversion = "idref"),
                                  AttrDesc("tablename", True,
                                           conversion = "ascii")])
        ID = attrs["id"]
        db = attrs["dbconn"]
        tablename = attrs["tablename"]
        self.idmap[ID] = self.theSession.OpenDBShapeStore(db, tablename)

    def start_fileshapesource(self, name, qname, attrs):
        attrs = self.check_attrs(name, attrs,
                                  [AttrDesc("id", True),
                                   AttrDesc("filename", True,
                                            conversion = "filename"),
                                   AttrDesc("filetype", True)])
        ID = attrs["id"]
        filename = attrs["filename"]
        filetype = attrs["filetype"]
        if filetype != "shapefile":
            raise LoadError("shapesource filetype %r not supported" % filetype)
        self.idmap[ID] = self.theSession.OpenShapefile(filename)

    def start_derivedshapesource(self, name, qname, attrs):
        attrs = self.check_attrs(name, attrs,
                                 [AttrDesc("id", True),
                                  AttrDesc("shapesource", True,
                                           conversion = "shapesource"),
                                  AttrDesc("table", True, conversion="table")])
        store = DerivedShapeStore(attrs["shapesource"], attrs["table"])
        self.theSession.AddShapeStore(store)
        self.idmap[attrs["id"]] = store

    def start_filetable(self, name, qname, attrs):
        attrs = self.check_attrs(name, attrs,
                                 [AttrDesc("id", True),
                                  AttrDesc("title", True),
                                  AttrDesc("filename", True,
                                           conversion = "filename"),
                                  AttrDesc("filetype")])
        filetype = attrs["filetype"]
        if filetype != "DBF":
            raise LoadError("shapesource filetype %r not supported" % filetype)
        table = DBFTable(attrs["filename"])
        table.SetTitle(attrs["title"])
        self.idmap[attrs["id"]] = self.theSession.AddTable(table)

    def start_jointable(self, name, qname, attrs):
        attrs = self.check_attrs(name, attrs,
                                 [AttrDesc("id", True),
                                  AttrDesc("title", True),
                                  AttrDesc("left", True, conversion="table"),
                                  AttrDesc("leftcolumn", True),
                                  AttrDesc("right", True, conversion="table"),
                                  AttrDesc("rightcolumn", True),

                                  # jointype is required for file
                                  # version 0.9 but this attribute
                                  # wasn't in the 0.8 version because of
                                  # an oversight so we assume it's
                                  # optional since we want to handle
                                  # both file format versions here.
                                  AttrDesc("jointype", False,
                                           default="INNER")])

        jointype = attrs["jointype"]
        if jointype == "LEFT OUTER":
            outer_join = True
        elif jointype == "INNER":
            outer_join = False
        else:
            raise LoadError("jointype %r not supported" % jointype )
        table = TransientJoinedTable(self.theSession.TransientDB(),
                                     attrs["left"], attrs["leftcolumn"],
                                     attrs["right"], attrs["rightcolumn"],
                                     outer_join = outer_join)
        table.SetTitle(attrs["title"])
        self.idmap[attrs["id"]] = self.theSession.AddTable(table)

    def start_map(self, name, qname, attrs):
        """Start a map."""
        self.aMap = Map(self.encode(attrs.get((None, 'title'), None)))

    def end_map(self, name, qname):
        self.theSession.AddMap(self.aMap)
        self.aMap = None

    def start_projection(self, name, qname, attrs):
        self.ProjectionName = self.encode(attrs.get((None, 'name'), None))
        self.ProjectionParams = [ ]

    def end_projection(self, name, qname):
        if self.aLayer is not None:
            obj = self.aLayer
        elif self.aMap is not None:
            obj = self.aMap
        else:
            assert False, "projection tag out of context"
            pass

        obj.SetProjection(
            Projection(self.ProjectionParams, self.ProjectionName))

    def start_parameter(self, name, qname, attrs):
        s = attrs.get((None, 'value'))
        s = str(s) # we can't handle unicode in proj
        self.ProjectionParams.append(s)

    def start_layer(self, name, qname, attrs, layer_class = Layer):
        """Start a layer

        Instantiate a layer of class layer_class from the attributes in
        attrs which may be a dictionary as well as the normal SAX attrs
        object and bind it to self.aLayer.
        """
        title = self.encode(attrs.get((None, 'title'), ""))
        filename = attrs.get((None, 'filename'), "")
        filename = os.path.join(self.GetDirectory(), filename)
        filename = self.encode(filename)
        visible  = self.encode(attrs.get((None, 'visible'), "true")) != "false"
        fill = parse_color(attrs.get((None, 'fill'), "None"))
        stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))
        stroke_width = int(attrs.get((None, 'stroke_width'), "1"))
        if attrs.has_key((None, "shapestore")):
            store = self.idmap[attrs[(None, "shapestore")]]
        else:
            store = self.theSession.OpenShapefile(filename)
        self.aLayer = layer_class(title, store,
                                  fill = fill, stroke = stroke,
                                  lineWidth = stroke_width,
                                  visible = visible)

    def end_layer(self, name, qname):
        self.aMap.AddLayer(self.aLayer)
        self.aLayer = None

    def start_rasterlayer(self, name, qname, attrs, layer_class = RasterLayer):
        title = self.encode(attrs.get((None, 'title'), ""))
        filename = attrs.get((None, 'filename'), "")
        filename = os.path.join(self.GetDirectory(), filename)
        filename = self.encode(filename)
        visible  = self.encode(attrs.get((None, 'visible'), "true")) != "false"

        self.aLayer = layer_class(title, filename, visible = visible)

    def end_rasterlayer(self, name, qname):
        self.aMap.AddLayer(self.aLayer)
        self.aLayer = None

    def start_classification(self, name, qname, attrs):
        field = attrs.get((None, 'field'), None)

        fieldType = attrs.get((None, 'field_type'), None)
        dbFieldType = self.aLayer.GetFieldType(field)

        if fieldType != dbFieldType:
            raise ValueError(_("xml field type differs from database!"))

        # setup conversion routines depending on the kind of data
        # we will be seeing later on
        if fieldType == FIELDTYPE_STRING:
            self.conv = str
        elif fieldType == FIELDTYPE_INT:
            self.conv = lambda p: int(float(p))
        elif fieldType == FIELDTYPE_DOUBLE:
            self.conv = float

        self.aLayer.SetClassificationColumn(field)

    def end_classification(self, name, qname): 
        pass

    def start_clnull(self, name, qname, attrs):
        self.cl_group = ClassGroupDefault()
        self.cl_group.SetLabel(self.encode(attrs.get((None, 'label'), "")))
        self.cl_prop = ClassGroupProperties()

    def end_clnull(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)
        del self.cl_group, self.cl_prop

    def start_clpoint(self, name, qname, attrs):
        attrib_value = attrs.get((None, 'value'), "0")

        field = self.aLayer.GetClassificationColumn()
        if self.aLayer.GetFieldType(field) == FIELDTYPE_STRING:
            value = self.encode(attrib_value)
        else:
            value = self.conv(attrib_value)
        self.cl_group = ClassGroupSingleton(value)
        self.cl_group.SetLabel(self.encode(attrs.get((None, 'label'), "")))
        self.cl_prop = ClassGroupProperties()


    def end_clpoint(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().AppendGroup(self.cl_group)
        del self.cl_group, self.cl_prop

    def start_clrange(self, name, qname, attrs):

        range = attrs.get((None, 'range'), None)
        # for backward compatibility (min/max are not saved)
        min   = attrs.get((None, 'min'), None)
        max   = attrs.get((None, 'max'), None)

        try:
            if range is not None:
                self.cl_group = ClassGroupRange(Range(range))
            elif min is not None and max is not None:
                self.cl_group = ClassGroupRange((self.conv(min), 
                                                 self.conv(max)))
            else:
                self.cl_group = ClassGroupRange(Range(None))

        except ValueError:
            raise ValueError(_("Classification range is not a number!"))

        self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
        self.cl_prop = ClassGroupProperties()


    def end_clrange(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().AppendGroup(self.cl_group)
        del self.cl_group, self.cl_prop

    def start_cldata(self, name, qname, attrs):
        self.cl_prop.SetLineColor(
            parse_color(attrs.get((None, 'stroke'), "None")))
        self.cl_prop.SetLineWidth(
            int(attrs.get((None, 'stroke_width'), "0")))
        self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))

    def end_cldata(self, name, qname):
        pass

    def start_labellayer(self, name, qname, attrs):
        self.aLayer = self.aMap.LabelLayer()

    def start_label(self, name, qname, attrs):
        x = float(attrs[(None, 'x')])
        y = float(attrs[(None, 'y')])
        text = self.encode(attrs[(None, 'text')])
        halign = attrs[(None, 'halign')]
        valign = attrs[(None, 'valign')]
        self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)

    def characters(self, chars):
        pass


def load_session(filename, db_connection_callback = None):
    """Load a Thuban session from the file object file

    The db_connection_callback, if given should be a callable object
    that can be called like this:
       db_connection_callback(params, message)

    where params is a dictionary containing the known connection
    parameters and message is a string with a message why the connection
    failed. db_connection_callback should return a new dictionary with
    corrected and perhaps additional parameters like a password or None
    to indicate that the user cancelled.
    """
    handler = SessionLoader(db_connection_callback)
    handler.read(filename)

    session = handler.theSession
    # Newly loaded session aren't modified
    session.UnsetModified()

    return session

1	bh	723	# Copyright (C) 2001, 2002, 2003 by Intevation GmbH
2	bh	6	# Authors:
3			# Jan-Oliver Wagner <[email protected]>
4	bh	267	# Bernhard Herzog <[email protected]>
5	jonathan	413	# Jonathan Coles <[email protected]>
6	bh	6	#
7			# This program is free software under the GPL (>=v2)
8			# Read the file COPYING coming with GRASS for details.
9
10			"""
11			Parser for thuban session files.
12			"""
13
14			__version__ = "$Revision$"
15
16	bh	723	import string, os
17	bh	267
18			import xml.sax
19			import xml.sax.handler
20	jonathan	526	from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException
21	bh	267
22	jan	374	from Thuban import _
23	jonathan	413
24	jonathan	473	from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
25			FIELDTYPE_STRING
26
27	jonathan	1339	from Thuban.Model.color import Color, Transparent
28
29	bh	6	from Thuban.Model.session import Session
30			from Thuban.Model.map import Map
31	jonathan	930	from Thuban.Model.layer import Layer, RasterLayer
32	bh	6	from Thuban.Model.proj import Projection
33	jonathan	874	from Thuban.Model.range import Range
34	jonathan	413	from Thuban.Model.classification import Classification, \
35	jonathan	439	ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap, \
36			ClassGroupProperties
37	bh	1268	from Thuban.Model.data import DerivedShapeStore, ShapefileStore
38			from Thuban.Model.table import DBFTable
39			from Thuban.Model.transientdb import TransientJoinedTable
40	bh	6
41	bh	1646	from Thuban.Model.xmlreader import XMLReader
42			import resource
43
44			import postgisdb
45
46	bh	1268	class LoadError(Exception):
47
48	bh	1646	"""Exception raised when the thuban file is corrupted
49	bh	6
50	bh	1646	Not all cases of corrupted thuban files will lead to this exception
51			but those that are found by checks in the loading code itself are.
52			"""
53
54
55			class LoadCancelled(Exception):
56
57			"""Exception raised to indicate that loading was interrupted by the user"""
58
59
60	bh	267	def parse_color(color):
61			"""Return the color object for the string color.
62	bh	6
63	bh	267	Color may be either 'None' or of the form '#RRGGBB' in the usual
64			HTML color notation
65	bh	6	"""
66			color = string.strip(color)
67			if color == "None":
68	jonathan	1339	result = Transparent
69	bh	6	elif color[0] == '#':
70			if len(color) == 7:
71			r = string.atoi(color[1:3], 16) / 255.0
72			g = string.atoi(color[3:5], 16) / 255.0
73			b = string.atoi(color[5:7], 16) / 255.0
74			result = Color(r, g, b)
75			else:
76	jan	374	raise ValueError(_("Invalid hexadecimal color specification %s")
77	bh	6	% color)
78			else:
79	jan	374	raise ValueError(_("Invalid color specification %s") % color)
80	bh	6	return result
81
82	bh	1268	class AttrDesc:
83
84			def __init__(self, name, required = False, default = "",
85			conversion = None):
86			if not isinstance(name, tuple):
87			fullname = (None, name)
88			else:
89			fullname = name
90			name = name[1]
91			self.name = name
92			self.fullname = fullname
93			self.required = required
94			self.default = default
95			self.conversion = conversion
96
97			# set by the SessionLoader's check_attrs method
98			self.value = None
99
100
101	jonathan	706	class SessionLoader(XMLReader):
102	jonathan	694
103	bh	1646	def __init__(self, db_connection_callback = None):
104	jonathan	694	"""Inititialize the Sax handler."""
105	jonathan	706	XMLReader.__init__(self)
106	jonathan	694
107	bh	1646	self.db_connection_callback = db_connection_callback
108
109	jonathan	694	self.theSession = None
110			self.aMap = None
111			self.aLayer = None
112
113	bh	1268	# Map ids used in the thuban file to the corresponding objects
114			# in the session
115			self.idmap = {}
116	jonathan	706
117	bh	1268	dispatchers = {
118			'session' : ("start_session", "end_session"),
119	bh	1646
120			'dbconnection': ("start_dbconnection", None),
121
122			'dbshapesource': ("start_dbshapesource", None),
123	bh	1268	'fileshapesource': ("start_fileshapesource", None),
124			'derivedshapesource': ("start_derivedshapesource", None),
125			'filetable': ("start_filetable", None),
126			'jointable': ("start_jointable", None),
127
128			'map' : ("start_map", "end_map"),
129			'projection' : ("start_projection", "end_projection"),
130			'parameter' : ("start_parameter", None),
131			'layer' : ("start_layer", "end_layer"),
132			'rasterlayer' : ("start_rasterlayer", "end_rasterlayer"),
133			'classification': ("start_classification", "end_classification"),
134			'clnull' : ("start_clnull", "end_clnull"),
135			'clpoint' : ("start_clpoint", "end_clpoint"),
136			'clrange' : ("start_clrange", "end_clrange"),
137			'cldata' : ("start_cldata", "end_cldata"),
138			'table' : ("start_table", "end_table"),
139			'labellayer' : ("start_labellayer", None),
140			'label' : ("start_label", None)}
141
142	bh	1375	# all dispatchers should be used for the 0.8 and 0.9 namespaces too
143			for xmlns in ("http://thuban.intevation.org/dtds/thuban-0.8.dtd",
144			"http://thuban.intevation.org/dtds/thuban-0.9-dev.dtd"):
145			for key, value in dispatchers.items():
146			dispatchers[(xmlns, key)] = value
147	bh	1268
148			XMLReader.AddDispatchers(self, dispatchers)
149
150	bh	267	def start_session(self, name, qname, attrs):
151	bh	1268	self.theSession = Session(self.encode(attrs.get((None, 'title'),
152			None)))
153	bh	6
154	bh	267	def end_session(self, name, qname):
155			pass
156	bh	6
157	bh	1268	def check_attrs(self, element, attrs, descr):
158			"""Check and convert some of the attributes of an element
159
160			Parameters:
161			element -- The element name
162			attrs -- The attrs mapping as passed to the start_* methods
163			descr -- Sequence of attribute descriptions (AttrDesc instances)
164
165			Return a dictionary containig normalized versions of the
166			attributes described in descr. The keys of that dictionary are
167			the name attributes of the attribute descriptions. The attrs
168			dictionary will not be modified.
169
170			If the attribute is required, i.e. the 'required' attribute of
171			the descrtiption is true, but it is not in attrs, raise a
172			LoadError.
173
174			If the attribute has a default value and it is not present in
175			attrs, use that default value as the value in the returned dict.
176
177			If a conversion is specified, convert the value before putting
178			it into the returned dict. The following conversions are
179			available:
180
181			'filename' -- The attribute is a filename.
182
183			If the filename is a relative name, interpret
184			it relative to the directory containing the
185			.thuban file and make it an absolute name
186
187			'shapestore' -- The attribute is the ID of a shapestore
188			defined earlier in the .thuban file. Look it
189			up self.idmap
190
191			'table' -- The attribute is the ID of a table or shapestore
192			defined earlier in the .thuban file. Look it up
193			self.idmap. If it's the ID of a shapestore the
194			value will be the table of the shapestore.
195	bh	1646
196			'idref' -- The attribute is the id of an object defined
197			earlier in the .thuban file. Look it up self.idmap
198
199			'ascii' -- The attribute is converted to a bytestring with
200			ascii encoding.
201	bh	1268	"""
202			normalized = {}
203
204			for d in descr:
205			if d.required and not attrs.has_key(d.fullname):
206	bh	1642	raise LoadError("Element %s requires an attribute %r"
207			% (element, d.name))
208	bh	1268	value = attrs.get(d.fullname, d.default)
209
210	bh	1646	if d.conversion in ("idref", "shapesource"):
211	bh	1268	if value in self.idmap:
212			value = self.idmap[value]
213			else:
214			raise LoadError("Element %s requires an already defined ID"
215			" in attribute %r"
216			% (element, d.name))
217			elif d.conversion == "table":
218			if value in self.idmap:
219			value = self.idmap[value]
220			if isinstance(value, ShapefileStore):
221			value = value.Table()
222			else:
223			raise LoadError("Element %s requires an already defined ID"
224			" in attribute %r"
225			% (element, d.name))
226			elif d.conversion == "filename":
227			value = os.path.abspath(os.path.join(self.GetDirectory(),
228			value))
229	bh	1646	elif d.conversion == "ascii":
230			value = value.encode("ascii")
231			else:
232			if d.conversion:
233			raise ValueError("Unknown attribute conversion %r"
234			% d.conversion)
235	bh	1268
236			normalized[d.name] = value
237			return normalized
238
239	bh	1646	def start_dbconnection(self, name, qname, attrs):
240			attrs = self.check_attrs(name, attrs,
241			[AttrDesc("id", True),
242			AttrDesc("dbtype", True),
243			AttrDesc("host", False, ""),
244			AttrDesc("port", False, ""),
245			AttrDesc("user", False, ""),
246			AttrDesc("dbname", True)])
247			ID = attrs["id"]
248			dbtype = attrs["dbtype"]
249			if dbtype != "postgis":
250			raise LoadError("dbtype %r not supported" % filetype)
251
252			del attrs["id"]
253			del attrs["dbtype"]
254
255			# Try to open the connection and if it fails ask the user for
256			# the correct parameters repeatedly.
257			# FIXME: it would be better not to insist on getting a
258			# connection here. We should handle this more like the raster
259			# images where the layers etc still are created but are not
260			# drawn in case Thuban can't use the data for various reasons
261			while 1:
262			try:
263			conn = postgisdb.PostGISConnection(**attrs)
264			break
265			except postgisdb.ConnectionError, val:
266			if self.db_connection_callback is not None:
267			attrs = self.db_connection_callback(attrs, str(val))
268			if attrs is None:
269			raise LoadCancelled
270			else:
271			raise
272
273			self.idmap[ID] = conn
274			self.theSession.AddDBConnection(conn)
275
276			def start_dbshapesource(self, name, qname, attrs):
277			attrs = self.check_attrs(name, attrs,
278			[AttrDesc("id", True),
279			AttrDesc("dbconn", True,
280			conversion = "idref"),
281			AttrDesc("tablename", True,
282			conversion = "ascii")])
283			ID = attrs["id"]
284			db = attrs["dbconn"]
285			tablename = attrs["tablename"]
286			self.idmap[ID] = self.theSession.OpenDBShapeStore(db, tablename)
287
288	bh	1268	def start_fileshapesource(self, name, qname, attrs):
289			attrs = self.check_attrs(name, attrs,
290			[AttrDesc("id", True),
291			AttrDesc("filename", True,
292			conversion = "filename"),
293			AttrDesc("filetype", True)])
294			ID = attrs["id"]
295			filename = attrs["filename"]
296			filetype = attrs["filetype"]
297			if filetype != "shapefile":
298			raise LoadError("shapesource filetype %r not supported" % filetype)
299			self.idmap[ID] = self.theSession.OpenShapefile(filename)
300
301			def start_derivedshapesource(self, name, qname, attrs):
302			attrs = self.check_attrs(name, attrs,
303			[AttrDesc("id", True),
304			AttrDesc("shapesource", True,
305			conversion = "shapesource"),
306			AttrDesc("table", True, conversion="table")])
307	bh	1282	store = DerivedShapeStore(attrs["shapesource"], attrs["table"])
308			self.theSession.AddShapeStore(store)
309			self.idmap[attrs["id"]] = store
310	bh	1268
311			def start_filetable(self, name, qname, attrs):
312			attrs = self.check_attrs(name, attrs,
313			[AttrDesc("id", True),
314			AttrDesc("title", True),
315			AttrDesc("filename", True,
316			conversion = "filename"),
317			AttrDesc("filetype")])
318			filetype = attrs["filetype"]
319			if filetype != "DBF":
320			raise LoadError("shapesource filetype %r not supported" % filetype)
321			table = DBFTable(attrs["filename"])
322			table.SetTitle(attrs["title"])
323			self.idmap[attrs["id"]] = self.theSession.AddTable(table)
324
325			def start_jointable(self, name, qname, attrs):
326			attrs = self.check_attrs(name, attrs,
327			[AttrDesc("id", True),
328			AttrDesc("title", True),
329			AttrDesc("left", True, conversion="table"),
330			AttrDesc("leftcolumn", True),
331			AttrDesc("right", True, conversion="table"),
332	bh	1375	AttrDesc("rightcolumn", True),
333
334			# jointype is required for file
335			# version 0.9 but this attribute
336			# wasn't in the 0.8 version because of
337			# an oversight so we assume it's
338			# optional since we want to handle
339			# both file format versions here.
340			AttrDesc("jointype", False,
341			default="INNER")])
342
343			jointype = attrs["jointype"]
344			if jointype == "LEFT OUTER":
345			outer_join = True
346			elif jointype == "INNER":
347			outer_join = False
348			else:
349			raise LoadError("jointype %r not supported" % jointype )
350	bh	1268	table = TransientJoinedTable(self.theSession.TransientDB(),
351			attrs["left"], attrs["leftcolumn"],
352	bh	1375	attrs["right"], attrs["rightcolumn"],
353			outer_join = outer_join)
354	bh	1268	table.SetTitle(attrs["title"])
355			self.idmap[attrs["id"]] = self.theSession.AddTable(table)
356
357	bh	267	def start_map(self, name, qname, attrs):
358			"""Start a map."""
359	frank	1408	self.aMap = Map(self.encode(attrs.get((None, 'title'), None)))
360	bh	267
361			def end_map(self, name, qname):
362			self.theSession.AddMap(self.aMap)
363	jonathan	874	self.aMap = None
364	bh	267
365			def start_projection(self, name, qname, attrs):
366	jonathan	874	self.ProjectionName = self.encode(attrs.get((None, 'name'), None))
367	bh	267	self.ProjectionParams = [ ]
368
369			def end_projection(self, name, qname):
370	jonathan	874	if self.aLayer is not None:
371			obj = self.aLayer
372			elif self.aMap is not None:
373			obj = self.aMap
374			else:
375			assert False, "projection tag out of context"
376			pass
377
378			obj.SetProjection(
379	jonathan	744	Projection(self.ProjectionParams, self.ProjectionName))
380	bh	267
381			def start_parameter(self, name, qname, attrs):
382			s = attrs.get((None, 'value'))
383			s = str(s) # we can't handle unicode in proj
384			self.ProjectionParams.append(s)
385
386			def start_layer(self, name, qname, attrs, layer_class = Layer):
387			"""Start a layer
388
389			Instantiate a layer of class layer_class from the attributes in
390			attrs which may be a dictionary as well as the normal SAX attrs
391			object and bind it to self.aLayer.
392			"""
393	jonathan	874	title = self.encode(attrs.get((None, 'title'), ""))
394	bh	267	filename = attrs.get((None, 'filename'), "")
395	jonathan	694	filename = os.path.join(self.GetDirectory(), filename)
396	jonathan	930	filename = self.encode(filename)
397			visible = self.encode(attrs.get((None, 'visible'), "true")) != "false"
398	bh	267	fill = parse_color(attrs.get((None, 'fill'), "None"))
399			stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))
400			stroke_width = int(attrs.get((None, 'stroke_width'), "1"))
401	bh	1268	if attrs.has_key((None, "shapestore")):
402			store = self.idmap[attrs[(None, "shapestore")]]
403			else:
404			store = self.theSession.OpenShapefile(filename)
405			self.aLayer = layer_class(title, store,
406	bh	723	fill = fill, stroke = stroke,
407	jonathan	772	lineWidth = stroke_width,
408	jonathan	930	visible = visible)
409	bh	267
410			def end_layer(self, name, qname):
411			self.aMap.AddLayer(self.aLayer)
412	jonathan	874	self.aLayer = None
413	bh	267
414	jonathan	930	def start_rasterlayer(self, name, qname, attrs, layer_class = RasterLayer):
415			title = self.encode(attrs.get((None, 'title'), ""))
416			filename = attrs.get((None, 'filename'), "")
417			filename = os.path.join(self.GetDirectory(), filename)
418			filename = self.encode(filename)
419			visible = self.encode(attrs.get((None, 'visible'), "true")) != "false"
420
421			self.aLayer = layer_class(title, filename, visible = visible)
422
423			def end_rasterlayer(self, name, qname):
424			self.aMap.AddLayer(self.aLayer)
425			self.aLayer = None
426
427	jonathan	365	def start_classification(self, name, qname, attrs):
428	jonathan	465	field = attrs.get((None, 'field'), None)
429
430			fieldType = attrs.get((None, 'field_type'), None)
431			dbFieldType = self.aLayer.GetFieldType(field)
432
433			if fieldType != dbFieldType:
434			raise ValueError(_("xml field type differs from database!"))
435
436			# setup conversion routines depending on the kind of data
437			# we will be seeing later on
438			if fieldType == FIELDTYPE_STRING:
439			self.conv = str
440			elif fieldType == FIELDTYPE_INT:
441			self.conv = lambda p: int(float(p))
442			elif fieldType == FIELDTYPE_DOUBLE:
443			self.conv = float
444
445	bh	1452	self.aLayer.SetClassificationColumn(field)
446	jonathan	465
447	jonathan	365	def end_classification(self, name, qname):
448			pass
449
450			def start_clnull(self, name, qname, attrs):
451	jonathan	439	self.cl_group = ClassGroupDefault()
452	jonathan	874	self.cl_group.SetLabel(self.encode(attrs.get((None, 'label'), "")))
453	jonathan	439	self.cl_prop = ClassGroupProperties()
454	jonathan	365
455			def end_clnull(self, name, qname):
456	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
457			self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)
458			del self.cl_group, self.cl_prop
459	jonathan	365
460			def start_clpoint(self, name, qname, attrs):
461			attrib_value = attrs.get((None, 'value'), "0")
462
463	bh	1452	field = self.aLayer.GetClassificationColumn()
464	jonathan	1428	if self.aLayer.GetFieldType(field) == FIELDTYPE_STRING:
465	bh	1417	value = self.encode(attrib_value)
466			else:
467			value = self.conv(attrib_value)
468	jonathan	439	self.cl_group = ClassGroupSingleton(value)
469	jonathan	874	self.cl_group.SetLabel(self.encode(attrs.get((None, 'label'), "")))
470	jonathan	439	self.cl_prop = ClassGroupProperties()
471	jonathan	413
472	jonathan	365
473			def end_clpoint(self, name, qname):
474	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
475	jonathan	614	self.aLayer.GetClassification().AppendGroup(self.cl_group)
476	jonathan	439	del self.cl_group, self.cl_prop
477	jonathan	365
478			def start_clrange(self, name, qname, attrs):
479
480	jonathan	874	range = attrs.get((None, 'range'), None)
481			# for backward compatibility (min/max are not saved)
482			min = attrs.get((None, 'min'), None)
483			max = attrs.get((None, 'max'), None)
484
485	jonathan	365	try:
486	jonathan	874	if range is not None:
487			self.cl_group = ClassGroupRange(Range(range))
488			elif min is not None and max is not None:
489	jonathan	1354	self.cl_group = ClassGroupRange((self.conv(min),
490			self.conv(max)))
491	jonathan	874	else:
492			self.cl_group = ClassGroupRange(Range(None))
493
494	jonathan	365	except ValueError:
495	jan	374	raise ValueError(_("Classification range is not a number!"))
496	jonathan	365
497	jonathan	439	self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
498			self.cl_prop = ClassGroupProperties()
499	jonathan	413
500	jonathan	365
501			def end_clrange(self, name, qname):
502	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
503	jonathan	614	self.aLayer.GetClassification().AppendGroup(self.cl_group)
504	jonathan	439	del self.cl_group, self.cl_prop
505	jonathan	365
506			def start_cldata(self, name, qname, attrs):
507	jonathan	465	self.cl_prop.SetLineColor(
508			parse_color(attrs.get((None, 'stroke'), "None")))
509			self.cl_prop.SetLineWidth(
510	jonathan	390	int(attrs.get((None, 'stroke_width'), "0")))
511	jonathan	439	self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))
512	jonathan	365
513			def end_cldata(self, name, qname):
514			pass
515
516	bh	267	def start_labellayer(self, name, qname, attrs):
517			self.aLayer = self.aMap.LabelLayer()
518
519			def start_label(self, name, qname, attrs):
520			x = float(attrs[(None, 'x')])
521			y = float(attrs[(None, 'y')])
522	jonathan	874	text = self.encode(attrs[(None, 'text')])
523	bh	267	halign = attrs[(None, 'halign')]
524			valign = attrs[(None, 'valign')]
525			self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)
526
527			def characters(self, chars):
528			pass
529
530
531	bh	1646	def load_session(filename, db_connection_callback = None):
532			"""Load a Thuban session from the file object file
533	jonathan	694
534	bh	1646	The db_connection_callback, if given should be a callable object
535			that can be called like this:
536			db_connection_callback(params, message)
537
538			where params is a dictionary containing the known connection
539			parameters and message is a string with a message why the connection
540			failed. db_connection_callback should return a new dictionary with
541			corrected and perhaps additional parameters like a password or None
542			to indicate that the user cancelled.
543			"""
544			handler = SessionLoader(db_connection_callback)
545	jonathan	706	handler.read(filename)
546	jonathan	694
547	bh	6	session = handler.theSession
548			# Newly loaded session aren't modified
549			session.UnsetModified()
550
551			return session
552
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision