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.2"
thuban_release = "0"


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 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	bernhard	2729	thuban_branch = "1.2"
42			thuban_release = "0"
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	dpinte	2700
106			from wx import __version__ as wxPython_version
107	jonathan	1306	versions['wxPython'] = wxPython_version
108	jonathan	1322	versions['wxPython-tuple'] = make_tuple(wxPython_version)
109	jonathan	1306
110			# Python
111			versions['python'] = "%d.%d.%d" % sys.version_info[:3]
112			versions['python-tuple'] = sys.version_info[:3]
113
114			# PySQLite
115	dpinte	2680	try:
116	dpinte	2681	from pysqlite2 import dbapi2 as sqlite
117	dpinte	2680	except ImportError:
118	dpinte	2682	import sqlite
119	dpinte	2687	versions['pysqlite'] = sqlite.version
120			versions['pysqlite-tuple'] = make_tuple(sqlite.version)
121	jonathan	1306
122			# SQLite
123	dpinte	2680	try:
124	dpinte	2682	from pysqlite2._sqlite import sqlite_version
125	dpinte	2687	versions['sqlite'] = sqlite_version
126			versions['sqlite-tuple'] = make_tuple(sqlite_version)
127	dpinte	2680	except ImportError:
128	dpinte	2682	from _sqlite import sqlite_version
129	dpinte	2687	versions['sqlite'] = sqlite_version()
130			versions['sqlite-tuple'] = make_tuple(sqlite_version())
131	jonathan	1306
132			# GDAL
133			from Thuban.Model.resource import has_gdal_support
134			if has_gdal_support():
135			from gdalwarp import get_gdal_version
136			versions['gdal'] = get_gdal_version()
137	jonathan	1322	versions['gdal-tuple'] = make_tuple(get_gdal_version())
138	jonathan	1306
139	bh	2088	from wxproj import get_proj_version, get_gtk_version, get_wx_version
140	jonathan	1306
141			# GTK
142			gtk_ver = get_gtk_version()
143			if gtk_ver:
144			versions['gtk'] = ".".join(map(str, gtk_ver))
145			versions['gtk-tuple'] = gtk_ver
146
147			# PROJ
148			proj_ver = get_proj_version()
149			if proj_ver:
150			versions['proj'] = ".".join(map(str, proj_ver))
151			versions['proj-tuple'] = proj_ver
152
153	bh	2088	wxproj_wx_version = get_wx_version()
154			versions['wxproj-wx'] = ".".join(map(str, wxproj_wx_version))
155			versions['wxproj-wx-tuple'] = wxproj_wx_version
156
157
158	bh	1631	# psycopg/postgis
159			import Thuban.Model.postgisdb
160			if Thuban.Model.postgisdb.has_postgis_support():
161			v = Thuban.Model.postgisdb.psycopg_version()
162			versions['psycopg'] = v
163			versions['psycopg-tuple'] = make_tuple(v)
164
165	jonathan	1306	def verify_versions():
166	bh	2088	"""Verify that Thuban is using the correct versions of libraries.
167	jonathan	1306
168			Returns a non-empty list of strings indicating which libraries
169			are wrong, or the empty list if everthing is ok.
170			"""
171
172			#
173			# The 'name' below must correspong to an mapping in 'versions'.
174			# There must also exist a 'name'-tuple mapping.
175			#
176			# title name version
177			list = [["Python", "python", (2, 2, 1)],
178	jonathan	1322	["wxPython", "wxPython", (2, 4, 0)],
179	jonathan	1319	["SQLite", "sqlite", (2, 8, 0)],
180			["PySQLite", "pysqlite", (0, 4, 1)],
181	jonathan	1306	["PROJ", "proj", (4, 4, 5)],
182			["GTK", "gtk", (1, 2, 3)],
183	jonathan	1322	["GDAL", "gdal", (1, 1, 8)]]
184	jonathan	1306
185			errors = []
186			for title, name, version in list:
187			tup = versions.get("%s-tuple" % name, None)
188			if tup and tup < version:
189			errors.append(_("%s %s < %s") % \
190	bh	2088	(title, versions[name], ".".join(map(str, version))))
191	jonathan	1306
192	bh	2088	# Check whether the wxWindows version of wxPython and thuban's
193			# wxproj module match. If they don't match, segfaults are likely.
194			if versions["wxproj-wx-tuple"] != versions["wxPython-tuple"][:3]:
195			errors.append(_("Thuban was compiled with wx %(wxproj-wx)s"
196			" but wxPython is %(wxPython)s")
197			% versions)
198
199	jonathan	1306	return errors
200	bh	2088
201	frank	922	if __name__ == "__main__":
202			print longversion
203	jonathan	1306
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision