metaflow 2.16.5__py2.py3-none-any.whl → 2.16.7__py2.py3-none-any.whl

metaflow/_vendor/yaml/serializer.py

@@ -0,0 +1,111 @@
+
+__all__ = ['Serializer', 'SerializerError']
+
+from .error import YAMLError
+from .events import *
+from .nodes import *
+
+class SerializerError(YAMLError):
+    pass
+
+class Serializer:
+
+    ANCHOR_TEMPLATE = 'id%03d'
+
+    def __init__(self, encoding=None,
+            explicit_start=None, explicit_end=None, version=None, tags=None):
+        self.use_encoding = encoding
+        self.use_explicit_start = explicit_start
+        self.use_explicit_end = explicit_end
+        self.use_version = version
+        self.use_tags = tags
+        self.serialized_nodes = {}
+        self.anchors = {}
+        self.last_anchor_id = 0
+        self.closed = None
+
+    def open(self):
+        if self.closed is None:
+            self.emit(StreamStartEvent(encoding=self.use_encoding))
+            self.closed = False
+        elif self.closed:
+            raise SerializerError("serializer is closed")
+        else:
+            raise SerializerError("serializer is already opened")
+
+    def close(self):
+        if self.closed is None:
+            raise SerializerError("serializer is not opened")
+        elif not self.closed:
+            self.emit(StreamEndEvent())
+            self.closed = True
+
+    #def __del__(self):
+    #    self.close()
+
+    def serialize(self, node):
+        if self.closed is None:
+            raise SerializerError("serializer is not opened")
+        elif self.closed:
+            raise SerializerError("serializer is closed")
+        self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
+            version=self.use_version, tags=self.use_tags))
+        self.anchor_node(node)
+        self.serialize_node(node, None, None)
+        self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
+        self.serialized_nodes = {}
+        self.anchors = {}
+        self.last_anchor_id = 0
+
+    def anchor_node(self, node):
+        if node in self.anchors:
+            if self.anchors[node] is None:
+                self.anchors[node] = self.generate_anchor(node)
+        else:
+            self.anchors[node] = None
+            if isinstance(node, SequenceNode):
+                for item in node.value:
+                    self.anchor_node(item)
+            elif isinstance(node, MappingNode):
+                for key, value in node.value:
+                    self.anchor_node(key)
+                    self.anchor_node(value)
+
+    def generate_anchor(self, node):
+        self.last_anchor_id += 1
+        return self.ANCHOR_TEMPLATE % self.last_anchor_id
+
+    def serialize_node(self, node, parent, index):
+        alias = self.anchors[node]
+        if node in self.serialized_nodes:
+            self.emit(AliasEvent(alias))
+        else:
+            self.serialized_nodes[node] = True
+            self.descend_resolver(parent, index)
+            if isinstance(node, ScalarNode):
+                detected_tag = self.resolve(ScalarNode, node.value, (True, False))
+                default_tag = self.resolve(ScalarNode, node.value, (False, True))
+                implicit = (node.tag == detected_tag), (node.tag == default_tag)
+                self.emit(ScalarEvent(alias, node.tag, implicit, node.value,
+                    style=node.style))
+            elif isinstance(node, SequenceNode):
+                implicit = (node.tag
+                            == self.resolve(SequenceNode, node.value, True))
+                self.emit(SequenceStartEvent(alias, node.tag, implicit,
+                    flow_style=node.flow_style))
+                index = 0
+                for item in node.value:
+                    self.serialize_node(item, node, index)
+                    index += 1
+                self.emit(SequenceEndEvent())
+            elif isinstance(node, MappingNode):
+                implicit = (node.tag
+                            == self.resolve(MappingNode, node.value, True))
+                self.emit(MappingStartEvent(alias, node.tag, implicit,
+                    flow_style=node.flow_style))
+                for key, value in node.value:
+                    self.serialize_node(key, node, None)
+                    self.serialize_node(value, node, key)
+                self.emit(MappingEndEvent())
+            self.ascend_resolver()
+

metaflow/_vendor/yaml/tokens.py

@@ -0,0 +1,104 @@
+
+class Token(object):
+    def __init__(self, start_mark, end_mark):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+    def __repr__(self):
+        attributes = [key for key in self.__dict__
+                if not key.endswith('_mark')]
+        attributes.sort()
+        arguments = ', '.join(['%s=%r' % (key, getattr(self, key))
+                for key in attributes])
+        return '%s(%s)' % (self.__class__.__name__, arguments)
+
+#class BOMToken(Token):
+#    id = '<byte order mark>'
+
+class DirectiveToken(Token):
+    id = '<directive>'
+    def __init__(self, name, value, start_mark, end_mark):
+        self.name = name
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class DocumentStartToken(Token):
+    id = '<document start>'
+
+class DocumentEndToken(Token):
+    id = '<document end>'
+
+class StreamStartToken(Token):
+    id = '<stream start>'
+    def __init__(self, start_mark=None, end_mark=None,
+            encoding=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.encoding = encoding
+
+class StreamEndToken(Token):
+    id = '<stream end>'
+
+class BlockSequenceStartToken(Token):
+    id = '<block sequence start>'
+
+class BlockMappingStartToken(Token):
+    id = '<block mapping start>'
+
+class BlockEndToken(Token):
+    id = '<block end>'
+
+class FlowSequenceStartToken(Token):
+    id = '['
+
+class FlowMappingStartToken(Token):
+    id = '{'
+
+class FlowSequenceEndToken(Token):
+    id = ']'
+
+class FlowMappingEndToken(Token):
+    id = '}'
+
+class KeyToken(Token):
+    id = '?'
+
+class ValueToken(Token):
+    id = ':'
+
+class BlockEntryToken(Token):
+    id = '-'
+
+class FlowEntryToken(Token):
+    id = ','
+
+class AliasToken(Token):
+    id = '<alias>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class AnchorToken(Token):
+    id = '<anchor>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class TagToken(Token):
+    id = '<tag>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class ScalarToken(Token):
+    id = '<scalar>'
+    def __init__(self, value, plain, start_mark, end_mark, style=None):
+        self.value = value
+        self.plain = plain
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.style = style
+

metaflow/cli.py

@@ -7,6 +7,7 @@ from datetime import datetime
 
 import metaflow.tracing as tracing
 from metaflow._vendor import click
+from metaflow.system import _system_logger, _system_monitor
 
 from . import decorators, lint, metaflow_version, parameters, plugins
 from .cli_args import cli_args
@@ -26,7 +27,6 @@ from .metaflow_config import (
     DEFAULT_PACKAGE_SUFFIXES,
 )
 from .metaflow_current import current
-from metaflow.system import _system_monitor, _system_logger
 from .metaflow_environment import MetaflowEnvironment
 from .packaging_sys import MetaflowCodeContent
 from .plugins import (
@@ -38,9 +38,9 @@ from .plugins import (
 )
 from .pylint_wrapper import PyLint
 from .R import metaflow_r_version, use_r
-from .util import get_latest_run_id, resolve_identity
 from .user_configs.config_options import LocalFileInput, config_options
 from .user_configs.config_parameters import ConfigValue
+from .util import get_latest_run_id, resolve_identity
 
 ERASE_TO_EOL = "\033[K"
 HIGHLIGHT = "red"
@@ -56,6 +56,15 @@ def echo_dev_null(*args, **kwargs):
 
 
 def echo_always(line, **kwargs):
+    if kwargs.pop("wrap", False):
+        import textwrap
+
+        indent_str = INDENT if kwargs.get("indent", None) else ""
+        effective_width = 80 - len(indent_str)
+        wrapped = textwrap.wrap(line, width=effective_width, break_long_words=False)
+        line = "\n".join(indent_str + l for l in wrapped)
+        kwargs["indent"] = False
+
     kwargs["err"] = kwargs.get("err", True)
     if kwargs.pop("indent", None):
         line = "\n".join(INDENT + x for x in line.splitlines())

metaflow/client/core.py

@@ -831,10 +831,12 @@ class MetaflowCode(object):
         )
         self._code_obj = BytesIO(blobdata)
         self._info = MetaflowPackage.cls_get_info(self._code_metadata, self._code_obj)
+        self._code_obj.seek(0)
         if self._info:
             self._flowspec = MetaflowPackage.cls_get_content(
                 self._code_metadata, self._code_obj, self._info["script"]
             )
+            self._code_obj.seek(0)
         else:
             raise MetaflowInternalError("Code package metadata is invalid.")
 
@@ -885,7 +887,9 @@ class MetaflowCode(object):
             TarFile for everything in this code package
         """
         if self._backend.type == "tgz":
-            return self._backend.cls_open(self._code_obj)
+            to_return = self._backend.cls_open(self._code_obj)
+            self._code_obj.seek(0)
+            return to_return
         raise RuntimeError("Archive is not a tarball")
 
     def extract(self) -> TemporaryDirectory:
@@ -921,6 +925,7 @@ class MetaflowCode(object):
         MetaflowPackage.cls_extract_into(
             self._code_metadata, self._code_obj, tmp.name, ContentType.USER_CONTENT
         )
+        self._code_obj.seek(0)
         return tmp
 
     @property

metaflow/extension_support/__init__.py

@@ -205,9 +205,10 @@ def package_mfext_all():
     # the packaged metaflow_extensions directory "self-contained" so that
     # python doesn't go and search other parts of the system for more
     # metaflow_extensions.
-    yield os.path.join(
-        os.path.dirname(os.path.abspath(__file__)), "_empty_file.py"
-    ), os.path.join(EXT_PKG, "__init__.py")
+    if _all_packages:
+        yield os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), "_empty_file.py"
+        ), os.path.join(EXT_PKG, "__init__.py")
 
     for p in _all_packages:
         for path_tuple in package_mfext_package(p):

metaflow/metaflow_environment.py

@@ -203,6 +203,19 @@ class MetaflowEnvironment(object):
                     "mfcontent_version": 1,
                 }
             )
+
+        extra_exports = []
+        for k, v in MetaflowPackage.get_post_extract_env_vars(
+            code_package_metadata, dest_dir="$(pwd)"
+        ).items():
+            if k.endswith(":"):
+                # If the value ends with a colon, we override the existing value
+                extra_exports.append("export %s=%s" % (k[:-1], v))
+            else:
+                extra_exports.append(
+                    "export %s=%s:$(printenv %s)" % (k, v.replace('"', '\\"'), k)
+                )
+
         cmds = (
             [
                 BASH_MFLOG,
@@ -226,12 +239,7 @@ class MetaflowEnvironment(object):
             + MetaflowPackage.get_extract_commands(
                 code_package_metadata, "job.tar", dest_dir="."
             )
-            + [
-                "export %s=%s:$(printenv %s)" % (k, v.replace('"', '\\"'), k)
-                for k, v in MetaflowPackage.get_post_extract_env_vars(
-                    code_package_metadata, dest_dir="."
-                ).items()
-            ]
+            + extra_exports
             + [
                 "mflog 'Task is starting.'",
                 "flush_mflogs",

metaflow/package/__init__.py

@@ -17,7 +17,6 @@ from ..packaging_sys.utils import suffix_filter, walk
 from ..metaflow_config import DEFAULT_PACKAGE_SUFFIXES
 from ..exception import MetaflowException
 from ..user_configs.config_parameters import dump_config_values
-from ..util import get_metaflow_root
 from .. import R
 
 DEFAULT_SUFFIXES_LIST = DEFAULT_PACKAGE_SUFFIXES.split(",")
@@ -76,12 +75,22 @@ class MetaflowPackage(object):
             from ..user_decorators.user_flow_decorator import FlowMutatorMeta
             from ..user_decorators.user_step_decorator import UserStepDecoratorMeta
 
-            if (
-                m.__name__ in FlowMutatorMeta._import_modules
-                or m.__name__ in UserStepDecoratorMeta._import_modules
-                or hasattr(m, "METAFLOW_PACKAGE")
-            ):
-                return True
+            # Be very defensive here to filter modules in case there are
+            # some badly behaved modules that have weird values for
+            # METAFLOW_PACKAGE_POLICY for example.
+            try:
+                if (
+                    m.__name__ in FlowMutatorMeta._import_modules
+                    or m.__name__ in UserStepDecoratorMeta._import_modules
+                    or (
+                        hasattr(m, "METAFLOW_PACKAGE_POLICY")
+                        and m.METAFLOW_PACKAGE_POLICY == "include"
+                    )
+                ):
+                    return True
+                return False
+            except:
+                return False
 
         if mfcontent is None:
             self._mfcontent = MetaflowCodeContentV1(criteria=_module_selector)
@@ -350,10 +359,10 @@ class MetaflowPackage(object):
         """
         backend = cls.get_backend(pkg_metadata)
         with backend.cls_open(archive) as opened_archive:
-            include_names = MetaflowCodeContent.get_archive_content_names(
+            include_members = MetaflowCodeContent.get_archive_content_members(
                 opened_archive, content_types, backend
             )
-            backend.extract_members(include_names, dest_dir)
+            backend.cls_extract_members(opened_archive, include_members, dest_dir)
 
     def user_tuples(self, timeout: Optional[float] = None):
         # Wait for at least the blob to be formed

metaflow/packaging_sys/__init__.py

@@ -118,9 +118,7 @@ class MetaflowCodeContent:
         return handling_cls.get_filename_impl(mfcontent_info, filename, content_type)
 
     @classmethod
-    def get_env_vars_for_packaged_metaflow(
-        cls, dest_dir: str
-    ) -> Optional[Dict[str, str]]:
+    def get_env_vars_for_packaged_metaflow(cls, dest_dir: str) -> Dict[str, str]:
         """
         Get the environment variables that are needed to run Metaflow when it is
         packaged. This is typically used to set the PYTHONPATH to include the
@@ -128,17 +126,19 @@ class MetaflowCodeContent:
 
         Returns
         -------
-        Optional[Dict[str, str]]
+        Dict[str, str]
             The environment variables that are needed to run Metaflow when it is
-            packaged -- None if there are no such variables (not packaged for example)
+            packaged it present.
         """
-        mfcontent_info = cls._extract_mfcontent_info()
+        mfcontent_info = cls._extract_mfcontent_info(dest_dir)
         if mfcontent_info is None:
             # No MFCONTENT_MARKER file found -- this is not a packaged Metaflow code
             # package so no environment variables to set.
-            return None
+            return {}
         handling_cls = cls._get_mfcontent_class(mfcontent_info)
-        return handling_cls.get_post_extract_env_vars_impl(dest_dir)
+        v = handling_cls.get_post_extract_env_vars_impl(dest_dir)
+        v["METAFLOW_EXTRACTED_ROOT:"] = dest_dir
+        return v
 
     @classmethod
     def get_archive_info(
@@ -216,15 +216,15 @@ class MetaflowCodeContent:
         )
 
     @classmethod
-    def get_archive_content_names(
+    def get_archive_content_members(
         cls,
         archive: Any,
         content_types: Optional[int] = None,
         packaging_backend: Type[PackagingBackend] = TarPackagingBackend,
-    ) -> List[str]:
+    ) -> List[Any]:
         mfcontent_info = cls._extract_archive_mfcontent_info(archive, packaging_backend)
         handling_cls = cls._get_mfcontent_class(mfcontent_info)
-        return handling_cls.get_archive_content_names_impl(
+        return handling_cls.get_archive_content_members_impl(
             mfcontent_info, archive, content_types, packaging_backend
         )
 
@@ -276,7 +276,9 @@ class MetaflowCodeContent:
                 "Invalid package -- unknown version %s in info: %s"
                 % (version_id, cls._mappings)
             )
-        return cls._mappings[version_id].get_post_extract_env_vars_impl(dest_dir)
+        v = cls._mappings[version_id].get_post_extract_env_vars_impl(dest_dir)
+        v["METAFLOW_EXTRACTED_ROOT:"] = dest_dir
+        return v
 
     # Implement the _impl methods in the base subclass (in this file). These need to
     # happen with as few imports as possible to prevent circular dependencies.
@@ -337,14 +339,14 @@ class MetaflowCodeContent:
         raise NotImplementedError("get_archive_filename_impl not implemented")
 
     @classmethod
-    def get_archive_content_names_impl(
+    def get_archive_content_members_impl(
         cls,
         mfcontent_info: Optional[Dict[str, Any]],
         archive: Any,
         content_types: Optional[int] = None,
         packaging_backend: Type[PackagingBackend] = TarPackagingBackend,
-    ) -> List[str]:
-        raise NotImplementedError("get_archive_content_names_impl not implemented")
+    ) -> List[Any]:
+        raise NotImplementedError("get_archive_content_members_impl not implemented")
 
     @classmethod
     def get_post_extract_env_vars_impl(cls, dest_dir: str) -> Dict[str, str]:
@@ -523,19 +525,22 @@ class MetaflowCodeContent:
         return mfcontent_info
 
     @classmethod
-    def _extract_mfcontent_info(cls) -> Optional[Dict[str, Any]]:
-        if "_local" in cls._cached_mfcontent_info:
-            return cls._cached_mfcontent_info["_local"]
+    def _extract_mfcontent_info(
+        cls, target_dir: Optional[str] = None
+    ) -> Optional[Dict[str, Any]]:
+        target_dir = target_dir or "_local"
+        if target_dir in cls._cached_mfcontent_info:
+            return cls._cached_mfcontent_info[target_dir]
 
         mfcontent_info = None  # type: Optional[Dict[str, Any]]
-        if os.path.exists(os.path.join(get_metaflow_root(), MFCONTENT_MARKER)):
-            with open(
-                os.path.join(get_metaflow_root(), MFCONTENT_MARKER),
-                "r",
-                encoding="utf-8",
-            ) as f:
+        if target_dir == "_local":
+            root = os.environ.get("METAFLOW_EXTRACTED_ROOT", get_metaflow_root())
+        else:
+            root = target_dir
+        if os.path.exists(os.path.join(root, MFCONTENT_MARKER)):
+            with open(os.path.join(root, MFCONTENT_MARKER), "r", encoding="utf-8") as f:
                 mfcontent_info = json.load(f)
-        cls._cached_mfcontent_info["_local"] = mfcontent_info
+        cls._cached_mfcontent_info[target_dir] = mfcontent_info
         return mfcontent_info
 
     def get_package_version(self) -> int:
@@ -627,13 +632,13 @@ class MetaflowCodeContentV0(MetaflowCodeContent, version_id=0):
         return None
 
     @classmethod
-    def get_archive_content_names_impl(
+    def get_archive_content_members_impl(
         cls,
         mfcontent_info: Optional[Dict[str, Any]],
         archive: Any,
         content_types: Optional[int] = None,
         packaging_backend: Type[PackagingBackend] = TarPackagingBackend,
-    ) -> List[str]:
+    ) -> List[Any]:
         """
         For V0, we use a static list of known files to classify the content
         """
@@ -649,16 +654,20 @@ class MetaflowCodeContentV0(MetaflowCodeContent, version_id=0):
             "condav2-1.cnd": ContentType.OTHER_CONTENT.value,
         }
         to_return = []
-        for filename in packaging_backend.cls_list_members(archive):
+        for member in packaging_backend.cls_list_members(archive):
+            filename = packaging_backend.cls_member_name(member)
+            added = False
             for prefix, classification in known_prefixes.items():
                 if (
                     prefix[-1] == "/" and filename.startswith(prefix)
                 ) or prefix == filename:
                     if content_types & classification:
-                        to_return.append(filename)
-                elif content_types & ContentType.USER_CONTENT.value:
-                    # Everything else is user content
-                    to_return.append(filename)
+                        to_return.append(member)
+                        added = True
+                        break
+            if not added and content_types & ContentType.USER_CONTENT.value:
+                # Everything else is user content
+                to_return.append(member)
         return to_return
 
     @classmethod
@@ -705,7 +714,7 @@ class MetaflowCodeContentV1Base(MetaflowCodeContent, version_id=1):
         cls, mfcontent_info: Optional[Dict[str, Any]], filename: str, in_archive: bool
     ) -> str:
         if in_archive:
-            return filename
+            return os.path.join(cls._other_dir, filename)
         return os.path.join(get_metaflow_root(), "..", cls._other_dir, filename)
 
     @classmethod
@@ -713,7 +722,7 @@ class MetaflowCodeContentV1Base(MetaflowCodeContent, version_id=1):
         cls, mfcontent_info: Optional[Dict[str, Any]], filename: str, in_archive: bool
     ) -> str:
         if in_archive:
-            return filename
+            return os.path.join(cls._code_dir, filename)
         return os.path.join(get_metaflow_root(), filename)
 
     @classmethod
@@ -832,37 +841,38 @@ class MetaflowCodeContentV1Base(MetaflowCodeContent, version_id=1):
         return None
 
     @classmethod
-    def get_archive_content_names_impl(
+    def get_archive_content_members_impl(
         cls,
         mfcontent_info: Optional[Dict[str, Any]],
         archive: Any,
         content_types: Optional[int] = None,
         packaging_backend: Type[PackagingBackend] = TarPackagingBackend,
-    ) -> List[str]:
+    ) -> List[Any]:
         to_return = []
         module_content = set(mfcontent_info.get("module_files", []))
-        for filename in packaging_backend.cls_list_members(archive):
+        for member in packaging_backend.cls_list_members(archive):
+            filename = packaging_backend.cls_member_name(member)
             if filename.startswith(cls._other_dir) and (
                 content_types & ContentType.OTHER_CONTENT.value
             ):
-                to_return.append(filename)
+                to_return.append(member)
             elif filename.startswith(cls._code_dir):
                 # Special case for marker which is a other content even if in code.
-                if filename == f"{cls._code_dir}/{MFCONTENT_MARKER}":
+                if filename == MFCONTENT_MARKER:
                     if content_types & ContentType.OTHER_CONTENT.value:
-                        to_return.append(filename)
+                        to_return.append(member)
                     else:
                         continue
                 # Here it is either module or code
                 if os.path.join(cls._code_dir, filename) in module_content:
                     if content_types & ContentType.MODULE_CONTENT.value:
-                        to_return.append(filename)
+                        to_return.append(member)
                 elif content_types & ContentType.CODE_CONTENT.value:
-                    to_return.append(filename)
+                    to_return.append(member)
             else:
                 if content_types & ContentType.USER_CONTENT.value:
                     # Everything else is user content
-                    to_return.append(filename)
+                    to_return.append(member)
         return to_return
 
     @classmethod

metaflow/packaging_sys/backend.py

@@ -57,6 +57,15 @@ class PackagingBackend(ABC):
         """Open the archive from the given content."""
         pass
 
+    @classmethod
+    @abstractmethod
+    def cls_member_name(cls, member: Union[Any, str]) -> str:
+        """
+        Returns the name of the member as a string.
+        This is used to ensure consistent naming across different archive formats.
+        """
+        pass
+
     @classmethod
     @abstractmethod
     def cls_has_member(cls, archive: Any, name: str) -> bool:
@@ -72,14 +81,20 @@ class PackagingBackend(ABC):
     def cls_extract_members(
         cls,
         archive: Any,
-        members: Optional[List[str]] = None,
+        members: Optional[List[Any]] = None,
         dest_dir: str = ".",
     ) -> None:
         pass
 
     @classmethod
     @abstractmethod
-    def cls_list_members(cls, archive: Any) -> Optional[List[str]]:
+    def cls_list_names(cls, archive: Any) -> Optional[List[str]]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def cls_list_members(cls, archive: Any) -> Optional[List[Any]]:
+        """List all members in the archive."""
         pass
 
     def has_member(self, name: str) -> bool:
@@ -93,17 +108,17 @@ class PackagingBackend(ABC):
         raise ValueError("Cannot get member from an uncreated archive")
 
     def extract_members(
-        self, members: Optional[List[str]] = None, dest_dir: str = "."
+        self, members: Optional[List[Any]] = None, dest_dir: str = "."
     ) -> None:
         if self._archive:
             self.cls_extract_members(self._archive, members, dest_dir)
         else:
             raise ValueError("Cannot extract from an uncreated archive")
 
-    def list_members(self) -> Optional[List[str]]:
+    def list_names(self) -> Optional[List[str]]:
         if self._archive:
-            return self.cls_list_members(self._archive)
-        raise ValueError("Cannot list members from an uncreated archive")
+            return self.cls_list_names(self._archive)
+        raise ValueError("Cannot list names from an uncreated archive")
 
     def __enter__(self):
         self.create()