WIP-pyshapelib-bramz/Thuban/version.py

# Copyright (C) 2002, 2003, 2004 by Intevation GmbH
# Authors:
# Thomas Koester <[email protected]>
# Frank Koormann <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""
Thuban version information
"""

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


# Note that this file defines the version number of Thuban for the about
# dialog.

# The thuban version string is build from two values, thuban_branch and
# thuban_release.  If release is "cvs" the code is from a non-released
# cvs version and the version string is built from the branch, the
# release and an approximation of the date (e.g. the most recent date of
# the ChangeLog file or the most recent modification time of a source
# file).  Otherwise the string is build from the branch and the release.
# E.g. given
#
#  thuban_branch = "1.1"
#  thuban_release = "svn"
#
# the version string will be "Thuban 1.1 svn-20040224" (obviously the
# actual date might differ :) ).  OTOH, given
#
#  thuban_branch = "1.0"
#  thuban_release = "1"
#
# the version string will be "Thuban 1.0.1"
#

thuban_branch = "1.1"
thuban_release = "svn"


import sys, os, os.path
import time
from string import split

from Thuban import  _
from Thuban.Lib.version import make_tuple

if __name__ == "__main__":
    import sys
    __file__ = sys.argv[0]

def is_relevant_file(file):
    """check if a file is relevant for determining the current version"""
    extensions = ['.py', '.xpm', '.c', '.h']
    return os.path.isfile(file) and os.path.splitext(file)[1] in extensions

def visit(args, dirname, names):
    """helper for os.path.walk; save mtime of newest file for this directory"""
    files = filter(is_relevant_file,
                   [os.path.join(dirname, file) for file in names])
    args['max'] = max([args['max']] + map(os.path.getmtime, files))

def get_date(format):
    """strftime formatted mtime of the newest relevant file"""
    dir = os.path.dirname(os.path.abspath(__file__))
    args = {'max': 0}
    os.path.walk(dir, visit, args)
    return time.strftime(format, time.localtime(args['max']))

def get_changelog_date():
    changelog = os.path.join(os.path.dirname(__file__), os.pardir, "ChangeLog")
    try:
        file = open(changelog, "r")
        line = file.readline()
        file.close() 
    except:
        return ""
    return 'ChangeLog %s' % line.split(" ")[0]


# 
# Fill in versions with the different versions of the libraries
# that Thuban is using or requires (only if those libraries are
# available.
#

versions = {}

if thuban_release == "svn":
    version = '%s %s-%s' % (thuban_branch, thuban_release, get_date('%Y%m%d'))
    longversion = '%s\n%s' % (version, get_changelog_date())
else:
    version = thuban_branch + "." + thuban_release
    longversion = 'Release Version ' + version

versions['thuban'] = version
versions['thuban-long'] = longversion

# wxPython
from wxPython.wx import __version__ as wxPython_version
versions['wxPython'] = wxPython_version
versions['wxPython-tuple'] = make_tuple(wxPython_version)

# Python
versions['python'] = "%d.%d.%d" % sys.version_info[:3]
versions['python-tuple'] = sys.version_info[:3]

# PySQLite
try:
    from pysqlite2 import dbapi2 as sqlite
except ImportError:
    import sqlite
versions['pysqlite'] = sqlite.version
versions['pysqlite-tuple'] = make_tuple(sqlite.version)

# SQLite
try:
    from pysqlite2._sqlite import sqlite_version
    versions['sqlite'] = sqlite_version
    versions['sqlite-tuple'] = make_tuple(sqlite_version)
except ImportError:
    from _sqlite import sqlite_version
    versions['sqlite'] = sqlite_version()
    versions['sqlite-tuple'] = make_tuple(sqlite_version())

# GDAL
from  Thuban.Model.resource import has_gdal_support
if has_gdal_support():
    from gdalwarp import get_gdal_version
    versions['gdal'] = get_gdal_version()
    versions['gdal-tuple'] = make_tuple(get_gdal_version())

from wxproj import get_proj_version, get_gtk_version, get_wx_version

# GTK
gtk_ver = get_gtk_version()
if gtk_ver:
    versions['gtk'] = ".".join(map(str, gtk_ver))
    versions['gtk-tuple'] = gtk_ver

# PROJ
proj_ver = get_proj_version()
if proj_ver:
    versions['proj'] = ".".join(map(str, proj_ver))
    versions['proj-tuple'] = proj_ver

wxproj_wx_version = get_wx_version()
versions['wxproj-wx'] = ".".join(map(str, wxproj_wx_version))
versions['wxproj-wx-tuple'] = wxproj_wx_version


# psycopg/postgis
import Thuban.Model.postgisdb
if Thuban.Model.postgisdb.has_postgis_support():
    v = Thuban.Model.postgisdb.psycopg_version()
    versions['psycopg'] = v
    versions['psycopg-tuple'] = make_tuple(v)

def verify_versions():
    """Verify that Thuban is using the correct versions of libraries.

    Returns a non-empty list of strings indicating which libraries
    are wrong, or the empty list if everthing is ok.
    """

    #
    # The 'name' below must correspong to an mapping in 'versions'.
    # There must also exist a 'name'-tuple mapping.
    #
    #         title           name       version
    list = [["Python",      "python",   (2, 2, 1)],
            ["wxPython",    "wxPython", (2, 4, 0)],
            ["SQLite",      "sqlite",   (2, 8, 0)],
            ["PySQLite",    "pysqlite", (0, 4, 1)],
            ["PROJ",        "proj",     (4, 4, 5)],
            ["GTK",         "gtk",      (1, 2, 3)],
            ["GDAL",        "gdal",     (1, 1, 8)]]

    errors = []
    for title, name, version in list:
        tup = versions.get("%s-tuple" % name, None)
        if tup and tup < version:
            errors.append(_("%s %s < %s") % \
                          (title, versions[name], ".".join(map(str, version))))

    # Check whether the wxWindows version of wxPython and thuban's
    # wxproj module match.  If they don't match, segfaults are likely.
    if versions["wxproj-wx-tuple"] != versions["wxPython-tuple"][:3]:
        errors.append(_("Thuban was compiled with wx %(wxproj-wx)s"
                        " but wxPython is %(wxPython)s")
                      % versions)

    return errors

if __name__ == "__main__":
    print longversion

1	bh	2088	# Copyright (C) 2002, 2003, 2004 by Intevation GmbH
2	frank	922	# Authors:
3			# Thomas Koester <[email protected]>
4			# Frank Koormann <[email protected]>
5			#
6			# This program is free software under the GPL (>=v2)
7			# Read the file COPYING coming with the software for details.
8
9			"""
10			Thuban version information
11			"""
12
13			__version__ = "$Revision$"
14			# $Source$
15			# $Id$
16
17
18	bh	2088	# Note that this file defines the version number of Thuban for the about
19			# dialog.
20	frank	922
21	bh	2088	# The thuban version string is build from two values, thuban_branch and
22			# thuban_release. If release is "cvs" the code is from a non-released
23			# cvs version and the version string is built from the branch, the
24			# release and an approximation of the date (e.g. the most recent date of
25			# the ChangeLog file or the most recent modification time of a source
26			# file). Otherwise the string is build from the branch and the release.
27			# E.g. given
28			#
29			# thuban_branch = "1.1"
30	bernhard	2677	# thuban_release = "svn"
31	bh	2088	#
32	bernhard	2677	# the version string will be "Thuban 1.1 svn-20040224" (obviously the
33	bh	2088	# actual date might differ :) ). OTOH, given
34			#
35			# thuban_branch = "1.0"
36			# thuban_release = "1"
37			#
38			# the version string will be "Thuban 1.0.1"
39			#
40	frank	922
41	bh	2088	thuban_branch = "1.1"
42	bernhard	2677	thuban_release = "svn"
43	bh	2088
44
45
46	jonathan	1306	import sys, os, os.path
47	frank	922	import time
48	jonathan	1306	from string import split
49	frank	922
50	jonathan	1306	from Thuban import _
51	bh	2011	from Thuban.Lib.version import make_tuple
52	jonathan	1306
53	frank	922	if __name__ == "__main__":
54			import sys
55			__file__ = sys.argv[0]
56
57			def is_relevant_file(file):
58			"""check if a file is relevant for determining the current version"""
59			extensions = ['.py', '.xpm', '.c', '.h']
60			return os.path.isfile(file) and os.path.splitext(file)[1] in extensions
61
62			def visit(args, dirname, names):
63			"""helper for os.path.walk; save mtime of newest file for this directory"""
64			files = filter(is_relevant_file,
65			[os.path.join(dirname, file) for file in names])
66			args['max'] = max([args['max']] + map(os.path.getmtime, files))
67
68			def get_date(format):
69			"""strftime formatted mtime of the newest relevant file"""
70			dir = os.path.dirname(os.path.abspath(__file__))
71			args = {'max': 0}
72			os.path.walk(dir, visit, args)
73			return time.strftime(format, time.localtime(args['max']))
74
75			def get_changelog_date():
76			changelog = os.path.join(os.path.dirname(__file__), os.pardir, "ChangeLog")
77	frank	925	try:
78			file = open(changelog, "r")
79			line = file.readline()
80			file.close()
81			except:
82			return ""
83	jonathan	1306	return 'ChangeLog %s' % line.split(" ")[0]
84	frank	922
85	jonathan	1306
86			#
87			# Fill in versions with the different versions of the libraries
88			# that Thuban is using or requires (only if those libraries are
89			# available.
90			#
91
92			versions = {}
93
94	bernhard	2677	if thuban_release == "svn":
95	bh	2088	version = '%s %s-%s' % (thuban_branch, thuban_release, get_date('%Y%m%d'))
96			longversion = '%s\n%s' % (version, get_changelog_date())
97			else:
98			version = thuban_branch + "." + thuban_release
99			longversion = 'Release Version ' + version
100
101	jonathan	1306	versions['thuban'] = version
102			versions['thuban-long'] = longversion
103
104			# wxPython
105			from wxPython.wx import __version__ as wxPython_version
106			versions['wxPython'] = wxPython_version
107	jonathan	1322	versions['wxPython-tuple'] = make_tuple(wxPython_version)
108	jonathan	1306
109			# Python
110			versions['python'] = "%d.%d.%d" % sys.version_info[:3]
111			versions['python-tuple'] = sys.version_info[:3]
112
113			# PySQLite
114	dpinte	2680	try:
115	dpinte	2681	from pysqlite2 import dbapi2 as sqlite
116	dpinte	2680	except ImportError:
117	dpinte	2682	import sqlite
118	dpinte	2687	versions['pysqlite'] = sqlite.version
119			versions['pysqlite-tuple'] = make_tuple(sqlite.version)
120	jonathan	1306
121			# SQLite
122	dpinte	2680	try:
123	dpinte	2682	from pysqlite2._sqlite import sqlite_version
124	dpinte	2687	versions['sqlite'] = sqlite_version
125			versions['sqlite-tuple'] = make_tuple(sqlite_version)
126	dpinte	2680	except ImportError:
127	dpinte	2682	from _sqlite import sqlite_version
128	dpinte	2687	versions['sqlite'] = sqlite_version()
129			versions['sqlite-tuple'] = make_tuple(sqlite_version())
130	jonathan	1306
131			# GDAL
132			from Thuban.Model.resource import has_gdal_support
133			if has_gdal_support():
134			from gdalwarp import get_gdal_version
135			versions['gdal'] = get_gdal_version()
136	jonathan	1322	versions['gdal-tuple'] = make_tuple(get_gdal_version())
137	jonathan	1306
138	bh	2088	from wxproj import get_proj_version, get_gtk_version, get_wx_version
139	jonathan	1306
140			# GTK
141			gtk_ver = get_gtk_version()
142			if gtk_ver:
143			versions['gtk'] = ".".join(map(str, gtk_ver))
144			versions['gtk-tuple'] = gtk_ver
145
146			# PROJ
147			proj_ver = get_proj_version()
148			if proj_ver:
149			versions['proj'] = ".".join(map(str, proj_ver))
150			versions['proj-tuple'] = proj_ver
151
152	bh	2088	wxproj_wx_version = get_wx_version()
153			versions['wxproj-wx'] = ".".join(map(str, wxproj_wx_version))
154			versions['wxproj-wx-tuple'] = wxproj_wx_version
155
156
157	bh	1631	# psycopg/postgis
158			import Thuban.Model.postgisdb
159			if Thuban.Model.postgisdb.has_postgis_support():
160			v = Thuban.Model.postgisdb.psycopg_version()
161			versions['psycopg'] = v
162			versions['psycopg-tuple'] = make_tuple(v)
163
164	jonathan	1306	def verify_versions():
165	bh	2088	"""Verify that Thuban is using the correct versions of libraries.
166	jonathan	1306
167			Returns a non-empty list of strings indicating which libraries
168			are wrong, or the empty list if everthing is ok.
169			"""
170
171			#
172			# The 'name' below must correspong to an mapping in 'versions'.
173			# There must also exist a 'name'-tuple mapping.
174			#
175			# title name version
176			list = [["Python", "python", (2, 2, 1)],
177	jonathan	1322	["wxPython", "wxPython", (2, 4, 0)],
178	jonathan	1319	["SQLite", "sqlite", (2, 8, 0)],
179			["PySQLite", "pysqlite", (0, 4, 1)],
180	jonathan	1306	["PROJ", "proj", (4, 4, 5)],
181			["GTK", "gtk", (1, 2, 3)],
182	jonathan	1322	["GDAL", "gdal", (1, 1, 8)]]
183	jonathan	1306
184			errors = []
185			for title, name, version in list:
186			tup = versions.get("%s-tuple" % name, None)
187			if tup and tup < version:
188			errors.append(_("%s %s < %s") % \
189	bh	2088	(title, versions[name], ".".join(map(str, version))))
190	jonathan	1306
191	bh	2088	# Check whether the wxWindows version of wxPython and thuban's
192			# wxproj module match. If they don't match, segfaults are likely.
193			if versions["wxproj-wx-tuple"] != versions["wxPython-tuple"][:3]:
194			errors.append(_("Thuban was compiled with wx %(wxproj-wx)s"
195			" but wxPython is %(wxPython)s")
196			% versions)
197
198	jonathan	1306	return errors
199	bh	2088
200	frank	922	if __name__ == "__main__":
201			print longversion
202	jonathan	1306
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision