def import_modules_by_entry_point(_packages=None): """Import plugins by entry-point 'rally_plugins'.""" loaded_packages = _packages or find_packages_by_entry_point() for package in loaded_packages: if "plugins_path" in package: em = pkg_resources.get_entry_map(package["name"]) ep = em["rally_plugins"]["path"] try: m = ep.load() if hasattr(m, "__path__"): path = pkgutil.extend_path(m.__path__, m.__name__) else: path = [m.__file__] prefix = m.__name__ + "." for loader, name, _is_pkg in pkgutil.walk_packages( path, prefix=prefix): sys.modules[name] = importlib.import_module(name) except Exception as e: msg = ("\t Failed to load plugins from module '%(module)s' " "(package: '%(package)s')" % {"module": ep.module_name, "package": "%s %s" % (package["name"], package["version"])}) if logging.is_debug(): LOG.exception(msg) else: LOG.warning(msg + (": %s" % six.text_type(e))) return loaded_packages
def component_loader(__path__, __name__): """ Loads classes from subdirectories of a given module. """ __path__ = pkgutil.extend_path(__path__, __name__) for importer, module_name, ispkg in pkgutil.walk_packages(path=__path__, prefix=__name__+'.'): importlib.import_module(module_name)
def __splpy_addDirToPath(dir): if os.path.isdir(dir): if dir not in sys.path: sys.path.insert(0, dir) # In case a streamsx module (e.g. streamsx.bm) # is included in the additional code if os.path.isdir(os.path.join(dir, 'streamsx')): streamsx.__path__ = extend_path(streamsx.__path__, streamsx.__name__)
def __enter__(self): # pkg_resources comes with setuptools. try: import pkg_resources nsdict = copy.deepcopy(pkg_resources._namespace_packages) declare_namespace = pkg_resources.declare_namespace pkg_resources.declare_namespace = self._declare_namespace except ImportError: nsdict = None declare_namespace = None # Save the global importer state. self.state = { 'nsdict': nsdict, 'declare_namespace': declare_namespace, 'nspaths': {}, 'path': sys.path[:], 'meta_path': sys.meta_path[:], 'disables': {}, 'pkgutil.extend_path': pkgutil.extend_path, } # Update the systems meta path and apply function mocks. sys.path[:] = self.path sys.meta_path[:] = self.meta_path + sys.meta_path pkgutil.extend_path = extend_path # If this function is called not the first time, we need to # restore the modules that have been imported with it and # temporarily disable the ones that would be shadowed. for key, mod in items(self.modules): try: self.state['disables'][key] = sys.modules.pop(key) except KeyError: pass sys.modules[key] = mod # Evaluate imports from the .pth files, if any. for fn, lineno, stmt in self.pth_imports: exec_pth_import(fn, lineno, stmt) # Add the original path to sys.path. sys.path += self.state['path'] # Update the __path__ of all namespace modules. for key, mod in items(sys.modules): if mod is None: # Relative imports could have lead to None-entries in # sys.modules. Get rid of them so they can be re-evaluated. prefix = key.rpartition('.')[0] if hasattr(sys.modules.get(prefix), '__path__'): del sys.modules[key] elif hasattr(mod, '__path__'): self.state['nspaths'][key] = copy.copy(mod.__path__) mod.__path__ = pkgutil.extend_path(mod.__path__, mod.__name__) self.in_context = True if self.do_autodisable: self.autodisable() return self
def _declare_namespace(self, package_name): ''' Mock for #pkg_resources.declare_namespace() which calls #pkgutil.extend_path() afterwards as the original implementation doesn't seem to properly find all available namespace paths. ''' self.state['declare_namespace'](package_name) mod = sys.modules[package_name] mod.__path__ = pkgutil.extend_path(mod.__path__, package_name)
def _add_to_sys_path(dir_): if _TRACE.isEnabledFor(logging.DEBUG): _TRACE.debug('Potential addition to sys.path: %s EXISTS %s', dir_, str(os.path.isdir(dir_))) if os.path.isdir(dir_) and dir_ not in sys.path and os.listdir(dir_): _TRACE.debug('Inserting as first entry to sys.path: %s', dir_) sys.path.insert(0, dir_) pkg_resources.working_set.add_entry(dir_) # In case a streamsx module (e.g. streamsx.bm) # is included in the additional code if os.path.isdir(os.path.join(dir_, 'streamsx')): streamsx.__path__ = extend_path(streamsx.__path__, streamsx.__name__) return True return False
def _import_encodings(): import os import imp import encodings import pkgutil import sys del sys.path[:2] import encodings.aliases encodings.__path__ = pkgutil.extend_path( encodings.__path__, encodings.__name__) #imp.reload(encodings) import encodings.mac_roman encodings.aliases.__file__ = os.path.join( os.path.dirname(encodings.mac_roman.__file__), 'aliases.py' + encodings.mac_roman.__file__[:-1]) imp.reload(encodings.aliases) imp.reload(encodings)
def import_modules_by_entry_point(): """Import plugins by entry-point 'rally_plugins'.""" for ep in pkg_resources.iter_entry_points("rally_plugins"): if ep.name == "path": try: m = ep.load() if hasattr(m, "__path__"): path = pkgutil.extend_path(m.__path__, m.__name__) else: path = [m.__file__] prefix = m.__name__ + "." for loader, name, _is_pkg in pkgutil.walk_packages( path, prefix=prefix): sys.modules[name] = importlib.import_module(name) except Exception as e: msg = ("\t Failed to load plugins from module '%(module)s' " "(package: '%(package)s')" % {"module": ep.module_name, "package": "%s %s" % (ep.dist.project_name, ep.dist.version)}) if logging.is_debug(): LOG.exception(msg) else: LOG.warning(msg + (": %s" % six.text_type(e)))
def extendPath(path, name): """Extend path, this method is based on pkgutil.extend_path and will allow aid on supporting inheriting resource paths. Example usage: from BWUtil import extendPath __path__ = extendPath(__path__, __name__) """ from pkgutil import extend_path path = extend_path(path, name) if not isinstance(path, list): return path pname = os.path.join(*name.split('.')) init_py = '__init__' + os.extsep + 'py' path = path[:] for dir in sys.path: if not isinstance(dir, basestring) or not ResMgr.isDir(dir): continue subdir = os.path.join(dir, pname) initfile = os.path.join(subdir, init_py) if subdir not in path and ResMgr.isFile(initfile): path.append(subdir) return path
# -*- coding: utf-8 -*- # Namespaced packages, see http://www.python.org/dev/peps/pep-0420/ try: __import__('pkg_resources').declare_namespace(__name__) except ImportError: # pragma: no cover from pkgutil import extend_path # pragma: no cover __path__ = extend_path(__path__, __name__) # pragma: no cover
# the Flemish Supercomputer Centre (VSC) (https://vscentrum.be/nl/en), # the Hercules foundation (http://www.herculesstichting.be/in_English) # and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en). # # http://github.com/hpcugent/VSC-tools # # VSC-tools is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation v2. # # VSC-tools is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with VSC-tools. If not, see <http://www.gnu.org/licenses/>. ## """ initialize vsc.mympirun package. the vsc.mympirun namespace is used in different folders allong the system so explicitly declare this is also the vsc namespace @author: Jens Timmerman (Ghent University) @author: Stijn De Weirdt (Ghent University) """ from pkgutil import extend_path # we're not the only ones in this namespace __path__ = extend_path(__path__, __name__) #@reservedassignment
relies on GitPython (see http://gitorious.org/git-python) """ try: import git except ImportError: return UNKNOWN try: path = os.path.dirname(__file__) gitrepo = git.Git(path) return gitrepo.rev_list("HEAD").splitlines()[0] except git.GitCommandError: return UNKNOWN git_rev = get_git_revision() if git_rev == UNKNOWN: VERBOSE_VERSION = VERSION else: VERBOSE_VERSION = LooseVersion("%s-r%s" % (VERSION, git_rev)) # extend path so python finds our easyblocks in the subdirectories where they are located subdirs = [chr(l) for l in range(ord('a'), ord('z') + 1)] + ['0'] for subdir in subdirs: __path__ = extend_path(__path__, '%s.%s' % (__name__, subdir)) del subdir, subdirs, l, git_rev # let python know this is not the only place to look for easyblocks, so we can have multiple # easybuild/easyblocks paths in the Python search path, next to the official easyblocks distribution pkg_resources.declare_namespace(__name__)
from pkgutil import extend_path __path__ = extend_path(__path__, 'neurokernel')
from pkgutil import extend_path __path__ = extend_path(__path__, 'fabctx')
# this is a namespace package try: import pkg_resources pkg_resources.declare_namespace(__name__) except ImportError: import pkgutil __path__ = pkgutil.extend_path(__path__, __name__) # @ReservedAssignment VERSION = '2.1' FULL_VERSION = '2.1.6'
from pkgutil import extend_path # pragma: nocover __path__ = extend_path(__path__, __name__) # pragma: nocover
from pydantic import BaseModel from nonebot.utils import DataclassEncoder if TYPE_CHECKING: from nonebot.config import Config from nonebot.drivers import Driver, WebSocket try: import pkg_resources pkg_resources.declare_namespace(__name__) del pkg_resources except ImportError: import pkgutil __path__: Iterable[str] = pkgutil.extend_path(__path__, __name__) del pkgutil except Exception: pass class Bot(abc.ABC): """ Bot 基类。用于处理上报消息,并提供 API 调用接口。 """ driver: "Driver" """Driver 对象""" config: "Config" """Config 配置对象"""
# maky "pyxb" subpackages available from pkgutil import extend_path __path__ = extend_path(__path__, "pyxb")
__author__ = "Jérôme Kieffer" __contact__ = "*****@*****.**" __license__ = "GPLv3+" __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France" __date__ = "15/12/2014" import unittest import os import numpy import logging, time import sys import fabio if __name__ == '__main__': import pkgutil, os __path__ = pkgutil.extend_path([os.path.dirname(__file__)], "pyFAI.test") from .utilstest import UtilsTest, Rwp, getLogger logger = getLogger(__file__) pyFAI = sys.modules["pyFAI"] if logger.getEffectiveLevel() <= logging.INFO: import pylab class TestPolarization(unittest.TestCase): shape = (13, 13) Y, X = numpy.ogrid[-6:7, -6:7] rotY = numpy.radians(30.0 * Y) rotX = numpy.radians(30.0 * X) tth = numpy.sqrt(rotY ** 2 + rotX ** 2) chi = numpy.arctan2(rotY, rotX) # print numpy.degrees(tth[6])
# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"). # You may not use this file except in compliance with the License. # A copy of the License is located at # # http://www.apache.org/licenses/LICENSE-2.0 # # or in the "license" file accompanying this file. This file 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. # !!! DO NOT MODIFY !!! (pkgutil-style namespace package) from pkgutil import extend_path from pkg_resources import get_distribution, DistributionNotFound __path__ = extend_path(__path__, __name__) # type: ignore try: __version__ = get_distribution(__name__).version except DistributionNotFound: __version__ = "0.0.0-unknown"
# Map from listeners proto, with holes where filter config fragments should go, and # a list of filter config fragment protos, to a final listeners.pb with the # config fragments converted to the opaque Struct representation. import sys # Some evil hack to deal with the fact that Bazel puts both google/api and # google/protobuf roots in the sys.path, and Python gets confused, e.g. it # thinks that there is no api package if it encounters the google/protobuf root # in sys.path first. from pkgutil import extend_path import google google.__path__ = extend_path(google.__path__, google.__name__) from google.protobuf import json_format from google.protobuf import struct_pb2 from google.protobuf import text_format from envoy.api.v2 import lds_pb2 from envoy.config.filter.network.http_connection_manager.v2 import http_connection_manager_pb2 # Convert an arbitrary proto object to its Struct proto representation. def proto_to_struct(proto): json_rep = json_format.MessageToJson(proto) parsed_msg = struct_pb2.Struct() json_format.Parse(json_rep, parsed_msg) return parsed_msg
# See http://peak.telecommunity.com/DevCenter/setuptools#namespace-packages try: __import__('pkg_resources').declare_namespace(__name__) except ImportError: from pkgutil import extend_path __path__ = extend_path(__path__, __name__) # @ReservedAssignment
def ExtendPath(self): self.path = pkgutil.extend_path(self.path, self.name) if self.parent is not None: self.parent.ExtendPath()
# # LSST Data Management System # # Copyright 2008-2017 AURA/LSST. # # This product includes software developed by the # LSST Project (http://www.lsst.org/). # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the LSST License Statement and # the GNU General Public License along with this program. If not, # see <https://www.lsstcorp.org/LegalNotices/>. # import pkgutil, lsstimport __path__ = pkgutil.extend_path(__path__, __name__)
# Copyright (C) 2016 Chintalagiri Shashank # # This file is part of tendril. # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. """ The Connectors Utils Package (:mod:`tendril.utils.connectors`) ============================================================== .. toctree:: tendril.utils.connectors.prefab """ from pkgutil import extend_path __path__ = extend_path(__path__, 'tendril.utils.connectors')
# generated from catkin/cmake/template/__init__.py.in # keep symbol table as clean as possible by deleting all unnecessary symbols from os import path as os_path from sys import path as sys_path from pkgutil import extend_path __extended_path = "/home/rip-acer-vn7-591g-1/catkin_ws/src/rosserial/rosserial_arduino/src".split( ";") for p in reversed(__extended_path): sys_path.insert(0, p) del p del sys_path __path__ = extend_path(__path__, __name__) del extend_path __execfiles = [] for p in __extended_path: src_init_file = os_path.join(p, __name__ + '.py') if os_path.isfile(src_init_file): __execfiles.append(src_init_file) else: src_init_file = os_path.join(p, __name__, '__init__.py') if os_path.isfile(src_init_file): __execfiles.append(src_init_file) del src_init_file del p del os_path del __extended_path
# -*- coding: utf-8 -*- # # Copyright 2013, Qunar OPSDEV # # 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. # # Author: jaypei <*****@*****.**> # try: __import__('pkg_resources').declare_namespace(__name__) except ImportError: from pkgutil import extend_path __path__ = extend_path(__path__, __name__) # flake8: noqa
from pkgutil import extend_path __path__ = extend_path([], "pylet.%s" % __name__)
from __future__ import absolute_import import os import warnings warnings.warn('The scikits.cuda namespace package is deprecated and will be ' 'removed in the future; please import the skcuda package ' 'instead.', DeprecationWarning, stacklevel=2) # This import must precede the invocation of extend_path() to work with Python # 3: import skcuda from pkgutil import extend_path __path__ = extend_path(__path__, 'skcuda') from .info import __doc__ from .version import __version__ # Needed to ensure correct header location even when modules are import as # scikits.cuda.something: install_headers = skcuda.__file__.replace(os.path.basename(skcuda.__file__), '') + 'include'
from pkgutil import extend_path __path__ = extend_path(__path__, __name__) # type: ignore
# -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. """ OpenERP core library.""" #---------------------------------------------------------- # odoo must be a namespace package for odoo.addons to become one too # https://packaging.python.org/guides/packaging-namespace-packages/ #---------------------------------------------------------- import pkgutil import os.path __path__ = [ os.path.abspath(path) for path in pkgutil.extend_path(__path__, __name__) ] import sys assert sys.version_info > (3, 6), "Outdated python version detected, Odoo requires Python >= 3.6 to run." #---------------------------------------------------------- # Running mode flags (gevent, prefork) #---------------------------------------------------------- # Is the server running with gevent. evented = False if len(sys.argv) > 1 and sys.argv[1] == 'gevent': sys.argv.remove('gevent') import gevent.monkey import psycopg2 from gevent.socket import wait_read, wait_write gevent.monkey.patch_all()
import os, re, StringIO import ConfigParser, pkgutil import sonata.plugins def find_plugin_dirs(): return [os.path.expanduser('~/.sonata/plugins'), '/usr/local/lib/sonata/plugins'] # add dirs from sys.path: sonata.plugins.__path__ = pkgutil.extend_path(sonata.plugins.__path__, sonata.plugins.__name__) # add dirs specific to sonata: sonata.plugins.__path__ = find_plugin_dirs() + sonata.plugins.__path__ class Plugin(object): def __init__(self, path, name, info, load): self.path = path self.name = name self._info = info self._load = load # obligatory plugin info: format_value = info.get('plugin', 'plugin_format') self.plugin_format = tuple(map(int, format_value.split(','))) self.longname = info.get('plugin', 'name') versionvalue = info.get('plugin', 'version') self.version = tuple(map(int, versionvalue.split(','))) self.version_string = '.'.join(map(str, self.version)) self._capabilities = dict(info.items('capabilities'))
# GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # """ Test for numpy images. """ __author__ = "Jérôme Kieffer" __date__ = "16/06/2016" import os import sys import unittest if __name__ == '__main__': import pkgutil __path__ = pkgutil.extend_path([os.path.dirname(__file__)], "fabio.test") from .utilstest import UtilsTest import numpy logger = UtilsTest.get_logger(__file__) fabio = sys.modules["fabio"] from fabio.numpyimage import NumpyImage from fabio.openimage import openimage class TestNumpy(unittest.TestCase): """basic test""" def setUp(self): """Generate files""" self.ary = numpy.random.randint(0, 6500, size=99).reshape(11, 9).astype("uint16")
from pkgutil import extend_path # Extend path so python finds our easyblocks in the subdirectories where they are located subdirs = [chr(l) for l in range(ord('a'), ord('z') + 1)] + ['0'] for subdir in subdirs: __path__ = extend_path(__path__, '%s.%s' % (__name__, subdir)) # And let python know this is not the only place to look for them, so we can have multiple # easybuild/easyblock paths in your python search path, next to the official easyblocks distribution __path__ = extend_path(__path__, __name__) # @ReservedAssignment del subdir, subdirs, l
from __future__ import absolute_import import pkgutil __path__ = pkgutil.extend_path(__path__, __name__)
from time import time as _time from sys import stdout as _stdout from os.path import split as _split from pkgutil import extend_path __path__ = extend_path(__path__, "ome") del extend_path import settings import logging def timing(function): def wrapper(*args, **kwargs): arg_str = str(args) if arg_str[-2] == ",": # trailing comma arg_str = arg_str[:-2] + ")" logging.debug("starting %s" % function.func_name) _stdout.flush() l = len(function.func_name) start = _time() res = function(*args, **kwargs) logging.debug("%s complete (%.2f sec)"% (function.func_name, _time() - start)) return res wrapper.func_doc = function.func_doc return wrapper def notiming(function): return function
def ex_path(): __path__ = os.path.abspath() pkgutil.extend_path(__path__, __name__)
# Load preprocessing unit from pkgutil import extend_path __path__ = extend_path(__path__, "../preprocessing/")
from pkgutil import extend_path from .dict_extension import * from .enum_argparse import * from .file import * from .folder import * from .list_extension import * from .sftp import * __path__ = extend_path(__path__, "functional") __path__ = extend_path(__path__, "dl") __version__ = "0.1.4"
# Copyright 2014-2015 MathWorks, Inc. """ Array interface between Python and MATLAB. This package defines classes and exceptions that create and manage multidimensional arrays in Python that are passed between Python and MATLAB. The arrays, while similar to Python sequences, have different behaviors. Modules ------- * mlarray - type-specific multidimensional array classes for working with MATLAB * mlexceptions - exceptions raised manipulating mlarray objects """ import os import sys from pkgutil import extend_path __path__ = extend_path(__path__, '__name__') _package_folder = os.path.dirname(os.path.realpath(__file__)) sys.path.append(_package_folder) from mlarray import double, single, uint8, int8, uint16, \ int16, uint32, int32, uint64, int64, logical from mlexceptions import ShapeError as ShapeError from mlexceptions import SizeError as SizeError
relies on GitPython (see http://gitorious.org/git-python) """ try: import git except ImportError: return UNKNOWN try: path = os.path.dirname(__file__) gitrepo = git.Git(path) return gitrepo.rev_list("HEAD").splitlines()[0] except git.GitCommandError: return UNKNOWN git_rev = get_git_revision() if git_rev == UNKNOWN: VERBOSE_VERSION = VERSION else: VERBOSE_VERSION = LooseVersion("%s-r%s" % (VERSION, git_rev)) # extend path so python finds our easyblocks in the subdirectories where they are located subdirs = [chr(l) for l in range(ord("a"), ord("z") + 1)] + ["0"] for subdir in subdirs: __path__ = extend_path(__path__, "%s.%s" % (__name__, subdir)) del subdir, subdirs, l, git_rev # let python know this is not the only place to look for easyblocks, so we can have multiple # easybuild/easyblocks paths in the Python search path, next to the official easyblocks distribution pkg_resources.declare_namespace(__name__)
# -*- coding: utf-8 -*- """Tests for fastavro""" from __future__ import absolute_import from pkgutil import extend_path __path__ = extend_path(__path__, 'fastavro') import fastavro # noqa
or UNKNOWN is getting the git revision fails relies on GitPython (see http://gitorious.org/git-python) """ try: import git except ImportError: return UNKNOWN try: path = os.path.dirname(__file__) gitrepo = git.Git(path) return gitrepo.rev_list("HEAD").splitlines()[0] except git.GitCommandError: return UNKNOWN git_rev = get_git_revision() if git_rev == UNKNOWN: VERBOSE_VERSION = VERSION else: VERBOSE_VERSION = LooseVersion("%s-r%s" % (VERSION, get_git_revision())) # Extend path so python finds our easyblocks in the subdirectories where they are located subdirs = [chr(l) for l in range(ord('a'), ord('z') + 1)] + ['0'] __path__.extend([os.path.join(__path__[0], subdir) for subdir in subdirs]) # And let python know this is not the only place to look for them, so we can have multiple # easybuild/easyblock paths in your python search path, next to the official easyblocks distribution __path__ = extend_path(__path__, __name__) # @ReservedAssignment del subdir, subdirs, l, git_rev
#!/usr/bin/env python # encoding: utf-8 # Copyright (C) 2016 Chintalagiri Shashank # # This file is part of tendril. # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. """ Docstring for __init__.py """ from pkgutil import extend_path __path__ = extend_path(__path__, 'tendril.utils.connectors')
""" Galaxy root package -- this is a namespace package. """ from pkgutil import extend_path __path__ = extend_path(__path__, __name__)
# see https://docs.python.org/3/library/pkgutil.html import sys from pkgutil import extend_path __path__ = extend_path(sys.path, __name__)