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
from tempfile import mktemp

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")

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