def monkeypatch_pkg_resources():
"""
There is a bug in pkg_resources ZipProvider, so fix it.
Filed https://bitbucket.org/tarek/distribute/issue/274
"""
import pkg_resources
_EggMetadata = pkg_resources.EggMetadata
def normalized_elements(path):
path_split = path.split('/')
while path_split[-1] in ('', '.'):
path_split.pop(-1)
return path_split
class EggMetadata(_EggMetadata):
def __init__(self, *args, **kw):
_EggMetadata.__init__(self, *args, **kw)
def _fn(self, base, resource_name):
return '/'.join(normalized_elements(_EggMetadata._fn(self, base, resource_name)))
def _zipinfo_name(self, fspath):
fspath = normalized_elements(fspath)
zip_pre = normalized_elements(self.zip_pre)
if fspath[:len(zip_pre)] == zip_pre:
return '/'.join(fspath[len(zip_pre):])
raise AssertionError(
"%s is not a subpath of %s" % (fspath, self.zip_pre)
)
# TODO(wickman) Send pull request to setuptools to allow registering a factory for
# zipfile.ZipFile
def build_zipmanifest(path):
zipinfo = dict()
def contents_as_zipfile(path):
new_zf = zipfile.ZipFile(StringIO(Nested.read(path)))
new_zf.filename = path
return new_zf
zfile = contents_as_zipfile(path)
try:
for zitem in zfile.namelist():
zpath = zitem.replace('/', os.sep)
zipinfo[zpath] = zfile.getinfo(zitem)
assert zipinfo[zpath] is not None
finally:
zfile.close()
return zipinfo
pkg_resources.zipimport = sys.modules[__name__] # if monkeypatching after import
pkg_resources.build_zipmanifest = build_zipmanifest
pkg_resources.EggMetadata = EggMetadata
try:
pkg_resources.register_finder(EggZipImporter, pkg_resources.find_in_zip)
except AttributeError:
# setuptools 2.1+ move find_in_zip to find_eggs_in_zip to make it clear this does not
# do wheels.
pkg_resources.register_finder(EggZipImporter, pkg_resources.find_eggs_in_zip)
pkg_resources.register_namespace_handler(EggZipImporter, pkg_resources.file_ns_handler)
pkg_resources.register_loader_type(EggZipImporter, pkg_resources.ZipProvider)
def _register_with_pkg_resources(cls):
"""
Ensure package resources can be loaded from this loader. May be called
multiple times, as the operation is idempotent.
"""
try:
import pkg_resources
# access an attribute in case a deferred importer is present
pkg_resources.__name__
except ImportError:
return
# Since pytest tests are always located in the file system, the
# DefaultProvider is appropriate.
pkg_resources.register_loader_type(cls, pkg_resources.DefaultProvider)
def install():
"""
This installs a hook into setuptools' pkg_resources infrastructure, so that resource
files can be found in files relative to the runnin executable, in addition to the
usual egg and source lookup mechanisms. This overrides the ZipProvider, since that
is the lookup mechanism triggered within pkg_resources when running code out of a
py2exe or py2app build's library.zip.
"""
import os, sys
import pkg_resources, zipimport
platform_libdirs = {
'darwin': '../Resources/pkg_resources',
}
exedir = os.path.dirname(sys.executable)
libdir = platform_libdirs.get(sys.platform, 'pkg_resources')
class Provider(pkg_resources.ZipProvider):
def __init__(self, module):
self._module_name = module.__name__
pkg_resources.ZipProvider.__init__(self, module)
def get_resource_filename(self, manager, resource_name):
#print 'get_resource_filename(%s, %s)' % (manager, resource_name)
path = [exedir, libdir] + self._module_name.split('.') + [resource_name]
localfile = os.path.join(*path)
#print ' checking(%s)' % (localfile,)
if os.path.exists(localfile):
#print 'found locally'
return localfile
else:
try:
ret = pkg_resources.ZipProvider.get_resource_filename(self, manager, resource_name)
#print 'returning %s' % (ret,)
return ret
except NotImplementedError:
#print 'get_resource_filename(%s,%s): not found' % (self._module_name, resource_name)
#import traceback
#traceback.print_exc()
return ''
pkg_resources.register_loader_type(zipimport.zipimporter, Provider)
def __init__(self, package, pkg_resources=pkg_resources):
loader = self._real_loader = getattr(package, '__loader__', None)
if isinstance(loader, self.__class__):
self._real_loader = None
# We register ourselves as a __loader__ *only* to support the
# setuptools _find_adapter adapter lookup; this class doesn't
# actually support the PEP 302 loader "API". This is
# excusable due to the following statement in the spec:
# ... Loader objects are not
# required to offer any useful functionality (any such functionality,
# such as the zipimport get_data() method mentioned above, is
# optional)...
# A __loader__ attribute is basically metadata, and setuptools
# uses it as such.
package.__loader__ = self
# we call register_loader_type for every instantiation of this
# class; that's OK, it's idempotent to do it more than once.
pkg_resources.register_loader_type(self.__class__, OverrideProvider)
self.overrides = []
self.overridden_package_name = package.__name__
def monkeypatch_pkg_resources():
"""
There is a bug in pkg_resources ZipProvider, so fix it.
Filed https://bitbucket.org/tarek/distribute/issue/274
"""
import pkg_resources
_EggMetadata = pkg_resources.EggMetadata
def normalized_elements(path):
path_split = path.split('/')
while path_split[-1] in ('', '.'):
path_split.pop(-1)
return path_split
class EggMetadata(_EggMetadata):
def __init__(self, *args, **kw):
_EggMetadata.__init__(self, *args, **kw)
def _fn(self, base, resource_name):
return '/'.join(normalized_elements(_EggMetadata._fn(self, base, resource_name)))
def _zipinfo_name(self, fspath):
fspath = normalized_elements(fspath)
zip_pre = normalized_elements(self.zip_pre)
if fspath[:len(zip_pre)] == zip_pre:
return '/'.join(fspath[len(zip_pre):])
raise AssertionError(
"%s is not a subpath of %s" % (fspath, self.zip_pre)
)
pkg_resources.zipimport = sys.modules[__name__] # if monkeypatching after import
pkg_resources.EggMetadata = EggMetadata
pkg_resources.register_finder(EggZipImporter, pkg_resources.find_in_zip)
pkg_resources.register_namespace_handler(EggZipImporter, pkg_resources.file_ns_handler)
pkg_resources.register_loader_type(EggZipImporter, pkg_resources.ZipProvider)
# Embedded resources have precedence over filesystem...
rel_path = path.relative_to(SYS_PREFIX)
node = self.embedded_tree._get_tree_node(rel_path)
if node is None:
return path.is_dir() # No match found; try the filesystem
else:
# str = file, dict = directory
return not isinstance(node, str)
def _listdir(self, path):
# Prevent access outside the package
path = self._normalize_path(path)
if not self._is_relative_to_package(path):
return []
# Relative path for searching embedded resources
rel_path = path.relative_to(SYS_PREFIX)
# List content from embedded filesystem...
content = self.embedded_tree.path_listdir(rel_path)
# ... as well as the actual one
if path.is_dir():
# Use os.listdir() to avoid having to convert Path objects
# to strings... Also make sure to de-duplicate the results
path = str(path) # not is_py36
content = list(set(content + os.listdir(path)))
return content
pkg_resources.register_loader_type(FrozenImporter, PyiFrozenProvider)
# both base and alias should be in sys.modules to handle recursive and
# corecursive situations
sys.modules[odoo_name] = sys.modules[openerp_name] = new_mod
# execute source in context of module *after* putting everything in
# sys.modules, so recursive import works
execfile(modfile, new_mod.__dict__)
# people import openerp.addons and expect openerp.addons.<module> to work
setattr(odoo.addons, addon_name, new_mod)
return sys.modules[name]
# need to register loader with setuptools as Jinja relies on it when using
# PackageLoader
pkg_resources.register_loader_type(AddonsHook, pkg_resources.DefaultProvider)
class OdooHook(object):
""" Makes odoo package also available as openerp """
def find_module(self, name, path=None):
# openerp.addons.<identifier> should already be matched by AddonsHook,
# only framework and subdirectories of modules should match
if re.match(r'^openerp\b', name):
return self
def load_module(self, name):
assert name not in sys.modules
canonical = re.sub(r'^openerp(.*)', r'odoo\g<1>', name)
# fix sys path to include dists
import sys
import os
sys.path.insert(0, 'distlib')
# register gae loader for pkg_resources
if os.environ.get('SERVER_SOFTWARE', 'Development')[0:11] == "Development":
from google.appengine.tools.dev_appserver_import_hook import \
HardenedModulesHook
from pkg_resources import register_loader_type, DefaultProvider
register_loader_type(HardenedModulesHook, DefaultProvider)
# disable chameleon debug module loader, gae does not allow tempdirs
import chameleon.template
from chameleon.loader import MemoryLoader
chameleon.template._make_module_loader = MemoryLoader
chameleon.template.BaseTemplate.loader = MemoryLoader()
just registers some helper functions with the pkg_resources machinery.
You must import this module before using pkg_resources when signed imports
are in use.
"""
import sys
import signedimp
if "pkg_resources" in sys.modules:
pkg_resources = sys.modules["pkg_resources"]
else:
import pkg_resources
_find_adapter = pkg_resources._find_adapter
_provider_factories = pkg_resources._provider_factories
DefaultProvider = pkg_resources.DefaultProvider
def _get_provider(mod):
"""Get the pkg_resources provider appropriate for the given loader.
This basically calls back into the pkg_resources machinery to find the
provider for the wrapper loader, and just returns that.
"""
return _find_adapter(_provider_factories,mod.__loader__.loader)(mod)
pkg_resources.register_loader_type(signedimp.SignedLoader,_get_provider)
pkg_resources.register_loader_type(signedimp.DefaultImporter,DefaultProvider)
just registers some helper functions with the pkg_resources machinery.
You must import this module before using pkg_resources when signed imports
are in use.
"""
import sys
import signedimp
if "pkg_resources" in sys.modules:
pkg_resources = sys.modules["pkg_resources"]
else:
import pkg_resources
_find_adapter = pkg_resources._find_adapter
_provider_factories = pkg_resources._provider_factories
DefaultProvider = pkg_resources.DefaultProvider
def _get_provider(mod):
"""Get the pkg_resources provider appropriate for the given loader.
This basically calls back into the pkg_resources machinery to find the
provider for the wrapper loader, and just returns that.
"""
return _find_adapter(_provider_factories, mod.__loader__.loader)(mod)
pkg_resources.register_loader_type(signedimp.SignedLoader, _get_provider)
pkg_resources.register_loader_type(signedimp.DefaultImporter, DefaultProvider)
#----------------------------------------------------------------------------- # Copyright (c) 2013-2018, PyInstaller Development Team. # # Distributed under the terms of the GNU General Public License with exception # for distributing bootloader. # # The full license is in the file COPYING.txt, distributed with this software. #----------------------------------------------------------------------------- import pkg_resources as res from pyimod03_importers import FrozenImporter # To make pkg_resources work with froze moduels we need to set the 'Provider' # class for FrozenImporter. This class decides where to look for resources # and other stuff. 'pkg_resources.NullProvider' is dedicated to PEP302 # import hooks like FrozenImporter is. It uses method __loader__.get_data() in # methods pkg_resources.resource_string() and pkg_resources.resource_stream() res.register_loader_type(FrozenImporter, res.NullProvider)
# Again for Mac and pkg_resources:
@patch(os)
def uname():
return ("AppEngine", "appengine-host", "0.0.0", "#1", "i386")
try:
import pkg_resources
except ImportError:
pass
else:
if hasattr(os, "__loader__"):
# This only seems to apply to the SDK
pkg_resources.register_loader_type(type(os.__loader__), pkg_resources.DefaultProvider)
def get_file_dir(*parts):
file_dir = os.path.dirname(__file__)
if os.path.exists(os.path.join(file_dir, "appengine_monkey_files")):
file_dir = os.path.join(file_dir, "appengine_monkey_files")
if parts:
file_dir = os.path.join(file_dir, *parts)
return file_dir
def patch_modules():
"""
Adds the module-replacements/ directory to the start of sys.path, and removes any modules that
have already been loaded that instead should be loaded from module-replacements/
# both base and alias should be in sys.modules to handle recursive and
# corecursive situations
sys.modules[odoo_name] = sys.modules[openerp_name] = new_mod
# execute source in context of module *after* putting everything in
# sys.modules, so recursive import works
exec(open(modfile, 'rb').read(), new_mod.__dict__)
# people import openerp.addons and expect openerp.addons.<module> to work
setattr(odoo.addons, addon_name, new_mod)
return sys.modules[name]
# need to register loader with setuptools as Jinja relies on it when using
# PackageLoader
pkg_resources.register_loader_type(AddonsHook, pkg_resources.DefaultProvider)
class OdooHook(object):
""" Makes odoo package also available as openerp """
def find_module(self, name, path=None):
# openerp.addons.<identifier> should already be matched by AddonsHook,
# only framework and subdirectories of modules should match
if re.match(r'^openerp\b', name):
return self
def load_module(self, name):
assert name not in sys.modules
canonical = re.sub(r'^openerp(.*)', r'odoo\g<1>', name)
def monkeypatch_pkg_resources():
"""
There is a bug in pkg_resources ZipProvider, so fix it.
Filed https://bitbucket.org/tarek/distribute/issue/274
"""
import pkg_resources
_EggMetadata = pkg_resources.EggMetadata
def normalized_elements(path):
path_split = path.split('/')
while path_split[-1] in ('', '.'):
path_split.pop(-1)
return path_split
class EggMetadata(_EggMetadata):
def __init__(self, *args, **kw):
_EggMetadata.__init__(self, *args, **kw)
def _fn(self, base, resource_name):
return '/'.join(
normalized_elements(_EggMetadata._fn(self, base,
resource_name)))
def _zipinfo_name(self, fspath):
fspath = normalized_elements(fspath)
zip_pre = normalized_elements(self.zip_pre)
if fspath[:len(zip_pre)] == zip_pre:
return '/'.join(fspath[len(zip_pre):])
raise AssertionError("%s is not a subpath of %s" %
(fspath, self.zip_pre))
# TODO(wickman) Send pull request to setuptools to allow registering a factory for
# zipfile.ZipFile
def build_zipmanifest(path):
zipinfo = dict()
def contents_as_zipfile(path):
new_zf = zipfile.ZipFile(StringIO(Nested.read(path)))
new_zf.filename = path
return new_zf
zfile = contents_as_zipfile(path)
try:
for zitem in zfile.namelist():
zpath = zitem.replace('/', os.sep)
zipinfo[zpath] = zfile.getinfo(zitem)
assert zipinfo[zpath] is not None
finally:
zfile.close()
return zipinfo
pkg_resources.zipimport = sys.modules[
__name__] # if monkeypatching after import
pkg_resources.build_zipmanifest = build_zipmanifest
pkg_resources.EggMetadata = EggMetadata
pkg_resources.register_finder(EggZipImporter, pkg_resources.find_in_zip)
pkg_resources.register_namespace_handler(EggZipImporter,
pkg_resources.file_ns_handler)
pkg_resources.register_loader_type(EggZipImporter,
pkg_resources.ZipProvider)
class _KiwiProvider(pkg_resources.DefaultProvider):
_my_resources = {}
def __init__(self, module):
pkg_resources.DefaultProvider.__init__(self, module)
if module.__name__ in self._my_resources:
self.module_path = self._my_resources[module.__name__]
@classmethod
def add_resource(cls, name, path=None):
cls._my_resources[name] = path
pkg_resources.register_loader_type(type(None), _KiwiProvider)
class Environment:
"""Environment control
When you want to access a resource on the filesystem, such as
an image or a glade file you use this object.
External libraries or applications are free to add extra directories"""
def __init__(self, root='.'):
self._root = root
#
# Public
#
#----------------------------------------------------------------------------- # Copyright (c) 2013-2016, PyInstaller Development Team. # # Distributed under the terms of the GNU General Public License with exception # for distributing bootloader. # # The full license is in the file COPYING.txt, distributed with this software. #----------------------------------------------------------------------------- import pkg_resources as res from pyimod03_importers import FrozenImporter # To make pkg_resources work with froze moduels we need to set the 'Provider' # class for FrozenImporter. This class decides where to look for resources # and other stuff. 'pkg_resources.NullProvider' is dedicated to PEP302 # import hooks like FrozenImporter is. It uses method __loader__.get_data() in # methods pkg_resources.resource_string() and pkg_resources.resource_stream() res.register_loader_type(FrozenImporter, res.NullProvider)
import pkg_resources
import sys
from pyimod03_importers import FrozenImporter
from mkhost import main
# Fix for pyinstaller
if getattr(sys, 'frozen', False):
pkg_resources.register_loader_type(FrozenImporter,
pkg_resources.DefaultProvider)
main()
class _KiwiProvider(pkg_resources.DefaultProvider):
_my_resources = {}
def __init__(self, module):
pkg_resources.DefaultProvider.__init__(self, module)
if module.__name__ in self._my_resources:
self.module_path = self._my_resources[module.__name__]
@classmethod
def add_resource(cls, name, path=None):
cls._my_resources[name] = path
pkg_resources.register_loader_type(type(None), _KiwiProvider)
class Environment:
"""Environment control
When you want to access a resource on the filesystem, such as
an image or a glade file you use this object.
External libraries or applications are free to add extra directories"""
def __init__(self, root='.'):
self._root = root
#
# Public
