modAL 1.3.2.dev0__tar.gz → 1.3.3__tar.gz

{modal-1.3.2.dev0 → modal-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.3.2.dev0
+Version: 1.3.3
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0

{modal-1.3.2.dev0 → modal-1.3.3}/modal/__init__.py

@@ -9,6 +9,7 @@ if sys.version_info[:2] >= (3, 15):
 from modal_version import __version__
 
 try:
+    from . import billing
     from ._runtime.execution_context import current_function_call_id, current_input_id, interact, is_local
     from ._tunnel import Tunnel, forward
     from .app import App
@@ -41,7 +42,6 @@ try:
     from .schedule import Cron, Period
     from .scheduler_placement import SchedulerPlacement
     from .secret import Secret
-    from .server import Server
     from .snapshot import SandboxSnapshot
     from .volume import Volume
 except Exception:
@@ -76,11 +76,11 @@ __all__ = [
     "SandboxSnapshot",
     "SchedulerPlacement",
     "Secret",
-    "Server",
     "Tunnel",
     "Volume",
     "asgi_app",
     "batched",
+    "billing",
     "concurrent",
     "current_function_call_id",
     "current_input_id",

modal-1.3.3/modal/__main__.py

@@ -0,0 +1,49 @@
+# Copyright Modal Labs 2022
+import sys
+
+from ._traceback import reduce_traceback_to_user_code
+from .cli._traceback import highlight_modal_warnings, setup_rich_traceback
+from .cli.entry_point import entrypoint_cli
+from .cli.import_refs import _CliUserExecutionError
+from .config import config
+from .output import OutputManager, enable_output
+
+
+def main():
+    # Setup rich tracebacks, but only on user's end, when using the Modal CLI.
+    setup_rich_traceback()
+    highlight_modal_warnings()
+
+    # Enable rich output for the entire CLI session
+    with enable_output():
+        try:
+            entrypoint_cli()
+
+        except _CliUserExecutionError as exc:
+            if config.get("traceback"):
+                raise
+
+            assert exc.__cause__  # We should always raise this class from another error
+            tb = reduce_traceback_to_user_code(exc.__cause__.__traceback__, exc.user_source)
+            sys.excepthook(type(exc.__cause__), exc.__cause__, tb)
+            sys.exit(1)
+
+        except Exception as exc:
+            if (
+                # User has asked to alway see full tracebacks
+                config.get("traceback")
+                # The exception message is empty, so we need to provide _some_ actionable information
+                or not str(exc)
+            ):
+                raise
+
+            content = str(exc)
+            if notes := getattr(exc, "__notes__", []):
+                content = f"{content}\n\nNote: {' '.join(notes)}"
+
+            OutputManager.get().print_error(content)
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

{modal-1.3.2.dev0 → modal-1.3.3}/modal/_billing.py

@@ -40,8 +40,14 @@ async def _workspace_billing_report(
     partial `end` intervals will be excluded.
 
     Additional user-provided metadata can be included in the report if the objects have tags
-    and `tag_names` (i.e., keys) are specified in the request. Note that tags will be attributed
-    to the entire interval even if they were added or removed at some point within it.
+    and `tag_names` (i.e., keys) are specified in the request. Alternatively, pass `tag_names=["*"]`
+    to include all tags in the report. Note that tags will be attributed to the entire interval even
+    if they were added or removed at some point within it. If the tag name was not in use during an
+    interval, it will be absent from the tags dictionary in that output row.
+
+    In most cases, billing data will be available in the database that this API queries within
+    minutes, although there may be collection delays. If completeness is important for your use
+    case, we recommend leaving a buffer after the end of the query interval.
 
     """
     if client is None:

{modal-1.3.2.dev0 → modal-1.3.3}/modal/_functions.py

@@ -21,7 +21,8 @@ from modal_proto.modal_api_grpc import ModalClientModal
 
 from ._load_context import LoadContext
 from ._object import _Object, live_method, live_method_gen
-from ._pty import get_pty_info
+from ._output.pty import get_pty_info
+from ._output.status import FunctionCreationStatus
 from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
 from ._runtime.execution_context import current_input_id, is_local
@@ -47,7 +48,6 @@ from ._utils.deprecation import deprecation_warning, warn_if_passing_namespace
 from ._utils.function_utils import (
     ATTEMPT_TIMEOUT_GRACE_PERIOD,
     OUTPUTS_TIMEOUT,
-    FunctionCreationStatus,
     FunctionInfo,
     _create_input,
     _process_result,
@@ -71,7 +71,7 @@ from .gpu import GPU_T, parse_gpu_config
 from .image import _Image
 from .mount import _get_client_mount, _Mount
 from .network_file_system import _NetworkFileSystem, network_file_system_mount_protos
-from .output import _get_output_manager
+from .output import OutputManager
 from .parallel_map import (
     _experimental_spawn_map_async,
     _experimental_spawn_map_sync,
@@ -922,7 +922,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         async def _load(
             self: _Function, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
         ):
-            with FunctionCreationStatus(resolver, tag) as function_creation_status:
+            with FunctionCreationStatus(tag) as function_creation_status:
                 timeout_secs = timeout
 
                 if app and app.is_interactive and not is_builder_function:
@@ -1639,10 +1639,7 @@ Use the `Function.get_web_url()` method instead.
             raise InvalidError("A generator function cannot be called with `.map(...)`.")
 
         assert self._function_name
-        if output_mgr := _get_output_manager():
-            count_update_callback = output_mgr.function_progress_callback(self._function_name, total=None)
-        else:
-            count_update_callback = None
+        count_update_callback = OutputManager.get().function_progress_callback(self._function_name, total=None)
 
         if self._input_plane_url:
             async with aclosing(

{modal-1.3.2.dev0 → modal-1.3.3}/modal/_object.py

@@ -39,6 +39,41 @@ def _get_environment_name(
         return config.get("environment")
 
 
+def live_method(method):
+    @wraps(method)
+    async def wrapped(self, *args, **kwargs):
+        await self.hydrate()
+        return await method(self, *args, **kwargs)
+
+    return wrapped
+
+
+def live_method_gen(method):
+    @wraps(method)
+    async def wrapped(self, *args, **kwargs):
+        await self.hydrate()
+        async with aclosing(method(self, *args, **kwargs)) as stream:
+            async for item in stream:
+                yield item
+
+    return wrapped
+
+
+def live_method_contextmanager(method):
+    # make sure a wrapped function returning an async context manager
+    # will not require both an `await func.aio()` and `async with`
+    # which would have been the case if it was wrapped in live_method
+
+    @wraps(method)
+    @contextlib.asynccontextmanager
+    async def wrapped(self, *args, **kwargs):
+        await self.hydrate()
+        async with method(self, *args, **kwargs) as ctx:
+            yield ctx
+
+    return wrapped
+
+
 class _Object:
     _type_prefix: ClassVar[Optional[str]] = None
     _prefix_to_type: ClassVar[dict[str, type]] = {}
@@ -275,6 +310,11 @@ class _Object:
             raise AttributeError(f"Attempting to get object_id of unhydrated {self}")
         return self._object_id
 
+    @live_method
+    async def get_dashboard_url(self) -> str:
+        """mdmd:hidden"""
+        return f"https://modal.com/id/{self.object_id}"
+
     @property
     def client(self) -> _Client:
         """mdmd:hidden"""
@@ -336,38 +376,3 @@ class _Object:
                 with suppress_tb_frame():  # skip this frame by default
                     await resolver.load(self, root_load_context)
         return self
-
-
-def live_method(method):
-    @wraps(method)
-    async def wrapped(self, *args, **kwargs):
-        await self.hydrate()
-        return await method(self, *args, **kwargs)
-
-    return wrapped
-
-
-def live_method_gen(method):
-    @wraps(method)
-    async def wrapped(self, *args, **kwargs):
-        await self.hydrate()
-        async with aclosing(method(self, *args, **kwargs)) as stream:
-            async for item in stream:
-                yield item
-
-    return wrapped
-
-
-def live_method_contextmanager(method):
-    # make sure a wrapped function returning an async context manager
-    # will not require both an `await func.aio()` and `async with`
-    # which would have been the case if it was wrapped in live_method
-
-    @wraps(method)
-    @contextlib.asynccontextmanager
-    async def wrapped(self, *args, **kwargs):
-        await self.hydrate()
-        async with method(self, *args, **kwargs) as ctx:
-            yield ctx
-
-    return wrapped

modal-1.3.3/modal/_output/__init__.py

@@ -0,0 +1 @@
+# Copyright Modal Labs 2025