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 Thuban
from Thuban import _

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  = os.path.expanduser("~/.thuban")

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