Thuban/Model/resource.py

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

import os
import os.path

import Thuban
from Thuban import _

from Thuban.Lib.fileutil import get_application_dir

from Thuban.Model.load import XMLReader
from Thuban.Model.save import XMLWriter
from Thuban.Model.proj import Projection, ProjFile
from xml.sax import SAXParseException

projdir = \
        os.path.join(Thuban.__path__[0], os.pardir, "Resources", "Projections")

usrdir  = get_application_dir()

PROJ_EXT = ".proj"

def ReadProjFile(filename):
    """Read a single .proj file and return a ProjFile object.
    
    Raises IOError if the file cannot be opened.
    Raises OSError if the file cannot be read.
    Raises SAXParseException if the file is not valid XML.
    """

    handler = ProjFileReader()
    handler.read(filename)
    return handler.GetProjFile()

def WriteProjFile(pf):
    """Write a single .proj file

    Raises IOError if the file cannot be written.
    """

    saver = ProjFileSaver(pf)
    saver.write(pf.GetFilename())

def GetProjFiles(dir):
    """Read all .proj files in the given directory and 
    return a list of ProjFile objects.
    """

    list = []
    try:
        dirlist = os.listdir(dir)
    except OSError:
        pass # if we can't get a directory listing just return []
    else:
        for file in filter(lambda s: s.endswith(PROJ_EXT), dirlist):
            try:
                filename = os.path.join(dir, file)
                list.append(ReadProjFile(filename))
            except (OSError, IOError, SAXParseException):
                pass # just move onto the next file

    return list

def GetSystemProjFiles():
    """Return a list of ProjFile objects from files that are 
    supplied by Thuban.

    If no files could not be opened return a list with one
    empty projection file set to store data in the default file.
    """
    filename = os.path.join(projdir, "defaults.proj")
    try:
        return [ReadProjFile(filename)]
    except (OSError, IOError, SAXParseException):
        return [ProjFile(filename)]

def GetUserProjFiles():
    """Return a list of ProjFile objects from files that are user-defined.

    If no files could not be opened return a list with one
    empty projection file set to store data in the default file.
    """

    filename = os.path.join(usrdir, "user.proj")
    try:
        return [ReadProjFile(filename)]
    except (OSError, IOError, SAXParseException):
        return [ProjFile(filename)]

class ProjFileReader(XMLReader):

    def __init__(self):
        XMLReader.__init__(self)
        self.__pf = ProjFile("")

        XMLReader.AddDispatchers(self,
            {'projection': ("start_projection", "end_projection"),
             'parameter':  ("start_parameter", None)})
            
    def read(self, file_or_filename):
        XMLReader.read(self, file_or_filename)

        self.__pf.SetFilename(XMLReader.GetFilename(self))
        
    def start_projection(self, name, qname, attrs):
        self.params = []
        self.name = self.encode(attrs.get((None, 'name'), _("Unknown")))

    def end_projection(self, name, qname):
        self.__pf.Add(Projection(self.params, self.name))

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

    def GetProjFile(self):
        return self.__pf


class ProjFileSaver(XMLWriter):

    def __init__(self, pf):
        XMLWriter.__init__(self)
        self.__pf = pf

    def write(self, file_or_filename):
        XMLWriter.write(self, file_or_filename)

        self.write_header("projfile", "projfile.dtd")
        self.write_projfile(self.__pf)
        self.close()

    def write_projfile(self, pf):

        self.open_element("projectionlist")

        for p in pf.GetProjections():
            self.open_element("projection", {"name": p.GetName()})

            for param in p.GetAllParameters():
                self.write_element("parameter", {"value": param})

            self.close_element("projection")

        self.close_element("projectionlist")


1	# Copyright (c) 2003 by Intevation GmbH
2	# Authors:
3	# Jonathan Coles <[email protected]>
4	#
5	# This program is free software under the GPL (>=v2)
6	# Read the file COPYING coming with Thuban for details.
7
8	import os
9	import os.path
10
11	import Thuban
12	from Thuban import _
13
14	from Thuban.Lib.fileutil import get_application_dir
15
16	from Thuban.Model.load import XMLReader
17	from Thuban.Model.save import XMLWriter
18	from Thuban.Model.proj import Projection, ProjFile
19	from xml.sax import SAXParseException
20
21	projdir = \
22	os.path.join(Thuban.__path__[0], os.pardir, "Resources", "Projections")
23
24	usrdir = get_application_dir()
25
26	PROJ_EXT = ".proj"
27
28	def ReadProjFile(filename):
29	"""Read a single .proj file and return a ProjFile object.
30
31	Raises IOError if the file cannot be opened.
32	Raises OSError if the file cannot be read.
33	Raises SAXParseException if the file is not valid XML.
34	"""
35
36	handler = ProjFileReader()
37	handler.read(filename)
38	return handler.GetProjFile()
39
40	def WriteProjFile(pf):
41	"""Write a single .proj file
42
43	Raises IOError if the file cannot be written.
44	"""
45
46	saver = ProjFileSaver(pf)
47	saver.write(pf.GetFilename())
48
49	def GetProjFiles(dir):
50	"""Read all .proj files in the given directory and
51	return a list of ProjFile objects.
52	"""
53
54	list = []
55	try:
56	dirlist = os.listdir(dir)
57	except OSError:
58	pass # if we can't get a directory listing just return []
59	else:
60	for file in filter(lambda s: s.endswith(PROJ_EXT), dirlist):
61	try:
62	filename = os.path.join(dir, file)
63	list.append(ReadProjFile(filename))
64	except (OSError, IOError, SAXParseException):
65	pass # just move onto the next file
66
67	return list
68
69	def GetSystemProjFiles():
70	"""Return a list of ProjFile objects from files that are
71	supplied by Thuban.
72
73	If no files could not be opened return a list with one
74	empty projection file set to store data in the default file.
75	"""
76	filename = os.path.join(projdir, "defaults.proj")
77	try:
78	return [ReadProjFile(filename)]
79	except (OSError, IOError, SAXParseException):
80	return [ProjFile(filename)]
81
82	def GetUserProjFiles():
83	"""Return a list of ProjFile objects from files that are user-defined.
84
85	If no files could not be opened return a list with one
86	empty projection file set to store data in the default file.
87	"""
88
89	filename = os.path.join(usrdir, "user.proj")
90	try:
91	return [ReadProjFile(filename)]
92	except (OSError, IOError, SAXParseException):
93	return [ProjFile(filename)]
94
95	class ProjFileReader(XMLReader):
96
97	def __init__(self):
98	XMLReader.__init__(self)
99	self.__pf = ProjFile("")
100
101	XMLReader.AddDispatchers(self,
102	{'projection': ("start_projection", "end_projection"),
103	'parameter': ("start_parameter", None)})
104
105	def read(self, file_or_filename):
106	XMLReader.read(self, file_or_filename)
107
108	self.__pf.SetFilename(XMLReader.GetFilename(self))
109
110	def start_projection(self, name, qname, attrs):
111	self.params = []
112	self.name = self.encode(attrs.get((None, 'name'), _("Unknown")))
113
114	def end_projection(self, name, qname):
115	self.__pf.Add(Projection(self.params, self.name))
116
117	def start_parameter(self, name, qname, attrs):
118	s = attrs.get((None, 'value'))
119	s = str(s) # we can't handle unicode in proj
120	self.params.append(s)
121
122	def GetProjFile(self):
123	return self.__pf
124
125
126	class ProjFileSaver(XMLWriter):
127
128	def __init__(self, pf):
129	XMLWriter.__init__(self)
130	self.__pf = pf
131
132	def write(self, file_or_filename):
133	XMLWriter.write(self, file_or_filename)
134
135	self.write_header("projfile", "projfile.dtd")
136	self.write_projfile(self.__pf)
137	self.close()
138
139	def write_projfile(self, pf):
140
141	self.open_element("projectionlist")
142
143	for p in pf.GetProjections():
144	self.open_element("projection", {"name": p.GetName()})
145
146	for param in p.GetAllParameters():
147	self.write_element("parameter", {"value": param})
148
149	self.close_element("projection")
150
151	self.close_element("projectionlist")
152
153
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision