removed some dead code and standardized the ignore interface & made it a bit more ergonomic

Author: james-rl

src/runloop_api_client/lib/_ignore.py

@@ -1,19 +1,23 @@
 from __future__ import annotations
 
 import os
+import tarfile
 from abc import ABC, abstractmethod
-from typing import Iterable, Optional, Sequence
+from typing import Callable, Iterable, Optional, Sequence
 from pathlib import Path, PurePosixPath
 from dataclasses import dataclass
 
 __all__ = [
     "IgnorePattern",
     "IgnoreMatcher",
     "DockerIgnoreMatcher",
+    "FilePatternMatcher",
+    "TarFilterMatcher",
     "read_ignorefile",
     "compile_ignore",
     "path_match",
     "is_ignored",
+    "iter_included_files",
 ]
 
 
@@ -286,6 +290,74 @@ def iter_included_files(
             yield file_path
 
 
+TarFilter = Callable[[tarfile.TarInfo], Optional[tarfile.TarInfo]]
+
+
+def _compute_included_dirs_from_files(included_files: set[str]) -> set[str]:
+    """Return all directory ancestors (plus ``'.'``) for a set of file paths."""
+
+    included_dirs: set[str] = {"."}
+    for rel in included_files:
+        parent = PurePosixPath(rel).parent
+        while True:
+            as_posix = parent.as_posix() or "."
+            included_dirs.add(as_posix)
+            if as_posix == ".":
+                break
+            parent = parent.parent
+    return included_dirs
+
+
+class TarFilterMatcher:
+    """Adapt an :class:`IgnoreMatcher` to a :class:`TarFilter`-compatible callable.
+
+    This helper precomputes the set of included files under ``root`` using the
+    provided :class:`IgnoreMatcher` and converts that into a simple tar filter:
+
+    - Only files returned by ``matcher.iter_paths(root)`` are included.
+    - Directory entries are included only when they are ancestors of at least
+      one included file (plus the root ``'.'`` entry).
+
+    Member names passed to ``__call__`` are expected to be relative to
+    ``root`` and to use POSIX ``'/'`` separators, matching the behaviour of
+    ``build_directory_tar`` in :mod:`runloop_api_client.lib.context_loader`.
+    """
+
+    def __init__(self, root: Path, matcher: IgnoreMatcher) -> None:
+        self._root = root.resolve()
+
+        # Compute the set of included files as relative POSIX paths.
+        # Note: the majority of the work being performed here is simply to deal with the path to the root.
+        included_files: set[str] = set()
+        for path in matcher.iter_paths(self._root):
+            rel = path.resolve().relative_to(self._root)
+            rel_posix = PurePosixPath(rel).as_posix()
+            included_files.add(rel_posix)
+
+        included_dirs = _compute_included_dirs_from_files(included_files)
+
+        self._included_files = included_files
+        self._included_dirs = included_dirs
+
+    def __call__(self, ti: tarfile.TarInfo) -> Optional[tarfile.TarInfo]:
+        name = ti.name
+
+        # The root of the archive is always kept.
+        if name == ".":
+            return ti
+
+        if ti.isdir():
+            if name in self._included_dirs:
+                return ti
+            return None
+
+        # Non-directory entries (files, symlinks, etc.) are kept only if their
+        # relative path is in the included file set.
+        if name in self._included_files:
+            return ti
+        return None
+
+
 class IgnoreMatcher(ABC):
     """Abstract interface for ignore matchers like .dockerignore and .gitignore.
 
@@ -342,3 +414,30 @@ def iter_paths(self, root: Path) -> Iterable[Path]:
 
         compiled: list[IgnorePattern] = compile_ignore(all_patterns)
         return iter_included_files(root, patterns=compiled)
+
+
+@dataclass(frozen=True)
+class FilePatternMatcher(IgnoreMatcher):
+    """Ignore matcher that applies only inline patterns, without .dockerignore.
+
+    Patterns follow the same semantics as :func:`compile_ignore` / Docker-style
+    ignore files and are treated as *ignore* rules (``!`` negation for
+    re-inclusion, ``**`` support, etc.).
+
+    The constructor accepts either a single pattern string or a sequence of
+    pattern strings; a single string is automatically wrapped into a list.
+    """
+
+    patterns: Sequence[str] | str
+
+    def __post_init__(self) -> None:
+        # Normalise a single pattern string into a list for downstream helpers.
+        if isinstance(self.patterns, str):
+            object.__setattr__(self, "patterns", [self.patterns])
+
+    def iter_paths(self, root: Path) -> Iterable[Path]:
+        """Yield non-ignored files under ``root`` based only on ``patterns``."""
+
+        root = root.resolve()
+        compiled: list[IgnorePattern] = compile_ignore(self.patterns)  # type: ignore[arg-type]
+        return iter_included_files(root, patterns=compiled)

src/runloop_api_client/lib/context_loader.py

@@ -2,18 +2,18 @@
 
 import io
 import tarfile
-from typing import Callable, Iterable, Optional, Sequence
+from typing import Callable, Optional, Sequence
 from pathlib import Path
 
-from ._ignore import IgnoreMatcher, IgnorePattern, DockerIgnoreMatcher, iter_included_files
+from ._ignore import IgnoreMatcher, DockerIgnoreMatcher
 
 TarFilter = Callable[[tarfile.TarInfo], Optional[tarfile.TarInfo]]
 
 
 def build_docker_context_tar(
     context_root: Path,
     *,
-    ignore: Optional[IgnoreMatcher] = None,
+    ignore: IgnoreMatcher | Sequence[str] | None = None,
 ) -> bytes:
     """Create a .tar.gz of the build context, honoring Docker-style ignore patterns.
 
@@ -25,7 +25,15 @@ def build_docker_context_tar(
 
     context_root = context_root.resolve()
 
-    matcher: IgnoreMatcher = ignore or DockerIgnoreMatcher()
+    if ignore is None:
+        matcher: IgnoreMatcher = DockerIgnoreMatcher()
+    elif isinstance(ignore, IgnoreMatcher):
+        matcher = ignore
+    else:
+        # Treat sequences of pattern strings as additional inline patterns
+        # appended after ``.dockerignore`` (if present), mirroring
+        # :class:`DockerIgnoreMatcher` semantics.
+        matcher = DockerIgnoreMatcher(patterns=list(ignore))
 
     buf = io.BytesIO()
 
@@ -50,20 +58,21 @@ def build_directory_tar(
 
     root = root.resolve()
     buf = io.BytesIO()
-    with tarfile.open(mode="w:gz", fileobj=buf) as tf:
-        for file_path in root.rglob("*"):
-            if not file_path.is_file():
-                continue
-            rel = file_path.relative_to(root)
-            tf.add(file_path, arcname=rel.as_posix(), filter=tar_filter)
-    return buf.getvalue()
 
+    def _wrapped_filter(ti: tarfile.TarInfo) -> Optional[tarfile.TarInfo]:
+        # Normalise member names so callers see paths relative to ``root``
+        # without a leading ``./``, preserving existing TarFilter semantics and
+        # archive layout. This applies to both files and directories.
+        if ti.name.startswith("./"):
+            ti.name = ti.name[2:]
 
-def _iter_build_context_files(
-    context_root: Path,
-    *,
-    patterns: Sequence[IgnorePattern],
-) -> Iterable[Path]:
-    """Yield files to include in the build context, honoring ignore patterns."""
+        if tar_filter is not None:
+            return tar_filter(ti)
+        return ti
 
-    return iter_included_files(context_root, patterns=patterns)
+    with tarfile.open(mode="w:gz", fileobj=buf) as tf:
+        # Add the root directory recursively in one call, delegating member
+        # handling to the wrapped filter above.
+        tf.add(root, arcname=".", filter=_wrapped_filter)
+
+    return buf.getvalue()

src/runloop_api_client/sdk/_build_context.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Dict, Mapping, Optional
+from typing import Dict, Mapping, Optional, Sequence
 from pathlib import Path
 from datetime import timedelta
 from typing_extensions import Unpack
@@ -24,10 +24,11 @@
 from .._types import Timeout, NotGiven, not_given
 from .._client import DEFAULT_MAX_RETRIES, AsyncRunloop
 from ._helpers import detect_content_type
+from ..lib._ignore import IgnoreMatcher, TarFilterMatcher, FilePatternMatcher
 from .async_devbox import AsyncDevbox
 from .async_snapshot import AsyncSnapshot
 from .async_blueprint import AsyncBlueprint
-from ..lib.context_loader import TarFilter, build_directory_tar
+from ..lib.context_loader import build_directory_tar
 from .async_storage_object import AsyncStorageObject
 from ..types.object_create_params import ContentType
 
@@ -375,7 +376,7 @@ async def upload_from_dir(
         name: Optional[str] = None,
         metadata: Optional[Dict[str, str]] = None,
         ttl: Optional[timedelta] = None,
-        ignore: TarFilter | None = None,
+        ignore: IgnoreMatcher | Sequence[str] | str | None = None,
         **options: Unpack[LongRequestOptions],
     ) -> AsyncStorageObject:
         """Create and upload an object from a local directory.
@@ -390,10 +391,17 @@ async def upload_from_dir(
         :type metadata: Optional[Dict[str, str]]
         :param ttl: Optional Time-To-Live, after which the object is automatically deleted
         :type ttl: Optional[timedelta]
-        :param ignore: Optional tar filter function compatible with
-            :meth:`tarfile.TarFile.add`. If provided, it will be called for each
-            member to allow modification or exclusion (by returning ``None``).
-        :type ignore: Optional[TarFilter]
+        :param ignore: Optional ignore configuration controlling which files from
+            ``dir_path`` are included in the uploaded tarball. This may be:
+
+            - An :class:`~runloop_api_client.lib._ignore.IgnoreMatcher`
+              implementation such as :class:`~runloop_api_client.lib._ignore.DockerIgnoreMatcher`
+              or :class:`~runloop_api_client.lib._ignore.FilePatternMatcher`.
+            - A single pattern string.
+            - A sequence of pattern strings.
+
+            Patterns follow Docker-style semantics (``!`` negation, ``**`` support).
+        :type ignore: Optional[IgnoreMatcher | Sequence[str] | str]
         :param options: See :typeddict:`~runloop_api_client.sdk._types.LongRequestOptions`
             for available options
         :return: Wrapper for the uploaded object
@@ -408,7 +416,17 @@ async def upload_from_dir(
         ttl_ms = int(ttl.total_seconds()) * 1000 if ttl else None
 
         def synchronous_io() -> bytes:
-            return build_directory_tar(path, tar_filter=ignore)
+            matcher: IgnoreMatcher | None
+            if ignore is None:
+                matcher = None
+            elif isinstance(ignore, IgnoreMatcher):
+                matcher = ignore
+            else:
+                matcher = FilePatternMatcher(ignore)  # type: ignore[arg-type]
+
+            if matcher is None:
+                return build_directory_tar(path)
+            return build_directory_tar(path, tar_filter=TarFilterMatcher(path, matcher))
 
         tar_bytes = await asyncio.to_thread(synchronous_io)