modal 1.6.2.dev8__tar.gz → 1.6.2.dev10__tar.gz

{modal-1.6.2.dev8 → modal-1.6.2.dev10}/PKG-INFO

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

{modal-1.6.2.dev8 → modal-1.6.2.dev10}/modal/_workspace.py

@@ -8,7 +8,8 @@ from typing import Optional
 
 from google.protobuf.empty_pb2 import Empty
 
-from modal.exception import DeprecationError, InvalidError
+from modal.exception import DeprecationError, InvalidError, NotFoundError
+from modal.types import ServiceUserInfo
 from modal_proto import api_pb2
 
 from ._load_context import LoadContext
@@ -129,6 +130,15 @@ class _Workspace(_Object, type_prefix="ac"):
         """Namespace for Workspace settings APIs."""
         return _WorkspaceSettingsManager(self)
 
+    @property
+    def service_users(self) -> "_WorkspaceServiceUserManager":
+        """Namespace for managing Service Users in a Workspace.
+
+        See [the guide](https://modal.com/docs/guide/service-users) for more information about Service
+        Users.
+        """
+        return _WorkspaceServiceUserManager(self)
+
 
 class _WorkspaceProxyTokenManager:
     """mdmd:namespace"""
@@ -556,3 +566,172 @@ class _WorkspaceSettingsManager:
                 await self._set_default_environment(value)
             case _:
                 raise ValueError(f"Unknown setting {name!r}. Valid settings: {', '.join(self._valid_settings())}")
+
+
+class _WorkspaceServiceUserManager:
+    """mdmd:namespace"""
+
+    def __init__(self, workspace: _Workspace):
+        """mdmd:hidden"""
+        self._workspace = workspace
+
+    async def create(self, name: str, *, expires_in: int | None) -> TokenData:
+        """Create a new Service User in the current workspace.
+
+        To call this function, you are required to have Manager permissions in the Workspace.
+
+        Args:
+            name: The name of the new Service User. Must consistent only of alphanumeric, '-', or '_'
+                characters.
+            expires_in: An expiration time, in seconds, after which the token will stop working. If
+                `None`, the token will never expire.
+
+        Returns:
+            A `TokenData` dataclass containing the credentials for the Service User. Note that this
+            is the only time you will be able to view these credentials.
+
+        Examples:
+
+        ```python notest
+        ws = modal.Workspace.from_context()
+
+        # Creates a Service User named "test-service-user", whose credentials expire after one year.
+        service_user_token_data = ws.service_users.create(
+            "test-service-user",
+            expires_in=datetime.timedelta(days=365).total_seconds(),
+        )
+        ```
+        """
+        if not self._workspace._is_hydrated:
+            await self._workspace.hydrate()
+
+        if expires_in is None:
+            req = api_pb2.ServiceUserCreateRequest(name=name)
+        else:
+            req = api_pb2.ServiceUserCreateRequest(name=name, expires_in_seconds=expires_in)
+
+        resp = await self._workspace.client._stub.ServiceUserCreate(req)
+
+        return TokenData(token_id=resp.token_id, token_secret=resp.token_secret)
+
+    async def set_role(
+        self,
+        service_user_name: str,
+        environment_name: str,
+        *,
+        role: str,
+    ) -> None:
+        """Set the role of a specified Service User within an Environment.
+
+        To call this function, you are required to have Manager permissions in the Workspace.
+
+        Args:
+            service_user_name: The name of the Service User.
+            environment_name: The name of the Environment to which the Service User's new role will
+                apply.
+            role: The access level to grant this Service User.
+
+        Examples:
+
+        ```python notest
+        ws = modal.Workspace.from_context()
+        # Grants Service User "test-service-user" the Viewer role in Environment "production"
+        ws.service_users.set_role("test-service-user", "production", role="viewer")
+
+        # Revokes access to "production" from Service User "test-service-user"
+        ws.service_users.set_role("test-service-user", "production", role="no-access")
+        ```
+        """
+
+        if not role:
+            raise InvalidError("Invalid argument: `role` must not be empty.")
+
+        if not self._workspace._is_hydrated:
+            await self._workspace.hydrate()
+
+        from ._environments import _Environment
+
+        env = _Environment.from_name(environment_name, client=self._workspace.client)
+        await env.hydrate()
+
+        await self._workspace.client._stub.EnvironmentRoleSet(
+            api_pb2.EnvironmentRoleSetRequest(
+                service_user_name=service_user_name,
+                environment_id=env.object_id,
+                role_str=role,
+            )
+        )
+
+    async def info(self, name: str) -> ServiceUserInfo:
+        """Get information about a specific Service User.
+
+        Args:
+            name: The name of the Service User to introspect.
+
+        Returns:
+            A `ServiceUserInfo` dataclass containing information about the Service User.
+
+        Examples:
+
+        ```python notest
+        ws = modal.Workspace.from_context()
+        service_user = ws.service_users.info("test-service-user")
+        ```
+        """
+
+        if not self._workspace._is_hydrated:
+            await self._workspace.hydrate()
+
+        resp = await self._workspace.client._stub.ServiceUserInfo(
+            api_pb2.ServiceUserInfoRequest(service_user_name=name)
+        )
+
+        return ServiceUserInfo._from_proto(resp.service_user)
+
+    async def list(self) -> list[ServiceUserInfo]:
+        """List all Service Users in the current workspace.
+
+        Returns:
+            A list of `ServiceUserInfo` dataclasses.
+
+        Examples:
+
+        ```python notest
+        ws = modal.Workspace.from_context()
+        for service_user in ws.service_users.list():
+            print(service_user.name)
+        ```
+        """
+
+        if not self._workspace._is_hydrated:
+            await self._workspace.hydrate()
+
+        resp = await self._workspace.client._stub.ServiceUserList(Empty())
+
+        return [ServiceUserInfo._from_proto(su) for su in resp.service_users]
+
+    async def delete(self, name: str, *, allow_missing: bool = False) -> None:
+        """Permanently delete a Service User.
+
+        Args:
+            name: The name of the Service User to delete.
+            allow_missing: If `True`, do not throw an exception if the Service User does not exist.
+
+        Examples:
+
+        ```python notest
+        ws = modal.Workspace.from_context()
+        ws.service_users.delete("test-service-user")
+        ```
+        """
+
+        if not self._workspace._is_hydrated:
+            await self._workspace.hydrate()
+
+        try:
+            await self._workspace.client._stub.ServiceUserDelete(
+                api_pb2.ServiceUserDeleteRequest(service_user_name=name)
+            )
+        except NotFoundError:
+            if not allow_missing:
+                raise

{modal-1.6.2.dev8 → modal-1.6.2.dev10}/modal/cli/import_refs.py

@@ -7,11 +7,14 @@ or the app lookup of `modal deploy some_file.py`.
 These functions are only called by the Modal CLI, not in tasks.
 """
 
+import atexit
 import dataclasses
 import importlib
 import importlib.util
 import inspect
+import shutil
 import sys
+import tempfile
 import typing
 from collections import defaultdict
 from dataclasses import dataclass
@@ -60,15 +63,40 @@ def parse_import_ref(object_ref: str, use_module_mode: bool = False, command: st
 
 DEFAULT_APP_NAME = "app"
 
+STDIN_REF = "-"
+STDIN_MODULE_NAME = "modal_stdin_app"
 
-def import_file_or_module(import_ref: ImportRef, base_cmd: str = ""):
+
+def _write_stdin_script() -> str:
+    if sys.stdin is None or sys.stdin.isatty():
+        raise InvalidError("No script was piped on stdin. Usage: `cat my_app.py | modal run -`")
+    source = sys.stdin.read()
+    # The file must outlive the import: the entrypoint mount is built from it when the App runs.
+    tmp_dir = tempfile.mkdtemp(prefix="modal-stdin-")
+    atexit.register(shutil.rmtree, tmp_dir, ignore_errors=True)
+    script_path = Path(tmp_dir) / f"{STDIN_MODULE_NAME}.py"
+    script_path.write_text(source)
+    return str(script_path)
+
+
+def import_file_or_module(import_ref: ImportRef, base_cmd: str = "", allow_stdin: bool = False):
     if "" not in sys.path:
         # When running from a CLI like `modal run`
         # the current working directory isn't added to sys.path
         # so we add it in order to make module path specification possible
         sys.path.insert(0, "")  # "" means the current working directory
 
-    if not import_ref.file_or_module.endswith(".py") or import_ref.use_module_mode:
+    from_stdin = import_ref.file_or_module == STDIN_REF
+    if from_stdin:
+        if not allow_stdin:
+            raise InvalidError(f"`{base_cmd}` does not support reading a script from stdin.")
+        if import_ref.use_module_mode:
+            raise InvalidError("Reading a script from stdin (`-`) can't be combined with the -m flag.")
+        script_path = _write_stdin_script()
+    else:
+        script_path = import_ref.file_or_module
+
+    if not script_path.endswith(".py") or import_ref.use_module_mode:
         if not import_ref.use_module_mode:
             raise InvalidError(
                 "Python module paths must be specified with the -m flag. "
@@ -82,7 +110,7 @@ def import_file_or_module(import_ref: ImportRef, base_cmd: str = ""):
     else:
         # when using a script path, that scripts directory should also be on the path as it is
         # with `python some/script.py`
-        full_path = Path(import_ref.file_or_module).resolve()
+        full_path = Path(script_path).resolve()
         if "." in full_path.name.removesuffix(".py"):
             raise InvalidError(
                 f"Invalid Modal source filename: {full_path.name!r}."
@@ -90,10 +118,10 @@ def import_file_or_module(import_ref: ImportRef, base_cmd: str = ""):
             )
         sys.path.insert(0, str(full_path.parent))
 
-        module_name = inspect.getmodulename(import_ref.file_or_module)
+        module_name = inspect.getmodulename(script_path)
         assert module_name is not None
         # Import the module - see https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
-        spec = importlib.util.spec_from_file_location(module_name, import_ref.file_or_module)
+        spec = importlib.util.spec_from_file_location(module_name, script_path)
         assert spec is not None
         module = importlib.util.module_from_spec(spec)
         sys.modules[module_name] = module
@@ -103,7 +131,7 @@ def import_file_or_module(import_ref: ImportRef, base_cmd: str = ""):
                 spec.loader.exec_module(module)
         except Exception as exc:
             if isinstance(exc, ImportError) and "attempted relative import with no known parent package" in str(exc):
-                if import_ref.file_or_module and import_ref.command and not import_ref.use_module_mode:
+                if import_ref.command and not import_ref.use_module_mode and not from_stdin:
                     file_path = Path(import_ref.file_or_module)
                     suggested_module_path = ".".join(file_path.parts).removesuffix(".py").lstrip(".")
                     suffix = f"::{import_ref.object_path}" if import_ref.object_path else ""
@@ -356,6 +384,7 @@ def import_and_filter(
     accept_local_entrypoint=True,
     accept_webhook=False,
     accept_service_functions=False,
+    allow_stdin=False,
 ) -> tuple[Runnable | None, list[CLICommand]]:
     """Takes a function ref string and returns a single determined "runnable" to use, and a list of all available
     runnables.
@@ -371,7 +400,7 @@ def import_and_filter(
     3. if there is a single method (within a class) that one is used
     """
     # all commands:
-    module = import_file_or_module(import_ref, base_cmd)
+    module = import_file_or_module(import_ref, base_cmd, allow_stdin=allow_stdin)
     cli_commands = list_cli_commands(
         dict(inspect.getmembers(module)),
         include_service_functions=accept_service_functions,

{modal-1.6.2.dev8 → modal-1.6.2.dev10}/modal/cli/run.py

@@ -2,7 +2,9 @@
 import asyncio
 import functools
 import inspect
+import os
 import re
+import stat
 import sys
 import time
 import typing
@@ -25,6 +27,7 @@ from ..runner import DEPLOYMENT_STRATEGY_TYPE, deploy_app, run_app
 from ..serving import serve_app
 from ._help import ModalCommand, ModalGroup, _consume_global_options, _global_option_token_length
 from .import_refs import (
+    STDIN_REF,
     CLICommand,
     MethodReference,
     _get_runnable_app,
@@ -399,6 +402,14 @@ def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoin
         return click.command(cls=ModalCommand)(with_click_options)
 
 
+def _stdin_is_piped() -> bool:
+    try:
+        mode = os.fstat(sys.stdin.fileno()).st_mode
+    except (AttributeError, OSError, ValueError):
+        return False
+    return stat.S_ISFIFO(mode) or stat.S_ISREG(mode)
+
+
 def _get_runnable_list(all_usable_commands: list[CLICommand]) -> str:
     usable_command_lines = []
     for cmd in all_usable_commands:
@@ -428,6 +439,8 @@ class RunGroup(ModalGroup):
             elif arg == "--":
                 func_ref_index += 1
                 break
+            elif arg == STDIN_REF:
+                break
             elif param := option_params.get(arg.split("=", 1)[0]):
                 func_ref_index += 1 if "=" in arg or param.is_flag else param.nargs + 1
             elif arg.startswith("-"):
@@ -435,6 +448,14 @@ class RunGroup(ModalGroup):
             else:
                 break
 
+        missing_func_ref = func_ref_index >= len(args)
+        requests_help = any(arg in ctx.help_option_names for arg in args)
+        if missing_func_ref and not requests_help and not ctx.resilient_parsing and _stdin_is_piped():
+            raise click.UsageError(
+                f"Missing FUNC_REF. To read the script from stdin, pass `{STDIN_REF}`: `cat my_app.py | modal run -`",
+                ctx,
+            )
+
         args[:] = _consume_global_options(ctx, args[:func_ref_index]) + args[func_ref_index:]
         return click.Group.parse_args(self, ctx, args)
 
@@ -448,9 +469,23 @@ class RunGroup(ModalGroup):
         func_ref = cmd_name
 
         import_ref = parse_import_ref(func_ref, use_module_mode=ctx.params["m"], command="modal run")
+        from_stdin = import_ref.file_or_module == STDIN_REF
+        if from_stdin and ctx.params["interactive"]:
+            raise ClickException("Interactive mode can't be used when reading a script from stdin.")
         runnable, all_usable_commands = import_and_filter(
-            import_ref, base_cmd="modal run", accept_local_entrypoint=True, accept_webhook=False
+            import_ref, base_cmd="modal run", accept_local_entrypoint=True, accept_webhook=False, allow_stdin=True
         )
+        if not runnable and from_stdin:
+            help_header = (
+                "Couldn't determine what to run from the script on stdin. Define a single "
+                "`@app.local_entrypoint()`, or save the script to a file and pass `my_app.py::my_function`."
+            )
+            if all_usable_commands:
+                help_footer = "The script has the following functions and local entrypoints:\n"
+                help_footer += _get_runnable_list(all_usable_commands)
+            else:
+                help_footer = "The script has no functions or local entrypoints."
+            raise ClickException(f"{help_header}\n\n{help_footer}")
         if not runnable:
             help_header = (
                 "Specify a Modal Function or local entrypoint to run. E.g.\n"
@@ -535,6 +570,21 @@ def run(
     ```
     modal run -m my_project.my_app
     ```
+
+    Pass `-` to read the script from stdin. The script must have a single local
+    entrypoint (or a single function):
+
+    ```
+    modal run - <<'EOF'
+    import modal
+
+    app = modal.App()
+
+    @app.function()
+    def hello():
+        print("hello from Modal")
+    EOF
+    ```
     """
     ctx.ensure_object(dict)
     ctx.obj["name"] = name