FM / python3.4

/opt/alt/python34/lib64/python3.4

Name	Size	Mode	Actions
asyncio/	-	0755	rm
collections/	-	0755	rm
concurrent/	-	0755	rm
config-3.4m/	-	0755	rm
ctypes/	-	0755	rm
curses/	-	0755	rm
dbm/	-	0755	rm
distutils/	-	0755	rm
email/	-	0755	rm
encodings/	-	0755	rm
ensurepip/	-	0755	rm
html/	-	0755	rm
http/	-	0755	rm
idlelib/	-	0755	rm
importlib/	-	0755	rm
json/	-	0755	rm
lib-dynload/	-	0755	rm
lib2to3/	-	0755	rm
logging/	-	0755	rm
multiprocessing/	-	0755	rm
plat-linux/	-	0755	rm
pydoc_data/	-	0755	rm
site-packages/	-	0755	rm
sqlite3/	-	0755	rm
test/	-	0755	rm
unittest/	-	0755	rm
urllib/	-	0755	rm
venv/	-	0755	rm
wsgiref/	-	0755	rm
xml/	-	0755	rm
xmlrpc/	-	0755	rm
__pycache__/	-	0755	rm
abc.py	8624	0644	edit dl rm
aifc.py	31578	0644	edit dl rm
antigravity.py	475	0644	edit dl rm
argparse.py	90027	0644	edit dl rm
ast.py	12034	0644	edit dl rm
asynchat.py	11825	0644	edit dl rm
asyncore.py	20998	0644	edit dl rm
base64.py	20180	0755	edit dl rm
bdb.py	23354	0644	edit dl rm
binhex.py	13928	0644	edit dl rm
bisect.py	2595	0644	edit dl rm
bz2.py	18860	0644	edit dl rm
calendar.py	22941	0644	edit dl rm
cgi.py	35941	0755	edit dl rm
cgitb.py	12041	0644	edit dl rm
chunk.py	5425	0644	edit dl rm
cmd.py	14860	0644	edit dl rm
code.py	10037	0644	edit dl rm
codecs.py	35910	0644	edit dl rm
codeop.py	5994	0644	edit dl rm
colorsys.py	4064	0644	edit dl rm
compileall.py	9618	0644	edit dl rm
configparser.py	49698	0644	edit dl rm
contextlib.py	11639	0644	edit dl rm
copy.py	9005	0644	edit dl rm
copyreg.py	6833	0644	edit dl rm
cProfile.py	5324	0755	edit dl rm
crypt.py	1879	0644	edit dl rm
csv.py	16185	0644	edit dl rm
datetime.py	75804	0644	edit dl rm
decimal.py	228688	0644	edit dl rm
difflib.py	81684	0644	edit dl rm
dis.py	17160	0644	edit dl rm
doctest.py	104492	0644	edit dl rm
dummy_threading.py	2815	0644	edit dl rm
enum.py	21538	0644	edit dl rm
filecmp.py	9830	0644	edit dl rm
fileinput.py	14865	0644	edit dl rm
fnmatch.py	3163	0644	edit dl rm
formatter.py	15173	0644	edit dl rm
fractions.py	23203	0644	edit dl rm
ftplib.py	38532	0644	edit dl rm
functools.py	28511	0644	edit dl rm
genericpath.py	3882	0644	edit dl rm
getopt.py	7489	0644	edit dl rm
getpass.py	6069	0644	edit dl rm
gettext.py	20767	0644	edit dl rm
glob.py	3461	0644	edit dl rm
gzip.py	24314	0644	edit dl rm
hashlib.py	9850	0644	edit dl rm
heapq.py	17997	0644	edit dl rm
hmac.py	5063	0644	edit dl rm
imaplib.py	50267	0644	edit dl rm
imghdr.py	3528	0644	edit dl rm
imp.py	9984	0644	edit dl rm
inspect.py	104640	0644	edit dl rm
io.py	3396	0644	edit dl rm
ipaddress.py	71598	0644	edit dl rm
keyword.py	2222	0755	edit dl rm
linecache.py	3953	0644	edit dl rm
locale.py	74530	0644	edit dl rm
lzma.py	19371	0644	edit dl rm
macpath.py	5619	0644	edit dl rm
macurl2path.py	2732	0644	edit dl rm
mailbox.py	78382	0644	edit dl rm
mailcap.py	7437	0644	edit dl rm
mimetypes.py	20781	0644	edit dl rm
modulefinder.py	23421	0644	edit dl rm
netrc.py	5748	0644	edit dl rm
nntplib.py	43082	0644	edit dl rm
ntpath.py	20477	0644	edit dl rm
nturl2path.py	2444	0644	edit dl rm
numbers.py	10243	0644	edit dl rm
opcode.py	5442	0644	edit dl rm
operator.py	9195	0644	edit dl rm
optparse.py	60346	0644	edit dl rm
os.py	33882	0644	edit dl rm
pathlib.py	42467	0644	edit dl rm
pdb.py	60992	0755	edit dl rm
pickle.py	55989	0644	edit dl rm
pickletools.py	91762	0644	edit dl rm
pipes.py	8916	0644	edit dl rm
pkgutil.py	21215	0644	edit dl rm
platform.py	46761	0755	edit dl rm
plistlib.py	31791	0644	edit dl rm
poplib.py	14319	0644	edit dl rm
posixpath.py	13448	0644	edit dl rm
pprint.py	14919	0644	edit dl rm
profile.py	22032	0755	edit dl rm
pstats.py	26316	0644	edit dl rm
pty.py	4763	0644	edit dl rm
pyclbr.py	13520	0644	edit dl rm
pydoc.py	103011	0755	edit dl rm
py_compile.py	7103	0644	edit dl rm
queue.py	8835	0644	edit dl rm
quopri.py	7265	0755	edit dl rm
random.py	26084	0644	edit dl rm
re.py	15604	0644	edit dl rm
reprlib.py	5110	0644	edit dl rm
rlcompleter.py	6069	0644	edit dl rm
runpy.py	10816	0644	edit dl rm
sched.py	6354	0644	edit dl rm
selectors.py	17097	0644	edit dl rm
shelve.py	8528	0644	edit dl rm
shlex.py	11548	0644	edit dl rm
shutil.py	39902	0644	edit dl rm
site.py	21553	0644	edit dl rm
smtpd.py	29991	0755	edit dl rm
smtplib.py	38971	0755	edit dl rm
sndhdr.py	6256	0644	edit dl rm
socket.py	19067	0644	edit dl rm
socketserver.py	24372	0644	edit dl rm
sre_compile.py	19903	0644	edit dl rm
sre_constants.py	7267	0644	edit dl rm
sre_parse.py	31429	0644	edit dl rm
ssl.py	34747	0644	edit dl rm
stat.py	4400	0644	edit dl rm
statistics.py	19556	0644	edit dl rm
string.py	11445	0644	edit dl rm
stringprep.py	12917	0644	edit dl rm
struct.py	257	0644	edit dl rm
subprocess.py	64549	0644	edit dl rm
sunau.py	18095	0644	edit dl rm
symbol.py	2053	0755	edit dl rm
symtable.py	7404	0644	edit dl rm
sysconfig.py	24632	0644	edit dl rm
tabnanny.py	11410	0755	edit dl rm
tarfile.py	91557	0755	edit dl rm
telnetlib.py	23074	0644	edit dl rm
tempfile.py	22525	0644	edit dl rm
textwrap.py	19282	0644	edit dl rm
this.py	1003	0644	edit dl rm
threading.py	48802	0644	edit dl rm
timeit.py	11972	0755	edit dl rm
token.py	3034	0644	edit dl rm
tokenize.py	25596	0644	edit dl rm
trace.py	31487	0755	edit dl rm
traceback.py	11167	0644	edit dl rm
tracemalloc.py	15651	0644	edit dl rm
tty.py	879	0644	edit dl rm
types.py	5411	0644	edit dl rm
uu.py	6766	0755	edit dl rm
uuid.py	23724	0644	edit dl rm
warnings.py	14303	0644	edit dl rm
wave.py	17682	0644	edit dl rm
weakref.py	19384	0644	edit dl rm
webbrowser.py	21432	0755	edit dl rm
xdrlib.py	5913	0644	edit dl rm
zipfile.py	68547	0644	edit dl rm
_bootlocale.py	1301	0644	edit dl rm
_collections_abc.py	19898	0644	edit dl rm
_compat_pickle.py	8318	0644	edit dl rm
_dummy_thread.py	4872	0644	edit dl rm
_markupbase.py	14598	0644	edit dl rm
_osx_support.py	19101	0644	edit dl rm
_pyio.py	73893	0644	edit dl rm
_sitebuiltins.py	3115	0644	edit dl rm
_strptime.py	22053	0644	edit dl rm
_sysconfigdata.py	24480	0644	edit dl rm
_threading_local.py	7410	0644	edit dl rm
_weakrefset.py	5705	0644	edit dl rm
__future__.py	4584	0644	edit dl rm
__phello__.foo.py	64	0644	edit dl rm

Edit: /opt/alt/python34/lib64/python3.4/pkgutil.py (21215B)

"""Utilities to support packages."""

from functools import singledispatch as simplegeneric
import importlib
import importlib.util
import importlib.machinery
import os
import os.path
import sys
from types import ModuleType
import warnings

__all__ = [
    'get_importer', 'iter_importers', 'get_loader', 'find_loader',
    'walk_packages', 'iter_modules', 'get_data',
    'ImpImporter', 'ImpLoader', 'read_code', 'extend_path',
]

def _get_spec(finder, name):
    """Return the finder-specific module spec."""
    # Works with legacy finders.
    try:
        find_spec = finder.find_spec
    except AttributeError:
        loader = finder.find_module(name)
        if loader is None:
            return None
        return importlib.util.spec_from_loader(name, loader)
    else:
        return find_spec(name)

def read_code(stream):
    # This helper is needed in order for the PEP 302 emulation to
    # correctly handle compiled files
    import marshal

magic = stream.read(4)
    if magic != importlib.util.MAGIC_NUMBER:
        return None

stream.read(8) # Skip timestamp and size
    return marshal.load(stream)

def walk_packages(path=None, prefix='', onerror=None):
    """Yields (module_loader, name, ispkg) for all modules recursively
    on path, or, if path is None, all accessible modules.

'path' should be either None or a list of paths to look for
    modules in.

'prefix' is a string to output on the front of every module name
    on output.

Note that this function must import all *packages* (NOT all
    modules!) on the given path, in order to access the __path__
    attribute to find submodules.

'onerror' is a function which gets called with one argument (the
    name of the package which was being imported) if any exception
    occurs while trying to import a package.  If no onerror function is
    supplied, ImportErrors are caught and ignored, while all other
    exceptions are propagated, terminating the search.

Examples:

# list all modules python can access
    walk_packages()

# list all submodules of ctypes
    walk_packages(ctypes.__path__, ctypes.__name__+'.')
    """

def seen(p, m={}):
        if p in m:
            return True
        m[p] = True

for importer, name, ispkg in iter_modules(path, prefix):
        yield importer, name, ispkg

if ispkg:
            try:
                __import__(name)
            except ImportError:
                if onerror is not None:
                    onerror(name)
            except Exception:
                if onerror is not None:
                    onerror(name)
                else:
                    raise
            else:
                path = getattr(sys.modules[name], '__path__', None) or []

# don't traverse path items we've seen before
                path = [p for p in path if not seen(p)]

yield from walk_packages(path, name+'.', onerror)

def iter_modules(path=None, prefix=''):
    """Yields (module_loader, name, ispkg) for all submodules on path,
    or, if path is None, all top-level modules on sys.path.

'path' should be either None or a list of paths to look for
    modules in.

'prefix' is a string to output on the front of every module name
    on output.
    """

if path is None:
        importers = iter_importers()
    else:
        importers = map(get_importer, path)

yielded = {}
    for i in importers:
        for name, ispkg in iter_importer_modules(i, prefix):
            if name not in yielded:
                yielded[name] = 1
                yield i, name, ispkg

@simplegeneric
def iter_importer_modules(importer, prefix=''):
    if not hasattr(importer, 'iter_modules'):
        return []
    return importer.iter_modules(prefix)

# Implement a file walker for the normal importlib path hook
def _iter_file_finder_modules(importer, prefix=''):
    if importer.path is None or not os.path.isdir(importer.path):
        return

yielded = {}
    import inspect
    try:
        filenames = os.listdir(importer.path)
    except OSError:
        # ignore unreadable directories like import does
        filenames = []
    filenames.sort()  # handle packages before same-named modules

for fn in filenames:
        modname = inspect.getmodulename(fn)
        if modname=='__init__' or modname in yielded:
            continue

path = os.path.join(importer.path, fn)
        ispkg = False

if not modname and os.path.isdir(path) and '.' not in fn:
            modname = fn
            try:
                dircontents = os.listdir(path)
            except OSError:
                # ignore unreadable directories like import does
                dircontents = []
            for fn in dircontents:
                subname = inspect.getmodulename(fn)
                if subname=='__init__':
                    ispkg = True
                    break
            else:
                continue    # not a package

if modname and '.' not in modname:
            yielded[modname] = 1
            yield prefix + modname, ispkg

iter_importer_modules.register(
    importlib.machinery.FileFinder, _iter_file_finder_modules)

def _import_imp():
    global imp
    with warnings.catch_warnings():
        warnings.simplefilter('ignore', PendingDeprecationWarning)
        imp = importlib.import_module('imp')

class ImpImporter:
    """PEP 302 Importer that wraps Python's "classic" import algorithm

ImpImporter(dirname) produces a PEP 302 importer that searches that
    directory.  ImpImporter(None) produces a PEP 302 importer that searches
    the current sys.path, plus any modules that are frozen or built-in.

Note that ImpImporter does not currently support being used by placement
    on sys.meta_path.
    """

def __init__(self, path=None):
        global imp
        warnings.warn("This emulation is deprecated, use 'importlib' instead",
             DeprecationWarning)
        _import_imp()
        self.path = path

def find_module(self, fullname, path=None):
        # Note: we ignore 'path' argument since it is only used via meta_path
        subname = fullname.split(".")[-1]
        if subname != fullname and self.path is None:
            return None
        if self.path is None:
            path = None
        else:
            path = [os.path.realpath(self.path)]
        try:
            file, filename, etc = imp.find_module(subname, path)
        except ImportError:
            return None
        return ImpLoader(fullname, file, filename, etc)

def iter_modules(self, prefix=''):
        if self.path is None or not os.path.isdir(self.path):
            return

yielded = {}
        import inspect
        try:
            filenames = os.listdir(self.path)
        except OSError:
            # ignore unreadable directories like import does
            filenames = []
        filenames.sort()  # handle packages before same-named modules

for fn in filenames:
            modname = inspect.getmodulename(fn)
            if modname=='__init__' or modname in yielded:
                continue

path = os.path.join(self.path, fn)
            ispkg = False

if not modname and os.path.isdir(path) and '.' not in fn:
                modname = fn
                try:
                    dircontents = os.listdir(path)
                except OSError:
                    # ignore unreadable directories like import does
                    dircontents = []
                for fn in dircontents:
                    subname = inspect.getmodulename(fn)
                    if subname=='__init__':
                        ispkg = True
                        break
                else:
                    continue    # not a package

if modname and '.' not in modname:
                yielded[modname] = 1
                yield prefix + modname, ispkg

class ImpLoader:
    """PEP 302 Loader that wraps Python's "classic" import algorithm
    """
    code = source = None

def __init__(self, fullname, file, filename, etc):
        warnings.warn("This emulation is deprecated, use 'importlib' instead",
                      DeprecationWarning)
        _import_imp()
        self.file = file
        self.filename = filename
        self.fullname = fullname
        self.etc = etc

def load_module(self, fullname):
        self._reopen()
        try:
            mod = imp.load_module(fullname, self.file, self.filename, self.etc)
        finally:
            if self.file:
                self.file.close()
        # Note: we don't set __loader__ because we want the module to look
        # normal; i.e. this is just a wrapper for standard import machinery
        return mod

def get_data(self, pathname):
        with open(pathname, "rb") as file:
            return file.read()

def _reopen(self):
        if self.file and self.file.closed:
            mod_type = self.etc[2]
            if mod_type==imp.PY_SOURCE:
                self.file = open(self.filename, 'r')
            elif mod_type in (imp.PY_COMPILED, imp.C_EXTENSION):
                self.file = open(self.filename, 'rb')

def _fix_name(self, fullname):
        if fullname is None:
            fullname = self.fullname
        elif fullname != self.fullname:
            raise ImportError("Loader for module %s cannot handle "
                              "module %s" % (self.fullname, fullname))
        return fullname

def is_package(self, fullname):
        fullname = self._fix_name(fullname)
        return self.etc[2]==imp.PKG_DIRECTORY

def get_code(self, fullname=None):
        fullname = self._fix_name(fullname)
        if self.code is None:
            mod_type = self.etc[2]
            if mod_type==imp.PY_SOURCE:
                source = self.get_source(fullname)
                self.code = compile(source, self.filename, 'exec')
            elif mod_type==imp.PY_COMPILED:
                self._reopen()
                try:
                    self.code = read_code(self.file)
                finally:
                    self.file.close()
            elif mod_type==imp.PKG_DIRECTORY:
                self.code = self._get_delegate().get_code()
        return self.code

def get_source(self, fullname=None):
        fullname = self._fix_name(fullname)
        if self.source is None:
            mod_type = self.etc[2]
            if mod_type==imp.PY_SOURCE:
                self._reopen()
                try:
                    self.source = self.file.read()
                finally:
                    self.file.close()
            elif mod_type==imp.PY_COMPILED:
                if os.path.exists(self.filename[:-1]):
                    with open(self.filename[:-1], 'r') as f:
                        self.source = f.read()
            elif mod_type==imp.PKG_DIRECTORY:
                self.source = self._get_delegate().get_source()
        return self.source

def _get_delegate(self):
        finder = ImpImporter(self.filename)
        spec = _get_spec(finder, '__init__')
        return spec.loader

def get_filename(self, fullname=None):
        fullname = self._fix_name(fullname)
        mod_type = self.etc[2]
        if mod_type==imp.PKG_DIRECTORY:
            return self._get_delegate().get_filename()
        elif mod_type in (imp.PY_SOURCE, imp.PY_COMPILED, imp.C_EXTENSION):
            return self.filename
        return None

try:
    import zipimport
    from zipimport import zipimporter

def iter_zipimport_modules(importer, prefix=''):
        dirlist = sorted(zipimport._zip_directory_cache[importer.archive])
        _prefix = importer.prefix
        plen = len(_prefix)
        yielded = {}
        import inspect
        for fn in dirlist:
            if not fn.startswith(_prefix):
                continue

fn = fn[plen:].split(os.sep)

if len(fn)==2 and fn[1].startswith('__init__.py'):
                if fn[0] not in yielded:
                    yielded[fn[0]] = 1
                    yield fn[0], True

if len(fn)!=1:
                continue

modname = inspect.getmodulename(fn[0])
            if modname=='__init__':
                continue

if modname and '.' not in modname and modname not in yielded:
                yielded[modname] = 1
                yield prefix + modname, False

iter_importer_modules.register(zipimporter, iter_zipimport_modules)

except ImportError:
    pass

def get_importer(path_item):
    """Retrieve a PEP 302 importer for the given path item

The returned importer is cached in sys.path_importer_cache
    if it was newly created by a path hook.

The cache (or part of it) can be cleared manually if a
    rescan of sys.path_hooks is necessary.
    """
    try:
        importer = sys.path_importer_cache[path_item]
    except KeyError:
        for path_hook in sys.path_hooks:
            try:
                importer = path_hook(path_item)
                sys.path_importer_cache.setdefault(path_item, importer)
                break
            except ImportError:
                pass
        else:
            importer = None
    return importer

def iter_importers(fullname=""):
    """Yield PEP 302 importers for the given module name

If fullname contains a '.', the importers will be for the package
    containing fullname, otherwise they will be all registered top level
    importers (i.e. those on both sys.meta_path and sys.path_hooks).

If the named module is in a package, that package is imported as a side
    effect of invoking this function.

If no module name is specified, all top level importers are produced.
    """
    if fullname.startswith('.'):
        msg = "Relative module name {!r} not supported".format(fullname)
        raise ImportError(msg)
    if '.' in fullname:
        # Get the containing package's __path__
        pkg_name = fullname.rpartition(".")[0]
        pkg = importlib.import_module(pkg_name)
        path = getattr(pkg, '__path__', None)
        if path is None:
            return
    else:
        yield from sys.meta_path
        path = sys.path
    for item in path:
        yield get_importer(item)

def get_loader(module_or_name):
    """Get a PEP 302 "loader" object for module_or_name

Returns None if the module cannot be found or imported.
    If the named module is not already imported, its containing package
    (if any) is imported, in order to establish the package __path__.
    """
    if module_or_name in sys.modules:
        module_or_name = sys.modules[module_or_name]
        if module_or_name is None:
            return None
    if isinstance(module_or_name, ModuleType):
        module = module_or_name
        loader = getattr(module, '__loader__', None)
        if loader is not None:
            return loader
        if getattr(module, '__spec__', None) is None:
            return None
        fullname = module.__name__
    else:
        fullname = module_or_name
    return find_loader(fullname)

def find_loader(fullname):
    """Find a PEP 302 "loader" object for fullname

This is a backwards compatibility wrapper around
    importlib.util.find_spec that converts most failures to ImportError
    and only returns the loader rather than the full spec
    """
    if fullname.startswith('.'):
        msg = "Relative module name {!r} not supported".format(fullname)
        raise ImportError(msg)
    try:
        spec = importlib.util.find_spec(fullname)
    except (ImportError, AttributeError, TypeError, ValueError) as ex:
        # This hack fixes an impedance mismatch between pkgutil and
        # importlib, where the latter raises other errors for cases where
        # pkgutil previously raised ImportError
        msg = "Error while finding loader for {!r} ({}: {})"
        raise ImportError(msg.format(fullname, type(ex), ex)) from ex
    return spec.loader if spec is not None else None

def extend_path(path, name):
    """Extend a package's path.

Intended use is to place the following code in a package's __init__.py:

from pkgutil import extend_path
        __path__ = extend_path(__path__, __name__)

This will add to the package's __path__ all subdirectories of
    directories on sys.path named after the package.  This is useful
    if one wants to distribute different parts of a single logical
    package as multiple directories.

It also looks for *.pkg files beginning where * matches the name
    argument.  This feature is similar to *.pth files (see site.py),
    except that it doesn't special-case lines starting with 'import'.
    A *.pkg file is trusted at face value: apart from checking for
    duplicates, all entries found in a *.pkg file are added to the
    path, regardless of whether they are exist the filesystem.  (This
    is a feature.)

If the input path is not a list (as is the case for frozen
    packages) it is returned unchanged.  The input path is not
    modified; an extended copy is returned.  Items are only appended
    to the copy at the end.

It is assumed that sys.path is a sequence.  Items of sys.path that
    are not (unicode or 8-bit) strings referring to existing
    directories are ignored.  Unicode items of sys.path that cause
    errors when used as filenames may cause this function to raise an
    exception (in line with os.path.isdir() behavior).
    """

if not isinstance(path, list):
        # This could happen e.g. when this is called from inside a
        # frozen package.  Return the path unchanged in that case.
        return path

sname_pkg = name + ".pkg"

path = path[:] # Start with a copy of the existing path

parent_package, _, final_name = name.rpartition('.')
    if parent_package:
        try:
            search_path = sys.modules[parent_package].__path__
        except (KeyError, AttributeError):
            # We can't do anything: find_loader() returns None when
            # passed a dotted name.
            return path
    else:
        search_path = sys.path

for dir in search_path:
        if not isinstance(dir, str):
            continue

finder = get_importer(dir)
        if finder is not None:
            portions = []
            if hasattr(finder, 'find_spec'):
                spec = finder.find_spec(final_name)
                if spec is not None:
                    portions = spec.submodule_search_locations or []
            # Is this finder PEP 420 compliant?
            elif hasattr(finder, 'find_loader'):
                _, portions = finder.find_loader(final_name)

for portion in portions:
                # XXX This may still add duplicate entries to path on
                # case-insensitive filesystems
                if portion not in path:
                    path.append(portion)

# XXX Is this the right thing for subpackages like zope.app?
        # It looks for a file named "zope.app.pkg"
        pkgfile = os.path.join(dir, sname_pkg)
        if os.path.isfile(pkgfile):
            try:
                f = open(pkgfile)
            except OSError as msg:
                sys.stderr.write("Can't open %s: %s\n" %
                                 (pkgfile, msg))
            else:
                with f:
                    for line in f:
                        line = line.rstrip('\n')
                        if not line or line.startswith('#'):
                            continue
                        path.append(line) # Don't check for existence!

return path

def get_data(package, resource):
    """Get a resource from a package.

This is a wrapper round the PEP 302 loader get_data API. The package
    argument should be the name of a package, in standard module format
    (foo.bar). The resource argument should be in the form of a relative
    filename, using '/' as the path separator. The parent directory name '..'
    is not allowed, and nor is a rooted name (starting with a '/').

The function returns a binary string, which is the contents of the
    specified resource.

For packages located in the filesystem, which have already been imported,
    this is the rough equivalent of

d = os.path.dirname(sys.modules[package].__file__)
        data = open(os.path.join(d, resource), 'rb').read()

If the package cannot be located or loaded, or it uses a PEP 302 loader
    which does not support get_data(), then None is returned.
    """

spec = importlib.util.find_spec(package)
    if spec is None:
        return None
    loader = spec.loader
    if loader is None or not hasattr(loader, 'get_data'):
        return None
    # XXX needs test
    mod = (sys.modules.get(package) or
           importlib._bootstrap._SpecMethods(spec).load())
    if mod is None or not hasattr(mod, '__file__'):
        return None

# Modify the resource name to be compatible with the loader.get_data
    # signature - an os.path format "filename" starting with the dirname of
    # the package's __file__
    parts = resource.split('/')
    parts.insert(0, os.path.dirname(mod.__file__))
    resource_name = os.path.join(*parts)
    return loader.get_data(resource_name)

cmd: