modal 0.62.115__py3-none-any.whl → 0.72.13__py3-none-any.whl

modal/_utils/deprecation.py

@@ -0,0 +1,89 @@
+# Copyright Modal Labs 2024
+import functools
+import sys
+import warnings
+from datetime import date
+from typing import Any, Callable, TypeVar
+
+from typing_extensions import ParamSpec  # Needed for Python 3.9
+
+from ..exception import DeprecationError, PendingDeprecationError
+
+_INTERNAL_MODULES = ["modal", "synchronicity"]
+
+
+def _is_internal_frame(frame):
+    module = frame.f_globals["__name__"].split(".")[0]
+    return module in _INTERNAL_MODULES
+
+
+def deprecation_error(deprecated_on: tuple[int, int, int], msg: str):
+    raise DeprecationError(f"Deprecated on {date(*deprecated_on)}: {msg}")
+
+
+def deprecation_warning(
+    deprecated_on: tuple[int, int, int], msg: str, *, pending: bool = False, show_source: bool = True
+) -> None:
+    """Issue a Modal deprecation warning with source optionally attributed to user code.
+
+    See the implementation of the built-in [warnings.warn](https://docs.python.org/3/library/warnings.html#available-functions).
+    """
+    filename, lineno = "<unknown>", 0
+    if show_source:
+        # Find the last non-Modal line that triggered the warning
+        try:
+            frame = sys._getframe()
+            while frame is not None and _is_internal_frame(frame):
+                frame = frame.f_back
+            if frame is not None:
+                filename = frame.f_code.co_filename
+                lineno = frame.f_lineno
+        except ValueError:
+            # Use the defaults from above
+            pass
+
+    warning_cls = PendingDeprecationError if pending else DeprecationError
+
+    # This is a lower-level function that warnings.warn uses
+    warnings.warn_explicit(f"{date(*deprecated_on)}: {msg}", warning_cls, filename, lineno)
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def renamed_parameter(
+    date: tuple[int, int, int],
+    old_name: str,
+    new_name: str,
+    show_source: bool = True,
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Decorator for semi-gracefully changing a parameter name.
+
+    Functions wrapped with this decorator can be defined using only the `new_name` of the parameter.
+    If the function is invoked with the `old_name`, the wrapper will pass the value as a keyword
+    argument for `new_name` and issue a Modal deprecation warning about the change.
+
+    Note that this only prevents parameter renamings from breaking code at runtime.
+    Type checking will fail when code uses `old_name`. To avoid this, the `old_name` can be
+    preserved in the function signature with an `Annotated` type hint indicating the renaming.
+    """
+
+    def decorator(func: Callable[P, R]) -> Callable[P, R]:
+        @functools.wraps(func)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            mut_kwargs: dict[str, Any] = locals()["kwargs"]  # Avoid referencing kwargs directly due to bug in sigtools
+            if old_name in mut_kwargs:
+                mut_kwargs[new_name] = mut_kwargs.pop(old_name)
+                func_name = func.__qualname__.removeprefix("_")  # Avoid confusion when synchronicity-wrapped
+                message = (
+                    f"The '{old_name}' parameter of `{func_name}` has been renamed to '{new_name}'."
+                    "\nUsing the old name will become an error in a future release. Please update your code."
+                )
+                deprecation_warning(date, message, show_source=show_source)
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

modal/_utils/docker_utils.py

@@ -0,0 +1,98 @@
+# Copyright Modal Labs 2024
+import re
+import shlex
+from pathlib import Path
+from typing import Optional, Sequence
+
+from ..exception import InvalidError
+
+
+def extract_copy_command_patterns(dockerfile_lines: Sequence[str]) -> list[str]:
+    """
+    Extract all COPY command sources from a Dockerfile.
+    Combines multiline COPY commands into a single line.
+    """
+    copy_source_patterns: set[str] = set()
+    current_command = ""
+    copy_pattern = re.compile(r"^\s*COPY\s+(.+)$", re.IGNORECASE)
+
+    # First pass: handle line continuations and collect full commands
+    for line in dockerfile_lines:
+        line = line.strip()
+        if not line or line.startswith("#"):
+            # ignore comments and empty lines
+            continue
+
+        if current_command:
+            # Continue previous line
+            current_command += " " + line.rstrip("\\").strip()
+        else:
+            # Start new command
+            current_command = line.rstrip("\\").strip()
+
+        if not line.endswith("\\"):
+            # Command is complete
+
+            match = copy_pattern.match(current_command)
+            if match:
+                args = match.group(1)
+                parts = shlex.split(args)
+
+                # COPY --from=... commands reference external sources and do not need a context mount.
+                # https://docs.docker.com/reference/dockerfile/#copy---from
+                if parts[0].startswith("--from="):
+                    current_command = ""
+                    continue
+
+                if len(parts) >= 2:
+                    # Last part is destination, everything else is a mount source
+                    sources = parts[:-1]
+
+                    for source in sources:
+                        special_pattern = re.compile(r"^\s*--|\$\s*")
+                        if special_pattern.match(source):
+                            raise InvalidError(
+                                f"COPY command: {source} using special flags/arguments/variables are not supported"
+                            )
+
+                        if source == ".":
+                            copy_source_patterns.add("./**")
+                        else:
+                            copy_source_patterns.add(source)
+
+            current_command = ""
+
+    return list(copy_source_patterns)
+
+
+def find_dockerignore_file(context_directory: Path, dockerfile_path: Optional[Path] = None) -> Optional[Path]:
+    """
+    Find dockerignore file relative to current context directory
+    and if dockerfile path is provided, check if specific <dockerfile_name>.dockerignore
+    file exists in the same directory as <dockerfile_name>
+    Finds the most specific dockerignore file that exists.
+    """
+
+    def valid_dockerignore_file(fp):
+        # fp has to exist
+        if not fp.exists():
+            return False
+        # fp has to be subpath to current working directory
+        if not fp.is_relative_to(context_directory):
+            return False
+
+        return True
+
+    generic_name = ".dockerignore"
+    possible_locations = []
+    if dockerfile_path:
+        specific_name = f"{dockerfile_path.name}.dockerignore"
+        # 1. check if specific <dockerfile_name>.dockerignore file exists in the same directory as <dockerfile_name>
+        possible_locations.append(dockerfile_path.parent / specific_name)
+        # 2. check if generic .dockerignore file exists in the same directory as <dockerfile_name>
+        possible_locations.append(dockerfile_path.parent / generic_name)
+
+    # 3. check if generic .dockerignore file exists in current working directory
+    possible_locations.append(context_directory / generic_name)
+
+    return next((e for e in possible_locations if valid_dockerignore_file(e)), None)