def test_get_pkginfo_non_toplevel(self): from trac import core import tracopt pkginfo = util.get_pkginfo(trac) self.assertEqual(pkginfo, util.get_pkginfo(util)) self.assertEqual(pkginfo, util.get_pkginfo(core)) self.assertEqual(pkginfo, util.get_pkginfo(tracopt))
def test_file_metadata(self): pkgname = 'TestModule_' + util.hex_entropy(16) modname = pkgname.lower() with open(os.path.join(self.dir, pkgname + '-0.1.egg-info'), 'w') as f: f.write('Metadata-Version: 1.1\n' 'Name: %(pkgname)s\n' 'Version: 0.1\n' 'Author: Joe\n' 'Author-email: [email protected]\n' 'Home-page: http://example.org/\n' 'Summary: summary.\n' 'Description: description.\n' 'Provides: %(modname)s\n' 'Provides: %(modname)s.foo\n' % { 'pkgname': pkgname, 'modname': modname }) os.mkdir(os.path.join(self.dir, modname)) for name in ('__init__.py', 'bar.py', 'foo.py'): with open(os.path.join(self.dir, modname, name), 'w') as f: f.write('# -*- coding: utf-8 -*-\n') mod = __import__(modname, {}, {}, ['bar', 'foo']) pkginfo = util.get_pkginfo(mod) self.assertEqual('0.1', pkginfo['version']) self.assertEqual('Joe', pkginfo['author']) self.assertEqual('*****@*****.**', pkginfo['author_email']) self.assertEqual('http://example.org/', pkginfo['home_page']) self.assertEqual('summary.', pkginfo['summary']) self.assertEqual('description.', pkginfo['description']) self.assertEqual(pkginfo, util.get_pkginfo(mod.bar)) self.assertEqual(pkginfo, util.get_pkginfo(mod.foo))
def test_get_pkginfo_babel(self): try: import babel import babel.core dist = pkg_resources.get_distribution('Babel') except: pass else: pkginfo = util.get_pkginfo(babel) self.assertNotEqual({}, pkginfo) self.assertEqual(pkginfo, util.get_pkginfo(babel.core))
def test_get_pkginfo_pymysql(self): try: import pymysql dist = pkg_resources.get_distribution('pymysql') dist.get_metadata('top_level.txt') except: pass else: pkginfo = util.get_pkginfo(pymysql) self.assertNotEqual({}, pkginfo) self.assertEqual(pkginfo, util.get_pkginfo(pymysql.cursors))
def test_get_pkginfo_genshi(self): try: import genshi import genshi.core dist = pkg_resources.get_distribution('Genshi') except: pass else: pkginfo = util.get_pkginfo(genshi) self.assertNotEqual({}, pkginfo) self.assertEqual(pkginfo, util.get_pkginfo(genshi.core))
def test_get_pkginfo_psycopg2(self): # python-psycopg2 deb package doesn't provide SOURCES.txt and # top_level.txt try: import psycopg2 import psycopg2.extensions dist = pkg_resources.get_distribution('psycopg2') except: pass else: pkginfo = util.get_pkginfo(psycopg2) self.assertNotEqual({}, pkginfo) self.assertEqual(pkginfo, util.get_pkginfo(psycopg2.extensions))
def test_get_pkginfo_mysqldb(self): # MySQLdb's package name is "MySQL-Python" try: import MySQLdb import MySQLdb.cursors dist = pkg_resources.get_distribution('MySQL-Python') dist.get_metadata('top_level.txt') except: pass else: pkginfo = util.get_pkginfo(MySQLdb) self.assertNotEqual({}, pkginfo) self.assertEqual(pkginfo, util.get_pkginfo(MySQLdb.cursors))
def get_system_info(self): """Yield a sequence of `(name, version)` tuples describing the name and version information of external packages used by a component. """ import gdata from trac.util import get_pkginfo yield 'Google Data', get_pkginfo(gdata)['version']
def trac_version(self): """Returns the version of Trac. :since: 1.2 """ from trac import core, __version__ return get_pkginfo(core).get("version", __version__)
def functionalSuite(suite=None): if not suite: import trac.tests.functional suite = trac.tests.functional.functionalSuite() suite.addTest(TestWiki()) suite.addTest(TestWikiDelete()) suite.addTest(TestWikiAddAttachment()) suite.addTest(TestWikiPageManipulator()) suite.addTest(TestWikiHistory()) suite.addTest(TestWikiReadonlyAttribute()) suite.addTest(TestWikiRename()) suite.addTest(RegressionTestTicket4812()) suite.addTest(RegressionTestTicket8976()) suite.addTest(RegressionTestTicket10274()) suite.addTest(RegressionTestTicket10850()) suite.addTest(RegressionTestTicket10957()) suite.addTest(RegressionTestTicket11302()) suite.addTest(RegressionTestTicket11518()) if has_docutils: import docutils if get_pkginfo(docutils): suite.addTest(ReStructuredTextWikiTest()) suite.addTest(ReStructuredTextCodeBlockTest()) else: print("SKIP: reST wiki tests (docutils has no setuptools" " metadata)") else: print("SKIP: reST wiki tests (no docutils)") return suite
def __init__(self): self._version = have_pysqlite and \ get_pkginfo(sqlite).get('version', '%d.%d.%s' % sqlite.version_info) self.error = None self._extensions = None
def functionalSuite(suite=None): if not suite: import trac.tests.functional suite = trac.tests.functional.functionalSuite() suite.addTest(TestWiki()) suite.addTest(TestWikiAddAttachment()) suite.addTest(TestWikiPageManipulator()) suite.addTest(TestWikiHistory()) suite.addTest(TestWikiRename()) suite.addTest(RegressionTestTicket4812()) suite.addTest(RegressionTestTicket10274()) suite.addTest(RegressionTestTicket10850()) suite.addTest(RegressionTestTicket10957()) suite.addTest(RegressionTestTicket11302()) suite.addTest(RegressionTestTicket11518()) if has_docutils: import docutils if get_pkginfo(docutils): suite.addTest(ReStructuredTextWikiTest()) suite.addTest(ReStructuredTextCodeBlockTest()) else: print "SKIP: reST wiki tests (docutils has no setuptools metadata)" else: print "SKIP: reST wiki tests (no docutils)" if ConfigObj: suite.addTest(RegressionTestTicket8976()) else: print "SKIP: RegressionTestTicket8976 (ConfigObj not installed)" return suite
def __init__(self): version = get_pkginfo(pygments).get('version') # if installed from source, fallback to the hardcoded version info if not version and hasattr(pygments, '__version__'): version = pygments.__version__ self.env.systeminfo.append(('Pygments',version)) self._types = None
def __init__(self): self._mssql_version = None self._mssql_version = has_mssql and \ get_pkginfo(pymssql).get('version', pymssql.__version__) if self._mssql_version: self.required = True self.error = None
def get_system_info(self): from trac import core, __version__ as VERSION yield 'Trac', get_pkginfo(core).get('version', VERSION) yield 'Python', sys.version yield 'setuptools', setuptools.__version__ from trac.util.datefmt import pytz if pytz is not None: yield 'pytz', pytz.__version__
def get_system_info(self): # Move implementation to httpbl, ip_blacklist and url_blacklist # when support for Trac < 1.2 is dropped (#12294). try: import dns except ImportError: pass else: yield 'dnspython', get_pkginfo(dns)['version']
def get_system_info(self): import genshi info = get_pkginfo(genshi).get('version') if hasattr(genshi, '_speedups'): info += ' (with speedups)' else: info += ' (without speedups)' yield 'Genshi', info try: import babel except ImportError: babel = None if babel is not None: info = get_pkginfo(babel).get('version') if not get_available_locales(): info += " (translations unavailable)" # No i18n on purpose self.log.warning("Locale data is missing") yield 'Babel', info
def get_connection(self, path, log=None, user=None, password=None, host=None, port=None, params={}): cnx = PostgreSQLConnection(path, log, user, password, host, port, params) if not self._version: self._version = get_pkginfo(psycopg).get('version', psycopg.__version__) self.env.systeminfo.append(('psycopg2', self._version)) self.required = True return cnx
def __init__(self): self.log.debug("SilverCity installed? %r", have_silvercity) if have_silvercity: self.env.systeminfo.append(('SilverCity', get_pkginfo(SilverCity).get('version', '?'))) # TODO: the above works only if setuptools was used to build # SilverCity, which is not yet the case by default for 0.9.7. # I've not been able to find an alternative way to get version. self._types = None
def get_connection(self, path, log=None, user=None, password=None, host=None, port=None, params={}): cnx = PostgreSQLConnection(path, log, user, password, host, port, params) if not self._version: if has_psycopg: self._version = get_pkginfo(psycopg).get('version', psycopg.__version__) name = 'psycopg2' elif has_pgsql: import pyPgSQL self._version = get_pkginfo(pyPgSQL).get('version', pyPgSQL.__version__) name = 'pyPgSQL' else: name = 'unknown postgreSQL driver' self._version = '?' self.env.systeminfo.append((name, self._version)) return cnx
def get_connection(self, path, log=None, user=None, password=None, host=None, port=None, params={}): cnx = MySQLConnection(path, log, user, password, host, port, params) if not self._version: self._version = get_pkginfo(MySQLdb).get("version", MySQLdb.__version__) mysql_info = 'server: "%s", client: "%s", thread-safe: %s' % ( cnx.cnx.get_server_info(), MySQLdb.get_client_info(), MySQLdb.thread_safe(), ) self.env.systeminfo.extend([("MySQL", mysql_info), ("MySQLdb", self._version)]) self.required = True return cnx
def get_connection(self, path, log=None, params={}): if not self._version: self._version = get_pkginfo(sqlite).get( 'version', '%d.%d.%s' % sqlite.version_info) self.env.systeminfo.extend([('SQLite', sqlite_version_string), ('pysqlite', self._version)]) if have_pysqlite == 1: self.log.warning("Support for SQLite v2 and PySqlite 1.0.x " "will be dropped in version 0.12, see " "http://trac.edgewall.org/wiki/" "PySqlite#UpgradingSQLitefrom2.xto3.x") return SQLiteConnection(path, log, params)
def get_connection(self, path, log=None, user=None, password=None, host=None, port=None, params={}): cnx = MySQLConnection(path, log, user, password, host, port, params) if not self._version: self._version = get_pkginfo(MySQLdb).get('version', MySQLdb.__version__) mysql_info = 'server: "%s", client: "%s", thread-safe: %s' % \ (cnx.cnx.get_server_info(), MySQLdb.get_client_info(), MySQLdb.thread_safe()) self.env.systeminfo.extend([('MySQL', mysql_info), ('MySQLdb', self._version)]) self.required = True return cnx
def get_connection(self, path, log=None, params={}): if not self._version: self._version = get_pkginfo(sqlite).get( 'version', '%d.%d.%s' % sqlite.version_info) self.env.systeminfo.extend([('SQLite', sqlite_version_string), ('pysqlite', self._version)]) self.required = True # construct list of sqlite extension libraries if self._extensions is None: self._extensions = [] for extpath in self.extensions: if not os.path.isabs(extpath): extpath = os.path.join(self.env.path, extpath) self._extensions.append(extpath) params['extensions'] = self._extensions return SQLiteConnection(path, log, params)
def functionalSuite(suite=None): if not suite: import trac.tests.functional.testcases suite = trac.tests.functional.testcases.functionalSuite() suite.addTest(TestWiki()) suite.addTest(RegressionTestTicket4812()) if has_docutils: import docutils if get_pkginfo(docutils): suite.addTest(ReStructuredTextWikiTest()) suite.addTest(ReStructuredTextCodeBlockTest()) else: print "SKIP: reST wiki tests (docutils has no setuptools metadata)" else: print "SKIP: reST wiki tests (no docutils)" return suite
def functionalSuite(suite=None): if not suite: import trac.tests.functional.testcases suite = trac.tests.functional.testcases.functionalSuite() suite.addTest(TestWiki()) suite.addTest(TestWikiRename()) suite.addTest(RegressionTestTicket4812()) if has_docutils: import docutils if get_pkginfo(docutils): suite.addTest(ReStructuredTextWikiTest()) suite.addTest(ReStructuredTextCodeBlockTest()) else: print "SKIP: reST wiki tests (docutils has no setuptools metadata)" else: print "SKIP: reST wiki tests (no docutils)" return suite
def setup_log(self): """Initialize the logging sub-system.""" from trac.log import logger_handler_factory logtype = self.log_type logfile = self.log_file if logtype == 'file' and not os.path.isabs(logfile): logfile = os.path.join(self.get_log_dir(), logfile) format = self.log_format if format: format = format.replace('$(', '%(') \ .replace('%(path)s', self.path) \ .replace('%(basename)s', os.path.basename(self.path)) \ .replace('%(project)s', self.project_name) self.log, self._log_handler = logger_handler_factory( logtype, logfile, self.log_level, self.path, format=format) from trac import core, __version__ as VERSION self.log.info('-' * 32 + ' environment startup [Trac %s] ' + '-' * 32, get_pkginfo(core).get('version', VERSION))
def setup_log(self): """Initialize the logging sub-system.""" from trac.log import logger_handler_factory logtype = self.log_type logfile = self.log_file if logtype == 'file' and not os.path.isabs(logfile): logfile = os.path.join(self.get_log_dir(), logfile) format = self.log_format logid = 'Trac.%s' % sha1(self.path).hexdigest() if format: format = format.replace('$(', '%(') \ .replace('%(path)s', self.path) \ .replace('%(basename)s', os.path.basename(self.path)) \ .replace('%(project)s', self.project_name) self.log, self._log_handler = logger_handler_factory( logtype, logfile, self.log_level, logid, format=format) from trac import core, __version__ as VERSION self.log.info('-' * 32 + ' environment startup [Trac %s] ' + '-' * 32, get_pkginfo(core).get('version', VERSION))
def __init__(self, path, create=False, options=[]): """Initialize the Trac environment. @param path: the absolute path to the Trac environment @param create: if `True`, the environment is created and populated with default data; otherwise, the environment is expected to already exist. @param options: A list of `(section, name, value)` tuples that define configuration options """ ComponentManager.__init__(self) self.path = path self.setup_config(load_defaults=create) self.setup_log() from trac import core, __version__ as VERSION trac_version = get_pkginfo(core).get('version', VERSION) self.systeminfo = [ ('Trac', trac_version), ('Python', sys.version), ('setuptools', setuptools.__version__), ] self.log.info('-' * 32 + ' environment startup [Trac %s] ' + '-' * 32, trac_version) self._href = self._abs_href = None from trac.loader import load_components plugins_dir = self.shared_plugins_dir load_components(self, plugins_dir and (plugins_dir,)) if create: self.create(options) else: self.verify() if create: for setup_participant in self.setup_participants: setup_participant.environment_created() self._known_users_cache_time = 0 self._known_users_cache = None
def setup_log(self): """Initialize the logging sub-system.""" from trac.log import logger_handler_factory logtype = self.log_type logfile = self.log_file format = self.log_format self.parent.log.debug("Log type '%s' for product '%s'", logtype, self.product.prefix) # Force logger inheritance on identical configuration if (logtype, logfile, format) == (self.parent.log_type, self.parent.log_file, self.parent.log_format): logtype = 'inherit' if logtype == 'inherit': self.log = self.parent.log self._log_handler = self.parent._log_handler self.parent.log.warning( "Inheriting parent logger for product '%s'", self.product.prefix) else: if logtype == 'file' and not os.path.isabs(logfile): logfile = os.path.join(self.get_log_dir(), logfile) logid = 'Trac.%s.%s' % \ (sha1(self.parent.path).hexdigest(), self.product.prefix) if format: format = format.replace('$(', '%(') \ .replace('%(path)s', self.path) \ .replace('%(basename)s', os.path.basename(self.path)) \ .replace('%(project)s', self.project_name) self.log, self._log_handler = logger_handler_factory( logtype, logfile, self.log_level, logid, format=format) from trac import core, __version__ as VERSION self.log.info( '-' * 32 + ' product %s environment startup [Trac %s] ' + '-' * 32, self.product.prefix, get_pkginfo(core).get('version', VERSION))
def setup_log(self): """Initialize the logging sub-system.""" from trac.log import logger_handler_factory logtype = self.log_type logfile = self.log_file format = self.log_format self.parent.log.debug("Log type '%s' for product '%s'", logtype, self.product.prefix) # Force logger inheritance on identical configuration if (logtype, logfile, format) == (self.parent.log_type, self.parent.log_file, self.parent.log_format): logtype = 'inherit' if logtype == 'inherit': self.log = self.parent.log self._log_handler = self.parent._log_handler self.parent.log.info("Inheriting parent logger for product '%s'", self.product.prefix) else: if logtype == 'file' and not os.path.isabs(logfile): logfile = os.path.join(self.get_log_dir(), logfile) logid = 'Trac.%s.%s' % \ (sha1(self.parent.path).hexdigest(), self.product.prefix) if format: format = format.replace('$(', '%(') \ .replace('%(path)s', self.path) \ .replace('%(basename)s', os.path.basename(self.path)) \ .replace('%(project)s', self.project_name) self.log, self._log_handler = logger_handler_factory( logtype, logfile, self.log_level, logid, format=format) from trac import core, __version__ as VERSION self.log.info('-' * 32 + ' product %s environment startup [Trac %s] ' + '-' * 32, self.product.prefix, get_pkginfo(core).get('version', VERSION))
def get_connection(self, path, log=None, params={}): if not self._version: self._version = get_pkginfo(sqlite).get( 'version', '%d.%d.%s' % sqlite.version_info) self.env.systeminfo.extend([('SQLite', sqlite_version_string), ('pysqlite', self._version)]) self.required = True # construct list of sqlite extension libraries if self._extensions is None: self._extensions = [] for extpath in self.extensions: if not os.path.isabs(extpath): extpath = os.path.join(self.env.path, extpath) self._extensions.append(extpath) params['extensions'] = self._extensions if path == ':memory:': try: self.memory_cnx.cursor() except (AttributeError, sqlite.DatabaseError): # memory_cnx is None or database connection closed. self.memory_cnx = SQLiteConnection(path, log, params) return self.memory_cnx else: return SQLiteConnection(path, log, params)
# All configuration values have a default value; values that are # commented out serve to show the default value. import os import sys from datetime import datetime from trac.util import get_pkginfo try: from pygments.lexers.templates import DjangoLexer html_jinja_lexer = DjangoLexer() except ImportError: html_jinja_lexer = None pkg_info = get_pkginfo(sys.modules['trac']) # General substitutions. project = 'Trac' copyright = '%s, Edgewall Software' % datetime.now().year url = pkg_info['home_page'] # The default replacements for |version| and |release|, also used in various # other places throughout the built documents. # # The short X.Y version. version = pkg_info['version'].split('dev')[0] # The full version, including alpha/beta/rc tags. release = pkg_info['version'] # Devel or Release mode for the documentation (if devel, include TODOs,
try: import psycopg2 as psycopg import psycopg2.extensions from psycopg2 import DataError, ProgrammingError from psycopg2.extensions import register_type, UNICODE, \ register_adapter, AsIs, QuotedString except ImportError: has_psycopg = False psycopg = None psycopg2_version = None else: has_psycopg = True register_type(UNICODE) register_adapter(Markup, lambda markup: QuotedString(unicode(markup))) register_adapter(type(empty), lambda empty: AsIs("''")) psycopg2_version = get_pkginfo(psycopg).get('version', psycopg.__version__) if hasattr(psycopg, 'libpq_version'): _libpq_pathname = None else: try: _libpq_pathname = find_library('pq' if os.name != 'nt' else 'libpq') except Exception: _libpq_pathname = None _like_escape_re = re.compile(r'([/_%])') # Mapping from "abstract" SQL types to DB-specific types _type_map = { 'int64': 'bigint', }
def get_system_info(self): if have_silvercity: yield 'SilverCity', get_pkginfo(SilverCity).get('version', '?')
def get_system_info(self): version = get_pkginfo(pygments).get('version') # if installed from source, fallback to the hardcoded version info if not version and hasattr(pygments, '__version__'): version = pygments.__version__ yield 'Pygments', version
def __init__(self): import genshi self.env.systeminfo.append(('Genshi', get_pkginfo(genshi).get('version')))
def get_plugin_info(env, include_core=False): """Return package information about Trac core and installed plugins.""" path_sources = {} def find_distribution(module): name = module.__name__ path = get_module_path(module) sources = path_sources.get(path) if sources is None: sources = path_sources[path] = get_sources(path) dist = sources.get(name.replace('.', '/') + '.py') if dist is None: dist = sources.get(name.replace('.', '/') + '/__init__.py') if dist is None: # This is a plain Python source file, not an egg dist = pkg_resources.Distribution(project_name=name, version='', location=module.__file__) return dist plugins_dir = env.plugins_dir plugins = {} from trac.core import ComponentMeta for component in ComponentMeta._components: module = sys.modules[component.__module__] dist = find_distribution(module) plugin_filename = None if os.path.realpath(os.path.dirname(dist.location)) == plugins_dir: plugin_filename = os.path.basename(dist.location) if dist.project_name not in plugins: readonly = True if plugin_filename and os.access(dist.location, os.F_OK + os.W_OK): readonly = False # retrieve plugin metadata info = get_pkginfo(dist) if not info: info = {} for k in ('author', 'author_email', 'home_page', 'url', 'license', 'summary', 'trac'): v = getattr(module, k, '') if v and isinstance(v, basestring): if k in ('home_page', 'url'): k = 'home_page' v = v.replace('$', '').replace('URL: ', '') else: v = to_unicode(v) info[k] = v else: # Info found; set all those fields to "None" that have the # value "UNKNOWN" as this is the value for fields that # aren't specified in "setup.py" for k in info: if info[k] == 'UNKNOWN': info[k] = '' else: # Must be encoded as unicode as otherwise Genshi # may raise a "UnicodeDecodeError". info[k] = to_unicode(info[k]) # retrieve plugin version info version = dist.version if not version: version = (getattr(module, 'version', '') or getattr(module, 'revision', '')) # special handling for "$Rev$" strings if version != '$Rev$': version = version.replace('$', '').replace('Rev: ', 'r') else: # keyword hasn't been expanded version = '' plugins[dist.project_name] = { 'name': dist.project_name, 'version': version, 'path': dist.location, 'plugin_filename': plugin_filename, 'readonly': readonly, 'info': info, 'modules': {}, } modules = plugins[dist.project_name]['modules'] if module.__name__ not in modules: summary, description = get_doc(module) plugins[dist.project_name]['modules'][module.__name__] = { 'summary': summary, 'description': description, 'components': {}, } full_name = module.__name__ + '.' + component.__name__ summary, description = get_doc(component) c = component if c in env and not issubclass(c, env.__class__): c = component(env) modules[module.__name__]['components'][component.__name__] = { 'full_name': full_name, 'summary': summary, 'description': description, 'enabled': env.is_component_enabled(component), 'required': getattr(c, 'required', False), } if not include_core: for name in list(plugins): if name.lower() == 'trac': plugins.pop(name) return sorted(plugins.itervalues(), key=lambda p: (p['name'].lower() != 'trac', p['name'].lower()))
def test_get_pkginfo_trac(self): pkginfo = util.get_pkginfo(trac) self.assertEqual(trac.__version__, pkginfo.get('version')) self.assertNotEqual({}, pkginfo)
def get_system_info(self): yield 'Pygments', get_pkginfo(pygments).get('version')
from trac.db.util import ConnectionWrapper, IterableCursor from trac.util import as_int, get_pkginfo from trac.util.html import Markup from trac.util.compat import close_fds from trac.util.text import exception_to_unicode, to_unicode from trac.util.translation import _ _like_escape_re = re.compile(r'([/_%])') try: import pymysql except ImportError: pymysql = None pymsql_version = None else: pymsql_version = get_pkginfo(pymysql).get('version', pymysql.__version__) class MySQLUnicodeCursor(pymysql.cursors.Cursor): def _convert_row(self, row): return tuple( v.decode('utf-8') if isinstance(v, str) else v for v in row) def fetchone(self): row = super(MySQLUnicodeCursor, self).fetchone() return self._convert_row(row) if row else None def fetchmany(self, num): rows = super(MySQLUnicodeCursor, self).fetchmany(num) return [self._convert_row(row) for row in rows] \ if rows is not None else []
def _render_view(self, req): plugins = {} plugins_dir = os.path.realpath(os.path.join(self.env.path, 'plugins')) plugins_dir = os.path.normcase(plugins_dir) # needs to match loader.py from trac.core import ComponentMeta for component in ComponentMeta._components: module = sys.modules[component.__module__] dist = self._find_distribution(module) plugin_filename = None if os.path.realpath(os.path.dirname(dist.location)) == plugins_dir: plugin_filename = os.path.basename(dist.location) description = inspect.getdoc(component) if description: description = to_unicode(description).split('.', 1)[0] + '.' if dist.project_name not in plugins: readonly = True if plugin_filename and os.access(dist.location, os.F_OK + os.W_OK): readonly = False # retrieve plugin metadata info = get_pkginfo(dist) if not info: info = {'summary': description} for k in ('author author_email home_page url license trac' .split()): v = getattr(module, k, '') if v: if k == 'home_page' or k == 'url': k = 'home_page' v = v.replace('$', '').replace('URL: ', '') info[k] = v # retrieve plugin version info version = dist.version if not version: version = (getattr(module, 'version', '') or getattr(module, 'revision', '')) # special handling for "$Rev$" strings version = version.replace('$', '').replace('Rev: ', 'r') plugins[dist.project_name] = { 'name': dist.project_name, 'version': version, 'path': dist.location, 'description': description, 'plugin_filename': plugin_filename, 'readonly': readonly, 'info': info, 'components': [], 'settingheader': dist.project_name, 'settings': [] } self.getSettings(component, plugins[dist.project_name]['settings']) prjconf = Configuration(conf.global_conf_path) pstate = self.get_project_component_state(component, prjconf) ostate = self.get_project_component_state(component, self.config) plugins[dist.project_name]['components'].append({ 'name': component.__name__, 'module': module.__name__, 'description': description, 'enabled': self.is_plugin_enabled(ostate), 'required': self.is_plugin_required(ostate), 'view': self.is_plugin_shown(ostate), 'penabled': self.is_plugin_enabled(pstate), 'prequired': self.is_plugin_required(pstate), 'pview': self.is_plugin_shown(pstate), }) def component_order(a, b): c = cmp(len(a['module'].split('.')), len(b['module'].split('.'))) if c == 0: c = cmp(a['module'].lower(), b['module'].lower()) if c == 0: c = cmp(a['name'].lower(), b['name'].lower()) return c for category in plugins: plugins[category]['components'].sort(component_order) plugin_list = [plugins['Trac']] addons = [key for key in plugins.keys() if key != 'Trac'] addons.sort() plugin_list += [plugins[category] for category in addons] data = { 'plugins': plugin_list, 'readonly': not os.access(plugins_dir, os.F_OK + os.W_OK), } return 'admin_home_plugins.html', data
def __init__(self): self._mysql_version = None self._mysqldb_version = has_mysqldb and \ get_pkginfo(MySQLdb).get('version', MySQLdb.__version__) self.error = None
try: import psycopg2 as psycopg import psycopg2.extensions from psycopg2 import DataError, ProgrammingError from psycopg2.extensions import register_type, UNICODE, \ register_adapter, AsIs, QuotedString except ImportError: has_psycopg = False psycopg2_version = None else: has_psycopg = True register_type(UNICODE) register_adapter(Markup, lambda markup: QuotedString(unicode(markup))) register_adapter(type(empty), lambda empty: AsIs("''")) psycopg2_version = get_pkginfo(psycopg).get('version', psycopg.__version__) _like_escape_re = re.compile(r'([/_%])') # Mapping from "abstract" SQL types to DB-specific types _type_map = { 'int64': 'bigint', } def assemble_pg_dsn(path, user=None, password=None, host=None, port=None): """Quote the parameters and assemble the DSN.""" def quote(value): if not isinstance(value, basestring): value = unicode(value) return "'%s'" % value.replace('\\', r'\\').replace("'", r"\'")
def get_plugin_info(env, include_core=False): """Return package information about Trac core and installed plugins.""" path_sources = {} def find_distribution(module): name = module.__name__ path = get_module_path(module) sources = path_sources.get(path) if sources is None: sources = path_sources[path] = get_sources(path) dist = sources.get(name.replace('.', '/') + '.py') if dist is None: dist = sources.get(name.replace('.', '/') + '/__init__.py') if dist is None: # This is a plain Python source file, not an egg dist = pkg_resources.Distribution(project_name=name, version='', location=module.__file__) return dist plugins_dir = get_plugins_dir(env) plugins = {} from trac.core import ComponentMeta for component in ComponentMeta._components: module = sys.modules[component.__module__] dist = find_distribution(module) plugin_filename = None if os.path.realpath(os.path.dirname(dist.location)) == plugins_dir: plugin_filename = os.path.basename(dist.location) if dist.project_name not in plugins: readonly = True if plugin_filename and os.access(dist.location, os.F_OK + os.W_OK): readonly = False # retrieve plugin metadata info = get_pkginfo(dist) if not info: info = {} for k in ('author', 'author_email', 'home_page', 'url', 'license', 'trac'): v = getattr(module, k, '') if v and isinstance(v, basestring): if k == 'home_page' or k == 'url': k = 'home_page' v = v.replace('$', '').replace('URL: ', '') else: v = to_unicode(v) info[k] = v else: # Info found; set all those fields to "None" that have the # value "UNKNOWN" as this is the value for fields that # aren't specified in "setup.py" for k in info: if info[k] == 'UNKNOWN': info[k] = '' else: # Must be encoded as unicode as otherwise Genshi # may raise a "UnicodeDecodeError". info[k] = to_unicode(info[k]) # retrieve plugin version info version = dist.version if not version: version = (getattr(module, 'version', '') or getattr(module, 'revision', '')) # special handling for "$Rev$" strings version = version.replace('$', '').replace('Rev: ', 'r') plugins[dist.project_name] = { 'name': dist.project_name, 'version': version, 'path': dist.location, 'plugin_filename': plugin_filename, 'readonly': readonly, 'info': info, 'modules': {}, } modules = plugins[dist.project_name]['modules'] if module.__name__ not in modules: summary, description = get_doc(module) plugins[dist.project_name]['modules'][module.__name__] = { 'summary': summary, 'description': description, 'components': {}, } full_name = module.__name__ + '.' + component.__name__ summary, description = get_doc(component) c = component if c in env and not issubclass(c, env.__class__): c = component(env) modules[module.__name__]['components'][component.__name__] = { 'full_name': full_name, 'summary': summary, 'description': description, 'enabled': env.is_component_enabled(component), 'required': getattr(c, 'required', False), } if not include_core: for name in plugins.keys(): if name.lower() == 'trac': plugins.pop(name) return sorted(plugins.itervalues(), key=lambda p: (p['name'].lower() != 'trac', p['name'].lower()))
from trac.util import get_pkginfo, getuser, lazy from trac.util.translation import _, tag_ _like_escape_re = re.compile(r'([/_%])') _glob_escape_re = re.compile(r'[*?\[]') try: import pysqlite2.dbapi2 as sqlite except ImportError: import sqlite3 as sqlite sqlite_version = sqlite.sqlite_version_info sqlite_version_string = sqlite.sqlite_version pysqlite_version = sqlite.version_info pysqlite_version_string = get_pkginfo(sqlite).get( 'version', '%d.%d.%s' % pysqlite_version) min_sqlite_version = (3, 0, 0) min_pysqlite_version = (2, 4, 1) # version provided by Python 2.6 class PyFormatCursor(sqlite.Cursor): def _rollback_on_error(self, function, *args, **kwargs): try: return function(self, *args, **kwargs) except sqlite.DatabaseError: self.cnx.rollback() raise def execute(self, sql, args=None): if args: sql = sql % (('?', ) * len(args))
def trac_version(self): """Returns the version of Trac. :since: 1.2 """ from trac import core, __version__ return get_pkginfo(core).get('version', __version__)
# containing dir. # # The contents of this file are pickled, so don't put values in the # namespace that aren't pickleable (module imports are okay, they're # removed automatically). # # All configuration values have a default value; values that are # commented out serve to show the default value. import os import sys from datetime import datetime from trac.util import get_pkginfo pkg_info = get_pkginfo(sys.modules['trac']) # General substitutions. project = 'Trac' copyright = '%s, Edgewall Software' % datetime.now().year url = pkg_info['home_page'] # The default replacements for |version| and |release|, also used in various # other places throughout the built documents. # # The short X.Y version. version = pkg_info['version'].split('dev')[0] # The full version, including alpha/beta/rc tags. release = pkg_info['version'] # Devel or Release mode for the documentation (if devel, include TODOs,
def get_system_info(self): if has_textile: # textile.__version__ is available since 2.1.6 version = get_pkginfo(textile).get('version') or \ getattr(textile, '__version__', 'n/a') yield 'Textile', version
from trac.util.translation import _, tag_ _like_escape_re = re.compile(r'([/_%])') _glob_escape_re = re.compile(r'[*?\[]') try: import pysqlite2.dbapi2 as sqlite except ImportError: import sqlite3 as sqlite sqlite_version = sqlite.sqlite_version_info sqlite_version_string = sqlite.sqlite_version pysqlite_version = sqlite.version_info pysqlite_version_string = get_pkginfo(sqlite).get('version', '%d.%d.%s' % pysqlite_version) min_sqlite_version = (3, 0, 0) min_pysqlite_version = (2, 4, 1) # version provided by Python 2.6 class PyFormatCursor(sqlite.Cursor): def _rollback_on_error(self, function, *args, **kwargs): try: return function(self, *args, **kwargs) except sqlite.DatabaseError: self.cnx.rollback() raise def execute(self, sql, args=None): if args: