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

modal/_serialization.py

@@ -1,13 +1,16 @@
 # Copyright Modal Labs 2022
 import io
 import pickle
+import typing
+from dataclasses import dataclass
 from typing import Any
 
+from modal._utils.async_utils import synchronizer
 from modal_proto import api_pb2
 
 from ._vendor import cloudpickle
 from .config import logger
-from .exception import DeserializationError, InvalidError
+from .exception import DeserializationError, ExecutionError, InvalidError
 from .object import Object, _Object
 
 PICKLE_PROTOCOL = 4  # Support older Python versions.
@@ -18,10 +21,31 @@ class Pickler(cloudpickle.Pickler):
         super().__init__(buf, protocol=PICKLE_PROTOCOL)
 
     def persistent_id(self, obj):
+        from modal.partial_function import PartialFunction
+
         if isinstance(obj, _Object):
             flag = "_o"
         elif isinstance(obj, Object):
             flag = "o"
+        elif isinstance(obj, PartialFunction):
+            # Special case for PartialObject since it's a synchronicity wrapped object
+            # that's set on serialized classes.
+            # The resulting pickled instance can't be deserialized without this in a
+            # new process, since the original referenced synchronizer will have different
+            # values for `._original_attr` etc.
+
+            impl_object = synchronizer._translate_in(obj)
+            attributes = impl_object.__dict__.copy()
+            # ugly - we remove the `._wrapped_attr` attribute from the implementation instance
+            # to avoid referencing and therefore pickling the wrapped instance despite having
+            # translated it to the implementation type
+
+            # it would be nice if we could avoid this by not having the wrapped instances
+            # be directly linked from objects and instead having a lookup table in the Synchronizer:
+            if synchronizer._wrapped_attr and synchronizer._wrapped_attr in attributes:
+                attributes.pop(synchronizer._wrapped_attr)
+
+            return ("sync", (impl_object.__class__, attributes))
         else:
             return
         if not obj.object_id:
@@ -35,8 +59,20 @@ class Unpickler(pickle.Unpickler):
         super().__init__(buf)
 
     def persistent_load(self, pid):
+        if len(pid) == 2:
+            # more general protocol
+            obj_type, obj_data = pid
+            if obj_type == "sync":  # synchronicity wrapped object
+                # not actually a proto object in this case but the underlying object of a synchronicity object
+                impl_class, attributes = obj_data
+                impl_instance = impl_class.__new__(impl_class)
+                impl_instance.__dict__.update(attributes)
+                return synchronizer._translate_out(impl_instance)
+            else:
+                raise ExecutionError("Unknown serialization format")
+
+        # old protocol, always a 3-tuple
         (object_id, flag, handle_proto) = pid
-
         if flag in ("o", "p", "h"):
             return Object._new_hydrated(object_id, self.client, handle_proto)
         elif flag in ("_o", "_p", "_h"):
@@ -54,6 +90,9 @@ def serialize(obj: Any) -> bytes:
 
 def deserialize(s: bytes, client) -> Any:
     """Deserializes object and replaces all client placeholders by self."""
+    from ._runtime.execution_context import is_local  # Avoid circular import
+
+    env = "local" if is_local() else "remote"
     try:
         return Unpickler(client, io.BytesIO(s)).load()
     except AttributeError as exc:
@@ -72,11 +111,19 @@ def deserialize(s: bytes, client) -> Any:
                 " you have different versions of a library in your local and remote environments."
             ) from exc
     except ModuleNotFoundError as exc:
-        from .execution_context import is_local  # Avoid circular import
-
-        dest = "local" if is_local() else "remote"
         raise DeserializationError(
-            f"Deserialization failed because the '{exc.name}' module is not available in the {dest} environment."
+            f"Deserialization failed because the '{exc.name}' module is not available in the {env} environment."
+        ) from exc
+    except Exception as exc:
+        if env == "remote":
+            # We currently don't always package the full traceback from errors in the remote entrypoint logic.
+            # So try to include as much information as we can in the main error message.
+            more = f": {type(exc)}({str(exc)})"
+        else:
+            # When running locally, we can just rely on standard exception chaining.
+            more = " (see above for details)"
+        raise DeserializationError(
+            f"Encountered an error when deserializing an object in the {env} environment{more}."
         ) from exc
 
 
@@ -336,3 +383,73 @@ def check_valid_cls_constructor_arg(key, obj):
         raise ValueError(
             f"Only pickle-able types are allowed in remote class constructors: argument {key} of type {type(obj)}."
         )
+
+
+@dataclass
+class ParamTypeInfo:
+    default_field: str
+    proto_field: str
+    converter: typing.Callable[[str], typing.Any]
+
+
+PARAM_TYPE_MAPPING = {
+    api_pb2.PARAM_TYPE_STRING: ParamTypeInfo(default_field="string_default", proto_field="string_value", converter=str),
+    api_pb2.PARAM_TYPE_INT: ParamTypeInfo(default_field="int_default", proto_field="int_value", converter=int),
+}
+
+
+def serialize_proto_params(python_params: dict[str, Any], schema: typing.Sequence[api_pb2.ClassParameterSpec]) -> bytes:
+    proto_params: list[api_pb2.ClassParameterValue] = []
+    for schema_param in schema:
+        type_info = PARAM_TYPE_MAPPING.get(schema_param.type)
+        if not type_info:
+            raise ValueError(f"Unsupported parameter type: {schema_param.type}")
+        proto_param = api_pb2.ClassParameterValue(
+            name=schema_param.name,
+            type=schema_param.type,
+        )
+        python_value = python_params.get(schema_param.name)
+        if python_value is None:
+            if schema_param.has_default:
+                python_value = getattr(schema_param, type_info.default_field)
+            else:
+                raise ValueError(f"Missing required parameter: {schema_param.name}")
+        try:
+            converted_value = type_info.converter(python_value)
+        except ValueError as exc:
+            raise ValueError(f"Invalid type for parameter {schema_param.name}: {exc}")
+        setattr(proto_param, type_info.proto_field, converted_value)
+        proto_params.append(proto_param)
+    proto_bytes = api_pb2.ClassParameterSet(parameters=proto_params).SerializeToString(deterministic=True)
+    return proto_bytes
+
+
+def deserialize_proto_params(serialized_params: bytes, schema: list[api_pb2.ClassParameterSpec]) -> dict[str, Any]:
+    proto_struct = api_pb2.ClassParameterSet()
+    proto_struct.ParseFromString(serialized_params)
+    value_by_name = {p.name: p for p in proto_struct.parameters}
+    python_params = {}
+    for schema_param in schema:
+        if schema_param.name not in value_by_name:
+            # TODO: handle default values? Could just be a flag on the FunctionParameter schema spec,
+            #  allowing it to not be supplied in the FunctionParameterSet?
+            raise AttributeError(f"Constructor arguments don't match declared parameters (missing {schema_param.name})")
+        param_value = value_by_name[schema_param.name]
+        if schema_param.type != param_value.type:
+            raise ValueError(
+                "Constructor arguments types don't match declared parameters "
+                f"({schema_param.name}: type {schema_param.type} != type {param_value.type})"
+            )
+        python_value: Any
+        if schema_param.type == api_pb2.PARAM_TYPE_STRING:
+            python_value = param_value.string_value
+        elif schema_param.type == api_pb2.PARAM_TYPE_INT:
+            python_value = param_value.int_value
+        else:
+            # TODO(elias): based on `parameters` declared types, we could add support for
+            #  custom non proto types encoded as bytes in the proto, e.g. PARAM_TYPE_PYTHON_PICKLE
+            raise NotImplementedError("Only strings and ints are supported parameter value types at the moment")
+
+        python_params[schema_param.name] = python_value
+
+    return python_params

modal/_traceback.py

@@ -1,24 +1,27 @@
 # Copyright Modal Labs 2022
-import functools
+"""Helper functions related to operating on exceptions, warnings, and traceback objects.
+
+Functions related to *displaying* tracebacks should go in `modal/cli/_traceback.py`
+so that Rich is not a dependency of the container Client.
+"""
+
+import re
+import sys
 import traceback
 import warnings
 from types import TracebackType
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Iterable, Optional
 
-from rich.console import Console, RenderResult, group
-from rich.panel import Panel
-from rich.syntax import Syntax
-from rich.text import Text
-from rich.traceback import PathHighlighter, Stack, Traceback, install
+from modal_proto import api_pb2
 
 from ._vendor.tblib import Traceback as TBLibTraceback
-from .exception import DeprecationError
+from .exception import ServerWarning
 
-TBDictType = Dict[str, Any]
-LineCacheType = Dict[Tuple[str, str], str]
+TBDictType = dict[str, Any]
+LineCacheType = dict[tuple[str, str], str]
 
 
-def extract_traceback(exc: BaseException, task_id: str) -> Tuple[TBDictType, LineCacheType]:
+def extract_traceback(exc: BaseException, task_id: str) -> tuple[TBDictType, LineCacheType]:
     """Given an exception, extract a serializable traceback (with task ID markers included),
     and a line cache that maps (filename, lineno) to line contents. The latter is used to show
     a helpful traceback to the user, even if they don't have packages installed locally that
@@ -37,6 +40,8 @@ def extract_traceback(exc: BaseException, task_id: str) -> Tuple[TBDictType, Lin
         # container. This means we've reached the end of the local traceback.
         if file.startswith("<"):
             break
+        # We rely on this specific filename format when inferring where the exception was raised
+        # in various other exception-related code
         cur.tb_frame.f_code.co_filename = f"<{task_id}>:{file}"
         cur = cur.tb_next
 
@@ -67,13 +72,17 @@ def append_modal_tb(exc: BaseException, tb_dict: TBDictType, line_cache: LineCac
     setattr(exc, "__line_cache__", line_cache)
 
 
-def reduce_traceback_to_user_code(tb: TracebackType, user_source: str) -> TracebackType:
+def reduce_traceback_to_user_code(tb: Optional[TracebackType], user_source: str) -> TracebackType:
     """Return a traceback that does not contain modal entrypoint or synchronicity frames."""
-    # Step forward all the way through the traceback and drop any synchronicity frames
+
+    # Step forward all the way through the traceback and drop any "Modal support" frames
+    def skip_frame(filename: str) -> bool:
+        return "/site-packages/synchronicity/" in filename or "modal/_utils/deprecation" in filename
+
     tb_root = tb
     while tb is not None:
         while tb.tb_next is not None:
-            if "/site-packages/synchronicity/" in tb.tb_next.tb_frame.f_code.co_filename:
+            if skip_frame(tb.tb_next.tb_frame.f_code.co_filename):
                 tb.tb_next = tb.tb_next.tb_next
             else:
                 break
@@ -94,176 +103,27 @@ def reduce_traceback_to_user_code(tb: TracebackType, user_source: str) -> Traceb
     return tb
 
 
-@group()
-def _render_stack(self, stack: Stack) -> RenderResult:
-    """Patched variant of rich.Traceback._render_stack that uses the line from the modal StackSummary,
-    when the file isn't available to be read locally."""
-
-    path_highlighter = PathHighlighter()
-    theme = self.theme
-    code_cache: Dict[str, str] = {}
-    line_cache = getattr(stack, "line_cache", {})
-    task_id = None
-
-    def read_code(filename: str) -> str:
-        code = code_cache.get(filename)
-        if code is None:
-            with open(filename, "rt", encoding="utf-8", errors="replace") as code_file:
-                code = code_file.read()
-            code_cache[filename] = code
-        return code
-
-    exclude_frames: Optional[range] = None
-    if self.max_frames != 0:
-        exclude_frames = range(
-            self.max_frames // 2,
-            len(stack.frames) - self.max_frames // 2,
-        )
-
-    excluded = False
-    for frame_index, frame in enumerate(stack.frames):
-        if exclude_frames and frame_index in exclude_frames:
-            excluded = True
-            continue
-
-        if excluded:
-            assert exclude_frames is not None
-            yield Text(
-                f"\n... {len(exclude_frames)} frames hidden ...",
-                justify="center",
-                style="traceback.error",
-            )
-            excluded = False
-
-        first = frame_index == 0
-        # Patched Modal-specific code.
-        if frame.filename.startswith("<") and ":" in frame.filename:
-            next_task_id, frame_filename = frame.filename.split(":", 1)
-            next_task_id = next_task_id.strip("<>")
-        else:
-            frame_filename = frame.filename
-            next_task_id = None
-        suppressed = any(frame_filename.startswith(path) for path in self.suppress)
-
-        if next_task_id != task_id:
-            task_id = next_task_id
-            yield ""
-            yield Text(
-                f"...Remote call to Modal Function ({task_id})...",
-                justify="center",
-                style="green",
-            )
-
-        text = Text.assemble(
-            path_highlighter(Text(frame_filename, style="pygments.string")),
-            (":", "pygments.text"),
-            (str(frame.lineno), "pygments.number"),
-            " in ",
-            (frame.name, "pygments.function"),
-            style="pygments.text",
-        )
-        if not frame_filename.startswith("<") and not first:
-            yield ""
-
-        yield text
-        if not suppressed:
-            try:
-                code = read_code(frame_filename)
-                lexer_name = self._guess_lexer(frame_filename, code)
-                syntax = Syntax(
-                    code,
-                    lexer_name,
-                    theme=theme,
-                    line_numbers=True,
-                    line_range=(
-                        frame.lineno - self.extra_lines,
-                        frame.lineno + self.extra_lines,
-                    ),
-                    highlight_lines={frame.lineno},
-                    word_wrap=self.word_wrap,
-                    code_width=88,
-                    indent_guides=self.indent_guides,
-                    dedent=False,
-                )
-                yield ""
-            except Exception as error:
-                # Patched Modal-specific code.
-                line = line_cache.get((frame_filename, frame.lineno))
-                if line:
-                    try:
-                        lexer_name = self._guess_lexer(frame_filename, line)
-                        yield ""
-                        yield Syntax(
-                            line,
-                            lexer_name,
-                            theme=theme,
-                            line_numbers=True,
-                            line_range=(0, 1),
-                            highlight_lines={frame.lineno},
-                            word_wrap=self.word_wrap,
-                            code_width=88,
-                            indent_guides=self.indent_guides,
-                            dedent=False,
-                            start_line=frame.lineno,
-                        )
-                    except Exception:
-                        yield Text.assemble(
-                            (f"\n{error}", "traceback.error"),
-                        )
-                yield ""
-            else:
-                yield syntax
-
-
-def setup_rich_traceback() -> None:
-    from_exception = Traceback.from_exception
-
-    @functools.wraps(Traceback.from_exception)
-    def _from_exception(exc_type, exc_value, *args, **kwargs):
-        """Patch from_exception to grab the Modal line_cache and store it with the
-        Stack object, so it's available to render_stack at display time."""
-
-        line_cache = getattr(exc_value, "__line_cache__", {})
-        tb = from_exception(exc_type, exc_value, *args, **kwargs)
-        for stack in tb.trace.stacks:
-            stack.line_cache = line_cache  # type: ignore
-        return tb
-
-    Traceback._render_stack = _render_stack  # type: ignore
-    Traceback.from_exception = _from_exception  # type: ignore
-
-    import click
-    import grpclib
-    import synchronicity
-    import typer
-
-    install(suppress=[synchronicity, grpclib, click, typer], extra_lines=1)
-
-
-def highlight_modal_deprecation_warnings() -> None:
-    """Patch the warnings module to make client deprecation warnings more salient in the CLI."""
-    base_showwarning = warnings.showwarning
-
-    def showwarning(warning, category, filename, lineno, file=None, line=None):
-        if issubclass(category, DeprecationError):
-            content = str(warning)
-            date = content[:10]
-            message = content[11:].strip()
-            try:
-                with open(filename, "rt", encoding="utf-8", errors="replace") as code_file:
-                    source = code_file.readlines()[lineno - 1].strip()
-                message = f"{message}\n\nSource: {filename}:{lineno}\n  {source}"
-            except OSError:
-                # e.g., when filename is "<unknown>"; raises FileNotFoundError on posix but OSError on windows
-                pass
-            panel = Panel(
-                message,
-                style="yellow",
-                title=f"Modal Deprecation Warning ({date})",
-                title_align="left",
-            )
-            Console().print(panel)
-        else:
-            base_showwarning(warning, category, filename, lineno, file=None, line=None)
-
-    warnings.showwarning = showwarning
+def traceback_contains_remote_call(tb: Optional[TracebackType]) -> bool:
+    """Inspect the traceback stack to determine whether an error was raised locally or remotely."""
+    while tb is not None:
+        if re.match(r"^<ta-[0-9A-Z]{26}>:", tb.tb_frame.f_code.co_filename):
+            return True
+        tb = tb.tb_next
+    return False
+
+
+def print_exception(exc: Optional[type[BaseException]], value: Optional[BaseException], tb: Optional[TracebackType]):
+    """Add backwards compatibility for printing exceptions with "notes" for Python<3.11."""
+    traceback.print_exception(exc, value, tb)
+    if sys.version_info < (3, 11) and value is not None:
+        notes = getattr(value, "__notes__", [])
+        print(*notes, sep="\n", file=sys.stderr)
+
+
+def print_server_warnings(server_warnings: Iterable[api_pb2.Warning]):
+    """Issue a warning originating from the server with empty metadata about local origin.
+
+    When using the Modal CLI, these warnings should get caught and coerced into Rich panels.
+    """
+    for warning in server_warnings:
+        warnings.warn_explicit(warning.message, ServerWarning, "<modal-server>", 0)

modal/_tunnel.py

@@ -1,8 +1,9 @@
 # Copyright Modal Labs 2023
 """Client for Modal relay servers, allowing users to expose TLS."""
 
+from collections.abc import AsyncIterator
 from dataclasses import dataclass
-from typing import AsyncIterator, Optional, Tuple
+from typing import Optional
 
 from grpclib import GRPCError, Status
 from synchronicity.async_wrap import asynccontextmanager
@@ -35,12 +36,12 @@ class Tunnel:
         return value
 
     @property
-    def tls_socket(self) -> Tuple[str, int]:
+    def tls_socket(self) -> tuple[str, int]:
         """Get the public TLS socket as a (host, port) tuple."""
         return (self.host, self.port)
 
     @property
-    def tcp_socket(self) -> Tuple[str, int]:
+    def tcp_socket(self) -> tuple[str, int]:
         """Get the public TCP socket as a (host, port) tuple."""
         if not self.unencrypted_host:
             raise InvalidError(
@@ -54,22 +55,22 @@ async def _forward(port: int, *, unencrypted: bool = False, client: Optional[_Cl
     """Expose a port publicly from inside a running Modal container, with TLS.
 
     If `unencrypted` is set, this also exposes the TCP socket without encryption on a random port
-    number. This can be used to SSH into a container. Note that it is on the public Internet, so
+    number. This can be used to SSH into a container (see example below). Note that it is on the public Internet, so
     make sure you are using a secure protocol over TCP.
 
     **Important:** This is an experimental API which may change in the future.
 
     **Usage:**
 
-    ```python
+    ```python notest
+    import modal
     from flask import Flask
-    from modal import Image, App, forward
 
-    app = App(image=Image.debian_slim().pip_install("Flask"))  # Note: "app" was called "stub" up until April 2024
-    app = Flask(__name__)
+    app = modal.App(image=modal.Image.debian_slim().pip_install("Flask"))
+    flask_app = Flask(__name__)
 
 
-    @app.route("/")
+    @flask_app.route("/")
     def hello_world():
         return "Hello, World!"
 
@@ -78,9 +79,9 @@ async def _forward(port: int, *, unencrypted: bool = False, client: Optional[_Cl
     def run_app():
         # Start a web server inside the container at port 8000. `modal.forward(8000)` lets us
         # expose that port to the world at a random HTTPS URL.
-        with forward(8000) as tunnel:
+        with modal.forward(8000) as tunnel:
             print("Server listening at", tunnel.url)
-            app.run("0.0.0.0", 8000)
+            flask_app.run("0.0.0.0", 8000)
 
         # When the context manager exits, the port is no longer exposed.
     ```
@@ -90,7 +91,8 @@ async def _forward(port: int, *, unencrypted: bool = False, client: Optional[_Cl
     ```python
     import socket
     import threading
-    from modal import App, forward
+
+    import modal
 
 
     def run_echo_server(port: int):
@@ -115,17 +117,51 @@ async def _forward(port: int, *, unencrypted: bool = False, client: Optional[_Cl
             threading.Thread(target=handle, args=(conn,)).start()
 
 
-    app = App()  # Note: "app" was called "stub" up until April 2024
+    app = modal.App()
 
 
     @app.function()
     def tcp_tunnel():
         # This exposes port 8000 to public Internet traffic over TCP.
-        with forward(8000, unencrypted=True) as tunnel:
+        with modal.forward(8000, unencrypted=True) as tunnel:
             # You can connect to this TCP socket from outside the container, for example, using `nc`:
             #  nc <HOST> <PORT>
             print("TCP tunnel listening at:", tunnel.tcp_socket)
             run_echo_server(8000)
+    ```
+
+    **SSH example:**
+    This assumes you have a rsa keypair in `~/.ssh/id_rsa{.pub}`, this is a bare-bones example
+    letting you SSH into a Modal container.
+
+    ```python
+    import subprocess
+    import time
+
+    import modal
+
+    app = modal.App()
+    image = (
+        modal.Image.debian_slim()
+        .apt_install("openssh-server")
+        .run_commands("mkdir /run/sshd")
+        .copy_local_file("~/.ssh/id_rsa.pub", "/root/.ssh/authorized_keys")
+    )
+
+
+    @app.function(image=image, timeout=3600)
+    def some_function():
+        subprocess.Popen(["/usr/sbin/sshd", "-D", "-e"])
+        with modal.forward(port=22, unencrypted=True) as tunnel:
+            hostname, port = tunnel.tcp_socket
+            connection_cmd = f'ssh -p {port} root@{hostname}'
+            print(f"ssh into container using: {connection_cmd}")
+            time.sleep(3600)  # keep alive for 1 hour or until killed
+    ```
+
+    If you intend to use this more generally, a suggestion is to put the subprocess and port
+    forwarding code in an `@enter` lifecycle method of an @app.cls, to only make a single
+    ssh server and port for each container (and not one for each input to the function).
     """
 
     if not isinstance(port, int):

modal/_tunnel.pyi

@@ -10,45 +10,28 @@ class Tunnel:
     unencrypted_port: int
 
     @property
-    def url(self) -> str:
-        ...
-
+    def url(self) -> str: ...
     @property
-    def tls_socket(self) -> typing.Tuple[str, int]:
-        ...
-
+    def tls_socket(self) -> tuple[str, int]: ...
     @property
-    def tcp_socket(self) -> typing.Tuple[str, int]:
-        ...
-
-    def __init__(self, host: str, port: int, unencrypted_host: str, unencrypted_port: int) -> None:
-        ...
-
-    def __repr__(self):
-        ...
-
-    def __eq__(self, other):
-        ...
-
-    def __setattr__(self, name, value):
-        ...
-
-    def __delattr__(self, name):
-        ...
-
-    def __hash__(self):
-        ...
-
-
-def _forward(port: int, *, unencrypted: bool = False, client: typing.Union[modal.client._Client, None] = None) -> typing.AsyncContextManager[Tunnel]:
-    ...
-
+    def tcp_socket(self) -> tuple[str, int]: ...
+    def __init__(self, host: str, port: int, unencrypted_host: str, unencrypted_port: int) -> None: ...
+    def __repr__(self): ...
+    def __eq__(self, other): ...
+    def __setattr__(self, name, value): ...
+    def __delattr__(self, name): ...
+    def __hash__(self): ...
+
+def _forward(
+    port: int, *, unencrypted: bool = False, client: typing.Optional[modal.client._Client] = None
+) -> typing.AsyncContextManager[Tunnel]: ...
 
 class __forward_spec(typing_extensions.Protocol):
-    def __call__(self, port: int, *, unencrypted: bool = False, client: typing.Union[modal.client.Client, None] = None) -> synchronicity.combined_types.AsyncAndBlockingContextManager[Tunnel]:
-        ...
-
-    def aio(self, port: int, *, unencrypted: bool = False, client: typing.Union[modal.client.Client, None] = None) -> typing.AsyncContextManager[Tunnel]:
-        ...
+    def __call__(
+        self, port: int, *, unencrypted: bool = False, client: typing.Optional[modal.client.Client] = None
+    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[Tunnel]: ...
+    def aio(
+        self, port: int, *, unencrypted: bool = False, client: typing.Optional[modal.client.Client] = None
+    ) -> typing.AsyncContextManager[Tunnel]: ...
 
 forward: __forward_spec

modal/_utils/app_utils.py

@@ -1,17 +1,3 @@
-# Copyright Modal Labs 2022
-import re
-
-# https://www.rfc-editor.org/rfc/rfc1035
-subdomain_regex = re.compile("^(?![0-9]+$)(?!-)[a-z0-9-]{,63}(?<!-)$")
-
-
-def is_valid_subdomain_label(label: str):
-    return subdomain_regex.match(label) is not None
-
-
-def replace_invalid_subdomain_chars(label: str):
-    return re.sub("[^a-z0-9-]", "-", label.lower())
-
-
-def is_valid_app_name(name: str):
-    return len(name) <= 64 and re.match("^[a-zA-Z0-9-_.]+$", name) is not None
+# Copyright Modal Labs 2024
+# Temporary shim as we use this in the server
+from .name_utils import *  # noqa