modal 0.73.46__py3-none-any.whl → 0.73.48__py3-none-any.whl

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.46"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.48"
     ): ...
     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.46"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.48"
     ): ...
     def is_closed(self) -> bool: ...
     @property

{modal-0.73.46.dist-info → modal-0.73.48.dist-info}/METADATA

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

{modal-0.73.46.dist-info → modal-0.73.48.dist-info}/RECORD

@@ -22,7 +22,7 @@ modal/app.py,sha256=rCOPD51gVyow8muyaqMuV65qfTnAZKf_w1OCZdSF_6o,44636
 modal/app.pyi,sha256=0MMCgskIL4r3eq8oBcfm2lLyeao2gXjS3iXaIfmaJ-o,25959
 modal/call_graph.py,sha256=1g2DGcMIJvRy-xKicuf63IVE98gJSnQsr8R_NVMptNc,2581
 modal/client.py,sha256=8SQawr7P1PNUCq1UmJMUQXG2jIo4Nmdcs311XqrNLRE,15276
-modal/client.pyi,sha256=O1FkvafYE0HPYhNlOAfgFPBfi1-ZQ00hbjPGOtk2PAk,7593
+modal/client.pyi,sha256=MOaK9KIS8ydiafT9fHWFbO-13oomwgiUHqXQkfoat1U,7593
 modal/cloud_bucket_mount.py,sha256=YOe9nnvSr4ZbeCn587d7_VhE9IioZYRvF9VYQTQux08,5914
 modal/cloud_bucket_mount.pyi,sha256=30T3K1a89l6wzmEJ_J9iWv9SknoGqaZDx59Xs-ZQcmk,1607
 modal/cls.py,sha256=nJhJr-YuttOmdNWxtMHcBV-q6iQmY5qXkEy9yO43clY,31130
@@ -144,6 +144,12 @@ modal/requirements/2024.04.txt,sha256=6NnrbIE-mflwMyKyQ0tsWeY8XFE1kSW9oE8DVDoD8Q
 modal/requirements/2024.10.txt,sha256=qD-5cVIVM9wXesJ6JC89Ew-3m2KjEElUz3jaw_MddRo,296
 modal/requirements/README.md,sha256=9tK76KP0Uph7O0M5oUgsSwEZDj5y-dcUPsnpR0Sc-Ik,854
 modal/requirements/base-images.json,sha256=kLNo5Sqmnhp9H6Hr9IcaGJFrRaRg1yfuepUWkm-y8iQ,571
+modal_docs/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
+modal_docs/gen_cli_docs.py,sha256=c1yfBS_x--gL5bs0N4ihMwqwX8l3IBWSkBAKNNIi6bQ,3801
+modal_docs/gen_reference_docs.py,sha256=aDcUSSDtAAZ4eeFWyroeIg2TOzyRoYcic-d9Zh9TdLY,6656
+modal_docs/mdmd/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
+modal_docs/mdmd/mdmd.py,sha256=Irx49MCCTlBOP4FBdLR--JrpA3-WhsVeriq0LGgsRic,6232
+modal_docs/mdmd/signatures.py,sha256=XJaZrK7Mdepk5fdX51A8uENiLFNil85Ud0d4MH8H5f0,3218
 modal_proto/__init__.py,sha256=MIEP8jhXUeGq_eCjYFcqN5b1bxBM4fdk0VESpjWR0fc,28
 modal_proto/api.proto,sha256=hM-iLwpYycp-wGyvoAieAEM_km42yI0jZTigPQLGPC0,86712
 modal_proto/api_grpc.py,sha256=FYGqDegM_w_qxdtlxum8k31mDibKoMvmNxv_p9cKdKs,109056
@@ -162,10 +168,10 @@ modal_proto/options_pb2_grpc.pyi,sha256=CImmhxHsYnF09iENPoe8S4J-n93jtgUYD2JPAc0y
 modal_proto/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modal_version/__init__.py,sha256=wiJQ53c-OMs0Xf1UeXOxQ7FwlV1VzIjnX6o-pRYZ_Pk,470
 modal_version/__main__.py,sha256=2FO0yYQQwDTh6udt1h-cBnGd1c4ZyHnHSI4BksxzVac,105
-modal_version/_version_generated.py,sha256=8fsq1Mwk_oc-cRzDa1hVjelGQTPb2sWXcU1-oVbyluE,149
-modal-0.73.46.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-modal-0.73.46.dist-info/METADATA,sha256=cRFzas4CsmfLqOAtoQuAAfiB1dKGnRUifH9e0hUWVwg,2452
-modal-0.73.46.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-modal-0.73.46.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-0.73.46.dist-info/top_level.txt,sha256=UkI9BtusWSFRKv6hePUkcXTROTUz7xo7rKGg_IHjuBM,32
-modal-0.73.46.dist-info/RECORD,,
+modal_version/_version_generated.py,sha256=e28LshLG_gjVm75cDsOX8iy2TJ5X-jcZ9J-BhbHCKEM,149
+modal-0.73.48.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-0.73.48.dist-info/METADATA,sha256=Fiv2Ka8W-_sBsxtyoc9qE6BsDFmJkblF57Y37cchiNY,2452
+modal-0.73.48.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+modal-0.73.48.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-0.73.48.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
+modal-0.73.48.dist-info/RECORD,,

{modal-0.73.46.dist-info → modal-0.73.48.dist-info}/top_level.txt

@@ -1,3 +1,4 @@
 modal
+modal_docs
 modal_proto
 modal_version

modal_docs/__init__.py

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

modal_docs/gen_cli_docs.py

@@ -0,0 +1,117 @@
+# Copyright Modal Labs 2023
+import inspect
+import sys
+from pathlib import Path
+from typing import Optional, cast
+
+from click import Command, Context, Group
+
+from modal.cli.entry_point import entrypoint_cli
+
+
+# Adapted from typer_cli, since it's incompatible with the latest version of typer
+# (see https://github.com/tiangolo/typer-cli/issues/50)
+def get_docs_for_click(
+    obj: Command,
+    ctx: Context,
+    *,
+    indent: int = 0,
+    name: str = "",
+    call_prefix: str = "",
+) -> str:
+    docs = "#" * (1 + indent)
+    command_name = name or obj.name
+    if call_prefix:
+        command_name = f"{call_prefix} {command_name}"
+    title = f"`{command_name}`" if command_name else "CLI"
+    docs += f" {title}\n\n"
+    if obj.help:
+        docs += f"{inspect.cleandoc(obj.help)}\n\n"
+    usage_pieces = obj.collect_usage_pieces(ctx)
+    if usage_pieces:
+        docs += "**Usage**:\n\n"
+        docs += "```shell\n"
+        if command_name:
+            docs += f"{command_name} "
+        docs += f"{' '.join(usage_pieces)}\n"
+        docs += "```\n\n"
+    args = []
+    opts = []
+    for param in obj.get_params(ctx):
+        rv = param.get_help_record(ctx)
+        if rv is not None:
+            if getattr(param, "hidden", False):
+                continue
+            if param.param_type_name == "argument":
+                args.append(rv)
+            elif param.param_type_name == "option":
+                opts.append(rv)
+    if args:
+        docs += "**Arguments**:\n\n"
+        for arg_name, arg_help in args:
+            docs += f"* `{arg_name}`"
+            if arg_help:
+                docs += f": {arg_help}"
+            docs += "\n"
+        docs += "\n"
+    if opts:
+        docs += "**Options**:\n\n"
+        for opt_name, opt_help in opts:
+            docs += f"* `{opt_name}`"
+            if opt_help:
+                docs += f": {opt_help}"
+            docs += "\n"
+        docs += "\n"
+    if obj.epilog:
+        docs += f"{obj.epilog}\n\n"
+    if isinstance(obj, Group):
+        group: Group = cast(Group, obj)
+        commands = group.list_commands(ctx)
+        if commands:
+            docs += "**Commands**:\n\n"
+            for command in commands:
+                command_obj = group.get_command(ctx, command)
+                assert command_obj
+                if command_obj.hidden:
+                    continue
+                docs += f"* `{command_obj.name}`"
+                command_help = command_obj.get_short_help_str(limit=250)
+                if command_help:
+                    docs += f": {command_help}"
+                docs += "\n"
+            docs += "\n"
+        for command in commands:
+            command_obj = group.get_command(ctx, command)
+            if command_obj.hidden:
+                continue
+            assert command_obj
+            use_prefix = ""
+            if command_name:
+                use_prefix += f"{command_name}"
+            docs += get_docs_for_click(obj=command_obj, ctx=ctx, indent=indent + 1, call_prefix=use_prefix)
+    return docs
+
+
+def run(output_dirname: Optional[str]) -> None:
+    entrypoint: Group = cast(Group, entrypoint_cli)
+    ctx = Context(entrypoint)
+    commands = entrypoint.list_commands(ctx)
+
+    for command in commands:
+        command_obj = entrypoint.get_command(ctx, command)
+        if command_obj.hidden:
+            continue
+        docs = get_docs_for_click(obj=command_obj, ctx=ctx, call_prefix="modal")
+
+        if output_dirname:
+            output_dir = Path(output_dirname)
+            output_dir.mkdir(parents=True, exist_ok=True)
+            output_file = output_dir / f"{command}.md"
+            print("Writing to", output_file)
+            output_file.write_text(docs)
+        else:
+            print(docs)
+
+
+if __name__ == "__main__":
+    run(None if len(sys.argv) <= 1 else sys.argv[1])

modal_docs/gen_reference_docs.py

@@ -0,0 +1,193 @@
+# Copyright Modal Labs 2023
+import importlib
+import inspect
+import json
+import os
+import sys
+import warnings
+from typing import NamedTuple
+
+from synchronicity.synchronizer import FunctionWithAio
+
+from .mdmd.mdmd import (
+    Category,
+    class_str,
+    default_filter,
+    function_str,
+    module_items,
+    module_str,
+    object_is_private,
+    package_filter,
+)
+
+
+class DocItem(NamedTuple):
+    label: str
+    category: Category
+    document: str
+    in_sidebar: bool = True
+
+
+def validate_doc_item(docitem: DocItem) -> DocItem:
+    # Check that unwanted strings aren't leaking into our docs.
+    bad_strings = [
+        # Presence of a to-do inside a `DocItem` usually indicates it's been
+        # placed inside a function signature definition or right underneath it, before the body.
+        # Fix by moving the to-do into the body or above the signature.
+        "TODO:"
+    ]
+    for line in docitem.document.splitlines():
+        for bad_str in bad_strings:
+            if bad_str in line:
+                msg = f"Found unwanted string '{bad_str}' in content for item '{docitem.label}'. Problem line: {line}"
+                raise ValueError(msg)
+    return docitem
+
+
+def run(output_dir: str = None):
+    """Generate Modal docs."""
+    import modal
+
+    ordered_doc_items: list[DocItem] = []
+    documented_items = set()
+
+    def filter_non_aio(module, name):
+        return not name.lower().startswith("aio")
+
+    def filter_already_documented(module, name):
+        item = getattr(module, name)
+        try:
+            if item in documented_items:
+                return False
+        except TypeError:  # unhashable stuff
+            print(f"Warning: could not document item {name}: {item}:")
+            return False
+        documented_items.add(item)
+        return True
+
+    def modal_default_filter(module, name):
+        return default_filter(module, name) and filter_non_aio(module, name) and filter_already_documented(module, name)
+
+    def top_level_filter(module, name):
+        item = getattr(module, name)
+        if object_is_private(name, item) or inspect.ismodule(item):
+            return False
+        return package_filter("modal") and filter_already_documented(module, name) and filter_non_aio(module, name)
+
+    base_title_level = "#"
+    forced_module_docs = [
+        ("modal.Function", "modal.functions"),
+        ("modal.Secret", "modal.secret"),
+        ("modal.Dict", "modal.dict"),
+        ("modal.Queue", "modal.queue"),
+        ("modal.call_graph", "modal.call_graph"),
+        ("modal.gpu", "modal.gpu"),
+        ("modal.runner", "modal.runner"),
+        ("modal.Sandbox", "modal.sandbox"),
+        ("modal.ContainerProcess", "modal.container_process"),
+        ("modal.io_streams", "modal.io_streams"),
+        ("modal.FileIO", "modal.file_io"),
+    ]
+    # These aren't defined in `modal`, but should still be documented as top-level entries.
+    forced_members = {"web_endpoint", "asgi_app", "method", "wsgi_app", "forward"}
+    # These are excluded from the sidebar, typically to 'soft release' some documentation.
+    sidebar_excluded: set[str] = set()
+
+    for title, modulepath in forced_module_docs:
+        module = importlib.import_module(modulepath)
+        document = module_str(modulepath, module, title_level=base_title_level, filter_items=modal_default_filter)
+        if document:
+            ordered_doc_items.append(
+                validate_doc_item(
+                    DocItem(
+                        label=title,
+                        category=Category.MODULE,
+                        document=document,
+                        in_sidebar=title not in sidebar_excluded,
+                    )
+                )
+            )
+
+    def f(module, member_name):
+        return top_level_filter(module, member_name) or (member_name in forced_members)
+
+    # now add all remaining top level modal.X entries
+    for qual_name, item_name, item in module_items(modal, filter_items=f):
+        if object_is_private(item_name, item):
+            continue  # skip stuff that's part of explicit `handle_objects` above
+
+        title = f"modal.{item_name}"
+        if inspect.isclass(item):
+            content = f"{base_title_level} {qual_name}\n\n" + class_str(item_name, item, base_title_level)
+            category = Category.CLASS
+        elif inspect.isroutine(item) or isinstance(item, FunctionWithAio):
+            content = f"{base_title_level} {qual_name}\n\n" + function_str(item_name, item)
+            category = Category.FUNCTION
+        elif inspect.ismodule(item):
+            continue  # skipping imported modules
+        else:
+            warnings.warn(f"Not sure how to document: {item_name} ({item})")
+            continue
+        ordered_doc_items.append(
+            validate_doc_item(
+                DocItem(
+                    label=title,
+                    category=category,
+                    document=content,
+                    in_sidebar=title not in sidebar_excluded,
+                )
+            )
+        )
+    ordered_doc_items.sort()
+
+    for modulepath in ["modal.exception", "modal.config"]:
+        module = importlib.import_module(modulepath)
+        document = module_str(modulepath, module, title_level=base_title_level, filter_items=modal_default_filter)
+        ordered_doc_items.append(
+            DocItem(
+                label=modulepath,
+                category=Category.MODULE,
+                document=document,
+            )
+        )
+
+    # TODO: add some way of documenting our .aio sub-methods
+
+    make_markdown_docs(
+        ordered_doc_items,
+        output_dir,
+    )
+
+
+def make_markdown_docs(items: list[DocItem], output_dir: str = None):
+    def _write_file(rel_path: str, data: str):
+        if output_dir is None:
+            print(f"<<< {rel_path}")
+            print(data)
+            print(f">>> {rel_path}")
+            return
+
+        filename = os.path.join(output_dir, rel_path)
+        print("Writing to", filename)
+        os.makedirs(os.path.dirname(filename), exist_ok=True)
+        with open(filename, "w") as fp:
+            fp.write(data)
+
+    sidebar_items = []
+    for item in items:
+        if item.in_sidebar:
+            sidebar_items.append(
+                {
+                    "label": item.label,
+                    "category": item.category.value,
+                }
+            )
+        _write_file(f"{item.label}.md", item.document)
+
+    sidebar_data = {"items": sidebar_items}
+    _write_file("sidebar.json", json.dumps(sidebar_data))
+
+
+if __name__ == "__main__":
+    # running this module outputs docs to stdout for inspection, useful for debugging
+    run(None if len(sys.argv) <= 1 else sys.argv[1])

modal_docs/mdmd/__init__.py

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

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_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_version/_version_generated.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 
 # Note: Reset this value to -1 whenever you make a minor `0.X` release of the client.
-build_number = 46  # git: 8736584
+build_number = 48  # git: 39a82b7