modal 0.68.9__py3-none-any.whl → 0.68.14__py3-none-any.whl

modal/_ipython.py

@@ -1,21 +1,11 @@
 # Copyright Modal Labs 2022
 import sys
-import warnings
-
-ipy_outstream = None
-try:
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        import ipykernel.iostream
-
-    ipy_outstream = ipykernel.iostream.OutStream
-except ImportError:
-    pass
 
 
 def is_notebook(stdout=None):
-    if ipy_outstream is None:
+    ipykernel_iostream = sys.modules.get("ipykernel.iostream")
+    if ipykernel_iostream is None:
         return False
     if stdout is None:
         stdout = sys.stdout
-    return isinstance(stdout, ipy_outstream)
+    return isinstance(stdout, ipykernel_iostream.OutStream)

modal/_runtime/user_code_imports.py

@@ -269,10 +269,12 @@ def import_single_function_service(
                 # The cls decorator is in global scope
                 _cls = synchronizer._translate_in(cls)
                 user_defined_callable = _cls._callables[fun_name]
-                function = _cls._method_functions.get(fun_name)
+                function = _cls._method_functions.get(
+                    fun_name
+                )  # bound to the class service function - there is no instance
                 active_app = _cls._app
             else:
-                # This is a raw class
+                # This is non-decorated class
                 user_defined_callable = getattr(cls, fun_name)
         else:
             raise InvalidError(f"Invalid function qualname {qual_name}")

modal/_utils/blob_utils.py

@@ -21,7 +21,7 @@ from modal_proto.modal_api_grpc import ModalClientModal
 from ..exception import ExecutionError
 from .async_utils import TaskContext, retry
 from .grpc_utils import retry_transient_errors
-from .hash_utils import UploadHashes, get_sha256_hex, get_upload_hashes
+from .hash_utils import UploadHashes, get_upload_hashes
 from .http_utils import ClientSessionRegistry
 from .logger import logger
 
@@ -38,6 +38,11 @@ BLOB_MAX_PARALLELISM = 10
 # read ~16MiB chunks by default
 DEFAULT_SEGMENT_CHUNK_SIZE = 2**24
 
+# Files larger than this will be multipart uploaded. The server might request multipart upload for smaller files as
+# well, but the limit will never be raised.
+# TODO(dano): remove this once we stop requiring md5 for blobs
+MULTIPART_UPLOAD_THRESHOLD = 1024**3
+
 
 class BytesIOSegmentPayload(BytesIOPayload):
     """Modified bytes payload for concurrent sends of chunks from the same file.
@@ -305,9 +310,13 @@ async def blob_upload(payload: bytes, stub: ModalClientModal) -> str:
 
 
 async def blob_upload_file(
-    file_obj: BinaryIO, stub: ModalClientModal, progress_report_cb: Optional[Callable] = None
+    file_obj: BinaryIO,
+    stub: ModalClientModal,
+    progress_report_cb: Optional[Callable] = None,
+    sha256_hex: Optional[str] = None,
+    md5_hex: Optional[str] = None,
 ) -> str:
-    upload_hashes = get_upload_hashes(file_obj)
+    upload_hashes = get_upload_hashes(file_obj, sha256_hex=sha256_hex, md5_hex=md5_hex)
     return await _blob_upload(upload_hashes, file_obj, stub, progress_report_cb)
 
 
@@ -366,6 +375,7 @@ class FileUploadSpec:
     use_blob: bool
     content: Optional[bytes]  # typically None if using blob, required otherwise
     sha256_hex: str
+    md5_hex: str
     mode: int  # file permission bits (last 12 bits of st_mode)
     size: int
 
@@ -383,13 +393,15 @@ def _get_file_upload_spec(
         fp.seek(0)
 
         if size >= LARGE_FILE_LIMIT:
+            # TODO(dano): remove the placeholder md5 once we stop requiring md5 for blobs
+            md5_hex = "baadbaadbaadbaadbaadbaadbaadbaad" if size > MULTIPART_UPLOAD_THRESHOLD else None
             use_blob = True
             content = None
-            sha256_hex = get_sha256_hex(fp)
+            hashes = get_upload_hashes(fp, md5_hex=md5_hex)
         else:
             use_blob = False
             content = fp.read()
-            sha256_hex = get_sha256_hex(content)
+            hashes = get_upload_hashes(content)
 
     return FileUploadSpec(
         source=source,
@@ -397,7 +409,8 @@ def _get_file_upload_spec(
         mount_filename=mount_filename.as_posix(),
         use_blob=use_blob,
         content=content,
-        sha256_hex=sha256_hex,
+        sha256_hex=hashes.sha256_hex(),
+        md5_hex=hashes.md5_hex(),
         mode=mode & 0o7777,
         size=size,
     )

modal/_utils/function_utils.py

@@ -99,7 +99,11 @@ def get_function_type(is_generator: Optional[bool]) -> "api_pb2.Function.Functio
 
 
 class FunctionInfo:
-    """Class that helps us extract a bunch of information about a function."""
+    """Class that helps us extract a bunch of information about a locally defined function.
+
+    Used for populating the definition of a remote function, and for making .local() calls
+    on a host with the local definition available.
+    """
 
     raw_f: Optional[Callable[..., Any]]  # if None - this is a "class service function"
     function_name: str

modal/_utils/grpc_testing.py

@@ -50,7 +50,7 @@ def patch_mock_servicer(cls):
 
     @contextlib.contextmanager
     def intercept(servicer):
-        ctx = InterceptionContext()
+        ctx = InterceptionContext(servicer)
         servicer.interception_context = ctx
         yield ctx
         ctx._assert_responses_consumed()
@@ -101,7 +101,8 @@ class ResponseNotConsumed(Exception):
 
 
 class InterceptionContext:
-    def __init__(self):
+    def __init__(self, servicer):
+        self._servicer = servicer
         self.calls: list[tuple[str, Any]] = []  # List[Tuple[method_name, message]]
         self.custom_responses: dict[str, list[tuple[Callable[[Any], bool], list[Any]]]] = defaultdict(list)
         self.custom_defaults: dict[str, Callable[["MockClientServicer", grpclib.server.Stream], Awaitable[None]]] = {}
@@ -149,6 +150,9 @@ class InterceptionContext:
         raise KeyError(f"No message of that type in call list: {self.calls}")
 
     def get_requests(self, method_name: str) -> list[Any]:
+        if not hasattr(self._servicer, method_name):
+            # we check this to prevent things like `assert ctx.get_requests("ASdfFunctionCreate") == 0` passing
+            raise ValueError(f"{method_name} not in MockServicer - did you spell it right?")
         return [msg for _method_name, msg in self.calls if _method_name == method_name]
 
     def _add_recv(self, method_name: str, msg):

modal/_utils/hash_utils.py

@@ -3,14 +3,14 @@ import base64
 import dataclasses
 import hashlib
 import time
-from typing import BinaryIO, Callable, Union
+from typing import BinaryIO, Callable, Optional, Sequence, Union
 
 from modal.config import logger
 
 HASH_CHUNK_SIZE = 65536
 
 
-def _update(hashers: list[Callable[[bytes], None]], data: Union[bytes, BinaryIO]) -> None:
+def _update(hashers: Sequence[Callable[[bytes], None]], data: Union[bytes, BinaryIO]) -> None:
     if isinstance(data, bytes):
         for hasher in hashers:
             hasher(data)
@@ -57,15 +57,44 @@ class UploadHashes:
     md5_base64: str
     sha256_base64: str
 
+    def md5_hex(self) -> str:
+        return base64.b64decode(self.md5_base64).hex()
 
-def get_upload_hashes(data: Union[bytes, BinaryIO]) -> UploadHashes:
+    def sha256_hex(self) -> str:
+        return base64.b64decode(self.sha256_base64).hex()
+
+
+def get_upload_hashes(
+    data: Union[bytes, BinaryIO], sha256_hex: Optional[str] = None, md5_hex: Optional[str] = None
+) -> UploadHashes:
     t0 = time.monotonic()
-    md5 = hashlib.md5()
-    sha256 = hashlib.sha256()
-    _update([md5.update, sha256.update], data)
+    hashers = {}
+
+    if not sha256_hex:
+        sha256 = hashlib.sha256()
+        hashers["sha256"] = sha256
+    if not md5_hex:
+        md5 = hashlib.md5()
+        hashers["md5"] = md5
+
+    if hashers:
+        updaters = [h.update for h in hashers.values()]
+        _update(updaters, data)
+
+    if sha256_hex:
+        sha256_base64 = base64.b64encode(bytes.fromhex(sha256_hex)).decode("ascii")
+    else:
+        sha256_base64 = base64.b64encode(hashers["sha256"].digest()).decode("ascii")
+
+    if md5_hex:
+        md5_base64 = base64.b64encode(bytes.fromhex(md5_hex)).decode("ascii")
+    else:
+        md5_base64 = base64.b64encode(hashers["md5"].digest()).decode("ascii")
+
     hashes = UploadHashes(
-        md5_base64=base64.b64encode(md5.digest()).decode("ascii"),
-        sha256_base64=base64.b64encode(sha256.digest()).decode("ascii"),
+        md5_base64=md5_base64,
+        sha256_base64=sha256_base64,
     )
-    logger.debug("get_upload_hashes took %.3fs", time.monotonic() - t0)
+
+    logger.debug("get_upload_hashes took %.3fs (%s)", time.monotonic() - t0, hashers.keys())
     return hashes

modal/client.pyi

@@ -26,7 +26,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.9"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.14"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -81,7 +81,7 @@ class Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.9"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.14"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -19,7 +19,7 @@ from ._utils.async_utils import synchronize_api, synchronizer
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
 from .client import _Client
-from .exception import InvalidError, NotFoundError, VersionError
+from .exception import ExecutionError, InvalidError, NotFoundError, VersionError
 from .functions import _Function, _parse_retries
 from .gpu import GPU_T
 from .object import _get_environment_name, _Object
@@ -40,7 +40,7 @@ if typing.TYPE_CHECKING:
     import modal.app
 
 
-def _use_annotation_parameters(user_cls) -> bool:
+def _use_annotation_parameters(user_cls: type) -> bool:
     has_parameters = any(is_parameter(cls_member) for cls_member in user_cls.__dict__.values())
     has_explicit_constructor = user_cls.__init__ != object.__init__
     return has_parameters and not has_explicit_constructor
@@ -73,7 +73,7 @@ def _get_class_constructor_signature(user_cls: type) -> inspect.Signature:
 def _bind_instance_method(service_function: _Function, class_bound_method: _Function):
     """mdmd:hidden
 
-    Binds an "instance service function" to a specific method.
+    Binds an "instance service function" to a specific method name.
     This "dummy" _Function gets no unique object_id and isn't backend-backed at the moment, since all
     it does it forward invocations to the underlying instance_service_function with the specified method,
     and we don't support web_config for parameterized methods at the moment.
@@ -84,7 +84,6 @@ def _bind_instance_method(service_function: _Function, class_bound_method: _Func
     #   object itself doesn't need any "loading"
     assert service_function._obj
     method_name = class_bound_method._use_method_name
-    full_function_name = f"{class_bound_method._function_name}[parameterized]"
 
     def hydrate_from_instance_service_function(method_placeholder_fun):
         method_placeholder_fun._hydrate_from_other(service_function)
@@ -92,7 +91,7 @@ def _bind_instance_method(service_function: _Function, class_bound_method: _Func
         method_placeholder_fun._web_url = (
             class_bound_method._web_url
         )  # TODO: this shouldn't be set when actual parameters are used
-        method_placeholder_fun._function_name = full_function_name
+        method_placeholder_fun._function_name = f"{class_bound_method._function_name}[parameterized]"
         method_placeholder_fun._is_generator = class_bound_method._is_generator
         method_placeholder_fun._cluster_size = class_bound_method._cluster_size
         method_placeholder_fun._use_method_name = method_name
@@ -112,7 +111,7 @@ def _bind_instance_method(service_function: _Function, class_bound_method: _Func
             return []
         return [service_function]
 
-    rep = f"Method({full_function_name})"
+    rep = f"Method({method_name})"
 
     fun = _Function._from_loader(
         _load,
@@ -137,22 +136,23 @@ class _Obj:
 
     All this class does is to return `Function` objects."""
 
+    _cls: "_Cls"  # parent
     _functions: dict[str, _Function]
     _has_entered: bool
     _user_cls_instance: Optional[Any] = None
-    _construction_args: tuple[tuple, dict[str, Any]]
+    _args: tuple[Any, ...]
+    _kwargs: dict[str, Any]
 
-    _instance_service_function: Optional[_Function]
+    _instance_service_function: Optional[_Function] = None  # this gets set lazily
 
     def _uses_common_service_function(self):
         # Used for backwards compatibility checks with pre v0.63 classes
-        return self._instance_service_function is not None
+        return self._cls._class_service_function is not None
 
     def __init__(
         self,
+        cls: "_Cls",
         user_cls: Optional[type],  # this would be None in case of lookups
-        class_service_function: Optional[_Function],  # only None for <v0.63 classes
-        classbound_methods: dict[str, _Function],
         options: Optional[api_pb2.FunctionOptions],
         args,
         kwargs,
@@ -161,45 +161,60 @@ class _Obj:
             check_valid_cls_constructor_arg(i + 1, arg)
         for key, kwarg in kwargs.items():
             check_valid_cls_constructor_arg(key, kwarg)
-
-        self._method_functions = {}
-        if class_service_function:
-            # >= v0.63 classes
-            # first create the singular object function used by all methods on this parameterization
-            self._instance_service_function = class_service_function._bind_parameters(self, options, args, kwargs)
-            for method_name, class_bound_method in classbound_methods.items():
-                method = _bind_instance_method(self._instance_service_function, class_bound_method)
-                self._method_functions[method_name] = method
-        else:
-            # looked up <v0.63 classes - bind each individual method to the new parameters
-            self._instance_service_function = None
-            for method_name, class_bound_method in classbound_methods.items():
-                method = class_bound_method._bind_parameters(self, options, args, kwargs)
-                self._method_functions[method_name] = method
+        self._cls = cls
 
         # Used for construction local object lazily
         self._has_entered = False
         self._user_cls = user_cls
-        self._construction_args = (args, kwargs)  # used for lazy construction in case of explicit constructors
+
+        # used for lazy construction in case of explicit constructors
+        self._args = args
+        self._kwargs = kwargs
+        self._options = options
+
+    def _cached_service_function(self) -> "modal.functions._Function":
+        # Returns a service function for this _Obj, serving all its methods
+        # In case of methods without parameters or options, this is simply proxying to the class service function
+
+        # only safe to call for 0.63+ classes (before then, all methods had their own services)
+        if not self._instance_service_function:
+            assert self._cls._class_service_function
+            self._instance_service_function = self._cls._class_service_function._bind_parameters(
+                self, self._options, self._args, self._kwargs
+            )
+        return self._instance_service_function
+
+    def _get_parameter_values(self) -> dict[str, Any]:
+        # binds args and kwargs according to the class constructor signature
+        # (implicit by parameters or explicit)
+        sig = _get_class_constructor_signature(self._user_cls)
+        bound_vars = sig.bind(*self._args, **self._kwargs)
+        bound_vars.apply_defaults()
+        return bound_vars.arguments
 
     def _new_user_cls_instance(self):
-        args, kwargs = self._construction_args
         if not _use_annotation_parameters(self._user_cls):
             # TODO(elias): deprecate this code path eventually
-            user_cls_instance = self._user_cls(*args, **kwargs)
+            user_cls_instance = self._user_cls(*self._args, **self._kwargs)
         else:
             # ignore constructor (assumes there is no custom constructor,
             # which is guaranteed by _use_annotation_parameters)
             # set the attributes on the class corresponding to annotations
             # with = parameter() specifications
-            sig = _get_class_constructor_signature(self._user_cls)
-            bound_vars = sig.bind(*args, **kwargs)
-            bound_vars.apply_defaults()
+            param_values = self._get_parameter_values()
             user_cls_instance = self._user_cls.__new__(self._user_cls)  # new instance without running __init__
-            user_cls_instance.__dict__.update(bound_vars.arguments)
+            user_cls_instance.__dict__.update(param_values)
 
         # TODO: always use Obj instances instead of making modifications to user cls
-        user_cls_instance._modal_functions = self._method_functions  # Needed for PartialFunction.__get__
+        # TODO: OR (if simpler for now) replace all the PartialFunctions on the user cls
+        #   with getattr(self, method_name)
+
+        # user cls instances are only created locally, so we have all partial functions available
+        instance_methods = {}
+        for method_name in _find_partial_methods_for_user_cls(self._user_cls, _PartialFunctionFlags.FUNCTION):
+            instance_methods[method_name] = getattr(self, method_name)
+
+        user_cls_instance._modal_functions = instance_methods
         return user_cls_instance
 
     async def keep_warm(self, warm_pool_size: int) -> None:
@@ -221,7 +236,7 @@ class _Obj:
             raise VersionError(
                 "Class instance `.keep_warm(...)` can't be used on classes deployed using client version <v0.63"
             )
-        await self._instance_service_function.keep_warm(warm_pool_size)
+        await self._cached_service_function().keep_warm(warm_pool_size)
 
     def _cached_user_cls_instance(self):
         """Get or construct the local object
@@ -233,18 +248,20 @@ class _Obj:
         return self._user_cls_instance
 
     def _enter(self):
+        assert self._user_cls
         if not self._has_entered:
-            if hasattr(self._user_cls_instance, "__enter__"):
-                self._user_cls_instance.__enter__()
+            user_cls_instance = self._cached_user_cls_instance()
+            if hasattr(user_cls_instance, "__enter__"):
+                user_cls_instance.__enter__()
 
             for method_flag in (
                 _PartialFunctionFlags.ENTER_PRE_SNAPSHOT,
                 _PartialFunctionFlags.ENTER_POST_SNAPSHOT,
             ):
-                for enter_method in _find_callables_for_obj(self._user_cls_instance, method_flag).values():
+                for enter_method in _find_callables_for_obj(user_cls_instance, method_flag).values():
                     enter_method()
 
-        self._has_entered = True
+            self._has_entered = True
 
     @property
     def _entered(self) -> bool:
@@ -266,23 +283,74 @@ class _Obj:
         self._has_entered = True
 
     def __getattr__(self, k):
-        if k in self._method_functions:
-            # If we know the user is accessing a *method* and not another attribute,
-            # we don't have to create an instance of the user class yet.
-            # This is because it might just be a call to `.remote()` on it which
-            # doesn't require a local instance.
-            # As long as we have the service function or params, we can do remote calls
-            # without calling the constructor of the class in the calling context.
-            return self._method_functions[k]
+        # This is a bit messy and branchy because:
+        # * Support for pre-0.63 lookups *and* newer classes
+        # * Support .remote() on both hydrated (local or remote classes) or unhydrated classes (remote classes only)
+        # * Support .local() on both hydrated and unhydrated classes (assuming local access to code)
+        # * Support attribute access (when local cls is available)
+
+        def _get_method_bound_function() -> Optional["_Function"]:
+            """Gets _Function object for method - either for a local or a hydrated remote class
+
+            * If class is neither local or hydrated - raise exception (should never happen)
+            * If attribute isn't a method - return None
+            """
+            if self._cls._method_functions is None:
+                raise ExecutionError("Method is not local and not hydrated")
+
+            if class_bound_method := self._cls._method_functions.get(k, None):
+                # If we know the user is accessing a *method* and not another attribute,
+                # we don't have to create an instance of the user class yet.
+                # This is because it might just be a call to `.remote()` on it which
+                # doesn't require a local instance.
+                # As long as we have the service function or params, we can do remote calls
+                # without calling the constructor of the class in the calling context.
+                if self._cls._class_service_function is None:
+                    # a <v0.63 lookup
+                    return class_bound_method._bind_parameters(self, self._options, self._args, self._kwargs)
+                else:
+                    return _bind_instance_method(self._cached_service_function(), class_bound_method)
+
+            return None  # The attribute isn't a method
+
+        if self._cls._method_functions is not None:
+            # We get here with either a hydrated Cls or an unhydrated one with local definition
+            if method := _get_method_bound_function():
+                return method
+            elif self._user_cls:
+                # We have the local definition, and the attribute isn't a method
+                # so we instantiate if we don't have an instance, and try to get the attribute
+                user_cls_instance = self._cached_user_cls_instance()
+                return getattr(user_cls_instance, k)
+            else:
+                # This is the case for a *hydrated* class without the local definition, i.e. a lookup
+                # where the attribute isn't a registered method of the class
+                raise NotFoundError(
+                    f"Class has no method `{k}` and attributes (or undecorated methods) can't be accessed for"
+                    f" remote classes (`Cls.from_name` instances)"
+                )
+
+        # Not hydrated Cls, and we don't have the class - typically a Cls.from_name that
+        # has not yet been loaded. So use a special loader that loads it lazily:
 
-        # if it's *not* a method, it *might* be an attribute of the class,
-        # so we construct it and proxy the attribute
-        # TODO: To get lazy loading (from_name) of classes to work, we need to avoid
-        #  this path, otherwise local initialization will happen regardless if user
-        #  only runs .remote(), since we don't know methods for the class until we
-        #  load it
-        user_cls_instance = self._cached_user_cls_instance()
-        return getattr(user_cls_instance, k)
+        async def method_loader(fun, resolver: Resolver, existing_object_id):
+            await resolver.load(self._cls)  # load class so we get info about methods
+            method_function = _get_method_bound_function()
+            if method_function is None:
+                raise NotFoundError(
+                    f"Class has no method {k}, and attributes can't be accessed for `Cls.from_name` instances"
+                )
+            await resolver.load(method_function)  # get the appropriate method handle (lazy)
+            fun._hydrate_from_other(method_function)
+
+        # The reason we don't *always* use this lazy loader is because it precludes attribute access
+        # on local classes.
+        return _Function._from_loader(
+            method_loader,
+            repr,
+            deps=lambda: [],  # TODO: use cls as dep instead of loading inside method_loader?
+            hydrate_lazily=True,
+        )
 
 
 Obj = synchronize_api(_Obj)
@@ -313,6 +381,7 @@ class _Cls(_Object, type_prefix="cs"):
         self._callables = {}
 
     def _initialize_from_other(self, other: "_Cls"):
+        super()._initialize_from_other(other)
         self._user_cls = other._user_cls
         self._class_service_function = other._class_service_function
         self._method_functions = other._method_functions
@@ -503,7 +572,8 @@ class _Cls(_Object, type_prefix="cs"):
             obj._hydrate(response.class_id, resolver.client, response.handle_metadata)
 
         rep = f"Ref({app_name})"
-        cls = cls._from_loader(_load_remote, rep, is_another_app=True)
+        cls = cls._from_loader(_load_remote, rep, is_another_app=True, hydrate_lazily=True)
+        # TODO: when pre 0.63 is phased out, we can set class_service_function here instead
         return cls
 
     def with_options(
@@ -594,9 +664,8 @@ class _Cls(_Object, type_prefix="cs"):
     def __call__(self, *args, **kwargs) -> _Obj:
         """This acts as the class constructor."""
         return _Obj(
+            self,
             self._user_cls,
-            self._class_service_function,
-            self._method_functions,
             self._options,
             args,
             kwargs,
@@ -604,6 +673,7 @@ class _Cls(_Object, type_prefix="cs"):
 
     def __getattr__(self, k):
         # Used by CLI and container entrypoint
+        # TODO: remove this method - access to attributes on classes should be discouraged
         if k in self._method_functions:
             return self._method_functions[k]
         return getattr(self._user_cls, k)

modal/cls.pyi

@@ -17,29 +17,32 @@ import typing_extensions
 
 T = typing.TypeVar("T")
 
-def _use_annotation_parameters(user_cls) -> bool: ...
+def _use_annotation_parameters(user_cls: type) -> bool: ...
 def _get_class_constructor_signature(user_cls: type) -> inspect.Signature: ...
 def _bind_instance_method(
     service_function: modal.functions._Function, class_bound_method: modal.functions._Function
 ): ...
 
 class _Obj:
+    _cls: _Cls
     _functions: dict[str, modal.functions._Function]
     _has_entered: bool
     _user_cls_instance: typing.Optional[typing.Any]
-    _construction_args: tuple[tuple, dict[str, typing.Any]]
+    _args: tuple[typing.Any, ...]
+    _kwargs: dict[str, typing.Any]
     _instance_service_function: typing.Optional[modal.functions._Function]
 
     def _uses_common_service_function(self): ...
     def __init__(
         self,
+        cls: _Cls,
         user_cls: typing.Optional[type],
-        class_service_function: typing.Optional[modal.functions._Function],
-        classbound_methods: dict[str, modal.functions._Function],
         options: typing.Optional[modal_proto.api_pb2.FunctionOptions],
         args,
         kwargs,
     ): ...
+    def _cached_service_function(self) -> modal.functions._Function: ...
+    def _get_parameter_values(self) -> dict[str, typing.Any]: ...
     def _new_user_cls_instance(self): ...
     async def keep_warm(self, warm_pool_size: int) -> None: ...
     def _cached_user_cls_instance(self): ...
@@ -52,22 +55,25 @@ class _Obj:
     def __getattr__(self, k): ...
 
 class Obj:
+    _cls: Cls
     _functions: dict[str, modal.functions.Function]
     _has_entered: bool
     _user_cls_instance: typing.Optional[typing.Any]
-    _construction_args: tuple[tuple, dict[str, typing.Any]]
+    _args: tuple[typing.Any, ...]
+    _kwargs: dict[str, typing.Any]
     _instance_service_function: typing.Optional[modal.functions.Function]
 
     def __init__(
         self,
+        cls: Cls,
         user_cls: typing.Optional[type],
-        class_service_function: typing.Optional[modal.functions.Function],
-        classbound_methods: dict[str, modal.functions.Function],
         options: typing.Optional[modal_proto.api_pb2.FunctionOptions],
         args,
         kwargs,
     ): ...
     def _uses_common_service_function(self): ...
+    def _cached_service_function(self) -> modal.functions.Function: ...
+    def _get_parameter_values(self) -> dict[str, typing.Any]: ...
     def _new_user_cls_instance(self): ...
 
     class __keep_warm_spec(typing_extensions.Protocol):

modal/functions.py

@@ -432,7 +432,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         image: _Image,
         secrets: Sequence[_Secret] = (),
         schedule: Optional[Schedule] = None,
-        is_generator=False,
+        is_generator: bool = False,
         gpu: Union[GPU_T, list[GPU_T]] = None,
         # TODO: maybe break this out into a separate decorator for notebooks.
         mounts: Collection[_Mount] = (),
@@ -628,7 +628,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             raise InvalidError(f"Expected modal.Image object. Got {type(image)}.")
 
         method_definitions: Optional[dict[str, api_pb2.MethodDefinition]] = None
-        partial_functions: dict[str, "modal.partial_function._PartialFunction"] = {}
+
         if info.user_cls:
             method_definitions = {}
             partial_functions = _find_partial_methods_for_user_cls(info.user_cls, _PartialFunctionFlags.FUNCTION)
@@ -1191,9 +1191,16 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return self._web_url
 
     @property
-    def is_generator(self) -> bool:
+    async def is_generator(self) -> bool:
         """mdmd:hidden"""
-        assert self._is_generator is not None
+        # hacky: kind of like @live_method, but not hydrating if we have the value already from local source
+        if self._is_generator is not None:
+            # this is set if the function or class is local
+            return self._is_generator
+
+        # not set - this is a from_name lookup - hydrate
+        await self.resolve()
+        assert self._is_generator is not None  # should be set now
         return self._is_generator
 
     @property
@@ -1318,6 +1325,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         async for item in self._call_generator(args, kwargs):  # type: ignore
             yield item
 
+    def _is_local(self):
+        return self._info is not None
+
     def _get_info(self) -> FunctionInfo:
         if not self._info:
             raise ExecutionError("Can't get info for a function that isn't locally defined")
@@ -1342,19 +1352,24 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         """
         # TODO(erikbern): it would be nice to remove the nowrap thing, but right now that would cause
         # "user code" to run on the synchronicity thread, which seems bad
+        if not self._is_local():
+            msg = (
+                "The definition for this function is missing here so it is not possible to invoke it locally. "
+                "If this function was retrieved via `Function.lookup` you need to use `.remote()`."
+            )
+            raise ExecutionError(msg)
+
         info = self._get_info()
+        if not info.raw_f:
+            # Here if calling .local on a service function itself which should never happen
+            # TODO: check if we end up here in a container for a serialized function?
+            raise ExecutionError("Can't call .local on service function")
 
         if is_local() and self.spec.volumes or self.spec.network_file_systems:
             warnings.warn(
                 f"The {info.function_name} function is executing locally "
                 + "and will not have access to the mounted Volume or NetworkFileSystem data"
             )
-        if not info or not info.raw_f:
-            msg = (
-                "The definition for this function is missing so it is not possible to invoke it locally. "
-                "If this function was retrieved via `Function.lookup` you need to use `.remote()`."
-            )
-            raise ExecutionError(msg)
 
         obj: Optional["modal.cls._Obj"] = self._get_obj()
 
@@ -1364,9 +1379,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         else:
             # This is a method on a class, so bind the self to the function
             user_cls_instance = obj._cached_user_cls_instance()
-
             fun = info.raw_f.__get__(user_cls_instance)
 
+            # TODO: replace implicit local enter/exit with a context manager
             if is_async(info.raw_f):
                 # We want to run __aenter__ and fun in the same coroutine
                 async def coro():

modal/functions.pyi

@@ -157,7 +157,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
         image: modal.image._Image,
         secrets: collections.abc.Sequence[modal.secret._Secret] = (),
         schedule: typing.Optional[modal.schedule.Schedule] = None,
-        is_generator=False,
+        is_generator: bool = False,
         gpu: typing.Union[
             None, bool, str, modal.gpu._GPUConfig, list[typing.Union[None, bool, str, modal.gpu._GPUConfig]]
         ] = None,
@@ -234,7 +234,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     @property
     async def web_url(self) -> str: ...
     @property
-    def is_generator(self) -> bool: ...
+    async def is_generator(self) -> bool: ...
     @property
     def cluster_size(self) -> int: ...
     def _map(
@@ -246,6 +246,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     async def _call_generator_nowait(self, args, kwargs): ...
     async def remote(self, *args: P.args, **kwargs: P.kwargs) -> ReturnType: ...
     def remote_gen(self, *args, **kwargs) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
+    def _is_local(self): ...
     def _get_info(self) -> modal._utils.function_utils.FunctionInfo: ...
     def _get_obj(self) -> typing.Optional[modal.cls._Obj]: ...
     def local(self, *args: P.args, **kwargs: P.kwargs) -> OriginalReturnType: ...
@@ -325,7 +326,7 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
         image: modal.image.Image,
         secrets: collections.abc.Sequence[modal.secret.Secret] = (),
         schedule: typing.Optional[modal.schedule.Schedule] = None,
-        is_generator=False,
+        is_generator: bool = False,
         gpu: typing.Union[
             None, bool, str, modal.gpu._GPUConfig, list[typing.Union[None, bool, str, modal.gpu._GPUConfig]]
         ] = None,
@@ -467,6 +468,7 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     remote_gen: __remote_gen_spec
 
+    def _is_local(self): ...
     def _get_info(self) -> modal._utils.function_utils.FunctionInfo: ...
     def _get_obj(self) -> typing.Optional[modal.cls.Obj]: ...
     def local(self, *args: P.args, **kwargs: P.kwargs) -> OriginalReturnType: ...

modal/mount.py

@@ -483,7 +483,9 @@ class _Mount(_Object, type_prefix="mo"):
                 logger.debug(f"Creating blob file for {file_spec.source_description} ({file_spec.size} bytes)")
                 async with blob_upload_concurrency:
                     with file_spec.source() as fp:
-                        blob_id = await blob_upload_file(fp, resolver.client.stub)
+                        blob_id = await blob_upload_file(
+                            fp, resolver.client.stub, sha256_hex=file_spec.sha256_hex, md5_hex=file_spec.md5_hex
+                        )
                 logger.debug(f"Uploading blob file {file_spec.source_description} as {remote_filename}")
                 request2 = api_pb2.MountPutFileRequest(data_blob_id=blob_id, sha256_hex=file_spec.sha256_hex)
             else:

modal/network_file_system.py

@@ -245,7 +245,10 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         if data_size > LARGE_FILE_LIMIT:
             progress_task_id = progress_cb(name=remote_path, size=data_size)
             blob_id = await blob_upload_file(
-                fp, self._client.stub, progress_report_cb=functools.partial(progress_cb, progress_task_id)
+                fp,
+                self._client.stub,
+                progress_report_cb=functools.partial(progress_cb, progress_task_id),
+                sha256_hex=sha_hash,
             )
             req = api_pb2.SharedVolumePutFileRequest(
                 shared_volume_id=self.object_id,

modal/object.py

@@ -96,7 +96,9 @@ class _Object:
 
     def _initialize_from_other(self, other):
         # default implementation, can be overriden in subclasses
-        pass
+        self._object_id = other._object_id
+        self._is_hydrated = other._is_hydrated
+        self._client = other._client
 
     def _hydrate(self, object_id: str, client: _Client, metadata: Optional[Message]):
         assert isinstance(object_id, str)
@@ -139,7 +141,7 @@ class _Object:
 
         # Object to clone must already be hydrated, otherwise from_loader is more suitable.
         self._validate_is_hydrated()
-        obj = _Object.__new__(type(self))
+        obj = type(self).__new__(type(self))
         obj._initialize_from_other(self)
         return obj
 

modal/volume.py

@@ -632,7 +632,11 @@ class _VolumeUploadContextManager:
                 logger.debug(f"Creating blob file for {file_spec.source_description} ({file_spec.size} bytes)")
                 with file_spec.source() as fp:
                     blob_id = await blob_upload_file(
-                        fp, self._client.stub, functools.partial(self._progress_cb, progress_task_id)
+                        fp,
+                        self._client.stub,
+                        functools.partial(self._progress_cb, progress_task_id),
+                        sha256_hex=file_spec.sha256_hex,
+                        md5_hex=file_spec.md5_hex,
                     )
                 logger.debug(f"Uploading blob file {file_spec.source_description} as {remote_filename}")
                 request2 = api_pb2.MountPutFileRequest(data_blob_id=blob_id, sha256_hex=file_spec.sha256_hex)

{modal-0.68.9.dist-info → modal-0.68.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: modal
-Version: 0.68.9
+Version: 0.68.14
 Summary: Python client library for Modal
 Author: Modal Labs
 Author-email: support@modal.com

{modal-0.68.9.dist-info → modal-0.68.14.dist-info}/RECORD

@@ -3,7 +3,7 @@ modal/__main__.py,sha256=scYhGFqh8OJcVDo-VOxIT6CCwxOgzgflYWMnIZiMRqE,2871
 modal/_clustered_functions.py,sha256=kTf-9YBXY88NutC1akI-gCbvf01RhMPCw-zoOI_YIUE,2700
 modal/_clustered_functions.pyi,sha256=vllkegc99A0jrUOWa8mdlSbdp6uz36TsHhGxysAOpaQ,771
 modal/_container_entrypoint.py,sha256=wk10vA5vRZZsVwQ0yINOLd0i-NwH7x6XbhTslumvGjo,28910
-modal/_ipython.py,sha256=HF_DYy0e0qM9WnGDmTY30s1RxzGya9GeORCauCEpRaE,450
+modal/_ipython.py,sha256=TW1fkVOmZL3YYqdS2YlM1hqpf654Yf8ZyybHdBnlhSw,301
 modal/_location.py,sha256=S3lSxIU3h9HkWpkJ3Pwo0pqjIOSB1fjeSgUsY3x7eec,1202
 modal/_output.py,sha256=0fWX_KQwhER--U81ys16CL-pA5A-LN20C0EZjElKGJQ,25410
 modal/_proxy_tunnel.py,sha256=gnKyCfmVB7x2d1A6c-JDysNIP3kEFxmXzhcXhPrzPn0,1906
@@ -19,11 +19,11 @@ modal/app.py,sha256=EJ7FUN6rWnSwLJoYJh8nmKg_t-8hdN8_rt0OrkP7JvQ,46084
 modal/app.pyi,sha256=BE5SlR5tRECuc6-e2lUuOknDdov3zxgZ4N0AsLb5ZVQ,25270
 modal/call_graph.py,sha256=1g2DGcMIJvRy-xKicuf63IVE98gJSnQsr8R_NVMptNc,2581
 modal/client.py,sha256=nyPjfromWBeOyurexpFP2QLQNk822RPggMCLyX9j1jA,15247
-modal/client.pyi,sha256=pl58Y423t0X7ykjle0WhhFYcAirdwjSD4jGS2qqYW_Y,7278
+modal/client.pyi,sha256=4x5j0yBlE_sZf8cS2eChs-pYuxr-_SsRiKrf1fSJmfA,7280
 modal/cloud_bucket_mount.py,sha256=G7T7jWLD0QkmrfKR75mSTwdUZ2xNfj7pkVqb4ipmxmI,5735
 modal/cloud_bucket_mount.pyi,sha256=CEi7vrH3kDUF4LAy4qP6tfImy2UJuFRcRbsgRNM1wo8,1403
-modal/cls.py,sha256=pMirIOmb59YzaIK2rn7Vd756E1QKDDweYT90GYIHiMk,27472
-modal/cls.pyi,sha256=47jaIT06fz8PSUrs-MaNn6r03PHsAyUGsKuK5e9RMhQ,8140
+modal/cls.py,sha256=ONnrfZ2vPcaY2JuKypPiBA9eTiyg8Qfg-Ull40nn9zs,30956
+modal/cls.pyi,sha256=uoOEANXgCFT9Au3e-_bU98M6ZfAgQWF5ngj8f4c6qpY,8225
 modal/config.py,sha256=1KhNJkjYsJkX1V8RPPdRYPlM2HE-ZZs0JVSxbiXjmrw,11010
 modal/container_process.py,sha256=zDxCLk6KfJT1G9FfNtjom6gekBQ46op3TWepT7-Hkbg,6077
 modal/container_process.pyi,sha256=dqtqBmyRpXXpRrDooESL6WBVU_1Rh6OG-66P2Hk9E5U,2666
@@ -35,18 +35,18 @@ modal/exception.py,sha256=dRK789TD1HaB63kHhu1yZuvS2vP_Vua3iLMBtA6dgqk,7128
 modal/experimental.py,sha256=jFuNbwrNHos47viMB9q-cHJSvf2RDxDdoEcss9plaZE,2302
 modal/file_io.py,sha256=q8s872qf6Ntdw7dPogDlpYbixxGkwCA0BlQn2UUoVhY,14637
 modal/file_io.pyi,sha256=pfkmJiaBpMCZReE6-KCjYOzB1dVtyYDYokJoYX8ARK4,6932
-modal/functions.py,sha256=rtqs2Rq-Jg8_BniksWAqxId0aLU8obtRzw80--VD4zk,66960
-modal/functions.pyi,sha256=IyuM9TV79JfrtfTaJ4yq3EcWp3yHuxLavpxTOwSWEDw,24988
+modal/functions.py,sha256=IIdHw0FNOdoMksG1b2zvkn8f-xskhJu07ZvHMey9iq4,67667
+modal/functions.pyi,sha256=EYH4w4VgQtdbEWLGarnU5QtYVfuM2_tnovKFEbYyg2c,25068
 modal/gpu.py,sha256=r4rL6uH3UJIQthzYvfWauXNyh01WqCPtKZCmmSX1fd4,6881
 modal/image.py,sha256=cQ6WP1xHXZT_nY8z3aEFiGwKzrTV0yxi3Ab8JzF91eo,79653
 modal/image.pyi,sha256=PIKH6JBA4L5TfdJrQu3pm2ykyIITmiP920TpP8cdyQA,24585
 modal/io_streams.py,sha256=QkQiizKRzd5bnbKQsap31LJgBYlAnj4-XkV_50xPYX0,15079
 modal/io_streams.pyi,sha256=bCCVSxkMcosYd8O3PQDDwJw7TQ8JEcnYonLJ5t27TQs,4804
-modal/mount.py,sha256=liaid5p42o0OKnzoocJJ_oCovDVderk3-JuCTa5pqtA,27656
+modal/mount.py,sha256=7FJrS-QkRJGndKuvRnMz452wfUcbLpd_UEnmFgQCKQQ,27770
 modal/mount.pyi,sha256=3e4nkXUeeVmUmOyK8Tiyk_EQlHeWruN3yGJVnmDUVrI,9761
-modal/network_file_system.py,sha256=NKZgh_p8MyJyyJgP92lhRgTmwA3kOPw7m8AbYlchhCE,14530
+modal/network_file_system.py,sha256=kwwQLCJVO086FTiAWSF_jz9BkqijZLpSbEYXpFvS0Ik,14600
 modal/network_file_system.pyi,sha256=8mHKXuRkxHPazF6ljIW7g4M5aVqLSl6eKUPLgDCug5c,7901
-modal/object.py,sha256=KmtWRDd5ntHGSO9ASHe9MJcIgjNRqaDXGc3rWOXwrmA,9646
+modal/object.py,sha256=HZs3N59C6JxlMuPQWJYvrWV1FEEkH9txUovVDorVUbs,9763
 modal/object.pyi,sha256=MO78H9yFSE5i1gExPEwyyQzLdlshkcGHN1aQ0ylyvq0,8802
 modal/output.py,sha256=N0xf4qeudEaYrslzdAl35VKV8rapstgIM2e9wO8_iy0,1967
 modal/parallel_map.py,sha256=4aoMXIrlG3wl5Ifk2YDNOQkXsGRsm6Xbfm6WtJ2t3WY,16002
@@ -73,22 +73,22 @@ modal/serving.pyi,sha256=ncV-9jY_vZYFnGs5ZnMb3ffrX8LmcLdIMHBC56xRbtE,1711
 modal/stream_type.py,sha256=A6320qoAAWhEfwOCZfGtymQTu5AfLfJXXgARqooTPvY,417
 modal/token_flow.py,sha256=LcgSce_MSQ2p7j55DPwpVRpiAtCDe8GRSEwzO7muNR8,6774
 modal/token_flow.pyi,sha256=gOYtYujrWt_JFZeiI8EmfahXPx5GCR5Na-VaPQcWgEY,1937
-modal/volume.py,sha256=IISuMeXq9MoSkhXg8Q6JG0F-2n9NTkWk0xGuJB8l3d8,29159
+modal/volume.py,sha256=PGzbninvRU-IhSwJgM2jZKzD8llRhZhadsOxZ-YNwaM,29316
 modal/volume.pyi,sha256=St0mDiaojfep6Bs4sBbkRJmeacYHF6lh6FKOWGmheHA,11182
 modal/_runtime/__init__.py,sha256=MIEP8jhXUeGq_eCjYFcqN5b1bxBM4fdk0VESpjWR0fc,28
 modal/_runtime/asgi.py,sha256=GvuxZqWnIHMIR-Bx5f7toCQlkERaJO8CHjTPNM9IFIw,21537
 modal/_runtime/container_io_manager.py,sha256=ctgyNFiHjq1brCrabXmlurkAXjnrCeWPRvTVa735vRw,44215
 modal/_runtime/execution_context.py,sha256=E6ofm6j1POXGPxS841X3V7JU6NheVb8OkQc7JpLq4Kg,2712
 modal/_runtime/telemetry.py,sha256=T1RoAGyjBDr1swiM6pPsGRSITm7LI5FDK18oNXxY08U,5163
-modal/_runtime/user_code_imports.py,sha256=q_3JOYqCPDcVFZWCHEjyEqj8yzdFsQ49HzeqYmFDLbk,14521
+modal/_runtime/user_code_imports.py,sha256=4fI0F9OIaNOcO_S4Tx2JcnYwZwZq6JdhMAkUzYN6je4,14629
 modal/_utils/__init__.py,sha256=waLjl5c6IPDhSsdWAm9Bji4e2PVxamYABKAze6CHVXY,28
 modal/_utils/app_utils.py,sha256=88BT4TPLWfYAQwKTHcyzNQRHg8n9B-QE2UyJs96iV-0,108
 modal/_utils/async_utils.py,sha256=9ubwMkwiDB4gzOYG2jL9j7Fs-5dxHjcifZe3r7JRg-k,25091
-modal/_utils/blob_utils.py,sha256=0k_qUpO5GHnz538wjRhyRw4NdJ5O322N7QSilIu32jw,16601
-modal/_utils/function_utils.py,sha256=GV-mq6sSGXQIX5PcExYWJMaWY9YLjChjsiQjg-oPvm8,24902
-modal/_utils/grpc_testing.py,sha256=iqM9n5M0cWUUIIWNaEDer_pIfPnzXdZBO4L8FVbNepQ,8309
+modal/_utils/blob_utils.py,sha256=1D_dXspFdsVxkW3gsYH-wJUUHiCpYvlwhmCgYZZgN9k,17237
+modal/_utils/function_utils.py,sha256=LgcveUUb4XU_dWxtqgK_3ujZBvS3cGVzcDOkljyFZ2w,25066
+modal/_utils/grpc_testing.py,sha256=H1zHqthv19eGPJz2HKXDyWXWGSqO4BRsxah3L5Xaa8A,8619
 modal/_utils/grpc_utils.py,sha256=PPB5ay-vXencXNIWPVw5modr3EH7gfq2QPcO5YJ1lMU,7737
-modal/_utils/hash_utils.py,sha256=LOWJ9U5Eaye2ZIGQOdEk8RN8ExPFovGQisyuGv1PXU0,2236
+modal/_utils/hash_utils.py,sha256=zg3J6OGxTFGSFri1qQ12giDz90lWk8bzaxCTUCRtiX4,3034
 modal/_utils/http_utils.py,sha256=VKXYNPJtrSwZ1ttcXVGQUWmn8cLAXiOTv05g2ac3GbU,2179
 modal/_utils/logger.py,sha256=ePzdudrtx9jJCjuO6-bcL_kwUJfi4AwloUmIiNtqkY0,1330
 modal/_utils/mount_utils.py,sha256=J-FRZbPQv1i__Tob-FIpbB1oXWpFLAwZiB4OCiJpFG0,3206
@@ -161,10 +161,10 @@ modal_proto/options_pb2_grpc.pyi,sha256=CImmhxHsYnF09iENPoe8S4J-n93jtgUYD2JPAc0y
 modal_proto/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modal_version/__init__.py,sha256=RT6zPoOdFO99u5Wcxxaoir4ZCuPTbQ22cvzFAXl3vUY,470
 modal_version/__main__.py,sha256=2FO0yYQQwDTh6udt1h-cBnGd1c4ZyHnHSI4BksxzVac,105
-modal_version/_version_generated.py,sha256=KGFfqnh_ipp1SMsIR7jjAwSJnOQ_TUXMsPTVZMuxRcs,148
-modal-0.68.9.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-modal-0.68.9.dist-info/METADATA,sha256=Boz-j_G8TxxueTch5nd084dyB-x7_Ti0qNuYKjCGzFo,2328
-modal-0.68.9.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-modal-0.68.9.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-0.68.9.dist-info/top_level.txt,sha256=1nvYbOSIKcmU50fNrpnQnrrOpj269ei3LzgB6j9xGqg,64
-modal-0.68.9.dist-info/RECORD,,
+modal_version/_version_generated.py,sha256=SWqJPFBaGp3gDChTb6Zx02oI_iQyIRtKpGgcw69Yegs,149
+modal-0.68.14.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-0.68.14.dist-info/METADATA,sha256=gHSGyvKb5gQiL1YbO3mRis3T8En0t19ug9mfOY4HYos,2329
+modal-0.68.14.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+modal-0.68.14.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-0.68.14.dist-info/top_level.txt,sha256=1nvYbOSIKcmU50fNrpnQnrrOpj269ei3LzgB6j9xGqg,64
+modal-0.68.14.dist-info/RECORD,,

modal_version/_version_generated.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2024
 
 # Note: Reset this value to -1 whenever you make a minor `0.X` release of the client.
-build_number = 9  # git: 02c0b6e
+build_number = 14  # git: 45ed247