modal 0.73.47__tar.gz → 0.73.49__tar.gz

{modal-0.73.47 → modal-0.73.49}/PKG-INFO

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

{modal-0.73.47 → modal-0.73.49}/modal/_functions.py

@@ -862,6 +862,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         warm_pool_size=function_definition.warm_pool_size,
                         concurrency_limit=function_definition.concurrency_limit,
                         task_idle_timeout_secs=function_definition.task_idle_timeout_secs,
+                        autoscaler_settings=function_definition.autoscaler_settings,
                         worker_id=function_definition.worker_id,
                         timeout_secs=function_definition.timeout_secs,
                         web_url=function_definition.web_url,

{modal-0.73.47 → modal-0.73.49}/modal/client.pyi

@@ -27,7 +27,7 @@ class _Client:
     _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.47"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.49"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -85,7 +85,7 @@ class Client:
     _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.47"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.49"
     ): ...
     def is_closed(self) -> bool: ...
     @property

{modal-0.73.47 → modal-0.73.49}/modal/functions.pyi

@@ -200,11 +200,11 @@ class Function(
 
     _call_generator_nowait: ___call_generator_nowait_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, *args, **kwargs) -> typing.Generator[typing.Any, None, None]: ...
@@ -219,19 +219,19 @@ class Function(
         self, *args: modal._functions.P.args, **kwargs: modal._functions.P.kwargs
     ) -> modal._functions.OriginalReturnType: ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
+        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
     ]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]: ...
 

{modal-0.73.47 → modal-0.73.49}/modal.egg-info/PKG-INFO

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

{modal-0.73.47 → modal-0.73.49}/modal.egg-info/SOURCES.txt

@@ -156,6 +156,9 @@ modal/requirements/base-images.json
 modal_docs/__init__.py
 modal_docs/gen_cli_docs.py
 modal_docs/gen_reference_docs.py
+modal_docs/mdmd/__init__.py
+modal_docs/mdmd/mdmd.py
+modal_docs/mdmd/signatures.py
 modal_proto/__init__.py
 modal_proto/api.proto
 modal_proto/api_grpc.py

modal-0.73.49/modal_docs/mdmd/__init__.py

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

modal-0.73.49/modal_docs/mdmd/mdmd.py

@@ -0,0 +1,195 @@
+# Copyright Modal Labs 2023
+"""mdmd - MoDal MarkDown"""
+
+import inspect
+import warnings
+from enum import Enum, EnumMeta
+from types import ModuleType
+from typing import Callable
+
+import synchronicity.synchronizer
+
+from .signatures import get_signature
+
+
+def format_docstring(docstring: str):
+    if docstring is None:
+        docstring = ""
+    else:
+        docstring = inspect.cleandoc(docstring)
+
+    if docstring and not docstring.endswith("\n"):
+        docstring += "\n"
+
+    return docstring
+
+
+def function_str(name: str, func):
+    signature = get_signature(name, func)
+    decl = f"""```python
+{signature}
+```\n\n"""
+    docstring = format_docstring(func.__doc__)
+    return decl + docstring
+
+
+def class_str(name, obj, title_level="##"):
+    def qual_name(cls):
+        if cls.__module__ == "builtins":
+            return cls.__name__
+        return f"{cls.__module__}.{cls.__name__}"
+
+    bases = [qual_name(b) for b in obj.__bases__]
+    bases_str = f"({', '.join(bases)})" if bases else ""
+    decl = f"""```python
+class {name}{bases_str}
+```\n\n"""
+    parts = [decl]
+    docstring = format_docstring(obj.__doc__)
+
+    if isinstance(obj, EnumMeta) and not docstring:
+        # Python 3.11 removed the docstring from enums
+        docstring = "An enumeration.\n"
+
+    if docstring:
+        parts.append(docstring + "\n")
+
+    if isinstance(obj, EnumMeta):
+        enum_vals = "\n".join(f"* `{k}`" for k in obj.__members__.keys())
+        parts.append(f"The possible values are:\n\n{enum_vals}\n")
+
+    else:
+        init = inspect.unwrap(obj.__init__)
+
+        if (inspect.isfunction(init) or inspect.ismethod(init)) and not object_is_private("constructor", init):
+            parts.append(function_str("__init__", init))
+
+    member_title_level = title_level + "#"
+
+    entries = {}
+
+    def rec_update_attributes(cls):
+        # first bases, then class itself
+        for base_cls in cls.__bases__:
+            rec_update_attributes(base_cls)
+        entries.update(cls.__dict__)
+
+    rec_update_attributes(obj)
+
+    for member_name, member in entries.items():
+        if isinstance(member, classmethod) or isinstance(member, staticmethod):
+            # get the original function definition instead of the descriptor object
+            member = getattr(obj, member_name)
+        elif isinstance(member, property):
+            member = member.fget
+        elif isinstance(member, (synchronicity.synchronizer.FunctionWithAio, synchronicity.synchronizer.MethodWithAio)):
+            member = member._func
+
+        if object_is_private(member_name, member):
+            continue
+
+        if callable(member):
+            parts.append(f"{member_title_level} {member_name}\n\n")
+            parts.append(function_str(member_name, member))
+
+    return "".join(parts)
+
+
+def module_str(header, module, title_level="#", filter_items: Callable[[ModuleType, str], bool] = None):
+    header = [f"{title_level} {header}\n\n"]
+    docstring = format_docstring(module.__doc__)
+    if docstring:
+        header.append(docstring + "\n")
+
+    object_docs = []
+    member_title_level = title_level + "#"
+    for qual_name, name, item in module_items(module, filter_items):
+        try:
+            if hasattr(item, "__wrapped__"):
+                item = item.__wrapped__
+        except KeyError:
+            pass
+        except:
+            print("failed on", qual_name, name, item)
+            raise
+        if inspect.isclass(item):
+            classdoc = class_str(name, item, title_level=member_title_level)
+            object_docs.append(f"{member_title_level} {qual_name}\n\n")
+            object_docs.append(classdoc)
+        elif callable(item):
+            funcdoc = function_str(name, item)
+            object_docs.append(f"{member_title_level} {qual_name}\n\n")
+            object_docs.append(funcdoc)
+        else:
+            item_doc = getattr(module, f"__doc__{name}", None)
+            if item_doc:
+                # variable documentation
+                object_docs.append(f"{member_title_level} {qual_name}\n\n")
+                object_docs.append(item_doc)
+            else:
+                warnings.warn(f"Not sure how to document: {name} ({item}")
+
+    if object_docs:
+        return "".join(header + object_docs)
+    return ""
+
+
+def object_is_private(name, obj):
+    docstring = inspect.getdoc(obj)
+    if docstring is None:
+        docstring = ""
+    module = getattr(obj, "__module__", None)  # obj is class
+    if not module:
+        cls = getattr(obj, "__class__", None)  # obj is instance
+        if cls:
+            module = getattr(cls, "__module__", None)
+    if module == "builtins":
+        return True
+
+    if docstring.lstrip().startswith("mdmd:hidden") or name.startswith("_"):
+        return True
+
+    return False
+
+
+def default_filter(module, item_name):
+    """Include non-private objects defined in the module itself"""
+    item = getattr(module, item_name)
+    if object_is_private(item_name, item) or inspect.ismodule(item):
+        return False
+    member_module = getattr(item, "__module__", type(item).__module__)
+    return member_module == module.__name__
+
+
+def package_filter(module_prefix: str):
+    """Include non-private objects defined in any module with the prefix `module_prefix`"""
+
+    def return_filter(module, item_name):
+        item = getattr(module, item_name)
+        if object_is_private(item_name, item) or inspect.ismodule(item):
+            return False
+        member_module = getattr(item, "__module__", type(item).__module__)
+        return member_module.startswith(module_prefix)
+
+    return return_filter
+
+
+def module_items(module, filter_items: Callable[[ModuleType, str], bool] = None):
+    """Returns filtered members of module"""
+    if filter_items is None:
+        # default filter is to only include classes and functions declared (or whose type is declared) in the file
+        filter_items = default_filter
+
+    for member_name, member in inspect.getmembers(module):
+        # only modal items
+        if not filter_items(module, member_name):
+            continue
+
+        qual_name = f"{module.__name__}.{member_name}"
+        yield qual_name, member_name, member
+
+
+class Category(Enum):
+    FUNCTION = "function"
+    CLASS = "class"
+    MODULE = "module"

modal-0.73.49/modal_docs/mdmd/signatures.py

@@ -0,0 +1,76 @@
+# Copyright Modal Labs 2023
+import ast
+import inspect
+import re
+import textwrap
+import warnings
+
+from synchronicity.synchronizer import FunctionWithAio
+
+
+def _signature_from_ast(func) -> tuple[str, str]:
+    """Get function signature, including decorators and comments, from source code
+
+    Traverses functools.wraps-wrappings to get source of underlying function.
+
+    Has the advantage over inspect.signature that it can get decorators, default arguments and comments verbatim
+    from the function definition.
+    """
+    src = inspect.getsource(func)
+    src = textwrap.dedent(src)
+
+    def get_source_segment(src, fromline, fromcol, toline, tocol) -> str:
+        lines = src.split("\n")
+        lines = lines[fromline - 1 : toline]
+        lines[-1] = lines[-1][:tocol]
+        lines[0] = lines[0][fromcol:]
+        return "\n".join(lines)
+
+    tree = ast.parse(src)
+    func_def = list(ast.iter_child_nodes(tree))[0]
+    assert isinstance(func_def, (ast.FunctionDef, ast.AsyncFunctionDef))
+    decorator_starts = [(item.lineno, item.col_offset - 1) for item in func_def.decorator_list]
+    declaration_start = min([(func_def.lineno, func_def.col_offset)] + decorator_starts)
+    body_start = min((item.lineno, item.col_offset) for item in func_def.body)
+
+    return (
+        func_def.name,
+        get_source_segment(src, declaration_start[0], declaration_start[1], body_start[0], body_start[1] - 1).strip(),
+    )
+
+
+def get_signature(name, callable) -> str:
+    """A problem with using *only* this method is that the wrapping method signature will not be respected.
+    TODO: use source parsing *only* to extract default arguments, comments (and possibly decorators) and "merge"
+          that definition with the outer-most definition."""
+
+    if not (inspect.isfunction(callable) or inspect.ismethod(callable) or isinstance(callable, FunctionWithAio)):
+        assert hasattr(callable, "__call__")
+        callable = callable.__call__
+
+    try:
+        original_name, definition_source = _signature_from_ast(callable)
+    except Exception:
+        warnings.warn(f"Could not get source signature for {name}. Using fallback.")
+        original_name = name
+        definition_source = f"def {name}{inspect.signature(callable)}"
+
+    if original_name != name:
+        # ugly name and definition replacement hack when needed
+        definition_source = definition_source.replace(f"def {original_name}", f"def {name}")
+
+    if (
+        "async def" in definition_source
+        and not inspect.iscoroutinefunction(callable)
+        and not inspect.isasyncgenfunction(callable)
+    ):
+        # hack to "reset" signature to a blocking one if the underlying source definition is async
+        # but the wrapper function isn't (like when synchronicity wraps an async function as a blocking one)
+        definition_source = definition_source.replace("async def", "def")
+        definition_source = definition_source.replace("asynccontextmanager", "contextmanager")
+        definition_source = definition_source.replace("AsyncIterator", "Iterator")
+
+    # remove any synchronicity-internal decorators
+    definition_source, _ = re.subn(r"^\s*@synchronizer\..*\n", "", definition_source)
+
+    return definition_source

{modal-0.73.47 → modal-0.73.49}/modal_proto/api.proto

@@ -1435,6 +1435,9 @@ message FunctionData {
   bool untrusted = 27; // If set, the function will be run in an untrusted environment.
   bool snapshot_debug = 28; // For internal debugging use only.
   bool runtime_perf_record = 29; // For internal debugging use only.
+
+  AutoscalerSettings autoscaler_settings = 31;  // Bundle of parameters related to autoscaling
+
 }
 
 message FunctionExtended {