modal 0.62.16__py3-none-any.whl → 0.72.11__py3-none-any.whl

test/async_utils_test.py

@@ -1,262 +0,0 @@
-# Copyright Modal Labs 2022
-import asyncio
-import logging
-import os
-import platform
-import pytest
-
-from synchronicity import Synchronizer
-
-from modal._utils import async_utils
-from modal._utils.async_utils import (
-    ConcurrencyPool,
-    TaskContext,
-    queue_batch_iterator,
-    retry,
-    warn_if_generator_is_not_consumed,
-)
-
-skip_github_non_linux = pytest.mark.skipif(
-    (os.environ.get("GITHUB_ACTIONS") == "true" and platform.system() != "Linux"),
-    reason="sleep is inaccurate on GitHub Actions runners.",
-)
-
-
-class SampleException(Exception):
-    pass
-
-
-class FailNTimes:
-    def __init__(self, n_failures, exc=SampleException("Something bad happened")):
-        self.n_failures = n_failures
-        self.n_calls = 0
-        self.exc = exc
-
-    async def __call__(self, x):
-        self.n_calls += 1
-        if self.n_calls <= self.n_failures:
-            raise self.exc
-        else:
-            return x + 1
-
-
-@pytest.mark.asyncio
-async def test_retry():
-    f_retry = retry(FailNTimes(2))
-    assert await f_retry(42) == 43
-
-    with pytest.raises(SampleException):
-        f_retry = retry(FailNTimes(3))
-        assert await f_retry(42) == 43
-
-    f_retry = retry(n_attempts=5)(FailNTimes(4))
-    assert await f_retry(42) == 43
-
-    with pytest.raises(SampleException):
-        f_retry = retry(n_attempts=5)(FailNTimes(5))
-        assert await f_retry(42) == 43
-
-
-@pytest.mark.asyncio
-async def test_task_context():
-    async with TaskContext() as task_context:
-        t = task_context.create_task(asyncio.sleep(0.1))
-        assert not t.done()
-        # await asyncio.sleep(0.0)
-    await asyncio.sleep(0.0)  # just waste a loop step for the cancellation to go through
-    assert t.cancelled()
-
-
-@pytest.mark.asyncio
-async def test_task_context_grace():
-    async with TaskContext(grace=0.2) as task_context:
-        u = task_context.create_task(asyncio.sleep(0.1))
-        v = task_context.create_task(asyncio.sleep(0.3))
-        assert not u.done()
-        assert not v.done()
-    await asyncio.sleep(0.0)
-    assert u.done()
-    assert v.cancelled()
-
-
-async def raise_exception():
-    raise SampleException("foo")
-
-
-@skip_github_non_linux
-@pytest.mark.asyncio
-async def test_task_context_wait():
-    async with TaskContext(grace=0.1) as task_context:
-        u = task_context.create_task(asyncio.sleep(1.1))
-        v = task_context.create_task(asyncio.sleep(1.3))
-        await task_context.wait(u)
-
-    assert u.done()
-    assert v.cancelled()
-
-    with pytest.raises(SampleException):
-        async with TaskContext(grace=0.2) as task_context:
-            u = task_context.create_task(asyncio.sleep(1.1))
-            v = task_context.create_task(raise_exception())
-            await task_context.wait(u)
-
-    assert u.cancelled()
-    assert v.done()
-
-
-@skip_github_non_linux
-@pytest.mark.asyncio
-async def test_task_context_infinite_loop():
-    async with TaskContext(grace=0.01) as task_context:
-        counter = 0
-
-        async def f():
-            nonlocal counter
-            counter += 1
-
-        t = task_context.infinite_loop(f, sleep=0.1)
-        assert not t.done()
-        await asyncio.sleep(0.35)
-        assert counter == 4  # at 0.00, 0.10, 0.20, 0.30
-    await asyncio.sleep(0.0)  # just waste a loop step for the cancellation to go through
-    assert not t.cancelled()
-    assert t.done()
-    assert counter == 4  # should be exited immediately
-
-
-DEBOUNCE_TIME = 0.1
-
-
-@pytest.mark.asyncio
-async def test_queue_batch_iterator():
-    queue: asyncio.Queue = asyncio.Queue()
-    await queue.put(1)
-    drained_items = []
-
-    async def drain_queue(logs_queue):
-        async for batch in queue_batch_iterator(logs_queue, debounce_time=DEBOUNCE_TIME):
-            drained_items.extend(batch)
-
-    async with TaskContext(grace=0.0) as tc:
-        tc.create_task(drain_queue(queue))
-
-        # Make sure the queue gets drained.
-        await asyncio.sleep(0.001)
-
-        assert len(drained_items) == 1
-
-        # Add items to the queue and a sentinel while it's still waiting for DEBOUNCE_TIME.
-        await queue.put(2)
-        await queue.put(3)
-        await queue.put(None)
-
-        await asyncio.sleep(DEBOUNCE_TIME + 0.001)
-
-        assert len(drained_items) == 3
-
-
-@pytest.mark.asyncio
-async def test_warn_if_generator_is_not_consumed(caplog):
-    @warn_if_generator_is_not_consumed
-    async def my_generator():
-        yield 42
-
-    with caplog.at_level(logging.WARNING):
-        g = my_generator()
-        assert "my_generator" in repr(g)
-        del g  # Force destructor
-
-    assert len(caplog.records) == 1
-    assert "my_generator" in caplog.text
-    assert "for" in caplog.text
-    assert "list" in caplog.text
-
-
-@pytest.mark.asyncio
-async def test_no_warn_if_generator_is_consumed(caplog):
-    @warn_if_generator_is_not_consumed
-    async def my_generator():
-        yield 42
-
-    with caplog.at_level(logging.WARNING):
-        g = my_generator()
-        async for _ in g:
-            pass
-        del g  # Force destructor
-
-    assert len(caplog.records) == 0
-
-
-def test_exit_handler():
-    result = None
-    sync = Synchronizer()
-
-    async def cleanup():
-        nonlocal result
-        result = "bye"
-
-    async def _setup_code():
-        async_utils.on_shutdown(cleanup())
-
-    setup_code = sync.create_blocking(_setup_code)
-    setup_code()
-
-    sync._close_loop()  # this is called on exit by synchronicity, which shuts down the event loop
-    assert result == "bye"
-
-
-@pytest.mark.asyncio
-async def test_concurrency_pool():
-    max_running = 0
-    running = 0
-
-    async def f():
-        nonlocal running, max_running
-        running += 1
-        max_running = max(max_running, running)
-        await asyncio.sleep(0.1)
-        running -= 1
-
-    def gen():
-        for i in range(100):
-            yield f()
-
-    await asyncio.wait_for(ConcurrencyPool(50).run_coros(gen()), 0.3)
-    assert max_running == 50
-
-
-@pytest.mark.asyncio
-async def test_concurrency_pool_cancels_non_started():
-    counter = 0
-
-    async def f():
-        nonlocal counter
-        counter += 1
-        raise RuntimeError("some error")
-
-    def gen():
-        for i in range(100):
-            yield f()
-
-    with pytest.raises(RuntimeError):
-        await ConcurrencyPool(2).run_coros(gen(), return_exceptions=False)
-    await asyncio.sleep(0.1)
-    assert counter == 2
-
-
-@pytest.mark.asyncio
-async def test_concurrency_pool_return_exceptions():
-    async def f(x):
-        if x % 2:
-            raise RuntimeError("some error")
-        else:
-            return 42
-
-    def gen():
-        for x in range(4):
-            yield f(x)
-
-    res = await asyncio.wait_for(ConcurrencyPool(2).run_coros(gen(), return_exceptions=True), 0.1)
-    assert res[0] == res[2] == 42
-    assert isinstance(res[1], RuntimeError)
-    assert isinstance(res[3], RuntimeError)

test/blob_test.py

@@ -1,67 +0,0 @@
-# Copyright Modal Labs 2022
-import pytest
-import random
-
-from modal._utils.async_utils import synchronize_api
-from modal._utils.blob_utils import (
-    blob_download as _blob_download,
-    blob_upload as _blob_upload,
-    blob_upload_file as _blob_upload_file,
-)
-from modal.exception import ExecutionError
-
-from .supports.skip import skip_old_py
-
-blob_upload = synchronize_api(_blob_upload)
-blob_download = synchronize_api(_blob_download)
-blob_upload_file = synchronize_api(_blob_upload_file)
-
-
-@pytest.mark.asyncio
-async def test_blob_put_get(servicer, blob_server, client):
-    # Upload
-    blob_id = await blob_upload.aio(b"Hello, world", client.stub)
-
-    # Download
-    data = await blob_download.aio(blob_id, client.stub)
-    assert data == b"Hello, world"
-
-
-@pytest.mark.asyncio
-async def test_blob_put_failure(servicer, blob_server, client):
-    with pytest.raises(ExecutionError):
-        await blob_upload.aio(b"FAILURE", client.stub)
-
-
-@pytest.mark.asyncio
-async def test_blob_get_failure(servicer, blob_server, client):
-    with pytest.raises(ExecutionError):
-        await blob_download.aio("bl-failure", client.stub)
-
-
-@pytest.mark.asyncio
-async def test_blob_large(servicer, blob_server, client):
-    data = b"*" * 10_000_000
-    blob_id = await blob_upload.aio(data, client.stub)
-    assert await blob_download.aio(blob_id, client.stub) == data
-
-
-@skip_old_py("random.randbytes() was introduced in python 3.9", (3, 9))
-@pytest.mark.asyncio
-async def test_blob_multipart(servicer, blob_server, client, monkeypatch, tmp_path):
-    monkeypatch.setattr("modal._utils.blob_utils.DEFAULT_SEGMENT_CHUNK_SIZE", 128)
-    multipart_threshold = 1024
-    servicer.blob_multipart_threshold = multipart_threshold
-    # - set high # of parts, to test concurrency correctness
-    # - make last part significantly shorter than rest, creating uneven upload time.
-    data_len = (256 * multipart_threshold) + (multipart_threshold // 2)
-    data = random.randbytes(data_len)  # random data will not hide byte re-ordering corruption
-    blob_id = await blob_upload.aio(data, client.stub)
-    assert await blob_download.aio(blob_id, client.stub) == data
-
-    data_len = (256 * multipart_threshold) + (multipart_threshold // 2)
-    data = random.randbytes(data_len)  # random data will not hide byte re-ordering corruption
-    data_filepath = tmp_path / "temp.bin"
-    data_filepath.write_bytes(data)
-    blob_id = await blob_upload_file.aio(data_filepath.open("rb"), client.stub)
-    assert await blob_download.aio(blob_id, client.stub) == data

test/cli_imports_test.py

@@ -1,149 +0,0 @@
-# Copyright Modal Labs 2023
-import pytest
-
-from modal._utils.async_utils import synchronizer
-from modal.cli.import_refs import (
-    DEFAULT_STUB_NAME,
-    get_by_object_path,
-    import_file_or_module,
-    parse_import_ref,
-)
-from modal.stub import _LocalEntrypoint, _Stub
-
-# Some helper vars for import_stub tests:
-local_entrypoint_src = """
-import modal
-
-stub = modal.Stub()
-@stub.local_entrypoint()
-def main():
-    pass
-"""
-python_module_src = """
-import modal
-stub = modal.Stub("FOO")
-other_stub = modal.Stub("BAR")
-@other_stub.function()
-def func():
-    pass
-@stub.cls()
-class Parent:
-    @modal.method()
-    def meth(self):
-        pass
-
-assert not __package__
-"""
-
-python_package_src = """
-import modal
-stub = modal.Stub("FOO")
-other_stub = modal.Stub("BAR")
-@other_stub.function()
-def func():
-    pass
-assert __package__ == "pack"
-"""
-
-python_subpackage_src = """
-import modal
-stub = modal.Stub("FOO")
-other_stub = modal.Stub("BAR")
-@other_stub.function()
-def func():
-    pass
-assert __package__ == "pack.sub"
-"""
-
-python_file_src = """
-import modal
-stub = modal.Stub("FOO")
-other_stub = modal.Stub("BAR")
-@other_stub.function()
-def func():
-    pass
-
-assert __package__ == ""
-"""
-
-empty_dir_with_python_file = {"mod.py": python_module_src}
-
-
-dir_containing_python_package = {
-    "dir": {"sub": {"mod.py": python_module_src, "subfile.py": python_file_src}},
-    "pack": {
-        "file.py": python_file_src,
-        "mod.py": python_package_src,
-        "local.py": local_entrypoint_src,
-        "__init__.py": "",
-        "sub": {"mod.py": python_subpackage_src, "__init__.py": "", "subfile.py": python_file_src},
-    },
-}
-
-
-@pytest.mark.parametrize(
-    ["dir_structure", "ref", "expected_object_type"],
-    [
-        # # file syntax
-        (empty_dir_with_python_file, "mod.py", _Stub),
-        (empty_dir_with_python_file, "mod.py::stub", _Stub),
-        (empty_dir_with_python_file, "mod.py::other_stub", _Stub),
-        (dir_containing_python_package, "pack/file.py", _Stub),
-        (dir_containing_python_package, "pack/sub/subfile.py", _Stub),
-        (dir_containing_python_package, "dir/sub/subfile.py", _Stub),
-        # # python module syntax
-        (empty_dir_with_python_file, "mod", _Stub),
-        (empty_dir_with_python_file, "mod::stub", _Stub),
-        (empty_dir_with_python_file, "mod::other_stub", _Stub),
-        (dir_containing_python_package, "pack.mod", _Stub),
-        (dir_containing_python_package, "pack.mod::other_stub", _Stub),
-        (dir_containing_python_package, "pack/local.py::stub.main", _LocalEntrypoint),
-    ],
-)
-def test_import_object(dir_structure, ref, expected_object_type, mock_dir):
-    with mock_dir(dir_structure):
-        import_ref = parse_import_ref(ref)
-        module = import_file_or_module(import_ref.file_or_module)
-        imported_object = get_by_object_path(module, import_ref.object_path or DEFAULT_STUB_NAME)
-        _translated_obj = synchronizer._translate_in(imported_object)
-        assert isinstance(_translated_obj, expected_object_type)
-
-
-def test_import_package_and_module_names(monkeypatch, supports_dir):
-    # We try to reproduce the package/module naming standard that the `python` command line tool uses,
-    # i.e. when loading using a module path (-m flag w/ python) you get a fully qualified package/module name
-    # but when loading using a filename, some/mod.py it will not have a __package__
-
-    # The biggest difference is that __name__ of the imported "entrypoint" script
-    # is __main__ when using `python` but in the Modal runtime it's the name of the
-    # file minus the ".py", since Modal has its own __main__
-    monkeypatch.chdir(supports_dir)
-    mod1 = import_file_or_module("assert_package")
-    assert mod1.__package__ == ""
-    assert mod1.__name__ == "assert_package"
-
-    monkeypatch.chdir(supports_dir.parent)
-    mod2 = import_file_or_module("test.supports.assert_package")
-    assert mod2.__package__ == "test.supports"
-    assert mod2.__name__ == "test.supports.assert_package"
-
-    mod3 = import_file_or_module("supports/assert_package.py")
-    assert mod3.__package__ == ""
-    assert mod3.__name__ == "assert_package"
-
-
-def test_get_by_object_path():
-    class NS(dict):
-        def __getattr__(self, n):
-            return dict.__getitem__(self, n)
-
-    # simple
-    assert get_by_object_path(NS(foo="bar"), "foo") == "bar"
-    assert get_by_object_path(NS(foo="bar"), "bar") is None
-
-    # nested simple
-    assert get_by_object_path(NS(foo=NS(bar="baz")), "foo.bar") == "baz"
-
-    # try to find item keys with periods in them (ugh).
-    # this helps resolving lifecycled functions
-    assert get_by_object_path(NS({"foo.bar": "baz"}), "foo.bar") == "baz"