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

test/function_utils_test.py

@@ -1,101 +0,0 @@
-# Copyright Modal Labs 2023
-import pytest
-from typing import List
-
-from modal import Queue
-from modal._utils.function_utils import FunctionInfo, get_referred_objects, method_has_params
-from modal.exception import InvalidError
-from modal.object import Object
-
-q1 = Queue.from_name("q1", create_if_missing=True)
-q2 = Queue.from_name("q2", create_if_missing=True)
-
-
-def f1():
-    q1.get()
-
-
-def f2():
-    f1()
-    q2.get()
-
-
-def test_referred_objects():
-    objs: List[Object] = get_referred_objects(f1)
-    assert objs == [q1]
-
-
-def test_referred_objects_recursive():
-    objs: List[Object] = get_referred_objects(f2)
-    assert set(objs) == set([q1, q2])
-
-
-def recursive():
-    recursive()
-
-
-def test_recursive():
-    get_referred_objects(recursive)
-
-
-l = [q1, q2]
-
-
-def refers_list():
-    return len(l)
-
-
-def test_refers_list():
-    objs: List[Object] = get_referred_objects(refers_list)
-    assert objs == []  # This may return [q1, q2] in the future
-
-
-def hasarg(a):
-    ...
-
-
-def noarg():
-    ...
-
-
-def defaultarg(a="hello"):
-    ...
-
-
-def wildcard_args(*wildcard_list, **wildcard_dict):
-    ...
-
-
-def test_is_nullary():
-    assert not FunctionInfo(hasarg).is_nullary()
-    assert FunctionInfo(noarg).is_nullary()
-    assert FunctionInfo(defaultarg).is_nullary()
-    assert FunctionInfo(wildcard_args).is_nullary()
-
-
-class Cls:
-    def foo(self):
-        pass
-
-    def bar(self, x):
-        pass
-
-    def buz(self, *args):
-        pass
-
-
-def test_method_has_params():
-    assert not method_has_params(Cls.foo)
-    assert not method_has_params(Cls().foo)
-    assert method_has_params(Cls.bar)
-    assert method_has_params(Cls().bar)
-    assert method_has_params(Cls.buz)
-    assert method_has_params(Cls().buz)
-
-
-def test_nonglobal_function():
-    def f():
-        ...
-
-    with pytest.raises(InvalidError, match=r"Cannot wrap `test_nonglobal_function.<locals>.f"):
-        FunctionInfo(f)

test/gpu_test.py

@@ -1,159 +0,0 @@
-# Copyright Modal Labs 2022
-import pytest
-
-from modal import Stub
-from modal.exception import DeprecationError, InvalidError
-from modal_proto import api_pb2
-
-
-def dummy():
-    pass  # not actually used in test (servicer returns sum of square of all args)
-
-
-def test_gpu_true_function(client, servicer):
-    stub = Stub()
-
-    with pytest.raises(DeprecationError):
-        stub.function(gpu=True)(dummy)
-
-
-def test_gpu_any_function(client, servicer):
-    stub = Stub()
-
-    stub.function(gpu="any")(dummy)
-    with stub.run(client=client):
-        pass
-
-    assert len(servicer.app_functions) == 1
-    func_def = next(iter(servicer.app_functions.values()))
-    assert func_def.resources.gpu_config.count == 1
-    assert func_def.resources.gpu_config.type == api_pb2.GPU_TYPE_ANY
-
-
-def test_gpu_string_config(client, servicer):
-    stub = Stub()
-
-    # Invalid enum value.
-    with pytest.raises(InvalidError):
-        stub.function(gpu="foo")(dummy)
-
-    stub.function(gpu="A100")(dummy)
-    with stub.run(client=client):
-        pass
-
-    assert len(servicer.app_functions) == 1
-    func_def = next(iter(servicer.app_functions.values()))
-    assert func_def.resources.gpu_config.count == 1
-    assert func_def.resources.gpu_config.type == api_pb2.GPU_TYPE_A100
-
-
-def test_gpu_string_count_config(client, servicer):
-    stub = Stub()
-
-    # Invalid count values.
-    with pytest.raises(InvalidError):
-        stub.function(gpu="A10G:hello")(dummy)
-    with pytest.raises(InvalidError):
-        stub.function(gpu="Nonexistent:2")(dummy)
-
-    stub.function(gpu="A10G:4")(dummy)
-    with stub.run(client=client):
-        pass
-
-    assert len(servicer.app_functions) == 1
-    func_def = next(iter(servicer.app_functions.values()))
-    assert func_def.resources.gpu_config.count == 4
-    assert func_def.resources.gpu_config.type == api_pb2.GPU_TYPE_A10G
-
-
-def test_gpu_config_function(client, servicer):
-    import modal
-
-    stub = Stub()
-
-    stub.function(gpu=modal.gpu.A100())(dummy)
-    with stub.run(client=client):
-        pass
-
-    assert len(servicer.app_functions) == 1
-    func_def = next(iter(servicer.app_functions.values()))
-    assert func_def.resources.gpu_config.count == 1
-    assert func_def.resources.gpu_config.type == api_pb2.GPU_TYPE_A100
-
-
-def test_cloud_provider_selection(client, servicer):
-    import modal
-
-    stub = Stub()
-
-    stub.function(gpu=modal.gpu.A100(), cloud="gcp")(dummy)
-    with stub.run(client=client):
-        pass
-
-    assert len(servicer.app_functions) == 1
-    func_def = next(iter(servicer.app_functions.values()))
-    assert func_def.cloud_provider == api_pb2.CLOUD_PROVIDER_GCP
-
-    assert func_def.resources.gpu_config.count == 1
-    assert func_def.resources.gpu_config.type == api_pb2.GPU_TYPE_A100
-
-    # Invalid enum value.
-    with pytest.raises(InvalidError):
-        stub.function(cloud="foo")(dummy)
-
-
-@pytest.mark.parametrize(
-    "memory_arg,gpu_type,memory_gb",
-    [
-        (0, api_pb2.GPU_TYPE_A100, 40),
-        (40, api_pb2.GPU_TYPE_A100, 40),
-        (80, api_pb2.GPU_TYPE_A100_80GB, 80),
-        ("40GB", api_pb2.GPU_TYPE_A100, 40),
-        ("80GB", api_pb2.GPU_TYPE_A100_80GB, 80),
-    ],
-)
-def test_memory_selection_gpu_variant(client, servicer, memory_arg, gpu_type, memory_gb):
-    import modal
-
-    stub = Stub()
-    if isinstance(memory_arg, int):
-        stub.function(gpu=modal.gpu.A100(memory=memory_arg))(dummy)
-    elif isinstance(memory_arg, str):
-        stub.function(gpu=modal.gpu.A100(size=memory_arg))(dummy)
-    else:
-        raise RuntimeError(f"Unexpected test parameterization arg type {type(memory_arg)}")
-
-    with stub.run(client=client):
-        pass
-
-    func_def = next(iter(servicer.app_functions.values()))
-
-    assert func_def.resources.gpu_config.count == 1
-    assert func_def.resources.gpu_config.type == gpu_type
-    assert func_def.resources.gpu_config.memory == memory_gb
-
-
-def test_a100_20gb_gpu_unsupported():
-    import modal
-
-    stub = Stub()
-
-    with pytest.raises(ValueError, match="A100 20GB is unsupported, consider"):
-        stub.function(gpu=modal.gpu.A100(memory=20))(dummy)
-
-
-@pytest.mark.parametrize("count", [1, 2, 3, 4])
-def test_gpu_type_selection_from_count(client, servicer, count):
-    import modal
-
-    stub = Stub()
-
-    # Task type does not change when user asks more than 1 GPU on an A100.
-    stub.function(gpu=modal.gpu.A100(count=count))(dummy)
-    with stub.run(client=client):
-        pass
-
-    func_def = next(iter(servicer.app_functions.values()))
-
-    assert func_def.resources.gpu_config.count == count
-    assert func_def.resources.gpu_config.type == api_pb2.GPU_TYPE_A100

test/grpc_utils_test.py

@@ -1,141 +0,0 @@
-# Copyright Modal Labs 2022
-import asyncio
-import math
-import pytest
-import time
-
-from grpclib import GRPCError, Status
-
-from modal._utils.grpc_utils import ChannelPool, create_channel, retry_transient_errors
-from modal_proto import api_grpc, api_pb2
-
-from .supports.skip import skip_windows_unix_socket
-
-
-@pytest.mark.asyncio
-async def test_http_channel(servicer):
-    assert servicer.remote_addr.startswith("http://")
-    channel = create_channel(servicer.remote_addr, use_pool=False)
-    client_stub = api_grpc.ModalClientStub(channel)
-
-    req = api_pb2.BlobCreateRequest()
-    resp = await client_stub.BlobCreate(req)
-    assert resp.blob_id
-
-    channel.close()
-
-
-@skip_windows_unix_socket
-@pytest.mark.asyncio
-async def test_unix_channel(unix_servicer):
-    assert unix_servicer.remote_addr.startswith("unix://")
-    channel = create_channel(unix_servicer.remote_addr, use_pool=False)
-    client_stub = api_grpc.ModalClientStub(channel)
-
-    req = api_pb2.BlobCreateRequest()
-    resp = await client_stub.BlobCreate(req)
-    assert resp.blob_id
-
-    channel.close()
-
-
-@pytest.mark.asyncio
-async def test_channel_pool(servicer, n=1000):
-    channel_pool = create_channel(servicer.remote_addr, use_pool=True)
-    assert isinstance(channel_pool, ChannelPool)
-    client_stub = api_grpc.ModalClientStub(channel_pool)
-
-    # Trigger a lot of requests
-    for i in range(n):
-        req = api_pb2.BlobCreateRequest()
-        resp = await client_stub.BlobCreate(req)
-        assert resp.blob_id
-
-    # Make sure we created the right number of subchannels
-    assert len(channel_pool._subchannels) == math.ceil(n / channel_pool._max_requests)
-
-    channel_pool.close()
-
-
-@pytest.mark.asyncio
-async def test_channel_pool_closed_transport(servicer):
-    channel_pool = create_channel(servicer.remote_addr, use_pool=True)
-    assert isinstance(channel_pool, ChannelPool)
-
-    connection = await channel_pool.__connect__()
-    connection.connection_lost(None)  # simulates a h2 connection being closed
-
-    client_stub = api_grpc.ModalClientStub(channel_pool)
-    req = api_pb2.BlobCreateRequest()
-    resp = await client_stub.BlobCreate(req)  # this should close the terminated connection and start a new one
-    assert resp.blob_id
-    channel_pool.close()
-
-
-@pytest.mark.asyncio
-async def test_channel_pool_max_active(servicer):
-    channel_pool = create_channel(servicer.remote_addr, use_pool=True)
-    assert isinstance(channel_pool, ChannelPool)
-    channel_pool._max_active = 1.0
-    client_stub = api_grpc.ModalClientStub(channel_pool)
-
-    # Do a few requests and assert there's just one subchannel
-    for i in range(3):
-        req = api_pb2.BlobCreateRequest()
-        resp = await client_stub.BlobCreate(req)
-        assert resp.blob_id
-    assert len(channel_pool._subchannels) == 1
-
-    # Sleep a couple of seconds and do a new request: it should create a new subchannel
-    await asyncio.sleep(2.0)
-    req = api_pb2.BlobCreateRequest()
-    resp = await client_stub.BlobCreate(req)
-    assert resp.blob_id
-    assert len(channel_pool._subchannels) == 2
-
-    channel_pool.close()
-
-
-@pytest.mark.asyncio
-async def test_retry_transient_errors(servicer):
-    channel = create_channel(servicer.remote_addr)
-    client_stub = api_grpc.ModalClientStub(channel)
-
-    # Use the BlobCreate request for retries
-    req = api_pb2.BlobCreateRequest()
-
-    # Fail 3 times -> should still succeed
-    servicer.fail_blob_create = [Status.UNAVAILABLE] * 3
-    assert await retry_transient_errors(client_stub.BlobCreate, req)
-    assert servicer.blob_create_metadata.get("x-idempotency-key")
-    assert servicer.blob_create_metadata.get("x-retry-attempt") == "3"
-
-    # Fail 4 times -> should fail
-    servicer.fail_blob_create = [Status.UNAVAILABLE] * 4
-    with pytest.raises(GRPCError):
-        await retry_transient_errors(client_stub.BlobCreate, req)
-    assert servicer.blob_create_metadata.get("x-idempotency-key")
-    assert servicer.blob_create_metadata.get("x-retry-attempt") == "3"
-
-    # Fail 5 times, but set max_retries to infinity
-    servicer.fail_blob_create = [Status.UNAVAILABLE] * 5
-    assert await retry_transient_errors(client_stub.BlobCreate, req, max_retries=None, base_delay=0)
-    assert servicer.blob_create_metadata.get("x-idempotency-key")
-    assert servicer.blob_create_metadata.get("x-retry-attempt") == "5"
-
-    # Not a transient error.
-    servicer.fail_blob_create = [Status.PERMISSION_DENIED]
-    with pytest.raises(GRPCError):
-        assert await retry_transient_errors(client_stub.BlobCreate, req, max_retries=None, base_delay=0)
-    assert servicer.blob_create_metadata.get("x-idempotency-key")
-    assert servicer.blob_create_metadata.get("x-retry-attempt") == "0"
-
-    # Make sure to respect total_timeout
-    t0 = time.time()
-    servicer.fail_blob_create = [Status.UNAVAILABLE] * 99
-    with pytest.raises(GRPCError):
-        assert await retry_transient_errors(client_stub.BlobCreate, req, max_retries=None, total_timeout=3)
-    total_time = time.time() - t0
-    assert total_time <= 3.1
-
-    channel.close()

test/helpers.py

@@ -1,42 +0,0 @@
-# Copyright Modal Labs 2023
-import os
-import pathlib
-import subprocess
-import sys
-from typing import Optional
-
-
-def deploy_stub_externally(
-    servicer,
-    file_or_module: str,
-    stub_variable: Optional[str] = None,
-    deployment_name="Deployment",
-    cwd=None,
-    env={},
-    capture_output=True,
-) -> Optional[str]:
-    # deploys a stub from another interpreter to prevent leaking state from client into a container process (apart from what goes through the servicer)
-    # also has the advantage that no modules imported by the test files themselves will be added to sys.modules and included in mounts etc.
-    windows_support: dict[str, str] = {}
-
-    if sys.platform == "win32":
-        windows_support = {
-            **os.environ.copy(),
-            **{"PYTHONUTF8": "1"},
-        }  # windows apparently needs a bunch of env vars to start python...
-
-    env = {**windows_support, "MODAL_SERVER_URL": servicer.remote_addr, **env}
-    if cwd is None:
-        cwd = pathlib.Path(__file__).parent.parent
-
-    stub_ref = file_or_module if stub_variable is None else f"{file_or_module}::{stub_variable}"
-
-    p = subprocess.Popen(
-        [sys.executable, "-m", "modal.cli.entry_point", "deploy", stub_ref, "--name", deployment_name],
-        cwd=cwd,
-        env=env,
-        stderr=subprocess.STDOUT,
-        stdout=subprocess.PIPE if capture_output else None,
-    )
-    stdout, _ = p.communicate()
-    return stdout.decode("utf8")