metaflow-prebuilt 0.2.1__py2.py3-none-any.whl

metaflow_extensions/prebuilt/plugins/conda/build_service.py

@@ -0,0 +1,76 @@
+import importlib.metadata
+import os
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Dict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+
+def _resolve_entry_point(group: str, name: str) -> Any:
+    try:
+        eps = importlib.metadata.entry_points(group=group)
+    except TypeError:
+        # Python 3.8 compatibility
+        eps = importlib.metadata.entry_points().get(group, [])  # type: ignore[assignment]
+    mapping = {ep.name: ep for ep in eps}
+    if name not in mapping:
+        from metaflow.exception import MetaflowException  # noqa: PLC0415
+
+        raise MetaflowException(
+            "No entry point named %r in group %r. "
+            "Installed: %s. "
+            "Install the package that provides this backend or check "
+            "METAFLOW_PREBUILT_BUILD_SERVICE." % (name, group, sorted(mapping))
+        )
+    return mapping[name].load()
+
+
+class DockerBuildService(ABC):
+    """Abstract base class for Docker image build-and-push backends.
+
+    Implement this class and register it under the
+    ``metaflow_prebuilt.build_services`` entry point group to make it
+    selectable via ``METAFLOW_PREBUILT_BUILD_SERVICE=<name>``.
+    """
+
+    @abstractmethod
+    def build_and_push(
+        self,
+        dockerfile: str,
+        context_files: Dict[str, Any],
+        image_tag: str,
+        push_credentials: Dict[str, Any],
+        echo: Callable[..., None],
+    ) -> bool:
+        """Build a Docker image and push it to the registry.
+
+        Args:
+            dockerfile: Full Dockerfile content.
+            context_files: Files to include in the build context alongside the
+                Dockerfile. Keys are filenames; values are ``str`` (text) or
+                ``bytes`` (binary).
+            image_tag: Fully-qualified destination tag, e.g.
+                ``registry.example.com/ns/name:v28-abc123``.
+                Provided by ``ImageRegistry.push_tag()``.
+            push_credentials: Opaque dict from ``ImageRegistry.push_credentials()``.
+                Schema is defined by the paired registry implementation.
+            echo: Callable for user-visible progress output.
+
+        Returns:
+            ``True`` on success, ``False`` on recoverable failure.
+            Must NOT raise on recoverable failures — return ``False`` and
+            call ``echo()`` with a diagnostic. MAY raise on programmer errors.
+        """
+        ...
+
+    @classmethod
+    def from_config(cls) -> "DockerBuildService":
+        """Resolve and instantiate the build service selected by
+        ``METAFLOW_PREBUILT_BUILD_SERVICE`` (default: ``docker``).
+
+        Raises ``MetaflowException`` if the name is not registered.
+        """
+        name = os.environ.get("METAFLOW_PREBUILT_BUILD_SERVICE", "docker")
+        service_cls = _resolve_entry_point("metaflow_prebuilt.build_services", name)
+        return service_cls()

metaflow_extensions/prebuilt/plugins/conda/image_registry.py

@@ -0,0 +1,97 @@
+import os
+from abc import ABC, abstractmethod
+from typing import Any, Dict, TYPE_CHECKING
+
+from .build_service import _resolve_entry_point
+
+if TYPE_CHECKING:
+    from metaflow_extensions.nflx.plugins.conda.env_descr import EnvID
+
+
+class ImageRegistry(ABC):
+    """Abstract base class for Docker image registries.
+
+    Implement this class and register it under the
+    ``metaflow_prebuilt.image_registries`` entry point group to make it
+    selectable via ``METAFLOW_PREBUILT_IMAGE_REGISTRY=<name>``.
+
+    For most registries ``push_tag()`` and ``pull_tag()`` both delegate to
+    ``image_tag()`` — subclasses only need to implement ``image_tag()``.
+    Override ``push_tag()`` and/or ``pull_tag()`` independently only when the
+    push address differs from the pull address (e.g. ``LocalRegistry``).
+    """
+
+    @abstractmethod
+    def image_tag(self, env_id: "EnvID") -> str:
+        """Canonical fully-qualified image tag for the given env_id.
+
+        Used as the default return value for both ``push_tag()`` and
+        ``pull_tag()``. Format: ``<registry>/<namespace>/<name>:<version>``.
+        """
+        ...
+
+    def push_tag(self, env_id: "EnvID") -> str:
+        """Tag the build service uses to push. Defaults to ``image_tag()``."""
+        return self.image_tag(env_id)
+
+    def pull_tag(self, env_id: "EnvID") -> str:
+        """Tag baked into the remote runner spec. Defaults to ``image_tag()``."""
+        return self.image_tag(env_id)
+
+    def image_tag_for_named(self, name: str) -> str:
+        """Full mutable tag for a ``@named_env(fetch_at_exec=True)`` env.
+
+        Tagged by alias name (not env_id hash) so subsequent deploys under the
+        same name overwrite the manifest — matching fetch_at_exec semantics.
+
+        Raises ``NotImplementedError`` by default; registries that support named
+        envs must override this method.
+        """
+        raise NotImplementedError(
+            "Registry %r does not implement named env tags. "
+            "Override image_tag_for_named() to use @named_env(fetch_at_exec=True)."
+            % type(self).__name__
+        )
+
+    def push_tag_for_named(self, name: str) -> str:
+        """Push-side tag for a named env. Defaults to ``image_tag_for_named()``."""
+        return self.image_tag_for_named(name)
+
+    def pull_tag_for_named(self, name: str) -> str:
+        """Pull-side tag for a named env. Defaults to ``push_tag_for_named()``."""
+        return self.push_tag_for_named(name)
+
+    @abstractmethod
+    def push_credentials(self) -> Dict[str, Any]:
+        """Credentials/config passed to ``DockerBuildService.build_and_push``.
+
+        Return ``{}`` when the build service uses ambient auth (e.g. docker login).
+        The schema is build-service-specific; see the ``DockerBuildService``
+        contract for which keys each service consumes.
+        """
+        ...
+
+    @abstractmethod
+    def pull_config(self, pull_tag: str) -> Dict[str, Any]:
+        """Attributes to inject into the remote runner decorator so it can pull
+        the image at ``pull_tag``.
+
+        Return ``{}`` when the runner has ambient pull credentials (e.g. an IAM
+        role for ECR + Batch, or a service account for GKE).
+
+        Non-empty example (private registry with K8s imagePullSecrets)::
+
+            {"image_pull_policy": "Always", "image_pull_secrets": "my-secret"}
+        """
+        ...
+
+    @classmethod
+    def from_config(cls) -> "ImageRegistry":
+        """Resolve and instantiate the registry selected by
+        ``METAFLOW_PREBUILT_IMAGE_REGISTRY`` (default: ``dockerhub``).
+
+        Raises ``MetaflowException`` if the name is not registered.
+        """
+        name = os.environ.get("METAFLOW_PREBUILT_IMAGE_REGISTRY", "dockerhub")
+        registry_cls = _resolve_entry_point("metaflow_prebuilt.image_registries", name)
+        return registry_cls()

metaflow_extensions/prebuilt/plugins/conda/prebuilt_build_install.py

@@ -0,0 +1,21 @@
+"""
+Build-time conda installer stub.
+
+This module is intentionally empty in the OSS metaflow-prebuilt package.
+The real implementation lives alongside the conda stack (e.g. nflx-metaflow's
+metaflow_extensions.nflx.plugins.conda.prebuilt_build_install), which
+imports the Conda class and related utilities needed to install the env.
+
+Set PrebuiltCondaEnvironment._BUILD_INSTALL_MODULE to the package that
+provides the real prebuilt_build_install module.
+"""
+
+import sys
+
+if __name__ == "__main__":
+    print(
+        "ERROR: This is a stub. Configure PrebuiltCondaEnvironment._BUILD_INSTALL_MODULE "
+        "to point to a real prebuilt_build_install implementation.",
+        file=sys.stderr,
+    )
+    sys.exit(1)