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