trac/util/__init__.py
# -*- coding: utf-8 -*-
#
# Copyright (C) 2003-2023 Edgewall Software
# Copyright (C) 2003-2006 Jonas Borgström <jonas@edgewall.com>
# Copyright (C) 2006 Matthew Good <trac@matt-good.net>
# Copyright (C) 2005-2006 Christian Boos <cboos@edgewall.org>
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution. The terms
# are also available at https://trac.edgewall.org/wiki/TracLicense.
#
# This software consists of voluntary contributions made by many
# individuals. For the exact contribution history, see the revision
# history and logs, available at https://trac.edgewall.org/log/.
#
# Author: Jonas Borgström <jonas@edgewall.com>
# Matthew Good <trac@matt-good.net>
import csv
import errno
import functools
import hashlib
import importlib
import io
import os
import pkg_resources
import posixpath
import random
import re
import shutil
import sys
import string
import struct
import tempfile
import urllib.parse
import unicodedata
import zipfile
from trac.util.datefmt import time_now, to_datetime, to_timestamp, utc
from trac.util.text import exception_to_unicode, getpreferredencoding, \
stripws, to_unicode, to_utf8
def get_reporter_id(req, arg_name=None):
"""Get most informative "reporter" identity out of a request.
That's the `Request`'s authname if not 'anonymous', or a `Request`
argument, or the session name and e-mail, or only the name or only
the e-mail, or 'anonymous' as last resort.
:param req: a `trac.web.api.Request`
:param arg_name: if given, a `Request` argument which may contain
the id for non-authentified users
"""
if req.is_authenticated:
return req.authname
if arg_name:
r = req.args.get(arg_name)
if r:
return r
name = req.session.get('name')
email = req.session.get('email')
if name and email:
return '%s <%s>' % (name, email)
return name or email or req.authname # == 'anonymous'
def content_disposition(type=None, filename=None):
"""Generate a properly escaped Content-Disposition header."""
type = type or ''
if filename is not None:
if isinstance(filename, str):
filename = filename.encode('utf-8')
if type:
type += '; '
type += 'filename=' + urllib.parse.quote(filename, safe='')
return type
# -- os utilities
if os.name == 'nt':
from getpass import getuser
else:
import pwd
def getuser():
"""Retrieve the identity of the process owner"""
try:
return pwd.getpwuid(os.geteuid())[0]
except KeyError:
return 'unknown'
try:
WindowsError = WindowsError
except NameError:
class WindowsError(OSError):
"""Dummy exception replacing WindowsError on non-Windows platforms"""
def native_path(path):
"""Converts a Windows-style or POSIX-style path to the native style.
i.e. on Windows, convert POSIX path to Windows path, and in a
POSIX system, convert Windows path to POSIX path.
:param path: the input path
:return: the path converted to native style
"""
if path:
if os.name == 'posix':
if (len(path) > 1 and path[1] == ':') or '\\' in path:
path = path.replace('\\', '/')
if path[1] == ':':
path = '/' + path[0] + path[2:]
elif os.name == 'nt':
if path[0] == '/': # abs path
if len(path) == 2 or len(path) > 2 and path[2] == '/':
# interpret 1-letter toplevel as volume name
path = path[1] + ':' + path[2:]
else:
# assume we're talking about C:
path = 'C:\\' + path[1:]
path = path.replace('/', '\\')
return path
_control_codes_re = re.compile(
'[' +
''.join(filter(lambda c: unicodedata.category(c) == 'Cc',
map(chr, range(0x10000)))) +
']')
def normalize_filename(filepath):
# We try to normalize the filename to unicode NFC if we can.
# Files from OS X might be in NFD.
if not isinstance(filepath, str):
filepath = str(filepath, 'utf-8')
filepath = unicodedata.normalize('NFC', filepath)
# Replace control codes with spaces, e.g. NUL, LF, DEL, U+009F
filepath = _control_codes_re.sub(' ', filepath)
# Replace backslashes with slashes if filename is Windows full path
if filepath.startswith('\\') or re.match(r'[A-Za-z]:\\', filepath):
filepath = filepath.replace('\\', '/')
# We want basename to be delimited by only slashes on all platforms
filename = posixpath.basename(filepath)
filename = stripws(filename)
return filename
can_rename_open_file = False
if os.name == 'nt':
_rename = lambda src, dst: False
_rename_atomic = lambda src, dst: False
try:
import ctypes
MOVEFILE_REPLACE_EXISTING = 0x1
MOVEFILE_WRITE_THROUGH = 0x8
MoveFileEx = ctypes.windll.kernel32.MoveFileExW
def _rename(src, dst):
if not isinstance(src, str):
src = str(src, sys.getfilesystemencoding())
if not isinstance(dst, str):
dst = str(dst, sys.getfilesystemencoding())
if _rename_atomic(src, dst):
return True
return MoveFileEx(src, dst, MOVEFILE_REPLACE_EXISTING
| MOVEFILE_WRITE_THROUGH)
CreateTransaction = ctypes.windll.ktmw32.CreateTransaction
CommitTransaction = ctypes.windll.ktmw32.CommitTransaction
MoveFileTransacted = ctypes.windll.kernel32.MoveFileTransactedW
CloseHandle = ctypes.windll.kernel32.CloseHandle
can_rename_open_file = True
def _rename_atomic(src, dst):
ta = CreateTransaction(None, 0, 0, 0, 0, 10000, 'Trac rename')
if ta == -1:
return False
try:
return (MoveFileTransacted(src, dst, None, None,
MOVEFILE_REPLACE_EXISTING
| MOVEFILE_WRITE_THROUGH, ta)
and CommitTransaction(ta))
finally:
CloseHandle(ta)
except Exception:
pass
def rename(src, dst):
# Try atomic or pseudo-atomic rename
if _rename(src, dst):
return
# Fall back to "move away and replace"
try:
os.rename(src, dst)
except OSError as e:
if e.errno != errno.EEXIST:
raise
old = "%s-%08x" % (dst, random.randint(0, 0xffffffff))
os.rename(dst, old)
os.rename(src, dst)
try:
os.unlink(old)
except Exception:
pass
else:
rename = os.rename
can_rename_open_file = True
class AtomicFile(object):
"""A file that appears atomically with its full content.
This file-like object writes to a temporary file in the same directory
as the final file. If the file is committed, the temporary file is renamed
atomically (on Unix, at least) to its final name. If it is rolled back,
the temporary file is removed.
"""
def __init__(self, path, mode='w', bufsize=-1, encoding='utf-8',
errors='strict'):
self._file = None
self._path = os.path.realpath(path)
dir, name = os.path.split(self._path)
fd, self._temp = tempfile.mkstemp(prefix=name + '-', dir=dir)
kwargs = {} if 'b' in mode else \
{'encoding': encoding, 'errors': errors}
self._file = os.fdopen(fd, mode, bufsize, **kwargs)
# Try to preserve permissions and group ownership, but failure
# should not be fatal
try:
st = os.stat(self._path)
if hasattr(os, 'chmod'):
os.chmod(self._temp, st.st_mode)
if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):
os.chflags(self._temp, st.st_flags)
if hasattr(os, 'chown'):
os.chown(self._temp, -1, st.st_gid)
except OSError:
pass
def __getattr__(self, name):
return getattr(self._file, name)
def commit(self):
if self._file is None:
return
try:
f, self._file = self._file, None
f.close()
rename(self._temp, self._path)
except Exception:
os.unlink(self._temp)
raise
def rollback(self):
if self._file is None:
return
try:
f, self._file = self._file, None
f.close()
finally:
try:
os.unlink(self._temp)
except Exception:
pass
close = commit
__del__ = rollback
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
closed = property(lambda self: self._file is None or self._file.closed)
def read_file(path, mode='r', encoding='utf-8', errors='strict'):
"""Read a file and return its content."""
kwargs = {} if 'b' in mode else {'encoding': encoding, 'errors': errors}
with open(path, mode, **kwargs) as f:
return f.read()
def create_file(path, data='', mode='w', encoding='utf-8', errors='strict'):
"""Create a new file with the given data.
:data: string or iterable of strings.
"""
kwargs = {} if 'b' in mode else {'encoding': encoding, 'errors': errors}
with open(path, mode, **kwargs) as f:
if data:
if isinstance(data, (str, bytes)):
f.write(data)
else: # Assume iterable
f.writelines(data)
def create_unique_file(path):
"""Create a new file. An index is added if the path exists"""
parts = os.path.splitext(path)
flags = os.O_CREAT + os.O_WRONLY + os.O_EXCL
if hasattr(os, 'O_BINARY'):
flags += os.O_BINARY
idx = 1
while 1:
try:
return path, os.fdopen(os.open(path, flags, 0o666), 'wb')
except OSError as e:
if e.errno != errno.EEXIST:
raise
idx += 1
# A sanity check
if idx > 100:
raise Exception('Failed to create unique name: ' + path)
path = '%s.%d%s' % (parts[0], idx, parts[1])
if os.name == 'nt':
def touch_file(filename):
"""Update modified time of the given file. The file is created if
missing."""
# Use f.truncate() to avoid low resolution of GetSystemTime()
# on Windows
with open(filename, 'ab') as f:
stat = os.fstat(f.fileno())
size = stat.st_size
# update forcibly the modified time because f.truncate()
# with the same size doesn't update
f.truncate(size + 1)
f.truncate(size)
else:
def touch_file(filename):
"""Update modified time of the given file. The file is created if
missing."""
try:
os.utime(filename, None)
except OSError as e:
if e.errno == errno.ENOENT:
with open(filename, 'ab'):
pass
else:
raise
def backup_config_file(env, suffix):
try:
backup, f = create_unique_file(env.config.filename + suffix)
f.close()
shutil.copyfile(env.config.filename, backup)
except IOError as e:
env.log.warning("Couldn't save backup of configuration file (%s)",
exception_to_unicode(e))
else:
env.log.info("Saved backup of configuration file in %s", backup)
def create_zipinfo(filename, mtime=None, dir=False, executable=False, symlink=False,
comment=None):
"""Create a instance of `ZipInfo`.
:param filename: file name of the entry
:param mtime: modified time of the entry
:param dir: if `True`, the entry is a directory
:param executable: if `True`, the entry is a executable file
:param symlink: if `True`, the entry is a symbolic link
:param comment: comment of the entry
"""
zipinfo = zipfile.ZipInfo()
zipinfo.filename = filename
if mtime is not None:
mtime = to_datetime(mtime, utc)
zipinfo.date_time = mtime.utctimetuple()[:6]
# The "extended-timestamp" extra field is used for the
# modified time of the entry in unix time. It avoids
# extracting wrong modified time if non-GMT timezone.
# See http://www.opensource.apple.com/source/zip/zip-6/unzip/unzip
# /proginfo/extra.fld
zipinfo.extra += struct.pack(
'<hhBl',
0x5455, # extended-timestamp extra block type
1 + 4, # size of this block
1, # modification time is present
to_timestamp(mtime)) # time of last modification
# external_attr is 4 bytes in size. The high order two
# bytes represent UNIX permission and file type bits,
# while the low order two contain MS-DOS FAT file
# attributes, most notably bit 4 marking directories.
if dir:
if not zipinfo.filename.endswith('/'):
zipinfo.filename += '/'
zipinfo.compress_type = zipfile.ZIP_STORED
zipinfo.external_attr = 0o40755 << 16 # permissions drwxr-xr-x
zipinfo.external_attr |= 0x10 # MS-DOS directory flag
else:
zipinfo.compress_type = zipfile.ZIP_DEFLATED
zipinfo.external_attr = 0o644 << 16 # permissions -r-wr--r--
if executable:
zipinfo.external_attr |= 0o755 << 16 # -rwxr-xr-x
if symlink:
zipinfo.compress_type = zipfile.ZIP_STORED
zipinfo.external_attr |= 0o120000 << 16 # symlink file type
if comment:
zipinfo.comment = comment.encode('utf-8') \
if isinstance(comment, str) else comment
return zipinfo
def extract_zipfile(srcfile, destdir):
with zipfile.ZipFile(srcfile) as zip:
for entry in zip.namelist():
if entry.endswith('/'): # is a directory
continue
names = entry.split('/')
content = zip.read(entry)
filename = os.path.join(destdir, *names)
dirname = os.path.dirname(filename)
if not os.path.isdir(dirname):
os.makedirs(dirname)
create_file(filename, content, 'wb')
class NaivePopen(object):
"""This is a deadlock-safe version of popen that returns an object with
errorlevel, out (a string) and err (a string).
The optional `input`, which must be a `str` object, is first written
to a temporary file from which the process will read.
(`capturestderr` may not work under Windows 9x.)
Example::
print(Popen3('grep spam','\\n\\nhere spam\\n\\n').out)
"""
def __init__(self, command, input=None, capturestderr=None):
outfile = tempfile.mktemp()
command = '( %s ) > %s' % (command, outfile)
if input is not None:
infile = tempfile.mktemp()
with open(infile, 'wb') as tmp:
tmp.write(input)
command = command + ' <' + infile
if capturestderr:
errfile = tempfile.mktemp()
command = command + ' 2>' + errfile
try:
self.err = None
self.errorlevel = os.system(command) >> 8
self.out = read_file(outfile)
if capturestderr:
self.err = read_file(errfile)
finally:
if os.path.isfile(outfile):
os.remove(outfile)
if input and os.path.isfile(infile):
os.remove(infile)
if capturestderr and os.path.isfile(errfile):
os.remove(errfile)
def terminate(process):
"""Terminate the process.
If the process has already finished and has not been waited for,
the function does not raise OSError and WindowsError exceptions unlike
a terminate method of `subprocess.Popen`.
:param process: the integer id (`pid`) of the process.
"""
pid = process if isinstance(process, int) else process.pid
def terminate_win():
import ctypes
PROCESS_TERMINATE = 1
handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE,
False, pid)
ctypes.windll.kernel32.TerminateProcess(handle, -1)
ctypes.windll.kernel32.CloseHandle(handle)
def terminate_nix():
import signal
try:
os.kill(pid, signal.SIGTERM)
except OSError as e:
# If the process has already finished and has not been
# waited for, killing it raises an ESRCH error on Cygwin
if e.errno != errno.ESRCH:
raise
if sys.platform == 'win32':
return terminate_win()
return terminate_nix()
def makedirs(path, overwrite=False):
"""Create as many directories as necessary to make `path` exist.
If `overwrite` is `True`, don't raise an exception in case `path`
already exists.
"""
if overwrite and os.path.exists(path):
return
os.makedirs(path)
def copytree(src, dst, symlinks=False, skip=[], overwrite=False):
"""Recursively copy a directory tree using copy2() (from shutil.copytree.)
Added a `skip` parameter consisting of absolute paths
which we don't want to copy.
"""
def str_path(path):
if isinstance(path, str):
path = path.encode(sys.getfilesystemencoding() or
getpreferredencoding())
return path
def remove_if_overwriting(path):
if overwrite and os.path.exists(path):
os.unlink(path)
skip = [str_path(f) for f in skip]
def copytree_rec(src, dst):
names = os.listdir(src)
makedirs(dst, overwrite=overwrite)
errors = []
for name in names:
srcname = os.path.join(src, name)
if srcname in skip:
continue
dstname = os.path.join(dst, name)
try:
if symlinks and os.path.islink(srcname):
remove_if_overwriting(dstname)
linkto = os.readlink(srcname)
os.symlink(linkto, dstname)
elif os.path.isdir(srcname):
copytree_rec(srcname, dstname)
else:
remove_if_overwriting(dstname)
shutil.copy2(srcname, dstname)
# XXX What about devices, sockets etc.?
except (IOError, OSError) as why:
errors.append((srcname, dstname, str(why)))
# catch the Error from the recursive copytree so that we can
# continue with other files
except shutil.Error as err:
errors.extend(err.args[0])
try:
shutil.copystat(src, dst)
except WindowsError:
pass # Ignore errors due to limited Windows copystat support
except OSError as why:
errors.append((src, dst, str(why)))
if errors:
raise shutil.Error(errors)
copytree_rec(str_path(src), str_path(dst))
def is_path_below(path, parent):
"""Return True iff `path` is equal to parent or is located below `parent`
at any level.
"""
def normalize(path):
return os.path.normcase(os.path.abspath(path))
path = normalize(path)
parent = normalize(parent)
return path == parent or path.startswith(parent + os.sep)
class file_or_std(object):
"""Context manager for opening a file or using a standard stream
If `filename` is non-empty, open the file and close it when exiting the
block. Otherwise, use `sys.stdin` if opening for reading, or `sys.stdout`
if opening for writing or appending."""
file = None
def __init__(self, filename, mode='r', bufsize=-1, encoding='utf-8',
errors='strict'):
self.filename = filename
self.mode = mode
self.bufsize = bufsize
self.encoding = encoding
self.errors = errors
def __enter__(self):
if not self.filename:
f = sys.stdin if 'r' in self.mode else sys.stdout
if 'b' in self.mode:
f = f.buffer
return f
kwargs = {} if 'b' in self.mode else \
{'encoding': self.encoding, 'errors': self.errors}
self.file = open(self.filename, self.mode, self.bufsize, **kwargs)
return self.file
def __exit__(self, et, ev, tb):
if self.file is not None:
self.file.close()
# -- sys utils
def fq_class_name(obj):
"""Return the fully qualified class name of given object."""
c = type(obj)
m, n = c.__module__, c.__name__
return n if m == '__builtin__' else '%s.%s' % (m, n)
def arity(f):
"""Return the number of arguments expected by the given function, unbound
or bound method.
"""
return f.__code__.co_argcount - bool(getattr(f, '__self__', False))
def get_last_traceback():
"""Retrieve the last traceback as a `str` string."""
import traceback
tb = io.StringIO()
traceback.print_exc(file=tb)
return tb.getvalue()
_egg_path_re = re.compile(r'build/bdist\.[^/]+/egg/(.*)')
def get_lines_from_file(filename, lineno, context=0, globals=None):
"""Return `content` number of lines before and after the specified
`lineno` from the (source code) file identified by `filename`.
Returns a `(lines_before, line, lines_after)` tuple.
"""
# The linecache module can load source code from eggs since Python 2.6.
# Prior versions return lines from the wrong file, so we try locating
# the file in eggs manually first.
lines = []
match = _egg_path_re.match(filename)
if match:
for path in sys.path:
try:
with zipfile.ZipFile(path, 'r') as zip:
lines = zip.read(match.group(1)).splitlines()
break
except Exception:
pass
if not lines:
import linecache
linecache.checkcache(filename)
lines = linecache.getlines(filename, globals)
if not 0 <= lineno < len(lines):
return (), None, ()
lbound = max(0, lineno - context)
ubound = lineno + 1 + context
charset = None
rep = re.compile(r'coding[=:]\s*([-\w.]+)')
for linestr in lines[:2]:
match = rep.search(linestr)
if match:
charset = match.group(1)
break
before = [to_unicode(l.rstrip('\n'), charset)
for l in lines[lbound:lineno]]
line = to_unicode(lines[lineno].rstrip('\n'), charset)
after = [to_unicode(l.rstrip('\n'), charset)
for l in lines[lineno + 1:ubound]]
return before, line, after
def get_frame_info(tb):
"""Return frame information for a traceback."""
frames = []
while tb:
tb_hide = tb.tb_frame.f_locals.get('__traceback_hide__')
if tb_hide in ('before', 'before_and_this'):
del frames[:]
tb_hide = tb_hide[6:]
if not tb_hide:
filename = tb.tb_frame.f_code.co_filename
filename = filename.replace('\\', '/')
lineno = tb.tb_lineno - 1
before, line, after = get_lines_from_file(filename, lineno, 5,
tb.tb_frame.f_globals)
frames.append({'traceback': tb, 'filename': filename,
'lineno': lineno, 'line': line,
'lines_before': before, 'lines_after': after,
'function': tb.tb_frame.f_code.co_name,
'vars': tb.tb_frame.f_locals})
tb = tb.tb_next
return frames
def safe__import__(module_name):
"""
Safe imports: rollback after a failed import.
Initially inspired from the RollbackImporter in PyUnit,
but it's now much simpler and works better for our needs.
See http://pyunit.sourceforge.net/notes/reloading.html
"""
already_imported = sys.modules.copy()
try:
return importlib.import_module(module_name)
except Exception as e:
for modname in sys.modules.copy():
if modname not in already_imported:
del(sys.modules[modname])
raise e
def safe_repr(x):
"""`repr` replacement which "never" breaks.
Make sure we always get a representation of the input `x`
without risking to trigger an exception (e.g. from a buggy
`x.__repr__`).
.. versionadded :: 1.0
"""
try:
return to_unicode(repr(x))
except Exception as e:
return "<%s object at 0x%X (repr() error: %s)>" % (
fq_class_name(x), id(x), exception_to_unicode(e))
def get_doc(obj):
"""Return the docstring of an object as a tuple `(summary, description)`,
where `summary` is the first paragraph and `description` is the remaining
text.
"""
doc = obj.__doc__
if not doc:
return None, None
doc = to_unicode(doc).split('\n\n', 1)
summary = doc[0].replace('\n', ' ')
description = doc[1] if len(doc) > 1 else None
return summary, description
_dont_import = frozenset(['__file__', '__name__', '__package__'])
def import_namespace(globals_dict, module_name):
"""Import the namespace of a module into a globals dict.
This function is used in stub modules to import all symbols defined in
another module into the global namespace of the stub, usually for
backward compatibility.
"""
module = importlib.import_module(module_name)
globals_dict.update(item for item in module.__dict__.items()
if item[0] not in _dont_import)
globals_dict.pop('import_namespace', None)
# -- setuptools utils
def get_module_path(module):
"""Return the base path the given module is imported from"""
path = module.__file__
module_name = module.__name__
if path.endswith(('.pyc', '.pyo')):
path = path[:-1]
if os.path.basename(path) == '__init__.py':
path = os.path.dirname(path)
base_path = os.path.splitext(path)[0]
while base_path.replace(os.sep, '.').endswith(module_name):
base_path = os.path.dirname(base_path)
module_name = '.'.join(module_name.split('.')[:-1])
if not module_name:
break
return base_path
def get_sources(path):
"""Return a dictionary mapping Python module source paths to the
distributions that contain them.
"""
sources = {}
for dist in pkg_resources.find_distributions(path, only=True):
if not dist.has_metadata('top_level.txt'):
continue
toplevels = dist.get_metadata_lines('top_level.txt')
toplevels = [top + '/' for top in toplevels]
if dist.has_metadata('SOURCES.txt'): # *.egg-info/SOURCES.txt
sources.update((src, dist)
for src in dist.get_metadata_lines('SOURCES.txt')
if any(src.startswith(top) for top in toplevels))
continue
if dist.has_metadata('RECORD'): # *.dist-info/RECORD
with io.StringIO(dist.get_metadata('RECORD')) as f:
reader = csv.reader(f)
sources.update((row[0], dist)
for row in reader if any(row[0].startswith(top)
for top in toplevels))
continue
return sources
def get_pkginfo(dist):
"""Get a dictionary containing package information for a package
`dist` can be either a Distribution instance or, as a shortcut,
directly the module instance, if one can safely infer a Distribution
instance from it.
Always returns a dictionary but it will be empty if no Distribution
instance can be created for the given module.
"""
import email
import email.errors
import types
from trac.util.translation import _
def parse_pkginfo(dist, name):
return email.message_from_string(dist.get_metadata(name))
if isinstance(dist, types.ModuleType):
def has_resource(dist, module, resource_name):
if dist.location.endswith('.egg'): # installed by easy_install
return dist.has_resource(resource_name)
if dist.has_metadata('installed-files.txt'): # installed by pip
resource_name = os.path.normpath('../' + resource_name)
return any(resource_name == os.path.normpath(name)
for name
in dist.get_metadata_lines('installed-files.txt'))
if dist.has_metadata('SOURCES.txt'):
resource_name = os.path.normpath(resource_name)
return any(resource_name == os.path.normpath(name)
for name in dist.get_metadata_lines('SOURCES.txt'))
if dist.has_metadata('RECORD'): # *.dist-info/RECORD
with io.StringIO(dist.get_metadata('RECORD')) as f:
reader = csv.reader(f)
return any(resource_name == row[0] for row in reader)
if dist.has_metadata('PKG-INFO'):
try:
pkginfo = parse_pkginfo(dist, 'PKG-INFO')
provides = pkginfo.get_all('Provides', ())
names = module.__name__.split('.')
if any('.'.join(names[:n + 1]) in provides
for n in range(len(names))):
return True
except (IOError, email.Errors.MessageError):
pass
toplevel = resource_name.split('/')[0]
if dist.has_metadata('top_level.txt'):
return toplevel in dist.get_metadata_lines('top_level.txt')
return dist.key == toplevel.lower()
module = dist
module_path = get_module_path(module)
resource_name = module.__name__.replace('.', '/')
if os.path.basename(module.__file__) in ('__init__.py', '__init__.pyc',
'__init__.pyo'):
resource_name += '/__init__.py'
else:
resource_name += '.py'
for dist in pkg_resources.find_distributions(module_path, only=True):
if os.path.isfile(module_path) or \
has_resource(dist, module, resource_name):
break
else:
return {}
attrs = ('author', 'author-email', 'maintainer', 'maintainer-email',
'license', 'home-page', 'summary', 'name', 'description',
'version')
info = {}
def normalize(attr):
return attr.lower().replace('-', '_')
metadata = 'METADATA' if dist.has_metadata('METADATA') else 'PKG-INFO'
try:
pkginfo = parse_pkginfo(dist, metadata)
for attr in [key for key in attrs if key in pkginfo]:
info[normalize(attr)] = pkginfo[attr]
except IOError as e:
err = _("Failed to read %(metadata)s file for %(dist)s: %(err)s",
metadata=metadata, dist=dist, err=to_unicode(e))
for attr in attrs:
info[normalize(attr)] = err
except email.errors.MessageError as e:
err = _("Failed to parse %(metadata)s file for %(dist)s: %(err)s",
metadata=metadata, dist=dist, err=to_unicode(e))
for attr in attrs:
info[normalize(attr)] = err
return info
def get_module_metadata(module):
"""Get a dictionary containing metadata for a module."""
info = {}
for k in ('author', 'author_email', 'maintainer',
'maintainer_email', 'home_page', 'url', 'license',
'summary', 'trac'):
v = getattr(module, k, '')
if v and isinstance(v, str):
if k in ('home_page', 'url'):
k = 'home_page'
v = v.replace('$', '').replace('URL: ', '').strip()
else:
v = to_unicode(v)
info[k] = v
# retrieve plugin version info
version = (getattr(module, 'version', '') or
getattr(module, 'revision', ''))
# special handling for "$Rev$" strings
if version != '$Rev$':
info['version'] = \
version.replace('$', '').replace('Rev: ', 'r').strip()
else: # keyword hasn't been expanded
info['version'] = ''
return info
# -- crypto utils
try:
os.urandom(16)
urandom = os.urandom
except NotImplementedError:
_entropy = random.Random()
def urandom(n):
result = []
hasher = hashlib.sha1('{}{}'.format(os.getpid(), time_now())
.encode('utf-8'))
while len(result) * hasher.digest_size < n:
hasher.update(str(_entropy.random()).encode('utf-8'))
result.append(hasher.digest())
result = b''.join(result)
return result[:n] if len(result) > n else result
def hex_entropy(digits=32):
"""Generate `digits` number of hex digits of entropy."""
result = ''.join('%.2x' % v for v in urandom((digits + 1) // 2))
return result[:digits] if len(result) > digits else result
def salt(length=2):
"""Returns a string of `length` random letters and numbers."""
return ''.join(random.choice(string.ascii_letters + string.digits + '/.')
for x in range(length))
# Original license for md5crypt:
# Based on FreeBSD src/lib/libcrypt/crypt.c 1.2
#
# "THE BEER-WARE LICENSE" (Revision 42):
# <phk@login.dknet.dk> wrote this file. As long as you retain this notice you
# can do whatever you want with this stuff. If we meet some day, and you think
# this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
def md5crypt(password, salt, magic='$1$'):
"""Based on FreeBSD src/lib/libcrypt/crypt.c 1.2
:param password: the plain text password to crypt
:param salt: the raw salt
:param magic: our magic string
"""
magic_arg = magic
salt_arg = salt
password = to_utf8(password)
magic = to_utf8(magic)
salt = to_utf8(salt)
# /* The password first, since that is what is most unknown */
# /* Then our magic string */
# /* Then the raw salt */
m = hashlib.md5(password + magic + salt)
# /* Then just as many characters of the MD5(pw,salt,pw) */
mixin = hashlib.md5(password + salt + password).digest()
m.update(bytes(mixin[i % 16] for i in range(len(password))))
# /* Then something really weird... */
# Also really broken, as far as I can tell. -m
def iter_password_or_zero():
i = len(password)
while i:
if i & 1:
yield 0
else:
yield password[0]
i >>= 1
m.update(bytes(iter_password_or_zero()))
final = m.digest()
# /* and now, just to make sure things don't run too fast */
for i in range(1000):
m2 = hashlib.md5()
if i & 1:
m2.update(password)
else:
m2.update(final)
if i % 3:
m2.update(salt)
if i % 7:
m2.update(password)
if i & 1:
m2.update(final)
else:
m2.update(password)
final = m2.digest()
# This is the bit that uses to64() in the original code.
def iter_ito64(value):
itoa64 = b'./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' \
b'abcdefghijklmnopqrstuvwxyz'
for a, b, c in ((0, 6, 12), (1, 7, 13), (2, 8, 14), (3, 9, 15),
(4, 10, 5)):
v = final[a] << 16 | final[b] << 8 | final[c]
for i in range(4):
yield itoa64[v & 0x3f]
v >>= 6
v = final[11]
for i in range(2):
yield itoa64[v & 0x3f]
v >>= 6
return magic_arg + salt_arg + '$' + str(bytes(iter_ito64(final)), 'ascii')
# -- data structures
class Ranges(object):
"""Holds information about ranges parsed from a string
:author: Tim Hatch
>>> x = Ranges("1,2,9-15")
>>> 1 in x
True
>>> 5 in x
False
>>> 10 in x
True
>>> 16 in x
False
>>> [i for i in range(20) if i in x]
[1, 2, 9, 10, 11, 12, 13, 14, 15]
Also supports iteration, which makes that last example a bit simpler:
>>> list(x)
[1, 2, 9, 10, 11, 12, 13, 14, 15]
Note that it automatically reduces the list and short-circuits when the
desired ranges are a relatively small portion of the entire set:
>>> x = Ranges("99")
>>> 1 in x # really fast
False
>>> x = Ranges("1, 2, 1-2, 2") # reduces this to 1-2
>>> x.pairs
[(1, 2)]
>>> x = Ranges("1-9,2-4") # handle ranges that completely overlap
>>> list(x)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
The members 'a' and 'b' refer to the min and max value of the range, and
are None if the range is empty:
>>> x.a
1
>>> x.b
9
>>> e = Ranges()
>>> e.a, e.b
(None, None)
Empty ranges are ok, and ranges can be constructed in pieces, if you
so choose:
>>> x = Ranges()
>>> x.appendrange("1, 2, 3")
>>> x.appendrange("5-9")
>>> x.appendrange("2-3") # reduce'd away
>>> list(x)
[1, 2, 3, 5, 6, 7, 8, 9]
Reversed ranges are ignored, unless the Ranges has the `reorder` property
set.
>>> str(Ranges("20-10"))
''
>>> str(Ranges("20-10", reorder=True))
'10-20'
As rendered ranges are often using ',\u200b' (comma + Zero-width
space) to enable wrapping, we also support reading such ranges, as
they can be copy/pasted back.
>>> str(Ranges('1,\u200b3,\u200b5,\u200b6,\u200b7,\u200b9'))
'1,3,5-7,9'
"""
RE_STR = '[0-9]+(?:[-:][0-9]+)?(?:,\u200b?[0-9]+(?:[-:][0-9]+)?)*'
def __init__(self, r=None, reorder=False):
self.pairs = []
self.a = self.b = None
self.reorder = reorder
self.appendrange(r)
def appendrange(self, r):
"""Add ranges to the current one.
A range is specified as a string of the form "low-high", and
`r` can be a list of such strings, a string containing comma-separated
ranges, or `None`.
"""
if not r:
return
p = self.pairs
if isinstance(r, str):
r = re.split(',\u200b?', r)
for x in r:
try:
a, b = map(int, x.split('-', 1))
except ValueError:
a, b = int(x), int(x)
if b >= a:
p.append((a, b))
elif self.reorder:
p.append((b, a))
self._reduce()
def _reduce(self):
"""Come up with the minimal representation of the ranges"""
p = self.pairs
p.sort()
i = 0
while i + 1 < len(p):
if p[i+1][0]-1 <= p[i][1]: # this item overlaps with the next
# make the first include the second
p[i] = (p[i][0], max(p[i][1], p[i+1][1]))
del p[i+1] # delete the second, after adjusting my endpoint
else:
i += 1
if p:
self.a = p[0][0] # min value
self.b = p[-1][1] # max value
else:
self.a = self.b = None
def __iter__(self):
"""
This is another way I came up with to do it. Is it faster?
from itertools import chain
return chain(*[range(a, b+1) for a, b in self.pairs])
"""
for a, b in self.pairs:
for i in range(a, b+1):
yield i
def __contains__(self, x):
"""
>>> 55 in Ranges()
False
"""
# short-circuit if outside the possible range
if self.a is not None and self.a <= x <= self.b:
for a, b in self.pairs:
if a <= x <= b:
return True
if b > x: # short-circuit if we've gone too far
break
return False
def __str__(self):
"""Provide a compact string representation of the range.
>>> (str(Ranges("1,2,3,5")), str(Ranges()), str(Ranges('2')))
('1-3,5', '', '2')
>>> str(Ranges('99-1')) # only nondecreasing ranges allowed
''
"""
r = []
for a, b in self.pairs:
if a == b:
r.append(str(a))
else:
r.append("%d-%d" % (a, b))
return ",".join(r)
def __len__(self):
"""The length of the entire span, ignoring holes.
>>> (len(Ranges('99')), len(Ranges('1-2')), len(Ranges('')))
(1, 2, 0)
"""
if self.a is None or self.b is None:
return 0
# Result must fit an int
return min(self.b - self.a + 1, sys.maxsize)
def __nonzero__(self):
"""Return True iff the range is not empty.
>>> (bool(Ranges()), bool(Ranges('1-2')))
(False, True)
"""
return self.a is not None and self.b is not None
def truncate(self, max):
"""Truncate the Ranges by setting a maximal allowed value.
Note that this `max` can be a value in a gap, so the only guarantee
is that `self.b` will be lesser than or equal to `max`.
>>> r = Ranges("10-20,25-45")
>>> str(r.truncate(30))
'10-20,25-30'
>>> str(r.truncate(22))
'10-20'
>>> str(r.truncate(10))
'10'
"""
r = Ranges()
r.a, r.b, r.reorder = self.a, self.b, self.reorder
r.pairs = []
for a, b in self.pairs:
if a <= max:
if b > max:
r.pairs.append((a, max))
r.b = max
break
r.pairs.append((a, b))
else:
break
return r
def to_ranges(revs):
"""Converts a list of revisions to a minimal set of ranges.
>>> to_ranges([2, 12, 3, 6, 9, 1, 5, 11])
'1-3,5-6,9,11-12'
>>> to_ranges([])
''
"""
ranges = []
begin = end = None
def store():
if end == begin:
ranges.append(str(begin))
else:
ranges.append('%d-%d' % (begin, end))
for rev in sorted(revs):
if begin is None:
begin = end = rev
elif rev == end + 1:
end = rev
else:
store()
begin = end = rev
if begin is not None:
store()
return ','.join(ranges)
class lazy(object):
"""A lazily-evaluated attribute.
:since: 1.0
"""
def __init__(self, fn):
self.fn = fn
functools.update_wrapper(self, fn)
def __get__(self, instance, owner):
if instance is None:
return self
if self.fn.__name__ in instance.__dict__:
return instance.__dict__[self.fn.__name__]
result = self.fn(instance)
instance.__dict__[self.fn.__name__] = result
return result
def __set__(self, instance, value):
instance.__dict__[self.fn.__name__] = value
def __delete__(self, instance):
if self.fn.__name__ in instance.__dict__:
del instance.__dict__[self.fn.__name__]
# -- algorithmic utilities
DIGITS = re.compile(r'(\d+)')
def embedded_numbers(s):
"""Comparison function for natural order sorting based on
http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/214202."""
pieces = DIGITS.split(s)
pieces[1::2] = map(int, pieces[1::2])
return pieces
def partition(iterable, order=None):
"""
>>> rv = partition([(1, "a"), (2, "b"), (3, "a")])
>>> rv == {'a': [1, 3], 'b': [2]}
True
>>> partition([(1, "a"), (2, "b"), (3, "a")], "ab")
[[1, 3], [2]]
"""
result = {}
if order is not None:
for key in order:
result[key] = []
for item, category in iterable:
result.setdefault(category, []).append(item)
if order is None:
return result
return [result[key] for key in order]
def _as_numeric(numeric_type, s, default, min, max):
try:
value = numeric_type(s)
except (TypeError, ValueError):
return default
if min is not None and value < min:
value = numeric_type(min) # cast to ensure proper type
if max is not None and value > max:
value = numeric_type(max) # cast to ensure proper type
return value
def as_int(s, default=None, min=None, max=None):
"""Convert s to an int and limit it to the given range, or return default
if unsuccessful.
:since 1.3.6: the default value of the `default` argument is `None`
"""
return _as_numeric(int, s, default, min, max)
def as_float(s, default=None, min=None, max=None):
"""Convert s to a float and limit it to the given range, or return default
if unsuccessful.
:since: 1.3.6
"""
return _as_numeric(float, s, default, min, max)
def as_bool(value, default=False):
"""Convert the given value to a `bool`.
If `value` is a string, return `True` for any of "yes", "true",
"enabled", "on" or non-zero numbers, ignoring case. For non-string
arguments, return the argument converted to a `bool`, or `default`
if the conversion fails.
:since 1.2: the `default` argument can be specified.
"""
if isinstance(value, str):
try:
return bool(float(value))
except ValueError:
value = value.strip().lower()
if value in ('yes', 'true', 'enabled', 'on'):
return True
elif value in ('no', 'false', 'disabled', 'off'):
return False
else:
return default
try:
return bool(value)
except (TypeError, ValueError):
return default
def pathjoin(*args):
"""Strip `/` from the arguments and join them with a single `/`."""
return '/'.join(filter(None, (each.strip('/') for each in args if each)))
def to_list(splittable, sep=','):
r"""Split a string at `sep` and return a list without any empty items.
>>> to_list('1,2, 3,4 ')
['1', '2', '3', '4']
>>> to_list('1;2; 3;4 ', sep=';')
['1', '2', '3', '4']
>>> to_list('1,2;3 4 ', sep=r'[,;\s]+')
['1', '2', '3', '4']
>>> to_list('')
[]
>>> to_list(None)
[]
>>> to_list([])
[]
:since 1.3.6: the `sep` argument may be a regular expression
"""
if not splittable:
return []
split = [x.strip() for x in re.split(sep, splittable)]
return [item for item in split if item]
def sub_val(the_list, item_to_remove, item_to_add):
"""Substitute an item if the item is found in a list, otherwise leave
the list unmodified.
"""
try:
index = the_list.index(item_to_remove)
except ValueError:
pass
else:
the_list[index] = item_to_add
__no_apidoc__ = 'compat presentation translation'