ob-metaflow 2.15.13.1__py2.py3-none-any.whl → 2.19.7.1rc0__py2.py3-none-any.whl

metaflow/_vendor/v3_5/importlib_metadata/_compat.py

@@ -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)

metaflow/_vendor/v3_5/zipp.py

@@ -1,329 +0,0 @@
-import io
-import posixpath
-import zipfile
-import itertools
-import contextlib
-import sys
-import pathlib
-
-if sys.version_info < (3, 7):
-    from collections import OrderedDict
-else:
-    OrderedDict = dict
-
-
-__all__ = ['Path']
-
-
-def _parents(path):
-    """
-    Given a path with elements separated by
-    posixpath.sep, generate all parents of that path.
-
-    >>> list(_parents('b/d'))
-    ['b']
-    >>> list(_parents('/b/d/'))
-    ['/b']
-    >>> list(_parents('b/d/f/'))
-    ['b/d', 'b']
-    >>> list(_parents('b'))
-    []
-    >>> list(_parents(''))
-    []
-    """
-    return itertools.islice(_ancestry(path), 1, None)
-
-
-def _ancestry(path):
-    """
-    Given a path with elements separated by
-    posixpath.sep, generate all elements of that path
-
-    >>> list(_ancestry('b/d'))
-    ['b/d', 'b']
-    >>> list(_ancestry('/b/d/'))
-    ['/b/d', '/b']
-    >>> list(_ancestry('b/d/f/'))
-    ['b/d/f', 'b/d', 'b']
-    >>> list(_ancestry('b'))
-    ['b']
-    >>> list(_ancestry(''))
-    []
-    """
-    path = path.rstrip(posixpath.sep)
-    while path and path != posixpath.sep:
-        yield path
-        path, tail = posixpath.split(path)
-
-
-_dedupe = OrderedDict.fromkeys
-"""Deduplicate an iterable in original order"""
-
-
-def _difference(minuend, subtrahend):
-    """
-    Return items in minuend not in subtrahend, retaining order
-    with O(1) lookup.
-    """
-    return itertools.filterfalse(set(subtrahend).__contains__, minuend)
-
-
-class CompleteDirs(zipfile.ZipFile):
-    """
-    A ZipFile subclass that ensures that implied directories
-    are always included in the namelist.
-    """
-
-    @staticmethod
-    def _implied_dirs(names):
-        parents = itertools.chain.from_iterable(map(_parents, names))
-        as_dirs = (p + posixpath.sep for p in parents)
-        return _dedupe(_difference(as_dirs, names))
-
-    def namelist(self):
-        names = super(CompleteDirs, self).namelist()
-        return names + list(self._implied_dirs(names))
-
-    def _name_set(self):
-        return set(self.namelist())
-
-    def resolve_dir(self, name):
-        """
-        If the name represents a directory, return that name
-        as a directory (with the trailing slash).
-        """
-        names = self._name_set()
-        dirname = name + '/'
-        dir_match = name not in names and dirname in names
-        return dirname if dir_match else name
-
-    @classmethod
-    def make(cls, source):
-        """
-        Given a source (filename or zipfile), return an
-        appropriate CompleteDirs subclass.
-        """
-        if isinstance(source, CompleteDirs):
-            return source
-
-        if not isinstance(source, zipfile.ZipFile):
-            return cls(_pathlib_compat(source))
-
-        # Only allow for FastLookup when supplied zipfile is read-only
-        if 'r' not in source.mode:
-            cls = CompleteDirs
-
-        source.__class__ = cls
-        return source
-
-
-class FastLookup(CompleteDirs):
-    """
-    ZipFile subclass to ensure implicit
-    dirs exist and are resolved rapidly.
-    """
-
-    def namelist(self):
-        with contextlib.suppress(AttributeError):
-            return self.__names
-        self.__names = super(FastLookup, self).namelist()
-        return self.__names
-
-    def _name_set(self):
-        with contextlib.suppress(AttributeError):
-            return self.__lookup
-        self.__lookup = super(FastLookup, self)._name_set()
-        return self.__lookup
-
-
-def _pathlib_compat(path):
-    """
-    For path-like objects, convert to a filename for compatibility
-    on Python 3.6.1 and earlier.
-    """
-    try:
-        return path.__fspath__()
-    except AttributeError:
-        return str(path)
-
-
-class Path:
-    """
-    A pathlib-compatible interface for zip files.
-
-    Consider a zip file with this structure::
-
-        .
-        ├── a.txt
-        └── b
-            ├── c.txt
-            └── d
-                └── e.txt
-
-    >>> data = io.BytesIO()
-    >>> zf = zipfile.ZipFile(data, 'w')
-    >>> zf.writestr('a.txt', 'content of a')
-    >>> zf.writestr('b/c.txt', 'content of c')
-    >>> zf.writestr('b/d/e.txt', 'content of e')
-    >>> zf.filename = 'mem/abcde.zip'
-
-    Path accepts the zipfile object itself or a filename
-
-    >>> root = Path(zf)
-
-    From there, several path operations are available.
-
-    Directory iteration (including the zip file itself):
-
-    >>> a, b = root.iterdir()
-    >>> a
-    Path('mem/abcde.zip', 'a.txt')
-    >>> b
-    Path('mem/abcde.zip', 'b/')
-
-    name property:
-
-    >>> b.name
-    'b'
-
-    join with divide operator:
-
-    >>> c = b / 'c.txt'
-    >>> c
-    Path('mem/abcde.zip', 'b/c.txt')
-    >>> c.name
-    'c.txt'
-
-    Read text:
-
-    >>> c.read_text()
-    'content of c'
-
-    existence:
-
-    >>> c.exists()
-    True
-    >>> (b / 'missing.txt').exists()
-    False
-
-    Coercion to string:
-
-    >>> import os
-    >>> str(c).replace(os.sep, posixpath.sep)
-    'mem/abcde.zip/b/c.txt'
-
-    At the root, ``name``, ``filename``, and ``parent``
-    resolve to the zipfile. Note these attributes are not
-    valid and will raise a ``ValueError`` if the zipfile
-    has no filename.
-
-    >>> root.name
-    'abcde.zip'
-    >>> str(root.filename).replace(os.sep, posixpath.sep)
-    'mem/abcde.zip'
-    >>> str(root.parent)
-    'mem'
-    """
-
-    __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})"
-
-    def __init__(self, root, at=""):
-        """
-        Construct a Path from a ZipFile or filename.
-
-        Note: When the source is an existing ZipFile object,
-        its type (__class__) will be mutated to a
-        specialized type. If the caller wishes to retain the
-        original type, the caller should either create a
-        separate ZipFile object or pass a filename.
-        """
-        self.root = FastLookup.make(root)
-        self.at = at
-
-    def open(self, mode='r', *args, pwd=None, **kwargs):
-        """
-        Open this entry as text or binary following the semantics
-        of ``pathlib.Path.open()`` by passing arguments through
-        to io.TextIOWrapper().
-        """
-        if self.is_dir():
-            raise IsADirectoryError(self)
-        zip_mode = mode[0]
-        if not self.exists() and zip_mode == 'r':
-            raise FileNotFoundError(self)
-        stream = self.root.open(self.at, zip_mode, pwd=pwd)
-        if 'b' in mode:
-            if args or kwargs:
-                raise ValueError("encoding args invalid for binary operation")
-            return stream
-        return io.TextIOWrapper(stream, *args, **kwargs)
-
-    @property
-    def name(self):
-        return pathlib.Path(self.at).name or self.filename.name
-
-    @property
-    def suffix(self):
-        return pathlib.Path(self.at).suffix or self.filename.suffix
-
-    @property
-    def suffixes(self):
-        return pathlib.Path(self.at).suffixes or self.filename.suffixes
-
-    @property
-    def stem(self):
-        return pathlib.Path(self.at).stem or self.filename.stem
-
-    @property
-    def filename(self):
-        return pathlib.Path(self.root.filename).joinpath(self.at)
-
-    def read_text(self, *args, **kwargs):
-        with self.open('r', *args, **kwargs) as strm:
-            return strm.read()
-
-    def read_bytes(self):
-        with self.open('rb') as strm:
-            return strm.read()
-
-    def _is_child(self, path):
-        return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/")
-
-    def _next(self, at):
-        return self.__class__(self.root, at)
-
-    def is_dir(self):
-        return not self.at or self.at.endswith("/")
-
-    def is_file(self):
-        return self.exists() and not self.is_dir()
-
-    def exists(self):
-        return self.at in self.root._name_set()
-
-    def iterdir(self):
-        if not self.is_dir():
-            raise ValueError("Can't listdir a file")
-        subs = map(self._next, self.root.namelist())
-        return filter(self._is_child, subs)
-
-    def __str__(self):
-        return posixpath.join(self.root.filename, self.at)
-
-    def __repr__(self):
-        return self.__repr.format(self=self)
-
-    def joinpath(self, *other):
-        next = posixpath.join(self.at, *map(_pathlib_compat, other))
-        return self._next(self.root.resolve_dir(next))
-
-    __truediv__ = joinpath
-
-    @property
-    def parent(self):
-        if not self.at:
-            return self.filename.parent
-        parent_at = posixpath.dirname(self.at.rstrip('/'))
-        if parent_at:
-            parent_at += '/'
-        return self._next(parent_at)

metaflow/info_file.py

@@ -1,25 +0,0 @@
-import json
-
-from os import path
-
-CURRENT_DIRECTORY = path.dirname(path.abspath(__file__))
-INFO_FILE = path.join(path.dirname(CURRENT_DIRECTORY), "INFO")
-
-_info_file_content = None
-_info_file_present = None
-
-
-def read_info_file():
-    global _info_file_content
-    global _info_file_present
-    if _info_file_present is None:
-        _info_file_present = path.exists(INFO_FILE)
-        if _info_file_present:
-            try:
-                with open(INFO_FILE, "r", encoding="utf-8") as contents:
-                    _info_file_content = json.load(contents)
-            except IOError:
-                pass
-    if _info_file_present:
-        return _info_file_content
-    return None

metaflow/package.py

@@ -1,203 +0,0 @@
-import importlib
-import os
-import sys
-import tarfile
-import time
-import json
-from io import BytesIO
-
-from .user_configs.config_parameters import CONFIG_FILE, dump_config_values
-from .extension_support import EXT_PKG, package_mfext_all
-from .metaflow_config import DEFAULT_PACKAGE_SUFFIXES
-from .exception import MetaflowException
-from .util import to_unicode
-from . import R
-from .info_file import INFO_FILE
-
-DEFAULT_SUFFIXES_LIST = DEFAULT_PACKAGE_SUFFIXES.split(",")
-METAFLOW_SUFFIXES_LIST = [".py", ".html", ".css", ".js"]
-
-
-class NonUniqueFileNameToFilePathMappingException(MetaflowException):
-    headline = "Non Unique file path for a file name included in code package"
-
-    def __init__(self, filename, file_paths, lineno=None):
-        msg = (
-            "Filename %s included in the code package includes multiple different paths for the same name : %s.\n"
-            "The `filename` in the `add_to_package` decorator hook requires a unique `file_path` to `file_name` mapping"
-            % (filename, ", ".join(file_paths))
-        )
-        super().__init__(msg=msg, lineno=lineno)
-
-
-# this is os.walk(follow_symlinks=True) with cycle detection
-def walk_without_cycles(top_root):
-    seen = set()
-
-    def _recurse(root):
-        for parent, dirs, files in os.walk(root):
-            for d in dirs:
-                path = os.path.join(parent, d)
-                if os.path.islink(path):
-                    # Breaking loops: never follow the same symlink twice
-                    #
-                    # NOTE: this also means that links to sibling links are
-                    # not followed. In this case:
-                    #
-                    #   x -> y
-                    #   y -> oo
-                    #   oo/real_file
-                    #
-                    # real_file is only included twice, not three times
-                    reallink = os.path.realpath(path)
-                    if reallink not in seen:
-                        seen.add(reallink)
-                        for x in _recurse(path):
-                            yield x
-            yield parent, files
-
-    for x in _recurse(top_root):
-        yield x
-
-
-class MetaflowPackage(object):
-    def __init__(self, flow, environment, echo, suffixes=DEFAULT_SUFFIXES_LIST):
-        self.suffixes = list(set().union(suffixes, DEFAULT_SUFFIXES_LIST))
-        self.environment = environment
-        self.metaflow_root = os.path.dirname(__file__)
-
-        self.flow_name = flow.name
-        self._flow = flow
-        self.create_time = time.time()
-        environment.init_environment(echo)
-        for step in flow:
-            for deco in step.decorators:
-                deco.package_init(flow, step.__name__, environment)
-        self.blob = self._make()
-
-    def _walk(self, root, exclude_hidden=True, suffixes=None):
-        if suffixes is None:
-            suffixes = []
-        root = to_unicode(root)  # handle files/folder with non ascii chars
-        prefixlen = len("%s/" % os.path.dirname(root))
-        for (
-            path,
-            files,
-        ) in walk_without_cycles(root):
-            if exclude_hidden and "/." in path:
-                continue
-            # path = path[2:] # strip the ./ prefix
-            # if path and (path[0] == '.' or './' in path):
-            #    continue
-            for fname in files:
-                if (fname[0] == "." and fname in suffixes) or (
-                    fname[0] != "."
-                    and any(fname.endswith(suffix) for suffix in suffixes)
-                ):
-                    p = os.path.join(path, fname)
-                    yield p, p[prefixlen:]
-
-    def path_tuples(self):
-        """
-        Returns list of (path, arcname) to be added to the job package, where
-        `arcname` is the alternative name for the file in the package.
-        """
-        # We want the following contents in the tarball
-        # Metaflow package itself
-        for path_tuple in self._walk(
-            self.metaflow_root, exclude_hidden=False, suffixes=METAFLOW_SUFFIXES_LIST
-        ):
-            yield path_tuple
-
-        # Metaflow extensions; for now, we package *all* extensions but this may change
-        # at a later date; it is possible to call `package_mfext_package` instead of
-        # `package_mfext_all` but in that case, make sure to also add a
-        # metaflow_extensions/__init__.py file to properly "close" the metaflow_extensions
-        # package and prevent other extensions from being loaded that may be
-        # present in the rest of the system
-        for path_tuple in package_mfext_all():
-            yield path_tuple
-
-        # Any custom packages exposed via decorators
-        deco_module_paths = {}
-        for step in self._flow:
-            for deco in step.decorators:
-                for path_tuple in deco.add_to_package():
-                    file_path, file_name = path_tuple
-                    # Check if the path is not duplicated as
-                    # many steps can have the same packages being imported
-                    if file_name not in deco_module_paths:
-                        deco_module_paths[file_name] = file_path
-                        yield path_tuple
-                    elif deco_module_paths[file_name] != file_path:
-                        raise NonUniqueFileNameToFilePathMappingException(
-                            file_name, [deco_module_paths[file_name], file_path]
-                        )
-
-        # the package folders for environment
-        for path_tuple in self.environment.add_to_package():
-            yield path_tuple
-        if R.use_r():
-            # the R working directory
-            for path_tuple in self._walk(
-                "%s/" % R.working_dir(), suffixes=self.suffixes
-            ):
-                yield path_tuple
-            # the R package
-            for path_tuple in R.package_paths():
-                yield path_tuple
-        else:
-            # the user's working directory
-            flowdir = os.path.dirname(os.path.abspath(sys.argv[0])) + "/"
-            for path_tuple in self._walk(flowdir, suffixes=self.suffixes):
-                yield path_tuple
-
-    def _add_configs(self, tar):
-        buf = BytesIO()
-        buf.write(json.dumps(dump_config_values(self._flow)).encode("utf-8"))
-        self._add_file(tar, os.path.basename(CONFIG_FILE), buf)
-
-    def _add_info(self, tar):
-        buf = BytesIO()
-        buf.write(
-            json.dumps(
-                self.environment.get_environment_info(include_ext_info=True)
-            ).encode("utf-8")
-        )
-        self._add_file(tar, os.path.basename(INFO_FILE), buf)
-
-    @staticmethod
-    def _add_file(tar, filename, buf):
-        info = tarfile.TarInfo(filename)
-        buf.seek(0)
-        info.size = len(buf.getvalue())
-        # Setting this default to Dec 3, 2019
-        info.mtime = 1575360000
-        tar.addfile(info, buf)
-
-    def _make(self):
-        def no_mtime(tarinfo):
-            # a modification time change should not change the hash of
-            # the package. Only content modifications will.
-            # Setting this default to Dec 3, 2019
-            tarinfo.mtime = 1575360000
-            return tarinfo
-
-        buf = BytesIO()
-        with tarfile.open(
-            fileobj=buf, mode="w:gz", compresslevel=3, dereference=True
-        ) as tar:
-            self._add_info(tar)
-            self._add_configs(tar)
-            for path, arcname in self.path_tuples():
-                tar.add(path, arcname=arcname, recursive=False, filter=no_mtime)
-
-        blob = bytearray(buf.getvalue())
-        blob[4:8] = [0] * 4  # Reset 4 bytes from offset 4 to account for ts
-        return blob
-
-    def __str__(self):
-        return "<code package for flow %s (created @ %s)>" % (
-            self.flow_name,
-            time.strftime("%a, %d %b %Y %H:%M:%S", self.create_time),
-        )