зеркало из https://github.com/mozilla/gecko-dev.git
Bug 1766497: Remove unused `virtualenv` package r=ahal
Now that Python's stdlib `venv` is used, `virtualenv` is no longer needed. Since mozharness depends on the wheels for `setuptools` and `pip`, and they were vendored within `virtualenv` we must move them somewhere else. I've chosen to add `third_party/python/venv/wheels` to hold those wheels now that `virtualenv` is no longer there. Depends on D145786 Differential Revision: https://phabricator.services.mozilla.com/D145787
This commit is contained in:
Alex Hochheiden
Родитель
4e98bd4b18
Коммит
fbe0d1ecd7
|
|
@ -298,7 +298,7 @@ ARCHIVE_FILES = {
|
||||||
{
|
{
|
||||||
"source": buildconfig.topsrcdir,
|
"source": buildconfig.topsrcdir,
|
||||||
"base": "",
|
"base": "",
|
||||||
"pattern": "third_party/python/virtualenv/**",
|
"pattern": "third_party/python/_venv/**",
|
||||||
},
|
},
|
||||||
{
|
{
|
||||||
"source": buildconfig.topsrcdir,
|
"source": buildconfig.topsrcdir,
|
||||||
|
|
|
||||||
|
|
@ -163,9 +163,8 @@ def _purge_vendor_dir(vendor_dir):
|
||||||
"dlmanager",
|
"dlmanager",
|
||||||
# gyp's package on PyPI doesn't have any downloadable files.
|
# gyp's package on PyPI doesn't have any downloadable files.
|
||||||
"gyp",
|
"gyp",
|
||||||
# We manage installing "virtualenv" package manually, and we have a custom
|
# We keep some wheels vendored in "_venv" for use in Mozharness
|
||||||
# "virtualenv.py" entry module.
|
"_venv",
|
||||||
"virtualenv",
|
|
||||||
# We manage vendoring "vsdownload" with a moz.yaml file (there is no module
|
# We manage vendoring "vsdownload" with a moz.yaml file (there is no module
|
||||||
# on PyPI).
|
# on PyPI).
|
||||||
"vsdownload",
|
"vsdownload",
|
||||||
|
|
|
||||||
|
|
@ -478,22 +478,16 @@ class VirtualenvMixin(object):
|
||||||
src_dir
|
src_dir
|
||||||
/ "third_party"
|
/ "third_party"
|
||||||
/ "python"
|
/ "python"
|
||||||
/ "virtualenv"
|
/ "_venv"
|
||||||
/ "virtualenv"
|
|
||||||
/ "seed"
|
|
||||||
/ "wheels"
|
/ "wheels"
|
||||||
/ "embed"
|
|
||||||
/ "pip-21.2.3-py3-none-any.whl"
|
/ "pip-21.2.3-py3-none-any.whl"
|
||||||
)
|
)
|
||||||
setuptools_wheel_path = (
|
setuptools_wheel_path = (
|
||||||
src_dir
|
src_dir
|
||||||
/ "third_party"
|
/ "third_party"
|
||||||
/ "python"
|
/ "python"
|
||||||
/ "virtualenv"
|
/ "_venv"
|
||||||
/ "virtualenv"
|
|
||||||
/ "seed"
|
|
||||||
/ "wheels"
|
/ "wheels"
|
||||||
/ "embed"
|
|
||||||
/ "setuptools-51.2.0-py3-none-any.whl"
|
/ "setuptools-51.2.0-py3-none-any.whl"
|
||||||
)
|
)
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -1,10 +0,0 @@
|
||||||
The contents of this directory are extracted from virtualenv.pyz as downloaded
|
|
||||||
from https://bootstrap.pypa.io/virtualenv.pyz.
|
|
||||||
|
|
||||||
The virtualenv.py script is a wrapper that should be preserved and allows to
|
|
||||||
use the extracted virtualenv.pyz as-is.
|
|
||||||
|
|
||||||
It is not vendored via `mach vendor` because that would require a larger wrapper
|
|
||||||
script that handles the same things as the zipapp already does, picking the right
|
|
||||||
dependencies to add to the PYTHONPATH depending on the python version.
|
|
||||||
|
|
||||||
|
|
@ -1,168 +0,0 @@
|
||||||
import json
|
|
||||||
import os
|
|
||||||
import sys
|
|
||||||
import zipfile
|
|
||||||
|
|
||||||
ABS_HERE = os.path.abspath(os.path.dirname(__file__))
|
|
||||||
NEW_IMPORT_SYSTEM = sys.version_info[0] == 3
|
|
||||||
|
|
||||||
|
|
||||||
class VersionPlatformSelect(object):
|
|
||||||
def __init__(self):
|
|
||||||
self.archive = ABS_HERE
|
|
||||||
self._zip_file = zipfile.ZipFile(ABS_HERE, "r")
|
|
||||||
self.modules = self._load("modules.json")
|
|
||||||
self.distributions = self._load("distributions.json")
|
|
||||||
self.__cache = {}
|
|
||||||
|
|
||||||
def _load(self, of_file):
|
|
||||||
version = ".".join(str(i) for i in sys.version_info[0:2])
|
|
||||||
per_version = json.loads(self.get_data(of_file).decode("utf-8"))
|
|
||||||
all_platforms = per_version[version] if version in per_version else per_version["3.9"]
|
|
||||||
content = all_platforms.get("==any", {}) # start will all platforms
|
|
||||||
not_us = "!={}".format(sys.platform)
|
|
||||||
for key, value in all_platforms.items(): # now override that with not platform
|
|
||||||
if key.startswith("!=") and key != not_us:
|
|
||||||
content.update(value)
|
|
||||||
content.update(all_platforms.get("=={}".format(sys.platform), {})) # and finish it off with our platform
|
|
||||||
return content
|
|
||||||
|
|
||||||
def __enter__(self):
|
|
||||||
return self
|
|
||||||
|
|
||||||
def __exit__(self, exc_type, exc_val, exc_tb):
|
|
||||||
self._zip_file.close()
|
|
||||||
|
|
||||||
def find_mod(self, fullname):
|
|
||||||
if fullname in self.modules:
|
|
||||||
result = self.modules[fullname]
|
|
||||||
return result
|
|
||||||
|
|
||||||
def get_filename(self, fullname):
|
|
||||||
zip_path = self.find_mod(fullname)
|
|
||||||
return None if zip_path is None else os.path.join(ABS_HERE, zip_path)
|
|
||||||
|
|
||||||
def get_data(self, filename):
|
|
||||||
if filename.startswith(ABS_HERE):
|
|
||||||
# keep paths relative from the zipfile
|
|
||||||
filename = filename[len(ABS_HERE) + 1 :]
|
|
||||||
filename = filename.lstrip(os.sep)
|
|
||||||
if sys.platform == "win32":
|
|
||||||
# paths within the zipfile is always /, fixup on Windows to transform \ to /
|
|
||||||
filename = "/".join(filename.split(os.sep))
|
|
||||||
with self._zip_file.open(filename) as file_handler:
|
|
||||||
return file_handler.read()
|
|
||||||
|
|
||||||
def find_distributions(self, context):
|
|
||||||
dist_class = versioned_distribution_class()
|
|
||||||
name = context.name
|
|
||||||
if name in self.distributions:
|
|
||||||
result = dist_class(file_loader=self.get_data, dist_path=self.distributions[name])
|
|
||||||
yield result
|
|
||||||
|
|
||||||
def __repr__(self):
|
|
||||||
return "{}(path={})".format(self.__class__.__name__, ABS_HERE)
|
|
||||||
|
|
||||||
def _register_distutils_finder(self):
|
|
||||||
if "distlib" not in self.modules:
|
|
||||||
return
|
|
||||||
|
|
||||||
class DistlibFinder(object):
|
|
||||||
def __init__(self, path, loader):
|
|
||||||
self.path = path
|
|
||||||
self.loader = loader
|
|
||||||
|
|
||||||
def find(self, name):
|
|
||||||
class Resource(object):
|
|
||||||
def __init__(self, content):
|
|
||||||
self.bytes = content
|
|
||||||
|
|
||||||
full_path = os.path.join(self.path, name)
|
|
||||||
return Resource(self.loader.get_data(full_path))
|
|
||||||
|
|
||||||
# noinspection PyPackageRequirements
|
|
||||||
from distlib.resources import register_finder
|
|
||||||
|
|
||||||
register_finder(self, lambda module: DistlibFinder(os.path.dirname(module.__file__), self))
|
|
||||||
|
|
||||||
|
|
||||||
_VER_DISTRIBUTION_CLASS = None
|
|
||||||
|
|
||||||
|
|
||||||
def versioned_distribution_class():
|
|
||||||
global _VER_DISTRIBUTION_CLASS
|
|
||||||
if _VER_DISTRIBUTION_CLASS is None:
|
|
||||||
if sys.version_info >= (3, 8):
|
|
||||||
# noinspection PyCompatibility
|
|
||||||
from importlib.metadata import Distribution
|
|
||||||
else:
|
|
||||||
# noinspection PyUnresolvedReferences
|
|
||||||
from importlib_metadata import Distribution
|
|
||||||
|
|
||||||
class VersionedDistribution(Distribution):
|
|
||||||
def __init__(self, file_loader, dist_path):
|
|
||||||
self.file_loader = file_loader
|
|
||||||
self.dist_path = dist_path
|
|
||||||
|
|
||||||
def read_text(self, filename):
|
|
||||||
return self.file_loader(self.locate_file(filename)).decode("utf-8")
|
|
||||||
|
|
||||||
def locate_file(self, path):
|
|
||||||
return os.path.join(self.dist_path, path)
|
|
||||||
|
|
||||||
_VER_DISTRIBUTION_CLASS = VersionedDistribution
|
|
||||||
return _VER_DISTRIBUTION_CLASS
|
|
||||||
|
|
||||||
|
|
||||||
if NEW_IMPORT_SYSTEM:
|
|
||||||
# noinspection PyCompatibility
|
|
||||||
# noinspection PyCompatibility
|
|
||||||
from importlib.abc import SourceLoader
|
|
||||||
from importlib.util import spec_from_file_location
|
|
||||||
|
|
||||||
class VersionedFindLoad(VersionPlatformSelect, SourceLoader):
|
|
||||||
def find_spec(self, fullname, path, target=None):
|
|
||||||
zip_path = self.find_mod(fullname)
|
|
||||||
if zip_path is not None:
|
|
||||||
spec = spec_from_file_location(name=fullname, loader=self)
|
|
||||||
return spec
|
|
||||||
|
|
||||||
def module_repr(self, module):
|
|
||||||
raise NotImplementedError
|
|
||||||
|
|
||||||
|
|
||||||
else:
|
|
||||||
# noinspection PyDeprecation
|
|
||||||
from imp import new_module
|
|
||||||
|
|
||||||
class VersionedFindLoad(VersionPlatformSelect):
|
|
||||||
def find_module(self, fullname, path=None):
|
|
||||||
return self if self.find_mod(fullname) else None
|
|
||||||
|
|
||||||
def load_module(self, fullname):
|
|
||||||
filename = self.get_filename(fullname)
|
|
||||||
code = self.get_data(filename)
|
|
||||||
mod = sys.modules.setdefault(fullname, new_module(fullname))
|
|
||||||
mod.__file__ = filename
|
|
||||||
mod.__loader__ = self
|
|
||||||
is_package = filename.endswith("__init__.py")
|
|
||||||
if is_package:
|
|
||||||
mod.__path__ = [os.path.dirname(filename)]
|
|
||||||
mod.__package__ = fullname
|
|
||||||
else:
|
|
||||||
mod.__package__ = fullname.rpartition(".")[0]
|
|
||||||
exec(code, mod.__dict__)
|
|
||||||
return mod
|
|
||||||
|
|
||||||
|
|
||||||
def run():
|
|
||||||
with VersionedFindLoad() as finder:
|
|
||||||
sys.meta_path.insert(0, finder)
|
|
||||||
finder._register_distutils_finder()
|
|
||||||
from virtualenv.__main__ import run as run_virtualenv
|
|
||||||
|
|
||||||
run_virtualenv()
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
run()
|
|
||||||
|
|
@ -1,19 +0,0 @@
|
||||||
Copyright Jason R. Coombs
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
of this software and associated documentation files (the "Software"), to
|
|
||||||
deal in the Software without restriction, including without limitation the
|
|
||||||
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
||||||
sell copies of the Software, and to permit persons to whom the Software is
|
|
||||||
furnished to do so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in
|
|
||||||
all copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
||||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
||||||
IN THE SOFTWARE.
|
|
||||||
|
|
@ -1,67 +0,0 @@
|
||||||
Metadata-Version: 2.1
|
|
||||||
Name: backports.entry-points-selectable
|
|
||||||
Version: 1.1.0
|
|
||||||
Summary: Compatibility shim providing selectable entry points for older implementations
|
|
||||||
Home-page: https://github.com/jaraco/backports.entry_points_selectable
|
|
||||||
Author: Jason R. Coombs
|
|
||||||
Author-email: jaraco@jaraco.com
|
|
||||||
License: UNKNOWN
|
|
||||||
Platform: UNKNOWN
|
|
||||||
Classifier: Development Status :: 5 - Production/Stable
|
|
||||||
Classifier: Intended Audience :: Developers
|
|
||||||
Classifier: License :: OSI Approved :: MIT License
|
|
||||||
Classifier: Programming Language :: Python :: 3
|
|
||||||
Classifier: Programming Language :: Python :: 2
|
|
||||||
Requires-Python: >=2.7
|
|
||||||
License-File: LICENSE
|
|
||||||
Requires-Dist: importlib-metadata ; python_version < "3.8"
|
|
||||||
Provides-Extra: docs
|
|
||||||
Requires-Dist: sphinx ; extra == 'docs'
|
|
||||||
Requires-Dist: jaraco.packaging (>=8.2) ; extra == 'docs'
|
|
||||||
Requires-Dist: rst.linker (>=1.9) ; extra == 'docs'
|
|
||||||
Provides-Extra: testing
|
|
||||||
Requires-Dist: pytest (>=4.6) ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-flake8 ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-cov ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-black (>=0.3.7) ; (platform_python_implementation != "PyPy" and python_version < "3.10") and extra == 'testing'
|
|
||||||
Requires-Dist: pytest-mypy ; (platform_python_implementation != "PyPy" and python_version < "3.10" and python_version >= "3") and extra == 'testing'
|
|
||||||
Requires-Dist: pytest-checkdocs (>=2.4) ; (python_version >= "3") and extra == 'testing'
|
|
||||||
Requires-Dist: pytest-enabler (>=1.0.1) ; (python_version >= "3") and extra == 'testing'
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/pypi/v/backports.entry_points_selectable.svg
|
|
||||||
:target: `PyPI link`_
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/pypi/pyversions/backports.entry_points_selectable.svg
|
|
||||||
:target: `PyPI link`_
|
|
||||||
|
|
||||||
.. _PyPI link: https://pypi.org/project/backports.entry_points_selectable
|
|
||||||
|
|
||||||
.. image:: https://github.com/jaraco/backports.entry_points_selectable/workflows/tests/badge.svg
|
|
||||||
:target: https://github.com/jaraco/backports.entry_points_selectable/actions?query=workflow%3A%22tests%22
|
|
||||||
:alt: tests
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
|
|
||||||
:target: https://github.com/psf/black
|
|
||||||
:alt: Code style: Black
|
|
||||||
|
|
||||||
.. .. image:: https://readthedocs.org/projects/skeleton/badge/?version=latest
|
|
||||||
.. :target: https://skeleton.readthedocs.io/en/latest/?badge=latest
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/badge/skeleton-2021-informational
|
|
||||||
:target: https://blog.jaraco.com/skeleton
|
|
||||||
|
|
||||||
Compatibility shim to ease adoption of `importlib_metadata 3.6 <https://importlib-metadata.readthedocs.io/en/latest/history.html#v3-6-0>`_. Supplies forward-compatibility of "selectable" entry points even on older versions of ``importlib_metadata`` and ``importlib.metadata``, and avoids usage that triggers `deprecation warnings <https://github.com/python/importlib_metadata/issues/298>`_.
|
|
||||||
|
|
||||||
Use this shim for libraries or applications invoking ``entry_points()`` that run on Python older than 3.10 or where importlib_metadata is older than 3.6. In most cases, this shim is unnecessary and the easiest thing to do is simply require ``importlib_metadata >= 3.6`` on all Pythons (or only those prior to 3.10a7). In some environments, a library may be constrained on which versions of ``importlib_metadata`` can be required, so this library bridges that gap.
|
|
||||||
|
|
||||||
To use this shim, add ``backports.entry_points_selectable`` to your project requirements. It will require ``importlib_metadata`` automatically where needed (prior to Python 3.8) but be satisfied by older versions. Projects should still require ``importlib_metadata`` as appropriate for API uses other than for ``entry_points``.
|
|
||||||
|
|
||||||
Then in code, instead of ``from importlib.metadata import entry_points``, use::
|
|
||||||
|
|
||||||
from backports.entry_points_selectable import entry_points
|
|
||||||
|
|
||||||
And then use the "selectable" features (pass keyword arguments to ``entry_points`` or invoke ``.select()`` on the result).
|
|
||||||
|
|
||||||
This backport has a very lenient dependency on `importlib_metadata` for older Pythons and is a single module implementation. If adding a dependency is a concern, this module may be vendored into the downstream project.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,7 +0,0 @@
|
||||||
backports/__init__.py,sha256=iOEMwnlORWezdO8-2vxBIPSR37D7JGjluZ8f55vzxls,81
|
|
||||||
backports/entry_points_selectable.py,sha256=p6WRKhYFNocmWtTassxkXAbSwyqO01hJMq60y4rPyxE,7444
|
|
||||||
backports.entry_points_selectable-1.1.0.dist-info/LICENSE,sha256=2z8CRrH5J48VhFuZ_sR4uLUG63ZIeZNyL4xuJUKF-vg,1050
|
|
||||||
backports.entry_points_selectable-1.1.0.dist-info/METADATA,sha256=A4EQx2Qnr7lDwW92E5aD2w1pr4Fq_EpcxVjO5l-4KUg,4078
|
|
||||||
backports.entry_points_selectable-1.1.0.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
|
|
||||||
backports.entry_points_selectable-1.1.0.dist-info/top_level.txt,sha256=cGjaLMOoBR1FK0ApojtzWVmViTtJ7JGIK_HwXiEsvtU,10
|
|
||||||
backports.entry_points_selectable-1.1.0.dist-info/RECORD,,
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
Wheel-Version: 1.0
|
|
||||||
Generator: bdist_wheel (0.36.2)
|
|
||||||
Root-Is-Purelib: true
|
|
||||||
Tag: py2-none-any
|
|
||||||
Tag: py3-none-any
|
|
||||||
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
backports
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
__path__ = __import__('pkgutil').extend_path(__path__, __name__) # type: ignore
|
|
||||||
|
|
@ -1,275 +0,0 @@
|
||||||
"""
|
|
||||||
>>> hasattr(entry_points(), 'select')
|
|
||||||
True
|
|
||||||
>>> tuple(entry_points(group='console_scripts'))
|
|
||||||
(...)
|
|
||||||
|
|
||||||
Some usage is deprecated and may emit deprecation warnings
|
|
||||||
on later versions.
|
|
||||||
|
|
||||||
>>> import warnings
|
|
||||||
>>> warnings.filterwarnings('ignore', category=DeprecationWarning)
|
|
||||||
|
|
||||||
>>> entry_points()['console_scripts'][0]
|
|
||||||
EntryPoint...(...)
|
|
||||||
"""
|
|
||||||
|
|
||||||
import collections
|
|
||||||
import textwrap
|
|
||||||
import itertools
|
|
||||||
import operator
|
|
||||||
import functools
|
|
||||||
|
|
||||||
try:
|
|
||||||
from itertools import filterfalse # type: ignore
|
|
||||||
except ImportError:
|
|
||||||
from itertools import ifilterfalse as filterfalse # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
# prefer importlib_metadata if it has EntryPoints
|
|
||||||
import importlib_metadata as metadata # type: ignore
|
|
||||||
|
|
||||||
if not hasattr(metadata, 'EntryPoints'):
|
|
||||||
raise ImportError("package without EntryPoints")
|
|
||||||
from importlib_metadata import distributions, EntryPoint # type: ignore
|
|
||||||
except ImportError:
|
|
||||||
try:
|
|
||||||
import importlib.metadata as metadata # type: ignore
|
|
||||||
from importlib.metadata import distributions, EntryPoint # type: ignore
|
|
||||||
except ImportError:
|
|
||||||
from importlib_metadata import distributions, EntryPoint # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
__all__ = ['entry_points']
|
|
||||||
|
|
||||||
|
|
||||||
def unique_everseen(iterable, key=None):
|
|
||||||
"List unique elements, preserving order. Remember all elements ever seen."
|
|
||||||
# unique_everseen('AAAABBBCCDAABBB') --> A B C D
|
|
||||||
# unique_everseen('ABBCcAD', str.lower) --> A B C D
|
|
||||||
seen = set()
|
|
||||||
seen_add = seen.add
|
|
||||||
if key is None:
|
|
||||||
for element in filterfalse(seen.__contains__, iterable):
|
|
||||||
seen_add(element)
|
|
||||||
yield element
|
|
||||||
else:
|
|
||||||
for element in iterable:
|
|
||||||
k = key(element)
|
|
||||||
if k not in seen:
|
|
||||||
seen_add(k)
|
|
||||||
yield element
|
|
||||||
|
|
||||||
|
|
||||||
class Pair(collections.namedtuple('Pair', 'name value')):
|
|
||||||
@classmethod
|
|
||||||
def parse(cls, text):
|
|
||||||
return cls(*map(str.strip, text.split("=", 1)))
|
|
||||||
|
|
||||||
|
|
||||||
class Sectioned:
|
|
||||||
"""
|
|
||||||
A simple entry point config parser for performance
|
|
||||||
|
|
||||||
>>> for item in Sectioned.read(Sectioned._sample):
|
|
||||||
... print(item)
|
|
||||||
Pair(name='sec1', value='# comments ignored')
|
|
||||||
Pair(name='sec1', value='a = 1')
|
|
||||||
Pair(name='sec1', value='b = 2')
|
|
||||||
Pair(name='sec2', value='a = 2')
|
|
||||||
|
|
||||||
>>> res = Sectioned.section_pairs(Sectioned._sample)
|
|
||||||
>>> item = next(res)
|
|
||||||
>>> item.name
|
|
||||||
'sec1'
|
|
||||||
>>> item.value
|
|
||||||
Pair(name='a', value='1')
|
|
||||||
>>> item = next(res)
|
|
||||||
>>> item.value
|
|
||||||
Pair(name='b', value='2')
|
|
||||||
>>> item = next(res)
|
|
||||||
>>> item.name
|
|
||||||
'sec2'
|
|
||||||
>>> item.value
|
|
||||||
Pair(name='a', value='2')
|
|
||||||
>>> list(res)
|
|
||||||
[]
|
|
||||||
"""
|
|
||||||
|
|
||||||
_sample = textwrap.dedent(
|
|
||||||
"""
|
|
||||||
[sec1]
|
|
||||||
# comments ignored
|
|
||||||
a = 1
|
|
||||||
b = 2
|
|
||||||
|
|
||||||
[sec2]
|
|
||||||
a = 2
|
|
||||||
"""
|
|
||||||
).lstrip()
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def section_pairs(cls, text):
|
|
||||||
return (
|
|
||||||
section._replace(value=Pair.parse(section.value))
|
|
||||||
for section in cls.read(text, filter_=cls.valid)
|
|
||||||
if section.name is not None
|
|
||||||
)
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def read(text, filter_=None):
|
|
||||||
lines = filter(filter_, map(str.strip, text.splitlines()))
|
|
||||||
name = None
|
|
||||||
for value in lines:
|
|
||||||
section_match = value.startswith('[') and value.endswith(']')
|
|
||||||
if section_match:
|
|
||||||
name = value.strip('[]')
|
|
||||||
continue
|
|
||||||
yield Pair(name, value)
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def valid(line):
|
|
||||||
return line and not line.startswith('#')
|
|
||||||
|
|
||||||
|
|
||||||
def compat_matches(ep, **params):
|
|
||||||
try:
|
|
||||||
return ep.matches(**params)
|
|
||||||
except AttributeError:
|
|
||||||
pass
|
|
||||||
attrs = (getattr(ep, param) for param in params)
|
|
||||||
return all(map(operator.eq, params.values(), attrs))
|
|
||||||
|
|
||||||
|
|
||||||
class EntryPoints(list):
|
|
||||||
"""
|
|
||||||
An immutable collection of selectable EntryPoint objects.
|
|
||||||
"""
|
|
||||||
|
|
||||||
__slots__ = ()
|
|
||||||
|
|
||||||
def __getitem__(self, name): # -> EntryPoint:
|
|
||||||
"""
|
|
||||||
Get the EntryPoint in self matching name.
|
|
||||||
"""
|
|
||||||
if isinstance(name, int):
|
|
||||||
return super(EntryPoints, self).__getitem__(name)
|
|
||||||
try:
|
|
||||||
return next(iter(self.select(name=name)))
|
|
||||||
except StopIteration:
|
|
||||||
raise KeyError(name)
|
|
||||||
|
|
||||||
def select(self, **params):
|
|
||||||
"""
|
|
||||||
Select entry points from self that match the
|
|
||||||
given parameters (typically group and/or name).
|
|
||||||
"""
|
|
||||||
return EntryPoints(ep for ep in self if compat_matches(ep, **params))
|
|
||||||
|
|
||||||
@property
|
|
||||||
def names(self):
|
|
||||||
"""
|
|
||||||
Return the set of all names of all entry points.
|
|
||||||
"""
|
|
||||||
return set(ep.name for ep in self)
|
|
||||||
|
|
||||||
@property
|
|
||||||
def groups(self):
|
|
||||||
"""
|
|
||||||
Return the set of all groups of all entry points.
|
|
||||||
|
|
||||||
For coverage while SelectableGroups is present.
|
|
||||||
>>> EntryPoints().groups
|
|
||||||
set(...)
|
|
||||||
"""
|
|
||||||
return set(ep.group for ep in self)
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def _from_text_for(cls, text, dist):
|
|
||||||
return cls(ep._for(dist) for ep in cls._from_text(text))
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def _from_text(cls, text):
|
|
||||||
return itertools.starmap(EntryPoint, cls._parse_groups(text or ''))
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def _parse_groups(text):
|
|
||||||
return (
|
|
||||||
(item.value.name, item.value.value, item.name)
|
|
||||||
for item in Sectioned.section_pairs(text)
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
class SelectableGroups(dict):
|
|
||||||
"""
|
|
||||||
A backward- and forward-compatible result from
|
|
||||||
entry_points that fully implements the dict interface.
|
|
||||||
"""
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def load(cls, eps):
|
|
||||||
by_group = operator.attrgetter('group')
|
|
||||||
ordered = sorted(eps, key=by_group)
|
|
||||||
grouped = itertools.groupby(ordered, by_group)
|
|
||||||
return cls((group, EntryPoints(eps)) for group, eps in grouped)
|
|
||||||
|
|
||||||
@property
|
|
||||||
def _all(self):
|
|
||||||
"""
|
|
||||||
Reconstruct a list of all entrypoints from the groups.
|
|
||||||
"""
|
|
||||||
return EntryPoints(itertools.chain.from_iterable(self.values()))
|
|
||||||
|
|
||||||
@property
|
|
||||||
def groups(self):
|
|
||||||
return self._all.groups
|
|
||||||
|
|
||||||
@property
|
|
||||||
def names(self):
|
|
||||||
"""
|
|
||||||
for coverage:
|
|
||||||
>>> SelectableGroups().names
|
|
||||||
set(...)
|
|
||||||
"""
|
|
||||||
return self._all.names
|
|
||||||
|
|
||||||
def select(self, **params):
|
|
||||||
if not params:
|
|
||||||
return self
|
|
||||||
return self._all.select(**params)
|
|
||||||
|
|
||||||
|
|
||||||
def entry_points_compat(**params):
|
|
||||||
"""Return EntryPoint objects for all installed packages.
|
|
||||||
|
|
||||||
Pass selection parameters (group or name) to filter the
|
|
||||||
result to entry points matching those properties (see
|
|
||||||
EntryPoints.select()).
|
|
||||||
|
|
||||||
For compatibility, returns ``SelectableGroups`` object unless
|
|
||||||
selection parameters are supplied. In the future, this function
|
|
||||||
will return ``EntryPoints`` instead of ``SelectableGroups``
|
|
||||||
even when no selection parameters are supplied.
|
|
||||||
|
|
||||||
For maximum future compatibility, pass selection parameters
|
|
||||||
or invoke ``.select`` with parameters on the result.
|
|
||||||
|
|
||||||
:return: EntryPoints or SelectableGroups for all installed packages.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def dist_name(dist):
|
|
||||||
return dist.metadata['Name']
|
|
||||||
|
|
||||||
unique = functools.partial(unique_everseen, key=dist_name)
|
|
||||||
eps = itertools.chain.from_iterable(
|
|
||||||
dist.entry_points for dist in unique(distributions())
|
|
||||||
)
|
|
||||||
return SelectableGroups.load(eps).select(**params)
|
|
||||||
|
|
||||||
|
|
||||||
needs_backport = not hasattr(metadata, 'EntryPoints') or issubclass(
|
|
||||||
metadata.EntryPoints, tuple
|
|
||||||
)
|
|
||||||
|
|
||||||
entry_points = entry_points_compat if needs_backport else metadata.entry_points
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
# A Python "namespace package" http://www.python.org/dev/peps/pep-0382/
|
|
||||||
# This always goes inside of a namespace package's __init__.py
|
|
||||||
|
|
||||||
from pkgutil import extend_path
|
|
||||||
|
|
||||||
__path__ = extend_path(__path__, __name__)
|
|
||||||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -1,274 +0,0 @@
|
||||||
#!/usr/bin/env python
|
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
|
|
||||||
from __future__ import absolute_import
|
|
||||||
from __future__ import division
|
|
||||||
from __future__ import print_function
|
|
||||||
from __future__ import unicode_literals
|
|
||||||
|
|
||||||
import abc
|
|
||||||
import os
|
|
||||||
|
|
||||||
try:
|
|
||||||
from collections.abc import MutableMapping
|
|
||||||
except ImportError:
|
|
||||||
from collections import MutableMapping
|
|
||||||
|
|
||||||
try:
|
|
||||||
from collections import UserDict
|
|
||||||
except ImportError:
|
|
||||||
from UserDict import UserDict
|
|
||||||
|
|
||||||
try:
|
|
||||||
from collections import OrderedDict
|
|
||||||
except ImportError:
|
|
||||||
from ordereddict import OrderedDict
|
|
||||||
|
|
||||||
try:
|
|
||||||
import pathlib
|
|
||||||
except ImportError:
|
|
||||||
pathlib = None
|
|
||||||
|
|
||||||
from io import open
|
|
||||||
import sys
|
|
||||||
|
|
||||||
try:
|
|
||||||
from thread import get_ident
|
|
||||||
except ImportError:
|
|
||||||
try:
|
|
||||||
from _thread import get_ident
|
|
||||||
except ImportError:
|
|
||||||
from _dummy_thread import get_ident
|
|
||||||
|
|
||||||
|
|
||||||
__all__ = ['UserDict', 'OrderedDict', 'open']
|
|
||||||
|
|
||||||
|
|
||||||
PY2 = sys.version_info[0] == 2
|
|
||||||
PY3 = sys.version_info[0] == 3
|
|
||||||
|
|
||||||
native_str = str
|
|
||||||
str = type('str')
|
|
||||||
|
|
||||||
|
|
||||||
def from_none(exc):
|
|
||||||
"""raise from_none(ValueError('a')) == raise ValueError('a') from None"""
|
|
||||||
exc.__cause__ = None
|
|
||||||
exc.__suppress_context__ = True
|
|
||||||
return exc
|
|
||||||
|
|
||||||
|
|
||||||
# from reprlib 3.2.1
|
|
||||||
def recursive_repr(fillvalue='...'):
|
|
||||||
'Decorator to make a repr function return fillvalue for a recursive call'
|
|
||||||
|
|
||||||
def decorating_function(user_function):
|
|
||||||
repr_running = set()
|
|
||||||
|
|
||||||
def wrapper(self):
|
|
||||||
key = id(self), get_ident()
|
|
||||||
if key in repr_running:
|
|
||||||
return fillvalue
|
|
||||||
repr_running.add(key)
|
|
||||||
try:
|
|
||||||
result = user_function(self)
|
|
||||||
finally:
|
|
||||||
repr_running.discard(key)
|
|
||||||
return result
|
|
||||||
|
|
||||||
# Can't use functools.wraps() here because of bootstrap issues
|
|
||||||
wrapper.__module__ = getattr(user_function, '__module__')
|
|
||||||
wrapper.__doc__ = getattr(user_function, '__doc__')
|
|
||||||
wrapper.__name__ = getattr(user_function, '__name__')
|
|
||||||
wrapper.__annotations__ = getattr(user_function, '__annotations__', {})
|
|
||||||
return wrapper
|
|
||||||
|
|
||||||
return decorating_function
|
|
||||||
|
|
||||||
|
|
||||||
# from collections 3.2.1
|
|
||||||
class _ChainMap(MutableMapping):
|
|
||||||
''' A ChainMap groups multiple dicts (or other mappings) together
|
|
||||||
to create a single, updateable view.
|
|
||||||
|
|
||||||
The underlying mappings are stored in a list. That list is public and can
|
|
||||||
accessed or updated using the *maps* attribute. There is no other state.
|
|
||||||
|
|
||||||
Lookups search the underlying mappings successively until a key is found.
|
|
||||||
In contrast, writes, updates, and deletions only operate on the first
|
|
||||||
mapping.
|
|
||||||
|
|
||||||
'''
|
|
||||||
|
|
||||||
def __init__(self, *maps):
|
|
||||||
'''Initialize a ChainMap by setting *maps* to the given mappings.
|
|
||||||
If no mappings are provided, a single empty dictionary is used.
|
|
||||||
|
|
||||||
'''
|
|
||||||
self.maps = list(maps) or [{}] # always at least one map
|
|
||||||
|
|
||||||
def __missing__(self, key):
|
|
||||||
raise KeyError(key)
|
|
||||||
|
|
||||||
def __getitem__(self, key):
|
|
||||||
for mapping in self.maps:
|
|
||||||
try:
|
|
||||||
# can't use 'key in mapping' with defaultdict
|
|
||||||
return mapping[key]
|
|
||||||
except KeyError:
|
|
||||||
pass
|
|
||||||
# support subclasses that define __missing__
|
|
||||||
return self.__missing__(key)
|
|
||||||
|
|
||||||
def get(self, key, default=None):
|
|
||||||
return self[key] if key in self else default
|
|
||||||
|
|
||||||
def __len__(self):
|
|
||||||
# reuses stored hash values if possible
|
|
||||||
return len(set().union(*self.maps))
|
|
||||||
|
|
||||||
def __iter__(self):
|
|
||||||
return iter(set().union(*self.maps))
|
|
||||||
|
|
||||||
def __contains__(self, key):
|
|
||||||
return any(key in m for m in self.maps)
|
|
||||||
|
|
||||||
@recursive_repr()
|
|
||||||
def __repr__(self):
|
|
||||||
return '{0.__class__.__name__}({1})'.format(
|
|
||||||
self, ', '.join(map(repr, self.maps))
|
|
||||||
)
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def fromkeys(cls, iterable, *args):
|
|
||||||
'Create a ChainMap with a single dict created from the iterable.'
|
|
||||||
return cls(dict.fromkeys(iterable, *args))
|
|
||||||
|
|
||||||
def copy(self):
|
|
||||||
"""
|
|
||||||
New ChainMap or subclass with a new copy of
|
|
||||||
maps[0] and refs to maps[1:]
|
|
||||||
"""
|
|
||||||
return self.__class__(self.maps[0].copy(), *self.maps[1:])
|
|
||||||
|
|
||||||
__copy__ = copy
|
|
||||||
|
|
||||||
def new_child(self): # like Django's Context.push()
|
|
||||||
'New ChainMap with a new dict followed by all previous maps.'
|
|
||||||
return self.__class__({}, *self.maps)
|
|
||||||
|
|
||||||
@property
|
|
||||||
def parents(self): # like Django's Context.pop()
|
|
||||||
'New ChainMap from maps[1:].'
|
|
||||||
return self.__class__(*self.maps[1:])
|
|
||||||
|
|
||||||
def __setitem__(self, key, value):
|
|
||||||
self.maps[0][key] = value
|
|
||||||
|
|
||||||
def __delitem__(self, key):
|
|
||||||
try:
|
|
||||||
del self.maps[0][key]
|
|
||||||
except KeyError:
|
|
||||||
raise KeyError('Key not found in the first mapping: {!r}'.format(key))
|
|
||||||
|
|
||||||
def popitem(self):
|
|
||||||
"""
|
|
||||||
Remove and return an item pair from maps[0].
|
|
||||||
Raise KeyError is maps[0] is empty.
|
|
||||||
"""
|
|
||||||
try:
|
|
||||||
return self.maps[0].popitem()
|
|
||||||
except KeyError:
|
|
||||||
raise KeyError('No keys found in the first mapping.')
|
|
||||||
|
|
||||||
def pop(self, key, *args):
|
|
||||||
"""
|
|
||||||
Remove *key* from maps[0] and return its value.
|
|
||||||
Raise KeyError if *key* not in maps[0].
|
|
||||||
"""
|
|
||||||
|
|
||||||
try:
|
|
||||||
return self.maps[0].pop(key, *args)
|
|
||||||
except KeyError:
|
|
||||||
raise KeyError('Key not found in the first mapping: {!r}'.format(key))
|
|
||||||
|
|
||||||
def clear(self):
|
|
||||||
'Clear maps[0], leaving maps[1:] intact.'
|
|
||||||
self.maps[0].clear()
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
from collections import ChainMap
|
|
||||||
except ImportError:
|
|
||||||
ChainMap = _ChainMap
|
|
||||||
|
|
||||||
|
|
||||||
_ABC = getattr(
|
|
||||||
abc,
|
|
||||||
'ABC',
|
|
||||||
# Python 3.3 compatibility
|
|
||||||
abc.ABCMeta(native_str('__ABC'), (object,), dict(__metaclass__=abc.ABCMeta)),
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
class _PathLike(_ABC):
|
|
||||||
|
|
||||||
"""Abstract base class for implementing the file system path protocol."""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def __fspath__(self):
|
|
||||||
"""Return the file system path representation of the object."""
|
|
||||||
raise NotImplementedError
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def __subclasshook__(cls, subclass):
|
|
||||||
return bool(
|
|
||||||
hasattr(subclass, '__fspath__')
|
|
||||||
# workaround for Python 3.5
|
|
||||||
or pathlib
|
|
||||||
and issubclass(subclass, pathlib.Path)
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
PathLike = getattr(os, 'PathLike', _PathLike)
|
|
||||||
|
|
||||||
|
|
||||||
def _fspath(path):
|
|
||||||
"""Return the path representation of a path-like object.
|
|
||||||
|
|
||||||
If str or bytes is passed in, it is returned unchanged. Otherwise the
|
|
||||||
os.PathLike interface is used to get the path representation. If the
|
|
||||||
path representation is not str or bytes, TypeError is raised. If the
|
|
||||||
provided path is not str, bytes, or os.PathLike, TypeError is raised.
|
|
||||||
"""
|
|
||||||
if isinstance(path, (str, bytes)):
|
|
||||||
return path
|
|
||||||
|
|
||||||
if not hasattr(path, '__fspath__') and isinstance(path, pathlib.Path):
|
|
||||||
# workaround for Python 3.5
|
|
||||||
return str(path)
|
|
||||||
|
|
||||||
# Work from the object's type to match method resolution of other magic
|
|
||||||
# methods.
|
|
||||||
path_type = type(path)
|
|
||||||
try:
|
|
||||||
path_repr = path_type.__fspath__(path)
|
|
||||||
except AttributeError:
|
|
||||||
|
|
||||||
if hasattr(path_type, '__fspath__'):
|
|
||||||
raise
|
|
||||||
else:
|
|
||||||
raise TypeError(
|
|
||||||
"expected str, bytes or os.PathLike object, "
|
|
||||||
"not " + path_type.__name__
|
|
||||||
)
|
|
||||||
if isinstance(path_repr, (str, bytes)):
|
|
||||||
return path_repr
|
|
||||||
else:
|
|
||||||
raise TypeError(
|
|
||||||
"expected {}.__fspath__() to return str or bytes, "
|
|
||||||
"not {}".format(path_type.__name__, type(path_repr).__name__)
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
fspath = getattr(os, 'fspath', _fspath)
|
|
||||||
|
|
@ -1,7 +0,0 @@
|
||||||
Copyright Jason R. Coombs
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
||||||
|
|
@ -1,259 +0,0 @@
|
||||||
Metadata-Version: 2.1
|
|
||||||
Name: configparser
|
|
||||||
Version: 4.0.2
|
|
||||||
Summary: Updated configparser from Python 3.7 for Python 2.6+.
|
|
||||||
Home-page: https://github.com/jaraco/configparser/
|
|
||||||
Author: Łukasz Langa
|
|
||||||
Author-email: lukasz@langa.pl
|
|
||||||
Maintainer: Jason R. Coombs
|
|
||||||
Maintainer-email: jaraco@jaraco.com
|
|
||||||
License: UNKNOWN
|
|
||||||
Keywords: configparser ini parsing conf cfg configuration file
|
|
||||||
Platform: any
|
|
||||||
Classifier: Development Status :: 5 - Production/Stable
|
|
||||||
Classifier: Intended Audience :: Developers
|
|
||||||
Classifier: License :: OSI Approved :: MIT License
|
|
||||||
Classifier: Programming Language :: Python :: 2.7
|
|
||||||
Classifier: Programming Language :: Python :: 3
|
|
||||||
Requires-Python: >=2.6
|
|
||||||
Provides-Extra: docs
|
|
||||||
Requires-Dist: sphinx ; extra == 'docs'
|
|
||||||
Requires-Dist: jaraco.packaging (>=3.2) ; extra == 'docs'
|
|
||||||
Requires-Dist: rst.linker (>=1.9) ; extra == 'docs'
|
|
||||||
Provides-Extra: testing
|
|
||||||
Requires-Dist: pytest (!=3.7.3,>=3.5) ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-checkdocs (>=1.2) ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-flake8 ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-black-multipy ; extra == 'testing'
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/pypi/v/configparser.svg
|
|
||||||
:target: https://pypi.org/project/configparser
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/pypi/pyversions/configparser.svg
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/travis/jaraco/configparser/master.svg
|
|
||||||
:target: https://travis-ci.org/jaraco/configparser
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
|
|
||||||
:target: https://github.com/ambv/black
|
|
||||||
:alt: Code style: Black
|
|
||||||
|
|
||||||
.. .. image:: https://img.shields.io/appveyor/ci/jaraco/configparser/master.svg
|
|
||||||
.. :target: https://ci.appveyor.com/project/jaraco/configparser/branch/master
|
|
||||||
|
|
||||||
.. image:: https://readthedocs.org/projects/configparser/badge/?version=latest
|
|
||||||
:target: https://configparser.readthedocs.io/en/latest/?badge=latest
|
|
||||||
|
|
||||||
.. image:: https://tidelift.com/badges/package/pypi/configparser
|
|
||||||
:target: https://tidelift.com/subscription/pkg/pypi-configparser?utm_source=pypi-configparser&utm_medium=readme
|
|
||||||
|
|
||||||
|
|
||||||
The ancient ``ConfigParser`` module available in the standard library 2.x has
|
|
||||||
seen a major update in Python 3.2. This is a backport of those changes so that
|
|
||||||
they can be used directly in Python 2.6 - 3.5.
|
|
||||||
|
|
||||||
To use the ``configparser`` backport instead of the built-in version on both
|
|
||||||
Python 2 and Python 3, simply import it explicitly as a backport::
|
|
||||||
|
|
||||||
from backports import configparser
|
|
||||||
|
|
||||||
If you'd like to use the backport on Python 2 and the built-in version on
|
|
||||||
Python 3, use that invocation instead::
|
|
||||||
|
|
||||||
import configparser
|
|
||||||
|
|
||||||
For detailed documentation consult the vanilla version at
|
|
||||||
http://docs.python.org/3/library/configparser.html.
|
|
||||||
|
|
||||||
Why you'll love ``configparser``
|
|
||||||
--------------------------------
|
|
||||||
|
|
||||||
Whereas almost completely compatible with its older brother, ``configparser``
|
|
||||||
sports a bunch of interesting new features:
|
|
||||||
|
|
||||||
* full mapping protocol access (`more info
|
|
||||||
<http://docs.python.org/3/library/configparser.html#mapping-protocol-access>`_)::
|
|
||||||
|
|
||||||
>>> parser = ConfigParser()
|
|
||||||
>>> parser.read_string("""
|
|
||||||
[DEFAULT]
|
|
||||||
location = upper left
|
|
||||||
visible = yes
|
|
||||||
editable = no
|
|
||||||
color = blue
|
|
||||||
|
|
||||||
[main]
|
|
||||||
title = Main Menu
|
|
||||||
color = green
|
|
||||||
|
|
||||||
[options]
|
|
||||||
title = Options
|
|
||||||
""")
|
|
||||||
>>> parser['main']['color']
|
|
||||||
'green'
|
|
||||||
>>> parser['main']['editable']
|
|
||||||
'no'
|
|
||||||
>>> section = parser['options']
|
|
||||||
>>> section['title']
|
|
||||||
'Options'
|
|
||||||
>>> section['title'] = 'Options (editable: %(editable)s)'
|
|
||||||
>>> section['title']
|
|
||||||
'Options (editable: no)'
|
|
||||||
|
|
||||||
* there's now one default ``ConfigParser`` class, which basically is the old
|
|
||||||
``SafeConfigParser`` with a bunch of tweaks which make it more predictable for
|
|
||||||
users. Don't need interpolation? Simply use
|
|
||||||
``ConfigParser(interpolation=None)``, no need to use a distinct
|
|
||||||
``RawConfigParser`` anymore.
|
|
||||||
|
|
||||||
* the parser is highly `customizable upon instantiation
|
|
||||||
<http://docs.python.org/3/library/configparser.html#customizing-parser-behaviour>`__
|
|
||||||
supporting things like changing option delimiters, comment characters, the
|
|
||||||
name of the DEFAULT section, the interpolation syntax, etc.
|
|
||||||
|
|
||||||
* you can easily create your own interpolation syntax but there are two powerful
|
|
||||||
implementations built-in (`more info
|
|
||||||
<http://docs.python.org/3/library/configparser.html#interpolation-of-values>`__):
|
|
||||||
|
|
||||||
* the classic ``%(string-like)s`` syntax (called ``BasicInterpolation``)
|
|
||||||
|
|
||||||
* a new ``${buildout:like}`` syntax (called ``ExtendedInterpolation``)
|
|
||||||
|
|
||||||
* fallback values may be specified in getters (`more info
|
|
||||||
<http://docs.python.org/3/library/configparser.html#fallback-values>`__)::
|
|
||||||
|
|
||||||
>>> config.get('closet', 'monster',
|
|
||||||
... fallback='No such things as monsters')
|
|
||||||
'No such things as monsters'
|
|
||||||
|
|
||||||
* ``ConfigParser`` objects can now read data directly `from strings
|
|
||||||
<http://docs.python.org/3/library/configparser.html#configparser.ConfigParser.read_string>`__
|
|
||||||
and `from dictionaries
|
|
||||||
<http://docs.python.org/3/library/configparser.html#configparser.ConfigParser.read_dict>`__.
|
|
||||||
That means importing configuration from JSON or specifying default values for
|
|
||||||
the whole configuration (multiple sections) is now a single line of code. Same
|
|
||||||
goes for copying data from another ``ConfigParser`` instance, thanks to its
|
|
||||||
mapping protocol support.
|
|
||||||
|
|
||||||
* many smaller tweaks, updates and fixes
|
|
||||||
|
|
||||||
A few words about Unicode
|
|
||||||
-------------------------
|
|
||||||
|
|
||||||
``configparser`` comes from Python 3 and as such it works well with Unicode.
|
|
||||||
The library is generally cleaned up in terms of internal data storage and
|
|
||||||
reading/writing files. There are a couple of incompatibilities with the old
|
|
||||||
``ConfigParser`` due to that. However, the work required to migrate is well
|
|
||||||
worth it as it shows the issues that would likely come up during migration of
|
|
||||||
your project to Python 3.
|
|
||||||
|
|
||||||
The design assumes that Unicode strings are used whenever possible [1]_. That
|
|
||||||
gives you the certainty that what's stored in a configuration object is text.
|
|
||||||
Once your configuration is read, the rest of your application doesn't have to
|
|
||||||
deal with encoding issues. All you have is text [2]_. The only two phases when
|
|
||||||
you should explicitly state encoding is when you either read from an external
|
|
||||||
source (e.g. a file) or write back.
|
|
||||||
|
|
||||||
Versioning
|
|
||||||
----------
|
|
||||||
|
|
||||||
This project uses `semver <https://semver.org/spec/v2.0.0.html>`_ to
|
|
||||||
communicate the impact of various releases while periodically syncing
|
|
||||||
with the upstream implementation in CPython.
|
|
||||||
`The changelog <https://github.com/jaraco/configparser/blob/master/CHANGES.rst>`_
|
|
||||||
serves as a reference indicating which versions incorporate
|
|
||||||
which upstream functionality.
|
|
||||||
|
|
||||||
Prior to the ``4.0.0`` release, `another scheme
|
|
||||||
<https://github.com/jaraco/configparser/blob/3.8.1/README.rst#versioning>`_
|
|
||||||
was used to associate the CPython and backports releases.
|
|
||||||
|
|
||||||
Maintenance
|
|
||||||
-----------
|
|
||||||
|
|
||||||
This backport was originally authored by Łukasz Langa, the current vanilla
|
|
||||||
``configparser`` maintainer for CPython and is currently maintained by
|
|
||||||
Jason R. Coombs:
|
|
||||||
|
|
||||||
* `configparser repository <https://github.com/jaraco/configparser>`_
|
|
||||||
|
|
||||||
* `configparser issue tracker <https://github.com/jaraco/configparser/issues>`_
|
|
||||||
|
|
||||||
Security Contact
|
|
||||||
----------------
|
|
||||||
|
|
||||||
To report a security vulnerability, please use the
|
|
||||||
`Tidelift security contact <https://tidelift.com/security>`_.
|
|
||||||
Tidelift will coordinate the fix and disclosure.
|
|
||||||
|
|
||||||
Conversion Process
|
|
||||||
------------------
|
|
||||||
|
|
||||||
This section is technical and should bother you only if you are wondering how
|
|
||||||
this backport is produced. If the implementation details of this backport are
|
|
||||||
not important for you, feel free to ignore the following content.
|
|
||||||
|
|
||||||
``configparser`` is converted using `python-future
|
|
||||||
<http://python-future.org>`_. The project takes the following
|
|
||||||
branching approach:
|
|
||||||
|
|
||||||
* the ``3.x`` branch holds unchanged files synchronized from the upstream
|
|
||||||
CPython repository. The synchronization is currently done by manually copying
|
|
||||||
the required files and stating from which CPython changeset they come from.
|
|
||||||
|
|
||||||
* the ``master`` branch holds a version of the ``3.x`` code with some tweaks
|
|
||||||
that make it independent from libraries and constructions unavailable on 2.x.
|
|
||||||
Code on this branch still *must* work on the corresponding Python 3.x but
|
|
||||||
will also work on Python 2.6 and 2.7 (including PyPy). You can check this
|
|
||||||
running the supplied unit tests with ``tox``.
|
|
||||||
|
|
||||||
The process works like this:
|
|
||||||
|
|
||||||
1. In the ``3.x`` branch, run ``pip-run -- sync-upstream.py``, which
|
|
||||||
downloads the latest stable release of Python and copies the relevant
|
|
||||||
files from there into their new locations here and then commits those
|
|
||||||
changes with a nice reference to the relevant upstream commit hash.
|
|
||||||
|
|
||||||
2. I check for new names in ``__all__`` and update imports in
|
|
||||||
``configparser.py`` accordingly. I run the tests on Python 3. Commit.
|
|
||||||
|
|
||||||
3. I merge the new commit to ``master``. I run ``tox``. Commit.
|
|
||||||
|
|
||||||
4. If there are necessary changes, I do them now (on ``master``). Note that
|
|
||||||
the changes should be written in the syntax subset supported by Python
|
|
||||||
2.6.
|
|
||||||
|
|
||||||
5. I run ``tox``. If it works, I update the docs and release the new version.
|
|
||||||
Otherwise, I go back to point 3. I might use ``pasteurize`` to suggest me
|
|
||||||
required changes but usually I do them manually to keep resulting code in
|
|
||||||
a nicer form.
|
|
||||||
|
|
||||||
|
|
||||||
Footnotes
|
|
||||||
---------
|
|
||||||
|
|
||||||
.. [1] To somewhat ease migration, passing bytestrings is still supported but
|
|
||||||
they are converted to Unicode for internal storage anyway. This means
|
|
||||||
that for the vast majority of strings used in configuration files, it
|
|
||||||
won't matter if you pass them as bytestrings or Unicode. However, if you
|
|
||||||
pass a bytestring that cannot be converted to Unicode using the naive
|
|
||||||
ASCII codec, a ``UnicodeDecodeError`` will be raised. This is purposeful
|
|
||||||
and helps you manage proper encoding for all content you store in
|
|
||||||
memory, read from various sources and write back.
|
|
||||||
|
|
||||||
.. [2] Life gets much easier when you understand that you basically manage
|
|
||||||
**text** in your application. You don't care about bytes but about
|
|
||||||
letters. In that regard the concept of content encoding is meaningless.
|
|
||||||
The only time when you deal with raw bytes is when you write the data to
|
|
||||||
a file. Then you have to specify how your text should be encoded. On
|
|
||||||
the other end, to get meaningful text from a file, the application
|
|
||||||
reading it has to know which encoding was used during its creation. But
|
|
||||||
once the bytes are read and properly decoded, all you have is text. This
|
|
||||||
is especially powerful when you start interacting with multiple data
|
|
||||||
sources. Even if each of them uses a different encoding, inside your
|
|
||||||
application data is held in abstract text form. You can program your
|
|
||||||
business logic without worrying about which data came from which source.
|
|
||||||
You can freely exchange the data you store between sources. Only
|
|
||||||
reading/writing files requires encoding your text to bytes.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,9 +0,0 @@
|
||||||
configparser.py,sha256=4VADEswCwzy_RDVgvje3BmZhD6iwo3k4EkUZcgzLD4M,1546
|
|
||||||
backports/__init__.py,sha256=elt6uFwbaEv80X8iGWsCJ_w_n_h1X8repgOoNrN0Syg,212
|
|
||||||
backports/configparser/__init__.py,sha256=thhQqB1qWNKf-F3CpZFYsjC8YT-_I_vF0w4JiuQfiWI,56628
|
|
||||||
backports/configparser/helpers.py,sha256=TxT00ldsHvIciQpml1YaoHfdtTl033Km6ywwT-U2nRc,7543
|
|
||||||
configparser-4.0.2.dist-info/LICENSE,sha256=pV4v_ptEmY5iHVHYwJS-0JrMS1I27nPX3zlaM7o8GP0,1050
|
|
||||||
configparser-4.0.2.dist-info/METADATA,sha256=oDqeXQXq8JhFEDHKDOBmbUtXmQ3CiiXB1Mr4UheTZ8Y,10910
|
|
||||||
configparser-4.0.2.dist-info/WHEEL,sha256=8zNYZbwQSXoB9IfXOjPfeNwvAsALAjffgk27FqvCWbo,110
|
|
||||||
configparser-4.0.2.dist-info/top_level.txt,sha256=mIs8gajd7cvEWhVluv4u6ocaHw_TJ9rOrpkZEFv-7Hc,23
|
|
||||||
configparser-4.0.2.dist-info/RECORD,,
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
Wheel-Version: 1.0
|
|
||||||
Generator: bdist_wheel (0.33.6)
|
|
||||||
Root-Is-Purelib: true
|
|
||||||
Tag: py2-none-any
|
|
||||||
Tag: py3-none-any
|
|
||||||
|
|
||||||
|
|
@ -1,2 +0,0 @@
|
||||||
backports
|
|
||||||
configparser
|
|
||||||
|
|
@ -1,61 +0,0 @@
|
||||||
#!/usr/bin/env python
|
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
|
|
||||||
"""Convenience module importing everything from backports.configparser."""
|
|
||||||
|
|
||||||
from __future__ import absolute_import
|
|
||||||
from __future__ import division
|
|
||||||
from __future__ import print_function
|
|
||||||
from __future__ import unicode_literals
|
|
||||||
|
|
||||||
from backports.configparser import (
|
|
||||||
RawConfigParser,
|
|
||||||
ConfigParser,
|
|
||||||
SafeConfigParser,
|
|
||||||
SectionProxy,
|
|
||||||
Interpolation,
|
|
||||||
BasicInterpolation,
|
|
||||||
ExtendedInterpolation,
|
|
||||||
LegacyInterpolation,
|
|
||||||
NoSectionError,
|
|
||||||
DuplicateSectionError,
|
|
||||||
DuplicateOptionError,
|
|
||||||
NoOptionError,
|
|
||||||
InterpolationError,
|
|
||||||
InterpolationMissingOptionError,
|
|
||||||
InterpolationSyntaxError,
|
|
||||||
InterpolationDepthError,
|
|
||||||
ParsingError,
|
|
||||||
MissingSectionHeaderError,
|
|
||||||
ConverterMapping,
|
|
||||||
DEFAULTSECT,
|
|
||||||
MAX_INTERPOLATION_DEPTH,
|
|
||||||
)
|
|
||||||
|
|
||||||
from backports.configparser import Error, _UNSET, _default_dict, _ChainMap # noqa: F401
|
|
||||||
|
|
||||||
__all__ = [
|
|
||||||
"NoSectionError",
|
|
||||||
"DuplicateOptionError",
|
|
||||||
"DuplicateSectionError",
|
|
||||||
"NoOptionError",
|
|
||||||
"InterpolationError",
|
|
||||||
"InterpolationDepthError",
|
|
||||||
"InterpolationMissingOptionError",
|
|
||||||
"InterpolationSyntaxError",
|
|
||||||
"ParsingError",
|
|
||||||
"MissingSectionHeaderError",
|
|
||||||
"ConfigParser",
|
|
||||||
"SafeConfigParser",
|
|
||||||
"RawConfigParser",
|
|
||||||
"Interpolation",
|
|
||||||
"BasicInterpolation",
|
|
||||||
"ExtendedInterpolation",
|
|
||||||
"LegacyInterpolation",
|
|
||||||
"SectionProxy",
|
|
||||||
"ConverterMapping",
|
|
||||||
"DEFAULTSECT",
|
|
||||||
"MAX_INTERPOLATION_DEPTH",
|
|
||||||
]
|
|
||||||
|
|
||||||
# NOTE: names missing from __all__ imported anyway for backwards compatibility.
|
|
||||||
|
|
@ -1,122 +0,0 @@
|
||||||
|
|
||||||
|
|
||||||
A. HISTORY OF THE SOFTWARE
|
|
||||||
==========================
|
|
||||||
|
|
||||||
contextlib2 is a derivative of the contextlib module distributed by the PSF
|
|
||||||
as part of the Python standard library. According, it is itself redistributed
|
|
||||||
under the PSF license (reproduced in full below). As the contextlib module
|
|
||||||
was added only in Python 2.5, the licenses for earlier Python versions are
|
|
||||||
not applicable and have not been included.
|
|
||||||
|
|
||||||
Python was created in the early 1990s by Guido van Rossum at Stichting
|
|
||||||
Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
|
|
||||||
as a successor of a language called ABC. Guido remains Python's
|
|
||||||
principal author, although it includes many contributions from others.
|
|
||||||
|
|
||||||
In 1995, Guido continued his work on Python at the Corporation for
|
|
||||||
National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
|
|
||||||
in Reston, Virginia where he released several versions of the
|
|
||||||
software.
|
|
||||||
|
|
||||||
In May 2000, Guido and the Python core development team moved to
|
|
||||||
BeOpen.com to form the BeOpen PythonLabs team. In October of the same
|
|
||||||
year, the PythonLabs team moved to Digital Creations (now Zope
|
|
||||||
Corporation, see http://www.zope.com). In 2001, the Python Software
|
|
||||||
Foundation (PSF, see http://www.python.org/psf/) was formed, a
|
|
||||||
non-profit organization created specifically to own Python-related
|
|
||||||
Intellectual Property. Zope Corporation is a sponsoring member of
|
|
||||||
the PSF.
|
|
||||||
|
|
||||||
All Python releases are Open Source (see http://www.opensource.org for
|
|
||||||
the Open Source Definition). Historically, most, but not all, Python
|
|
||||||
releases have also been GPL-compatible; the table below summarizes
|
|
||||||
the various releases that included the contextlib module.
|
|
||||||
|
|
||||||
Release Derived Year Owner GPL-
|
|
||||||
from compatible? (1)
|
|
||||||
|
|
||||||
2.5 2.4 2006 PSF yes
|
|
||||||
2.5.1 2.5 2007 PSF yes
|
|
||||||
2.5.2 2.5.1 2008 PSF yes
|
|
||||||
2.5.3 2.5.2 2008 PSF yes
|
|
||||||
2.6 2.5 2008 PSF yes
|
|
||||||
2.6.1 2.6 2008 PSF yes
|
|
||||||
2.6.2 2.6.1 2009 PSF yes
|
|
||||||
2.6.3 2.6.2 2009 PSF yes
|
|
||||||
2.6.4 2.6.3 2009 PSF yes
|
|
||||||
2.6.5 2.6.4 2010 PSF yes
|
|
||||||
3.0 2.6 2008 PSF yes
|
|
||||||
3.0.1 3.0 2009 PSF yes
|
|
||||||
3.1 3.0.1 2009 PSF yes
|
|
||||||
3.1.1 3.1 2009 PSF yes
|
|
||||||
3.1.2 3.1.1 2010 PSF yes
|
|
||||||
3.1.3 3.1.2 2010 PSF yes
|
|
||||||
3.1.4 3.1.3 2011 PSF yes
|
|
||||||
3.2 3.1 2011 PSF yes
|
|
||||||
3.2.1 3.2 2011 PSF yes
|
|
||||||
3.2.2 3.2.1 2011 PSF yes
|
|
||||||
3.3 3.2 2012 PSF yes
|
|
||||||
|
|
||||||
Footnotes:
|
|
||||||
|
|
||||||
(1) GPL-compatible doesn't mean that we're distributing Python under
|
|
||||||
the GPL. All Python licenses, unlike the GPL, let you distribute
|
|
||||||
a modified version without making your changes open source. The
|
|
||||||
GPL-compatible licenses make it possible to combine Python with
|
|
||||||
other software that is released under the GPL; the others don't.
|
|
||||||
|
|
||||||
Thanks to the many outside volunteers who have worked under Guido's
|
|
||||||
direction to make these releases possible.
|
|
||||||
|
|
||||||
|
|
||||||
B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
|
|
||||||
===============================================================
|
|
||||||
|
|
||||||
PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
|
|
||||||
--------------------------------------------
|
|
||||||
|
|
||||||
1. This LICENSE AGREEMENT is between the Python Software Foundation
|
|
||||||
("PSF"), and the Individual or Organization ("Licensee") accessing and
|
|
||||||
otherwise using this software ("Python") in source or binary form and
|
|
||||||
its associated documentation.
|
|
||||||
|
|
||||||
2. Subject to the terms and conditions of this License Agreement, PSF hereby
|
|
||||||
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
|
|
||||||
analyze, test, perform and/or display publicly, prepare derivative works,
|
|
||||||
distribute, and otherwise use Python alone or in any derivative version,
|
|
||||||
provided, however, that PSF's License Agreement and PSF's notice of copyright,
|
|
||||||
i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
|
|
||||||
2011 Python Software Foundation; All Rights Reserved" are retained in Python
|
|
||||||
alone or in any derivative version prepared by Licensee.
|
|
||||||
|
|
||||||
3. In the event Licensee prepares a derivative work that is based on
|
|
||||||
or incorporates Python or any part thereof, and wants to make
|
|
||||||
the derivative work available to others as provided herein, then
|
|
||||||
Licensee hereby agrees to include in any such work a brief summary of
|
|
||||||
the changes made to Python.
|
|
||||||
|
|
||||||
4. PSF is making Python available to Licensee on an "AS IS"
|
|
||||||
basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
|
|
||||||
IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
|
|
||||||
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
|
|
||||||
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
|
|
||||||
INFRINGE ANY THIRD PARTY RIGHTS.
|
|
||||||
|
|
||||||
5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
|
|
||||||
FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
|
|
||||||
A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
|
|
||||||
OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
|
|
||||||
|
|
||||||
6. This License Agreement will automatically terminate upon a material
|
|
||||||
breach of its terms and conditions.
|
|
||||||
|
|
||||||
7. Nothing in this License Agreement shall be deemed to create any
|
|
||||||
relationship of agency, partnership, or joint venture between PSF and
|
|
||||||
Licensee. This License Agreement does not grant permission to use PSF
|
|
||||||
trademarks or trade name in a trademark sense to endorse or promote
|
|
||||||
products or services of Licensee, or any third party.
|
|
||||||
|
|
||||||
8. By copying, installing or otherwise using Python, Licensee
|
|
||||||
agrees to be bound by the terms and conditions of this License
|
|
||||||
Agreement.
|
|
||||||
|
|
@ -1,70 +0,0 @@
|
||||||
Metadata-Version: 2.1
|
|
||||||
Name: contextlib2
|
|
||||||
Version: 0.6.0.post1
|
|
||||||
Summary: Backports and enhancements for the contextlib module
|
|
||||||
Home-page: http://contextlib2.readthedocs.org
|
|
||||||
Author: Nick Coghlan
|
|
||||||
Author-email: ncoghlan@gmail.com
|
|
||||||
License: PSF License
|
|
||||||
Platform: UNKNOWN
|
|
||||||
Classifier: Development Status :: 5 - Production/Stable
|
|
||||||
Classifier: License :: OSI Approved :: Python Software Foundation License
|
|
||||||
Classifier: Programming Language :: Python :: 2
|
|
||||||
Classifier: Programming Language :: Python :: 2.7
|
|
||||||
Classifier: Programming Language :: Python :: 3
|
|
||||||
Classifier: Programming Language :: Python :: 3.4
|
|
||||||
Classifier: Programming Language :: Python :: 3.5
|
|
||||||
Classifier: Programming Language :: Python :: 3.6
|
|
||||||
Classifier: Programming Language :: Python :: 3.7
|
|
||||||
Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
|
|
||||||
|
|
||||||
.. image:: https://jazzband.co/static/img/badge.svg
|
|
||||||
:target: https://jazzband.co/
|
|
||||||
:alt: Jazzband
|
|
||||||
|
|
||||||
.. image:: https://readthedocs.org/projects/contextlib2/badge/?version=latest
|
|
||||||
:target: https://contextlib2.readthedocs.org/
|
|
||||||
:alt: Latest Docs
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/travis/jazzband/contextlib2/master.svg
|
|
||||||
:target: http://travis-ci.org/jazzband/contextlib2
|
|
||||||
|
|
||||||
.. image:: https://coveralls.io/repos/github/jazzband/contextlib2/badge.svg?branch=master
|
|
||||||
:target: https://coveralls.io/github/jazzband/contextlib2?branch=master
|
|
||||||
|
|
||||||
.. image:: https://landscape.io/github/jazzband/contextlib2/master/landscape.svg
|
|
||||||
:target: https://landscape.io/github/jazzband/contextlib2/
|
|
||||||
|
|
||||||
contextlib2 is a backport of the `standard library's contextlib
|
|
||||||
module <https://docs.python.org/3.5/library/contextlib.html>`_ to
|
|
||||||
earlier Python versions.
|
|
||||||
|
|
||||||
It also serves as a real world proving ground for possible future
|
|
||||||
enhancements to the standard library version.
|
|
||||||
|
|
||||||
Development
|
|
||||||
-----------
|
|
||||||
|
|
||||||
contextlib2 has no runtime dependencies, but requires ``unittest2`` for testing
|
|
||||||
on Python 2.x, as well as ``setuptools`` and ``wheel`` to generate universal
|
|
||||||
wheel archives.
|
|
||||||
|
|
||||||
Local testing is just a matter of running ``python test_contextlib2.py``.
|
|
||||||
|
|
||||||
You can test against multiple versions of Python with
|
|
||||||
`tox <https://tox.testrun.org/>`_::
|
|
||||||
|
|
||||||
pip install tox
|
|
||||||
tox
|
|
||||||
|
|
||||||
Versions currently tested in both tox and Travis CI are:
|
|
||||||
|
|
||||||
* CPython 2.7
|
|
||||||
* CPython 3.4
|
|
||||||
* CPython 3.5
|
|
||||||
* CPython 3.6
|
|
||||||
* CPython 3.7
|
|
||||||
* PyPy
|
|
||||||
* PyPy3
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
contextlib2.py,sha256=5HjGflUzwWAUfcILhSmC2GqvoYdZZzFzVfIDztHigUs,16915
|
|
||||||
contextlib2-0.6.0.post1.dist-info/LICENSE.txt,sha256=xqev-sas2tLS3YfS12hDhiSraSYY2x8CvqOxHT85ePA,6054
|
|
||||||
contextlib2-0.6.0.post1.dist-info/METADATA,sha256=_kBcf3VJkbe-EMyAM1c5t5sRwBFfFu5YcfWCJMgVO1Q,2297
|
|
||||||
contextlib2-0.6.0.post1.dist-info/WHEEL,sha256=8zNYZbwQSXoB9IfXOjPfeNwvAsALAjffgk27FqvCWbo,110
|
|
||||||
contextlib2-0.6.0.post1.dist-info/top_level.txt,sha256=RxWWBMkHA_rsw1laXJ8L3yE_fyYaBmvt2bVUvj3WbMg,12
|
|
||||||
contextlib2-0.6.0.post1.dist-info/RECORD,,
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
Wheel-Version: 1.0
|
|
||||||
Generator: bdist_wheel (0.33.6)
|
|
||||||
Root-Is-Purelib: true
|
|
||||||
Tag: py2-none-any
|
|
||||||
Tag: py3-none-any
|
|
||||||
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
contextlib2
|
|
||||||
|
|
@ -1,518 +0,0 @@
|
||||||
"""contextlib2 - backports and enhancements to the contextlib module"""
|
|
||||||
|
|
||||||
import abc
|
|
||||||
import sys
|
|
||||||
import warnings
|
|
||||||
from collections import deque
|
|
||||||
from functools import wraps
|
|
||||||
|
|
||||||
__all__ = ["contextmanager", "closing", "nullcontext",
|
|
||||||
"AbstractContextManager",
|
|
||||||
"ContextDecorator", "ExitStack",
|
|
||||||
"redirect_stdout", "redirect_stderr", "suppress"]
|
|
||||||
|
|
||||||
# Backwards compatibility
|
|
||||||
__all__ += ["ContextStack"]
|
|
||||||
|
|
||||||
|
|
||||||
# Backport abc.ABC
|
|
||||||
if sys.version_info[:2] >= (3, 4):
|
|
||||||
_abc_ABC = abc.ABC
|
|
||||||
else:
|
|
||||||
_abc_ABC = abc.ABCMeta('ABC', (object,), {'__slots__': ()})
|
|
||||||
|
|
||||||
|
|
||||||
# Backport classic class MRO
|
|
||||||
def _classic_mro(C, result):
|
|
||||||
if C in result:
|
|
||||||
return
|
|
||||||
result.append(C)
|
|
||||||
for B in C.__bases__:
|
|
||||||
_classic_mro(B, result)
|
|
||||||
return result
|
|
||||||
|
|
||||||
|
|
||||||
# Backport _collections_abc._check_methods
|
|
||||||
def _check_methods(C, *methods):
|
|
||||||
try:
|
|
||||||
mro = C.__mro__
|
|
||||||
except AttributeError:
|
|
||||||
mro = tuple(_classic_mro(C, []))
|
|
||||||
|
|
||||||
for method in methods:
|
|
||||||
for B in mro:
|
|
||||||
if method in B.__dict__:
|
|
||||||
if B.__dict__[method] is None:
|
|
||||||
return NotImplemented
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
return NotImplemented
|
|
||||||
return True
|
|
||||||
|
|
||||||
|
|
||||||
class AbstractContextManager(_abc_ABC):
|
|
||||||
"""An abstract base class for context managers."""
|
|
||||||
|
|
||||||
def __enter__(self):
|
|
||||||
"""Return `self` upon entering the runtime context."""
|
|
||||||
return self
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def __exit__(self, exc_type, exc_value, traceback):
|
|
||||||
"""Raise any exception triggered within the runtime context."""
|
|
||||||
return None
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def __subclasshook__(cls, C):
|
|
||||||
"""Check whether subclass is considered a subclass of this ABC."""
|
|
||||||
if cls is AbstractContextManager:
|
|
||||||
return _check_methods(C, "__enter__", "__exit__")
|
|
||||||
return NotImplemented
|
|
||||||
|
|
||||||
|
|
||||||
class ContextDecorator(object):
|
|
||||||
"""A base class or mixin that enables context managers to work as decorators."""
|
|
||||||
|
|
||||||
def refresh_cm(self):
|
|
||||||
"""Returns the context manager used to actually wrap the call to the
|
|
||||||
decorated function.
|
|
||||||
|
|
||||||
The default implementation just returns *self*.
|
|
||||||
|
|
||||||
Overriding this method allows otherwise one-shot context managers
|
|
||||||
like _GeneratorContextManager to support use as decorators via
|
|
||||||
implicit recreation.
|
|
||||||
|
|
||||||
DEPRECATED: refresh_cm was never added to the standard library's
|
|
||||||
ContextDecorator API
|
|
||||||
"""
|
|
||||||
warnings.warn("refresh_cm was never added to the standard library",
|
|
||||||
DeprecationWarning)
|
|
||||||
return self._recreate_cm()
|
|
||||||
|
|
||||||
def _recreate_cm(self):
|
|
||||||
"""Return a recreated instance of self.
|
|
||||||
|
|
||||||
Allows an otherwise one-shot context manager like
|
|
||||||
_GeneratorContextManager to support use as
|
|
||||||
a decorator via implicit recreation.
|
|
||||||
|
|
||||||
This is a private interface just for _GeneratorContextManager.
|
|
||||||
See issue #11647 for details.
|
|
||||||
"""
|
|
||||||
return self
|
|
||||||
|
|
||||||
def __call__(self, func):
|
|
||||||
@wraps(func)
|
|
||||||
def inner(*args, **kwds):
|
|
||||||
with self._recreate_cm():
|
|
||||||
return func(*args, **kwds)
|
|
||||||
return inner
|
|
||||||
|
|
||||||
|
|
||||||
class _GeneratorContextManager(ContextDecorator):
|
|
||||||
"""Helper for @contextmanager decorator."""
|
|
||||||
|
|
||||||
def __init__(self, func, args, kwds):
|
|
||||||
self.gen = func(*args, **kwds)
|
|
||||||
self.func, self.args, self.kwds = func, args, kwds
|
|
||||||
# Issue 19330: ensure context manager instances have good docstrings
|
|
||||||
doc = getattr(func, "__doc__", None)
|
|
||||||
if doc is None:
|
|
||||||
doc = type(self).__doc__
|
|
||||||
self.__doc__ = doc
|
|
||||||
# Unfortunately, this still doesn't provide good help output when
|
|
||||||
# inspecting the created context manager instances, since pydoc
|
|
||||||
# currently bypasses the instance docstring and shows the docstring
|
|
||||||
# for the class instead.
|
|
||||||
# See http://bugs.python.org/issue19404 for more details.
|
|
||||||
|
|
||||||
def _recreate_cm(self):
|
|
||||||
# _GCM instances are one-shot context managers, so the
|
|
||||||
# CM must be recreated each time a decorated function is
|
|
||||||
# called
|
|
||||||
return self.__class__(self.func, self.args, self.kwds)
|
|
||||||
|
|
||||||
def __enter__(self):
|
|
||||||
try:
|
|
||||||
return next(self.gen)
|
|
||||||
except StopIteration:
|
|
||||||
raise RuntimeError("generator didn't yield")
|
|
||||||
|
|
||||||
def __exit__(self, type, value, traceback):
|
|
||||||
if type is None:
|
|
||||||
try:
|
|
||||||
next(self.gen)
|
|
||||||
except StopIteration:
|
|
||||||
return
|
|
||||||
else:
|
|
||||||
raise RuntimeError("generator didn't stop")
|
|
||||||
else:
|
|
||||||
if value is None:
|
|
||||||
# Need to force instantiation so we can reliably
|
|
||||||
# tell if we get the same exception back
|
|
||||||
value = type()
|
|
||||||
try:
|
|
||||||
self.gen.throw(type, value, traceback)
|
|
||||||
raise RuntimeError("generator didn't stop after throw()")
|
|
||||||
except StopIteration as exc:
|
|
||||||
# Suppress StopIteration *unless* it's the same exception that
|
|
||||||
# was passed to throw(). This prevents a StopIteration
|
|
||||||
# raised inside the "with" statement from being suppressed.
|
|
||||||
return exc is not value
|
|
||||||
except RuntimeError as exc:
|
|
||||||
# Don't re-raise the passed in exception
|
|
||||||
if exc is value:
|
|
||||||
return False
|
|
||||||
# Likewise, avoid suppressing if a StopIteration exception
|
|
||||||
# was passed to throw() and later wrapped into a RuntimeError
|
|
||||||
# (see PEP 479).
|
|
||||||
if _HAVE_EXCEPTION_CHAINING and exc.__cause__ is value:
|
|
||||||
return False
|
|
||||||
raise
|
|
||||||
except:
|
|
||||||
# only re-raise if it's *not* the exception that was
|
|
||||||
# passed to throw(), because __exit__() must not raise
|
|
||||||
# an exception unless __exit__() itself failed. But throw()
|
|
||||||
# has to raise the exception to signal propagation, so this
|
|
||||||
# fixes the impedance mismatch between the throw() protocol
|
|
||||||
# and the __exit__() protocol.
|
|
||||||
#
|
|
||||||
if sys.exc_info()[1] is not value:
|
|
||||||
raise
|
|
||||||
|
|
||||||
|
|
||||||
def contextmanager(func):
|
|
||||||
"""@contextmanager decorator.
|
|
||||||
|
|
||||||
Typical usage:
|
|
||||||
|
|
||||||
@contextmanager
|
|
||||||
def some_generator(<arguments>):
|
|
||||||
<setup>
|
|
||||||
try:
|
|
||||||
yield <value>
|
|
||||||
finally:
|
|
||||||
<cleanup>
|
|
||||||
|
|
||||||
This makes this:
|
|
||||||
|
|
||||||
with some_generator(<arguments>) as <variable>:
|
|
||||||
<body>
|
|
||||||
|
|
||||||
equivalent to this:
|
|
||||||
|
|
||||||
<setup>
|
|
||||||
try:
|
|
||||||
<variable> = <value>
|
|
||||||
<body>
|
|
||||||
finally:
|
|
||||||
<cleanup>
|
|
||||||
|
|
||||||
"""
|
|
||||||
@wraps(func)
|
|
||||||
def helper(*args, **kwds):
|
|
||||||
return _GeneratorContextManager(func, args, kwds)
|
|
||||||
return helper
|
|
||||||
|
|
||||||
|
|
||||||
class closing(object):
|
|
||||||
"""Context to automatically close something at the end of a block.
|
|
||||||
|
|
||||||
Code like this:
|
|
||||||
|
|
||||||
with closing(<module>.open(<arguments>)) as f:
|
|
||||||
<block>
|
|
||||||
|
|
||||||
is equivalent to this:
|
|
||||||
|
|
||||||
f = <module>.open(<arguments>)
|
|
||||||
try:
|
|
||||||
<block>
|
|
||||||
finally:
|
|
||||||
f.close()
|
|
||||||
|
|
||||||
"""
|
|
||||||
def __init__(self, thing):
|
|
||||||
self.thing = thing
|
|
||||||
|
|
||||||
def __enter__(self):
|
|
||||||
return self.thing
|
|
||||||
|
|
||||||
def __exit__(self, *exc_info):
|
|
||||||
self.thing.close()
|
|
||||||
|
|
||||||
|
|
||||||
class _RedirectStream(object):
|
|
||||||
|
|
||||||
_stream = None
|
|
||||||
|
|
||||||
def __init__(self, new_target):
|
|
||||||
self._new_target = new_target
|
|
||||||
# We use a list of old targets to make this CM re-entrant
|
|
||||||
self._old_targets = []
|
|
||||||
|
|
||||||
def __enter__(self):
|
|
||||||
self._old_targets.append(getattr(sys, self._stream))
|
|
||||||
setattr(sys, self._stream, self._new_target)
|
|
||||||
return self._new_target
|
|
||||||
|
|
||||||
def __exit__(self, exctype, excinst, exctb):
|
|
||||||
setattr(sys, self._stream, self._old_targets.pop())
|
|
||||||
|
|
||||||
|
|
||||||
class redirect_stdout(_RedirectStream):
|
|
||||||
"""Context manager for temporarily redirecting stdout to another file.
|
|
||||||
|
|
||||||
# How to send help() to stderr
|
|
||||||
with redirect_stdout(sys.stderr):
|
|
||||||
help(dir)
|
|
||||||
|
|
||||||
# How to write help() to a file
|
|
||||||
with open('help.txt', 'w') as f:
|
|
||||||
with redirect_stdout(f):
|
|
||||||
help(pow)
|
|
||||||
"""
|
|
||||||
|
|
||||||
_stream = "stdout"
|
|
||||||
|
|
||||||
|
|
||||||
class redirect_stderr(_RedirectStream):
|
|
||||||
"""Context manager for temporarily redirecting stderr to another file."""
|
|
||||||
|
|
||||||
_stream = "stderr"
|
|
||||||
|
|
||||||
|
|
||||||
class suppress(object):
|
|
||||||
"""Context manager to suppress specified exceptions
|
|
||||||
|
|
||||||
After the exception is suppressed, execution proceeds with the next
|
|
||||||
statement following the with statement.
|
|
||||||
|
|
||||||
with suppress(FileNotFoundError):
|
|
||||||
os.remove(somefile)
|
|
||||||
# Execution still resumes here if the file was already removed
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, *exceptions):
|
|
||||||
self._exceptions = exceptions
|
|
||||||
|
|
||||||
def __enter__(self):
|
|
||||||
pass
|
|
||||||
|
|
||||||
def __exit__(self, exctype, excinst, exctb):
|
|
||||||
# Unlike isinstance and issubclass, CPython exception handling
|
|
||||||
# currently only looks at the concrete type hierarchy (ignoring
|
|
||||||
# the instance and subclass checking hooks). While Guido considers
|
|
||||||
# that a bug rather than a feature, it's a fairly hard one to fix
|
|
||||||
# due to various internal implementation details. suppress provides
|
|
||||||
# the simpler issubclass based semantics, rather than trying to
|
|
||||||
# exactly reproduce the limitations of the CPython interpreter.
|
|
||||||
#
|
|
||||||
# See http://bugs.python.org/issue12029 for more details
|
|
||||||
return exctype is not None and issubclass(exctype, self._exceptions)
|
|
||||||
|
|
||||||
|
|
||||||
# Context manipulation is Python 3 only
|
|
||||||
_HAVE_EXCEPTION_CHAINING = sys.version_info[0] >= 3
|
|
||||||
if _HAVE_EXCEPTION_CHAINING:
|
|
||||||
def _make_context_fixer(frame_exc):
|
|
||||||
def _fix_exception_context(new_exc, old_exc):
|
|
||||||
# Context may not be correct, so find the end of the chain
|
|
||||||
while 1:
|
|
||||||
exc_context = new_exc.__context__
|
|
||||||
if exc_context is old_exc:
|
|
||||||
# Context is already set correctly (see issue 20317)
|
|
||||||
return
|
|
||||||
if exc_context is None or exc_context is frame_exc:
|
|
||||||
break
|
|
||||||
new_exc = exc_context
|
|
||||||
# Change the end of the chain to point to the exception
|
|
||||||
# we expect it to reference
|
|
||||||
new_exc.__context__ = old_exc
|
|
||||||
return _fix_exception_context
|
|
||||||
|
|
||||||
def _reraise_with_existing_context(exc_details):
|
|
||||||
try:
|
|
||||||
# bare "raise exc_details[1]" replaces our carefully
|
|
||||||
# set-up context
|
|
||||||
fixed_ctx = exc_details[1].__context__
|
|
||||||
raise exc_details[1]
|
|
||||||
except BaseException:
|
|
||||||
exc_details[1].__context__ = fixed_ctx
|
|
||||||
raise
|
|
||||||
else:
|
|
||||||
# No exception context in Python 2
|
|
||||||
def _make_context_fixer(frame_exc):
|
|
||||||
return lambda new_exc, old_exc: None
|
|
||||||
|
|
||||||
# Use 3 argument raise in Python 2,
|
|
||||||
# but use exec to avoid SyntaxError in Python 3
|
|
||||||
def _reraise_with_existing_context(exc_details):
|
|
||||||
exc_type, exc_value, exc_tb = exc_details
|
|
||||||
exec("raise exc_type, exc_value, exc_tb")
|
|
||||||
|
|
||||||
# Handle old-style classes if they exist
|
|
||||||
try:
|
|
||||||
from types import InstanceType
|
|
||||||
except ImportError:
|
|
||||||
# Python 3 doesn't have old-style classes
|
|
||||||
_get_type = type
|
|
||||||
else:
|
|
||||||
# Need to handle old-style context managers on Python 2
|
|
||||||
def _get_type(obj):
|
|
||||||
obj_type = type(obj)
|
|
||||||
if obj_type is InstanceType:
|
|
||||||
return obj.__class__ # Old-style class
|
|
||||||
return obj_type # New-style class
|
|
||||||
|
|
||||||
|
|
||||||
# Inspired by discussions on http://bugs.python.org/issue13585
|
|
||||||
class ExitStack(object):
|
|
||||||
"""Context manager for dynamic management of a stack of exit callbacks
|
|
||||||
|
|
||||||
For example:
|
|
||||||
|
|
||||||
with ExitStack() as stack:
|
|
||||||
files = [stack.enter_context(open(fname)) for fname in filenames]
|
|
||||||
# All opened files will automatically be closed at the end of
|
|
||||||
# the with statement, even if attempts to open files later
|
|
||||||
# in the list raise an exception
|
|
||||||
|
|
||||||
"""
|
|
||||||
def __init__(self):
|
|
||||||
self._exit_callbacks = deque()
|
|
||||||
|
|
||||||
def pop_all(self):
|
|
||||||
"""Preserve the context stack by transferring it to a new instance"""
|
|
||||||
new_stack = type(self)()
|
|
||||||
new_stack._exit_callbacks = self._exit_callbacks
|
|
||||||
self._exit_callbacks = deque()
|
|
||||||
return new_stack
|
|
||||||
|
|
||||||
def _push_cm_exit(self, cm, cm_exit):
|
|
||||||
"""Helper to correctly register callbacks to __exit__ methods"""
|
|
||||||
def _exit_wrapper(*exc_details):
|
|
||||||
return cm_exit(cm, *exc_details)
|
|
||||||
_exit_wrapper.__self__ = cm
|
|
||||||
self.push(_exit_wrapper)
|
|
||||||
|
|
||||||
def push(self, exit):
|
|
||||||
"""Registers a callback with the standard __exit__ method signature
|
|
||||||
|
|
||||||
Can suppress exceptions the same way __exit__ methods can.
|
|
||||||
|
|
||||||
Also accepts any object with an __exit__ method (registering a call
|
|
||||||
to the method instead of the object itself)
|
|
||||||
"""
|
|
||||||
# We use an unbound method rather than a bound method to follow
|
|
||||||
# the standard lookup behaviour for special methods
|
|
||||||
_cb_type = _get_type(exit)
|
|
||||||
try:
|
|
||||||
exit_method = _cb_type.__exit__
|
|
||||||
except AttributeError:
|
|
||||||
# Not a context manager, so assume its a callable
|
|
||||||
self._exit_callbacks.append(exit)
|
|
||||||
else:
|
|
||||||
self._push_cm_exit(exit, exit_method)
|
|
||||||
return exit # Allow use as a decorator
|
|
||||||
|
|
||||||
def callback(self, callback, *args, **kwds):
|
|
||||||
"""Registers an arbitrary callback and arguments.
|
|
||||||
|
|
||||||
Cannot suppress exceptions.
|
|
||||||
"""
|
|
||||||
def _exit_wrapper(exc_type, exc, tb):
|
|
||||||
callback(*args, **kwds)
|
|
||||||
# We changed the signature, so using @wraps is not appropriate, but
|
|
||||||
# setting __wrapped__ may still help with introspection
|
|
||||||
_exit_wrapper.__wrapped__ = callback
|
|
||||||
self.push(_exit_wrapper)
|
|
||||||
return callback # Allow use as a decorator
|
|
||||||
|
|
||||||
def enter_context(self, cm):
|
|
||||||
"""Enters the supplied context manager
|
|
||||||
|
|
||||||
If successful, also pushes its __exit__ method as a callback and
|
|
||||||
returns the result of the __enter__ method.
|
|
||||||
"""
|
|
||||||
# We look up the special methods on the type to match the with statement
|
|
||||||
_cm_type = _get_type(cm)
|
|
||||||
_exit = _cm_type.__exit__
|
|
||||||
result = _cm_type.__enter__(cm)
|
|
||||||
self._push_cm_exit(cm, _exit)
|
|
||||||
return result
|
|
||||||
|
|
||||||
def close(self):
|
|
||||||
"""Immediately unwind the context stack"""
|
|
||||||
self.__exit__(None, None, None)
|
|
||||||
|
|
||||||
def __enter__(self):
|
|
||||||
return self
|
|
||||||
|
|
||||||
def __exit__(self, *exc_details):
|
|
||||||
received_exc = exc_details[0] is not None
|
|
||||||
|
|
||||||
# We manipulate the exception state so it behaves as though
|
|
||||||
# we were actually nesting multiple with statements
|
|
||||||
frame_exc = sys.exc_info()[1]
|
|
||||||
_fix_exception_context = _make_context_fixer(frame_exc)
|
|
||||||
|
|
||||||
# Callbacks are invoked in LIFO order to match the behaviour of
|
|
||||||
# nested context managers
|
|
||||||
suppressed_exc = False
|
|
||||||
pending_raise = False
|
|
||||||
while self._exit_callbacks:
|
|
||||||
cb = self._exit_callbacks.pop()
|
|
||||||
try:
|
|
||||||
if cb(*exc_details):
|
|
||||||
suppressed_exc = True
|
|
||||||
pending_raise = False
|
|
||||||
exc_details = (None, None, None)
|
|
||||||
except:
|
|
||||||
new_exc_details = sys.exc_info()
|
|
||||||
# simulate the stack of exceptions by setting the context
|
|
||||||
_fix_exception_context(new_exc_details[1], exc_details[1])
|
|
||||||
pending_raise = True
|
|
||||||
exc_details = new_exc_details
|
|
||||||
if pending_raise:
|
|
||||||
_reraise_with_existing_context(exc_details)
|
|
||||||
return received_exc and suppressed_exc
|
|
||||||
|
|
||||||
|
|
||||||
# Preserve backwards compatibility
|
|
||||||
class ContextStack(ExitStack):
|
|
||||||
"""Backwards compatibility alias for ExitStack"""
|
|
||||||
|
|
||||||
def __init__(self):
|
|
||||||
warnings.warn("ContextStack has been renamed to ExitStack",
|
|
||||||
DeprecationWarning)
|
|
||||||
super(ContextStack, self).__init__()
|
|
||||||
|
|
||||||
def register_exit(self, callback):
|
|
||||||
return self.push(callback)
|
|
||||||
|
|
||||||
def register(self, callback, *args, **kwds):
|
|
||||||
return self.callback(callback, *args, **kwds)
|
|
||||||
|
|
||||||
def preserve(self):
|
|
||||||
return self.pop_all()
|
|
||||||
|
|
||||||
|
|
||||||
class nullcontext(AbstractContextManager):
|
|
||||||
"""Context manager that does no additional processing.
|
|
||||||
Used as a stand-in for a normal context manager, when a particular
|
|
||||||
block of code is only sometimes used with a normal context manager:
|
|
||||||
cm = optional_cm if condition else nullcontext()
|
|
||||||
with cm:
|
|
||||||
# Perform operation, using optional_cm if condition is True
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, enter_result=None):
|
|
||||||
self.enter_result = enter_result
|
|
||||||
|
|
||||||
def __enter__(self):
|
|
||||||
return self.enter_result
|
|
||||||
|
|
||||||
def __exit__(self, *excinfo):
|
|
||||||
pass
|
|
||||||
|
|
@ -1,24 +0,0 @@
|
||||||
Metadata-Version: 1.1
|
|
||||||
Name: distlib
|
|
||||||
Version: 0.3.2
|
|
||||||
Summary: Distribution utilities
|
|
||||||
Description: Low-level components of distutils2/packaging, augmented with higher-level APIs for making packaging easier.
|
|
||||||
Home-page: https://bitbucket.org/pypa/distlib
|
|
||||||
Author: Vinay Sajip
|
|
||||||
Author-email: vinay_sajip@red-dove.com
|
|
||||||
License: Python license
|
|
||||||
Classifier: Development Status :: 5 - Production/Stable
|
|
||||||
Classifier: Environment :: Console
|
|
||||||
Classifier: Intended Audience :: Developers
|
|
||||||
Classifier: License :: OSI Approved :: Python Software Foundation License
|
|
||||||
Classifier: Operating System :: OS Independent
|
|
||||||
Classifier: Programming Language :: Python
|
|
||||||
Classifier: Programming Language :: Python :: 2
|
|
||||||
Classifier: Programming Language :: Python :: 3
|
|
||||||
Classifier: Programming Language :: Python :: 2.7
|
|
||||||
Classifier: Programming Language :: Python :: 3.5
|
|
||||||
Classifier: Programming Language :: Python :: 3.6
|
|
||||||
Classifier: Programming Language :: Python :: 3.7
|
|
||||||
Classifier: Programming Language :: Python :: 3.8
|
|
||||||
Classifier: Topic :: Software Development :: Libraries :: Python Modules
|
|
||||||
Download-URL: https://bitbucket.org/pypa/distlib/downloads/distlib-0.3.2.zip
|
|
||||||
|
|
@ -1,26 +0,0 @@
|
||||||
distlib/__init__.py,sha256=bHNWOvZsLE4ES9S4FEA8CyP-rDYzatVgp9GHbpTnb2I,581
|
|
||||||
distlib/compat.py,sha256=ADA56xiAxar3mU6qemlBhNbsrFPosXRhO44RzsbJPqk,41408
|
|
||||||
distlib/database.py,sha256=Kl0YvPQKc4OcpVi7k5cFziydM1xOK8iqdxLGXgbZHV4,51059
|
|
||||||
distlib/index.py,sha256=UfcimNW19AB7IKWam4VaJbXuCBvArKfSxhV16EwavzE,20739
|
|
||||||
distlib/locators.py,sha256=AKlB3oZvfOTg4E0CtfwOzujFL19X5V4XUA4eHdKOu44,51965
|
|
||||||
distlib/manifest.py,sha256=nQEhYmgoreaBZzyFzwYsXxJARu3fo4EkunU163U16iE,14811
|
|
||||||
distlib/markers.py,sha256=OunMSH1SIbvLLt4z2VEERCll4WNlz2tDrg1mSXCNUj4,4344
|
|
||||||
distlib/metadata.py,sha256=vatoxFdmBr6ie-sTVXVNPOPG3uwMDWJTnEECnm7xDCw,39109
|
|
||||||
distlib/resources.py,sha256=LwbPksc0A1JMbi6XnuPdMBUn83X7BPuFNWqPGEKI698,10820
|
|
||||||
distlib/scripts.py,sha256=YD5_kioPD-qybYwQ4Gxyu-FR4ffxczy2gdBuU4II9qA,17248
|
|
||||||
distlib/t32.exe,sha256=NS3xBCVAld35JVFNmb-1QRyVtThukMrwZVeXn4LhaEQ,96768
|
|
||||||
distlib/t64.exe,sha256=oAqHes78rUWVM0OtVqIhUvequl_PKhAhXYQWnUf7zR0,105984
|
|
||||||
distlib/util.py,sha256=eIKKJ5Mp4unHMOVzixRIRxGq4ty5-h_PoFmZ_lpvkkM,67558
|
|
||||||
distlib/version.py,sha256=_geOv-cHoV-G8dQzKI8g6z8F0XeFeUqdJ_1G1K6iyrQ,23508
|
|
||||||
distlib/w32.exe,sha256=lJtnZdeUxTZWya_EW5DZos_K5rswRECGspIl8ZJCIXs,90112
|
|
||||||
distlib/w64.exe,sha256=0aRzoN2BO9NWW4ENy4_4vHkHR4qZTFZNVSAJJYlODTI,99840
|
|
||||||
distlib/wheel.py,sha256=W6aQQo2Si0CzWiCaqlS-Nu8CoHnDbmcGMqRxCHJmg_Q,43062
|
|
||||||
distlib/_backport/__init__.py,sha256=bqS_dTOH6uW9iGgd0uzfpPjo6vZ4xpPZ7kyfZJ2vNaw,274
|
|
||||||
distlib/_backport/misc.py,sha256=KWecINdbFNOxSOP1fGF680CJnaC6S4fBRgEtaYTw0ig,971
|
|
||||||
distlib/_backport/shutil.py,sha256=IX_G2NPqwecJibkIDje04bqu0xpHkfSQ2GaGdEVqM5Y,25707
|
|
||||||
distlib/_backport/sysconfig.cfg,sha256=swZKxq9RY5e9r3PXCrlvQPMsvOdiWZBTHLEbqS8LJLU,2617
|
|
||||||
distlib/_backport/sysconfig.py,sha256=BQHFlb6pubCl_dvT1NjtzIthylofjKisox239stDg0U,26854
|
|
||||||
distlib/_backport/tarfile.py,sha256=Ihp7rXRcjbIKw8COm9wSePV9ARGXbSF9gGXAMn2Q-KU,92628
|
|
||||||
distlib-0.3.2.dist-info/METADATA,sha256=ZiUBpryb-__fVLO0q26MutK6IyLBrKMXBXTVye-NLrU,1128
|
|
||||||
distlib-0.3.2.dist-info/WHEEL,sha256=drfrJ_lmbrASQtvw0M9reqwR5A6v9iRVE7Z0eesvh7Y,106
|
|
||||||
distlib-0.3.2.dist-info/RECORD,,
|
|
||||||
|
|
@ -1,5 +0,0 @@
|
||||||
Wheel-Version: 1.0
|
|
||||||
Generator: distlib 0.3.2.dev0
|
|
||||||
Root-Is-Purelib: true
|
|
||||||
Tag: py2-none-any
|
|
||||||
Tag: py3-none-any
|
|
||||||
|
|
@ -1,23 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
#
|
|
||||||
# Copyright (C) 2012-2019 Vinay Sajip.
|
|
||||||
# Licensed to the Python Software Foundation under a contributor agreement.
|
|
||||||
# See LICENSE.txt and CONTRIBUTORS.txt.
|
|
||||||
#
|
|
||||||
import logging
|
|
||||||
|
|
||||||
__version__ = '0.3.2'
|
|
||||||
|
|
||||||
class DistlibException(Exception):
|
|
||||||
pass
|
|
||||||
|
|
||||||
try:
|
|
||||||
from logging import NullHandler
|
|
||||||
except ImportError: # pragma: no cover
|
|
||||||
class NullHandler(logging.Handler):
|
|
||||||
def handle(self, record): pass
|
|
||||||
def emit(self, record): pass
|
|
||||||
def createLock(self): self.lock = None
|
|
||||||
|
|
||||||
logger = logging.getLogger(__name__)
|
|
||||||
logger.addHandler(NullHandler())
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
"""Modules copied from Python 3 standard libraries, for internal use only.
|
|
||||||
|
|
||||||
Individual classes and functions are found in d2._backport.misc. Intended
|
|
||||||
usage is to always import things missing from 3.1 from that module: the
|
|
||||||
built-in/stdlib objects will be used if found.
|
|
||||||
"""
|
|
||||||
|
|
@ -1,41 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
#
|
|
||||||
# Copyright (C) 2012 The Python Software Foundation.
|
|
||||||
# See LICENSE.txt and CONTRIBUTORS.txt.
|
|
||||||
#
|
|
||||||
"""Backports for individual classes and functions."""
|
|
||||||
|
|
||||||
import os
|
|
||||||
import sys
|
|
||||||
|
|
||||||
__all__ = ['cache_from_source', 'callable', 'fsencode']
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
from imp import cache_from_source
|
|
||||||
except ImportError:
|
|
||||||
def cache_from_source(py_file, debug=__debug__):
|
|
||||||
ext = debug and 'c' or 'o'
|
|
||||||
return py_file + ext
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
callable = callable
|
|
||||||
except NameError:
|
|
||||||
from collections import Callable
|
|
||||||
|
|
||||||
def callable(obj):
|
|
||||||
return isinstance(obj, Callable)
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
fsencode = os.fsencode
|
|
||||||
except AttributeError:
|
|
||||||
def fsencode(filename):
|
|
||||||
if isinstance(filename, bytes):
|
|
||||||
return filename
|
|
||||||
elif isinstance(filename, str):
|
|
||||||
return filename.encode(sys.getfilesystemencoding())
|
|
||||||
else:
|
|
||||||
raise TypeError("expect bytes or str, not %s" %
|
|
||||||
type(filename).__name__)
|
|
||||||
|
|
@ -1,764 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
#
|
|
||||||
# Copyright (C) 2012 The Python Software Foundation.
|
|
||||||
# See LICENSE.txt and CONTRIBUTORS.txt.
|
|
||||||
#
|
|
||||||
"""Utility functions for copying and archiving files and directory trees.
|
|
||||||
|
|
||||||
XXX The functions here don't copy the resource fork or other metadata on Mac.
|
|
||||||
|
|
||||||
"""
|
|
||||||
|
|
||||||
import os
|
|
||||||
import sys
|
|
||||||
import stat
|
|
||||||
from os.path import abspath
|
|
||||||
import fnmatch
|
|
||||||
try:
|
|
||||||
from collections.abc import Callable
|
|
||||||
except ImportError:
|
|
||||||
from collections import Callable
|
|
||||||
import errno
|
|
||||||
from . import tarfile
|
|
||||||
|
|
||||||
try:
|
|
||||||
import bz2
|
|
||||||
_BZ2_SUPPORTED = True
|
|
||||||
except ImportError:
|
|
||||||
_BZ2_SUPPORTED = False
|
|
||||||
|
|
||||||
try:
|
|
||||||
from pwd import getpwnam
|
|
||||||
except ImportError:
|
|
||||||
getpwnam = None
|
|
||||||
|
|
||||||
try:
|
|
||||||
from grp import getgrnam
|
|
||||||
except ImportError:
|
|
||||||
getgrnam = None
|
|
||||||
|
|
||||||
__all__ = ["copyfileobj", "copyfile", "copymode", "copystat", "copy", "copy2",
|
|
||||||
"copytree", "move", "rmtree", "Error", "SpecialFileError",
|
|
||||||
"ExecError", "make_archive", "get_archive_formats",
|
|
||||||
"register_archive_format", "unregister_archive_format",
|
|
||||||
"get_unpack_formats", "register_unpack_format",
|
|
||||||
"unregister_unpack_format", "unpack_archive", "ignore_patterns"]
|
|
||||||
|
|
||||||
class Error(EnvironmentError):
|
|
||||||
pass
|
|
||||||
|
|
||||||
class SpecialFileError(EnvironmentError):
|
|
||||||
"""Raised when trying to do a kind of operation (e.g. copying) which is
|
|
||||||
not supported on a special file (e.g. a named pipe)"""
|
|
||||||
|
|
||||||
class ExecError(EnvironmentError):
|
|
||||||
"""Raised when a command could not be executed"""
|
|
||||||
|
|
||||||
class ReadError(EnvironmentError):
|
|
||||||
"""Raised when an archive cannot be read"""
|
|
||||||
|
|
||||||
class RegistryError(Exception):
|
|
||||||
"""Raised when a registry operation with the archiving
|
|
||||||
and unpacking registries fails"""
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
WindowsError
|
|
||||||
except NameError:
|
|
||||||
WindowsError = None
|
|
||||||
|
|
||||||
def copyfileobj(fsrc, fdst, length=16*1024):
|
|
||||||
"""copy data from file-like object fsrc to file-like object fdst"""
|
|
||||||
while 1:
|
|
||||||
buf = fsrc.read(length)
|
|
||||||
if not buf:
|
|
||||||
break
|
|
||||||
fdst.write(buf)
|
|
||||||
|
|
||||||
def _samefile(src, dst):
|
|
||||||
# Macintosh, Unix.
|
|
||||||
if hasattr(os.path, 'samefile'):
|
|
||||||
try:
|
|
||||||
return os.path.samefile(src, dst)
|
|
||||||
except OSError:
|
|
||||||
return False
|
|
||||||
|
|
||||||
# All other platforms: check for same pathname.
|
|
||||||
return (os.path.normcase(os.path.abspath(src)) ==
|
|
||||||
os.path.normcase(os.path.abspath(dst)))
|
|
||||||
|
|
||||||
def copyfile(src, dst):
|
|
||||||
"""Copy data from src to dst"""
|
|
||||||
if _samefile(src, dst):
|
|
||||||
raise Error("`%s` and `%s` are the same file" % (src, dst))
|
|
||||||
|
|
||||||
for fn in [src, dst]:
|
|
||||||
try:
|
|
||||||
st = os.stat(fn)
|
|
||||||
except OSError:
|
|
||||||
# File most likely does not exist
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
# XXX What about other special files? (sockets, devices...)
|
|
||||||
if stat.S_ISFIFO(st.st_mode):
|
|
||||||
raise SpecialFileError("`%s` is a named pipe" % fn)
|
|
||||||
|
|
||||||
with open(src, 'rb') as fsrc:
|
|
||||||
with open(dst, 'wb') as fdst:
|
|
||||||
copyfileobj(fsrc, fdst)
|
|
||||||
|
|
||||||
def copymode(src, dst):
|
|
||||||
"""Copy mode bits from src to dst"""
|
|
||||||
if hasattr(os, 'chmod'):
|
|
||||||
st = os.stat(src)
|
|
||||||
mode = stat.S_IMODE(st.st_mode)
|
|
||||||
os.chmod(dst, mode)
|
|
||||||
|
|
||||||
def copystat(src, dst):
|
|
||||||
"""Copy all stat info (mode bits, atime, mtime, flags) from src to dst"""
|
|
||||||
st = os.stat(src)
|
|
||||||
mode = stat.S_IMODE(st.st_mode)
|
|
||||||
if hasattr(os, 'utime'):
|
|
||||||
os.utime(dst, (st.st_atime, st.st_mtime))
|
|
||||||
if hasattr(os, 'chmod'):
|
|
||||||
os.chmod(dst, mode)
|
|
||||||
if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):
|
|
||||||
try:
|
|
||||||
os.chflags(dst, st.st_flags)
|
|
||||||
except OSError as why:
|
|
||||||
if (not hasattr(errno, 'EOPNOTSUPP') or
|
|
||||||
why.errno != errno.EOPNOTSUPP):
|
|
||||||
raise
|
|
||||||
|
|
||||||
def copy(src, dst):
|
|
||||||
"""Copy data and mode bits ("cp src dst").
|
|
||||||
|
|
||||||
The destination may be a directory.
|
|
||||||
|
|
||||||
"""
|
|
||||||
if os.path.isdir(dst):
|
|
||||||
dst = os.path.join(dst, os.path.basename(src))
|
|
||||||
copyfile(src, dst)
|
|
||||||
copymode(src, dst)
|
|
||||||
|
|
||||||
def copy2(src, dst):
|
|
||||||
"""Copy data and all stat info ("cp -p src dst").
|
|
||||||
|
|
||||||
The destination may be a directory.
|
|
||||||
|
|
||||||
"""
|
|
||||||
if os.path.isdir(dst):
|
|
||||||
dst = os.path.join(dst, os.path.basename(src))
|
|
||||||
copyfile(src, dst)
|
|
||||||
copystat(src, dst)
|
|
||||||
|
|
||||||
def ignore_patterns(*patterns):
|
|
||||||
"""Function that can be used as copytree() ignore parameter.
|
|
||||||
|
|
||||||
Patterns is a sequence of glob-style patterns
|
|
||||||
that are used to exclude files"""
|
|
||||||
def _ignore_patterns(path, names):
|
|
||||||
ignored_names = []
|
|
||||||
for pattern in patterns:
|
|
||||||
ignored_names.extend(fnmatch.filter(names, pattern))
|
|
||||||
return set(ignored_names)
|
|
||||||
return _ignore_patterns
|
|
||||||
|
|
||||||
def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,
|
|
||||||
ignore_dangling_symlinks=False):
|
|
||||||
"""Recursively copy a directory tree.
|
|
||||||
|
|
||||||
The destination directory must not already exist.
|
|
||||||
If exception(s) occur, an Error is raised with a list of reasons.
|
|
||||||
|
|
||||||
If the optional symlinks flag is true, symbolic links in the
|
|
||||||
source tree result in symbolic links in the destination tree; if
|
|
||||||
it is false, the contents of the files pointed to by symbolic
|
|
||||||
links are copied. If the file pointed by the symlink doesn't
|
|
||||||
exist, an exception will be added in the list of errors raised in
|
|
||||||
an Error exception at the end of the copy process.
|
|
||||||
|
|
||||||
You can set the optional ignore_dangling_symlinks flag to true if you
|
|
||||||
want to silence this exception. Notice that this has no effect on
|
|
||||||
platforms that don't support os.symlink.
|
|
||||||
|
|
||||||
The optional ignore argument is a callable. If given, it
|
|
||||||
is called with the `src` parameter, which is the directory
|
|
||||||
being visited by copytree(), and `names` which is the list of
|
|
||||||
`src` contents, as returned by os.listdir():
|
|
||||||
|
|
||||||
callable(src, names) -> ignored_names
|
|
||||||
|
|
||||||
Since copytree() is called recursively, the callable will be
|
|
||||||
called once for each directory that is copied. It returns a
|
|
||||||
list of names relative to the `src` directory that should
|
|
||||||
not be copied.
|
|
||||||
|
|
||||||
The optional copy_function argument is a callable that will be used
|
|
||||||
to copy each file. It will be called with the source path and the
|
|
||||||
destination path as arguments. By default, copy2() is used, but any
|
|
||||||
function that supports the same signature (like copy()) can be used.
|
|
||||||
|
|
||||||
"""
|
|
||||||
names = os.listdir(src)
|
|
||||||
if ignore is not None:
|
|
||||||
ignored_names = ignore(src, names)
|
|
||||||
else:
|
|
||||||
ignored_names = set()
|
|
||||||
|
|
||||||
os.makedirs(dst)
|
|
||||||
errors = []
|
|
||||||
for name in names:
|
|
||||||
if name in ignored_names:
|
|
||||||
continue
|
|
||||||
srcname = os.path.join(src, name)
|
|
||||||
dstname = os.path.join(dst, name)
|
|
||||||
try:
|
|
||||||
if os.path.islink(srcname):
|
|
||||||
linkto = os.readlink(srcname)
|
|
||||||
if symlinks:
|
|
||||||
os.symlink(linkto, dstname)
|
|
||||||
else:
|
|
||||||
# ignore dangling symlink if the flag is on
|
|
||||||
if not os.path.exists(linkto) and ignore_dangling_symlinks:
|
|
||||||
continue
|
|
||||||
# otherwise let the copy occurs. copy2 will raise an error
|
|
||||||
copy_function(srcname, dstname)
|
|
||||||
elif os.path.isdir(srcname):
|
|
||||||
copytree(srcname, dstname, symlinks, ignore, copy_function)
|
|
||||||
else:
|
|
||||||
# Will raise a SpecialFileError for unsupported file types
|
|
||||||
copy_function(srcname, dstname)
|
|
||||||
# catch the Error from the recursive copytree so that we can
|
|
||||||
# continue with other files
|
|
||||||
except Error as err:
|
|
||||||
errors.extend(err.args[0])
|
|
||||||
except EnvironmentError as why:
|
|
||||||
errors.append((srcname, dstname, str(why)))
|
|
||||||
try:
|
|
||||||
copystat(src, dst)
|
|
||||||
except OSError as why:
|
|
||||||
if WindowsError is not None and isinstance(why, WindowsError):
|
|
||||||
# Copying file access times may fail on Windows
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
errors.extend((src, dst, str(why)))
|
|
||||||
if errors:
|
|
||||||
raise Error(errors)
|
|
||||||
|
|
||||||
def rmtree(path, ignore_errors=False, onerror=None):
|
|
||||||
"""Recursively delete a directory tree.
|
|
||||||
|
|
||||||
If ignore_errors is set, errors are ignored; otherwise, if onerror
|
|
||||||
is set, it is called to handle the error with arguments (func,
|
|
||||||
path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
|
|
||||||
path is the argument to that function that caused it to fail; and
|
|
||||||
exc_info is a tuple returned by sys.exc_info(). If ignore_errors
|
|
||||||
is false and onerror is None, an exception is raised.
|
|
||||||
|
|
||||||
"""
|
|
||||||
if ignore_errors:
|
|
||||||
def onerror(*args):
|
|
||||||
pass
|
|
||||||
elif onerror is None:
|
|
||||||
def onerror(*args):
|
|
||||||
raise
|
|
||||||
try:
|
|
||||||
if os.path.islink(path):
|
|
||||||
# symlinks to directories are forbidden, see bug #1669
|
|
||||||
raise OSError("Cannot call rmtree on a symbolic link")
|
|
||||||
except OSError:
|
|
||||||
onerror(os.path.islink, path, sys.exc_info())
|
|
||||||
# can't continue even if onerror hook returns
|
|
||||||
return
|
|
||||||
names = []
|
|
||||||
try:
|
|
||||||
names = os.listdir(path)
|
|
||||||
except os.error:
|
|
||||||
onerror(os.listdir, path, sys.exc_info())
|
|
||||||
for name in names:
|
|
||||||
fullname = os.path.join(path, name)
|
|
||||||
try:
|
|
||||||
mode = os.lstat(fullname).st_mode
|
|
||||||
except os.error:
|
|
||||||
mode = 0
|
|
||||||
if stat.S_ISDIR(mode):
|
|
||||||
rmtree(fullname, ignore_errors, onerror)
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
os.remove(fullname)
|
|
||||||
except os.error:
|
|
||||||
onerror(os.remove, fullname, sys.exc_info())
|
|
||||||
try:
|
|
||||||
os.rmdir(path)
|
|
||||||
except os.error:
|
|
||||||
onerror(os.rmdir, path, sys.exc_info())
|
|
||||||
|
|
||||||
|
|
||||||
def _basename(path):
|
|
||||||
# A basename() variant which first strips the trailing slash, if present.
|
|
||||||
# Thus we always get the last component of the path, even for directories.
|
|
||||||
return os.path.basename(path.rstrip(os.path.sep))
|
|
||||||
|
|
||||||
def move(src, dst):
|
|
||||||
"""Recursively move a file or directory to another location. This is
|
|
||||||
similar to the Unix "mv" command.
|
|
||||||
|
|
||||||
If the destination is a directory or a symlink to a directory, the source
|
|
||||||
is moved inside the directory. The destination path must not already
|
|
||||||
exist.
|
|
||||||
|
|
||||||
If the destination already exists but is not a directory, it may be
|
|
||||||
overwritten depending on os.rename() semantics.
|
|
||||||
|
|
||||||
If the destination is on our current filesystem, then rename() is used.
|
|
||||||
Otherwise, src is copied to the destination and then removed.
|
|
||||||
A lot more could be done here... A look at a mv.c shows a lot of
|
|
||||||
the issues this implementation glosses over.
|
|
||||||
|
|
||||||
"""
|
|
||||||
real_dst = dst
|
|
||||||
if os.path.isdir(dst):
|
|
||||||
if _samefile(src, dst):
|
|
||||||
# We might be on a case insensitive filesystem,
|
|
||||||
# perform the rename anyway.
|
|
||||||
os.rename(src, dst)
|
|
||||||
return
|
|
||||||
|
|
||||||
real_dst = os.path.join(dst, _basename(src))
|
|
||||||
if os.path.exists(real_dst):
|
|
||||||
raise Error("Destination path '%s' already exists" % real_dst)
|
|
||||||
try:
|
|
||||||
os.rename(src, real_dst)
|
|
||||||
except OSError:
|
|
||||||
if os.path.isdir(src):
|
|
||||||
if _destinsrc(src, dst):
|
|
||||||
raise Error("Cannot move a directory '%s' into itself '%s'." % (src, dst))
|
|
||||||
copytree(src, real_dst, symlinks=True)
|
|
||||||
rmtree(src)
|
|
||||||
else:
|
|
||||||
copy2(src, real_dst)
|
|
||||||
os.unlink(src)
|
|
||||||
|
|
||||||
def _destinsrc(src, dst):
|
|
||||||
src = abspath(src)
|
|
||||||
dst = abspath(dst)
|
|
||||||
if not src.endswith(os.path.sep):
|
|
||||||
src += os.path.sep
|
|
||||||
if not dst.endswith(os.path.sep):
|
|
||||||
dst += os.path.sep
|
|
||||||
return dst.startswith(src)
|
|
||||||
|
|
||||||
def _get_gid(name):
|
|
||||||
"""Returns a gid, given a group name."""
|
|
||||||
if getgrnam is None or name is None:
|
|
||||||
return None
|
|
||||||
try:
|
|
||||||
result = getgrnam(name)
|
|
||||||
except KeyError:
|
|
||||||
result = None
|
|
||||||
if result is not None:
|
|
||||||
return result[2]
|
|
||||||
return None
|
|
||||||
|
|
||||||
def _get_uid(name):
|
|
||||||
"""Returns an uid, given a user name."""
|
|
||||||
if getpwnam is None or name is None:
|
|
||||||
return None
|
|
||||||
try:
|
|
||||||
result = getpwnam(name)
|
|
||||||
except KeyError:
|
|
||||||
result = None
|
|
||||||
if result is not None:
|
|
||||||
return result[2]
|
|
||||||
return None
|
|
||||||
|
|
||||||
def _make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
|
|
||||||
owner=None, group=None, logger=None):
|
|
||||||
"""Create a (possibly compressed) tar file from all the files under
|
|
||||||
'base_dir'.
|
|
||||||
|
|
||||||
'compress' must be "gzip" (the default), "bzip2", or None.
|
|
||||||
|
|
||||||
'owner' and 'group' can be used to define an owner and a group for the
|
|
||||||
archive that is being built. If not provided, the current owner and group
|
|
||||||
will be used.
|
|
||||||
|
|
||||||
The output tar file will be named 'base_name' + ".tar", possibly plus
|
|
||||||
the appropriate compression extension (".gz", or ".bz2").
|
|
||||||
|
|
||||||
Returns the output filename.
|
|
||||||
"""
|
|
||||||
tar_compression = {'gzip': 'gz', None: ''}
|
|
||||||
compress_ext = {'gzip': '.gz'}
|
|
||||||
|
|
||||||
if _BZ2_SUPPORTED:
|
|
||||||
tar_compression['bzip2'] = 'bz2'
|
|
||||||
compress_ext['bzip2'] = '.bz2'
|
|
||||||
|
|
||||||
# flags for compression program, each element of list will be an argument
|
|
||||||
if compress is not None and compress not in compress_ext:
|
|
||||||
raise ValueError("bad value for 'compress', or compression format not "
|
|
||||||
"supported : {0}".format(compress))
|
|
||||||
|
|
||||||
archive_name = base_name + '.tar' + compress_ext.get(compress, '')
|
|
||||||
archive_dir = os.path.dirname(archive_name)
|
|
||||||
|
|
||||||
if not os.path.exists(archive_dir):
|
|
||||||
if logger is not None:
|
|
||||||
logger.info("creating %s", archive_dir)
|
|
||||||
if not dry_run:
|
|
||||||
os.makedirs(archive_dir)
|
|
||||||
|
|
||||||
# creating the tarball
|
|
||||||
if logger is not None:
|
|
||||||
logger.info('Creating tar archive')
|
|
||||||
|
|
||||||
uid = _get_uid(owner)
|
|
||||||
gid = _get_gid(group)
|
|
||||||
|
|
||||||
def _set_uid_gid(tarinfo):
|
|
||||||
if gid is not None:
|
|
||||||
tarinfo.gid = gid
|
|
||||||
tarinfo.gname = group
|
|
||||||
if uid is not None:
|
|
||||||
tarinfo.uid = uid
|
|
||||||
tarinfo.uname = owner
|
|
||||||
return tarinfo
|
|
||||||
|
|
||||||
if not dry_run:
|
|
||||||
tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
|
|
||||||
try:
|
|
||||||
tar.add(base_dir, filter=_set_uid_gid)
|
|
||||||
finally:
|
|
||||||
tar.close()
|
|
||||||
|
|
||||||
return archive_name
|
|
||||||
|
|
||||||
def _call_external_zip(base_dir, zip_filename, verbose=False, dry_run=False):
|
|
||||||
# XXX see if we want to keep an external call here
|
|
||||||
if verbose:
|
|
||||||
zipoptions = "-r"
|
|
||||||
else:
|
|
||||||
zipoptions = "-rq"
|
|
||||||
from distutils.errors import DistutilsExecError
|
|
||||||
from distutils.spawn import spawn
|
|
||||||
try:
|
|
||||||
spawn(["zip", zipoptions, zip_filename, base_dir], dry_run=dry_run)
|
|
||||||
except DistutilsExecError:
|
|
||||||
# XXX really should distinguish between "couldn't find
|
|
||||||
# external 'zip' command" and "zip failed".
|
|
||||||
raise ExecError("unable to create zip file '%s': "
|
|
||||||
"could neither import the 'zipfile' module nor "
|
|
||||||
"find a standalone zip utility") % zip_filename
|
|
||||||
|
|
||||||
def _make_zipfile(base_name, base_dir, verbose=0, dry_run=0, logger=None):
|
|
||||||
"""Create a zip file from all the files under 'base_dir'.
|
|
||||||
|
|
||||||
The output zip file will be named 'base_name' + ".zip". Uses either the
|
|
||||||
"zipfile" Python module (if available) or the InfoZIP "zip" utility
|
|
||||||
(if installed and found on the default search path). If neither tool is
|
|
||||||
available, raises ExecError. Returns the name of the output zip
|
|
||||||
file.
|
|
||||||
"""
|
|
||||||
zip_filename = base_name + ".zip"
|
|
||||||
archive_dir = os.path.dirname(base_name)
|
|
||||||
|
|
||||||
if not os.path.exists(archive_dir):
|
|
||||||
if logger is not None:
|
|
||||||
logger.info("creating %s", archive_dir)
|
|
||||||
if not dry_run:
|
|
||||||
os.makedirs(archive_dir)
|
|
||||||
|
|
||||||
# If zipfile module is not available, try spawning an external 'zip'
|
|
||||||
# command.
|
|
||||||
try:
|
|
||||||
import zipfile
|
|
||||||
except ImportError:
|
|
||||||
zipfile = None
|
|
||||||
|
|
||||||
if zipfile is None:
|
|
||||||
_call_external_zip(base_dir, zip_filename, verbose, dry_run)
|
|
||||||
else:
|
|
||||||
if logger is not None:
|
|
||||||
logger.info("creating '%s' and adding '%s' to it",
|
|
||||||
zip_filename, base_dir)
|
|
||||||
|
|
||||||
if not dry_run:
|
|
||||||
zip = zipfile.ZipFile(zip_filename, "w",
|
|
||||||
compression=zipfile.ZIP_DEFLATED)
|
|
||||||
|
|
||||||
for dirpath, dirnames, filenames in os.walk(base_dir):
|
|
||||||
for name in filenames:
|
|
||||||
path = os.path.normpath(os.path.join(dirpath, name))
|
|
||||||
if os.path.isfile(path):
|
|
||||||
zip.write(path, path)
|
|
||||||
if logger is not None:
|
|
||||||
logger.info("adding '%s'", path)
|
|
||||||
zip.close()
|
|
||||||
|
|
||||||
return zip_filename
|
|
||||||
|
|
||||||
_ARCHIVE_FORMATS = {
|
|
||||||
'gztar': (_make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
|
|
||||||
'bztar': (_make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
|
|
||||||
'tar': (_make_tarball, [('compress', None)], "uncompressed tar file"),
|
|
||||||
'zip': (_make_zipfile, [], "ZIP file"),
|
|
||||||
}
|
|
||||||
|
|
||||||
if _BZ2_SUPPORTED:
|
|
||||||
_ARCHIVE_FORMATS['bztar'] = (_make_tarball, [('compress', 'bzip2')],
|
|
||||||
"bzip2'ed tar-file")
|
|
||||||
|
|
||||||
def get_archive_formats():
|
|
||||||
"""Returns a list of supported formats for archiving and unarchiving.
|
|
||||||
|
|
||||||
Each element of the returned sequence is a tuple (name, description)
|
|
||||||
"""
|
|
||||||
formats = [(name, registry[2]) for name, registry in
|
|
||||||
_ARCHIVE_FORMATS.items()]
|
|
||||||
formats.sort()
|
|
||||||
return formats
|
|
||||||
|
|
||||||
def register_archive_format(name, function, extra_args=None, description=''):
|
|
||||||
"""Registers an archive format.
|
|
||||||
|
|
||||||
name is the name of the format. function is the callable that will be
|
|
||||||
used to create archives. If provided, extra_args is a sequence of
|
|
||||||
(name, value) tuples that will be passed as arguments to the callable.
|
|
||||||
description can be provided to describe the format, and will be returned
|
|
||||||
by the get_archive_formats() function.
|
|
||||||
"""
|
|
||||||
if extra_args is None:
|
|
||||||
extra_args = []
|
|
||||||
if not isinstance(function, Callable):
|
|
||||||
raise TypeError('The %s object is not callable' % function)
|
|
||||||
if not isinstance(extra_args, (tuple, list)):
|
|
||||||
raise TypeError('extra_args needs to be a sequence')
|
|
||||||
for element in extra_args:
|
|
||||||
if not isinstance(element, (tuple, list)) or len(element) !=2:
|
|
||||||
raise TypeError('extra_args elements are : (arg_name, value)')
|
|
||||||
|
|
||||||
_ARCHIVE_FORMATS[name] = (function, extra_args, description)
|
|
||||||
|
|
||||||
def unregister_archive_format(name):
|
|
||||||
del _ARCHIVE_FORMATS[name]
|
|
||||||
|
|
||||||
def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
|
|
||||||
dry_run=0, owner=None, group=None, logger=None):
|
|
||||||
"""Create an archive file (eg. zip or tar).
|
|
||||||
|
|
||||||
'base_name' is the name of the file to create, minus any format-specific
|
|
||||||
extension; 'format' is the archive format: one of "zip", "tar", "bztar"
|
|
||||||
or "gztar".
|
|
||||||
|
|
||||||
'root_dir' is a directory that will be the root directory of the
|
|
||||||
archive; ie. we typically chdir into 'root_dir' before creating the
|
|
||||||
archive. 'base_dir' is the directory where we start archiving from;
|
|
||||||
ie. 'base_dir' will be the common prefix of all files and
|
|
||||||
directories in the archive. 'root_dir' and 'base_dir' both default
|
|
||||||
to the current directory. Returns the name of the archive file.
|
|
||||||
|
|
||||||
'owner' and 'group' are used when creating a tar archive. By default,
|
|
||||||
uses the current owner and group.
|
|
||||||
"""
|
|
||||||
save_cwd = os.getcwd()
|
|
||||||
if root_dir is not None:
|
|
||||||
if logger is not None:
|
|
||||||
logger.debug("changing into '%s'", root_dir)
|
|
||||||
base_name = os.path.abspath(base_name)
|
|
||||||
if not dry_run:
|
|
||||||
os.chdir(root_dir)
|
|
||||||
|
|
||||||
if base_dir is None:
|
|
||||||
base_dir = os.curdir
|
|
||||||
|
|
||||||
kwargs = {'dry_run': dry_run, 'logger': logger}
|
|
||||||
|
|
||||||
try:
|
|
||||||
format_info = _ARCHIVE_FORMATS[format]
|
|
||||||
except KeyError:
|
|
||||||
raise ValueError("unknown archive format '%s'" % format)
|
|
||||||
|
|
||||||
func = format_info[0]
|
|
||||||
for arg, val in format_info[1]:
|
|
||||||
kwargs[arg] = val
|
|
||||||
|
|
||||||
if format != 'zip':
|
|
||||||
kwargs['owner'] = owner
|
|
||||||
kwargs['group'] = group
|
|
||||||
|
|
||||||
try:
|
|
||||||
filename = func(base_name, base_dir, **kwargs)
|
|
||||||
finally:
|
|
||||||
if root_dir is not None:
|
|
||||||
if logger is not None:
|
|
||||||
logger.debug("changing back to '%s'", save_cwd)
|
|
||||||
os.chdir(save_cwd)
|
|
||||||
|
|
||||||
return filename
|
|
||||||
|
|
||||||
|
|
||||||
def get_unpack_formats():
|
|
||||||
"""Returns a list of supported formats for unpacking.
|
|
||||||
|
|
||||||
Each element of the returned sequence is a tuple
|
|
||||||
(name, extensions, description)
|
|
||||||
"""
|
|
||||||
formats = [(name, info[0], info[3]) for name, info in
|
|
||||||
_UNPACK_FORMATS.items()]
|
|
||||||
formats.sort()
|
|
||||||
return formats
|
|
||||||
|
|
||||||
def _check_unpack_options(extensions, function, extra_args):
|
|
||||||
"""Checks what gets registered as an unpacker."""
|
|
||||||
# first make sure no other unpacker is registered for this extension
|
|
||||||
existing_extensions = {}
|
|
||||||
for name, info in _UNPACK_FORMATS.items():
|
|
||||||
for ext in info[0]:
|
|
||||||
existing_extensions[ext] = name
|
|
||||||
|
|
||||||
for extension in extensions:
|
|
||||||
if extension in existing_extensions:
|
|
||||||
msg = '%s is already registered for "%s"'
|
|
||||||
raise RegistryError(msg % (extension,
|
|
||||||
existing_extensions[extension]))
|
|
||||||
|
|
||||||
if not isinstance(function, Callable):
|
|
||||||
raise TypeError('The registered function must be a callable')
|
|
||||||
|
|
||||||
|
|
||||||
def register_unpack_format(name, extensions, function, extra_args=None,
|
|
||||||
description=''):
|
|
||||||
"""Registers an unpack format.
|
|
||||||
|
|
||||||
`name` is the name of the format. `extensions` is a list of extensions
|
|
||||||
corresponding to the format.
|
|
||||||
|
|
||||||
`function` is the callable that will be
|
|
||||||
used to unpack archives. The callable will receive archives to unpack.
|
|
||||||
If it's unable to handle an archive, it needs to raise a ReadError
|
|
||||||
exception.
|
|
||||||
|
|
||||||
If provided, `extra_args` is a sequence of
|
|
||||||
(name, value) tuples that will be passed as arguments to the callable.
|
|
||||||
description can be provided to describe the format, and will be returned
|
|
||||||
by the get_unpack_formats() function.
|
|
||||||
"""
|
|
||||||
if extra_args is None:
|
|
||||||
extra_args = []
|
|
||||||
_check_unpack_options(extensions, function, extra_args)
|
|
||||||
_UNPACK_FORMATS[name] = extensions, function, extra_args, description
|
|
||||||
|
|
||||||
def unregister_unpack_format(name):
|
|
||||||
"""Removes the pack format from the registry."""
|
|
||||||
del _UNPACK_FORMATS[name]
|
|
||||||
|
|
||||||
def _ensure_directory(path):
|
|
||||||
"""Ensure that the parent directory of `path` exists"""
|
|
||||||
dirname = os.path.dirname(path)
|
|
||||||
if not os.path.isdir(dirname):
|
|
||||||
os.makedirs(dirname)
|
|
||||||
|
|
||||||
def _unpack_zipfile(filename, extract_dir):
|
|
||||||
"""Unpack zip `filename` to `extract_dir`
|
|
||||||
"""
|
|
||||||
try:
|
|
||||||
import zipfile
|
|
||||||
except ImportError:
|
|
||||||
raise ReadError('zlib not supported, cannot unpack this archive.')
|
|
||||||
|
|
||||||
if not zipfile.is_zipfile(filename):
|
|
||||||
raise ReadError("%s is not a zip file" % filename)
|
|
||||||
|
|
||||||
zip = zipfile.ZipFile(filename)
|
|
||||||
try:
|
|
||||||
for info in zip.infolist():
|
|
||||||
name = info.filename
|
|
||||||
|
|
||||||
# don't extract absolute paths or ones with .. in them
|
|
||||||
if name.startswith('/') or '..' in name:
|
|
||||||
continue
|
|
||||||
|
|
||||||
target = os.path.join(extract_dir, *name.split('/'))
|
|
||||||
if not target:
|
|
||||||
continue
|
|
||||||
|
|
||||||
_ensure_directory(target)
|
|
||||||
if not name.endswith('/'):
|
|
||||||
# file
|
|
||||||
data = zip.read(info.filename)
|
|
||||||
f = open(target, 'wb')
|
|
||||||
try:
|
|
||||||
f.write(data)
|
|
||||||
finally:
|
|
||||||
f.close()
|
|
||||||
del data
|
|
||||||
finally:
|
|
||||||
zip.close()
|
|
||||||
|
|
||||||
def _unpack_tarfile(filename, extract_dir):
|
|
||||||
"""Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
|
|
||||||
"""
|
|
||||||
try:
|
|
||||||
tarobj = tarfile.open(filename)
|
|
||||||
except tarfile.TarError:
|
|
||||||
raise ReadError(
|
|
||||||
"%s is not a compressed or uncompressed tar file" % filename)
|
|
||||||
try:
|
|
||||||
tarobj.extractall(extract_dir)
|
|
||||||
finally:
|
|
||||||
tarobj.close()
|
|
||||||
|
|
||||||
_UNPACK_FORMATS = {
|
|
||||||
'gztar': (['.tar.gz', '.tgz'], _unpack_tarfile, [], "gzip'ed tar-file"),
|
|
||||||
'tar': (['.tar'], _unpack_tarfile, [], "uncompressed tar file"),
|
|
||||||
'zip': (['.zip'], _unpack_zipfile, [], "ZIP file")
|
|
||||||
}
|
|
||||||
|
|
||||||
if _BZ2_SUPPORTED:
|
|
||||||
_UNPACK_FORMATS['bztar'] = (['.bz2'], _unpack_tarfile, [],
|
|
||||||
"bzip2'ed tar-file")
|
|
||||||
|
|
||||||
def _find_unpack_format(filename):
|
|
||||||
for name, info in _UNPACK_FORMATS.items():
|
|
||||||
for extension in info[0]:
|
|
||||||
if filename.endswith(extension):
|
|
||||||
return name
|
|
||||||
return None
|
|
||||||
|
|
||||||
def unpack_archive(filename, extract_dir=None, format=None):
|
|
||||||
"""Unpack an archive.
|
|
||||||
|
|
||||||
`filename` is the name of the archive.
|
|
||||||
|
|
||||||
`extract_dir` is the name of the target directory, where the archive
|
|
||||||
is unpacked. If not provided, the current working directory is used.
|
|
||||||
|
|
||||||
`format` is the archive format: one of "zip", "tar", or "gztar". Or any
|
|
||||||
other registered format. If not provided, unpack_archive will use the
|
|
||||||
filename extension and see if an unpacker was registered for that
|
|
||||||
extension.
|
|
||||||
|
|
||||||
In case none is found, a ValueError is raised.
|
|
||||||
"""
|
|
||||||
if extract_dir is None:
|
|
||||||
extract_dir = os.getcwd()
|
|
||||||
|
|
||||||
if format is not None:
|
|
||||||
try:
|
|
||||||
format_info = _UNPACK_FORMATS[format]
|
|
||||||
except KeyError:
|
|
||||||
raise ValueError("Unknown unpack format '{0}'".format(format))
|
|
||||||
|
|
||||||
func = format_info[1]
|
|
||||||
func(filename, extract_dir, **dict(format_info[2]))
|
|
||||||
else:
|
|
||||||
# we need to look at the registered unpackers supported extensions
|
|
||||||
format = _find_unpack_format(filename)
|
|
||||||
if format is None:
|
|
||||||
raise ReadError("Unknown archive format '{0}'".format(filename))
|
|
||||||
|
|
||||||
func = _UNPACK_FORMATS[format][1]
|
|
||||||
kwargs = dict(_UNPACK_FORMATS[format][2])
|
|
||||||
func(filename, extract_dir, **kwargs)
|
|
||||||
|
|
@ -1,84 +0,0 @@
|
||||||
[posix_prefix]
|
|
||||||
# Configuration directories. Some of these come straight out of the
|
|
||||||
# configure script. They are for implementing the other variables, not to
|
|
||||||
# be used directly in [resource_locations].
|
|
||||||
confdir = /etc
|
|
||||||
datadir = /usr/share
|
|
||||||
libdir = /usr/lib
|
|
||||||
statedir = /var
|
|
||||||
# User resource directory
|
|
||||||
local = ~/.local/{distribution.name}
|
|
||||||
|
|
||||||
stdlib = {base}/lib/python{py_version_short}
|
|
||||||
platstdlib = {platbase}/lib/python{py_version_short}
|
|
||||||
purelib = {base}/lib/python{py_version_short}/site-packages
|
|
||||||
platlib = {platbase}/lib/python{py_version_short}/site-packages
|
|
||||||
include = {base}/include/python{py_version_short}{abiflags}
|
|
||||||
platinclude = {platbase}/include/python{py_version_short}{abiflags}
|
|
||||||
data = {base}
|
|
||||||
|
|
||||||
[posix_home]
|
|
||||||
stdlib = {base}/lib/python
|
|
||||||
platstdlib = {base}/lib/python
|
|
||||||
purelib = {base}/lib/python
|
|
||||||
platlib = {base}/lib/python
|
|
||||||
include = {base}/include/python
|
|
||||||
platinclude = {base}/include/python
|
|
||||||
scripts = {base}/bin
|
|
||||||
data = {base}
|
|
||||||
|
|
||||||
[nt]
|
|
||||||
stdlib = {base}/Lib
|
|
||||||
platstdlib = {base}/Lib
|
|
||||||
purelib = {base}/Lib/site-packages
|
|
||||||
platlib = {base}/Lib/site-packages
|
|
||||||
include = {base}/Include
|
|
||||||
platinclude = {base}/Include
|
|
||||||
scripts = {base}/Scripts
|
|
||||||
data = {base}
|
|
||||||
|
|
||||||
[os2]
|
|
||||||
stdlib = {base}/Lib
|
|
||||||
platstdlib = {base}/Lib
|
|
||||||
purelib = {base}/Lib/site-packages
|
|
||||||
platlib = {base}/Lib/site-packages
|
|
||||||
include = {base}/Include
|
|
||||||
platinclude = {base}/Include
|
|
||||||
scripts = {base}/Scripts
|
|
||||||
data = {base}
|
|
||||||
|
|
||||||
[os2_home]
|
|
||||||
stdlib = {userbase}/lib/python{py_version_short}
|
|
||||||
platstdlib = {userbase}/lib/python{py_version_short}
|
|
||||||
purelib = {userbase}/lib/python{py_version_short}/site-packages
|
|
||||||
platlib = {userbase}/lib/python{py_version_short}/site-packages
|
|
||||||
include = {userbase}/include/python{py_version_short}
|
|
||||||
scripts = {userbase}/bin
|
|
||||||
data = {userbase}
|
|
||||||
|
|
||||||
[nt_user]
|
|
||||||
stdlib = {userbase}/Python{py_version_nodot}
|
|
||||||
platstdlib = {userbase}/Python{py_version_nodot}
|
|
||||||
purelib = {userbase}/Python{py_version_nodot}/site-packages
|
|
||||||
platlib = {userbase}/Python{py_version_nodot}/site-packages
|
|
||||||
include = {userbase}/Python{py_version_nodot}/Include
|
|
||||||
scripts = {userbase}/Scripts
|
|
||||||
data = {userbase}
|
|
||||||
|
|
||||||
[posix_user]
|
|
||||||
stdlib = {userbase}/lib/python{py_version_short}
|
|
||||||
platstdlib = {userbase}/lib/python{py_version_short}
|
|
||||||
purelib = {userbase}/lib/python{py_version_short}/site-packages
|
|
||||||
platlib = {userbase}/lib/python{py_version_short}/site-packages
|
|
||||||
include = {userbase}/include/python{py_version_short}
|
|
||||||
scripts = {userbase}/bin
|
|
||||||
data = {userbase}
|
|
||||||
|
|
||||||
[osx_framework_user]
|
|
||||||
stdlib = {userbase}/lib/python
|
|
||||||
platstdlib = {userbase}/lib/python
|
|
||||||
purelib = {userbase}/lib/python/site-packages
|
|
||||||
platlib = {userbase}/lib/python/site-packages
|
|
||||||
include = {userbase}/include
|
|
||||||
scripts = {userbase}/bin
|
|
||||||
data = {userbase}
|
|
||||||
|
|
@ -1,786 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
#
|
|
||||||
# Copyright (C) 2012 The Python Software Foundation.
|
|
||||||
# See LICENSE.txt and CONTRIBUTORS.txt.
|
|
||||||
#
|
|
||||||
"""Access to Python's configuration information."""
|
|
||||||
|
|
||||||
import codecs
|
|
||||||
import os
|
|
||||||
import re
|
|
||||||
import sys
|
|
||||||
from os.path import pardir, realpath
|
|
||||||
try:
|
|
||||||
import configparser
|
|
||||||
except ImportError:
|
|
||||||
import ConfigParser as configparser
|
|
||||||
|
|
||||||
|
|
||||||
__all__ = [
|
|
||||||
'get_config_h_filename',
|
|
||||||
'get_config_var',
|
|
||||||
'get_config_vars',
|
|
||||||
'get_makefile_filename',
|
|
||||||
'get_path',
|
|
||||||
'get_path_names',
|
|
||||||
'get_paths',
|
|
||||||
'get_platform',
|
|
||||||
'get_python_version',
|
|
||||||
'get_scheme_names',
|
|
||||||
'parse_config_h',
|
|
||||||
]
|
|
||||||
|
|
||||||
|
|
||||||
def _safe_realpath(path):
|
|
||||||
try:
|
|
||||||
return realpath(path)
|
|
||||||
except OSError:
|
|
||||||
return path
|
|
||||||
|
|
||||||
|
|
||||||
if sys.executable:
|
|
||||||
_PROJECT_BASE = os.path.dirname(_safe_realpath(sys.executable))
|
|
||||||
else:
|
|
||||||
# sys.executable can be empty if argv[0] has been changed and Python is
|
|
||||||
# unable to retrieve the real program name
|
|
||||||
_PROJECT_BASE = _safe_realpath(os.getcwd())
|
|
||||||
|
|
||||||
if os.name == "nt" and "pcbuild" in _PROJECT_BASE[-8:].lower():
|
|
||||||
_PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir))
|
|
||||||
# PC/VS7.1
|
|
||||||
if os.name == "nt" and "\\pc\\v" in _PROJECT_BASE[-10:].lower():
|
|
||||||
_PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
|
|
||||||
# PC/AMD64
|
|
||||||
if os.name == "nt" and "\\pcbuild\\amd64" in _PROJECT_BASE[-14:].lower():
|
|
||||||
_PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
|
|
||||||
|
|
||||||
|
|
||||||
def is_python_build():
|
|
||||||
for fn in ("Setup.dist", "Setup.local"):
|
|
||||||
if os.path.isfile(os.path.join(_PROJECT_BASE, "Modules", fn)):
|
|
||||||
return True
|
|
||||||
return False
|
|
||||||
|
|
||||||
_PYTHON_BUILD = is_python_build()
|
|
||||||
|
|
||||||
_cfg_read = False
|
|
||||||
|
|
||||||
def _ensure_cfg_read():
|
|
||||||
global _cfg_read
|
|
||||||
if not _cfg_read:
|
|
||||||
from ..resources import finder
|
|
||||||
backport_package = __name__.rsplit('.', 1)[0]
|
|
||||||
_finder = finder(backport_package)
|
|
||||||
_cfgfile = _finder.find('sysconfig.cfg')
|
|
||||||
assert _cfgfile, 'sysconfig.cfg exists'
|
|
||||||
with _cfgfile.as_stream() as s:
|
|
||||||
_SCHEMES.readfp(s)
|
|
||||||
if _PYTHON_BUILD:
|
|
||||||
for scheme in ('posix_prefix', 'posix_home'):
|
|
||||||
_SCHEMES.set(scheme, 'include', '{srcdir}/Include')
|
|
||||||
_SCHEMES.set(scheme, 'platinclude', '{projectbase}/.')
|
|
||||||
|
|
||||||
_cfg_read = True
|
|
||||||
|
|
||||||
|
|
||||||
_SCHEMES = configparser.RawConfigParser()
|
|
||||||
_VAR_REPL = re.compile(r'\{([^{]*?)\}')
|
|
||||||
|
|
||||||
def _expand_globals(config):
|
|
||||||
_ensure_cfg_read()
|
|
||||||
if config.has_section('globals'):
|
|
||||||
globals = config.items('globals')
|
|
||||||
else:
|
|
||||||
globals = tuple()
|
|
||||||
|
|
||||||
sections = config.sections()
|
|
||||||
for section in sections:
|
|
||||||
if section == 'globals':
|
|
||||||
continue
|
|
||||||
for option, value in globals:
|
|
||||||
if config.has_option(section, option):
|
|
||||||
continue
|
|
||||||
config.set(section, option, value)
|
|
||||||
config.remove_section('globals')
|
|
||||||
|
|
||||||
# now expanding local variables defined in the cfg file
|
|
||||||
#
|
|
||||||
for section in config.sections():
|
|
||||||
variables = dict(config.items(section))
|
|
||||||
|
|
||||||
def _replacer(matchobj):
|
|
||||||
name = matchobj.group(1)
|
|
||||||
if name in variables:
|
|
||||||
return variables[name]
|
|
||||||
return matchobj.group(0)
|
|
||||||
|
|
||||||
for option, value in config.items(section):
|
|
||||||
config.set(section, option, _VAR_REPL.sub(_replacer, value))
|
|
||||||
|
|
||||||
#_expand_globals(_SCHEMES)
|
|
||||||
|
|
||||||
_PY_VERSION = '%s.%s.%s' % sys.version_info[:3]
|
|
||||||
_PY_VERSION_SHORT = '%s.%s' % sys.version_info[:2]
|
|
||||||
_PY_VERSION_SHORT_NO_DOT = '%s%s' % sys.version_info[:2]
|
|
||||||
_PREFIX = os.path.normpath(sys.prefix)
|
|
||||||
_EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
|
|
||||||
_CONFIG_VARS = None
|
|
||||||
_USER_BASE = None
|
|
||||||
|
|
||||||
|
|
||||||
def _subst_vars(path, local_vars):
|
|
||||||
"""In the string `path`, replace tokens like {some.thing} with the
|
|
||||||
corresponding value from the map `local_vars`.
|
|
||||||
|
|
||||||
If there is no corresponding value, leave the token unchanged.
|
|
||||||
"""
|
|
||||||
def _replacer(matchobj):
|
|
||||||
name = matchobj.group(1)
|
|
||||||
if name in local_vars:
|
|
||||||
return local_vars[name]
|
|
||||||
elif name in os.environ:
|
|
||||||
return os.environ[name]
|
|
||||||
return matchobj.group(0)
|
|
||||||
return _VAR_REPL.sub(_replacer, path)
|
|
||||||
|
|
||||||
|
|
||||||
def _extend_dict(target_dict, other_dict):
|
|
||||||
target_keys = target_dict.keys()
|
|
||||||
for key, value in other_dict.items():
|
|
||||||
if key in target_keys:
|
|
||||||
continue
|
|
||||||
target_dict[key] = value
|
|
||||||
|
|
||||||
|
|
||||||
def _expand_vars(scheme, vars):
|
|
||||||
res = {}
|
|
||||||
if vars is None:
|
|
||||||
vars = {}
|
|
||||||
_extend_dict(vars, get_config_vars())
|
|
||||||
|
|
||||||
for key, value in _SCHEMES.items(scheme):
|
|
||||||
if os.name in ('posix', 'nt'):
|
|
||||||
value = os.path.expanduser(value)
|
|
||||||
res[key] = os.path.normpath(_subst_vars(value, vars))
|
|
||||||
return res
|
|
||||||
|
|
||||||
|
|
||||||
def format_value(value, vars):
|
|
||||||
def _replacer(matchobj):
|
|
||||||
name = matchobj.group(1)
|
|
||||||
if name in vars:
|
|
||||||
return vars[name]
|
|
||||||
return matchobj.group(0)
|
|
||||||
return _VAR_REPL.sub(_replacer, value)
|
|
||||||
|
|
||||||
|
|
||||||
def _get_default_scheme():
|
|
||||||
if os.name == 'posix':
|
|
||||||
# the default scheme for posix is posix_prefix
|
|
||||||
return 'posix_prefix'
|
|
||||||
return os.name
|
|
||||||
|
|
||||||
|
|
||||||
def _getuserbase():
|
|
||||||
env_base = os.environ.get("PYTHONUSERBASE", None)
|
|
||||||
|
|
||||||
def joinuser(*args):
|
|
||||||
return os.path.expanduser(os.path.join(*args))
|
|
||||||
|
|
||||||
# what about 'os2emx', 'riscos' ?
|
|
||||||
if os.name == "nt":
|
|
||||||
base = os.environ.get("APPDATA") or "~"
|
|
||||||
if env_base:
|
|
||||||
return env_base
|
|
||||||
else:
|
|
||||||
return joinuser(base, "Python")
|
|
||||||
|
|
||||||
if sys.platform == "darwin":
|
|
||||||
framework = get_config_var("PYTHONFRAMEWORK")
|
|
||||||
if framework:
|
|
||||||
if env_base:
|
|
||||||
return env_base
|
|
||||||
else:
|
|
||||||
return joinuser("~", "Library", framework, "%d.%d" %
|
|
||||||
sys.version_info[:2])
|
|
||||||
|
|
||||||
if env_base:
|
|
||||||
return env_base
|
|
||||||
else:
|
|
||||||
return joinuser("~", ".local")
|
|
||||||
|
|
||||||
|
|
||||||
def _parse_makefile(filename, vars=None):
|
|
||||||
"""Parse a Makefile-style file.
|
|
||||||
|
|
||||||
A dictionary containing name/value pairs is returned. If an
|
|
||||||
optional dictionary is passed in as the second argument, it is
|
|
||||||
used instead of a new dictionary.
|
|
||||||
"""
|
|
||||||
# Regexes needed for parsing Makefile (and similar syntaxes,
|
|
||||||
# like old-style Setup files).
|
|
||||||
_variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
|
|
||||||
_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
|
|
||||||
_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
|
|
||||||
|
|
||||||
if vars is None:
|
|
||||||
vars = {}
|
|
||||||
done = {}
|
|
||||||
notdone = {}
|
|
||||||
|
|
||||||
with codecs.open(filename, encoding='utf-8', errors="surrogateescape") as f:
|
|
||||||
lines = f.readlines()
|
|
||||||
|
|
||||||
for line in lines:
|
|
||||||
if line.startswith('#') or line.strip() == '':
|
|
||||||
continue
|
|
||||||
m = _variable_rx.match(line)
|
|
||||||
if m:
|
|
||||||
n, v = m.group(1, 2)
|
|
||||||
v = v.strip()
|
|
||||||
# `$$' is a literal `$' in make
|
|
||||||
tmpv = v.replace('$$', '')
|
|
||||||
|
|
||||||
if "$" in tmpv:
|
|
||||||
notdone[n] = v
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
v = int(v)
|
|
||||||
except ValueError:
|
|
||||||
# insert literal `$'
|
|
||||||
done[n] = v.replace('$$', '$')
|
|
||||||
else:
|
|
||||||
done[n] = v
|
|
||||||
|
|
||||||
# do variable interpolation here
|
|
||||||
variables = list(notdone.keys())
|
|
||||||
|
|
||||||
# Variables with a 'PY_' prefix in the makefile. These need to
|
|
||||||
# be made available without that prefix through sysconfig.
|
|
||||||
# Special care is needed to ensure that variable expansion works, even
|
|
||||||
# if the expansion uses the name without a prefix.
|
|
||||||
renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')
|
|
||||||
|
|
||||||
while len(variables) > 0:
|
|
||||||
for name in tuple(variables):
|
|
||||||
value = notdone[name]
|
|
||||||
m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
|
|
||||||
if m is not None:
|
|
||||||
n = m.group(1)
|
|
||||||
found = True
|
|
||||||
if n in done:
|
|
||||||
item = str(done[n])
|
|
||||||
elif n in notdone:
|
|
||||||
# get it on a subsequent round
|
|
||||||
found = False
|
|
||||||
elif n in os.environ:
|
|
||||||
# do it like make: fall back to environment
|
|
||||||
item = os.environ[n]
|
|
||||||
|
|
||||||
elif n in renamed_variables:
|
|
||||||
if (name.startswith('PY_') and
|
|
||||||
name[3:] in renamed_variables):
|
|
||||||
item = ""
|
|
||||||
|
|
||||||
elif 'PY_' + n in notdone:
|
|
||||||
found = False
|
|
||||||
|
|
||||||
else:
|
|
||||||
item = str(done['PY_' + n])
|
|
||||||
|
|
||||||
else:
|
|
||||||
done[n] = item = ""
|
|
||||||
|
|
||||||
if found:
|
|
||||||
after = value[m.end():]
|
|
||||||
value = value[:m.start()] + item + after
|
|
||||||
if "$" in after:
|
|
||||||
notdone[name] = value
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
value = int(value)
|
|
||||||
except ValueError:
|
|
||||||
done[name] = value.strip()
|
|
||||||
else:
|
|
||||||
done[name] = value
|
|
||||||
variables.remove(name)
|
|
||||||
|
|
||||||
if (name.startswith('PY_') and
|
|
||||||
name[3:] in renamed_variables):
|
|
||||||
|
|
||||||
name = name[3:]
|
|
||||||
if name not in done:
|
|
||||||
done[name] = value
|
|
||||||
|
|
||||||
else:
|
|
||||||
# bogus variable reference (e.g. "prefix=$/opt/python");
|
|
||||||
# just drop it since we can't deal
|
|
||||||
done[name] = value
|
|
||||||
variables.remove(name)
|
|
||||||
|
|
||||||
# strip spurious spaces
|
|
||||||
for k, v in done.items():
|
|
||||||
if isinstance(v, str):
|
|
||||||
done[k] = v.strip()
|
|
||||||
|
|
||||||
# save the results in the global dictionary
|
|
||||||
vars.update(done)
|
|
||||||
return vars
|
|
||||||
|
|
||||||
|
|
||||||
def get_makefile_filename():
|
|
||||||
"""Return the path of the Makefile."""
|
|
||||||
if _PYTHON_BUILD:
|
|
||||||
return os.path.join(_PROJECT_BASE, "Makefile")
|
|
||||||
if hasattr(sys, 'abiflags'):
|
|
||||||
config_dir_name = 'config-%s%s' % (_PY_VERSION_SHORT, sys.abiflags)
|
|
||||||
else:
|
|
||||||
config_dir_name = 'config'
|
|
||||||
return os.path.join(get_path('stdlib'), config_dir_name, 'Makefile')
|
|
||||||
|
|
||||||
|
|
||||||
def _init_posix(vars):
|
|
||||||
"""Initialize the module as appropriate for POSIX systems."""
|
|
||||||
# load the installed Makefile:
|
|
||||||
makefile = get_makefile_filename()
|
|
||||||
try:
|
|
||||||
_parse_makefile(makefile, vars)
|
|
||||||
except IOError as e:
|
|
||||||
msg = "invalid Python installation: unable to open %s" % makefile
|
|
||||||
if hasattr(e, "strerror"):
|
|
||||||
msg = msg + " (%s)" % e.strerror
|
|
||||||
raise IOError(msg)
|
|
||||||
# load the installed pyconfig.h:
|
|
||||||
config_h = get_config_h_filename()
|
|
||||||
try:
|
|
||||||
with open(config_h) as f:
|
|
||||||
parse_config_h(f, vars)
|
|
||||||
except IOError as e:
|
|
||||||
msg = "invalid Python installation: unable to open %s" % config_h
|
|
||||||
if hasattr(e, "strerror"):
|
|
||||||
msg = msg + " (%s)" % e.strerror
|
|
||||||
raise IOError(msg)
|
|
||||||
# On AIX, there are wrong paths to the linker scripts in the Makefile
|
|
||||||
# -- these paths are relative to the Python source, but when installed
|
|
||||||
# the scripts are in another directory.
|
|
||||||
if _PYTHON_BUILD:
|
|
||||||
vars['LDSHARED'] = vars['BLDSHARED']
|
|
||||||
|
|
||||||
|
|
||||||
def _init_non_posix(vars):
|
|
||||||
"""Initialize the module as appropriate for NT"""
|
|
||||||
# set basic install directories
|
|
||||||
vars['LIBDEST'] = get_path('stdlib')
|
|
||||||
vars['BINLIBDEST'] = get_path('platstdlib')
|
|
||||||
vars['INCLUDEPY'] = get_path('include')
|
|
||||||
vars['SO'] = '.pyd'
|
|
||||||
vars['EXE'] = '.exe'
|
|
||||||
vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT
|
|
||||||
vars['BINDIR'] = os.path.dirname(_safe_realpath(sys.executable))
|
|
||||||
|
|
||||||
#
|
|
||||||
# public APIs
|
|
||||||
#
|
|
||||||
|
|
||||||
|
|
||||||
def parse_config_h(fp, vars=None):
|
|
||||||
"""Parse a config.h-style file.
|
|
||||||
|
|
||||||
A dictionary containing name/value pairs is returned. If an
|
|
||||||
optional dictionary is passed in as the second argument, it is
|
|
||||||
used instead of a new dictionary.
|
|
||||||
"""
|
|
||||||
if vars is None:
|
|
||||||
vars = {}
|
|
||||||
define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
|
|
||||||
undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
|
|
||||||
|
|
||||||
while True:
|
|
||||||
line = fp.readline()
|
|
||||||
if not line:
|
|
||||||
break
|
|
||||||
m = define_rx.match(line)
|
|
||||||
if m:
|
|
||||||
n, v = m.group(1, 2)
|
|
||||||
try:
|
|
||||||
v = int(v)
|
|
||||||
except ValueError:
|
|
||||||
pass
|
|
||||||
vars[n] = v
|
|
||||||
else:
|
|
||||||
m = undef_rx.match(line)
|
|
||||||
if m:
|
|
||||||
vars[m.group(1)] = 0
|
|
||||||
return vars
|
|
||||||
|
|
||||||
|
|
||||||
def get_config_h_filename():
|
|
||||||
"""Return the path of pyconfig.h."""
|
|
||||||
if _PYTHON_BUILD:
|
|
||||||
if os.name == "nt":
|
|
||||||
inc_dir = os.path.join(_PROJECT_BASE, "PC")
|
|
||||||
else:
|
|
||||||
inc_dir = _PROJECT_BASE
|
|
||||||
else:
|
|
||||||
inc_dir = get_path('platinclude')
|
|
||||||
return os.path.join(inc_dir, 'pyconfig.h')
|
|
||||||
|
|
||||||
|
|
||||||
def get_scheme_names():
|
|
||||||
"""Return a tuple containing the schemes names."""
|
|
||||||
return tuple(sorted(_SCHEMES.sections()))
|
|
||||||
|
|
||||||
|
|
||||||
def get_path_names():
|
|
||||||
"""Return a tuple containing the paths names."""
|
|
||||||
# xxx see if we want a static list
|
|
||||||
return _SCHEMES.options('posix_prefix')
|
|
||||||
|
|
||||||
|
|
||||||
def get_paths(scheme=_get_default_scheme(), vars=None, expand=True):
|
|
||||||
"""Return a mapping containing an install scheme.
|
|
||||||
|
|
||||||
``scheme`` is the install scheme name. If not provided, it will
|
|
||||||
return the default scheme for the current platform.
|
|
||||||
"""
|
|
||||||
_ensure_cfg_read()
|
|
||||||
if expand:
|
|
||||||
return _expand_vars(scheme, vars)
|
|
||||||
else:
|
|
||||||
return dict(_SCHEMES.items(scheme))
|
|
||||||
|
|
||||||
|
|
||||||
def get_path(name, scheme=_get_default_scheme(), vars=None, expand=True):
|
|
||||||
"""Return a path corresponding to the scheme.
|
|
||||||
|
|
||||||
``scheme`` is the install scheme name.
|
|
||||||
"""
|
|
||||||
return get_paths(scheme, vars, expand)[name]
|
|
||||||
|
|
||||||
|
|
||||||
def get_config_vars(*args):
|
|
||||||
"""With no arguments, return a dictionary of all configuration
|
|
||||||
variables relevant for the current platform.
|
|
||||||
|
|
||||||
On Unix, this means every variable defined in Python's installed Makefile;
|
|
||||||
On Windows and Mac OS it's a much smaller set.
|
|
||||||
|
|
||||||
With arguments, return a list of values that result from looking up
|
|
||||||
each argument in the configuration variable dictionary.
|
|
||||||
"""
|
|
||||||
global _CONFIG_VARS
|
|
||||||
if _CONFIG_VARS is None:
|
|
||||||
_CONFIG_VARS = {}
|
|
||||||
# Normalized versions of prefix and exec_prefix are handy to have;
|
|
||||||
# in fact, these are the standard versions used most places in the
|
|
||||||
# distutils2 module.
|
|
||||||
_CONFIG_VARS['prefix'] = _PREFIX
|
|
||||||
_CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX
|
|
||||||
_CONFIG_VARS['py_version'] = _PY_VERSION
|
|
||||||
_CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT
|
|
||||||
_CONFIG_VARS['py_version_nodot'] = _PY_VERSION[0] + _PY_VERSION[2]
|
|
||||||
_CONFIG_VARS['base'] = _PREFIX
|
|
||||||
_CONFIG_VARS['platbase'] = _EXEC_PREFIX
|
|
||||||
_CONFIG_VARS['projectbase'] = _PROJECT_BASE
|
|
||||||
try:
|
|
||||||
_CONFIG_VARS['abiflags'] = sys.abiflags
|
|
||||||
except AttributeError:
|
|
||||||
# sys.abiflags may not be defined on all platforms.
|
|
||||||
_CONFIG_VARS['abiflags'] = ''
|
|
||||||
|
|
||||||
if os.name in ('nt', 'os2'):
|
|
||||||
_init_non_posix(_CONFIG_VARS)
|
|
||||||
if os.name == 'posix':
|
|
||||||
_init_posix(_CONFIG_VARS)
|
|
||||||
# Setting 'userbase' is done below the call to the
|
|
||||||
# init function to enable using 'get_config_var' in
|
|
||||||
# the init-function.
|
|
||||||
if sys.version >= '2.6':
|
|
||||||
_CONFIG_VARS['userbase'] = _getuserbase()
|
|
||||||
|
|
||||||
if 'srcdir' not in _CONFIG_VARS:
|
|
||||||
_CONFIG_VARS['srcdir'] = _PROJECT_BASE
|
|
||||||
else:
|
|
||||||
_CONFIG_VARS['srcdir'] = _safe_realpath(_CONFIG_VARS['srcdir'])
|
|
||||||
|
|
||||||
# Convert srcdir into an absolute path if it appears necessary.
|
|
||||||
# Normally it is relative to the build directory. However, during
|
|
||||||
# testing, for example, we might be running a non-installed python
|
|
||||||
# from a different directory.
|
|
||||||
if _PYTHON_BUILD and os.name == "posix":
|
|
||||||
base = _PROJECT_BASE
|
|
||||||
try:
|
|
||||||
cwd = os.getcwd()
|
|
||||||
except OSError:
|
|
||||||
cwd = None
|
|
||||||
if (not os.path.isabs(_CONFIG_VARS['srcdir']) and
|
|
||||||
base != cwd):
|
|
||||||
# srcdir is relative and we are not in the same directory
|
|
||||||
# as the executable. Assume executable is in the build
|
|
||||||
# directory and make srcdir absolute.
|
|
||||||
srcdir = os.path.join(base, _CONFIG_VARS['srcdir'])
|
|
||||||
_CONFIG_VARS['srcdir'] = os.path.normpath(srcdir)
|
|
||||||
|
|
||||||
if sys.platform == 'darwin':
|
|
||||||
kernel_version = os.uname()[2] # Kernel version (8.4.3)
|
|
||||||
major_version = int(kernel_version.split('.')[0])
|
|
||||||
|
|
||||||
if major_version < 8:
|
|
||||||
# On Mac OS X before 10.4, check if -arch and -isysroot
|
|
||||||
# are in CFLAGS or LDFLAGS and remove them if they are.
|
|
||||||
# This is needed when building extensions on a 10.3 system
|
|
||||||
# using a universal build of python.
|
|
||||||
for key in ('LDFLAGS', 'BASECFLAGS',
|
|
||||||
# a number of derived variables. These need to be
|
|
||||||
# patched up as well.
|
|
||||||
'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
|
|
||||||
flags = _CONFIG_VARS[key]
|
|
||||||
flags = re.sub(r'-arch\s+\w+\s', ' ', flags)
|
|
||||||
flags = re.sub('-isysroot [^ \t]*', ' ', flags)
|
|
||||||
_CONFIG_VARS[key] = flags
|
|
||||||
else:
|
|
||||||
# Allow the user to override the architecture flags using
|
|
||||||
# an environment variable.
|
|
||||||
# NOTE: This name was introduced by Apple in OSX 10.5 and
|
|
||||||
# is used by several scripting languages distributed with
|
|
||||||
# that OS release.
|
|
||||||
if 'ARCHFLAGS' in os.environ:
|
|
||||||
arch = os.environ['ARCHFLAGS']
|
|
||||||
for key in ('LDFLAGS', 'BASECFLAGS',
|
|
||||||
# a number of derived variables. These need to be
|
|
||||||
# patched up as well.
|
|
||||||
'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
|
|
||||||
|
|
||||||
flags = _CONFIG_VARS[key]
|
|
||||||
flags = re.sub(r'-arch\s+\w+\s', ' ', flags)
|
|
||||||
flags = flags + ' ' + arch
|
|
||||||
_CONFIG_VARS[key] = flags
|
|
||||||
|
|
||||||
# If we're on OSX 10.5 or later and the user tries to
|
|
||||||
# compiles an extension using an SDK that is not present
|
|
||||||
# on the current machine it is better to not use an SDK
|
|
||||||
# than to fail.
|
|
||||||
#
|
|
||||||
# The major usecase for this is users using a Python.org
|
|
||||||
# binary installer on OSX 10.6: that installer uses
|
|
||||||
# the 10.4u SDK, but that SDK is not installed by default
|
|
||||||
# when you install Xcode.
|
|
||||||
#
|
|
||||||
CFLAGS = _CONFIG_VARS.get('CFLAGS', '')
|
|
||||||
m = re.search(r'-isysroot\s+(\S+)', CFLAGS)
|
|
||||||
if m is not None:
|
|
||||||
sdk = m.group(1)
|
|
||||||
if not os.path.exists(sdk):
|
|
||||||
for key in ('LDFLAGS', 'BASECFLAGS',
|
|
||||||
# a number of derived variables. These need to be
|
|
||||||
# patched up as well.
|
|
||||||
'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
|
|
||||||
|
|
||||||
flags = _CONFIG_VARS[key]
|
|
||||||
flags = re.sub(r'-isysroot\s+\S+(\s|$)', ' ', flags)
|
|
||||||
_CONFIG_VARS[key] = flags
|
|
||||||
|
|
||||||
if args:
|
|
||||||
vals = []
|
|
||||||
for name in args:
|
|
||||||
vals.append(_CONFIG_VARS.get(name))
|
|
||||||
return vals
|
|
||||||
else:
|
|
||||||
return _CONFIG_VARS
|
|
||||||
|
|
||||||
|
|
||||||
def get_config_var(name):
|
|
||||||
"""Return the value of a single variable using the dictionary returned by
|
|
||||||
'get_config_vars()'.
|
|
||||||
|
|
||||||
Equivalent to get_config_vars().get(name)
|
|
||||||
"""
|
|
||||||
return get_config_vars().get(name)
|
|
||||||
|
|
||||||
|
|
||||||
def get_platform():
|
|
||||||
"""Return a string that identifies the current platform.
|
|
||||||
|
|
||||||
This is used mainly to distinguish platform-specific build directories and
|
|
||||||
platform-specific built distributions. Typically includes the OS name
|
|
||||||
and version and the architecture (as supplied by 'os.uname()'),
|
|
||||||
although the exact information included depends on the OS; eg. for IRIX
|
|
||||||
the architecture isn't particularly important (IRIX only runs on SGI
|
|
||||||
hardware), but for Linux the kernel version isn't particularly
|
|
||||||
important.
|
|
||||||
|
|
||||||
Examples of returned values:
|
|
||||||
linux-i586
|
|
||||||
linux-alpha (?)
|
|
||||||
solaris-2.6-sun4u
|
|
||||||
irix-5.3
|
|
||||||
irix64-6.2
|
|
||||||
|
|
||||||
Windows will return one of:
|
|
||||||
win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
|
|
||||||
win-ia64 (64bit Windows on Itanium)
|
|
||||||
win32 (all others - specifically, sys.platform is returned)
|
|
||||||
|
|
||||||
For other non-POSIX platforms, currently just returns 'sys.platform'.
|
|
||||||
"""
|
|
||||||
if os.name == 'nt':
|
|
||||||
# sniff sys.version for architecture.
|
|
||||||
prefix = " bit ("
|
|
||||||
i = sys.version.find(prefix)
|
|
||||||
if i == -1:
|
|
||||||
return sys.platform
|
|
||||||
j = sys.version.find(")", i)
|
|
||||||
look = sys.version[i+len(prefix):j].lower()
|
|
||||||
if look == 'amd64':
|
|
||||||
return 'win-amd64'
|
|
||||||
if look == 'itanium':
|
|
||||||
return 'win-ia64'
|
|
||||||
return sys.platform
|
|
||||||
|
|
||||||
if os.name != "posix" or not hasattr(os, 'uname'):
|
|
||||||
# XXX what about the architecture? NT is Intel or Alpha,
|
|
||||||
# Mac OS is M68k or PPC, etc.
|
|
||||||
return sys.platform
|
|
||||||
|
|
||||||
# Try to distinguish various flavours of Unix
|
|
||||||
osname, host, release, version, machine = os.uname()
|
|
||||||
|
|
||||||
# Convert the OS name to lowercase, remove '/' characters
|
|
||||||
# (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
|
|
||||||
osname = osname.lower().replace('/', '')
|
|
||||||
machine = machine.replace(' ', '_')
|
|
||||||
machine = machine.replace('/', '-')
|
|
||||||
|
|
||||||
if osname[:5] == "linux":
|
|
||||||
# At least on Linux/Intel, 'machine' is the processor --
|
|
||||||
# i386, etc.
|
|
||||||
# XXX what about Alpha, SPARC, etc?
|
|
||||||
return "%s-%s" % (osname, machine)
|
|
||||||
elif osname[:5] == "sunos":
|
|
||||||
if release[0] >= "5": # SunOS 5 == Solaris 2
|
|
||||||
osname = "solaris"
|
|
||||||
release = "%d.%s" % (int(release[0]) - 3, release[2:])
|
|
||||||
# fall through to standard osname-release-machine representation
|
|
||||||
elif osname[:4] == "irix": # could be "irix64"!
|
|
||||||
return "%s-%s" % (osname, release)
|
|
||||||
elif osname[:3] == "aix":
|
|
||||||
return "%s-%s.%s" % (osname, version, release)
|
|
||||||
elif osname[:6] == "cygwin":
|
|
||||||
osname = "cygwin"
|
|
||||||
rel_re = re.compile(r'[\d.]+')
|
|
||||||
m = rel_re.match(release)
|
|
||||||
if m:
|
|
||||||
release = m.group()
|
|
||||||
elif osname[:6] == "darwin":
|
|
||||||
#
|
|
||||||
# For our purposes, we'll assume that the system version from
|
|
||||||
# distutils' perspective is what MACOSX_DEPLOYMENT_TARGET is set
|
|
||||||
# to. This makes the compatibility story a bit more sane because the
|
|
||||||
# machine is going to compile and link as if it were
|
|
||||||
# MACOSX_DEPLOYMENT_TARGET.
|
|
||||||
cfgvars = get_config_vars()
|
|
||||||
macver = cfgvars.get('MACOSX_DEPLOYMENT_TARGET')
|
|
||||||
|
|
||||||
if True:
|
|
||||||
# Always calculate the release of the running machine,
|
|
||||||
# needed to determine if we can build fat binaries or not.
|
|
||||||
|
|
||||||
macrelease = macver
|
|
||||||
# Get the system version. Reading this plist is a documented
|
|
||||||
# way to get the system version (see the documentation for
|
|
||||||
# the Gestalt Manager)
|
|
||||||
try:
|
|
||||||
f = open('/System/Library/CoreServices/SystemVersion.plist')
|
|
||||||
except IOError:
|
|
||||||
# We're on a plain darwin box, fall back to the default
|
|
||||||
# behaviour.
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
m = re.search(r'<key>ProductUserVisibleVersion</key>\s*'
|
|
||||||
r'<string>(.*?)</string>', f.read())
|
|
||||||
finally:
|
|
||||||
f.close()
|
|
||||||
if m is not None:
|
|
||||||
macrelease = '.'.join(m.group(1).split('.')[:2])
|
|
||||||
# else: fall back to the default behaviour
|
|
||||||
|
|
||||||
if not macver:
|
|
||||||
macver = macrelease
|
|
||||||
|
|
||||||
if macver:
|
|
||||||
release = macver
|
|
||||||
osname = "macosx"
|
|
||||||
|
|
||||||
if ((macrelease + '.') >= '10.4.' and
|
|
||||||
'-arch' in get_config_vars().get('CFLAGS', '').strip()):
|
|
||||||
# The universal build will build fat binaries, but not on
|
|
||||||
# systems before 10.4
|
|
||||||
#
|
|
||||||
# Try to detect 4-way universal builds, those have machine-type
|
|
||||||
# 'universal' instead of 'fat'.
|
|
||||||
|
|
||||||
machine = 'fat'
|
|
||||||
cflags = get_config_vars().get('CFLAGS')
|
|
||||||
|
|
||||||
archs = re.findall(r'-arch\s+(\S+)', cflags)
|
|
||||||
archs = tuple(sorted(set(archs)))
|
|
||||||
|
|
||||||
if len(archs) == 1:
|
|
||||||
machine = archs[0]
|
|
||||||
elif archs == ('i386', 'ppc'):
|
|
||||||
machine = 'fat'
|
|
||||||
elif archs == ('i386', 'x86_64'):
|
|
||||||
machine = 'intel'
|
|
||||||
elif archs == ('i386', 'ppc', 'x86_64'):
|
|
||||||
machine = 'fat3'
|
|
||||||
elif archs == ('ppc64', 'x86_64'):
|
|
||||||
machine = 'fat64'
|
|
||||||
elif archs == ('i386', 'ppc', 'ppc64', 'x86_64'):
|
|
||||||
machine = 'universal'
|
|
||||||
else:
|
|
||||||
raise ValueError(
|
|
||||||
"Don't know machine value for archs=%r" % (archs,))
|
|
||||||
|
|
||||||
elif machine == 'i386':
|
|
||||||
# On OSX the machine type returned by uname is always the
|
|
||||||
# 32-bit variant, even if the executable architecture is
|
|
||||||
# the 64-bit variant
|
|
||||||
if sys.maxsize >= 2**32:
|
|
||||||
machine = 'x86_64'
|
|
||||||
|
|
||||||
elif machine in ('PowerPC', 'Power_Macintosh'):
|
|
||||||
# Pick a sane name for the PPC architecture.
|
|
||||||
# See 'i386' case
|
|
||||||
if sys.maxsize >= 2**32:
|
|
||||||
machine = 'ppc64'
|
|
||||||
else:
|
|
||||||
machine = 'ppc'
|
|
||||||
|
|
||||||
return "%s-%s-%s" % (osname, release, machine)
|
|
||||||
|
|
||||||
|
|
||||||
def get_python_version():
|
|
||||||
return _PY_VERSION_SHORT
|
|
||||||
|
|
||||||
|
|
||||||
def _print_dict(title, data):
|
|
||||||
for index, (key, value) in enumerate(sorted(data.items())):
|
|
||||||
if index == 0:
|
|
||||||
print('%s: ' % (title))
|
|
||||||
print('\t%s = "%s"' % (key, value))
|
|
||||||
|
|
||||||
|
|
||||||
def _main():
|
|
||||||
"""Display all information sysconfig detains."""
|
|
||||||
print('Platform: "%s"' % get_platform())
|
|
||||||
print('Python version: "%s"' % get_python_version())
|
|
||||||
print('Current installation scheme: "%s"' % _get_default_scheme())
|
|
||||||
print()
|
|
||||||
_print_dict('Paths', get_paths())
|
|
||||||
print()
|
|
||||||
_print_dict('Variables', get_config_vars())
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == '__main__':
|
|
||||||
_main()
|
|
||||||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -1,509 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
#
|
|
||||||
# Copyright (C) 2013 Vinay Sajip.
|
|
||||||
# Licensed to the Python Software Foundation under a contributor agreement.
|
|
||||||
# See LICENSE.txt and CONTRIBUTORS.txt.
|
|
||||||
#
|
|
||||||
import hashlib
|
|
||||||
import logging
|
|
||||||
import os
|
|
||||||
import shutil
|
|
||||||
import subprocess
|
|
||||||
import tempfile
|
|
||||||
try:
|
|
||||||
from threading import Thread
|
|
||||||
except ImportError:
|
|
||||||
from dummy_threading import Thread
|
|
||||||
|
|
||||||
from . import DistlibException
|
|
||||||
from .compat import (HTTPBasicAuthHandler, Request, HTTPPasswordMgr,
|
|
||||||
urlparse, build_opener, string_types)
|
|
||||||
from .util import zip_dir, ServerProxy
|
|
||||||
|
|
||||||
logger = logging.getLogger(__name__)
|
|
||||||
|
|
||||||
DEFAULT_INDEX = 'https://pypi.org/pypi'
|
|
||||||
DEFAULT_REALM = 'pypi'
|
|
||||||
|
|
||||||
class PackageIndex(object):
|
|
||||||
"""
|
|
||||||
This class represents a package index compatible with PyPI, the Python
|
|
||||||
Package Index.
|
|
||||||
"""
|
|
||||||
|
|
||||||
boundary = b'----------ThIs_Is_tHe_distlib_index_bouNdaRY_$'
|
|
||||||
|
|
||||||
def __init__(self, url=None):
|
|
||||||
"""
|
|
||||||
Initialise an instance.
|
|
||||||
|
|
||||||
:param url: The URL of the index. If not specified, the URL for PyPI is
|
|
||||||
used.
|
|
||||||
"""
|
|
||||||
self.url = url or DEFAULT_INDEX
|
|
||||||
self.read_configuration()
|
|
||||||
scheme, netloc, path, params, query, frag = urlparse(self.url)
|
|
||||||
if params or query or frag or scheme not in ('http', 'https'):
|
|
||||||
raise DistlibException('invalid repository: %s' % self.url)
|
|
||||||
self.password_handler = None
|
|
||||||
self.ssl_verifier = None
|
|
||||||
self.gpg = None
|
|
||||||
self.gpg_home = None
|
|
||||||
with open(os.devnull, 'w') as sink:
|
|
||||||
# Use gpg by default rather than gpg2, as gpg2 insists on
|
|
||||||
# prompting for passwords
|
|
||||||
for s in ('gpg', 'gpg2'):
|
|
||||||
try:
|
|
||||||
rc = subprocess.check_call([s, '--version'], stdout=sink,
|
|
||||||
stderr=sink)
|
|
||||||
if rc == 0:
|
|
||||||
self.gpg = s
|
|
||||||
break
|
|
||||||
except OSError:
|
|
||||||
pass
|
|
||||||
|
|
||||||
def _get_pypirc_command(self):
|
|
||||||
"""
|
|
||||||
Get the distutils command for interacting with PyPI configurations.
|
|
||||||
:return: the command.
|
|
||||||
"""
|
|
||||||
from .util import _get_pypirc_command as cmd
|
|
||||||
return cmd()
|
|
||||||
|
|
||||||
def read_configuration(self):
|
|
||||||
"""
|
|
||||||
Read the PyPI access configuration as supported by distutils. This populates
|
|
||||||
``username``, ``password``, ``realm`` and ``url`` attributes from the
|
|
||||||
configuration.
|
|
||||||
"""
|
|
||||||
from .util import _load_pypirc
|
|
||||||
cfg = _load_pypirc(self)
|
|
||||||
self.username = cfg.get('username')
|
|
||||||
self.password = cfg.get('password')
|
|
||||||
self.realm = cfg.get('realm', 'pypi')
|
|
||||||
self.url = cfg.get('repository', self.url)
|
|
||||||
|
|
||||||
def save_configuration(self):
|
|
||||||
"""
|
|
||||||
Save the PyPI access configuration. You must have set ``username`` and
|
|
||||||
``password`` attributes before calling this method.
|
|
||||||
"""
|
|
||||||
self.check_credentials()
|
|
||||||
from .util import _store_pypirc
|
|
||||||
_store_pypirc(self)
|
|
||||||
|
|
||||||
def check_credentials(self):
|
|
||||||
"""
|
|
||||||
Check that ``username`` and ``password`` have been set, and raise an
|
|
||||||
exception if not.
|
|
||||||
"""
|
|
||||||
if self.username is None or self.password is None:
|
|
||||||
raise DistlibException('username and password must be set')
|
|
||||||
pm = HTTPPasswordMgr()
|
|
||||||
_, netloc, _, _, _, _ = urlparse(self.url)
|
|
||||||
pm.add_password(self.realm, netloc, self.username, self.password)
|
|
||||||
self.password_handler = HTTPBasicAuthHandler(pm)
|
|
||||||
|
|
||||||
def register(self, metadata):
|
|
||||||
"""
|
|
||||||
Register a distribution on PyPI, using the provided metadata.
|
|
||||||
|
|
||||||
:param metadata: A :class:`Metadata` instance defining at least a name
|
|
||||||
and version number for the distribution to be
|
|
||||||
registered.
|
|
||||||
:return: The HTTP response received from PyPI upon submission of the
|
|
||||||
request.
|
|
||||||
"""
|
|
||||||
self.check_credentials()
|
|
||||||
metadata.validate()
|
|
||||||
d = metadata.todict()
|
|
||||||
d[':action'] = 'verify'
|
|
||||||
request = self.encode_request(d.items(), [])
|
|
||||||
response = self.send_request(request)
|
|
||||||
d[':action'] = 'submit'
|
|
||||||
request = self.encode_request(d.items(), [])
|
|
||||||
return self.send_request(request)
|
|
||||||
|
|
||||||
def _reader(self, name, stream, outbuf):
|
|
||||||
"""
|
|
||||||
Thread runner for reading lines of from a subprocess into a buffer.
|
|
||||||
|
|
||||||
:param name: The logical name of the stream (used for logging only).
|
|
||||||
:param stream: The stream to read from. This will typically a pipe
|
|
||||||
connected to the output stream of a subprocess.
|
|
||||||
:param outbuf: The list to append the read lines to.
|
|
||||||
"""
|
|
||||||
while True:
|
|
||||||
s = stream.readline()
|
|
||||||
if not s:
|
|
||||||
break
|
|
||||||
s = s.decode('utf-8').rstrip()
|
|
||||||
outbuf.append(s)
|
|
||||||
logger.debug('%s: %s' % (name, s))
|
|
||||||
stream.close()
|
|
||||||
|
|
||||||
def get_sign_command(self, filename, signer, sign_password,
|
|
||||||
keystore=None):
|
|
||||||
"""
|
|
||||||
Return a suitable command for signing a file.
|
|
||||||
|
|
||||||
:param filename: The pathname to the file to be signed.
|
|
||||||
:param signer: The identifier of the signer of the file.
|
|
||||||
:param sign_password: The passphrase for the signer's
|
|
||||||
private key used for signing.
|
|
||||||
:param keystore: The path to a directory which contains the keys
|
|
||||||
used in verification. If not specified, the
|
|
||||||
instance's ``gpg_home`` attribute is used instead.
|
|
||||||
:return: The signing command as a list suitable to be
|
|
||||||
passed to :class:`subprocess.Popen`.
|
|
||||||
"""
|
|
||||||
cmd = [self.gpg, '--status-fd', '2', '--no-tty']
|
|
||||||
if keystore is None:
|
|
||||||
keystore = self.gpg_home
|
|
||||||
if keystore:
|
|
||||||
cmd.extend(['--homedir', keystore])
|
|
||||||
if sign_password is not None:
|
|
||||||
cmd.extend(['--batch', '--passphrase-fd', '0'])
|
|
||||||
td = tempfile.mkdtemp()
|
|
||||||
sf = os.path.join(td, os.path.basename(filename) + '.asc')
|
|
||||||
cmd.extend(['--detach-sign', '--armor', '--local-user',
|
|
||||||
signer, '--output', sf, filename])
|
|
||||||
logger.debug('invoking: %s', ' '.join(cmd))
|
|
||||||
return cmd, sf
|
|
||||||
|
|
||||||
def run_command(self, cmd, input_data=None):
|
|
||||||
"""
|
|
||||||
Run a command in a child process , passing it any input data specified.
|
|
||||||
|
|
||||||
:param cmd: The command to run.
|
|
||||||
:param input_data: If specified, this must be a byte string containing
|
|
||||||
data to be sent to the child process.
|
|
||||||
:return: A tuple consisting of the subprocess' exit code, a list of
|
|
||||||
lines read from the subprocess' ``stdout``, and a list of
|
|
||||||
lines read from the subprocess' ``stderr``.
|
|
||||||
"""
|
|
||||||
kwargs = {
|
|
||||||
'stdout': subprocess.PIPE,
|
|
||||||
'stderr': subprocess.PIPE,
|
|
||||||
}
|
|
||||||
if input_data is not None:
|
|
||||||
kwargs['stdin'] = subprocess.PIPE
|
|
||||||
stdout = []
|
|
||||||
stderr = []
|
|
||||||
p = subprocess.Popen(cmd, **kwargs)
|
|
||||||
# We don't use communicate() here because we may need to
|
|
||||||
# get clever with interacting with the command
|
|
||||||
t1 = Thread(target=self._reader, args=('stdout', p.stdout, stdout))
|
|
||||||
t1.start()
|
|
||||||
t2 = Thread(target=self._reader, args=('stderr', p.stderr, stderr))
|
|
||||||
t2.start()
|
|
||||||
if input_data is not None:
|
|
||||||
p.stdin.write(input_data)
|
|
||||||
p.stdin.close()
|
|
||||||
|
|
||||||
p.wait()
|
|
||||||
t1.join()
|
|
||||||
t2.join()
|
|
||||||
return p.returncode, stdout, stderr
|
|
||||||
|
|
||||||
def sign_file(self, filename, signer, sign_password, keystore=None):
|
|
||||||
"""
|
|
||||||
Sign a file.
|
|
||||||
|
|
||||||
:param filename: The pathname to the file to be signed.
|
|
||||||
:param signer: The identifier of the signer of the file.
|
|
||||||
:param sign_password: The passphrase for the signer's
|
|
||||||
private key used for signing.
|
|
||||||
:param keystore: The path to a directory which contains the keys
|
|
||||||
used in signing. If not specified, the instance's
|
|
||||||
``gpg_home`` attribute is used instead.
|
|
||||||
:return: The absolute pathname of the file where the signature is
|
|
||||||
stored.
|
|
||||||
"""
|
|
||||||
cmd, sig_file = self.get_sign_command(filename, signer, sign_password,
|
|
||||||
keystore)
|
|
||||||
rc, stdout, stderr = self.run_command(cmd,
|
|
||||||
sign_password.encode('utf-8'))
|
|
||||||
if rc != 0:
|
|
||||||
raise DistlibException('sign command failed with error '
|
|
||||||
'code %s' % rc)
|
|
||||||
return sig_file
|
|
||||||
|
|
||||||
def upload_file(self, metadata, filename, signer=None, sign_password=None,
|
|
||||||
filetype='sdist', pyversion='source', keystore=None):
|
|
||||||
"""
|
|
||||||
Upload a release file to the index.
|
|
||||||
|
|
||||||
:param metadata: A :class:`Metadata` instance defining at least a name
|
|
||||||
and version number for the file to be uploaded.
|
|
||||||
:param filename: The pathname of the file to be uploaded.
|
|
||||||
:param signer: The identifier of the signer of the file.
|
|
||||||
:param sign_password: The passphrase for the signer's
|
|
||||||
private key used for signing.
|
|
||||||
:param filetype: The type of the file being uploaded. This is the
|
|
||||||
distutils command which produced that file, e.g.
|
|
||||||
``sdist`` or ``bdist_wheel``.
|
|
||||||
:param pyversion: The version of Python which the release relates
|
|
||||||
to. For code compatible with any Python, this would
|
|
||||||
be ``source``, otherwise it would be e.g. ``3.2``.
|
|
||||||
:param keystore: The path to a directory which contains the keys
|
|
||||||
used in signing. If not specified, the instance's
|
|
||||||
``gpg_home`` attribute is used instead.
|
|
||||||
:return: The HTTP response received from PyPI upon submission of the
|
|
||||||
request.
|
|
||||||
"""
|
|
||||||
self.check_credentials()
|
|
||||||
if not os.path.exists(filename):
|
|
||||||
raise DistlibException('not found: %s' % filename)
|
|
||||||
metadata.validate()
|
|
||||||
d = metadata.todict()
|
|
||||||
sig_file = None
|
|
||||||
if signer:
|
|
||||||
if not self.gpg:
|
|
||||||
logger.warning('no signing program available - not signed')
|
|
||||||
else:
|
|
||||||
sig_file = self.sign_file(filename, signer, sign_password,
|
|
||||||
keystore)
|
|
||||||
with open(filename, 'rb') as f:
|
|
||||||
file_data = f.read()
|
|
||||||
md5_digest = hashlib.md5(file_data).hexdigest()
|
|
||||||
sha256_digest = hashlib.sha256(file_data).hexdigest()
|
|
||||||
d.update({
|
|
||||||
':action': 'file_upload',
|
|
||||||
'protocol_version': '1',
|
|
||||||
'filetype': filetype,
|
|
||||||
'pyversion': pyversion,
|
|
||||||
'md5_digest': md5_digest,
|
|
||||||
'sha256_digest': sha256_digest,
|
|
||||||
})
|
|
||||||
files = [('content', os.path.basename(filename), file_data)]
|
|
||||||
if sig_file:
|
|
||||||
with open(sig_file, 'rb') as f:
|
|
||||||
sig_data = f.read()
|
|
||||||
files.append(('gpg_signature', os.path.basename(sig_file),
|
|
||||||
sig_data))
|
|
||||||
shutil.rmtree(os.path.dirname(sig_file))
|
|
||||||
request = self.encode_request(d.items(), files)
|
|
||||||
return self.send_request(request)
|
|
||||||
|
|
||||||
def upload_documentation(self, metadata, doc_dir):
|
|
||||||
"""
|
|
||||||
Upload documentation to the index.
|
|
||||||
|
|
||||||
:param metadata: A :class:`Metadata` instance defining at least a name
|
|
||||||
and version number for the documentation to be
|
|
||||||
uploaded.
|
|
||||||
:param doc_dir: The pathname of the directory which contains the
|
|
||||||
documentation. This should be the directory that
|
|
||||||
contains the ``index.html`` for the documentation.
|
|
||||||
:return: The HTTP response received from PyPI upon submission of the
|
|
||||||
request.
|
|
||||||
"""
|
|
||||||
self.check_credentials()
|
|
||||||
if not os.path.isdir(doc_dir):
|
|
||||||
raise DistlibException('not a directory: %r' % doc_dir)
|
|
||||||
fn = os.path.join(doc_dir, 'index.html')
|
|
||||||
if not os.path.exists(fn):
|
|
||||||
raise DistlibException('not found: %r' % fn)
|
|
||||||
metadata.validate()
|
|
||||||
name, version = metadata.name, metadata.version
|
|
||||||
zip_data = zip_dir(doc_dir).getvalue()
|
|
||||||
fields = [(':action', 'doc_upload'),
|
|
||||||
('name', name), ('version', version)]
|
|
||||||
files = [('content', name, zip_data)]
|
|
||||||
request = self.encode_request(fields, files)
|
|
||||||
return self.send_request(request)
|
|
||||||
|
|
||||||
def get_verify_command(self, signature_filename, data_filename,
|
|
||||||
keystore=None):
|
|
||||||
"""
|
|
||||||
Return a suitable command for verifying a file.
|
|
||||||
|
|
||||||
:param signature_filename: The pathname to the file containing the
|
|
||||||
signature.
|
|
||||||
:param data_filename: The pathname to the file containing the
|
|
||||||
signed data.
|
|
||||||
:param keystore: The path to a directory which contains the keys
|
|
||||||
used in verification. If not specified, the
|
|
||||||
instance's ``gpg_home`` attribute is used instead.
|
|
||||||
:return: The verifying command as a list suitable to be
|
|
||||||
passed to :class:`subprocess.Popen`.
|
|
||||||
"""
|
|
||||||
cmd = [self.gpg, '--status-fd', '2', '--no-tty']
|
|
||||||
if keystore is None:
|
|
||||||
keystore = self.gpg_home
|
|
||||||
if keystore:
|
|
||||||
cmd.extend(['--homedir', keystore])
|
|
||||||
cmd.extend(['--verify', signature_filename, data_filename])
|
|
||||||
logger.debug('invoking: %s', ' '.join(cmd))
|
|
||||||
return cmd
|
|
||||||
|
|
||||||
def verify_signature(self, signature_filename, data_filename,
|
|
||||||
keystore=None):
|
|
||||||
"""
|
|
||||||
Verify a signature for a file.
|
|
||||||
|
|
||||||
:param signature_filename: The pathname to the file containing the
|
|
||||||
signature.
|
|
||||||
:param data_filename: The pathname to the file containing the
|
|
||||||
signed data.
|
|
||||||
:param keystore: The path to a directory which contains the keys
|
|
||||||
used in verification. If not specified, the
|
|
||||||
instance's ``gpg_home`` attribute is used instead.
|
|
||||||
:return: True if the signature was verified, else False.
|
|
||||||
"""
|
|
||||||
if not self.gpg:
|
|
||||||
raise DistlibException('verification unavailable because gpg '
|
|
||||||
'unavailable')
|
|
||||||
cmd = self.get_verify_command(signature_filename, data_filename,
|
|
||||||
keystore)
|
|
||||||
rc, stdout, stderr = self.run_command(cmd)
|
|
||||||
if rc not in (0, 1):
|
|
||||||
raise DistlibException('verify command failed with error '
|
|
||||||
'code %s' % rc)
|
|
||||||
return rc == 0
|
|
||||||
|
|
||||||
def download_file(self, url, destfile, digest=None, reporthook=None):
|
|
||||||
"""
|
|
||||||
This is a convenience method for downloading a file from an URL.
|
|
||||||
Normally, this will be a file from the index, though currently
|
|
||||||
no check is made for this (i.e. a file can be downloaded from
|
|
||||||
anywhere).
|
|
||||||
|
|
||||||
The method is just like the :func:`urlretrieve` function in the
|
|
||||||
standard library, except that it allows digest computation to be
|
|
||||||
done during download and checking that the downloaded data
|
|
||||||
matched any expected value.
|
|
||||||
|
|
||||||
:param url: The URL of the file to be downloaded (assumed to be
|
|
||||||
available via an HTTP GET request).
|
|
||||||
:param destfile: The pathname where the downloaded file is to be
|
|
||||||
saved.
|
|
||||||
:param digest: If specified, this must be a (hasher, value)
|
|
||||||
tuple, where hasher is the algorithm used (e.g.
|
|
||||||
``'md5'``) and ``value`` is the expected value.
|
|
||||||
:param reporthook: The same as for :func:`urlretrieve` in the
|
|
||||||
standard library.
|
|
||||||
"""
|
|
||||||
if digest is None:
|
|
||||||
digester = None
|
|
||||||
logger.debug('No digest specified')
|
|
||||||
else:
|
|
||||||
if isinstance(digest, (list, tuple)):
|
|
||||||
hasher, digest = digest
|
|
||||||
else:
|
|
||||||
hasher = 'md5'
|
|
||||||
digester = getattr(hashlib, hasher)()
|
|
||||||
logger.debug('Digest specified: %s' % digest)
|
|
||||||
# The following code is equivalent to urlretrieve.
|
|
||||||
# We need to do it this way so that we can compute the
|
|
||||||
# digest of the file as we go.
|
|
||||||
with open(destfile, 'wb') as dfp:
|
|
||||||
# addinfourl is not a context manager on 2.x
|
|
||||||
# so we have to use try/finally
|
|
||||||
sfp = self.send_request(Request(url))
|
|
||||||
try:
|
|
||||||
headers = sfp.info()
|
|
||||||
blocksize = 8192
|
|
||||||
size = -1
|
|
||||||
read = 0
|
|
||||||
blocknum = 0
|
|
||||||
if "content-length" in headers:
|
|
||||||
size = int(headers["Content-Length"])
|
|
||||||
if reporthook:
|
|
||||||
reporthook(blocknum, blocksize, size)
|
|
||||||
while True:
|
|
||||||
block = sfp.read(blocksize)
|
|
||||||
if not block:
|
|
||||||
break
|
|
||||||
read += len(block)
|
|
||||||
dfp.write(block)
|
|
||||||
if digester:
|
|
||||||
digester.update(block)
|
|
||||||
blocknum += 1
|
|
||||||
if reporthook:
|
|
||||||
reporthook(blocknum, blocksize, size)
|
|
||||||
finally:
|
|
||||||
sfp.close()
|
|
||||||
|
|
||||||
# check that we got the whole file, if we can
|
|
||||||
if size >= 0 and read < size:
|
|
||||||
raise DistlibException(
|
|
||||||
'retrieval incomplete: got only %d out of %d bytes'
|
|
||||||
% (read, size))
|
|
||||||
# if we have a digest, it must match.
|
|
||||||
if digester:
|
|
||||||
actual = digester.hexdigest()
|
|
||||||
if digest != actual:
|
|
||||||
raise DistlibException('%s digest mismatch for %s: expected '
|
|
||||||
'%s, got %s' % (hasher, destfile,
|
|
||||||
digest, actual))
|
|
||||||
logger.debug('Digest verified: %s', digest)
|
|
||||||
|
|
||||||
def send_request(self, req):
|
|
||||||
"""
|
|
||||||
Send a standard library :class:`Request` to PyPI and return its
|
|
||||||
response.
|
|
||||||
|
|
||||||
:param req: The request to send.
|
|
||||||
:return: The HTTP response from PyPI (a standard library HTTPResponse).
|
|
||||||
"""
|
|
||||||
handlers = []
|
|
||||||
if self.password_handler:
|
|
||||||
handlers.append(self.password_handler)
|
|
||||||
if self.ssl_verifier:
|
|
||||||
handlers.append(self.ssl_verifier)
|
|
||||||
opener = build_opener(*handlers)
|
|
||||||
return opener.open(req)
|
|
||||||
|
|
||||||
def encode_request(self, fields, files):
|
|
||||||
"""
|
|
||||||
Encode fields and files for posting to an HTTP server.
|
|
||||||
|
|
||||||
:param fields: The fields to send as a list of (fieldname, value)
|
|
||||||
tuples.
|
|
||||||
:param files: The files to send as a list of (fieldname, filename,
|
|
||||||
file_bytes) tuple.
|
|
||||||
"""
|
|
||||||
# Adapted from packaging, which in turn was adapted from
|
|
||||||
# http://code.activestate.com/recipes/146306
|
|
||||||
|
|
||||||
parts = []
|
|
||||||
boundary = self.boundary
|
|
||||||
for k, values in fields:
|
|
||||||
if not isinstance(values, (list, tuple)):
|
|
||||||
values = [values]
|
|
||||||
|
|
||||||
for v in values:
|
|
||||||
parts.extend((
|
|
||||||
b'--' + boundary,
|
|
||||||
('Content-Disposition: form-data; name="%s"' %
|
|
||||||
k).encode('utf-8'),
|
|
||||||
b'',
|
|
||||||
v.encode('utf-8')))
|
|
||||||
for key, filename, value in files:
|
|
||||||
parts.extend((
|
|
||||||
b'--' + boundary,
|
|
||||||
('Content-Disposition: form-data; name="%s"; filename="%s"' %
|
|
||||||
(key, filename)).encode('utf-8'),
|
|
||||||
b'',
|
|
||||||
value))
|
|
||||||
|
|
||||||
parts.extend((b'--' + boundary + b'--', b''))
|
|
||||||
|
|
||||||
body = b'\r\n'.join(parts)
|
|
||||||
ct = b'multipart/form-data; boundary=' + boundary
|
|
||||||
headers = {
|
|
||||||
'Content-type': ct,
|
|
||||||
'Content-length': str(len(body))
|
|
||||||
}
|
|
||||||
return Request(self.url, body, headers)
|
|
||||||
|
|
||||||
def search(self, terms, operator=None):
|
|
||||||
if isinstance(terms, string_types):
|
|
||||||
terms = {'name': terms}
|
|
||||||
rpc_proxy = ServerProxy(self.url, timeout=3.0)
|
|
||||||
try:
|
|
||||||
return rpc_proxy.search(terms, operator or 'and')
|
|
||||||
finally:
|
|
||||||
rpc_proxy('close')()
|
|
||||||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -1,393 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
#
|
|
||||||
# Copyright (C) 2012-2013 Python Software Foundation.
|
|
||||||
# See LICENSE.txt and CONTRIBUTORS.txt.
|
|
||||||
#
|
|
||||||
"""
|
|
||||||
Class representing the list of files in a distribution.
|
|
||||||
|
|
||||||
Equivalent to distutils.filelist, but fixes some problems.
|
|
||||||
"""
|
|
||||||
import fnmatch
|
|
||||||
import logging
|
|
||||||
import os
|
|
||||||
import re
|
|
||||||
import sys
|
|
||||||
|
|
||||||
from . import DistlibException
|
|
||||||
from .compat import fsdecode
|
|
||||||
from .util import convert_path
|
|
||||||
|
|
||||||
|
|
||||||
__all__ = ['Manifest']
|
|
||||||
|
|
||||||
logger = logging.getLogger(__name__)
|
|
||||||
|
|
||||||
# a \ followed by some spaces + EOL
|
|
||||||
_COLLAPSE_PATTERN = re.compile('\\\\w*\n', re.M)
|
|
||||||
_COMMENTED_LINE = re.compile('#.*?(?=\n)|\n(?=$)', re.M | re.S)
|
|
||||||
|
|
||||||
#
|
|
||||||
# Due to the different results returned by fnmatch.translate, we need
|
|
||||||
# to do slightly different processing for Python 2.7 and 3.2 ... this needed
|
|
||||||
# to be brought in for Python 3.6 onwards.
|
|
||||||
#
|
|
||||||
_PYTHON_VERSION = sys.version_info[:2]
|
|
||||||
|
|
||||||
class Manifest(object):
|
|
||||||
"""A list of files built by on exploring the filesystem and filtered by
|
|
||||||
applying various patterns to what we find there.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, base=None):
|
|
||||||
"""
|
|
||||||
Initialise an instance.
|
|
||||||
|
|
||||||
:param base: The base directory to explore under.
|
|
||||||
"""
|
|
||||||
self.base = os.path.abspath(os.path.normpath(base or os.getcwd()))
|
|
||||||
self.prefix = self.base + os.sep
|
|
||||||
self.allfiles = None
|
|
||||||
self.files = set()
|
|
||||||
|
|
||||||
#
|
|
||||||
# Public API
|
|
||||||
#
|
|
||||||
|
|
||||||
def findall(self):
|
|
||||||
"""Find all files under the base and set ``allfiles`` to the absolute
|
|
||||||
pathnames of files found.
|
|
||||||
"""
|
|
||||||
from stat import S_ISREG, S_ISDIR, S_ISLNK
|
|
||||||
|
|
||||||
self.allfiles = allfiles = []
|
|
||||||
root = self.base
|
|
||||||
stack = [root]
|
|
||||||
pop = stack.pop
|
|
||||||
push = stack.append
|
|
||||||
|
|
||||||
while stack:
|
|
||||||
root = pop()
|
|
||||||
names = os.listdir(root)
|
|
||||||
|
|
||||||
for name in names:
|
|
||||||
fullname = os.path.join(root, name)
|
|
||||||
|
|
||||||
# Avoid excess stat calls -- just one will do, thank you!
|
|
||||||
stat = os.stat(fullname)
|
|
||||||
mode = stat.st_mode
|
|
||||||
if S_ISREG(mode):
|
|
||||||
allfiles.append(fsdecode(fullname))
|
|
||||||
elif S_ISDIR(mode) and not S_ISLNK(mode):
|
|
||||||
push(fullname)
|
|
||||||
|
|
||||||
def add(self, item):
|
|
||||||
"""
|
|
||||||
Add a file to the manifest.
|
|
||||||
|
|
||||||
:param item: The pathname to add. This can be relative to the base.
|
|
||||||
"""
|
|
||||||
if not item.startswith(self.prefix):
|
|
||||||
item = os.path.join(self.base, item)
|
|
||||||
self.files.add(os.path.normpath(item))
|
|
||||||
|
|
||||||
def add_many(self, items):
|
|
||||||
"""
|
|
||||||
Add a list of files to the manifest.
|
|
||||||
|
|
||||||
:param items: The pathnames to add. These can be relative to the base.
|
|
||||||
"""
|
|
||||||
for item in items:
|
|
||||||
self.add(item)
|
|
||||||
|
|
||||||
def sorted(self, wantdirs=False):
|
|
||||||
"""
|
|
||||||
Return sorted files in directory order
|
|
||||||
"""
|
|
||||||
|
|
||||||
def add_dir(dirs, d):
|
|
||||||
dirs.add(d)
|
|
||||||
logger.debug('add_dir added %s', d)
|
|
||||||
if d != self.base:
|
|
||||||
parent, _ = os.path.split(d)
|
|
||||||
assert parent not in ('', '/')
|
|
||||||
add_dir(dirs, parent)
|
|
||||||
|
|
||||||
result = set(self.files) # make a copy!
|
|
||||||
if wantdirs:
|
|
||||||
dirs = set()
|
|
||||||
for f in result:
|
|
||||||
add_dir(dirs, os.path.dirname(f))
|
|
||||||
result |= dirs
|
|
||||||
return [os.path.join(*path_tuple) for path_tuple in
|
|
||||||
sorted(os.path.split(path) for path in result)]
|
|
||||||
|
|
||||||
def clear(self):
|
|
||||||
"""Clear all collected files."""
|
|
||||||
self.files = set()
|
|
||||||
self.allfiles = []
|
|
||||||
|
|
||||||
def process_directive(self, directive):
|
|
||||||
"""
|
|
||||||
Process a directive which either adds some files from ``allfiles`` to
|
|
||||||
``files``, or removes some files from ``files``.
|
|
||||||
|
|
||||||
:param directive: The directive to process. This should be in a format
|
|
||||||
compatible with distutils ``MANIFEST.in`` files:
|
|
||||||
|
|
||||||
http://docs.python.org/distutils/sourcedist.html#commands
|
|
||||||
"""
|
|
||||||
# Parse the line: split it up, make sure the right number of words
|
|
||||||
# is there, and return the relevant words. 'action' is always
|
|
||||||
# defined: it's the first word of the line. Which of the other
|
|
||||||
# three are defined depends on the action; it'll be either
|
|
||||||
# patterns, (dir and patterns), or (dirpattern).
|
|
||||||
action, patterns, thedir, dirpattern = self._parse_directive(directive)
|
|
||||||
|
|
||||||
# OK, now we know that the action is valid and we have the
|
|
||||||
# right number of words on the line for that action -- so we
|
|
||||||
# can proceed with minimal error-checking.
|
|
||||||
if action == 'include':
|
|
||||||
for pattern in patterns:
|
|
||||||
if not self._include_pattern(pattern, anchor=True):
|
|
||||||
logger.warning('no files found matching %r', pattern)
|
|
||||||
|
|
||||||
elif action == 'exclude':
|
|
||||||
for pattern in patterns:
|
|
||||||
found = self._exclude_pattern(pattern, anchor=True)
|
|
||||||
#if not found:
|
|
||||||
# logger.warning('no previously-included files '
|
|
||||||
# 'found matching %r', pattern)
|
|
||||||
|
|
||||||
elif action == 'global-include':
|
|
||||||
for pattern in patterns:
|
|
||||||
if not self._include_pattern(pattern, anchor=False):
|
|
||||||
logger.warning('no files found matching %r '
|
|
||||||
'anywhere in distribution', pattern)
|
|
||||||
|
|
||||||
elif action == 'global-exclude':
|
|
||||||
for pattern in patterns:
|
|
||||||
found = self._exclude_pattern(pattern, anchor=False)
|
|
||||||
#if not found:
|
|
||||||
# logger.warning('no previously-included files '
|
|
||||||
# 'matching %r found anywhere in '
|
|
||||||
# 'distribution', pattern)
|
|
||||||
|
|
||||||
elif action == 'recursive-include':
|
|
||||||
for pattern in patterns:
|
|
||||||
if not self._include_pattern(pattern, prefix=thedir):
|
|
||||||
logger.warning('no files found matching %r '
|
|
||||||
'under directory %r', pattern, thedir)
|
|
||||||
|
|
||||||
elif action == 'recursive-exclude':
|
|
||||||
for pattern in patterns:
|
|
||||||
found = self._exclude_pattern(pattern, prefix=thedir)
|
|
||||||
#if not found:
|
|
||||||
# logger.warning('no previously-included files '
|
|
||||||
# 'matching %r found under directory %r',
|
|
||||||
# pattern, thedir)
|
|
||||||
|
|
||||||
elif action == 'graft':
|
|
||||||
if not self._include_pattern(None, prefix=dirpattern):
|
|
||||||
logger.warning('no directories found matching %r',
|
|
||||||
dirpattern)
|
|
||||||
|
|
||||||
elif action == 'prune':
|
|
||||||
if not self._exclude_pattern(None, prefix=dirpattern):
|
|
||||||
logger.warning('no previously-included directories found '
|
|
||||||
'matching %r', dirpattern)
|
|
||||||
else: # pragma: no cover
|
|
||||||
# This should never happen, as it should be caught in
|
|
||||||
# _parse_template_line
|
|
||||||
raise DistlibException(
|
|
||||||
'invalid action %r' % action)
|
|
||||||
|
|
||||||
#
|
|
||||||
# Private API
|
|
||||||
#
|
|
||||||
|
|
||||||
def _parse_directive(self, directive):
|
|
||||||
"""
|
|
||||||
Validate a directive.
|
|
||||||
:param directive: The directive to validate.
|
|
||||||
:return: A tuple of action, patterns, thedir, dir_patterns
|
|
||||||
"""
|
|
||||||
words = directive.split()
|
|
||||||
if len(words) == 1 and words[0] not in ('include', 'exclude',
|
|
||||||
'global-include',
|
|
||||||
'global-exclude',
|
|
||||||
'recursive-include',
|
|
||||||
'recursive-exclude',
|
|
||||||
'graft', 'prune'):
|
|
||||||
# no action given, let's use the default 'include'
|
|
||||||
words.insert(0, 'include')
|
|
||||||
|
|
||||||
action = words[0]
|
|
||||||
patterns = thedir = dir_pattern = None
|
|
||||||
|
|
||||||
if action in ('include', 'exclude',
|
|
||||||
'global-include', 'global-exclude'):
|
|
||||||
if len(words) < 2:
|
|
||||||
raise DistlibException(
|
|
||||||
'%r expects <pattern1> <pattern2> ...' % action)
|
|
||||||
|
|
||||||
patterns = [convert_path(word) for word in words[1:]]
|
|
||||||
|
|
||||||
elif action in ('recursive-include', 'recursive-exclude'):
|
|
||||||
if len(words) < 3:
|
|
||||||
raise DistlibException(
|
|
||||||
'%r expects <dir> <pattern1> <pattern2> ...' % action)
|
|
||||||
|
|
||||||
thedir = convert_path(words[1])
|
|
||||||
patterns = [convert_path(word) for word in words[2:]]
|
|
||||||
|
|
||||||
elif action in ('graft', 'prune'):
|
|
||||||
if len(words) != 2:
|
|
||||||
raise DistlibException(
|
|
||||||
'%r expects a single <dir_pattern>' % action)
|
|
||||||
|
|
||||||
dir_pattern = convert_path(words[1])
|
|
||||||
|
|
||||||
else:
|
|
||||||
raise DistlibException('unknown action %r' % action)
|
|
||||||
|
|
||||||
return action, patterns, thedir, dir_pattern
|
|
||||||
|
|
||||||
def _include_pattern(self, pattern, anchor=True, prefix=None,
|
|
||||||
is_regex=False):
|
|
||||||
"""Select strings (presumably filenames) from 'self.files' that
|
|
||||||
match 'pattern', a Unix-style wildcard (glob) pattern.
|
|
||||||
|
|
||||||
Patterns are not quite the same as implemented by the 'fnmatch'
|
|
||||||
module: '*' and '?' match non-special characters, where "special"
|
|
||||||
is platform-dependent: slash on Unix; colon, slash, and backslash on
|
|
||||||
DOS/Windows; and colon on Mac OS.
|
|
||||||
|
|
||||||
If 'anchor' is true (the default), then the pattern match is more
|
|
||||||
stringent: "*.py" will match "foo.py" but not "foo/bar.py". If
|
|
||||||
'anchor' is false, both of these will match.
|
|
||||||
|
|
||||||
If 'prefix' is supplied, then only filenames starting with 'prefix'
|
|
||||||
(itself a pattern) and ending with 'pattern', with anything in between
|
|
||||||
them, will match. 'anchor' is ignored in this case.
|
|
||||||
|
|
||||||
If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
|
|
||||||
'pattern' is assumed to be either a string containing a regex or a
|
|
||||||
regex object -- no translation is done, the regex is just compiled
|
|
||||||
and used as-is.
|
|
||||||
|
|
||||||
Selected strings will be added to self.files.
|
|
||||||
|
|
||||||
Return True if files are found.
|
|
||||||
"""
|
|
||||||
# XXX docstring lying about what the special chars are?
|
|
||||||
found = False
|
|
||||||
pattern_re = self._translate_pattern(pattern, anchor, prefix, is_regex)
|
|
||||||
|
|
||||||
# delayed loading of allfiles list
|
|
||||||
if self.allfiles is None:
|
|
||||||
self.findall()
|
|
||||||
|
|
||||||
for name in self.allfiles:
|
|
||||||
if pattern_re.search(name):
|
|
||||||
self.files.add(name)
|
|
||||||
found = True
|
|
||||||
return found
|
|
||||||
|
|
||||||
def _exclude_pattern(self, pattern, anchor=True, prefix=None,
|
|
||||||
is_regex=False):
|
|
||||||
"""Remove strings (presumably filenames) from 'files' that match
|
|
||||||
'pattern'.
|
|
||||||
|
|
||||||
Other parameters are the same as for 'include_pattern()', above.
|
|
||||||
The list 'self.files' is modified in place. Return True if files are
|
|
||||||
found.
|
|
||||||
|
|
||||||
This API is public to allow e.g. exclusion of SCM subdirs, e.g. when
|
|
||||||
packaging source distributions
|
|
||||||
"""
|
|
||||||
found = False
|
|
||||||
pattern_re = self._translate_pattern(pattern, anchor, prefix, is_regex)
|
|
||||||
for f in list(self.files):
|
|
||||||
if pattern_re.search(f):
|
|
||||||
self.files.remove(f)
|
|
||||||
found = True
|
|
||||||
return found
|
|
||||||
|
|
||||||
def _translate_pattern(self, pattern, anchor=True, prefix=None,
|
|
||||||
is_regex=False):
|
|
||||||
"""Translate a shell-like wildcard pattern to a compiled regular
|
|
||||||
expression.
|
|
||||||
|
|
||||||
Return the compiled regex. If 'is_regex' true,
|
|
||||||
then 'pattern' is directly compiled to a regex (if it's a string)
|
|
||||||
or just returned as-is (assumes it's a regex object).
|
|
||||||
"""
|
|
||||||
if is_regex:
|
|
||||||
if isinstance(pattern, str):
|
|
||||||
return re.compile(pattern)
|
|
||||||
else:
|
|
||||||
return pattern
|
|
||||||
|
|
||||||
if _PYTHON_VERSION > (3, 2):
|
|
||||||
# ditch start and end characters
|
|
||||||
start, _, end = self._glob_to_re('_').partition('_')
|
|
||||||
|
|
||||||
if pattern:
|
|
||||||
pattern_re = self._glob_to_re(pattern)
|
|
||||||
if _PYTHON_VERSION > (3, 2):
|
|
||||||
assert pattern_re.startswith(start) and pattern_re.endswith(end)
|
|
||||||
else:
|
|
||||||
pattern_re = ''
|
|
||||||
|
|
||||||
base = re.escape(os.path.join(self.base, ''))
|
|
||||||
if prefix is not None:
|
|
||||||
# ditch end of pattern character
|
|
||||||
if _PYTHON_VERSION <= (3, 2):
|
|
||||||
empty_pattern = self._glob_to_re('')
|
|
||||||
prefix_re = self._glob_to_re(prefix)[:-len(empty_pattern)]
|
|
||||||
else:
|
|
||||||
prefix_re = self._glob_to_re(prefix)
|
|
||||||
assert prefix_re.startswith(start) and prefix_re.endswith(end)
|
|
||||||
prefix_re = prefix_re[len(start): len(prefix_re) - len(end)]
|
|
||||||
sep = os.sep
|
|
||||||
if os.sep == '\\':
|
|
||||||
sep = r'\\'
|
|
||||||
if _PYTHON_VERSION <= (3, 2):
|
|
||||||
pattern_re = '^' + base + sep.join((prefix_re,
|
|
||||||
'.*' + pattern_re))
|
|
||||||
else:
|
|
||||||
pattern_re = pattern_re[len(start): len(pattern_re) - len(end)]
|
|
||||||
pattern_re = r'%s%s%s%s.*%s%s' % (start, base, prefix_re, sep,
|
|
||||||
pattern_re, end)
|
|
||||||
else: # no prefix -- respect anchor flag
|
|
||||||
if anchor:
|
|
||||||
if _PYTHON_VERSION <= (3, 2):
|
|
||||||
pattern_re = '^' + base + pattern_re
|
|
||||||
else:
|
|
||||||
pattern_re = r'%s%s%s' % (start, base, pattern_re[len(start):])
|
|
||||||
|
|
||||||
return re.compile(pattern_re)
|
|
||||||
|
|
||||||
def _glob_to_re(self, pattern):
|
|
||||||
"""Translate a shell-like glob pattern to a regular expression.
|
|
||||||
|
|
||||||
Return a string containing the regex. Differs from
|
|
||||||
'fnmatch.translate()' in that '*' does not match "special characters"
|
|
||||||
(which are platform-specific).
|
|
||||||
"""
|
|
||||||
pattern_re = fnmatch.translate(pattern)
|
|
||||||
|
|
||||||
# '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
|
|
||||||
# IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
|
|
||||||
# and by extension they shouldn't match such "special characters" under
|
|
||||||
# any OS. So change all non-escaped dots in the RE to match any
|
|
||||||
# character except the special characters (currently: just os.sep).
|
|
||||||
sep = os.sep
|
|
||||||
if os.sep == '\\':
|
|
||||||
# we're using a regex to manipulate a regex, so we need
|
|
||||||
# to escape the backslash twice
|
|
||||||
sep = r'\\\\'
|
|
||||||
escaped = r'\1[^%s]' % sep
|
|
||||||
pattern_re = re.sub(r'((?<!\\)(\\\\)*)\.', escaped, pattern_re)
|
|
||||||
return pattern_re
|
|
||||||
|
|
@ -1,130 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
#
|
|
||||||
# Copyright (C) 2012-2017 Vinay Sajip.
|
|
||||||
# Licensed to the Python Software Foundation under a contributor agreement.
|
|
||||||
# See LICENSE.txt and CONTRIBUTORS.txt.
|
|
||||||
#
|
|
||||||
"""
|
|
||||||
Parser for the environment markers micro-language defined in PEP 508.
|
|
||||||
"""
|
|
||||||
|
|
||||||
# Note: In PEP 345, the micro-language was Python compatible, so the ast
|
|
||||||
# module could be used to parse it. However, PEP 508 introduced operators such
|
|
||||||
# as ~= and === which aren't in Python, necessitating a different approach.
|
|
||||||
|
|
||||||
import os
|
|
||||||
import sys
|
|
||||||
import platform
|
|
||||||
|
|
||||||
from .compat import string_types
|
|
||||||
from .util import in_venv, parse_marker
|
|
||||||
|
|
||||||
__all__ = ['interpret']
|
|
||||||
|
|
||||||
def _is_literal(o):
|
|
||||||
if not isinstance(o, string_types) or not o:
|
|
||||||
return False
|
|
||||||
return o[0] in '\'"'
|
|
||||||
|
|
||||||
class Evaluator(object):
|
|
||||||
"""
|
|
||||||
This class is used to evaluate marker expessions.
|
|
||||||
"""
|
|
||||||
|
|
||||||
operations = {
|
|
||||||
'==': lambda x, y: x == y,
|
|
||||||
'===': lambda x, y: x == y,
|
|
||||||
'~=': lambda x, y: x == y or x > y,
|
|
||||||
'!=': lambda x, y: x != y,
|
|
||||||
'<': lambda x, y: x < y,
|
|
||||||
'<=': lambda x, y: x == y or x < y,
|
|
||||||
'>': lambda x, y: x > y,
|
|
||||||
'>=': lambda x, y: x == y or x > y,
|
|
||||||
'and': lambda x, y: x and y,
|
|
||||||
'or': lambda x, y: x or y,
|
|
||||||
'in': lambda x, y: x in y,
|
|
||||||
'not in': lambda x, y: x not in y,
|
|
||||||
}
|
|
||||||
|
|
||||||
def evaluate(self, expr, context):
|
|
||||||
"""
|
|
||||||
Evaluate a marker expression returned by the :func:`parse_requirement`
|
|
||||||
function in the specified context.
|
|
||||||
"""
|
|
||||||
if isinstance(expr, string_types):
|
|
||||||
if expr[0] in '\'"':
|
|
||||||
result = expr[1:-1]
|
|
||||||
else:
|
|
||||||
if expr not in context:
|
|
||||||
raise SyntaxError('unknown variable: %s' % expr)
|
|
||||||
result = context[expr]
|
|
||||||
else:
|
|
||||||
assert isinstance(expr, dict)
|
|
||||||
op = expr['op']
|
|
||||||
if op not in self.operations:
|
|
||||||
raise NotImplementedError('op not implemented: %s' % op)
|
|
||||||
elhs = expr['lhs']
|
|
||||||
erhs = expr['rhs']
|
|
||||||
if _is_literal(expr['lhs']) and _is_literal(expr['rhs']):
|
|
||||||
raise SyntaxError('invalid comparison: %s %s %s' % (elhs, op, erhs))
|
|
||||||
|
|
||||||
lhs = self.evaluate(elhs, context)
|
|
||||||
rhs = self.evaluate(erhs, context)
|
|
||||||
result = self.operations[op](lhs, rhs)
|
|
||||||
return result
|
|
||||||
|
|
||||||
def default_context():
|
|
||||||
def format_full_version(info):
|
|
||||||
version = '%s.%s.%s' % (info.major, info.minor, info.micro)
|
|
||||||
kind = info.releaselevel
|
|
||||||
if kind != 'final':
|
|
||||||
version += kind[0] + str(info.serial)
|
|
||||||
return version
|
|
||||||
|
|
||||||
if hasattr(sys, 'implementation'):
|
|
||||||
implementation_version = format_full_version(sys.implementation.version)
|
|
||||||
implementation_name = sys.implementation.name
|
|
||||||
else:
|
|
||||||
implementation_version = '0'
|
|
||||||
implementation_name = ''
|
|
||||||
|
|
||||||
result = {
|
|
||||||
'implementation_name': implementation_name,
|
|
||||||
'implementation_version': implementation_version,
|
|
||||||
'os_name': os.name,
|
|
||||||
'platform_machine': platform.machine(),
|
|
||||||
'platform_python_implementation': platform.python_implementation(),
|
|
||||||
'platform_release': platform.release(),
|
|
||||||
'platform_system': platform.system(),
|
|
||||||
'platform_version': platform.version(),
|
|
||||||
'platform_in_venv': str(in_venv()),
|
|
||||||
'python_full_version': platform.python_version(),
|
|
||||||
'python_version': platform.python_version()[:3],
|
|
||||||
'sys_platform': sys.platform,
|
|
||||||
}
|
|
||||||
return result
|
|
||||||
|
|
||||||
DEFAULT_CONTEXT = default_context()
|
|
||||||
del default_context
|
|
||||||
|
|
||||||
evaluator = Evaluator()
|
|
||||||
|
|
||||||
def interpret(marker, execution_context=None):
|
|
||||||
"""
|
|
||||||
Interpret a marker and return a result depending on environment.
|
|
||||||
|
|
||||||
:param marker: The marker to interpret.
|
|
||||||
:type marker: str
|
|
||||||
:param execution_context: The context used for name lookup.
|
|
||||||
:type execution_context: mapping
|
|
||||||
"""
|
|
||||||
try:
|
|
||||||
expr, rest = parse_marker(marker)
|
|
||||||
except Exception as e:
|
|
||||||
raise SyntaxError('Unable to interpret marker syntax: %s: %s' % (marker, e))
|
|
||||||
if rest and rest[0] != '#':
|
|
||||||
raise SyntaxError('unexpected trailing data in marker: %s: %s' % (marker, rest))
|
|
||||||
context = dict(DEFAULT_CONTEXT)
|
|
||||||
if execution_context:
|
|
||||||
context.update(execution_context)
|
|
||||||
return evaluator.evaluate(expr, context)
|
|
||||||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -1,358 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
#
|
|
||||||
# Copyright (C) 2013-2017 Vinay Sajip.
|
|
||||||
# Licensed to the Python Software Foundation under a contributor agreement.
|
|
||||||
# See LICENSE.txt and CONTRIBUTORS.txt.
|
|
||||||
#
|
|
||||||
from __future__ import unicode_literals
|
|
||||||
|
|
||||||
import bisect
|
|
||||||
import io
|
|
||||||
import logging
|
|
||||||
import os
|
|
||||||
import pkgutil
|
|
||||||
import sys
|
|
||||||
import types
|
|
||||||
import zipimport
|
|
||||||
|
|
||||||
from . import DistlibException
|
|
||||||
from .util import cached_property, get_cache_base, Cache
|
|
||||||
|
|
||||||
logger = logging.getLogger(__name__)
|
|
||||||
|
|
||||||
|
|
||||||
cache = None # created when needed
|
|
||||||
|
|
||||||
|
|
||||||
class ResourceCache(Cache):
|
|
||||||
def __init__(self, base=None):
|
|
||||||
if base is None:
|
|
||||||
# Use native string to avoid issues on 2.x: see Python #20140.
|
|
||||||
base = os.path.join(get_cache_base(), str('resource-cache'))
|
|
||||||
super(ResourceCache, self).__init__(base)
|
|
||||||
|
|
||||||
def is_stale(self, resource, path):
|
|
||||||
"""
|
|
||||||
Is the cache stale for the given resource?
|
|
||||||
|
|
||||||
:param resource: The :class:`Resource` being cached.
|
|
||||||
:param path: The path of the resource in the cache.
|
|
||||||
:return: True if the cache is stale.
|
|
||||||
"""
|
|
||||||
# Cache invalidation is a hard problem :-)
|
|
||||||
return True
|
|
||||||
|
|
||||||
def get(self, resource):
|
|
||||||
"""
|
|
||||||
Get a resource into the cache,
|
|
||||||
|
|
||||||
:param resource: A :class:`Resource` instance.
|
|
||||||
:return: The pathname of the resource in the cache.
|
|
||||||
"""
|
|
||||||
prefix, path = resource.finder.get_cache_info(resource)
|
|
||||||
if prefix is None:
|
|
||||||
result = path
|
|
||||||
else:
|
|
||||||
result = os.path.join(self.base, self.prefix_to_dir(prefix), path)
|
|
||||||
dirname = os.path.dirname(result)
|
|
||||||
if not os.path.isdir(dirname):
|
|
||||||
os.makedirs(dirname)
|
|
||||||
if not os.path.exists(result):
|
|
||||||
stale = True
|
|
||||||
else:
|
|
||||||
stale = self.is_stale(resource, path)
|
|
||||||
if stale:
|
|
||||||
# write the bytes of the resource to the cache location
|
|
||||||
with open(result, 'wb') as f:
|
|
||||||
f.write(resource.bytes)
|
|
||||||
return result
|
|
||||||
|
|
||||||
|
|
||||||
class ResourceBase(object):
|
|
||||||
def __init__(self, finder, name):
|
|
||||||
self.finder = finder
|
|
||||||
self.name = name
|
|
||||||
|
|
||||||
|
|
||||||
class Resource(ResourceBase):
|
|
||||||
"""
|
|
||||||
A class representing an in-package resource, such as a data file. This is
|
|
||||||
not normally instantiated by user code, but rather by a
|
|
||||||
:class:`ResourceFinder` which manages the resource.
|
|
||||||
"""
|
|
||||||
is_container = False # Backwards compatibility
|
|
||||||
|
|
||||||
def as_stream(self):
|
|
||||||
"""
|
|
||||||
Get the resource as a stream.
|
|
||||||
|
|
||||||
This is not a property to make it obvious that it returns a new stream
|
|
||||||
each time.
|
|
||||||
"""
|
|
||||||
return self.finder.get_stream(self)
|
|
||||||
|
|
||||||
@cached_property
|
|
||||||
def file_path(self):
|
|
||||||
global cache
|
|
||||||
if cache is None:
|
|
||||||
cache = ResourceCache()
|
|
||||||
return cache.get(self)
|
|
||||||
|
|
||||||
@cached_property
|
|
||||||
def bytes(self):
|
|
||||||
return self.finder.get_bytes(self)
|
|
||||||
|
|
||||||
@cached_property
|
|
||||||
def size(self):
|
|
||||||
return self.finder.get_size(self)
|
|
||||||
|
|
||||||
|
|
||||||
class ResourceContainer(ResourceBase):
|
|
||||||
is_container = True # Backwards compatibility
|
|
||||||
|
|
||||||
@cached_property
|
|
||||||
def resources(self):
|
|
||||||
return self.finder.get_resources(self)
|
|
||||||
|
|
||||||
|
|
||||||
class ResourceFinder(object):
|
|
||||||
"""
|
|
||||||
Resource finder for file system resources.
|
|
||||||
"""
|
|
||||||
|
|
||||||
if sys.platform.startswith('java'):
|
|
||||||
skipped_extensions = ('.pyc', '.pyo', '.class')
|
|
||||||
else:
|
|
||||||
skipped_extensions = ('.pyc', '.pyo')
|
|
||||||
|
|
||||||
def __init__(self, module):
|
|
||||||
self.module = module
|
|
||||||
self.loader = getattr(module, '__loader__', None)
|
|
||||||
self.base = os.path.dirname(getattr(module, '__file__', ''))
|
|
||||||
|
|
||||||
def _adjust_path(self, path):
|
|
||||||
return os.path.realpath(path)
|
|
||||||
|
|
||||||
def _make_path(self, resource_name):
|
|
||||||
# Issue #50: need to preserve type of path on Python 2.x
|
|
||||||
# like os.path._get_sep
|
|
||||||
if isinstance(resource_name, bytes): # should only happen on 2.x
|
|
||||||
sep = b'/'
|
|
||||||
else:
|
|
||||||
sep = '/'
|
|
||||||
parts = resource_name.split(sep)
|
|
||||||
parts.insert(0, self.base)
|
|
||||||
result = os.path.join(*parts)
|
|
||||||
return self._adjust_path(result)
|
|
||||||
|
|
||||||
def _find(self, path):
|
|
||||||
return os.path.exists(path)
|
|
||||||
|
|
||||||
def get_cache_info(self, resource):
|
|
||||||
return None, resource.path
|
|
||||||
|
|
||||||
def find(self, resource_name):
|
|
||||||
path = self._make_path(resource_name)
|
|
||||||
if not self._find(path):
|
|
||||||
result = None
|
|
||||||
else:
|
|
||||||
if self._is_directory(path):
|
|
||||||
result = ResourceContainer(self, resource_name)
|
|
||||||
else:
|
|
||||||
result = Resource(self, resource_name)
|
|
||||||
result.path = path
|
|
||||||
return result
|
|
||||||
|
|
||||||
def get_stream(self, resource):
|
|
||||||
return open(resource.path, 'rb')
|
|
||||||
|
|
||||||
def get_bytes(self, resource):
|
|
||||||
with open(resource.path, 'rb') as f:
|
|
||||||
return f.read()
|
|
||||||
|
|
||||||
def get_size(self, resource):
|
|
||||||
return os.path.getsize(resource.path)
|
|
||||||
|
|
||||||
def get_resources(self, resource):
|
|
||||||
def allowed(f):
|
|
||||||
return (f != '__pycache__' and not
|
|
||||||
f.endswith(self.skipped_extensions))
|
|
||||||
return set([f for f in os.listdir(resource.path) if allowed(f)])
|
|
||||||
|
|
||||||
def is_container(self, resource):
|
|
||||||
return self._is_directory(resource.path)
|
|
||||||
|
|
||||||
_is_directory = staticmethod(os.path.isdir)
|
|
||||||
|
|
||||||
def iterator(self, resource_name):
|
|
||||||
resource = self.find(resource_name)
|
|
||||||
if resource is not None:
|
|
||||||
todo = [resource]
|
|
||||||
while todo:
|
|
||||||
resource = todo.pop(0)
|
|
||||||
yield resource
|
|
||||||
if resource.is_container:
|
|
||||||
rname = resource.name
|
|
||||||
for name in resource.resources:
|
|
||||||
if not rname:
|
|
||||||
new_name = name
|
|
||||||
else:
|
|
||||||
new_name = '/'.join([rname, name])
|
|
||||||
child = self.find(new_name)
|
|
||||||
if child.is_container:
|
|
||||||
todo.append(child)
|
|
||||||
else:
|
|
||||||
yield child
|
|
||||||
|
|
||||||
|
|
||||||
class ZipResourceFinder(ResourceFinder):
|
|
||||||
"""
|
|
||||||
Resource finder for resources in .zip files.
|
|
||||||
"""
|
|
||||||
def __init__(self, module):
|
|
||||||
super(ZipResourceFinder, self).__init__(module)
|
|
||||||
archive = self.loader.archive
|
|
||||||
self.prefix_len = 1 + len(archive)
|
|
||||||
# PyPy doesn't have a _files attr on zipimporter, and you can't set one
|
|
||||||
if hasattr(self.loader, '_files'):
|
|
||||||
self._files = self.loader._files
|
|
||||||
else:
|
|
||||||
self._files = zipimport._zip_directory_cache[archive]
|
|
||||||
self.index = sorted(self._files)
|
|
||||||
|
|
||||||
def _adjust_path(self, path):
|
|
||||||
return path
|
|
||||||
|
|
||||||
def _find(self, path):
|
|
||||||
path = path[self.prefix_len:]
|
|
||||||
if path in self._files:
|
|
||||||
result = True
|
|
||||||
else:
|
|
||||||
if path and path[-1] != os.sep:
|
|
||||||
path = path + os.sep
|
|
||||||
i = bisect.bisect(self.index, path)
|
|
||||||
try:
|
|
||||||
result = self.index[i].startswith(path)
|
|
||||||
except IndexError:
|
|
||||||
result = False
|
|
||||||
if not result:
|
|
||||||
logger.debug('_find failed: %r %r', path, self.loader.prefix)
|
|
||||||
else:
|
|
||||||
logger.debug('_find worked: %r %r', path, self.loader.prefix)
|
|
||||||
return result
|
|
||||||
|
|
||||||
def get_cache_info(self, resource):
|
|
||||||
prefix = self.loader.archive
|
|
||||||
path = resource.path[1 + len(prefix):]
|
|
||||||
return prefix, path
|
|
||||||
|
|
||||||
def get_bytes(self, resource):
|
|
||||||
return self.loader.get_data(resource.path)
|
|
||||||
|
|
||||||
def get_stream(self, resource):
|
|
||||||
return io.BytesIO(self.get_bytes(resource))
|
|
||||||
|
|
||||||
def get_size(self, resource):
|
|
||||||
path = resource.path[self.prefix_len:]
|
|
||||||
return self._files[path][3]
|
|
||||||
|
|
||||||
def get_resources(self, resource):
|
|
||||||
path = resource.path[self.prefix_len:]
|
|
||||||
if path and path[-1] != os.sep:
|
|
||||||
path += os.sep
|
|
||||||
plen = len(path)
|
|
||||||
result = set()
|
|
||||||
i = bisect.bisect(self.index, path)
|
|
||||||
while i < len(self.index):
|
|
||||||
if not self.index[i].startswith(path):
|
|
||||||
break
|
|
||||||
s = self.index[i][plen:]
|
|
||||||
result.add(s.split(os.sep, 1)[0]) # only immediate children
|
|
||||||
i += 1
|
|
||||||
return result
|
|
||||||
|
|
||||||
def _is_directory(self, path):
|
|
||||||
path = path[self.prefix_len:]
|
|
||||||
if path and path[-1] != os.sep:
|
|
||||||
path += os.sep
|
|
||||||
i = bisect.bisect(self.index, path)
|
|
||||||
try:
|
|
||||||
result = self.index[i].startswith(path)
|
|
||||||
except IndexError:
|
|
||||||
result = False
|
|
||||||
return result
|
|
||||||
|
|
||||||
|
|
||||||
_finder_registry = {
|
|
||||||
type(None): ResourceFinder,
|
|
||||||
zipimport.zipimporter: ZipResourceFinder
|
|
||||||
}
|
|
||||||
|
|
||||||
try:
|
|
||||||
# In Python 3.6, _frozen_importlib -> _frozen_importlib_external
|
|
||||||
try:
|
|
||||||
import _frozen_importlib_external as _fi
|
|
||||||
except ImportError:
|
|
||||||
import _frozen_importlib as _fi
|
|
||||||
_finder_registry[_fi.SourceFileLoader] = ResourceFinder
|
|
||||||
_finder_registry[_fi.FileFinder] = ResourceFinder
|
|
||||||
# See issue #146
|
|
||||||
_finder_registry[_fi.SourcelessFileLoader] = ResourceFinder
|
|
||||||
del _fi
|
|
||||||
except (ImportError, AttributeError):
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
def register_finder(loader, finder_maker):
|
|
||||||
_finder_registry[type(loader)] = finder_maker
|
|
||||||
|
|
||||||
|
|
||||||
_finder_cache = {}
|
|
||||||
|
|
||||||
|
|
||||||
def finder(package):
|
|
||||||
"""
|
|
||||||
Return a resource finder for a package.
|
|
||||||
:param package: The name of the package.
|
|
||||||
:return: A :class:`ResourceFinder` instance for the package.
|
|
||||||
"""
|
|
||||||
if package in _finder_cache:
|
|
||||||
result = _finder_cache[package]
|
|
||||||
else:
|
|
||||||
if package not in sys.modules:
|
|
||||||
__import__(package)
|
|
||||||
module = sys.modules[package]
|
|
||||||
path = getattr(module, '__path__', None)
|
|
||||||
if path is None:
|
|
||||||
raise DistlibException('You cannot get a finder for a module, '
|
|
||||||
'only for a package')
|
|
||||||
loader = getattr(module, '__loader__', None)
|
|
||||||
finder_maker = _finder_registry.get(type(loader))
|
|
||||||
if finder_maker is None:
|
|
||||||
raise DistlibException('Unable to locate finder for %r' % package)
|
|
||||||
result = finder_maker(module)
|
|
||||||
_finder_cache[package] = result
|
|
||||||
return result
|
|
||||||
|
|
||||||
|
|
||||||
_dummy_module = types.ModuleType(str('__dummy__'))
|
|
||||||
|
|
||||||
|
|
||||||
def finder_for_path(path):
|
|
||||||
"""
|
|
||||||
Return a resource finder for a path, which should represent a container.
|
|
||||||
|
|
||||||
:param path: The path.
|
|
||||||
:return: A :class:`ResourceFinder` instance for the path.
|
|
||||||
"""
|
|
||||||
result = None
|
|
||||||
# calls any path hooks, gets importer into cache
|
|
||||||
pkgutil.get_importer(path)
|
|
||||||
loader = sys.path_importer_cache.get(path)
|
|
||||||
finder = _finder_registry.get(type(loader))
|
|
||||||
if finder:
|
|
||||||
module = _dummy_module
|
|
||||||
module.__file__ = os.path.join(path, '')
|
|
||||||
module.__loader__ = loader
|
|
||||||
result = finder(module)
|
|
||||||
return result
|
|
||||||
|
|
@ -1,423 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
#
|
|
||||||
# Copyright (C) 2013-2015 Vinay Sajip.
|
|
||||||
# Licensed to the Python Software Foundation under a contributor agreement.
|
|
||||||
# See LICENSE.txt and CONTRIBUTORS.txt.
|
|
||||||
#
|
|
||||||
from io import BytesIO
|
|
||||||
import logging
|
|
||||||
import os
|
|
||||||
import re
|
|
||||||
import struct
|
|
||||||
import sys
|
|
||||||
|
|
||||||
from .compat import sysconfig, detect_encoding, ZipFile
|
|
||||||
from .resources import finder
|
|
||||||
from .util import (FileOperator, get_export_entry, convert_path,
|
|
||||||
get_executable, in_venv)
|
|
||||||
|
|
||||||
logger = logging.getLogger(__name__)
|
|
||||||
|
|
||||||
_DEFAULT_MANIFEST = '''
|
|
||||||
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
|
||||||
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
|
|
||||||
<assemblyIdentity version="1.0.0.0"
|
|
||||||
processorArchitecture="X86"
|
|
||||||
name="%s"
|
|
||||||
type="win32"/>
|
|
||||||
|
|
||||||
<!-- Identify the application security requirements. -->
|
|
||||||
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
|
|
||||||
<security>
|
|
||||||
<requestedPrivileges>
|
|
||||||
<requestedExecutionLevel level="asInvoker" uiAccess="false"/>
|
|
||||||
</requestedPrivileges>
|
|
||||||
</security>
|
|
||||||
</trustInfo>
|
|
||||||
</assembly>'''.strip()
|
|
||||||
|
|
||||||
# check if Python is called on the first line with this expression
|
|
||||||
FIRST_LINE_RE = re.compile(b'^#!.*pythonw?[0-9.]*([ \t].*)?$')
|
|
||||||
SCRIPT_TEMPLATE = r'''# -*- coding: utf-8 -*-
|
|
||||||
import re
|
|
||||||
import sys
|
|
||||||
from %(module)s import %(import_name)s
|
|
||||||
if __name__ == '__main__':
|
|
||||||
sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
|
|
||||||
sys.exit(%(func)s())
|
|
||||||
'''
|
|
||||||
|
|
||||||
|
|
||||||
def enquote_executable(executable):
|
|
||||||
if ' ' in executable:
|
|
||||||
# make sure we quote only the executable in case of env
|
|
||||||
# for example /usr/bin/env "/dir with spaces/bin/jython"
|
|
||||||
# instead of "/usr/bin/env /dir with spaces/bin/jython"
|
|
||||||
# otherwise whole
|
|
||||||
if executable.startswith('/usr/bin/env '):
|
|
||||||
env, _executable = executable.split(' ', 1)
|
|
||||||
if ' ' in _executable and not _executable.startswith('"'):
|
|
||||||
executable = '%s "%s"' % (env, _executable)
|
|
||||||
else:
|
|
||||||
if not executable.startswith('"'):
|
|
||||||
executable = '"%s"' % executable
|
|
||||||
return executable
|
|
||||||
|
|
||||||
# Keep the old name around (for now), as there is at least one project using it!
|
|
||||||
_enquote_executable = enquote_executable
|
|
||||||
|
|
||||||
class ScriptMaker(object):
|
|
||||||
"""
|
|
||||||
A class to copy or create scripts from source scripts or callable
|
|
||||||
specifications.
|
|
||||||
"""
|
|
||||||
script_template = SCRIPT_TEMPLATE
|
|
||||||
|
|
||||||
executable = None # for shebangs
|
|
||||||
|
|
||||||
def __init__(self, source_dir, target_dir, add_launchers=True,
|
|
||||||
dry_run=False, fileop=None):
|
|
||||||
self.source_dir = source_dir
|
|
||||||
self.target_dir = target_dir
|
|
||||||
self.add_launchers = add_launchers
|
|
||||||
self.force = False
|
|
||||||
self.clobber = False
|
|
||||||
# It only makes sense to set mode bits on POSIX.
|
|
||||||
self.set_mode = (os.name == 'posix') or (os.name == 'java' and
|
|
||||||
os._name == 'posix')
|
|
||||||
self.variants = set(('', 'X.Y'))
|
|
||||||
self._fileop = fileop or FileOperator(dry_run)
|
|
||||||
|
|
||||||
self._is_nt = os.name == 'nt' or (
|
|
||||||
os.name == 'java' and os._name == 'nt')
|
|
||||||
self.version_info = sys.version_info
|
|
||||||
|
|
||||||
def _get_alternate_executable(self, executable, options):
|
|
||||||
if options.get('gui', False) and self._is_nt: # pragma: no cover
|
|
||||||
dn, fn = os.path.split(executable)
|
|
||||||
fn = fn.replace('python', 'pythonw')
|
|
||||||
executable = os.path.join(dn, fn)
|
|
||||||
return executable
|
|
||||||
|
|
||||||
if sys.platform.startswith('java'): # pragma: no cover
|
|
||||||
def _is_shell(self, executable):
|
|
||||||
"""
|
|
||||||
Determine if the specified executable is a script
|
|
||||||
(contains a #! line)
|
|
||||||
"""
|
|
||||||
try:
|
|
||||||
with open(executable) as fp:
|
|
||||||
return fp.read(2) == '#!'
|
|
||||||
except (OSError, IOError):
|
|
||||||
logger.warning('Failed to open %s', executable)
|
|
||||||
return False
|
|
||||||
|
|
||||||
def _fix_jython_executable(self, executable):
|
|
||||||
if self._is_shell(executable):
|
|
||||||
# Workaround for Jython is not needed on Linux systems.
|
|
||||||
import java
|
|
||||||
|
|
||||||
if java.lang.System.getProperty('os.name') == 'Linux':
|
|
||||||
return executable
|
|
||||||
elif executable.lower().endswith('jython.exe'):
|
|
||||||
# Use wrapper exe for Jython on Windows
|
|
||||||
return executable
|
|
||||||
return '/usr/bin/env %s' % executable
|
|
||||||
|
|
||||||
def _build_shebang(self, executable, post_interp):
|
|
||||||
"""
|
|
||||||
Build a shebang line. In the simple case (on Windows, or a shebang line
|
|
||||||
which is not too long or contains spaces) use a simple formulation for
|
|
||||||
the shebang. Otherwise, use /bin/sh as the executable, with a contrived
|
|
||||||
shebang which allows the script to run either under Python or sh, using
|
|
||||||
suitable quoting. Thanks to Harald Nordgren for his input.
|
|
||||||
|
|
||||||
See also: http://www.in-ulm.de/~mascheck/various/shebang/#length
|
|
||||||
https://hg.mozilla.org/mozilla-central/file/tip/mach
|
|
||||||
"""
|
|
||||||
if os.name != 'posix':
|
|
||||||
simple_shebang = True
|
|
||||||
else:
|
|
||||||
# Add 3 for '#!' prefix and newline suffix.
|
|
||||||
shebang_length = len(executable) + len(post_interp) + 3
|
|
||||||
if sys.platform == 'darwin':
|
|
||||||
max_shebang_length = 512
|
|
||||||
else:
|
|
||||||
max_shebang_length = 127
|
|
||||||
simple_shebang = ((b' ' not in executable) and
|
|
||||||
(shebang_length <= max_shebang_length))
|
|
||||||
|
|
||||||
if simple_shebang:
|
|
||||||
result = b'#!' + executable + post_interp + b'\n'
|
|
||||||
else:
|
|
||||||
result = b'#!/bin/sh\n'
|
|
||||||
result += b"'''exec' " + executable + post_interp + b' "$0" "$@"\n'
|
|
||||||
result += b"' '''"
|
|
||||||
return result
|
|
||||||
|
|
||||||
def _get_shebang(self, encoding, post_interp=b'', options=None):
|
|
||||||
enquote = True
|
|
||||||
if self.executable:
|
|
||||||
executable = self.executable
|
|
||||||
enquote = False # assume this will be taken care of
|
|
||||||
elif not sysconfig.is_python_build():
|
|
||||||
executable = get_executable()
|
|
||||||
elif in_venv(): # pragma: no cover
|
|
||||||
executable = os.path.join(sysconfig.get_path('scripts'),
|
|
||||||
'python%s' % sysconfig.get_config_var('EXE'))
|
|
||||||
else: # pragma: no cover
|
|
||||||
executable = os.path.join(
|
|
||||||
sysconfig.get_config_var('BINDIR'),
|
|
||||||
'python%s%s' % (sysconfig.get_config_var('VERSION'),
|
|
||||||
sysconfig.get_config_var('EXE')))
|
|
||||||
if options:
|
|
||||||
executable = self._get_alternate_executable(executable, options)
|
|
||||||
|
|
||||||
if sys.platform.startswith('java'): # pragma: no cover
|
|
||||||
executable = self._fix_jython_executable(executable)
|
|
||||||
|
|
||||||
# Normalise case for Windows - COMMENTED OUT
|
|
||||||
# executable = os.path.normcase(executable)
|
|
||||||
# N.B. The normalising operation above has been commented out: See
|
|
||||||
# issue #124. Although paths in Windows are generally case-insensitive,
|
|
||||||
# they aren't always. For example, a path containing a ẞ (which is a
|
|
||||||
# LATIN CAPITAL LETTER SHARP S - U+1E9E) is normcased to ß (which is a
|
|
||||||
# LATIN SMALL LETTER SHARP S' - U+00DF). The two are not considered by
|
|
||||||
# Windows as equivalent in path names.
|
|
||||||
|
|
||||||
# If the user didn't specify an executable, it may be necessary to
|
|
||||||
# cater for executable paths with spaces (not uncommon on Windows)
|
|
||||||
if enquote:
|
|
||||||
executable = enquote_executable(executable)
|
|
||||||
# Issue #51: don't use fsencode, since we later try to
|
|
||||||
# check that the shebang is decodable using utf-8.
|
|
||||||
executable = executable.encode('utf-8')
|
|
||||||
# in case of IronPython, play safe and enable frames support
|
|
||||||
if (sys.platform == 'cli' and '-X:Frames' not in post_interp
|
|
||||||
and '-X:FullFrames' not in post_interp): # pragma: no cover
|
|
||||||
post_interp += b' -X:Frames'
|
|
||||||
shebang = self._build_shebang(executable, post_interp)
|
|
||||||
# Python parser starts to read a script using UTF-8 until
|
|
||||||
# it gets a #coding:xxx cookie. The shebang has to be the
|
|
||||||
# first line of a file, the #coding:xxx cookie cannot be
|
|
||||||
# written before. So the shebang has to be decodable from
|
|
||||||
# UTF-8.
|
|
||||||
try:
|
|
||||||
shebang.decode('utf-8')
|
|
||||||
except UnicodeDecodeError: # pragma: no cover
|
|
||||||
raise ValueError(
|
|
||||||
'The shebang (%r) is not decodable from utf-8' % shebang)
|
|
||||||
# If the script is encoded to a custom encoding (use a
|
|
||||||
# #coding:xxx cookie), the shebang has to be decodable from
|
|
||||||
# the script encoding too.
|
|
||||||
if encoding != 'utf-8':
|
|
||||||
try:
|
|
||||||
shebang.decode(encoding)
|
|
||||||
except UnicodeDecodeError: # pragma: no cover
|
|
||||||
raise ValueError(
|
|
||||||
'The shebang (%r) is not decodable '
|
|
||||||
'from the script encoding (%r)' % (shebang, encoding))
|
|
||||||
return shebang
|
|
||||||
|
|
||||||
def _get_script_text(self, entry):
|
|
||||||
return self.script_template % dict(module=entry.prefix,
|
|
||||||
import_name=entry.suffix.split('.')[0],
|
|
||||||
func=entry.suffix)
|
|
||||||
|
|
||||||
manifest = _DEFAULT_MANIFEST
|
|
||||||
|
|
||||||
def get_manifest(self, exename):
|
|
||||||
base = os.path.basename(exename)
|
|
||||||
return self.manifest % base
|
|
||||||
|
|
||||||
def _write_script(self, names, shebang, script_bytes, filenames, ext):
|
|
||||||
use_launcher = self.add_launchers and self._is_nt
|
|
||||||
linesep = os.linesep.encode('utf-8')
|
|
||||||
if not shebang.endswith(linesep):
|
|
||||||
shebang += linesep
|
|
||||||
if not use_launcher:
|
|
||||||
script_bytes = shebang + script_bytes
|
|
||||||
else: # pragma: no cover
|
|
||||||
if ext == 'py':
|
|
||||||
launcher = self._get_launcher('t')
|
|
||||||
else:
|
|
||||||
launcher = self._get_launcher('w')
|
|
||||||
stream = BytesIO()
|
|
||||||
with ZipFile(stream, 'w') as zf:
|
|
||||||
zf.writestr('__main__.py', script_bytes)
|
|
||||||
zip_data = stream.getvalue()
|
|
||||||
script_bytes = launcher + shebang + zip_data
|
|
||||||
for name in names:
|
|
||||||
outname = os.path.join(self.target_dir, name)
|
|
||||||
if use_launcher: # pragma: no cover
|
|
||||||
n, e = os.path.splitext(outname)
|
|
||||||
if e.startswith('.py'):
|
|
||||||
outname = n
|
|
||||||
outname = '%s.exe' % outname
|
|
||||||
try:
|
|
||||||
self._fileop.write_binary_file(outname, script_bytes)
|
|
||||||
except Exception:
|
|
||||||
# Failed writing an executable - it might be in use.
|
|
||||||
logger.warning('Failed to write executable - trying to '
|
|
||||||
'use .deleteme logic')
|
|
||||||
dfname = '%s.deleteme' % outname
|
|
||||||
if os.path.exists(dfname):
|
|
||||||
os.remove(dfname) # Not allowed to fail here
|
|
||||||
os.rename(outname, dfname) # nor here
|
|
||||||
self._fileop.write_binary_file(outname, script_bytes)
|
|
||||||
logger.debug('Able to replace executable using '
|
|
||||||
'.deleteme logic')
|
|
||||||
try:
|
|
||||||
os.remove(dfname)
|
|
||||||
except Exception:
|
|
||||||
pass # still in use - ignore error
|
|
||||||
else:
|
|
||||||
if self._is_nt and not outname.endswith('.' + ext): # pragma: no cover
|
|
||||||
outname = '%s.%s' % (outname, ext)
|
|
||||||
if os.path.exists(outname) and not self.clobber:
|
|
||||||
logger.warning('Skipping existing file %s', outname)
|
|
||||||
continue
|
|
||||||
self._fileop.write_binary_file(outname, script_bytes)
|
|
||||||
if self.set_mode:
|
|
||||||
self._fileop.set_executable_mode([outname])
|
|
||||||
filenames.append(outname)
|
|
||||||
|
|
||||||
variant_separator = '-'
|
|
||||||
|
|
||||||
def get_script_filenames(self, name):
|
|
||||||
result = set()
|
|
||||||
if '' in self.variants:
|
|
||||||
result.add(name)
|
|
||||||
if 'X' in self.variants:
|
|
||||||
result.add('%s%s' % (name, self.version_info[0]))
|
|
||||||
if 'X.Y' in self.variants:
|
|
||||||
result.add('%s%s%s.%s' % (name, self.variant_separator,
|
|
||||||
self.version_info[0], self.version_info[1]))
|
|
||||||
return result
|
|
||||||
|
|
||||||
def _make_script(self, entry, filenames, options=None):
|
|
||||||
post_interp = b''
|
|
||||||
if options:
|
|
||||||
args = options.get('interpreter_args', [])
|
|
||||||
if args:
|
|
||||||
args = ' %s' % ' '.join(args)
|
|
||||||
post_interp = args.encode('utf-8')
|
|
||||||
shebang = self._get_shebang('utf-8', post_interp, options=options)
|
|
||||||
script = self._get_script_text(entry).encode('utf-8')
|
|
||||||
scriptnames = self.get_script_filenames(entry.name)
|
|
||||||
if options and options.get('gui', False):
|
|
||||||
ext = 'pyw'
|
|
||||||
else:
|
|
||||||
ext = 'py'
|
|
||||||
self._write_script(scriptnames, shebang, script, filenames, ext)
|
|
||||||
|
|
||||||
def _copy_script(self, script, filenames):
|
|
||||||
adjust = False
|
|
||||||
script = os.path.join(self.source_dir, convert_path(script))
|
|
||||||
outname = os.path.join(self.target_dir, os.path.basename(script))
|
|
||||||
if not self.force and not self._fileop.newer(script, outname):
|
|
||||||
logger.debug('not copying %s (up-to-date)', script)
|
|
||||||
return
|
|
||||||
|
|
||||||
# Always open the file, but ignore failures in dry-run mode --
|
|
||||||
# that way, we'll get accurate feedback if we can read the
|
|
||||||
# script.
|
|
||||||
try:
|
|
||||||
f = open(script, 'rb')
|
|
||||||
except IOError: # pragma: no cover
|
|
||||||
if not self.dry_run:
|
|
||||||
raise
|
|
||||||
f = None
|
|
||||||
else:
|
|
||||||
first_line = f.readline()
|
|
||||||
if not first_line: # pragma: no cover
|
|
||||||
logger.warning('%s is an empty file (skipping)', script)
|
|
||||||
return
|
|
||||||
|
|
||||||
match = FIRST_LINE_RE.match(first_line.replace(b'\r\n', b'\n'))
|
|
||||||
if match:
|
|
||||||
adjust = True
|
|
||||||
post_interp = match.group(1) or b''
|
|
||||||
|
|
||||||
if not adjust:
|
|
||||||
if f:
|
|
||||||
f.close()
|
|
||||||
self._fileop.copy_file(script, outname)
|
|
||||||
if self.set_mode:
|
|
||||||
self._fileop.set_executable_mode([outname])
|
|
||||||
filenames.append(outname)
|
|
||||||
else:
|
|
||||||
logger.info('copying and adjusting %s -> %s', script,
|
|
||||||
self.target_dir)
|
|
||||||
if not self._fileop.dry_run:
|
|
||||||
encoding, lines = detect_encoding(f.readline)
|
|
||||||
f.seek(0)
|
|
||||||
shebang = self._get_shebang(encoding, post_interp)
|
|
||||||
if b'pythonw' in first_line: # pragma: no cover
|
|
||||||
ext = 'pyw'
|
|
||||||
else:
|
|
||||||
ext = 'py'
|
|
||||||
n = os.path.basename(outname)
|
|
||||||
self._write_script([n], shebang, f.read(), filenames, ext)
|
|
||||||
if f:
|
|
||||||
f.close()
|
|
||||||
|
|
||||||
@property
|
|
||||||
def dry_run(self):
|
|
||||||
return self._fileop.dry_run
|
|
||||||
|
|
||||||
@dry_run.setter
|
|
||||||
def dry_run(self, value):
|
|
||||||
self._fileop.dry_run = value
|
|
||||||
|
|
||||||
if os.name == 'nt' or (os.name == 'java' and os._name == 'nt'): # pragma: no cover
|
|
||||||
# Executable launcher support.
|
|
||||||
# Launchers are from https://bitbucket.org/vinay.sajip/simple_launcher/
|
|
||||||
|
|
||||||
def _get_launcher(self, kind):
|
|
||||||
if struct.calcsize('P') == 8: # 64-bit
|
|
||||||
bits = '64'
|
|
||||||
else:
|
|
||||||
bits = '32'
|
|
||||||
name = '%s%s.exe' % (kind, bits)
|
|
||||||
# Issue 31: don't hardcode an absolute package name, but
|
|
||||||
# determine it relative to the current package
|
|
||||||
distlib_package = __name__.rsplit('.', 1)[0]
|
|
||||||
resource = finder(distlib_package).find(name)
|
|
||||||
if not resource:
|
|
||||||
msg = ('Unable to find resource %s in package %s' % (name,
|
|
||||||
distlib_package))
|
|
||||||
raise ValueError(msg)
|
|
||||||
return resource.bytes
|
|
||||||
|
|
||||||
# Public API follows
|
|
||||||
|
|
||||||
def make(self, specification, options=None):
|
|
||||||
"""
|
|
||||||
Make a script.
|
|
||||||
|
|
||||||
:param specification: The specification, which is either a valid export
|
|
||||||
entry specification (to make a script from a
|
|
||||||
callable) or a filename (to make a script by
|
|
||||||
copying from a source location).
|
|
||||||
:param options: A dictionary of options controlling script generation.
|
|
||||||
:return: A list of all absolute pathnames written to.
|
|
||||||
"""
|
|
||||||
filenames = []
|
|
||||||
entry = get_export_entry(specification)
|
|
||||||
if entry is None:
|
|
||||||
self._copy_script(specification, filenames)
|
|
||||||
else:
|
|
||||||
self._make_script(entry, filenames, options=options)
|
|
||||||
return filenames
|
|
||||||
|
|
||||||
def make_multiple(self, specifications, options=None):
|
|
||||||
"""
|
|
||||||
Take a list of specifications and make scripts from them,
|
|
||||||
:param specifications: A list of specifications.
|
|
||||||
:return: A list of all absolute pathnames written to,
|
|
||||||
"""
|
|
||||||
filenames = []
|
|
||||||
for specification in specifications:
|
|
||||||
filenames.extend(self.make(specification, options))
|
|
||||||
return filenames
|
|
||||||
Двоичные данные
third_party/python/virtualenv/__virtualenv__/distlib-0.3.2-py2.py3-none-any/distlib/t32.exe
поставляемый
Двоичные данные
third_party/python/virtualenv/__virtualenv__/distlib-0.3.2-py2.py3-none-any/distlib/t32.exe
поставляемый
Двоичный файл не отображается.
Двоичные данные
third_party/python/virtualenv/__virtualenv__/distlib-0.3.2-py2.py3-none-any/distlib/t64.exe
поставляемый
Двоичные данные
third_party/python/virtualenv/__virtualenv__/distlib-0.3.2-py2.py3-none-any/distlib/t64.exe
поставляемый
Двоичный файл не отображается.
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -1,739 +0,0 @@
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
#
|
|
||||||
# Copyright (C) 2012-2017 The Python Software Foundation.
|
|
||||||
# See LICENSE.txt and CONTRIBUTORS.txt.
|
|
||||||
#
|
|
||||||
"""
|
|
||||||
Implementation of a flexible versioning scheme providing support for PEP-440,
|
|
||||||
setuptools-compatible and semantic versioning.
|
|
||||||
"""
|
|
||||||
|
|
||||||
import logging
|
|
||||||
import re
|
|
||||||
|
|
||||||
from .compat import string_types
|
|
||||||
from .util import parse_requirement
|
|
||||||
|
|
||||||
__all__ = ['NormalizedVersion', 'NormalizedMatcher',
|
|
||||||
'LegacyVersion', 'LegacyMatcher',
|
|
||||||
'SemanticVersion', 'SemanticMatcher',
|
|
||||||
'UnsupportedVersionError', 'get_scheme']
|
|
||||||
|
|
||||||
logger = logging.getLogger(__name__)
|
|
||||||
|
|
||||||
|
|
||||||
class UnsupportedVersionError(ValueError):
|
|
||||||
"""This is an unsupported version."""
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class Version(object):
|
|
||||||
def __init__(self, s):
|
|
||||||
self._string = s = s.strip()
|
|
||||||
self._parts = parts = self.parse(s)
|
|
||||||
assert isinstance(parts, tuple)
|
|
||||||
assert len(parts) > 0
|
|
||||||
|
|
||||||
def parse(self, s):
|
|
||||||
raise NotImplementedError('please implement in a subclass')
|
|
||||||
|
|
||||||
def _check_compatible(self, other):
|
|
||||||
if type(self) != type(other):
|
|
||||||
raise TypeError('cannot compare %r and %r' % (self, other))
|
|
||||||
|
|
||||||
def __eq__(self, other):
|
|
||||||
self._check_compatible(other)
|
|
||||||
return self._parts == other._parts
|
|
||||||
|
|
||||||
def __ne__(self, other):
|
|
||||||
return not self.__eq__(other)
|
|
||||||
|
|
||||||
def __lt__(self, other):
|
|
||||||
self._check_compatible(other)
|
|
||||||
return self._parts < other._parts
|
|
||||||
|
|
||||||
def __gt__(self, other):
|
|
||||||
return not (self.__lt__(other) or self.__eq__(other))
|
|
||||||
|
|
||||||
def __le__(self, other):
|
|
||||||
return self.__lt__(other) or self.__eq__(other)
|
|
||||||
|
|
||||||
def __ge__(self, other):
|
|
||||||
return self.__gt__(other) or self.__eq__(other)
|
|
||||||
|
|
||||||
# See http://docs.python.org/reference/datamodel#object.__hash__
|
|
||||||
def __hash__(self):
|
|
||||||
return hash(self._parts)
|
|
||||||
|
|
||||||
def __repr__(self):
|
|
||||||
return "%s('%s')" % (self.__class__.__name__, self._string)
|
|
||||||
|
|
||||||
def __str__(self):
|
|
||||||
return self._string
|
|
||||||
|
|
||||||
@property
|
|
||||||
def is_prerelease(self):
|
|
||||||
raise NotImplementedError('Please implement in subclasses.')
|
|
||||||
|
|
||||||
|
|
||||||
class Matcher(object):
|
|
||||||
version_class = None
|
|
||||||
|
|
||||||
# value is either a callable or the name of a method
|
|
||||||
_operators = {
|
|
||||||
'<': lambda v, c, p: v < c,
|
|
||||||
'>': lambda v, c, p: v > c,
|
|
||||||
'<=': lambda v, c, p: v == c or v < c,
|
|
||||||
'>=': lambda v, c, p: v == c or v > c,
|
|
||||||
'==': lambda v, c, p: v == c,
|
|
||||||
'===': lambda v, c, p: v == c,
|
|
||||||
# by default, compatible => >=.
|
|
||||||
'~=': lambda v, c, p: v == c or v > c,
|
|
||||||
'!=': lambda v, c, p: v != c,
|
|
||||||
}
|
|
||||||
|
|
||||||
# this is a method only to support alternative implementations
|
|
||||||
# via overriding
|
|
||||||
def parse_requirement(self, s):
|
|
||||||
return parse_requirement(s)
|
|
||||||
|
|
||||||
def __init__(self, s):
|
|
||||||
if self.version_class is None:
|
|
||||||
raise ValueError('Please specify a version class')
|
|
||||||
self._string = s = s.strip()
|
|
||||||
r = self.parse_requirement(s)
|
|
||||||
if not r:
|
|
||||||
raise ValueError('Not valid: %r' % s)
|
|
||||||
self.name = r.name
|
|
||||||
self.key = self.name.lower() # for case-insensitive comparisons
|
|
||||||
clist = []
|
|
||||||
if r.constraints:
|
|
||||||
# import pdb; pdb.set_trace()
|
|
||||||
for op, s in r.constraints:
|
|
||||||
if s.endswith('.*'):
|
|
||||||
if op not in ('==', '!='):
|
|
||||||
raise ValueError('\'.*\' not allowed for '
|
|
||||||
'%r constraints' % op)
|
|
||||||
# Could be a partial version (e.g. for '2.*') which
|
|
||||||
# won't parse as a version, so keep it as a string
|
|
||||||
vn, prefix = s[:-2], True
|
|
||||||
# Just to check that vn is a valid version
|
|
||||||
self.version_class(vn)
|
|
||||||
else:
|
|
||||||
# Should parse as a version, so we can create an
|
|
||||||
# instance for the comparison
|
|
||||||
vn, prefix = self.version_class(s), False
|
|
||||||
clist.append((op, vn, prefix))
|
|
||||||
self._parts = tuple(clist)
|
|
||||||
|
|
||||||
def match(self, version):
|
|
||||||
"""
|
|
||||||
Check if the provided version matches the constraints.
|
|
||||||
|
|
||||||
:param version: The version to match against this instance.
|
|
||||||
:type version: String or :class:`Version` instance.
|
|
||||||
"""
|
|
||||||
if isinstance(version, string_types):
|
|
||||||
version = self.version_class(version)
|
|
||||||
for operator, constraint, prefix in self._parts:
|
|
||||||
f = self._operators.get(operator)
|
|
||||||
if isinstance(f, string_types):
|
|
||||||
f = getattr(self, f)
|
|
||||||
if not f:
|
|
||||||
msg = ('%r not implemented '
|
|
||||||
'for %s' % (operator, self.__class__.__name__))
|
|
||||||
raise NotImplementedError(msg)
|
|
||||||
if not f(version, constraint, prefix):
|
|
||||||
return False
|
|
||||||
return True
|
|
||||||
|
|
||||||
@property
|
|
||||||
def exact_version(self):
|
|
||||||
result = None
|
|
||||||
if len(self._parts) == 1 and self._parts[0][0] in ('==', '==='):
|
|
||||||
result = self._parts[0][1]
|
|
||||||
return result
|
|
||||||
|
|
||||||
def _check_compatible(self, other):
|
|
||||||
if type(self) != type(other) or self.name != other.name:
|
|
||||||
raise TypeError('cannot compare %s and %s' % (self, other))
|
|
||||||
|
|
||||||
def __eq__(self, other):
|
|
||||||
self._check_compatible(other)
|
|
||||||
return self.key == other.key and self._parts == other._parts
|
|
||||||
|
|
||||||
def __ne__(self, other):
|
|
||||||
return not self.__eq__(other)
|
|
||||||
|
|
||||||
# See http://docs.python.org/reference/datamodel#object.__hash__
|
|
||||||
def __hash__(self):
|
|
||||||
return hash(self.key) + hash(self._parts)
|
|
||||||
|
|
||||||
def __repr__(self):
|
|
||||||
return "%s(%r)" % (self.__class__.__name__, self._string)
|
|
||||||
|
|
||||||
def __str__(self):
|
|
||||||
return self._string
|
|
||||||
|
|
||||||
|
|
||||||
PEP440_VERSION_RE = re.compile(r'^v?(\d+!)?(\d+(\.\d+)*)((a|b|c|rc)(\d+))?'
|
|
||||||
r'(\.(post)(\d+))?(\.(dev)(\d+))?'
|
|
||||||
r'(\+([a-zA-Z\d]+(\.[a-zA-Z\d]+)?))?$')
|
|
||||||
|
|
||||||
|
|
||||||
def _pep_440_key(s):
|
|
||||||
s = s.strip()
|
|
||||||
m = PEP440_VERSION_RE.match(s)
|
|
||||||
if not m:
|
|
||||||
raise UnsupportedVersionError('Not a valid version: %s' % s)
|
|
||||||
groups = m.groups()
|
|
||||||
nums = tuple(int(v) for v in groups[1].split('.'))
|
|
||||||
while len(nums) > 1 and nums[-1] == 0:
|
|
||||||
nums = nums[:-1]
|
|
||||||
|
|
||||||
if not groups[0]:
|
|
||||||
epoch = 0
|
|
||||||
else:
|
|
||||||
epoch = int(groups[0])
|
|
||||||
pre = groups[4:6]
|
|
||||||
post = groups[7:9]
|
|
||||||
dev = groups[10:12]
|
|
||||||
local = groups[13]
|
|
||||||
if pre == (None, None):
|
|
||||||
pre = ()
|
|
||||||
else:
|
|
||||||
pre = pre[0], int(pre[1])
|
|
||||||
if post == (None, None):
|
|
||||||
post = ()
|
|
||||||
else:
|
|
||||||
post = post[0], int(post[1])
|
|
||||||
if dev == (None, None):
|
|
||||||
dev = ()
|
|
||||||
else:
|
|
||||||
dev = dev[0], int(dev[1])
|
|
||||||
if local is None:
|
|
||||||
local = ()
|
|
||||||
else:
|
|
||||||
parts = []
|
|
||||||
for part in local.split('.'):
|
|
||||||
# to ensure that numeric compares as > lexicographic, avoid
|
|
||||||
# comparing them directly, but encode a tuple which ensures
|
|
||||||
# correct sorting
|
|
||||||
if part.isdigit():
|
|
||||||
part = (1, int(part))
|
|
||||||
else:
|
|
||||||
part = (0, part)
|
|
||||||
parts.append(part)
|
|
||||||
local = tuple(parts)
|
|
||||||
if not pre:
|
|
||||||
# either before pre-release, or final release and after
|
|
||||||
if not post and dev:
|
|
||||||
# before pre-release
|
|
||||||
pre = ('a', -1) # to sort before a0
|
|
||||||
else:
|
|
||||||
pre = ('z',) # to sort after all pre-releases
|
|
||||||
# now look at the state of post and dev.
|
|
||||||
if not post:
|
|
||||||
post = ('_',) # sort before 'a'
|
|
||||||
if not dev:
|
|
||||||
dev = ('final',)
|
|
||||||
|
|
||||||
#print('%s -> %s' % (s, m.groups()))
|
|
||||||
return epoch, nums, pre, post, dev, local
|
|
||||||
|
|
||||||
|
|
||||||
_normalized_key = _pep_440_key
|
|
||||||
|
|
||||||
|
|
||||||
class NormalizedVersion(Version):
|
|
||||||
"""A rational version.
|
|
||||||
|
|
||||||
Good:
|
|
||||||
1.2 # equivalent to "1.2.0"
|
|
||||||
1.2.0
|
|
||||||
1.2a1
|
|
||||||
1.2.3a2
|
|
||||||
1.2.3b1
|
|
||||||
1.2.3c1
|
|
||||||
1.2.3.4
|
|
||||||
TODO: fill this out
|
|
||||||
|
|
||||||
Bad:
|
|
||||||
1 # minimum two numbers
|
|
||||||
1.2a # release level must have a release serial
|
|
||||||
1.2.3b
|
|
||||||
"""
|
|
||||||
def parse(self, s):
|
|
||||||
result = _normalized_key(s)
|
|
||||||
# _normalized_key loses trailing zeroes in the release
|
|
||||||
# clause, since that's needed to ensure that X.Y == X.Y.0 == X.Y.0.0
|
|
||||||
# However, PEP 440 prefix matching needs it: for example,
|
|
||||||
# (~= 1.4.5.0) matches differently to (~= 1.4.5.0.0).
|
|
||||||
m = PEP440_VERSION_RE.match(s) # must succeed
|
|
||||||
groups = m.groups()
|
|
||||||
self._release_clause = tuple(int(v) for v in groups[1].split('.'))
|
|
||||||
return result
|
|
||||||
|
|
||||||
PREREL_TAGS = set(['a', 'b', 'c', 'rc', 'dev'])
|
|
||||||
|
|
||||||
@property
|
|
||||||
def is_prerelease(self):
|
|
||||||
return any(t[0] in self.PREREL_TAGS for t in self._parts if t)
|
|
||||||
|
|
||||||
|
|
||||||
def _match_prefix(x, y):
|
|
||||||
x = str(x)
|
|
||||||
y = str(y)
|
|
||||||
if x == y:
|
|
||||||
return True
|
|
||||||
if not x.startswith(y):
|
|
||||||
return False
|
|
||||||
n = len(y)
|
|
||||||
return x[n] == '.'
|
|
||||||
|
|
||||||
|
|
||||||
class NormalizedMatcher(Matcher):
|
|
||||||
version_class = NormalizedVersion
|
|
||||||
|
|
||||||
# value is either a callable or the name of a method
|
|
||||||
_operators = {
|
|
||||||
'~=': '_match_compatible',
|
|
||||||
'<': '_match_lt',
|
|
||||||
'>': '_match_gt',
|
|
||||||
'<=': '_match_le',
|
|
||||||
'>=': '_match_ge',
|
|
||||||
'==': '_match_eq',
|
|
||||||
'===': '_match_arbitrary',
|
|
||||||
'!=': '_match_ne',
|
|
||||||
}
|
|
||||||
|
|
||||||
def _adjust_local(self, version, constraint, prefix):
|
|
||||||
if prefix:
|
|
||||||
strip_local = '+' not in constraint and version._parts[-1]
|
|
||||||
else:
|
|
||||||
# both constraint and version are
|
|
||||||
# NormalizedVersion instances.
|
|
||||||
# If constraint does not have a local component,
|
|
||||||
# ensure the version doesn't, either.
|
|
||||||
strip_local = not constraint._parts[-1] and version._parts[-1]
|
|
||||||
if strip_local:
|
|
||||||
s = version._string.split('+', 1)[0]
|
|
||||||
version = self.version_class(s)
|
|
||||||
return version, constraint
|
|
||||||
|
|
||||||
def _match_lt(self, version, constraint, prefix):
|
|
||||||
version, constraint = self._adjust_local(version, constraint, prefix)
|
|
||||||
if version >= constraint:
|
|
||||||
return False
|
|
||||||
release_clause = constraint._release_clause
|
|
||||||
pfx = '.'.join([str(i) for i in release_clause])
|
|
||||||
return not _match_prefix(version, pfx)
|
|
||||||
|
|
||||||
def _match_gt(self, version, constraint, prefix):
|
|
||||||
version, constraint = self._adjust_local(version, constraint, prefix)
|
|
||||||
if version <= constraint:
|
|
||||||
return False
|
|
||||||
release_clause = constraint._release_clause
|
|
||||||
pfx = '.'.join([str(i) for i in release_clause])
|
|
||||||
return not _match_prefix(version, pfx)
|
|
||||||
|
|
||||||
def _match_le(self, version, constraint, prefix):
|
|
||||||
version, constraint = self._adjust_local(version, constraint, prefix)
|
|
||||||
return version <= constraint
|
|
||||||
|
|
||||||
def _match_ge(self, version, constraint, prefix):
|
|
||||||
version, constraint = self._adjust_local(version, constraint, prefix)
|
|
||||||
return version >= constraint
|
|
||||||
|
|
||||||
def _match_eq(self, version, constraint, prefix):
|
|
||||||
version, constraint = self._adjust_local(version, constraint, prefix)
|
|
||||||
if not prefix:
|
|
||||||
result = (version == constraint)
|
|
||||||
else:
|
|
||||||
result = _match_prefix(version, constraint)
|
|
||||||
return result
|
|
||||||
|
|
||||||
def _match_arbitrary(self, version, constraint, prefix):
|
|
||||||
return str(version) == str(constraint)
|
|
||||||
|
|
||||||
def _match_ne(self, version, constraint, prefix):
|
|
||||||
version, constraint = self._adjust_local(version, constraint, prefix)
|
|
||||||
if not prefix:
|
|
||||||
result = (version != constraint)
|
|
||||||
else:
|
|
||||||
result = not _match_prefix(version, constraint)
|
|
||||||
return result
|
|
||||||
|
|
||||||
def _match_compatible(self, version, constraint, prefix):
|
|
||||||
version, constraint = self._adjust_local(version, constraint, prefix)
|
|
||||||
if version == constraint:
|
|
||||||
return True
|
|
||||||
if version < constraint:
|
|
||||||
return False
|
|
||||||
# if not prefix:
|
|
||||||
# return True
|
|
||||||
release_clause = constraint._release_clause
|
|
||||||
if len(release_clause) > 1:
|
|
||||||
release_clause = release_clause[:-1]
|
|
||||||
pfx = '.'.join([str(i) for i in release_clause])
|
|
||||||
return _match_prefix(version, pfx)
|
|
||||||
|
|
||||||
_REPLACEMENTS = (
|
|
||||||
(re.compile('[.+-]$'), ''), # remove trailing puncts
|
|
||||||
(re.compile(r'^[.](\d)'), r'0.\1'), # .N -> 0.N at start
|
|
||||||
(re.compile('^[.-]'), ''), # remove leading puncts
|
|
||||||
(re.compile(r'^\((.*)\)$'), r'\1'), # remove parentheses
|
|
||||||
(re.compile(r'^v(ersion)?\s*(\d+)'), r'\2'), # remove leading v(ersion)
|
|
||||||
(re.compile(r'^r(ev)?\s*(\d+)'), r'\2'), # remove leading v(ersion)
|
|
||||||
(re.compile('[.]{2,}'), '.'), # multiple runs of '.'
|
|
||||||
(re.compile(r'\b(alfa|apha)\b'), 'alpha'), # misspelt alpha
|
|
||||||
(re.compile(r'\b(pre-alpha|prealpha)\b'),
|
|
||||||
'pre.alpha'), # standardise
|
|
||||||
(re.compile(r'\(beta\)$'), 'beta'), # remove parentheses
|
|
||||||
)
|
|
||||||
|
|
||||||
_SUFFIX_REPLACEMENTS = (
|
|
||||||
(re.compile('^[:~._+-]+'), ''), # remove leading puncts
|
|
||||||
(re.compile('[,*")([\\]]'), ''), # remove unwanted chars
|
|
||||||
(re.compile('[~:+_ -]'), '.'), # replace illegal chars
|
|
||||||
(re.compile('[.]{2,}'), '.'), # multiple runs of '.'
|
|
||||||
(re.compile(r'\.$'), ''), # trailing '.'
|
|
||||||
)
|
|
||||||
|
|
||||||
_NUMERIC_PREFIX = re.compile(r'(\d+(\.\d+)*)')
|
|
||||||
|
|
||||||
|
|
||||||
def _suggest_semantic_version(s):
|
|
||||||
"""
|
|
||||||
Try to suggest a semantic form for a version for which
|
|
||||||
_suggest_normalized_version couldn't come up with anything.
|
|
||||||
"""
|
|
||||||
result = s.strip().lower()
|
|
||||||
for pat, repl in _REPLACEMENTS:
|
|
||||||
result = pat.sub(repl, result)
|
|
||||||
if not result:
|
|
||||||
result = '0.0.0'
|
|
||||||
|
|
||||||
# Now look for numeric prefix, and separate it out from
|
|
||||||
# the rest.
|
|
||||||
#import pdb; pdb.set_trace()
|
|
||||||
m = _NUMERIC_PREFIX.match(result)
|
|
||||||
if not m:
|
|
||||||
prefix = '0.0.0'
|
|
||||||
suffix = result
|
|
||||||
else:
|
|
||||||
prefix = m.groups()[0].split('.')
|
|
||||||
prefix = [int(i) for i in prefix]
|
|
||||||
while len(prefix) < 3:
|
|
||||||
prefix.append(0)
|
|
||||||
if len(prefix) == 3:
|
|
||||||
suffix = result[m.end():]
|
|
||||||
else:
|
|
||||||
suffix = '.'.join([str(i) for i in prefix[3:]]) + result[m.end():]
|
|
||||||
prefix = prefix[:3]
|
|
||||||
prefix = '.'.join([str(i) for i in prefix])
|
|
||||||
suffix = suffix.strip()
|
|
||||||
if suffix:
|
|
||||||
#import pdb; pdb.set_trace()
|
|
||||||
# massage the suffix.
|
|
||||||
for pat, repl in _SUFFIX_REPLACEMENTS:
|
|
||||||
suffix = pat.sub(repl, suffix)
|
|
||||||
|
|
||||||
if not suffix:
|
|
||||||
result = prefix
|
|
||||||
else:
|
|
||||||
sep = '-' if 'dev' in suffix else '+'
|
|
||||||
result = prefix + sep + suffix
|
|
||||||
if not is_semver(result):
|
|
||||||
result = None
|
|
||||||
return result
|
|
||||||
|
|
||||||
|
|
||||||
def _suggest_normalized_version(s):
|
|
||||||
"""Suggest a normalized version close to the given version string.
|
|
||||||
|
|
||||||
If you have a version string that isn't rational (i.e. NormalizedVersion
|
|
||||||
doesn't like it) then you might be able to get an equivalent (or close)
|
|
||||||
rational version from this function.
|
|
||||||
|
|
||||||
This does a number of simple normalizations to the given string, based
|
|
||||||
on observation of versions currently in use on PyPI. Given a dump of
|
|
||||||
those version during PyCon 2009, 4287 of them:
|
|
||||||
- 2312 (53.93%) match NormalizedVersion without change
|
|
||||||
with the automatic suggestion
|
|
||||||
- 3474 (81.04%) match when using this suggestion method
|
|
||||||
|
|
||||||
@param s {str} An irrational version string.
|
|
||||||
@returns A rational version string, or None, if couldn't determine one.
|
|
||||||
"""
|
|
||||||
try:
|
|
||||||
_normalized_key(s)
|
|
||||||
return s # already rational
|
|
||||||
except UnsupportedVersionError:
|
|
||||||
pass
|
|
||||||
|
|
||||||
rs = s.lower()
|
|
||||||
|
|
||||||
# part of this could use maketrans
|
|
||||||
for orig, repl in (('-alpha', 'a'), ('-beta', 'b'), ('alpha', 'a'),
|
|
||||||
('beta', 'b'), ('rc', 'c'), ('-final', ''),
|
|
||||||
('-pre', 'c'),
|
|
||||||
('-release', ''), ('.release', ''), ('-stable', ''),
|
|
||||||
('+', '.'), ('_', '.'), (' ', ''), ('.final', ''),
|
|
||||||
('final', '')):
|
|
||||||
rs = rs.replace(orig, repl)
|
|
||||||
|
|
||||||
# if something ends with dev or pre, we add a 0
|
|
||||||
rs = re.sub(r"pre$", r"pre0", rs)
|
|
||||||
rs = re.sub(r"dev$", r"dev0", rs)
|
|
||||||
|
|
||||||
# if we have something like "b-2" or "a.2" at the end of the
|
|
||||||
# version, that is probably beta, alpha, etc
|
|
||||||
# let's remove the dash or dot
|
|
||||||
rs = re.sub(r"([abc]|rc)[\-\.](\d+)$", r"\1\2", rs)
|
|
||||||
|
|
||||||
# 1.0-dev-r371 -> 1.0.dev371
|
|
||||||
# 0.1-dev-r79 -> 0.1.dev79
|
|
||||||
rs = re.sub(r"[\-\.](dev)[\-\.]?r?(\d+)$", r".\1\2", rs)
|
|
||||||
|
|
||||||
# Clean: 2.0.a.3, 2.0.b1, 0.9.0~c1
|
|
||||||
rs = re.sub(r"[.~]?([abc])\.?", r"\1", rs)
|
|
||||||
|
|
||||||
# Clean: v0.3, v1.0
|
|
||||||
if rs.startswith('v'):
|
|
||||||
rs = rs[1:]
|
|
||||||
|
|
||||||
# Clean leading '0's on numbers.
|
|
||||||
#TODO: unintended side-effect on, e.g., "2003.05.09"
|
|
||||||
# PyPI stats: 77 (~2%) better
|
|
||||||
rs = re.sub(r"\b0+(\d+)(?!\d)", r"\1", rs)
|
|
||||||
|
|
||||||
# Clean a/b/c with no version. E.g. "1.0a" -> "1.0a0". Setuptools infers
|
|
||||||
# zero.
|
|
||||||
# PyPI stats: 245 (7.56%) better
|
|
||||||
rs = re.sub(r"(\d+[abc])$", r"\g<1>0", rs)
|
|
||||||
|
|
||||||
# the 'dev-rNNN' tag is a dev tag
|
|
||||||
rs = re.sub(r"\.?(dev-r|dev\.r)\.?(\d+)$", r".dev\2", rs)
|
|
||||||
|
|
||||||
# clean the - when used as a pre delimiter
|
|
||||||
rs = re.sub(r"-(a|b|c)(\d+)$", r"\1\2", rs)
|
|
||||||
|
|
||||||
# a terminal "dev" or "devel" can be changed into ".dev0"
|
|
||||||
rs = re.sub(r"[\.\-](dev|devel)$", r".dev0", rs)
|
|
||||||
|
|
||||||
# a terminal "dev" can be changed into ".dev0"
|
|
||||||
rs = re.sub(r"(?![\.\-])dev$", r".dev0", rs)
|
|
||||||
|
|
||||||
# a terminal "final" or "stable" can be removed
|
|
||||||
rs = re.sub(r"(final|stable)$", "", rs)
|
|
||||||
|
|
||||||
# The 'r' and the '-' tags are post release tags
|
|
||||||
# 0.4a1.r10 -> 0.4a1.post10
|
|
||||||
# 0.9.33-17222 -> 0.9.33.post17222
|
|
||||||
# 0.9.33-r17222 -> 0.9.33.post17222
|
|
||||||
rs = re.sub(r"\.?(r|-|-r)\.?(\d+)$", r".post\2", rs)
|
|
||||||
|
|
||||||
# Clean 'r' instead of 'dev' usage:
|
|
||||||
# 0.9.33+r17222 -> 0.9.33.dev17222
|
|
||||||
# 1.0dev123 -> 1.0.dev123
|
|
||||||
# 1.0.git123 -> 1.0.dev123
|
|
||||||
# 1.0.bzr123 -> 1.0.dev123
|
|
||||||
# 0.1a0dev.123 -> 0.1a0.dev123
|
|
||||||
# PyPI stats: ~150 (~4%) better
|
|
||||||
rs = re.sub(r"\.?(dev|git|bzr)\.?(\d+)$", r".dev\2", rs)
|
|
||||||
|
|
||||||
# Clean '.pre' (normalized from '-pre' above) instead of 'c' usage:
|
|
||||||
# 0.2.pre1 -> 0.2c1
|
|
||||||
# 0.2-c1 -> 0.2c1
|
|
||||||
# 1.0preview123 -> 1.0c123
|
|
||||||
# PyPI stats: ~21 (0.62%) better
|
|
||||||
rs = re.sub(r"\.?(pre|preview|-c)(\d+)$", r"c\g<2>", rs)
|
|
||||||
|
|
||||||
# Tcl/Tk uses "px" for their post release markers
|
|
||||||
rs = re.sub(r"p(\d+)$", r".post\1", rs)
|
|
||||||
|
|
||||||
try:
|
|
||||||
_normalized_key(rs)
|
|
||||||
except UnsupportedVersionError:
|
|
||||||
rs = None
|
|
||||||
return rs
|
|
||||||
|
|
||||||
#
|
|
||||||
# Legacy version processing (distribute-compatible)
|
|
||||||
#
|
|
||||||
|
|
||||||
_VERSION_PART = re.compile(r'([a-z]+|\d+|[\.-])', re.I)
|
|
||||||
_VERSION_REPLACE = {
|
|
||||||
'pre': 'c',
|
|
||||||
'preview': 'c',
|
|
||||||
'-': 'final-',
|
|
||||||
'rc': 'c',
|
|
||||||
'dev': '@',
|
|
||||||
'': None,
|
|
||||||
'.': None,
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
def _legacy_key(s):
|
|
||||||
def get_parts(s):
|
|
||||||
result = []
|
|
||||||
for p in _VERSION_PART.split(s.lower()):
|
|
||||||
p = _VERSION_REPLACE.get(p, p)
|
|
||||||
if p:
|
|
||||||
if '0' <= p[:1] <= '9':
|
|
||||||
p = p.zfill(8)
|
|
||||||
else:
|
|
||||||
p = '*' + p
|
|
||||||
result.append(p)
|
|
||||||
result.append('*final')
|
|
||||||
return result
|
|
||||||
|
|
||||||
result = []
|
|
||||||
for p in get_parts(s):
|
|
||||||
if p.startswith('*'):
|
|
||||||
if p < '*final':
|
|
||||||
while result and result[-1] == '*final-':
|
|
||||||
result.pop()
|
|
||||||
while result and result[-1] == '00000000':
|
|
||||||
result.pop()
|
|
||||||
result.append(p)
|
|
||||||
return tuple(result)
|
|
||||||
|
|
||||||
|
|
||||||
class LegacyVersion(Version):
|
|
||||||
def parse(self, s):
|
|
||||||
return _legacy_key(s)
|
|
||||||
|
|
||||||
@property
|
|
||||||
def is_prerelease(self):
|
|
||||||
result = False
|
|
||||||
for x in self._parts:
|
|
||||||
if (isinstance(x, string_types) and x.startswith('*') and
|
|
||||||
x < '*final'):
|
|
||||||
result = True
|
|
||||||
break
|
|
||||||
return result
|
|
||||||
|
|
||||||
|
|
||||||
class LegacyMatcher(Matcher):
|
|
||||||
version_class = LegacyVersion
|
|
||||||
|
|
||||||
_operators = dict(Matcher._operators)
|
|
||||||
_operators['~='] = '_match_compatible'
|
|
||||||
|
|
||||||
numeric_re = re.compile(r'^(\d+(\.\d+)*)')
|
|
||||||
|
|
||||||
def _match_compatible(self, version, constraint, prefix):
|
|
||||||
if version < constraint:
|
|
||||||
return False
|
|
||||||
m = self.numeric_re.match(str(constraint))
|
|
||||||
if not m:
|
|
||||||
logger.warning('Cannot compute compatible match for version %s '
|
|
||||||
' and constraint %s', version, constraint)
|
|
||||||
return True
|
|
||||||
s = m.groups()[0]
|
|
||||||
if '.' in s:
|
|
||||||
s = s.rsplit('.', 1)[0]
|
|
||||||
return _match_prefix(version, s)
|
|
||||||
|
|
||||||
#
|
|
||||||
# Semantic versioning
|
|
||||||
#
|
|
||||||
|
|
||||||
_SEMVER_RE = re.compile(r'^(\d+)\.(\d+)\.(\d+)'
|
|
||||||
r'(-[a-z0-9]+(\.[a-z0-9-]+)*)?'
|
|
||||||
r'(\+[a-z0-9]+(\.[a-z0-9-]+)*)?$', re.I)
|
|
||||||
|
|
||||||
|
|
||||||
def is_semver(s):
|
|
||||||
return _SEMVER_RE.match(s)
|
|
||||||
|
|
||||||
|
|
||||||
def _semantic_key(s):
|
|
||||||
def make_tuple(s, absent):
|
|
||||||
if s is None:
|
|
||||||
result = (absent,)
|
|
||||||
else:
|
|
||||||
parts = s[1:].split('.')
|
|
||||||
# We can't compare ints and strings on Python 3, so fudge it
|
|
||||||
# by zero-filling numeric values so simulate a numeric comparison
|
|
||||||
result = tuple([p.zfill(8) if p.isdigit() else p for p in parts])
|
|
||||||
return result
|
|
||||||
|
|
||||||
m = is_semver(s)
|
|
||||||
if not m:
|
|
||||||
raise UnsupportedVersionError(s)
|
|
||||||
groups = m.groups()
|
|
||||||
major, minor, patch = [int(i) for i in groups[:3]]
|
|
||||||
# choose the '|' and '*' so that versions sort correctly
|
|
||||||
pre, build = make_tuple(groups[3], '|'), make_tuple(groups[5], '*')
|
|
||||||
return (major, minor, patch), pre, build
|
|
||||||
|
|
||||||
|
|
||||||
class SemanticVersion(Version):
|
|
||||||
def parse(self, s):
|
|
||||||
return _semantic_key(s)
|
|
||||||
|
|
||||||
@property
|
|
||||||
def is_prerelease(self):
|
|
||||||
return self._parts[1][0] != '|'
|
|
||||||
|
|
||||||
|
|
||||||
class SemanticMatcher(Matcher):
|
|
||||||
version_class = SemanticVersion
|
|
||||||
|
|
||||||
|
|
||||||
class VersionScheme(object):
|
|
||||||
def __init__(self, key, matcher, suggester=None):
|
|
||||||
self.key = key
|
|
||||||
self.matcher = matcher
|
|
||||||
self.suggester = suggester
|
|
||||||
|
|
||||||
def is_valid_version(self, s):
|
|
||||||
try:
|
|
||||||
self.matcher.version_class(s)
|
|
||||||
result = True
|
|
||||||
except UnsupportedVersionError:
|
|
||||||
result = False
|
|
||||||
return result
|
|
||||||
|
|
||||||
def is_valid_matcher(self, s):
|
|
||||||
try:
|
|
||||||
self.matcher(s)
|
|
||||||
result = True
|
|
||||||
except UnsupportedVersionError:
|
|
||||||
result = False
|
|
||||||
return result
|
|
||||||
|
|
||||||
def is_valid_constraint_list(self, s):
|
|
||||||
"""
|
|
||||||
Used for processing some metadata fields
|
|
||||||
"""
|
|
||||||
# See issue #140. Be tolerant of a single trailing comma.
|
|
||||||
if s.endswith(','):
|
|
||||||
s = s[:-1]
|
|
||||||
return self.is_valid_matcher('dummy_name (%s)' % s)
|
|
||||||
|
|
||||||
def suggest(self, s):
|
|
||||||
if self.suggester is None:
|
|
||||||
result = None
|
|
||||||
else:
|
|
||||||
result = self.suggester(s)
|
|
||||||
return result
|
|
||||||
|
|
||||||
_SCHEMES = {
|
|
||||||
'normalized': VersionScheme(_normalized_key, NormalizedMatcher,
|
|
||||||
_suggest_normalized_version),
|
|
||||||
'legacy': VersionScheme(_legacy_key, LegacyMatcher, lambda self, s: s),
|
|
||||||
'semantic': VersionScheme(_semantic_key, SemanticMatcher,
|
|
||||||
_suggest_semantic_version),
|
|
||||||
}
|
|
||||||
|
|
||||||
_SCHEMES['default'] = _SCHEMES['normalized']
|
|
||||||
|
|
||||||
|
|
||||||
def get_scheme(name):
|
|
||||||
if name not in _SCHEMES:
|
|
||||||
raise ValueError('unknown scheme name: %r' % name)
|
|
||||||
return _SCHEMES[name]
|
|
||||||
Двоичные данные
third_party/python/virtualenv/__virtualenv__/distlib-0.3.2-py2.py3-none-any/distlib/w32.exe
поставляемый
Двоичные данные
third_party/python/virtualenv/__virtualenv__/distlib-0.3.2-py2.py3-none-any/distlib/w32.exe
поставляемый
Двоичный файл не отображается.
Двоичные данные
third_party/python/virtualenv/__virtualenv__/distlib-0.3.2-py2.py3-none-any/distlib/w64.exe
поставляемый
Двоичные данные
third_party/python/virtualenv/__virtualenv__/distlib-0.3.2-py2.py3-none-any/distlib/w64.exe
поставляемый
Двоичный файл не отображается.
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -1,24 +0,0 @@
|
||||||
This is free and unencumbered software released into the public domain.
|
|
||||||
|
|
||||||
Anyone is free to copy, modify, publish, use, compile, sell, or
|
|
||||||
distribute this software, either in source code form or as a compiled
|
|
||||||
binary, for any purpose, commercial or non-commercial, and by any
|
|
||||||
means.
|
|
||||||
|
|
||||||
In jurisdictions that recognize copyright laws, the author or authors
|
|
||||||
of this software dedicate any and all copyright interest in the
|
|
||||||
software to the public domain. We make this dedication for the benefit
|
|
||||||
of the public at large and to the detriment of our heirs and
|
|
||||||
successors. We intend this dedication to be an overt act of
|
|
||||||
relinquishment in perpetuity of all present and future rights to this
|
|
||||||
software under copyright law.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
||||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
||||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
||||||
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
||||||
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
||||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
||||||
OTHER DEALINGS IN THE SOFTWARE.
|
|
||||||
|
|
||||||
For more information, please refer to <http://unlicense.org>
|
|
||||||
|
|
@ -1,157 +0,0 @@
|
||||||
Metadata-Version: 2.1
|
|
||||||
Name: filelock
|
|
||||||
Version: 3.0.12
|
|
||||||
Summary: A platform independent file lock.
|
|
||||||
Home-page: https://github.com/benediktschmitt/py-filelock
|
|
||||||
Author: Benedikt Schmitt
|
|
||||||
Author-email: benedikt@benediktschmitt.de
|
|
||||||
License: Public Domain <http://unlicense.org>
|
|
||||||
Download-URL: https://github.com/benediktschmitt/py-filelock/archive/master.zip
|
|
||||||
Platform: UNKNOWN
|
|
||||||
Classifier: License :: Public Domain
|
|
||||||
Classifier: Development Status :: 5 - Production/Stable
|
|
||||||
Classifier: Operating System :: OS Independent
|
|
||||||
Classifier: Programming Language :: Python
|
|
||||||
Classifier: Programming Language :: Python :: 2
|
|
||||||
Classifier: Programming Language :: Python :: 2.7
|
|
||||||
Classifier: Programming Language :: Python :: 3
|
|
||||||
Classifier: Programming Language :: Python :: 3.4
|
|
||||||
Classifier: Programming Language :: Python :: 3.5
|
|
||||||
Classifier: Programming Language :: Python :: 3.6
|
|
||||||
Classifier: Programming Language :: Python :: 3.7
|
|
||||||
Classifier: Intended Audience :: Developers
|
|
||||||
Classifier: Topic :: System
|
|
||||||
Classifier: Topic :: Internet
|
|
||||||
Classifier: Topic :: Software Development :: Libraries
|
|
||||||
Description-Content-Type: text/markdown
|
|
||||||
License-File: LICENSE
|
|
||||||
|
|
||||||
# py-filelock
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
This package contains a single module, which implements a platform independent
|
|
||||||
file lock in Python, which provides a simple way of inter-process communication:
|
|
||||||
|
|
||||||
```Python
|
|
||||||
from filelock import Timeout, FileLock
|
|
||||||
|
|
||||||
lock = FileLock("high_ground.txt.lock")
|
|
||||||
with lock:
|
|
||||||
open("high_ground.txt", "a").write("You were the chosen one.")
|
|
||||||
```
|
|
||||||
|
|
||||||
**Don't use** a *FileLock* to lock the file you want to write to, instead create
|
|
||||||
a separate *.lock* file as shown above.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
## Similar libraries
|
|
||||||
|
|
||||||
Perhaps you are looking for something like
|
|
||||||
|
|
||||||
* https://pypi.python.org/pypi/pid/2.1.1
|
|
||||||
* https://docs.python.org/3.6/library/msvcrt.html#msvcrt.locking
|
|
||||||
* or https://docs.python.org/3/library/fcntl.html#fcntl.flock
|
|
||||||
|
|
||||||
|
|
||||||
## Installation
|
|
||||||
|
|
||||||
*py-filelock* is available via PyPi:
|
|
||||||
|
|
||||||
```
|
|
||||||
$ pip3 install filelock
|
|
||||||
```
|
|
||||||
|
|
||||||
|
|
||||||
## Documentation
|
|
||||||
|
|
||||||
The documentation for the API is available on
|
|
||||||
[readthedocs.org](https://filelock.readthedocs.io/).
|
|
||||||
|
|
||||||
|
|
||||||
### Examples
|
|
||||||
|
|
||||||
A *FileLock* is used to indicate another process of your application that a
|
|
||||||
resource or working
|
|
||||||
directory is currently used. To do so, create a *FileLock* first:
|
|
||||||
|
|
||||||
```Python
|
|
||||||
from filelock import Timeout, FileLock
|
|
||||||
|
|
||||||
file_path = "high_ground.txt"
|
|
||||||
lock_path = "high_ground.txt.lock"
|
|
||||||
|
|
||||||
lock = FileLock(lock_path, timeout=1)
|
|
||||||
```
|
|
||||||
|
|
||||||
The lock object supports multiple ways for acquiring the lock, including the
|
|
||||||
ones used to acquire standard Python thread locks:
|
|
||||||
|
|
||||||
```Python
|
|
||||||
with lock:
|
|
||||||
open(file_path, "a").write("Hello there!")
|
|
||||||
|
|
||||||
lock.acquire()
|
|
||||||
try:
|
|
||||||
open(file_path, "a").write("General Kenobi!")
|
|
||||||
finally:
|
|
||||||
lock.release()
|
|
||||||
```
|
|
||||||
|
|
||||||
The *acquire()* method accepts also a *timeout* parameter. If the lock cannot be
|
|
||||||
acquired within *timeout* seconds, a *Timeout* exception is raised:
|
|
||||||
|
|
||||||
```Python
|
|
||||||
try:
|
|
||||||
with lock.acquire(timeout=10):
|
|
||||||
open(file_path, "a").write("I have a bad feeling about this.")
|
|
||||||
except Timeout:
|
|
||||||
print("Another instance of this application currently holds the lock.")
|
|
||||||
```
|
|
||||||
|
|
||||||
The lock objects are recursive locks, which means that once acquired, they will
|
|
||||||
not block on successive lock requests:
|
|
||||||
|
|
||||||
```Python
|
|
||||||
def cite1():
|
|
||||||
with lock:
|
|
||||||
open(file_path, "a").write("I hate it when he does that.")
|
|
||||||
|
|
||||||
def cite2():
|
|
||||||
with lock:
|
|
||||||
open(file_path, "a").write("You don't want to sell me death sticks.")
|
|
||||||
|
|
||||||
# The lock is acquired here.
|
|
||||||
with lock:
|
|
||||||
cite1()
|
|
||||||
cite2()
|
|
||||||
|
|
||||||
# And released here.
|
|
||||||
```
|
|
||||||
|
|
||||||
|
|
||||||
## FileLock vs SoftFileLock
|
|
||||||
|
|
||||||
The *FileLock* is platform dependent while the *SoftFileLock* is not. Use the
|
|
||||||
*FileLock* if all instances of your application are running on the same host and
|
|
||||||
a *SoftFileLock* otherwise.
|
|
||||||
|
|
||||||
The *SoftFileLock* only watches the existence of the lock file. This makes it
|
|
||||||
ultra portable, but also more prone to dead locks if the application crashes.
|
|
||||||
You can simply delete the lock file in such cases.
|
|
||||||
|
|
||||||
|
|
||||||
## Contributions
|
|
||||||
|
|
||||||
Contributions are always welcome, please make sure they pass all tests before
|
|
||||||
creating a pull request. Never hesitate to open a new issue, although it may
|
|
||||||
take some time for me to respond.
|
|
||||||
|
|
||||||
|
|
||||||
## License
|
|
||||||
|
|
||||||
This package is [public domain](./LICENSE.rst).
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
filelock.py,sha256=5DQTtOaQq7-vgLkZzvOhqhVMh_umfydWgSA8Vuzmf8M,13229
|
|
||||||
filelock-3.0.12.dist-info/LICENSE,sha256=iNm062BXnBkew5HKBMFhMFctfu3EqG2qWL8oxuFMm80,1210
|
|
||||||
filelock-3.0.12.dist-info/METADATA,sha256=KYeYgE0nuoXtRp8NVK-5w4B0b_1HGjugDDScxhiBjFU,4365
|
|
||||||
filelock-3.0.12.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
|
|
||||||
filelock-3.0.12.dist-info/top_level.txt,sha256=NDrf9i5BNogz4hEdsr6Hi7Ws3TlSSKY4Q2Y9_-i2GwU,9
|
|
||||||
filelock-3.0.12.dist-info/RECORD,,
|
|
||||||
|
|
@ -1,5 +0,0 @@
|
||||||
Wheel-Version: 1.0
|
|
||||||
Generator: bdist_wheel (0.36.2)
|
|
||||||
Root-Is-Purelib: true
|
|
||||||
Tag: py3-none-any
|
|
||||||
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
filelock
|
|
||||||
|
|
@ -1,451 +0,0 @@
|
||||||
# This is free and unencumbered software released into the public domain.
|
|
||||||
#
|
|
||||||
# Anyone is free to copy, modify, publish, use, compile, sell, or
|
|
||||||
# distribute this software, either in source code form or as a compiled
|
|
||||||
# binary, for any purpose, commercial or non-commercial, and by any
|
|
||||||
# means.
|
|
||||||
#
|
|
||||||
# In jurisdictions that recognize copyright laws, the author or authors
|
|
||||||
# of this software dedicate any and all copyright interest in the
|
|
||||||
# software to the public domain. We make this dedication for the benefit
|
|
||||||
# of the public at large and to the detriment of our heirs and
|
|
||||||
# successors. We intend this dedication to be an overt act of
|
|
||||||
# relinquishment in perpetuity of all present and future rights to this
|
|
||||||
# software under copyright law.
|
|
||||||
#
|
|
||||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
||||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
||||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
||||||
# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
||||||
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
||||||
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
||||||
# OTHER DEALINGS IN THE SOFTWARE.
|
|
||||||
#
|
|
||||||
# For more information, please refer to <http://unlicense.org>
|
|
||||||
|
|
||||||
"""
|
|
||||||
A platform independent file lock that supports the with-statement.
|
|
||||||
"""
|
|
||||||
|
|
||||||
|
|
||||||
# Modules
|
|
||||||
# ------------------------------------------------
|
|
||||||
import logging
|
|
||||||
import os
|
|
||||||
import threading
|
|
||||||
import time
|
|
||||||
try:
|
|
||||||
import warnings
|
|
||||||
except ImportError:
|
|
||||||
warnings = None
|
|
||||||
|
|
||||||
try:
|
|
||||||
import msvcrt
|
|
||||||
except ImportError:
|
|
||||||
msvcrt = None
|
|
||||||
|
|
||||||
try:
|
|
||||||
import fcntl
|
|
||||||
except ImportError:
|
|
||||||
fcntl = None
|
|
||||||
|
|
||||||
|
|
||||||
# Backward compatibility
|
|
||||||
# ------------------------------------------------
|
|
||||||
try:
|
|
||||||
TimeoutError
|
|
||||||
except NameError:
|
|
||||||
TimeoutError = OSError
|
|
||||||
|
|
||||||
|
|
||||||
# Data
|
|
||||||
# ------------------------------------------------
|
|
||||||
__all__ = [
|
|
||||||
"Timeout",
|
|
||||||
"BaseFileLock",
|
|
||||||
"WindowsFileLock",
|
|
||||||
"UnixFileLock",
|
|
||||||
"SoftFileLock",
|
|
||||||
"FileLock"
|
|
||||||
]
|
|
||||||
|
|
||||||
__version__ = "3.0.12"
|
|
||||||
|
|
||||||
|
|
||||||
_logger = None
|
|
||||||
def logger():
|
|
||||||
"""Returns the logger instance used in this module."""
|
|
||||||
global _logger
|
|
||||||
_logger = _logger or logging.getLogger(__name__)
|
|
||||||
return _logger
|
|
||||||
|
|
||||||
|
|
||||||
# Exceptions
|
|
||||||
# ------------------------------------------------
|
|
||||||
class Timeout(TimeoutError):
|
|
||||||
"""
|
|
||||||
Raised when the lock could not be acquired in *timeout*
|
|
||||||
seconds.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, lock_file):
|
|
||||||
"""
|
|
||||||
"""
|
|
||||||
#: The path of the file lock.
|
|
||||||
self.lock_file = lock_file
|
|
||||||
return None
|
|
||||||
|
|
||||||
def __str__(self):
|
|
||||||
temp = "The file lock '{}' could not be acquired."\
|
|
||||||
.format(self.lock_file)
|
|
||||||
return temp
|
|
||||||
|
|
||||||
|
|
||||||
# Classes
|
|
||||||
# ------------------------------------------------
|
|
||||||
|
|
||||||
# This is a helper class which is returned by :meth:`BaseFileLock.acquire`
|
|
||||||
# and wraps the lock to make sure __enter__ is not called twice when entering
|
|
||||||
# the with statement.
|
|
||||||
# If we would simply return *self*, the lock would be acquired again
|
|
||||||
# in the *__enter__* method of the BaseFileLock, but not released again
|
|
||||||
# automatically.
|
|
||||||
#
|
|
||||||
# :seealso: issue #37 (memory leak)
|
|
||||||
class _Acquire_ReturnProxy(object):
|
|
||||||
|
|
||||||
def __init__(self, lock):
|
|
||||||
self.lock = lock
|
|
||||||
return None
|
|
||||||
|
|
||||||
def __enter__(self):
|
|
||||||
return self.lock
|
|
||||||
|
|
||||||
def __exit__(self, exc_type, exc_value, traceback):
|
|
||||||
self.lock.release()
|
|
||||||
return None
|
|
||||||
|
|
||||||
|
|
||||||
class BaseFileLock(object):
|
|
||||||
"""
|
|
||||||
Implements the base class of a file lock.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, lock_file, timeout = -1):
|
|
||||||
"""
|
|
||||||
"""
|
|
||||||
# The path to the lock file.
|
|
||||||
self._lock_file = lock_file
|
|
||||||
|
|
||||||
# The file descriptor for the *_lock_file* as it is returned by the
|
|
||||||
# os.open() function.
|
|
||||||
# This file lock is only NOT None, if the object currently holds the
|
|
||||||
# lock.
|
|
||||||
self._lock_file_fd = None
|
|
||||||
|
|
||||||
# The default timeout value.
|
|
||||||
self.timeout = timeout
|
|
||||||
|
|
||||||
# We use this lock primarily for the lock counter.
|
|
||||||
self._thread_lock = threading.Lock()
|
|
||||||
|
|
||||||
# The lock counter is used for implementing the nested locking
|
|
||||||
# mechanism. Whenever the lock is acquired, the counter is increased and
|
|
||||||
# the lock is only released, when this value is 0 again.
|
|
||||||
self._lock_counter = 0
|
|
||||||
return None
|
|
||||||
|
|
||||||
@property
|
|
||||||
def lock_file(self):
|
|
||||||
"""
|
|
||||||
The path to the lock file.
|
|
||||||
"""
|
|
||||||
return self._lock_file
|
|
||||||
|
|
||||||
@property
|
|
||||||
def timeout(self):
|
|
||||||
"""
|
|
||||||
You can set a default timeout for the filelock. It will be used as
|
|
||||||
fallback value in the acquire method, if no timeout value (*None*) is
|
|
||||||
given.
|
|
||||||
|
|
||||||
If you want to disable the timeout, set it to a negative value.
|
|
||||||
|
|
||||||
A timeout of 0 means, that there is exactly one attempt to acquire the
|
|
||||||
file lock.
|
|
||||||
|
|
||||||
.. versionadded:: 2.0.0
|
|
||||||
"""
|
|
||||||
return self._timeout
|
|
||||||
|
|
||||||
@timeout.setter
|
|
||||||
def timeout(self, value):
|
|
||||||
"""
|
|
||||||
"""
|
|
||||||
self._timeout = float(value)
|
|
||||||
return None
|
|
||||||
|
|
||||||
# Platform dependent locking
|
|
||||||
# --------------------------------------------
|
|
||||||
|
|
||||||
def _acquire(self):
|
|
||||||
"""
|
|
||||||
Platform dependent. If the file lock could be
|
|
||||||
acquired, self._lock_file_fd holds the file descriptor
|
|
||||||
of the lock file.
|
|
||||||
"""
|
|
||||||
raise NotImplementedError()
|
|
||||||
|
|
||||||
def _release(self):
|
|
||||||
"""
|
|
||||||
Releases the lock and sets self._lock_file_fd to None.
|
|
||||||
"""
|
|
||||||
raise NotImplementedError()
|
|
||||||
|
|
||||||
# Platform independent methods
|
|
||||||
# --------------------------------------------
|
|
||||||
|
|
||||||
@property
|
|
||||||
def is_locked(self):
|
|
||||||
"""
|
|
||||||
True, if the object holds the file lock.
|
|
||||||
|
|
||||||
.. versionchanged:: 2.0.0
|
|
||||||
|
|
||||||
This was previously a method and is now a property.
|
|
||||||
"""
|
|
||||||
return self._lock_file_fd is not None
|
|
||||||
|
|
||||||
def acquire(self, timeout=None, poll_intervall=0.05):
|
|
||||||
"""
|
|
||||||
Acquires the file lock or fails with a :exc:`Timeout` error.
|
|
||||||
|
|
||||||
.. code-block:: python
|
|
||||||
|
|
||||||
# You can use this method in the context manager (recommended)
|
|
||||||
with lock.acquire():
|
|
||||||
pass
|
|
||||||
|
|
||||||
# Or use an equivalent try-finally construct:
|
|
||||||
lock.acquire()
|
|
||||||
try:
|
|
||||||
pass
|
|
||||||
finally:
|
|
||||||
lock.release()
|
|
||||||
|
|
||||||
:arg float timeout:
|
|
||||||
The maximum time waited for the file lock.
|
|
||||||
If ``timeout < 0``, there is no timeout and this method will
|
|
||||||
block until the lock could be acquired.
|
|
||||||
If ``timeout`` is None, the default :attr:`~timeout` is used.
|
|
||||||
|
|
||||||
:arg float poll_intervall:
|
|
||||||
We check once in *poll_intervall* seconds if we can acquire the
|
|
||||||
file lock.
|
|
||||||
|
|
||||||
:raises Timeout:
|
|
||||||
if the lock could not be acquired in *timeout* seconds.
|
|
||||||
|
|
||||||
.. versionchanged:: 2.0.0
|
|
||||||
|
|
||||||
This method returns now a *proxy* object instead of *self*,
|
|
||||||
so that it can be used in a with statement without side effects.
|
|
||||||
"""
|
|
||||||
# Use the default timeout, if no timeout is provided.
|
|
||||||
if timeout is None:
|
|
||||||
timeout = self.timeout
|
|
||||||
|
|
||||||
# Increment the number right at the beginning.
|
|
||||||
# We can still undo it, if something fails.
|
|
||||||
with self._thread_lock:
|
|
||||||
self._lock_counter += 1
|
|
||||||
|
|
||||||
lock_id = id(self)
|
|
||||||
lock_filename = self._lock_file
|
|
||||||
start_time = time.time()
|
|
||||||
try:
|
|
||||||
while True:
|
|
||||||
with self._thread_lock:
|
|
||||||
if not self.is_locked:
|
|
||||||
logger().debug('Attempting to acquire lock %s on %s', lock_id, lock_filename)
|
|
||||||
self._acquire()
|
|
||||||
|
|
||||||
if self.is_locked:
|
|
||||||
logger().info('Lock %s acquired on %s', lock_id, lock_filename)
|
|
||||||
break
|
|
||||||
elif timeout >= 0 and time.time() - start_time > timeout:
|
|
||||||
logger().debug('Timeout on acquiring lock %s on %s', lock_id, lock_filename)
|
|
||||||
raise Timeout(self._lock_file)
|
|
||||||
else:
|
|
||||||
logger().debug(
|
|
||||||
'Lock %s not acquired on %s, waiting %s seconds ...',
|
|
||||||
lock_id, lock_filename, poll_intervall
|
|
||||||
)
|
|
||||||
time.sleep(poll_intervall)
|
|
||||||
except:
|
|
||||||
# Something did go wrong, so decrement the counter.
|
|
||||||
with self._thread_lock:
|
|
||||||
self._lock_counter = max(0, self._lock_counter - 1)
|
|
||||||
|
|
||||||
raise
|
|
||||||
return _Acquire_ReturnProxy(lock = self)
|
|
||||||
|
|
||||||
def release(self, force = False):
|
|
||||||
"""
|
|
||||||
Releases the file lock.
|
|
||||||
|
|
||||||
Please note, that the lock is only completly released, if the lock
|
|
||||||
counter is 0.
|
|
||||||
|
|
||||||
Also note, that the lock file itself is not automatically deleted.
|
|
||||||
|
|
||||||
:arg bool force:
|
|
||||||
If true, the lock counter is ignored and the lock is released in
|
|
||||||
every case.
|
|
||||||
"""
|
|
||||||
with self._thread_lock:
|
|
||||||
|
|
||||||
if self.is_locked:
|
|
||||||
self._lock_counter -= 1
|
|
||||||
|
|
||||||
if self._lock_counter == 0 or force:
|
|
||||||
lock_id = id(self)
|
|
||||||
lock_filename = self._lock_file
|
|
||||||
|
|
||||||
logger().debug('Attempting to release lock %s on %s', lock_id, lock_filename)
|
|
||||||
self._release()
|
|
||||||
self._lock_counter = 0
|
|
||||||
logger().info('Lock %s released on %s', lock_id, lock_filename)
|
|
||||||
|
|
||||||
return None
|
|
||||||
|
|
||||||
def __enter__(self):
|
|
||||||
self.acquire()
|
|
||||||
return self
|
|
||||||
|
|
||||||
def __exit__(self, exc_type, exc_value, traceback):
|
|
||||||
self.release()
|
|
||||||
return None
|
|
||||||
|
|
||||||
def __del__(self):
|
|
||||||
self.release(force = True)
|
|
||||||
return None
|
|
||||||
|
|
||||||
|
|
||||||
# Windows locking mechanism
|
|
||||||
# ~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
||||||
|
|
||||||
class WindowsFileLock(BaseFileLock):
|
|
||||||
"""
|
|
||||||
Uses the :func:`msvcrt.locking` function to hard lock the lock file on
|
|
||||||
windows systems.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def _acquire(self):
|
|
||||||
open_mode = os.O_RDWR | os.O_CREAT | os.O_TRUNC
|
|
||||||
|
|
||||||
try:
|
|
||||||
fd = os.open(self._lock_file, open_mode)
|
|
||||||
except OSError:
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
|
|
||||||
except (IOError, OSError):
|
|
||||||
os.close(fd)
|
|
||||||
else:
|
|
||||||
self._lock_file_fd = fd
|
|
||||||
return None
|
|
||||||
|
|
||||||
def _release(self):
|
|
||||||
fd = self._lock_file_fd
|
|
||||||
self._lock_file_fd = None
|
|
||||||
msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
|
|
||||||
os.close(fd)
|
|
||||||
|
|
||||||
try:
|
|
||||||
os.remove(self._lock_file)
|
|
||||||
# Probably another instance of the application
|
|
||||||
# that acquired the file lock.
|
|
||||||
except OSError:
|
|
||||||
pass
|
|
||||||
return None
|
|
||||||
|
|
||||||
# Unix locking mechanism
|
|
||||||
# ~~~~~~~~~~~~~~~~~~~~~~
|
|
||||||
|
|
||||||
class UnixFileLock(BaseFileLock):
|
|
||||||
"""
|
|
||||||
Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def _acquire(self):
|
|
||||||
open_mode = os.O_RDWR | os.O_CREAT | os.O_TRUNC
|
|
||||||
fd = os.open(self._lock_file, open_mode)
|
|
||||||
|
|
||||||
try:
|
|
||||||
fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
|
||||||
except (IOError, OSError):
|
|
||||||
os.close(fd)
|
|
||||||
else:
|
|
||||||
self._lock_file_fd = fd
|
|
||||||
return None
|
|
||||||
|
|
||||||
def _release(self):
|
|
||||||
# Do not remove the lockfile:
|
|
||||||
#
|
|
||||||
# https://github.com/benediktschmitt/py-filelock/issues/31
|
|
||||||
# https://stackoverflow.com/questions/17708885/flock-removing-locked-file-without-race-condition
|
|
||||||
fd = self._lock_file_fd
|
|
||||||
self._lock_file_fd = None
|
|
||||||
fcntl.flock(fd, fcntl.LOCK_UN)
|
|
||||||
os.close(fd)
|
|
||||||
return None
|
|
||||||
|
|
||||||
# Soft lock
|
|
||||||
# ~~~~~~~~~
|
|
||||||
|
|
||||||
class SoftFileLock(BaseFileLock):
|
|
||||||
"""
|
|
||||||
Simply watches the existence of the lock file.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def _acquire(self):
|
|
||||||
open_mode = os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_TRUNC
|
|
||||||
try:
|
|
||||||
fd = os.open(self._lock_file, open_mode)
|
|
||||||
except (IOError, OSError):
|
|
||||||
pass
|
|
||||||
else:
|
|
||||||
self._lock_file_fd = fd
|
|
||||||
return None
|
|
||||||
|
|
||||||
def _release(self):
|
|
||||||
os.close(self._lock_file_fd)
|
|
||||||
self._lock_file_fd = None
|
|
||||||
|
|
||||||
try:
|
|
||||||
os.remove(self._lock_file)
|
|
||||||
# The file is already deleted and that's what we want.
|
|
||||||
except OSError:
|
|
||||||
pass
|
|
||||||
return None
|
|
||||||
|
|
||||||
|
|
||||||
# Platform filelock
|
|
||||||
# ~~~~~~~~~~~~~~~~~
|
|
||||||
|
|
||||||
#: Alias for the lock, which should be used for the current platform. On
|
|
||||||
#: Windows, this is an alias for :class:`WindowsFileLock`, on Unix for
|
|
||||||
#: :class:`UnixFileLock` and otherwise for :class:`SoftFileLock`.
|
|
||||||
FileLock = None
|
|
||||||
|
|
||||||
if msvcrt:
|
|
||||||
FileLock = WindowsFileLock
|
|
||||||
elif fcntl:
|
|
||||||
FileLock = UnixFileLock
|
|
||||||
else:
|
|
||||||
FileLock = SoftFileLock
|
|
||||||
|
|
||||||
if warnings is not None:
|
|
||||||
warnings.warn("only soft file lock is available")
|
|
||||||
|
|
@ -1,13 +0,0 @@
|
||||||
Copyright 2017-2019 Jason R. Coombs, Barry Warsaw
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
||||||
|
|
@ -1,73 +0,0 @@
|
||||||
Metadata-Version: 2.1
|
|
||||||
Name: importlib-metadata
|
|
||||||
Version: 2.1.1
|
|
||||||
Summary: Read metadata from Python packages
|
|
||||||
Home-page: http://importlib-metadata.readthedocs.io/
|
|
||||||
Author: Jason R. Coombs
|
|
||||||
Author-email: jaraco@jaraco.com
|
|
||||||
License: Apache Software License
|
|
||||||
Platform: UNKNOWN
|
|
||||||
Classifier: Development Status :: 3 - Alpha
|
|
||||||
Classifier: Intended Audience :: Developers
|
|
||||||
Classifier: License :: OSI Approved :: Apache Software License
|
|
||||||
Classifier: Topic :: Software Development :: Libraries
|
|
||||||
Classifier: Programming Language :: Python :: 3
|
|
||||||
Classifier: Programming Language :: Python :: 2
|
|
||||||
Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7
|
|
||||||
Requires-Dist: zipp (>=0.5)
|
|
||||||
Requires-Dist: pathlib2 ; python_version < "3"
|
|
||||||
Requires-Dist: contextlib2 ; python_version < "3"
|
|
||||||
Requires-Dist: configparser (>=3.5) ; python_version < "3"
|
|
||||||
Provides-Extra: docs
|
|
||||||
Requires-Dist: sphinx ; extra == 'docs'
|
|
||||||
Requires-Dist: rst.linker ; extra == 'docs'
|
|
||||||
Provides-Extra: testing
|
|
||||||
Requires-Dist: packaging ; extra == 'testing'
|
|
||||||
Requires-Dist: pep517 ; extra == 'testing'
|
|
||||||
Requires-Dist: unittest2 ; (python_version < "3") and extra == 'testing'
|
|
||||||
Requires-Dist: importlib-resources (>=1.3) ; (python_version < "3.9") and extra == 'testing'
|
|
||||||
|
|
||||||
=========================
|
|
||||||
``importlib_metadata``
|
|
||||||
=========================
|
|
||||||
|
|
||||||
``importlib_metadata`` is a library to access the metadata for a
|
|
||||||
Python package.
|
|
||||||
|
|
||||||
As of Python 3.8, this functionality has been added to the
|
|
||||||
`Python standard library
|
|
||||||
<https://docs.python.org/3/library/importlib.metadata.html>`_.
|
|
||||||
This package supplies backports of that functionality including
|
|
||||||
improvements added to subsequent Python versions.
|
|
||||||
|
|
||||||
|
|
||||||
Usage
|
|
||||||
=====
|
|
||||||
|
|
||||||
See the `online documentation <https://importlib_metadata.readthedocs.io/>`_
|
|
||||||
for usage details.
|
|
||||||
|
|
||||||
`Finder authors
|
|
||||||
<https://docs.python.org/3/reference/import.html#finders-and-loaders>`_ can
|
|
||||||
also add support for custom package installers. See the above documentation
|
|
||||||
for details.
|
|
||||||
|
|
||||||
|
|
||||||
Caveats
|
|
||||||
=======
|
|
||||||
|
|
||||||
This project primarily supports third-party packages installed by PyPA
|
|
||||||
tools (or other conforming packages). It does not support:
|
|
||||||
|
|
||||||
- Packages in the stdlib.
|
|
||||||
- Packages installed without metadata.
|
|
||||||
|
|
||||||
Project details
|
|
||||||
===============
|
|
||||||
|
|
||||||
* Project home: https://github.com/python/importlib_metadata
|
|
||||||
* Report bugs at: https://github.com/python/importlib_metadata/issues
|
|
||||||
* Code hosting: https://github.com/python/importlib_metadata
|
|
||||||
* Documentation: https://importlib_metadata.readthedocs.io/
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,7 +0,0 @@
|
||||||
importlib_metadata/__init__.py,sha256=uaN7KDLs3-irvgwsxg4VZIuY3ZEo3jhu1dShjE7fR88,19587
|
|
||||||
importlib_metadata/_compat.py,sha256=DnM55BbJKFCcZmJOkArmyO76-0g7pA6HEfzSYWXN88k,4417
|
|
||||||
importlib_metadata-2.1.1.dist-info/LICENSE,sha256=wNe6dAchmJ1VvVB8D9oTc-gHHadCuaSBAev36sYEM6U,571
|
|
||||||
importlib_metadata-2.1.1.dist-info/METADATA,sha256=gBf5nX-Ff6_Ue9dSH4dkWg2FCNHHtQrs6mhunTAac8k,2421
|
|
||||||
importlib_metadata-2.1.1.dist-info/WHEEL,sha256=ADKeyaGyKF5DwBNE0sRE5pvW-bSkFMJfBuhzZ3rceP4,110
|
|
||||||
importlib_metadata-2.1.1.dist-info/top_level.txt,sha256=CO3fD9yylANiXkrMo4qHLV_mqXL2sC5JFKgt1yWAT-A,19
|
|
||||||
importlib_metadata-2.1.1.dist-info/RECORD,,
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
Wheel-Version: 1.0
|
|
||||||
Generator: bdist_wheel (0.35.1)
|
|
||||||
Root-Is-Purelib: true
|
|
||||||
Tag: py2-none-any
|
|
||||||
Tag: py3-none-any
|
|
||||||
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
importlib_metadata
|
|
||||||
|
|
@ -1,644 +0,0 @@
|
||||||
from __future__ import unicode_literals, absolute_import
|
|
||||||
|
|
||||||
import io
|
|
||||||
import os
|
|
||||||
import re
|
|
||||||
import abc
|
|
||||||
import csv
|
|
||||||
import sys
|
|
||||||
import zipp
|
|
||||||
import operator
|
|
||||||
import functools
|
|
||||||
import itertools
|
|
||||||
import posixpath
|
|
||||||
import collections
|
|
||||||
|
|
||||||
from ._compat import (
|
|
||||||
install,
|
|
||||||
NullFinder,
|
|
||||||
ConfigParser,
|
|
||||||
suppress,
|
|
||||||
map,
|
|
||||||
FileNotFoundError,
|
|
||||||
IsADirectoryError,
|
|
||||||
NotADirectoryError,
|
|
||||||
PermissionError,
|
|
||||||
pathlib,
|
|
||||||
ModuleNotFoundError,
|
|
||||||
MetaPathFinder,
|
|
||||||
email_message_from_string,
|
|
||||||
PyPy_repr,
|
|
||||||
unique_ordered,
|
|
||||||
str,
|
|
||||||
)
|
|
||||||
from importlib import import_module
|
|
||||||
from itertools import starmap
|
|
||||||
|
|
||||||
|
|
||||||
__metaclass__ = type
|
|
||||||
|
|
||||||
|
|
||||||
__all__ = [
|
|
||||||
'Distribution',
|
|
||||||
'DistributionFinder',
|
|
||||||
'PackageNotFoundError',
|
|
||||||
'distribution',
|
|
||||||
'distributions',
|
|
||||||
'entry_points',
|
|
||||||
'files',
|
|
||||||
'metadata',
|
|
||||||
'requires',
|
|
||||||
'version',
|
|
||||||
]
|
|
||||||
|
|
||||||
|
|
||||||
class PackageNotFoundError(ModuleNotFoundError):
|
|
||||||
"""The package was not found."""
|
|
||||||
|
|
||||||
def __str__(self):
|
|
||||||
tmpl = "No package metadata was found for {self.name}"
|
|
||||||
return tmpl.format(**locals())
|
|
||||||
|
|
||||||
@property
|
|
||||||
def name(self):
|
|
||||||
name, = self.args
|
|
||||||
return name
|
|
||||||
|
|
||||||
|
|
||||||
class EntryPoint(
|
|
||||||
PyPy_repr,
|
|
||||||
collections.namedtuple('EntryPointBase', 'name value group')):
|
|
||||||
"""An entry point as defined by Python packaging conventions.
|
|
||||||
|
|
||||||
See `the packaging docs on entry points
|
|
||||||
<https://packaging.python.org/specifications/entry-points/>`_
|
|
||||||
for more information.
|
|
||||||
"""
|
|
||||||
|
|
||||||
pattern = re.compile(
|
|
||||||
r'(?P<module>[\w.]+)\s*'
|
|
||||||
r'(:\s*(?P<attr>[\w.]+))?\s*'
|
|
||||||
r'(?P<extras>\[.*\])?\s*$'
|
|
||||||
)
|
|
||||||
"""
|
|
||||||
A regular expression describing the syntax for an entry point,
|
|
||||||
which might look like:
|
|
||||||
|
|
||||||
- module
|
|
||||||
- package.module
|
|
||||||
- package.module:attribute
|
|
||||||
- package.module:object.attribute
|
|
||||||
- package.module:attr [extra1, extra2]
|
|
||||||
|
|
||||||
Other combinations are possible as well.
|
|
||||||
|
|
||||||
The expression is lenient about whitespace around the ':',
|
|
||||||
following the attr, and following any extras.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def load(self):
|
|
||||||
"""Load the entry point from its definition. If only a module
|
|
||||||
is indicated by the value, return that module. Otherwise,
|
|
||||||
return the named object.
|
|
||||||
"""
|
|
||||||
match = self.pattern.match(self.value)
|
|
||||||
module = import_module(match.group('module'))
|
|
||||||
attrs = filter(None, (match.group('attr') or '').split('.'))
|
|
||||||
return functools.reduce(getattr, attrs, module)
|
|
||||||
|
|
||||||
@property
|
|
||||||
def module(self):
|
|
||||||
match = self.pattern.match(self.value)
|
|
||||||
return match.group('module')
|
|
||||||
|
|
||||||
@property
|
|
||||||
def attr(self):
|
|
||||||
match = self.pattern.match(self.value)
|
|
||||||
return match.group('attr')
|
|
||||||
|
|
||||||
@property
|
|
||||||
def extras(self):
|
|
||||||
match = self.pattern.match(self.value)
|
|
||||||
return list(re.finditer(r'\w+', match.group('extras') or ''))
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def _from_config(cls, config):
|
|
||||||
return [
|
|
||||||
cls(name, value, group)
|
|
||||||
for group in config.sections()
|
|
||||||
for name, value in config.items(group)
|
|
||||||
]
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def _from_text(cls, text):
|
|
||||||
config = ConfigParser(delimiters='=')
|
|
||||||
# case sensitive: https://stackoverflow.com/q/1611799/812183
|
|
||||||
config.optionxform = str
|
|
||||||
try:
|
|
||||||
config.read_string(text)
|
|
||||||
except AttributeError: # pragma: nocover
|
|
||||||
# Python 2 has no read_string
|
|
||||||
config.readfp(io.StringIO(text))
|
|
||||||
return EntryPoint._from_config(config)
|
|
||||||
|
|
||||||
def __iter__(self):
|
|
||||||
"""
|
|
||||||
Supply iter so one may construct dicts of EntryPoints easily.
|
|
||||||
"""
|
|
||||||
return iter((self.name, self))
|
|
||||||
|
|
||||||
def __reduce__(self):
|
|
||||||
return (
|
|
||||||
self.__class__,
|
|
||||||
(self.name, self.value, self.group),
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
class PackagePath(pathlib.PurePosixPath):
|
|
||||||
"""A reference to a path in a package"""
|
|
||||||
|
|
||||||
def read_text(self, encoding='utf-8'):
|
|
||||||
with self.locate().open(encoding=encoding) as stream:
|
|
||||||
return stream.read()
|
|
||||||
|
|
||||||
def read_binary(self):
|
|
||||||
with self.locate().open('rb') as stream:
|
|
||||||
return stream.read()
|
|
||||||
|
|
||||||
def locate(self):
|
|
||||||
"""Return a path-like object for this path"""
|
|
||||||
return self.dist.locate_file(self)
|
|
||||||
|
|
||||||
|
|
||||||
class FileHash:
|
|
||||||
def __init__(self, spec):
|
|
||||||
self.mode, _, self.value = spec.partition('=')
|
|
||||||
|
|
||||||
def __repr__(self):
|
|
||||||
return '<FileHash mode: {} value: {}>'.format(self.mode, self.value)
|
|
||||||
|
|
||||||
|
|
||||||
class Distribution:
|
|
||||||
"""A Python distribution package."""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def read_text(self, filename):
|
|
||||||
"""Attempt to load metadata file given by the name.
|
|
||||||
|
|
||||||
:param filename: The name of the file in the distribution info.
|
|
||||||
:return: The text if found, otherwise None.
|
|
||||||
"""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def locate_file(self, path):
|
|
||||||
"""
|
|
||||||
Given a path to a file in this distribution, return a path
|
|
||||||
to it.
|
|
||||||
"""
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def from_name(cls, name):
|
|
||||||
"""Return the Distribution for the given package name.
|
|
||||||
|
|
||||||
:param name: The name of the distribution package to search for.
|
|
||||||
:return: The Distribution instance (or subclass thereof) for the named
|
|
||||||
package, if found.
|
|
||||||
:raises PackageNotFoundError: When the named package's distribution
|
|
||||||
metadata cannot be found.
|
|
||||||
"""
|
|
||||||
for resolver in cls._discover_resolvers():
|
|
||||||
dists = resolver(DistributionFinder.Context(name=name))
|
|
||||||
dist = next(iter(dists), None)
|
|
||||||
if dist is not None:
|
|
||||||
return dist
|
|
||||||
else:
|
|
||||||
raise PackageNotFoundError(name)
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def discover(cls, **kwargs):
|
|
||||||
"""Return an iterable of Distribution objects for all packages.
|
|
||||||
|
|
||||||
Pass a ``context`` or pass keyword arguments for constructing
|
|
||||||
a context.
|
|
||||||
|
|
||||||
:context: A ``DistributionFinder.Context`` object.
|
|
||||||
:return: Iterable of Distribution objects for all packages.
|
|
||||||
"""
|
|
||||||
context = kwargs.pop('context', None)
|
|
||||||
if context and kwargs:
|
|
||||||
raise ValueError("cannot accept context and kwargs")
|
|
||||||
context = context or DistributionFinder.Context(**kwargs)
|
|
||||||
return itertools.chain.from_iterable(
|
|
||||||
resolver(context)
|
|
||||||
for resolver in cls._discover_resolvers()
|
|
||||||
)
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def at(path):
|
|
||||||
"""Return a Distribution for the indicated metadata path
|
|
||||||
|
|
||||||
:param path: a string or path-like object
|
|
||||||
:return: a concrete Distribution instance for the path
|
|
||||||
"""
|
|
||||||
return PathDistribution(pathlib.Path(path))
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def _discover_resolvers():
|
|
||||||
"""Search the meta_path for resolvers."""
|
|
||||||
declared = (
|
|
||||||
getattr(finder, 'find_distributions', None)
|
|
||||||
for finder in sys.meta_path
|
|
||||||
)
|
|
||||||
return filter(None, declared)
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def _local(cls, root='.'):
|
|
||||||
from pep517 import build, meta
|
|
||||||
system = build.compat_system(root)
|
|
||||||
builder = functools.partial(
|
|
||||||
meta.build,
|
|
||||||
source_dir=root,
|
|
||||||
system=system,
|
|
||||||
)
|
|
||||||
return PathDistribution(zipp.Path(meta.build_as_zip(builder)))
|
|
||||||
|
|
||||||
@property
|
|
||||||
def metadata(self):
|
|
||||||
"""Return the parsed metadata for this Distribution.
|
|
||||||
|
|
||||||
The returned object will have keys that name the various bits of
|
|
||||||
metadata. See PEP 566 for details.
|
|
||||||
"""
|
|
||||||
text = (
|
|
||||||
self.read_text('METADATA')
|
|
||||||
or self.read_text('PKG-INFO')
|
|
||||||
# This last clause is here to support old egg-info files. Its
|
|
||||||
# effect is to just end up using the PathDistribution's self._path
|
|
||||||
# (which points to the egg-info file) attribute unchanged.
|
|
||||||
or self.read_text('')
|
|
||||||
)
|
|
||||||
return email_message_from_string(text)
|
|
||||||
|
|
||||||
@property
|
|
||||||
def version(self):
|
|
||||||
"""Return the 'Version' metadata for the distribution package."""
|
|
||||||
return self.metadata['Version']
|
|
||||||
|
|
||||||
@property
|
|
||||||
def entry_points(self):
|
|
||||||
return EntryPoint._from_text(self.read_text('entry_points.txt'))
|
|
||||||
|
|
||||||
@property
|
|
||||||
def files(self):
|
|
||||||
"""Files in this distribution.
|
|
||||||
|
|
||||||
:return: List of PackagePath for this distribution or None
|
|
||||||
|
|
||||||
Result is `None` if the metadata file that enumerates files
|
|
||||||
(i.e. RECORD for dist-info or SOURCES.txt for egg-info) is
|
|
||||||
missing.
|
|
||||||
Result may be empty if the metadata exists but is empty.
|
|
||||||
"""
|
|
||||||
file_lines = self._read_files_distinfo() or self._read_files_egginfo()
|
|
||||||
|
|
||||||
def make_file(name, hash=None, size_str=None):
|
|
||||||
result = PackagePath(name)
|
|
||||||
result.hash = FileHash(hash) if hash else None
|
|
||||||
result.size = int(size_str) if size_str else None
|
|
||||||
result.dist = self
|
|
||||||
return result
|
|
||||||
|
|
||||||
return file_lines and list(starmap(make_file, csv.reader(file_lines)))
|
|
||||||
|
|
||||||
def _read_files_distinfo(self):
|
|
||||||
"""
|
|
||||||
Read the lines of RECORD
|
|
||||||
"""
|
|
||||||
text = self.read_text('RECORD')
|
|
||||||
return text and text.splitlines()
|
|
||||||
|
|
||||||
def _read_files_egginfo(self):
|
|
||||||
"""
|
|
||||||
SOURCES.txt might contain literal commas, so wrap each line
|
|
||||||
in quotes.
|
|
||||||
"""
|
|
||||||
text = self.read_text('SOURCES.txt')
|
|
||||||
return text and map('"{}"'.format, text.splitlines())
|
|
||||||
|
|
||||||
@property
|
|
||||||
def requires(self):
|
|
||||||
"""Generated requirements specified for this Distribution"""
|
|
||||||
reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs()
|
|
||||||
return reqs and list(reqs)
|
|
||||||
|
|
||||||
def _read_dist_info_reqs(self):
|
|
||||||
return self.metadata.get_all('Requires-Dist')
|
|
||||||
|
|
||||||
def _read_egg_info_reqs(self):
|
|
||||||
source = self.read_text('requires.txt')
|
|
||||||
return source and self._deps_from_requires_text(source)
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def _deps_from_requires_text(cls, source):
|
|
||||||
section_pairs = cls._read_sections(source.splitlines())
|
|
||||||
sections = {
|
|
||||||
section: list(map(operator.itemgetter('line'), results))
|
|
||||||
for section, results in
|
|
||||||
itertools.groupby(section_pairs, operator.itemgetter('section'))
|
|
||||||
}
|
|
||||||
return cls._convert_egg_info_reqs_to_simple_reqs(sections)
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def _read_sections(lines):
|
|
||||||
section = None
|
|
||||||
for line in filter(None, lines):
|
|
||||||
section_match = re.match(r'\[(.*)\]$', line)
|
|
||||||
if section_match:
|
|
||||||
section = section_match.group(1)
|
|
||||||
continue
|
|
||||||
yield locals()
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def _convert_egg_info_reqs_to_simple_reqs(sections):
|
|
||||||
"""
|
|
||||||
Historically, setuptools would solicit and store 'extra'
|
|
||||||
requirements, including those with environment markers,
|
|
||||||
in separate sections. More modern tools expect each
|
|
||||||
dependency to be defined separately, with any relevant
|
|
||||||
extras and environment markers attached directly to that
|
|
||||||
requirement. This method converts the former to the
|
|
||||||
latter. See _test_deps_from_requires_text for an example.
|
|
||||||
"""
|
|
||||||
def make_condition(name):
|
|
||||||
return name and 'extra == "{name}"'.format(name=name)
|
|
||||||
|
|
||||||
def parse_condition(section):
|
|
||||||
section = section or ''
|
|
||||||
extra, sep, markers = section.partition(':')
|
|
||||||
if extra and markers:
|
|
||||||
markers = '({markers})'.format(markers=markers)
|
|
||||||
conditions = list(filter(None, [markers, make_condition(extra)]))
|
|
||||||
return '; ' + ' and '.join(conditions) if conditions else ''
|
|
||||||
|
|
||||||
for section, deps in sections.items():
|
|
||||||
for dep in deps:
|
|
||||||
yield dep + parse_condition(section)
|
|
||||||
|
|
||||||
|
|
||||||
class DistributionFinder(MetaPathFinder):
|
|
||||||
"""
|
|
||||||
A MetaPathFinder capable of discovering installed distributions.
|
|
||||||
"""
|
|
||||||
|
|
||||||
class Context:
|
|
||||||
"""
|
|
||||||
Keyword arguments presented by the caller to
|
|
||||||
``distributions()`` or ``Distribution.discover()``
|
|
||||||
to narrow the scope of a search for distributions
|
|
||||||
in all DistributionFinders.
|
|
||||||
|
|
||||||
Each DistributionFinder may expect any parameters
|
|
||||||
and should attempt to honor the canonical
|
|
||||||
parameters defined below when appropriate.
|
|
||||||
"""
|
|
||||||
|
|
||||||
name = None
|
|
||||||
"""
|
|
||||||
Specific name for which a distribution finder should match.
|
|
||||||
A name of ``None`` matches all distributions.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, **kwargs):
|
|
||||||
vars(self).update(kwargs)
|
|
||||||
|
|
||||||
@property
|
|
||||||
def path(self):
|
|
||||||
"""
|
|
||||||
The path that a distribution finder should search.
|
|
||||||
|
|
||||||
Typically refers to Python package paths and defaults
|
|
||||||
to ``sys.path``.
|
|
||||||
"""
|
|
||||||
return vars(self).get('path', sys.path)
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def find_distributions(self, context=Context()):
|
|
||||||
"""
|
|
||||||
Find distributions.
|
|
||||||
|
|
||||||
Return an iterable of all Distribution instances capable of
|
|
||||||
loading the metadata for packages matching the ``context``,
|
|
||||||
a DistributionFinder.Context instance.
|
|
||||||
"""
|
|
||||||
|
|
||||||
|
|
||||||
class FastPath:
|
|
||||||
"""
|
|
||||||
Micro-optimized class for searching a path for
|
|
||||||
children.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, root):
|
|
||||||
self.root = str(root)
|
|
||||||
self.base = os.path.basename(self.root).lower()
|
|
||||||
|
|
||||||
def joinpath(self, child):
|
|
||||||
return pathlib.Path(self.root, child)
|
|
||||||
|
|
||||||
def children(self):
|
|
||||||
with suppress(Exception):
|
|
||||||
return os.listdir(self.root or '')
|
|
||||||
with suppress(Exception):
|
|
||||||
return self.zip_children()
|
|
||||||
return []
|
|
||||||
|
|
||||||
def zip_children(self):
|
|
||||||
zip_path = zipp.Path(self.root)
|
|
||||||
names = zip_path.root.namelist()
|
|
||||||
self.joinpath = zip_path.joinpath
|
|
||||||
|
|
||||||
return unique_ordered(
|
|
||||||
child.split(posixpath.sep, 1)[0]
|
|
||||||
for child in names
|
|
||||||
)
|
|
||||||
|
|
||||||
def search(self, name):
|
|
||||||
return (
|
|
||||||
self.joinpath(child)
|
|
||||||
for child in self.children()
|
|
||||||
if name.matches(child, self.base)
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
class Prepared:
|
|
||||||
"""
|
|
||||||
A prepared search for metadata on a possibly-named package.
|
|
||||||
"""
|
|
||||||
normalized = None
|
|
||||||
suffixes = '.dist-info', '.egg-info'
|
|
||||||
exact_matches = [''][:0]
|
|
||||||
|
|
||||||
def __init__(self, name):
|
|
||||||
self.name = name
|
|
||||||
if name is None:
|
|
||||||
return
|
|
||||||
self.normalized = self.normalize(name)
|
|
||||||
self.exact_matches = [
|
|
||||||
self.normalized + suffix for suffix in self.suffixes]
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def normalize(name):
|
|
||||||
"""
|
|
||||||
PEP 503 normalization plus dashes as underscores.
|
|
||||||
"""
|
|
||||||
return re.sub(r"[-_.]+", "-", name).lower().replace('-', '_')
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def legacy_normalize(name):
|
|
||||||
"""
|
|
||||||
Normalize the package name as found in the convention in
|
|
||||||
older packaging tools versions and specs.
|
|
||||||
"""
|
|
||||||
return name.lower().replace('-', '_')
|
|
||||||
|
|
||||||
def matches(self, cand, base):
|
|
||||||
low = cand.lower()
|
|
||||||
pre, ext = os.path.splitext(low)
|
|
||||||
name, sep, rest = pre.partition('-')
|
|
||||||
return (
|
|
||||||
low in self.exact_matches
|
|
||||||
or ext in self.suffixes and (
|
|
||||||
not self.normalized or
|
|
||||||
name.replace('.', '_') == self.normalized
|
|
||||||
)
|
|
||||||
# legacy case:
|
|
||||||
or self.is_egg(base) and low == 'egg-info'
|
|
||||||
)
|
|
||||||
|
|
||||||
def is_egg(self, base):
|
|
||||||
normalized = self.legacy_normalize(self.name or '')
|
|
||||||
prefix = normalized + '-' if normalized else ''
|
|
||||||
versionless_egg_name = normalized + '.egg' if self.name else ''
|
|
||||||
return (
|
|
||||||
base == versionless_egg_name
|
|
||||||
or base.startswith(prefix)
|
|
||||||
and base.endswith('.egg'))
|
|
||||||
|
|
||||||
|
|
||||||
@install
|
|
||||||
class MetadataPathFinder(NullFinder, DistributionFinder):
|
|
||||||
"""A degenerate finder for distribution packages on the file system.
|
|
||||||
|
|
||||||
This finder supplies only a find_distributions() method for versions
|
|
||||||
of Python that do not have a PathFinder find_distributions().
|
|
||||||
"""
|
|
||||||
|
|
||||||
def find_distributions(self, context=DistributionFinder.Context()):
|
|
||||||
"""
|
|
||||||
Find distributions.
|
|
||||||
|
|
||||||
Return an iterable of all Distribution instances capable of
|
|
||||||
loading the metadata for packages matching ``context.name``
|
|
||||||
(or all names if ``None`` indicated) along the paths in the list
|
|
||||||
of directories ``context.path``.
|
|
||||||
"""
|
|
||||||
found = self._search_paths(context.name, context.path)
|
|
||||||
return map(PathDistribution, found)
|
|
||||||
|
|
||||||
@classmethod
|
|
||||||
def _search_paths(cls, name, paths):
|
|
||||||
"""Find metadata directories in paths heuristically."""
|
|
||||||
return itertools.chain.from_iterable(
|
|
||||||
path.search(Prepared(name))
|
|
||||||
for path in map(FastPath, paths)
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
class PathDistribution(Distribution):
|
|
||||||
def __init__(self, path):
|
|
||||||
"""Construct a distribution from a path to the metadata directory.
|
|
||||||
|
|
||||||
:param path: A pathlib.Path or similar object supporting
|
|
||||||
.joinpath(), __div__, .parent, and .read_text().
|
|
||||||
"""
|
|
||||||
self._path = path
|
|
||||||
|
|
||||||
def read_text(self, filename):
|
|
||||||
with suppress(FileNotFoundError, IsADirectoryError, KeyError,
|
|
||||||
NotADirectoryError, PermissionError):
|
|
||||||
return self._path.joinpath(filename).read_text(encoding='utf-8')
|
|
||||||
read_text.__doc__ = Distribution.read_text.__doc__
|
|
||||||
|
|
||||||
def locate_file(self, path):
|
|
||||||
return self._path.parent / path
|
|
||||||
|
|
||||||
|
|
||||||
def distribution(distribution_name):
|
|
||||||
"""Get the ``Distribution`` instance for the named package.
|
|
||||||
|
|
||||||
:param distribution_name: The name of the distribution package as a string.
|
|
||||||
:return: A ``Distribution`` instance (or subclass thereof).
|
|
||||||
"""
|
|
||||||
return Distribution.from_name(distribution_name)
|
|
||||||
|
|
||||||
|
|
||||||
def distributions(**kwargs):
|
|
||||||
"""Get all ``Distribution`` instances in the current environment.
|
|
||||||
|
|
||||||
:return: An iterable of ``Distribution`` instances.
|
|
||||||
"""
|
|
||||||
return Distribution.discover(**kwargs)
|
|
||||||
|
|
||||||
|
|
||||||
def metadata(distribution_name):
|
|
||||||
"""Get the metadata for the named package.
|
|
||||||
|
|
||||||
:param distribution_name: The name of the distribution package to query.
|
|
||||||
:return: An email.Message containing the parsed metadata.
|
|
||||||
"""
|
|
||||||
return Distribution.from_name(distribution_name).metadata
|
|
||||||
|
|
||||||
|
|
||||||
def version(distribution_name):
|
|
||||||
"""Get the version string for the named package.
|
|
||||||
|
|
||||||
:param distribution_name: The name of the distribution package to query.
|
|
||||||
:return: The version string for the package as defined in the package's
|
|
||||||
"Version" metadata key.
|
|
||||||
"""
|
|
||||||
return distribution(distribution_name).version
|
|
||||||
|
|
||||||
|
|
||||||
def entry_points():
|
|
||||||
"""Return EntryPoint objects for all installed packages.
|
|
||||||
|
|
||||||
:return: EntryPoint objects for all installed packages.
|
|
||||||
"""
|
|
||||||
eps = itertools.chain.from_iterable(
|
|
||||||
dist.entry_points for dist in distributions())
|
|
||||||
by_group = operator.attrgetter('group')
|
|
||||||
ordered = sorted(eps, key=by_group)
|
|
||||||
grouped = itertools.groupby(ordered, by_group)
|
|
||||||
return {
|
|
||||||
group: tuple(eps)
|
|
||||||
for group, eps in grouped
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
def files(distribution_name):
|
|
||||||
"""Return a list of files for the named package.
|
|
||||||
|
|
||||||
:param distribution_name: The name of the distribution package to query.
|
|
||||||
:return: List of files composing the distribution.
|
|
||||||
"""
|
|
||||||
return distribution(distribution_name).files
|
|
||||||
|
|
||||||
|
|
||||||
def requires(distribution_name):
|
|
||||||
"""
|
|
||||||
Return a list of requirements for the named package.
|
|
||||||
|
|
||||||
:return: An iterator of requirements, suitable for
|
|
||||||
packaging.requirement.Requirement.
|
|
||||||
"""
|
|
||||||
return distribution(distribution_name).requires
|
|
||||||
|
|
@ -1,152 +0,0 @@
|
||||||
from __future__ import absolute_import, unicode_literals
|
|
||||||
|
|
||||||
import io
|
|
||||||
import abc
|
|
||||||
import sys
|
|
||||||
import email
|
|
||||||
|
|
||||||
|
|
||||||
if sys.version_info > (3,): # pragma: nocover
|
|
||||||
import builtins
|
|
||||||
from configparser import ConfigParser
|
|
||||||
import contextlib
|
|
||||||
FileNotFoundError = builtins.FileNotFoundError
|
|
||||||
IsADirectoryError = builtins.IsADirectoryError
|
|
||||||
NotADirectoryError = builtins.NotADirectoryError
|
|
||||||
PermissionError = builtins.PermissionError
|
|
||||||
map = builtins.map
|
|
||||||
from itertools import filterfalse
|
|
||||||
else: # pragma: nocover
|
|
||||||
from backports.configparser import ConfigParser
|
|
||||||
from itertools import imap as map # type: ignore
|
|
||||||
from itertools import ifilterfalse as filterfalse
|
|
||||||
import contextlib2 as contextlib
|
|
||||||
FileNotFoundError = IOError, OSError
|
|
||||||
IsADirectoryError = IOError, OSError
|
|
||||||
NotADirectoryError = IOError, OSError
|
|
||||||
PermissionError = IOError, OSError
|
|
||||||
|
|
||||||
str = type('')
|
|
||||||
|
|
||||||
suppress = contextlib.suppress
|
|
||||||
|
|
||||||
if sys.version_info > (3, 5): # pragma: nocover
|
|
||||||
import pathlib
|
|
||||||
else: # pragma: nocover
|
|
||||||
import pathlib2 as pathlib
|
|
||||||
|
|
||||||
try:
|
|
||||||
ModuleNotFoundError = builtins.FileNotFoundError
|
|
||||||
except (NameError, AttributeError): # pragma: nocover
|
|
||||||
ModuleNotFoundError = ImportError # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
if sys.version_info >= (3,): # pragma: nocover
|
|
||||||
from importlib.abc import MetaPathFinder
|
|
||||||
else: # pragma: nocover
|
|
||||||
class MetaPathFinder(object):
|
|
||||||
__metaclass__ = abc.ABCMeta
|
|
||||||
|
|
||||||
|
|
||||||
__metaclass__ = type
|
|
||||||
__all__ = [
|
|
||||||
'install', 'NullFinder', 'MetaPathFinder', 'ModuleNotFoundError',
|
|
||||||
'pathlib', 'ConfigParser', 'map', 'suppress', 'FileNotFoundError',
|
|
||||||
'NotADirectoryError', 'email_message_from_string',
|
|
||||||
]
|
|
||||||
|
|
||||||
|
|
||||||
def install(cls):
|
|
||||||
"""
|
|
||||||
Class decorator for installation on sys.meta_path.
|
|
||||||
|
|
||||||
Adds the backport DistributionFinder to sys.meta_path and
|
|
||||||
attempts to disable the finder functionality of the stdlib
|
|
||||||
DistributionFinder.
|
|
||||||
"""
|
|
||||||
sys.meta_path.append(cls())
|
|
||||||
disable_stdlib_finder()
|
|
||||||
return cls
|
|
||||||
|
|
||||||
|
|
||||||
def disable_stdlib_finder():
|
|
||||||
"""
|
|
||||||
Give the backport primacy for discovering path-based distributions
|
|
||||||
by monkey-patching the stdlib O_O.
|
|
||||||
|
|
||||||
See #91 for more background for rationale on this sketchy
|
|
||||||
behavior.
|
|
||||||
"""
|
|
||||||
def matches(finder):
|
|
||||||
return (
|
|
||||||
getattr(finder, '__module__', None) == '_frozen_importlib_external'
|
|
||||||
and hasattr(finder, 'find_distributions')
|
|
||||||
)
|
|
||||||
for finder in filter(matches, sys.meta_path): # pragma: nocover
|
|
||||||
del finder.find_distributions
|
|
||||||
|
|
||||||
|
|
||||||
class NullFinder:
|
|
||||||
"""
|
|
||||||
A "Finder" (aka "MetaClassFinder") that never finds any modules,
|
|
||||||
but may find distributions.
|
|
||||||
"""
|
|
||||||
@staticmethod
|
|
||||||
def find_spec(*args, **kwargs):
|
|
||||||
return None
|
|
||||||
|
|
||||||
# In Python 2, the import system requires finders
|
|
||||||
# to have a find_module() method, but this usage
|
|
||||||
# is deprecated in Python 3 in favor of find_spec().
|
|
||||||
# For the purposes of this finder (i.e. being present
|
|
||||||
# on sys.meta_path but having no other import
|
|
||||||
# system functionality), the two methods are identical.
|
|
||||||
find_module = find_spec
|
|
||||||
|
|
||||||
|
|
||||||
def py2_message_from_string(text): # nocoverpy3
|
|
||||||
# Work around https://bugs.python.org/issue25545 where
|
|
||||||
# email.message_from_string cannot handle Unicode on Python 2.
|
|
||||||
io_buffer = io.StringIO(text)
|
|
||||||
return email.message_from_file(io_buffer)
|
|
||||||
|
|
||||||
|
|
||||||
email_message_from_string = (
|
|
||||||
py2_message_from_string
|
|
||||||
if sys.version_info < (3,) else
|
|
||||||
email.message_from_string
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
class PyPy_repr:
|
|
||||||
"""
|
|
||||||
Override repr for EntryPoint objects on PyPy to avoid __iter__ access.
|
|
||||||
Ref #97, #102.
|
|
||||||
"""
|
|
||||||
affected = hasattr(sys, 'pypy_version_info')
|
|
||||||
|
|
||||||
def __compat_repr__(self): # pragma: nocover
|
|
||||||
def make_param(name):
|
|
||||||
value = getattr(self, name)
|
|
||||||
return '{name}={value!r}'.format(**locals())
|
|
||||||
params = ', '.join(map(make_param, self._fields))
|
|
||||||
return 'EntryPoint({params})'.format(**locals())
|
|
||||||
|
|
||||||
if affected: # pragma: nocover
|
|
||||||
__repr__ = __compat_repr__
|
|
||||||
del affected
|
|
||||||
|
|
||||||
|
|
||||||
# from itertools recipes
|
|
||||||
def unique_everseen(iterable): # pragma: nocover
|
|
||||||
"List unique elements, preserving order. Remember all elements ever seen."
|
|
||||||
seen = set()
|
|
||||||
seen_add = seen.add
|
|
||||||
|
|
||||||
for element in filterfalse(seen.__contains__, iterable):
|
|
||||||
seen_add(element)
|
|
||||||
yield element
|
|
||||||
|
|
||||||
|
|
||||||
unique_ordered = (
|
|
||||||
unique_everseen if sys.version_info < (3, 7) else dict.fromkeys)
|
|
||||||
|
|
@ -1,13 +0,0 @@
|
||||||
Copyright 2017-2019 Jason R. Coombs, Barry Warsaw
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
||||||
|
|
@ -1,117 +0,0 @@
|
||||||
Metadata-Version: 2.1
|
|
||||||
Name: importlib-metadata
|
|
||||||
Version: 4.6.3
|
|
||||||
Summary: Read metadata from Python packages
|
|
||||||
Home-page: https://github.com/python/importlib_metadata
|
|
||||||
Author: Jason R. Coombs
|
|
||||||
Author-email: jaraco@jaraco.com
|
|
||||||
License: UNKNOWN
|
|
||||||
Platform: UNKNOWN
|
|
||||||
Classifier: Development Status :: 5 - Production/Stable
|
|
||||||
Classifier: Intended Audience :: Developers
|
|
||||||
Classifier: License :: OSI Approved :: Apache Software License
|
|
||||||
Classifier: Programming Language :: Python :: 3
|
|
||||||
Classifier: Programming Language :: Python :: 3 :: Only
|
|
||||||
Requires-Python: >=3.6
|
|
||||||
License-File: LICENSE
|
|
||||||
Requires-Dist: zipp (>=0.5)
|
|
||||||
Requires-Dist: typing-extensions (>=3.6.4) ; python_version < "3.8"
|
|
||||||
Provides-Extra: docs
|
|
||||||
Requires-Dist: sphinx ; extra == 'docs'
|
|
||||||
Requires-Dist: jaraco.packaging (>=8.2) ; extra == 'docs'
|
|
||||||
Requires-Dist: rst.linker (>=1.9) ; extra == 'docs'
|
|
||||||
Provides-Extra: perf
|
|
||||||
Requires-Dist: ipython ; extra == 'perf'
|
|
||||||
Provides-Extra: testing
|
|
||||||
Requires-Dist: pytest (>=4.6) ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-checkdocs (>=2.4) ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-flake8 ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-cov ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-enabler (>=1.0.1) ; extra == 'testing'
|
|
||||||
Requires-Dist: packaging ; extra == 'testing'
|
|
||||||
Requires-Dist: pep517 ; extra == 'testing'
|
|
||||||
Requires-Dist: pyfakefs ; extra == 'testing'
|
|
||||||
Requires-Dist: flufl.flake8 ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-perf (>=0.9.2) ; extra == 'testing'
|
|
||||||
Requires-Dist: pytest-black (>=0.3.7) ; (platform_python_implementation != "PyPy" and python_version < "3.10") and extra == 'testing'
|
|
||||||
Requires-Dist: pytest-mypy ; (platform_python_implementation != "PyPy" and python_version < "3.10") and extra == 'testing'
|
|
||||||
Requires-Dist: importlib-resources (>=1.3) ; (python_version < "3.9") and extra == 'testing'
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/pypi/v/importlib_metadata.svg
|
|
||||||
:target: `PyPI link`_
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/pypi/pyversions/importlib_metadata.svg
|
|
||||||
:target: `PyPI link`_
|
|
||||||
|
|
||||||
.. _PyPI link: https://pypi.org/project/importlib_metadata
|
|
||||||
|
|
||||||
.. image:: https://github.com/python/importlib_metadata/workflows/tests/badge.svg
|
|
||||||
:target: https://github.com/python/importlib_metadata/actions?query=workflow%3A%22tests%22
|
|
||||||
:alt: tests
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
|
|
||||||
:target: https://github.com/psf/black
|
|
||||||
:alt: Code style: Black
|
|
||||||
|
|
||||||
.. image:: https://readthedocs.org/projects/importlib-metadata/badge/?version=latest
|
|
||||||
:target: https://importlib-metadata.readthedocs.io/en/latest/?badge=latest
|
|
||||||
|
|
||||||
.. image:: https://img.shields.io/badge/skeleton-2021-informational
|
|
||||||
:target: https://blog.jaraco.com/skeleton
|
|
||||||
|
|
||||||
|
|
||||||
Library to access the metadata for a Python package.
|
|
||||||
|
|
||||||
This package supplies third-party access to the functionality of
|
|
||||||
`importlib.metadata <https://docs.python.org/3/library/importlib.metadata.html>`_
|
|
||||||
including improvements added to subsequent Python versions.
|
|
||||||
|
|
||||||
|
|
||||||
Compatibility
|
|
||||||
=============
|
|
||||||
|
|
||||||
New features are introduced in this third-party library and later merged
|
|
||||||
into CPython. The following table indicates which versions of this library
|
|
||||||
were contributed to different versions in the standard library:
|
|
||||||
|
|
||||||
.. list-table::
|
|
||||||
:header-rows: 1
|
|
||||||
|
|
||||||
* - importlib_metadata
|
|
||||||
- stdlib
|
|
||||||
* - 4.4
|
|
||||||
- 3.10
|
|
||||||
* - 1.4
|
|
||||||
- 3.8
|
|
||||||
|
|
||||||
|
|
||||||
Usage
|
|
||||||
=====
|
|
||||||
|
|
||||||
See the `online documentation <https://importlib_metadata.readthedocs.io/>`_
|
|
||||||
for usage details.
|
|
||||||
|
|
||||||
`Finder authors
|
|
||||||
<https://docs.python.org/3/reference/import.html#finders-and-loaders>`_ can
|
|
||||||
also add support for custom package installers. See the above documentation
|
|
||||||
for details.
|
|
||||||
|
|
||||||
|
|
||||||
Caveats
|
|
||||||
=======
|
|
||||||
|
|
||||||
This project primarily supports third-party packages installed by PyPA
|
|
||||||
tools (or other conforming packages). It does not support:
|
|
||||||
|
|
||||||
- Packages in the stdlib.
|
|
||||||
- Packages installed without metadata.
|
|
||||||
|
|
||||||
Project details
|
|
||||||
===============
|
|
||||||
|
|
||||||
* Project home: https://github.com/python/importlib_metadata
|
|
||||||
* Report bugs at: https://github.com/python/importlib_metadata/issues
|
|
||||||
* Code hosting: https://github.com/python/importlib_metadata
|
|
||||||
* Documentation: https://importlib_metadata.readthedocs.io/
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,14 +0,0 @@
|
||||||
importlib_metadata/__init__.py,sha256=pHl8OPYOcUhfh23K15efpLFQOrb9Id_Jf8D5dTCYrVs,29389
|
|
||||||
importlib_metadata/_adapters.py,sha256=B6fCi5-8mLVDFUZj3krI5nAo-mKp1dH_qIavyIyFrJs,1862
|
|
||||||
importlib_metadata/_collections.py,sha256=CJ0OTCHIjWA0ZIVS4voORAsn2R4R2cQBEtPsZEJpASY,743
|
|
||||||
importlib_metadata/_compat.py,sha256=LhCNNS84sgjSRYBd5Hx8YYbgkmqSw-uzEbzwk4yURF4,2571
|
|
||||||
importlib_metadata/_functools.py,sha256=mJCTrU4JMrCndpDoqN3zbI6P9tAKU116LopceWedi1c,2501
|
|
||||||
importlib_metadata/_itertools.py,sha256=5TUj_APJHq3pvjn04hnP2oYBebP2No7HmNH_hkOGwLQ,607
|
|
||||||
importlib_metadata/_meta.py,sha256=ga8kgPmxAbf6HyJWOJzTD0uMkDo_fXwNPuwdW1HevpQ,1150
|
|
||||||
importlib_metadata/_text.py,sha256=8OAQl69ZcDQ-4cTx-RVvHw9DZh6dv3KsKJM22bfDKfk,2198
|
|
||||||
importlib_metadata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_metadata-4.6.3.dist-info/LICENSE,sha256=wNe6dAchmJ1VvVB8D9oTc-gHHadCuaSBAev36sYEM6U,571
|
|
||||||
importlib_metadata-4.6.3.dist-info/METADATA,sha256=Ve-X0Qm2lMpB70kQxtL-zrr2UezYpPnUrLeeIaHGSzM,4066
|
|
||||||
importlib_metadata-4.6.3.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
|
|
||||||
importlib_metadata-4.6.3.dist-info/top_level.txt,sha256=CO3fD9yylANiXkrMo4qHLV_mqXL2sC5JFKgt1yWAT-A,19
|
|
||||||
importlib_metadata-4.6.3.dist-info/RECORD,,
|
|
||||||
|
|
@ -1,5 +0,0 @@
|
||||||
Wheel-Version: 1.0
|
|
||||||
Generator: bdist_wheel (0.36.2)
|
|
||||||
Root-Is-Purelib: true
|
|
||||||
Tag: py3-none-any
|
|
||||||
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
importlib_metadata
|
|
||||||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -1,68 +0,0 @@
|
||||||
import re
|
|
||||||
import textwrap
|
|
||||||
import email.message
|
|
||||||
|
|
||||||
from ._text import FoldedCase
|
|
||||||
|
|
||||||
|
|
||||||
class Message(email.message.Message):
|
|
||||||
multiple_use_keys = set(
|
|
||||||
map(
|
|
||||||
FoldedCase,
|
|
||||||
[
|
|
||||||
'Classifier',
|
|
||||||
'Obsoletes-Dist',
|
|
||||||
'Platform',
|
|
||||||
'Project-URL',
|
|
||||||
'Provides-Dist',
|
|
||||||
'Provides-Extra',
|
|
||||||
'Requires-Dist',
|
|
||||||
'Requires-External',
|
|
||||||
'Supported-Platform',
|
|
||||||
'Dynamic',
|
|
||||||
],
|
|
||||||
)
|
|
||||||
)
|
|
||||||
"""
|
|
||||||
Keys that may be indicated multiple times per PEP 566.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __new__(cls, orig: email.message.Message):
|
|
||||||
res = super().__new__(cls)
|
|
||||||
vars(res).update(vars(orig))
|
|
||||||
return res
|
|
||||||
|
|
||||||
def __init__(self, *args, **kwargs):
|
|
||||||
self._headers = self._repair_headers()
|
|
||||||
|
|
||||||
# suppress spurious error from mypy
|
|
||||||
def __iter__(self):
|
|
||||||
return super().__iter__()
|
|
||||||
|
|
||||||
def _repair_headers(self):
|
|
||||||
def redent(value):
|
|
||||||
"Correct for RFC822 indentation"
|
|
||||||
if not value or '\n' not in value:
|
|
||||||
return value
|
|
||||||
return textwrap.dedent(' ' * 8 + value)
|
|
||||||
|
|
||||||
headers = [(key, redent(value)) for key, value in vars(self)['_headers']]
|
|
||||||
if self._payload:
|
|
||||||
headers.append(('Description', self.get_payload()))
|
|
||||||
return headers
|
|
||||||
|
|
||||||
@property
|
|
||||||
def json(self):
|
|
||||||
"""
|
|
||||||
Convert PackageMetadata to a JSON-compatible format
|
|
||||||
per PEP 0566.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def transform(key):
|
|
||||||
value = self.get_all(key) if key in self.multiple_use_keys else self[key]
|
|
||||||
if key == 'Keywords':
|
|
||||||
value = re.split(r'\s+', value)
|
|
||||||
tk = key.lower().replace('-', '_')
|
|
||||||
return tk, value
|
|
||||||
|
|
||||||
return dict(map(transform, map(FoldedCase, self)))
|
|
||||||
|
|
@ -1,30 +0,0 @@
|
||||||
import collections
|
|
||||||
|
|
||||||
|
|
||||||
# from jaraco.collections 3.3
|
|
||||||
class FreezableDefaultDict(collections.defaultdict):
|
|
||||||
"""
|
|
||||||
Often it is desirable to prevent the mutation of
|
|
||||||
a default dict after its initial construction, such
|
|
||||||
as to prevent mutation during iteration.
|
|
||||||
|
|
||||||
>>> dd = FreezableDefaultDict(list)
|
|
||||||
>>> dd[0].append('1')
|
|
||||||
>>> dd.freeze()
|
|
||||||
>>> dd[1]
|
|
||||||
[]
|
|
||||||
>>> len(dd)
|
|
||||||
1
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __missing__(self, key):
|
|
||||||
return getattr(self, '_frozen', super().__missing__)(key)
|
|
||||||
|
|
||||||
def freeze(self):
|
|
||||||
self._frozen = lambda key: self.default_factory()
|
|
||||||
|
|
||||||
|
|
||||||
class Pair(collections.namedtuple('Pair', 'name value')):
|
|
||||||
@classmethod
|
|
||||||
def parse(cls, text):
|
|
||||||
return cls(*map(str.strip, text.split("=", 1)))
|
|
||||||
|
|
@ -1,97 +0,0 @@
|
||||||
import sys
|
|
||||||
import platform
|
|
||||||
|
|
||||||
|
|
||||||
__all__ = ['install', 'NullFinder', 'PyPy_repr', 'Protocol']
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
from typing import Protocol
|
|
||||||
except ImportError: # pragma: no cover
|
|
||||||
"""
|
|
||||||
pytest-mypy complains here because:
|
|
||||||
error: Incompatible import of "Protocol" (imported name has type
|
|
||||||
"typing_extensions._SpecialForm", local name has type "typing._SpecialForm")
|
|
||||||
"""
|
|
||||||
from typing_extensions import Protocol # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
def install(cls):
|
|
||||||
"""
|
|
||||||
Class decorator for installation on sys.meta_path.
|
|
||||||
|
|
||||||
Adds the backport DistributionFinder to sys.meta_path and
|
|
||||||
attempts to disable the finder functionality of the stdlib
|
|
||||||
DistributionFinder.
|
|
||||||
"""
|
|
||||||
sys.meta_path.append(cls())
|
|
||||||
disable_stdlib_finder()
|
|
||||||
return cls
|
|
||||||
|
|
||||||
|
|
||||||
def disable_stdlib_finder():
|
|
||||||
"""
|
|
||||||
Give the backport primacy for discovering path-based distributions
|
|
||||||
by monkey-patching the stdlib O_O.
|
|
||||||
|
|
||||||
See #91 for more background for rationale on this sketchy
|
|
||||||
behavior.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def matches(finder):
|
|
||||||
return getattr(
|
|
||||||
finder, '__module__', None
|
|
||||||
) == '_frozen_importlib_external' and hasattr(finder, 'find_distributions')
|
|
||||||
|
|
||||||
for finder in filter(matches, sys.meta_path): # pragma: nocover
|
|
||||||
del finder.find_distributions
|
|
||||||
|
|
||||||
|
|
||||||
class NullFinder:
|
|
||||||
"""
|
|
||||||
A "Finder" (aka "MetaClassFinder") that never finds any modules,
|
|
||||||
but may find distributions.
|
|
||||||
"""
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def find_spec(*args, **kwargs):
|
|
||||||
return None
|
|
||||||
|
|
||||||
# In Python 2, the import system requires finders
|
|
||||||
# to have a find_module() method, but this usage
|
|
||||||
# is deprecated in Python 3 in favor of find_spec().
|
|
||||||
# For the purposes of this finder (i.e. being present
|
|
||||||
# on sys.meta_path but having no other import
|
|
||||||
# system functionality), the two methods are identical.
|
|
||||||
find_module = find_spec
|
|
||||||
|
|
||||||
|
|
||||||
class PyPy_repr:
|
|
||||||
"""
|
|
||||||
Override repr for EntryPoint objects on PyPy to avoid __iter__ access.
|
|
||||||
Ref #97, #102.
|
|
||||||
"""
|
|
||||||
|
|
||||||
affected = hasattr(sys, 'pypy_version_info')
|
|
||||||
|
|
||||||
def __compat_repr__(self): # pragma: nocover
|
|
||||||
def make_param(name):
|
|
||||||
value = getattr(self, name)
|
|
||||||
return f'{name}={value!r}'
|
|
||||||
|
|
||||||
params = ', '.join(map(make_param, self._fields))
|
|
||||||
return f'EntryPoint({params})'
|
|
||||||
|
|
||||||
if affected: # pragma: nocover
|
|
||||||
__repr__ = __compat_repr__
|
|
||||||
del affected
|
|
||||||
|
|
||||||
|
|
||||||
def pypy_partial(val):
|
|
||||||
"""
|
|
||||||
Adjust for variable stacklevel on partial under PyPy.
|
|
||||||
|
|
||||||
Workaround for #327.
|
|
||||||
"""
|
|
||||||
is_pypy = platform.python_implementation() == 'PyPy'
|
|
||||||
return val + is_pypy
|
|
||||||
|
|
@ -1,85 +0,0 @@
|
||||||
import types
|
|
||||||
import functools
|
|
||||||
|
|
||||||
|
|
||||||
# from jaraco.functools 3.3
|
|
||||||
def method_cache(method, cache_wrapper=None):
|
|
||||||
"""
|
|
||||||
Wrap lru_cache to support storing the cache data in the object instances.
|
|
||||||
|
|
||||||
Abstracts the common paradigm where the method explicitly saves an
|
|
||||||
underscore-prefixed protected property on first call and returns that
|
|
||||||
subsequently.
|
|
||||||
|
|
||||||
>>> class MyClass:
|
|
||||||
... calls = 0
|
|
||||||
...
|
|
||||||
... @method_cache
|
|
||||||
... def method(self, value):
|
|
||||||
... self.calls += 1
|
|
||||||
... return value
|
|
||||||
|
|
||||||
>>> a = MyClass()
|
|
||||||
>>> a.method(3)
|
|
||||||
3
|
|
||||||
>>> for x in range(75):
|
|
||||||
... res = a.method(x)
|
|
||||||
>>> a.calls
|
|
||||||
75
|
|
||||||
|
|
||||||
Note that the apparent behavior will be exactly like that of lru_cache
|
|
||||||
except that the cache is stored on each instance, so values in one
|
|
||||||
instance will not flush values from another, and when an instance is
|
|
||||||
deleted, so are the cached values for that instance.
|
|
||||||
|
|
||||||
>>> b = MyClass()
|
|
||||||
>>> for x in range(35):
|
|
||||||
... res = b.method(x)
|
|
||||||
>>> b.calls
|
|
||||||
35
|
|
||||||
>>> a.method(0)
|
|
||||||
0
|
|
||||||
>>> a.calls
|
|
||||||
75
|
|
||||||
|
|
||||||
Note that if method had been decorated with ``functools.lru_cache()``,
|
|
||||||
a.calls would have been 76 (due to the cached value of 0 having been
|
|
||||||
flushed by the 'b' instance).
|
|
||||||
|
|
||||||
Clear the cache with ``.cache_clear()``
|
|
||||||
|
|
||||||
>>> a.method.cache_clear()
|
|
||||||
|
|
||||||
Same for a method that hasn't yet been called.
|
|
||||||
|
|
||||||
>>> c = MyClass()
|
|
||||||
>>> c.method.cache_clear()
|
|
||||||
|
|
||||||
Another cache wrapper may be supplied:
|
|
||||||
|
|
||||||
>>> cache = functools.lru_cache(maxsize=2)
|
|
||||||
>>> MyClass.method2 = method_cache(lambda self: 3, cache_wrapper=cache)
|
|
||||||
>>> a = MyClass()
|
|
||||||
>>> a.method2()
|
|
||||||
3
|
|
||||||
|
|
||||||
Caution - do not subsequently wrap the method with another decorator, such
|
|
||||||
as ``@property``, which changes the semantics of the function.
|
|
||||||
|
|
||||||
See also
|
|
||||||
http://code.activestate.com/recipes/577452-a-memoize-decorator-for-instance-methods/
|
|
||||||
for another implementation and additional justification.
|
|
||||||
"""
|
|
||||||
cache_wrapper = cache_wrapper or functools.lru_cache()
|
|
||||||
|
|
||||||
def wrapper(self, *args, **kwargs):
|
|
||||||
# it's the first call, replace the method with a cached, bound method
|
|
||||||
bound_method = types.MethodType(method, self)
|
|
||||||
cached_method = cache_wrapper(bound_method)
|
|
||||||
setattr(self, method.__name__, cached_method)
|
|
||||||
return cached_method(*args, **kwargs)
|
|
||||||
|
|
||||||
# Support cache clear even before cache has been created.
|
|
||||||
wrapper.cache_clear = lambda: None
|
|
||||||
|
|
||||||
return wrapper
|
|
||||||
|
|
@ -1,19 +0,0 @@
|
||||||
from itertools import filterfalse
|
|
||||||
|
|
||||||
|
|
||||||
def unique_everseen(iterable, key=None):
|
|
||||||
"List unique elements, preserving order. Remember all elements ever seen."
|
|
||||||
# unique_everseen('AAAABBBCCDAABBB') --> A B C D
|
|
||||||
# unique_everseen('ABBCcAD', str.lower) --> A B C D
|
|
||||||
seen = set()
|
|
||||||
seen_add = seen.add
|
|
||||||
if key is None:
|
|
||||||
for element in filterfalse(seen.__contains__, iterable):
|
|
||||||
seen_add(element)
|
|
||||||
yield element
|
|
||||||
else:
|
|
||||||
for element in iterable:
|
|
||||||
k = key(element)
|
|
||||||
if k not in seen:
|
|
||||||
seen_add(k)
|
|
||||||
yield element
|
|
||||||
|
|
@ -1,48 +0,0 @@
|
||||||
from ._compat import Protocol
|
|
||||||
from typing import Any, Dict, Iterator, List, TypeVar, Union
|
|
||||||
|
|
||||||
|
|
||||||
_T = TypeVar("_T")
|
|
||||||
|
|
||||||
|
|
||||||
class PackageMetadata(Protocol):
|
|
||||||
def __len__(self) -> int:
|
|
||||||
... # pragma: no cover
|
|
||||||
|
|
||||||
def __contains__(self, item: str) -> bool:
|
|
||||||
... # pragma: no cover
|
|
||||||
|
|
||||||
def __getitem__(self, key: str) -> str:
|
|
||||||
... # pragma: no cover
|
|
||||||
|
|
||||||
def __iter__(self) -> Iterator[str]:
|
|
||||||
... # pragma: no cover
|
|
||||||
|
|
||||||
def get_all(self, name: str, failobj: _T = ...) -> Union[List[Any], _T]:
|
|
||||||
"""
|
|
||||||
Return all values associated with a possibly multi-valued key.
|
|
||||||
"""
|
|
||||||
|
|
||||||
@property
|
|
||||||
def json(self) -> Dict[str, Union[str, List[str]]]:
|
|
||||||
"""
|
|
||||||
A JSON-compatible form of the metadata.
|
|
||||||
"""
|
|
||||||
|
|
||||||
|
|
||||||
class SimplePath(Protocol):
|
|
||||||
"""
|
|
||||||
A minimal subset of pathlib.Path required by PathDistribution.
|
|
||||||
"""
|
|
||||||
|
|
||||||
def joinpath(self) -> 'SimplePath':
|
|
||||||
... # pragma: no cover
|
|
||||||
|
|
||||||
def __div__(self) -> 'SimplePath':
|
|
||||||
... # pragma: no cover
|
|
||||||
|
|
||||||
def parent(self) -> 'SimplePath':
|
|
||||||
... # pragma: no cover
|
|
||||||
|
|
||||||
def read_text(self) -> str:
|
|
||||||
... # pragma: no cover
|
|
||||||
|
|
@ -1,99 +0,0 @@
|
||||||
import re
|
|
||||||
|
|
||||||
from ._functools import method_cache
|
|
||||||
|
|
||||||
|
|
||||||
# from jaraco.text 3.5
|
|
||||||
class FoldedCase(str):
|
|
||||||
"""
|
|
||||||
A case insensitive string class; behaves just like str
|
|
||||||
except compares equal when the only variation is case.
|
|
||||||
|
|
||||||
>>> s = FoldedCase('hello world')
|
|
||||||
|
|
||||||
>>> s == 'Hello World'
|
|
||||||
True
|
|
||||||
|
|
||||||
>>> 'Hello World' == s
|
|
||||||
True
|
|
||||||
|
|
||||||
>>> s != 'Hello World'
|
|
||||||
False
|
|
||||||
|
|
||||||
>>> s.index('O')
|
|
||||||
4
|
|
||||||
|
|
||||||
>>> s.split('O')
|
|
||||||
['hell', ' w', 'rld']
|
|
||||||
|
|
||||||
>>> sorted(map(FoldedCase, ['GAMMA', 'alpha', 'Beta']))
|
|
||||||
['alpha', 'Beta', 'GAMMA']
|
|
||||||
|
|
||||||
Sequence membership is straightforward.
|
|
||||||
|
|
||||||
>>> "Hello World" in [s]
|
|
||||||
True
|
|
||||||
>>> s in ["Hello World"]
|
|
||||||
True
|
|
||||||
|
|
||||||
You may test for set inclusion, but candidate and elements
|
|
||||||
must both be folded.
|
|
||||||
|
|
||||||
>>> FoldedCase("Hello World") in {s}
|
|
||||||
True
|
|
||||||
>>> s in {FoldedCase("Hello World")}
|
|
||||||
True
|
|
||||||
|
|
||||||
String inclusion works as long as the FoldedCase object
|
|
||||||
is on the right.
|
|
||||||
|
|
||||||
>>> "hello" in FoldedCase("Hello World")
|
|
||||||
True
|
|
||||||
|
|
||||||
But not if the FoldedCase object is on the left:
|
|
||||||
|
|
||||||
>>> FoldedCase('hello') in 'Hello World'
|
|
||||||
False
|
|
||||||
|
|
||||||
In that case, use in_:
|
|
||||||
|
|
||||||
>>> FoldedCase('hello').in_('Hello World')
|
|
||||||
True
|
|
||||||
|
|
||||||
>>> FoldedCase('hello') > FoldedCase('Hello')
|
|
||||||
False
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __lt__(self, other):
|
|
||||||
return self.lower() < other.lower()
|
|
||||||
|
|
||||||
def __gt__(self, other):
|
|
||||||
return self.lower() > other.lower()
|
|
||||||
|
|
||||||
def __eq__(self, other):
|
|
||||||
return self.lower() == other.lower()
|
|
||||||
|
|
||||||
def __ne__(self, other):
|
|
||||||
return self.lower() != other.lower()
|
|
||||||
|
|
||||||
def __hash__(self):
|
|
||||||
return hash(self.lower())
|
|
||||||
|
|
||||||
def __contains__(self, other):
|
|
||||||
return super(FoldedCase, self).lower().__contains__(other.lower())
|
|
||||||
|
|
||||||
def in_(self, other):
|
|
||||||
"Does self appear in other?"
|
|
||||||
return self in FoldedCase(other)
|
|
||||||
|
|
||||||
# cache lower since it's likely to be called frequently.
|
|
||||||
@method_cache
|
|
||||||
def lower(self):
|
|
||||||
return super(FoldedCase, self).lower()
|
|
||||||
|
|
||||||
def index(self, sub):
|
|
||||||
return self.lower().index(sub.lower())
|
|
||||||
|
|
||||||
def split(self, splitter=' ', maxsplit=0):
|
|
||||||
pattern = re.compile(re.escape(splitter), re.I)
|
|
||||||
return pattern.split(self, maxsplit)
|
|
||||||
|
|
@ -1,13 +0,0 @@
|
||||||
Copyright 2017-2019 Brett Cannon, Barry Warsaw
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
||||||
|
|
@ -1,41 +0,0 @@
|
||||||
Metadata-Version: 2.1
|
|
||||||
Name: importlib-resources
|
|
||||||
Version: 3.2.1
|
|
||||||
Summary: Read resources from Python packages
|
|
||||||
Home-page: https://github.com/python/importlib_resources
|
|
||||||
Author: Barry Warsaw
|
|
||||||
Author-email: barry@python.org
|
|
||||||
License: UNKNOWN
|
|
||||||
Project-URL: Documentation, https://importlib-resources.readthedocs.io/
|
|
||||||
Platform: UNKNOWN
|
|
||||||
Classifier: Development Status :: 5 - Production/Stable
|
|
||||||
Classifier: Intended Audience :: Developers
|
|
||||||
Classifier: License :: OSI Approved :: Apache Software License
|
|
||||||
Classifier: Topic :: Software Development :: Libraries
|
|
||||||
Classifier: Programming Language :: Python :: 2.7
|
|
||||||
Classifier: Programming Language :: Python :: 3
|
|
||||||
Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7
|
|
||||||
Requires-Dist: pathlib2 ; python_version < "3"
|
|
||||||
Requires-Dist: contextlib2 ; python_version < "3"
|
|
||||||
Requires-Dist: singledispatch ; python_version < "3.4"
|
|
||||||
Requires-Dist: typing ; python_version < "3.5"
|
|
||||||
Requires-Dist: zipp (>=0.4) ; python_version < "3.8"
|
|
||||||
Provides-Extra: docs
|
|
||||||
Requires-Dist: sphinx ; extra == 'docs'
|
|
||||||
Requires-Dist: rst.linker ; extra == 'docs'
|
|
||||||
Requires-Dist: jaraco.packaging ; extra == 'docs'
|
|
||||||
|
|
||||||
``importlib_resources`` is a backport of Python standard library
|
|
||||||
`importlib.resources
|
|
||||||
<https://docs.python.org/3.9/library/importlib.html#module-importlib.resources>`_
|
|
||||||
module for Python 2.7, and 3.4 through 3.8. Users of Python 3.9 and beyond
|
|
||||||
should use the standard library module, since for these versions,
|
|
||||||
``importlib_resources`` just delegates to that module.
|
|
||||||
|
|
||||||
The key goal of this module is to replace parts of `pkg_resources
|
|
||||||
<https://setuptools.readthedocs.io/en/latest/pkg_resources.html>`_ with a
|
|
||||||
solution in Python's stdlib that relies on well-defined APIs. This makes
|
|
||||||
reading resources included in packages easier, with more stable and consistent
|
|
||||||
semantics.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,42 +0,0 @@
|
||||||
importlib_resources/__init__.py,sha256=hswDmLAH0IUlLWwmdHXPN2mgus2bk5IwDP-BFzg7VKo,977
|
|
||||||
importlib_resources/_common.py,sha256=RN8cXOZtlygvlbyTewd-ni9wC1hwXpfbZnrl7kbx0nI,3121
|
|
||||||
importlib_resources/_compat.py,sha256=NDCXOf1097aDJJx-_pQ0UIktzVx2G1aPIQTRFGx0FHI,3694
|
|
||||||
importlib_resources/_py2.py,sha256=G9M5mv1ILl8NARGdNX0v9_F_Hb4HUKCS-FCNK63Ajvw,4146
|
|
||||||
importlib_resources/_py3.py,sha256=5_FhUUHWFG1c3HcLrmDy65ZFB7EYxmHfOV3ybv4uTHM,5710
|
|
||||||
importlib_resources/abc.py,sha256=6PX4Nprv39YnAht3NymhHIuSso0ocAKqDJZf-A6BgIw,3894
|
|
||||||
importlib_resources/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/readers.py,sha256=fGuSBoMeeERUVrscN9Grhp0s-wKMy7nMVbCx92vIlGs,3674
|
|
||||||
importlib_resources/trees.py,sha256=U3FlQSI5--eF4AdzOjBvW4xnjL21OFX8ivk82Quwv_M,117
|
|
||||||
importlib_resources/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/_compat.py,sha256=geKWJe8UGXjC181JxmtxR3A_o5VrR4yxolS0xbnxMlw,801
|
|
||||||
importlib_resources/tests/py27compat.py,sha256=9lDJkGV2swPVQJg6isOorRNFWuP6KeoWd4D2bFNmzLI,965
|
|
||||||
importlib_resources/tests/test_files.py,sha256=91rf4C74_aJsKNSt-a-03slVpY9QSAuCbogFWnsaPjE,1017
|
|
||||||
importlib_resources/tests/test_open.py,sha256=pIYWvuTDpQOJKX0SEuOKGotssZcEeY_xNPDqLGCvP_U,2565
|
|
||||||
importlib_resources/tests/test_path.py,sha256=GnUOu-338o9offnC8xwbXjH9JIQJpD7JujgQkGB106Q,1548
|
|
||||||
importlib_resources/tests/test_read.py,sha256=DpA7tzxSQlU0_YQuWibB3E5PDL9fQUdzeKoEUGnAx78,2046
|
|
||||||
importlib_resources/tests/test_reader.py,sha256=yEO0xyrYDcGRmsBC6A1n99GXiTZpVvp-uGA313s6aao,4638
|
|
||||||
importlib_resources/tests/test_resource.py,sha256=GbrMeHJ74N6KJG38TDodCp--nsRnFHXJc7NrAEqUPaU,8766
|
|
||||||
importlib_resources/tests/util.py,sha256=8hBFwqIZRJFNvkboEB7aWsCqTtgUjlWI_iQ0KV158Yk,5914
|
|
||||||
importlib_resources/tests/data01/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/data01/binary.file,sha256=BU7ewdAhH2JP7Qy8qdT5QAsOSRxDdCryxbCr6_DJkNg,4
|
|
||||||
importlib_resources/tests/data01/utf-16.file,sha256=t5q9qhxX0rYqItBOM8D3ylwG-RHrnOYteTLtQr6sF7g,44
|
|
||||||
importlib_resources/tests/data01/utf-8.file,sha256=kwWgYG4yQ-ZF2X_WA66EjYPmxJRn-w8aSOiS9e8tKYY,20
|
|
||||||
importlib_resources/tests/data01/subdirectory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/data01/subdirectory/binary.file,sha256=BU7ewdAhH2JP7Qy8qdT5QAsOSRxDdCryxbCr6_DJkNg,4
|
|
||||||
importlib_resources/tests/data02/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/data02/one/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/data02/one/resource1.txt,sha256=10flKac7c-XXFzJ3t-AB5MJjlBy__dSZvPE_dOm2q6U,13
|
|
||||||
importlib_resources/tests/data02/two/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/data02/two/resource2.txt,sha256=lt2jbN3TMn9QiFKM832X39bU_62UptDdUkoYzkvEbl0,13
|
|
||||||
importlib_resources/tests/namespacedata01/binary.file,sha256=BU7ewdAhH2JP7Qy8qdT5QAsOSRxDdCryxbCr6_DJkNg,4
|
|
||||||
importlib_resources/tests/namespacedata01/utf-16.file,sha256=t5q9qhxX0rYqItBOM8D3ylwG-RHrnOYteTLtQr6sF7g,44
|
|
||||||
importlib_resources/tests/namespacedata01/utf-8.file,sha256=kwWgYG4yQ-ZF2X_WA66EjYPmxJRn-w8aSOiS9e8tKYY,20
|
|
||||||
importlib_resources/tests/zipdata01/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/zipdata01/ziptestdata.zip,sha256=AYf51fj80OKCRis93v2DlZjt5rM-VQOPptSHJbFtkXw,1131
|
|
||||||
importlib_resources/tests/zipdata02/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/zipdata02/ziptestdata.zip,sha256=e6HXvTEObXvJcNxyX5I8tu5M8_6mSN8ALahHfqE7ADA,698
|
|
||||||
importlib_resources-3.2.1.dist-info/LICENSE,sha256=uWRjFdYGataJX2ziXk048ItUglQmjng3GWBALaWA36U,568
|
|
||||||
importlib_resources-3.2.1.dist-info/METADATA,sha256=d_tMNLHsZ_lPU-wq04MWr0yEfpwbNFKgfO_CU5GCC9g,1783
|
|
||||||
importlib_resources-3.2.1.dist-info/WHEEL,sha256=ADKeyaGyKF5DwBNE0sRE5pvW-bSkFMJfBuhzZ3rceP4,110
|
|
||||||
importlib_resources-3.2.1.dist-info/top_level.txt,sha256=fHIjHU1GZwAjvcydpmUnUrTnbvdiWjG4OEVZK8by0TQ,20
|
|
||||||
importlib_resources-3.2.1.dist-info/RECORD,,
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
Wheel-Version: 1.0
|
|
||||||
Generator: bdist_wheel (0.35.1)
|
|
||||||
Root-Is-Purelib: true
|
|
||||||
Tag: py2-none-any
|
|
||||||
Tag: py3-none-any
|
|
||||||
|
|
||||||
|
|
@ -1 +0,0 @@
|
||||||
importlib_resources
|
|
||||||
|
|
@ -1,53 +0,0 @@
|
||||||
"""Read resources contained within a package."""
|
|
||||||
|
|
||||||
import sys
|
|
||||||
|
|
||||||
from ._common import (
|
|
||||||
as_file, files,
|
|
||||||
)
|
|
||||||
|
|
||||||
# For compatibility. Ref #88.
|
|
||||||
# Also requires hook-importlib_resources.py (Ref #101).
|
|
||||||
__import__('importlib_resources.trees')
|
|
||||||
|
|
||||||
|
|
||||||
__all__ = [
|
|
||||||
'Package',
|
|
||||||
'Resource',
|
|
||||||
'ResourceReader',
|
|
||||||
'as_file',
|
|
||||||
'contents',
|
|
||||||
'files',
|
|
||||||
'is_resource',
|
|
||||||
'open_binary',
|
|
||||||
'open_text',
|
|
||||||
'path',
|
|
||||||
'read_binary',
|
|
||||||
'read_text',
|
|
||||||
]
|
|
||||||
|
|
||||||
|
|
||||||
if sys.version_info >= (3,):
|
|
||||||
from importlib_resources._py3 import (
|
|
||||||
Package,
|
|
||||||
Resource,
|
|
||||||
contents,
|
|
||||||
is_resource,
|
|
||||||
open_binary,
|
|
||||||
open_text,
|
|
||||||
path,
|
|
||||||
read_binary,
|
|
||||||
read_text,
|
|
||||||
)
|
|
||||||
from importlib_resources.abc import ResourceReader
|
|
||||||
else:
|
|
||||||
from importlib_resources._py2 import (
|
|
||||||
contents,
|
|
||||||
is_resource,
|
|
||||||
open_binary,
|
|
||||||
open_text,
|
|
||||||
path,
|
|
||||||
read_binary,
|
|
||||||
read_text,
|
|
||||||
)
|
|
||||||
del __all__[:3]
|
|
||||||
|
|
@ -1,120 +0,0 @@
|
||||||
from __future__ import absolute_import
|
|
||||||
|
|
||||||
import os
|
|
||||||
import tempfile
|
|
||||||
import contextlib
|
|
||||||
import types
|
|
||||||
import importlib
|
|
||||||
|
|
||||||
from ._compat import (
|
|
||||||
Path, FileNotFoundError,
|
|
||||||
singledispatch, package_spec,
|
|
||||||
)
|
|
||||||
|
|
||||||
if False: # TYPE_CHECKING
|
|
||||||
from typing import Union, Any, Optional
|
|
||||||
from .abc import ResourceReader
|
|
||||||
Package = Union[types.ModuleType, str]
|
|
||||||
|
|
||||||
|
|
||||||
def files(package):
|
|
||||||
"""
|
|
||||||
Get a Traversable resource from a package
|
|
||||||
"""
|
|
||||||
return from_package(get_package(package))
|
|
||||||
|
|
||||||
|
|
||||||
def normalize_path(path):
|
|
||||||
# type: (Any) -> str
|
|
||||||
"""Normalize a path by ensuring it is a string.
|
|
||||||
|
|
||||||
If the resulting string contains path separators, an exception is raised.
|
|
||||||
"""
|
|
||||||
str_path = str(path)
|
|
||||||
parent, file_name = os.path.split(str_path)
|
|
||||||
if parent:
|
|
||||||
raise ValueError('{!r} must be only a file name'.format(path))
|
|
||||||
return file_name
|
|
||||||
|
|
||||||
|
|
||||||
def get_resource_reader(package):
|
|
||||||
# type: (types.ModuleType) -> Optional[ResourceReader]
|
|
||||||
"""
|
|
||||||
Return the package's loader if it's a ResourceReader.
|
|
||||||
"""
|
|
||||||
# We can't use
|
|
||||||
# a issubclass() check here because apparently abc.'s __subclasscheck__()
|
|
||||||
# hook wants to create a weak reference to the object, but
|
|
||||||
# zipimport.zipimporter does not support weak references, resulting in a
|
|
||||||
# TypeError. That seems terrible.
|
|
||||||
spec = package.__spec__
|
|
||||||
reader = getattr(spec.loader, 'get_resource_reader', None)
|
|
||||||
if reader is None:
|
|
||||||
return None
|
|
||||||
return reader(spec.name)
|
|
||||||
|
|
||||||
|
|
||||||
def resolve(cand):
|
|
||||||
# type: (Package) -> types.ModuleType
|
|
||||||
return (
|
|
||||||
cand if isinstance(cand, types.ModuleType)
|
|
||||||
else importlib.import_module(cand)
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
def get_package(package):
|
|
||||||
# type: (Package) -> types.ModuleType
|
|
||||||
"""Take a package name or module object and return the module.
|
|
||||||
|
|
||||||
Raise an exception if the resolved module is not a package.
|
|
||||||
"""
|
|
||||||
resolved = resolve(package)
|
|
||||||
if package_spec(resolved).submodule_search_locations is None:
|
|
||||||
raise TypeError('{!r} is not a package'.format(package))
|
|
||||||
return resolved
|
|
||||||
|
|
||||||
|
|
||||||
def from_package(package):
|
|
||||||
"""
|
|
||||||
Return a Traversable object for the given package.
|
|
||||||
|
|
||||||
"""
|
|
||||||
spec = package_spec(package)
|
|
||||||
reader = spec.loader.get_resource_reader(spec.name)
|
|
||||||
return reader.files()
|
|
||||||
|
|
||||||
|
|
||||||
@contextlib.contextmanager
|
|
||||||
def _tempfile(reader, suffix=''):
|
|
||||||
# Not using tempfile.NamedTemporaryFile as it leads to deeper 'try'
|
|
||||||
# blocks due to the need to close the temporary file to work on Windows
|
|
||||||
# properly.
|
|
||||||
fd, raw_path = tempfile.mkstemp(suffix=suffix)
|
|
||||||
try:
|
|
||||||
os.write(fd, reader())
|
|
||||||
os.close(fd)
|
|
||||||
del reader
|
|
||||||
yield Path(raw_path)
|
|
||||||
finally:
|
|
||||||
try:
|
|
||||||
os.remove(raw_path)
|
|
||||||
except FileNotFoundError:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
@singledispatch
|
|
||||||
def as_file(path):
|
|
||||||
"""
|
|
||||||
Given a Traversable object, return that object as a
|
|
||||||
path on the local file system in a context manager.
|
|
||||||
"""
|
|
||||||
return _tempfile(path.read_bytes, suffix=path.name)
|
|
||||||
|
|
||||||
|
|
||||||
@as_file.register(Path)
|
|
||||||
@contextlib.contextmanager
|
|
||||||
def _(path):
|
|
||||||
"""
|
|
||||||
Degenerate behavior for pathlib.Path objects.
|
|
||||||
"""
|
|
||||||
yield path
|
|
||||||
|
|
@ -1,139 +0,0 @@
|
||||||
from __future__ import absolute_import
|
|
||||||
import sys
|
|
||||||
|
|
||||||
# flake8: noqa
|
|
||||||
|
|
||||||
if sys.version_info > (3,5):
|
|
||||||
from pathlib import Path, PurePath
|
|
||||||
else:
|
|
||||||
from pathlib2 import Path, PurePath # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
if sys.version_info > (3,):
|
|
||||||
from contextlib import suppress
|
|
||||||
else:
|
|
||||||
from contextlib2 import suppress # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
from functools import singledispatch
|
|
||||||
except ImportError:
|
|
||||||
from singledispatch import singledispatch # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
from abc import ABC # type: ignore
|
|
||||||
except ImportError:
|
|
||||||
from abc import ABCMeta
|
|
||||||
|
|
||||||
class ABC(object): # type: ignore
|
|
||||||
__metaclass__ = ABCMeta
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
FileNotFoundError = FileNotFoundError # type: ignore
|
|
||||||
except NameError:
|
|
||||||
FileNotFoundError = OSError # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
NotADirectoryError = NotADirectoryError # type: ignore
|
|
||||||
except NameError:
|
|
||||||
NotADirectoryError = OSError # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
from zipfile import Path as ZipPath # type: ignore
|
|
||||||
except ImportError:
|
|
||||||
from zipp import Path as ZipPath # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
from typing import runtime_checkable # type: ignore
|
|
||||||
except ImportError:
|
|
||||||
def runtime_checkable(cls): # type: ignore
|
|
||||||
return cls
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
from typing import Protocol # type: ignore
|
|
||||||
except ImportError:
|
|
||||||
Protocol = ABC # type: ignore
|
|
||||||
|
|
||||||
|
|
||||||
__metaclass__ = type
|
|
||||||
|
|
||||||
|
|
||||||
class PackageSpec:
|
|
||||||
def __init__(self, **kwargs):
|
|
||||||
vars(self).update(kwargs)
|
|
||||||
|
|
||||||
|
|
||||||
class TraversableResourcesAdapter:
|
|
||||||
def __init__(self, spec):
|
|
||||||
self.spec = spec
|
|
||||||
self.loader = LoaderAdapter(spec)
|
|
||||||
|
|
||||||
def __getattr__(self, name):
|
|
||||||
return getattr(self.spec, name)
|
|
||||||
|
|
||||||
|
|
||||||
class LoaderAdapter:
|
|
||||||
"""
|
|
||||||
Adapt loaders to provide TraversableResources and other
|
|
||||||
compatibility.
|
|
||||||
"""
|
|
||||||
def __init__(self, spec):
|
|
||||||
self.spec = spec
|
|
||||||
|
|
||||||
@property
|
|
||||||
def path(self):
|
|
||||||
# Python < 3
|
|
||||||
return self.spec.origin
|
|
||||||
|
|
||||||
def get_resource_reader(self, name):
|
|
||||||
# Python < 3.9
|
|
||||||
from . import readers
|
|
||||||
|
|
||||||
def _zip_reader(spec):
|
|
||||||
with suppress(AttributeError):
|
|
||||||
return readers.ZipReader(spec.loader, spec.name)
|
|
||||||
|
|
||||||
def _namespace_reader(spec):
|
|
||||||
with suppress(AttributeError, ValueError):
|
|
||||||
return readers.NamespaceReader(spec.submodule_search_locations)
|
|
||||||
|
|
||||||
def _available_reader(spec):
|
|
||||||
with suppress(AttributeError):
|
|
||||||
return spec.loader.get_resource_reader(spec.name)
|
|
||||||
|
|
||||||
def _native_reader(spec):
|
|
||||||
reader = _available_reader(spec)
|
|
||||||
return reader if hasattr(reader, 'files') else None
|
|
||||||
|
|
||||||
return (
|
|
||||||
# native reader if it supplies 'files'
|
|
||||||
_native_reader(self.spec) or
|
|
||||||
# local ZipReader if a zip module
|
|
||||||
_zip_reader(self.spec) or
|
|
||||||
# local NamespaceReader if a namespace module
|
|
||||||
_namespace_reader(self.spec) or
|
|
||||||
# local FileReader
|
|
||||||
readers.FileReader(self)
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
def package_spec(package):
|
|
||||||
"""
|
|
||||||
Construct a minimal package spec suitable for
|
|
||||||
matching the interfaces this library relies upon
|
|
||||||
in later Python versions.
|
|
||||||
"""
|
|
||||||
spec = getattr(package, '__spec__', None) or \
|
|
||||||
PackageSpec(
|
|
||||||
origin=package.__file__,
|
|
||||||
loader=getattr(package, '__loader__', None),
|
|
||||||
name=package.__name__,
|
|
||||||
submodule_search_locations=getattr(package, '__path__', None),
|
|
||||||
)
|
|
||||||
return TraversableResourcesAdapter(spec)
|
|
||||||
|
|
@ -1,107 +0,0 @@
|
||||||
import os
|
|
||||||
import errno
|
|
||||||
|
|
||||||
from . import _common
|
|
||||||
from ._compat import FileNotFoundError
|
|
||||||
from io import BytesIO, TextIOWrapper, open as io_open
|
|
||||||
|
|
||||||
|
|
||||||
def open_binary(package, resource):
|
|
||||||
"""Return a file-like object opened for binary reading of the resource."""
|
|
||||||
resource = _common.normalize_path(resource)
|
|
||||||
package = _common.get_package(package)
|
|
||||||
# Using pathlib doesn't work well here due to the lack of 'strict' argument
|
|
||||||
# for pathlib.Path.resolve() prior to Python 3.6.
|
|
||||||
package_path = os.path.dirname(package.__file__)
|
|
||||||
relative_path = os.path.join(package_path, resource)
|
|
||||||
full_path = os.path.abspath(relative_path)
|
|
||||||
try:
|
|
||||||
return io_open(full_path, 'rb')
|
|
||||||
except IOError:
|
|
||||||
# This might be a package in a zip file. zipimport provides a loader
|
|
||||||
# with a functioning get_data() method, however we have to strip the
|
|
||||||
# archive (i.e. the .zip file's name) off the front of the path. This
|
|
||||||
# is because the zipimport loader in Python 2 doesn't actually follow
|
|
||||||
# PEP 302. It should allow the full path, but actually requires that
|
|
||||||
# the path be relative to the zip file.
|
|
||||||
try:
|
|
||||||
loader = package.__loader__
|
|
||||||
full_path = relative_path[len(loader.archive)+1:]
|
|
||||||
data = loader.get_data(full_path)
|
|
||||||
except (IOError, AttributeError):
|
|
||||||
package_name = package.__name__
|
|
||||||
message = '{!r} resource not found in {!r}'.format(
|
|
||||||
resource, package_name)
|
|
||||||
raise FileNotFoundError(message)
|
|
||||||
return BytesIO(data)
|
|
||||||
|
|
||||||
|
|
||||||
def open_text(package, resource, encoding='utf-8', errors='strict'):
|
|
||||||
"""Return a file-like object opened for text reading of the resource."""
|
|
||||||
return TextIOWrapper(
|
|
||||||
open_binary(package, resource), encoding=encoding, errors=errors)
|
|
||||||
|
|
||||||
|
|
||||||
def read_binary(package, resource):
|
|
||||||
"""Return the binary contents of the resource."""
|
|
||||||
with open_binary(package, resource) as fp:
|
|
||||||
return fp.read()
|
|
||||||
|
|
||||||
|
|
||||||
def read_text(package, resource, encoding='utf-8', errors='strict'):
|
|
||||||
"""Return the decoded string of the resource.
|
|
||||||
|
|
||||||
The decoding-related arguments have the same semantics as those of
|
|
||||||
bytes.decode().
|
|
||||||
"""
|
|
||||||
with open_text(package, resource, encoding, errors) as fp:
|
|
||||||
return fp.read()
|
|
||||||
|
|
||||||
|
|
||||||
def path(package, resource):
|
|
||||||
"""A context manager providing a file path object to the resource.
|
|
||||||
|
|
||||||
If the resource does not already exist on its own on the file system,
|
|
||||||
a temporary file will be created. If the file was created, the file
|
|
||||||
will be deleted upon exiting the context manager (no exception is
|
|
||||||
raised if the file was deleted prior to the context manager
|
|
||||||
exiting).
|
|
||||||
"""
|
|
||||||
path = _common.files(package).joinpath(_common.normalize_path(resource))
|
|
||||||
if not path.is_file():
|
|
||||||
raise FileNotFoundError(path)
|
|
||||||
return _common.as_file(path)
|
|
||||||
|
|
||||||
|
|
||||||
def is_resource(package, name):
|
|
||||||
"""True if name is a resource inside package.
|
|
||||||
|
|
||||||
Directories are *not* resources.
|
|
||||||
"""
|
|
||||||
package = _common.get_package(package)
|
|
||||||
_common.normalize_path(name)
|
|
||||||
try:
|
|
||||||
package_contents = set(contents(package))
|
|
||||||
except OSError as error:
|
|
||||||
if error.errno not in (errno.ENOENT, errno.ENOTDIR):
|
|
||||||
# We won't hit this in the Python 2 tests, so it'll appear
|
|
||||||
# uncovered. We could mock os.listdir() to return a non-ENOENT or
|
|
||||||
# ENOTDIR, but then we'd have to depend on another external
|
|
||||||
# library since Python 2 doesn't have unittest.mock. It's not
|
|
||||||
# worth it.
|
|
||||||
raise # pragma: nocover
|
|
||||||
return False
|
|
||||||
if name not in package_contents:
|
|
||||||
return False
|
|
||||||
return (_common.from_package(package) / name).is_file()
|
|
||||||
|
|
||||||
|
|
||||||
def contents(package):
|
|
||||||
"""Return an iterable of entries in `package`.
|
|
||||||
|
|
||||||
Note that not all entries are resources. Specifically, directories are
|
|
||||||
not considered resources. Use `is_resource()` on each entry returned here
|
|
||||||
to check if it is a resource or not.
|
|
||||||
"""
|
|
||||||
package = _common.get_package(package)
|
|
||||||
return list(item.name for item in _common.from_package(package).iterdir())
|
|
||||||
|
|
@ -1,164 +0,0 @@
|
||||||
import os
|
|
||||||
import sys
|
|
||||||
import io
|
|
||||||
|
|
||||||
from . import _common
|
|
||||||
from contextlib import suppress
|
|
||||||
from importlib.abc import ResourceLoader
|
|
||||||
from io import BytesIO, TextIOWrapper
|
|
||||||
from pathlib import Path
|
|
||||||
from types import ModuleType
|
|
||||||
from typing import Iterable, Iterator, Optional, Set, Union # noqa: F401
|
|
||||||
from typing import cast
|
|
||||||
from typing.io import BinaryIO, TextIO
|
|
||||||
from collections.abc import Sequence
|
|
||||||
from ._compat import singledispatch
|
|
||||||
|
|
||||||
if False: # TYPE_CHECKING
|
|
||||||
from typing import ContextManager
|
|
||||||
|
|
||||||
Package = Union[ModuleType, str]
|
|
||||||
if sys.version_info >= (3, 6):
|
|
||||||
Resource = Union[str, os.PathLike] # pragma: <=35
|
|
||||||
else:
|
|
||||||
Resource = str # pragma: >=36
|
|
||||||
|
|
||||||
|
|
||||||
def open_binary(package: Package, resource: Resource) -> BinaryIO:
|
|
||||||
"""Return a file-like object opened for binary reading of the resource."""
|
|
||||||
resource = _common.normalize_path(resource)
|
|
||||||
package = _common.get_package(package)
|
|
||||||
reader = _common.get_resource_reader(package)
|
|
||||||
if reader is not None:
|
|
||||||
return reader.open_resource(resource)
|
|
||||||
# Using pathlib doesn't work well here due to the lack of 'strict'
|
|
||||||
# argument for pathlib.Path.resolve() prior to Python 3.6.
|
|
||||||
if package.__spec__.submodule_search_locations is not None:
|
|
||||||
paths = package.__spec__.submodule_search_locations
|
|
||||||
elif package.__spec__.origin is not None:
|
|
||||||
paths = [os.path.dirname(os.path.abspath(package.__spec__.origin))]
|
|
||||||
|
|
||||||
for package_path in paths:
|
|
||||||
full_path = os.path.join(package_path, resource)
|
|
||||||
try:
|
|
||||||
return open(full_path, mode='rb')
|
|
||||||
except OSError:
|
|
||||||
# Just assume the loader is a resource loader; all the relevant
|
|
||||||
# importlib.machinery loaders are and an AttributeError for
|
|
||||||
# get_data() will make it clear what is needed from the loader.
|
|
||||||
loader = cast(ResourceLoader, package.__spec__.loader)
|
|
||||||
data = None
|
|
||||||
if hasattr(package.__spec__.loader, 'get_data'):
|
|
||||||
with suppress(OSError):
|
|
||||||
data = loader.get_data(full_path)
|
|
||||||
if data is not None:
|
|
||||||
return BytesIO(data)
|
|
||||||
|
|
||||||
raise FileNotFoundError('{!r} resource not found in {!r}'.format(
|
|
||||||
resource, package.__spec__.name))
|
|
||||||
|
|
||||||
|
|
||||||
def open_text(package: Package,
|
|
||||||
resource: Resource,
|
|
||||||
encoding: str = 'utf-8',
|
|
||||||
errors: str = 'strict') -> TextIO:
|
|
||||||
"""Return a file-like object opened for text reading of the resource."""
|
|
||||||
return TextIOWrapper(
|
|
||||||
open_binary(package, resource), encoding=encoding, errors=errors)
|
|
||||||
|
|
||||||
|
|
||||||
def read_binary(package: Package, resource: Resource) -> bytes:
|
|
||||||
"""Return the binary contents of the resource."""
|
|
||||||
with open_binary(package, resource) as fp:
|
|
||||||
return fp.read()
|
|
||||||
|
|
||||||
|
|
||||||
def read_text(package: Package,
|
|
||||||
resource: Resource,
|
|
||||||
encoding: str = 'utf-8',
|
|
||||||
errors: str = 'strict') -> str:
|
|
||||||
"""Return the decoded string of the resource.
|
|
||||||
|
|
||||||
The decoding-related arguments have the same semantics as those of
|
|
||||||
bytes.decode().
|
|
||||||
"""
|
|
||||||
with open_text(package, resource, encoding, errors) as fp:
|
|
||||||
return fp.read()
|
|
||||||
|
|
||||||
|
|
||||||
def path(
|
|
||||||
package: Package, resource: Resource,
|
|
||||||
) -> 'ContextManager[Path]':
|
|
||||||
"""A context manager providing a file path object to the resource.
|
|
||||||
|
|
||||||
If the resource does not already exist on its own on the file system,
|
|
||||||
a temporary file will be created. If the file was created, the file
|
|
||||||
will be deleted upon exiting the context manager (no exception is
|
|
||||||
raised if the file was deleted prior to the context manager
|
|
||||||
exiting).
|
|
||||||
"""
|
|
||||||
reader = _common.get_resource_reader(_common.get_package(package))
|
|
||||||
return (
|
|
||||||
_path_from_reader(reader, _common.normalize_path(resource))
|
|
||||||
if reader else
|
|
||||||
_common.as_file(
|
|
||||||
_common.files(package).joinpath(_common.normalize_path(resource)))
|
|
||||||
)
|
|
||||||
|
|
||||||
|
|
||||||
def _path_from_reader(reader, resource):
|
|
||||||
return _path_from_resource_path(reader, resource) or \
|
|
||||||
_path_from_open_resource(reader, resource)
|
|
||||||
|
|
||||||
|
|
||||||
def _path_from_resource_path(reader, resource):
|
|
||||||
with suppress(FileNotFoundError):
|
|
||||||
return Path(reader.resource_path(resource))
|
|
||||||
|
|
||||||
|
|
||||||
def _path_from_open_resource(reader, resource):
|
|
||||||
saved = io.BytesIO(reader.open_resource(resource).read())
|
|
||||||
return _common._tempfile(saved.read, suffix=resource)
|
|
||||||
|
|
||||||
|
|
||||||
def is_resource(package: Package, name: str) -> bool:
|
|
||||||
"""True if `name` is a resource inside `package`.
|
|
||||||
|
|
||||||
Directories are *not* resources.
|
|
||||||
"""
|
|
||||||
package = _common.get_package(package)
|
|
||||||
_common.normalize_path(name)
|
|
||||||
reader = _common.get_resource_reader(package)
|
|
||||||
if reader is not None:
|
|
||||||
return reader.is_resource(name)
|
|
||||||
package_contents = set(contents(package))
|
|
||||||
if name not in package_contents:
|
|
||||||
return False
|
|
||||||
return (_common.from_package(package) / name).is_file()
|
|
||||||
|
|
||||||
|
|
||||||
def contents(package: Package) -> Iterable[str]:
|
|
||||||
"""Return an iterable of entries in `package`.
|
|
||||||
|
|
||||||
Note that not all entries are resources. Specifically, directories are
|
|
||||||
not considered resources. Use `is_resource()` on each entry returned here
|
|
||||||
to check if it is a resource or not.
|
|
||||||
"""
|
|
||||||
package = _common.get_package(package)
|
|
||||||
reader = _common.get_resource_reader(package)
|
|
||||||
if reader is not None:
|
|
||||||
return _ensure_sequence(reader.contents())
|
|
||||||
transversable = _common.from_package(package)
|
|
||||||
if transversable.is_dir():
|
|
||||||
return list(item.name for item in transversable.iterdir())
|
|
||||||
return []
|
|
||||||
|
|
||||||
|
|
||||||
@singledispatch
|
|
||||||
def _ensure_sequence(iterable):
|
|
||||||
return list(iterable)
|
|
||||||
|
|
||||||
|
|
||||||
@_ensure_sequence.register(Sequence)
|
|
||||||
def _(iterable):
|
|
||||||
return iterable
|
|
||||||
|
|
@ -1,142 +0,0 @@
|
||||||
from __future__ import absolute_import
|
|
||||||
|
|
||||||
import abc
|
|
||||||
|
|
||||||
from ._compat import ABC, FileNotFoundError, runtime_checkable, Protocol
|
|
||||||
|
|
||||||
# Use mypy's comment syntax for Python 2 compatibility
|
|
||||||
try:
|
|
||||||
from typing import BinaryIO, Iterable, Text
|
|
||||||
except ImportError:
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class ResourceReader(ABC):
|
|
||||||
"""Abstract base class for loaders to provide resource reading support."""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def open_resource(self, resource):
|
|
||||||
# type: (Text) -> BinaryIO
|
|
||||||
"""Return an opened, file-like object for binary reading.
|
|
||||||
|
|
||||||
The 'resource' argument is expected to represent only a file name.
|
|
||||||
If the resource cannot be found, FileNotFoundError is raised.
|
|
||||||
"""
|
|
||||||
# This deliberately raises FileNotFoundError instead of
|
|
||||||
# NotImplementedError so that if this method is accidentally called,
|
|
||||||
# it'll still do the right thing.
|
|
||||||
raise FileNotFoundError
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def resource_path(self, resource):
|
|
||||||
# type: (Text) -> Text
|
|
||||||
"""Return the file system path to the specified resource.
|
|
||||||
|
|
||||||
The 'resource' argument is expected to represent only a file name.
|
|
||||||
If the resource does not exist on the file system, raise
|
|
||||||
FileNotFoundError.
|
|
||||||
"""
|
|
||||||
# This deliberately raises FileNotFoundError instead of
|
|
||||||
# NotImplementedError so that if this method is accidentally called,
|
|
||||||
# it'll still do the right thing.
|
|
||||||
raise FileNotFoundError
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def is_resource(self, path):
|
|
||||||
# type: (Text) -> bool
|
|
||||||
"""Return True if the named 'path' is a resource.
|
|
||||||
|
|
||||||
Files are resources, directories are not.
|
|
||||||
"""
|
|
||||||
raise FileNotFoundError
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def contents(self):
|
|
||||||
# type: () -> Iterable[str]
|
|
||||||
"""Return an iterable of entries in `package`."""
|
|
||||||
raise FileNotFoundError
|
|
||||||
|
|
||||||
|
|
||||||
@runtime_checkable
|
|
||||||
class Traversable(Protocol):
|
|
||||||
"""
|
|
||||||
An object with a subset of pathlib.Path methods suitable for
|
|
||||||
traversing directories and opening files.
|
|
||||||
"""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def iterdir(self):
|
|
||||||
"""
|
|
||||||
Yield Traversable objects in self
|
|
||||||
"""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def read_bytes(self):
|
|
||||||
"""
|
|
||||||
Read contents of self as bytes
|
|
||||||
"""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def read_text(self, encoding=None):
|
|
||||||
"""
|
|
||||||
Read contents of self as bytes
|
|
||||||
"""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def is_dir(self):
|
|
||||||
"""
|
|
||||||
Return True if self is a dir
|
|
||||||
"""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def is_file(self):
|
|
||||||
"""
|
|
||||||
Return True if self is a file
|
|
||||||
"""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def joinpath(self, child):
|
|
||||||
"""
|
|
||||||
Return Traversable child in self
|
|
||||||
"""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def __truediv__(self, child):
|
|
||||||
"""
|
|
||||||
Return Traversable child in self
|
|
||||||
"""
|
|
||||||
|
|
||||||
@abc.abstractmethod
|
|
||||||
def open(self, mode='r', *args, **kwargs):
|
|
||||||
"""
|
|
||||||
mode may be 'r' or 'rb' to open as text or binary. Return a handle
|
|
||||||
suitable for reading (same as pathlib.Path.open).
|
|
||||||
|
|
||||||
When opening as text, accepts encoding parameters such as those
|
|
||||||
accepted by io.TextIOWrapper.
|
|
||||||
"""
|
|
||||||
|
|
||||||
@abc.abstractproperty
|
|
||||||
def name(self):
|
|
||||||
# type: () -> str
|
|
||||||
"""
|
|
||||||
The base name of this object without any parent references.
|
|
||||||
"""
|
|
||||||
|
|
||||||
|
|
||||||
class TraversableResources(ResourceReader):
|
|
||||||
@abc.abstractmethod
|
|
||||||
def files(self):
|
|
||||||
"""Return a Traversable object for the loaded package."""
|
|
||||||
|
|
||||||
def open_resource(self, resource):
|
|
||||||
return self.files().joinpath(resource).open('rb')
|
|
||||||
|
|
||||||
def resource_path(self, resource):
|
|
||||||
raise FileNotFoundError(resource)
|
|
||||||
|
|
||||||
def is_resource(self, path):
|
|
||||||
return self.files().joinpath(path).is_file()
|
|
||||||
|
|
||||||
def contents(self):
|
|
||||||
return (item.name for item in self.files().iterdir())
|
|
||||||
|
|
@ -1,123 +0,0 @@
|
||||||
import os.path
|
|
||||||
|
|
||||||
from collections import OrderedDict
|
|
||||||
|
|
||||||
from . import abc
|
|
||||||
|
|
||||||
from ._compat import Path, ZipPath
|
|
||||||
from ._compat import FileNotFoundError, NotADirectoryError
|
|
||||||
|
|
||||||
|
|
||||||
class FileReader(abc.TraversableResources):
|
|
||||||
def __init__(self, loader):
|
|
||||||
self.path = Path(loader.path).parent
|
|
||||||
|
|
||||||
def resource_path(self, resource):
|
|
||||||
"""
|
|
||||||
Return the file system path to prevent
|
|
||||||
`resources.path()` from creating a temporary
|
|
||||||
copy.
|
|
||||||
"""
|
|
||||||
return str(self.path.joinpath(resource))
|
|
||||||
|
|
||||||
def files(self):
|
|
||||||
return self.path
|
|
||||||
|
|
||||||
|
|
||||||
class ZipReader(abc.TraversableResources):
|
|
||||||
def __init__(self, loader, module):
|
|
||||||
_, _, name = module.rpartition('.')
|
|
||||||
self.prefix = loader.prefix.replace('\\', '/') + name + '/'
|
|
||||||
self.archive = loader.archive
|
|
||||||
|
|
||||||
def open_resource(self, resource):
|
|
||||||
try:
|
|
||||||
return super().open_resource(resource)
|
|
||||||
except KeyError as exc:
|
|
||||||
raise FileNotFoundError(exc.args[0])
|
|
||||||
|
|
||||||
def is_resource(self, path):
|
|
||||||
# workaround for `zipfile.Path.is_file` returning true
|
|
||||||
# for non-existent paths.
|
|
||||||
target = self.files().joinpath(path)
|
|
||||||
return target.is_file() and target.exists()
|
|
||||||
|
|
||||||
def files(self):
|
|
||||||
return ZipPath(self.archive, self.prefix)
|
|
||||||
|
|
||||||
|
|
||||||
class MultiplexedPath(abc.Traversable):
|
|
||||||
"""
|
|
||||||
Given a series of Traversable objects, implement a merged
|
|
||||||
version of the interface across all objects. Useful for
|
|
||||||
namespace packages which may be multihomed at a single
|
|
||||||
name.
|
|
||||||
"""
|
|
||||||
def __init__(self, *paths):
|
|
||||||
paths = list(OrderedDict.fromkeys(paths)) # remove duplicates
|
|
||||||
self._paths = list(map(Path, paths))
|
|
||||||
if not self._paths:
|
|
||||||
message = 'MultiplexedPath must contain at least one path'
|
|
||||||
raise FileNotFoundError(message)
|
|
||||||
if any(not path.is_dir() for path in self._paths):
|
|
||||||
raise NotADirectoryError(
|
|
||||||
'MultiplexedPath only supports directories')
|
|
||||||
|
|
||||||
def iterdir(self):
|
|
||||||
visited = []
|
|
||||||
for path in self._paths:
|
|
||||||
for file in path.iterdir():
|
|
||||||
if file.name in visited:
|
|
||||||
continue
|
|
||||||
visited.append(file.name)
|
|
||||||
yield file
|
|
||||||
|
|
||||||
def read_bytes(self):
|
|
||||||
raise FileNotFoundError('{} is not a file'.format(self))
|
|
||||||
|
|
||||||
def read_text(self, *args, **kwargs):
|
|
||||||
raise FileNotFoundError('{} is not a file'.format(self))
|
|
||||||
|
|
||||||
def is_dir(self):
|
|
||||||
return True
|
|
||||||
|
|
||||||
def is_file(self):
|
|
||||||
return False
|
|
||||||
|
|
||||||
def joinpath(self, child):
|
|
||||||
# first try to find child in current paths
|
|
||||||
for file in self.iterdir():
|
|
||||||
if file.name == child:
|
|
||||||
return file
|
|
||||||
# if it does not exist, construct it with the first path
|
|
||||||
return self._paths[0] / child
|
|
||||||
|
|
||||||
__truediv__ = joinpath
|
|
||||||
|
|
||||||
def open(self, *args, **kwargs):
|
|
||||||
raise FileNotFoundError('{} is not a file'.format(self))
|
|
||||||
|
|
||||||
def name(self):
|
|
||||||
return os.path.basename(self._paths[0])
|
|
||||||
|
|
||||||
def __repr__(self):
|
|
||||||
return 'MultiplexedPath({})'.format(
|
|
||||||
', '.join("'{}'".format(path) for path in self._paths))
|
|
||||||
|
|
||||||
|
|
||||||
class NamespaceReader(abc.TraversableResources):
|
|
||||||
def __init__(self, namespace_path):
|
|
||||||
if 'NamespacePath' not in str(namespace_path):
|
|
||||||
raise ValueError('Invalid path')
|
|
||||||
self.path = MultiplexedPath(*list(namespace_path))
|
|
||||||
|
|
||||||
def resource_path(self, resource):
|
|
||||||
"""
|
|
||||||
Return the file system path to prevent
|
|
||||||
`resources.path()` from creating a temporary
|
|
||||||
copy.
|
|
||||||
"""
|
|
||||||
return str(self.path.joinpath(resource))
|
|
||||||
|
|
||||||
def files(self):
|
|
||||||
return self.path
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
# for compatibility with 1.1, continue to expose as_file here.
|
|
||||||
|
|
||||||
from ._common import as_file
|
|
||||||
|
|
||||||
|
|
||||||
__all__ = ['as_file']
|
|
||||||
|
|
@ -1,13 +0,0 @@
|
||||||
Copyright 2017-2019 Brett Cannon, Barry Warsaw
|
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
you may not use this file except in compliance with the License.
|
|
||||||
You may obtain a copy of the License at
|
|
||||||
|
|
||||||
http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
|
|
||||||
Unless required by applicable law or agreed to in writing, software
|
|
||||||
distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
See the License for the specific language governing permissions and
|
|
||||||
limitations under the License.
|
|
||||||
|
|
@ -1,41 +0,0 @@
|
||||||
Metadata-Version: 2.1
|
|
||||||
Name: importlib-resources
|
|
||||||
Version: 3.3.1
|
|
||||||
Summary: Read resources from Python packages
|
|
||||||
Home-page: https://github.com/python/importlib_resources
|
|
||||||
Author: Barry Warsaw
|
|
||||||
Author-email: barry@python.org
|
|
||||||
License: UNKNOWN
|
|
||||||
Project-URL: Documentation, https://importlib-resources.readthedocs.io/
|
|
||||||
Platform: UNKNOWN
|
|
||||||
Classifier: Development Status :: 5 - Production/Stable
|
|
||||||
Classifier: Intended Audience :: Developers
|
|
||||||
Classifier: License :: OSI Approved :: Apache Software License
|
|
||||||
Classifier: Topic :: Software Development :: Libraries
|
|
||||||
Classifier: Programming Language :: Python :: 2.7
|
|
||||||
Classifier: Programming Language :: Python :: 3
|
|
||||||
Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7
|
|
||||||
Requires-Dist: pathlib2 ; python_version < "3"
|
|
||||||
Requires-Dist: contextlib2 ; python_version < "3"
|
|
||||||
Requires-Dist: singledispatch ; python_version < "3.4"
|
|
||||||
Requires-Dist: typing ; python_version < "3.5"
|
|
||||||
Requires-Dist: zipp (>=0.4) ; python_version < "3.8"
|
|
||||||
Provides-Extra: docs
|
|
||||||
Requires-Dist: sphinx ; extra == 'docs'
|
|
||||||
Requires-Dist: rst.linker ; extra == 'docs'
|
|
||||||
Requires-Dist: jaraco.packaging ; extra == 'docs'
|
|
||||||
|
|
||||||
``importlib_resources`` is a backport of Python standard library
|
|
||||||
`importlib.resources
|
|
||||||
<https://docs.python.org/3.9/library/importlib.html#module-importlib.resources>`_
|
|
||||||
module for Python 2.7, and 3.6 through 3.8. Users of Python 3.9 and beyond
|
|
||||||
should use the standard library module, since for these versions,
|
|
||||||
``importlib_resources`` just delegates to that module.
|
|
||||||
|
|
||||||
The key goal of this module is to replace parts of `pkg_resources
|
|
||||||
<https://setuptools.readthedocs.io/en/latest/pkg_resources.html>`_ with a
|
|
||||||
solution in Python's stdlib that relies on well-defined APIs. This makes
|
|
||||||
reading resources included in packages easier, with more stable and consistent
|
|
||||||
semantics.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -1,42 +0,0 @@
|
||||||
importlib_resources/__init__.py,sha256=hswDmLAH0IUlLWwmdHXPN2mgus2bk5IwDP-BFzg7VKo,977
|
|
||||||
importlib_resources/_common.py,sha256=RN8cXOZtlygvlbyTewd-ni9wC1hwXpfbZnrl7kbx0nI,3121
|
|
||||||
importlib_resources/_compat.py,sha256=NDCXOf1097aDJJx-_pQ0UIktzVx2G1aPIQTRFGx0FHI,3694
|
|
||||||
importlib_resources/_py2.py,sha256=G9M5mv1ILl8NARGdNX0v9_F_Hb4HUKCS-FCNK63Ajvw,4146
|
|
||||||
importlib_resources/_py3.py,sha256=Bc-p0UYfPVWXFJ21HLNfVvbVrPJFXBA0g80rqPInkq8,5564
|
|
||||||
importlib_resources/abc.py,sha256=6PX4Nprv39YnAht3NymhHIuSso0ocAKqDJZf-A6BgIw,3894
|
|
||||||
importlib_resources/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/readers.py,sha256=fGuSBoMeeERUVrscN9Grhp0s-wKMy7nMVbCx92vIlGs,3674
|
|
||||||
importlib_resources/trees.py,sha256=U3FlQSI5--eF4AdzOjBvW4xnjL21OFX8ivk82Quwv_M,117
|
|
||||||
importlib_resources/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/_compat.py,sha256=geKWJe8UGXjC181JxmtxR3A_o5VrR4yxolS0xbnxMlw,801
|
|
||||||
importlib_resources/tests/py27compat.py,sha256=9lDJkGV2swPVQJg6isOorRNFWuP6KeoWd4D2bFNmzLI,965
|
|
||||||
importlib_resources/tests/test_files.py,sha256=91rf4C74_aJsKNSt-a-03slVpY9QSAuCbogFWnsaPjE,1017
|
|
||||||
importlib_resources/tests/test_open.py,sha256=pIYWvuTDpQOJKX0SEuOKGotssZcEeY_xNPDqLGCvP_U,2565
|
|
||||||
importlib_resources/tests/test_path.py,sha256=GnUOu-338o9offnC8xwbXjH9JIQJpD7JujgQkGB106Q,1548
|
|
||||||
importlib_resources/tests/test_read.py,sha256=DpA7tzxSQlU0_YQuWibB3E5PDL9fQUdzeKoEUGnAx78,2046
|
|
||||||
importlib_resources/tests/test_reader.py,sha256=yEO0xyrYDcGRmsBC6A1n99GXiTZpVvp-uGA313s6aao,4638
|
|
||||||
importlib_resources/tests/test_resource.py,sha256=GbrMeHJ74N6KJG38TDodCp--nsRnFHXJc7NrAEqUPaU,8766
|
|
||||||
importlib_resources/tests/util.py,sha256=8hBFwqIZRJFNvkboEB7aWsCqTtgUjlWI_iQ0KV158Yk,5914
|
|
||||||
importlib_resources/tests/data01/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/data01/binary.file,sha256=BU7ewdAhH2JP7Qy8qdT5QAsOSRxDdCryxbCr6_DJkNg,4
|
|
||||||
importlib_resources/tests/data01/utf-16.file,sha256=t5q9qhxX0rYqItBOM8D3ylwG-RHrnOYteTLtQr6sF7g,44
|
|
||||||
importlib_resources/tests/data01/utf-8.file,sha256=kwWgYG4yQ-ZF2X_WA66EjYPmxJRn-w8aSOiS9e8tKYY,20
|
|
||||||
importlib_resources/tests/data01/subdirectory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/data01/subdirectory/binary.file,sha256=BU7ewdAhH2JP7Qy8qdT5QAsOSRxDdCryxbCr6_DJkNg,4
|
|
||||||
importlib_resources/tests/data02/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/data02/one/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/data02/one/resource1.txt,sha256=10flKac7c-XXFzJ3t-AB5MJjlBy__dSZvPE_dOm2q6U,13
|
|
||||||
importlib_resources/tests/data02/two/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/data02/two/resource2.txt,sha256=lt2jbN3TMn9QiFKM832X39bU_62UptDdUkoYzkvEbl0,13
|
|
||||||
importlib_resources/tests/namespacedata01/binary.file,sha256=BU7ewdAhH2JP7Qy8qdT5QAsOSRxDdCryxbCr6_DJkNg,4
|
|
||||||
importlib_resources/tests/namespacedata01/utf-16.file,sha256=t5q9qhxX0rYqItBOM8D3ylwG-RHrnOYteTLtQr6sF7g,44
|
|
||||||
importlib_resources/tests/namespacedata01/utf-8.file,sha256=kwWgYG4yQ-ZF2X_WA66EjYPmxJRn-w8aSOiS9e8tKYY,20
|
|
||||||
importlib_resources/tests/zipdata01/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/zipdata01/ziptestdata.zip,sha256=AYf51fj80OKCRis93v2DlZjt5rM-VQOPptSHJbFtkXw,1131
|
|
||||||
importlib_resources/tests/zipdata02/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
||||||
importlib_resources/tests/zipdata02/ziptestdata.zip,sha256=e6HXvTEObXvJcNxyX5I8tu5M8_6mSN8ALahHfqE7ADA,698
|
|
||||||
importlib_resources-3.3.1.dist-info/LICENSE,sha256=uWRjFdYGataJX2ziXk048ItUglQmjng3GWBALaWA36U,568
|
|
||||||
importlib_resources-3.3.1.dist-info/METADATA,sha256=ulI0eHuldtC-h2_WiQal2AE2eoE91x_xKzbz9kpWvlk,1791
|
|
||||||
importlib_resources-3.3.1.dist-info/WHEEL,sha256=oh0NKYrTcu1i1-wgrI1cnhkjYIi8WJ-8qd9Jrr5_y4E,110
|
|
||||||
importlib_resources-3.3.1.dist-info/top_level.txt,sha256=fHIjHU1GZwAjvcydpmUnUrTnbvdiWjG4OEVZK8by0TQ,20
|
|
||||||
importlib_resources-3.3.1.dist-info/RECORD,,
|
|
||||||
|
|
@ -1,6 +0,0 @@
|
||||||
Wheel-Version: 1.0
|
|
||||||
Generator: bdist_wheel (0.36.1)
|
|
||||||
Root-Is-Purelib: true
|
|
||||||
Tag: py2-none-any
|
|
||||||
Tag: py3-none-any
|
|
||||||
|
|
||||||
Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше
Загрузка…
Ссылка в новой задаче