UncountablePythonSDK 0.0.68__py3-none-any.whl → 0.0.70__py3-none-any.whl

uncountable/integration/queue_runner/datastore/interface.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+
+from uncountable.types import queued_job_t
+
+
+class Datastore(ABC):
+    @abstractmethod
+    def add_job_to_queue(
+        self, job_payload: queued_job_t.QueuedJobPayload, job_ref_name: str
+    ) -> queued_job_t.QueuedJob: ...
+
+    @abstractmethod
+    def remove_job_from_queue(self, queued_job_uuid: str) -> None: ...
+
+    @abstractmethod
+    def increment_num_attempts(self, queued_job_uuid: str) -> int: ...
+
+    @abstractmethod
+    def load_job_queue(self) -> list[queued_job_t.QueuedJob]: ...

uncountable/integration/queue_runner/datastore/model.py

@@ -0,0 +1,17 @@
+from sqlalchemy import JSON, BigInteger, Column, DateTime, Text
+from sqlalchemy.orm import declarative_base
+from sqlalchemy.sql import func
+
+Base = declarative_base()
+
+
+class QueuedJob(Base):
+    __tablename__ = "queued_jobs"
+
+    id = Column(Text, primary_key=True)
+    job_ref_name = Column(Text, nullable=False, index=True)
+    submitted_at = Column(
+        DateTime(timezone=True), server_default=func.current_timestamp(), nullable=False
+    )
+    payload = Column(JSON, nullable=False)
+    num_attempts = Column(BigInteger, nullable=False, default=0, server_default="0")

uncountable/integration/queue_runner/job_scheduler.py

@@ -0,0 +1,119 @@
+import asyncio
+import typing
+from concurrent.futures import ProcessPoolExecutor
+from dataclasses import dataclass
+
+from uncountable.integration.db.connect import IntegrationDBService, create_db_engine
+from uncountable.integration.db.session import get_session_maker
+from uncountable.integration.queue_runner.command_server import (
+    CommandEnqueueJobResponse,
+    CommandQueue,
+    CommandTask,
+)
+from uncountable.integration.queue_runner.datastore import DatastoreSqlite
+from uncountable.integration.queue_runner.datastore.interface import Datastore
+from uncountable.integration.queue_runner.worker import Worker
+from uncountable.integration.scan_profiles import load_profiles
+from uncountable.types import job_definition_t, queued_job_t
+
+from .types import ResultQueue, ResultTask
+
+_MAX_JOB_WORKERS = 5
+
+
+@dataclass(kw_only=True, frozen=True)
+class JobListenerKey:
+    profile_name: str
+    subqueue_name: str = "default"
+
+
+def _get_job_worker_key(
+    job_definition: job_definition_t.JobDefinition, profile_name: str
+) -> JobListenerKey:
+    return JobListenerKey(profile_name=profile_name)
+
+
+def on_worker_crash(
+    worker_key: JobListenerKey,
+) -> typing.Callable[[asyncio.Task], None]:
+    def hook(task: asyncio.Task) -> None:
+        raise Exception(
+            f"worker {worker_key.profile_name}_{worker_key.subqueue_name} crashed unexpectedly"
+        )
+
+    return hook
+
+
+def _start_workers(
+    process_pool: ProcessPoolExecutor, result_queue: ResultQueue, datastore: Datastore
+) -> dict[str, Worker]:
+    profiles = load_profiles()
+    job_queue_worker_lookup: dict[JobListenerKey, Worker] = {}
+    job_worker_lookup: dict[str, Worker] = {}
+    job_definition_lookup: dict[str, job_definition_t.JobDefinition] = {}
+    for profile in profiles:
+        for job_definition in profile.definition.jobs:
+            job_definition_lookup[job_definition.id] = job_definition
+            job_worker_key = _get_job_worker_key(job_definition, profile.name)
+            if job_worker_key not in job_queue_worker_lookup:
+                worker = Worker(
+                    process_pool=process_pool,
+                    listen_queue=asyncio.Queue(),
+                    result_queue=result_queue,
+                    datastore=datastore,
+                )
+                task = asyncio.create_task(worker.run_worker_loop())
+                task.add_done_callback(on_worker_crash(job_worker_key))
+                job_queue_worker_lookup[job_worker_key] = worker
+            job_worker_lookup[job_definition.id] = job_queue_worker_lookup[
+                job_worker_key
+            ]
+    return job_worker_lookup
+
+
+async def start_scheduler(command_queue: CommandQueue) -> None:
+    result_queue: ResultQueue = asyncio.Queue()
+    engine = create_db_engine(IntegrationDBService.RUNNER)
+    session_maker = get_session_maker(engine)
+
+    datastore = DatastoreSqlite(session_maker)
+    datastore.setup(engine)
+
+    with ProcessPoolExecutor(max_workers=_MAX_JOB_WORKERS) as process_pool:
+        job_worker_lookup = _start_workers(
+            process_pool, result_queue, datastore=datastore
+        )
+
+        queued_jobs = datastore.load_job_queue()
+
+        async def enqueue_queued_job(queued_job: queued_job_t.QueuedJob) -> None:
+            worker = job_worker_lookup[queued_job.job_ref_name]
+            await worker.listen_queue.put(queued_job)
+
+        for queued_job in queued_jobs:
+            await enqueue_queued_job(queued_job)
+
+        result_task: ResultTask = asyncio.create_task(result_queue.get())
+        command_task: CommandTask = asyncio.create_task(command_queue.get())
+        while True:
+            finished, _ = await asyncio.wait(
+                [result_task, command_task], return_when=asyncio.FIRST_COMPLETED
+            )
+
+            for task in finished:
+                if task == command_task:
+                    command = command_task.result()
+                    queued_job = datastore.add_job_to_queue(
+                        job_payload=command.payload, job_ref_name=command.job_ref_name
+                    )
+                    await command.response_queue.put(
+                        CommandEnqueueJobResponse(
+                            queued_job_uuid=queued_job.queued_job_uuid
+                        )
+                    )
+                    await enqueue_queued_job(queued_job)
+                    command_task = asyncio.create_task(command_queue.get())
+                elif task == result_task:
+                    queued_job_result = result_task.result()
+                    datastore.remove_job_from_queue(queued_job_result.queued_job_uuid)
+                    result_task = asyncio.create_task(result_queue.get())

uncountable/integration/queue_runner/queue_runner.py

@@ -0,0 +1,26 @@
+import asyncio
+
+from uncountable.integration.queue_runner.command_server import serve
+from uncountable.integration.queue_runner.command_server.types import CommandQueue
+from uncountable.integration.queue_runner.job_scheduler import start_scheduler
+
+
+async def queue_runner_loop() -> None:
+    command_queue: CommandQueue = asyncio.Queue()
+
+    command_server = asyncio.create_task(serve(command_queue))
+
+    scheduler = asyncio.create_task(start_scheduler(command_queue))
+
+    await scheduler
+    await command_server
+
+
+def start_queue_runner() -> None:
+    loop = asyncio.new_event_loop()
+    loop.run_until_complete(queue_runner_loop())
+    loop.close()
+
+
+if __name__ == "__main__":
+    start_queue_runner()

uncountable/integration/queue_runner/types.py

@@ -0,0 +1,7 @@
+from asyncio import Queue, Task
+
+from uncountable.types import queued_job_t
+
+ListenQueue = Queue[queued_job_t.QueuedJob]
+ResultQueue = Queue[queued_job_t.QueuedJobResult]
+ResultTask = Task[queued_job_t.QueuedJobResult]

uncountable/integration/queue_runner/worker.py

@@ -0,0 +1,109 @@
+import asyncio
+from concurrent.futures import ProcessPoolExecutor
+from dataclasses import dataclass
+
+from uncountable.core.async_batch import AsyncBatchProcessor
+from uncountable.integration.construct_client import construct_uncountable_client
+from uncountable.integration.executors.executors import execute_job
+from uncountable.integration.job import JobArguments
+from uncountable.integration.queue_runner.datastore.interface import Datastore
+from uncountable.integration.queue_runner.types import ListenQueue, ResultQueue
+from uncountable.integration.scan_profiles import load_profiles
+from uncountable.integration.telemetry import JobLogger, get_otel_tracer
+from uncountable.types import base_t, job_definition_t, queued_job_t
+
+
+class Worker:
+    def __init__(
+        self,
+        *,
+        process_pool: ProcessPoolExecutor,
+        listen_queue: ListenQueue,
+        result_queue: ResultQueue,
+        datastore: Datastore,
+    ) -> None:
+        self.process_pool = process_pool
+        self.listen_queue = listen_queue
+        self.result_queue = result_queue
+        self.datastore = datastore
+
+    async def run_worker_loop(self) -> None:
+        while True:
+            queued_job = await self.listen_queue.get()
+            self.datastore.increment_num_attempts(queued_job.queued_job_uuid)
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                self.process_pool, run_queued_job, queued_job
+            )
+            assert isinstance(result, job_definition_t.JobResult)
+            await self.result_queue.put(
+                queued_job_t.QueuedJobResult(
+                    job_result=result, queued_job_uuid=queued_job.queued_job_uuid
+                )
+            )
+
+
+@dataclass(kw_only=True)
+class RegisteredJobDetails:
+    profile_metadata: job_definition_t.ProfileMetadata
+    job_definition: job_definition_t.JobDefinition
+
+
+def get_registered_job_details(job_ref_name: str) -> RegisteredJobDetails:
+    profiles = load_profiles()
+    for profile in profiles:
+        for job_definition in profile.definition.jobs:
+            if job_definition.id == job_ref_name:
+                return RegisteredJobDetails(
+                    profile_metadata=job_definition_t.ProfileMetadata(
+                        name=profile.name,
+                        base_url=profile.definition.base_url,
+                        auth_retrieval=profile.definition.auth_retrieval,
+                        client_options=profile.definition.client_options,
+                    ),
+                    job_definition=job_definition,
+                )
+    raise Exception(f"profile not found for job {job_ref_name}")
+
+
+def _resolve_queued_job_payload(queued_job: queued_job_t.QueuedJob) -> base_t.JsonValue:
+    match queued_job.payload.invocation_context:
+        case queued_job_t.InvocationContextCron():
+            return None
+        case queued_job_t.InvocationContextManual():
+            return None
+        case queued_job_t.InvocationContextWebhook():
+            return queued_job.payload.invocation_context.webhook_payload
+
+
+def run_queued_job(
+    queued_job: queued_job_t.QueuedJob,
+) -> job_definition_t.JobResult:
+    with get_otel_tracer().start_as_current_span(name="run_queued_job") as span:
+        job_details = get_registered_job_details(queued_job.job_ref_name)
+        job_logger = JobLogger(
+            base_span=span,
+            profile_metadata=job_details.profile_metadata,
+            job_definition=job_details.job_definition,
+        )
+        client = construct_uncountable_client(
+            profile_meta=job_details.profile_metadata, job_logger=job_logger
+        )
+        batch_processor = AsyncBatchProcessor(client=client)
+
+        payload = _resolve_queued_job_payload(queued_job)
+
+        args = JobArguments(
+            job_definition=job_details.job_definition,
+            client=client,
+            batch_processor=batch_processor,
+            profile_metadata=job_details.profile_metadata,
+            logger=job_logger,
+            payload=payload,
+        )
+
+        return execute_job(
+            args=args,
+            profile_metadata=job_details.profile_metadata,
+            job_definition=job_details.job_definition,
+        )

uncountable/integration/scan_profiles.py

@@ -1,3 +1,4 @@
+import functools
 import os
 from dataclasses import dataclass
 from importlib import resources
@@ -14,6 +15,7 @@ class ProfileDetails:
     definition: job_definition_t.ProfileDefinition
 
 
+@functools.cache
 def load_profiles() -> list[ProfileDetails]:
     profiles_module = os.environ["UNC_PROFILES_MODULE"]
     profiles = [

uncountable/integration/scheduler.py

@@ -0,0 +1,144 @@
+import multiprocessing
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from datetime import datetime, timezone
+
+from opentelemetry.trace import get_current_span
+
+from uncountable.core.environment import get_local_admin_server_port
+from uncountable.integration.entrypoint import main as cron_target
+from uncountable.integration.queue_runner.command_server import (
+    CommandServerTimeout,
+    check_health,
+)
+from uncountable.integration.queue_runner.queue_runner import start_queue_runner
+from uncountable.integration.telemetry import Logger
+
+SHUTDOWN_TIMEOUT_SECS = 30
+
+
+@dataclass(kw_only=True)
+class ProcessInfo:
+    name: str
+    process: multiprocessing.Process | subprocess.Popen[bytes]
+
+    @property
+    def is_alive(self) -> bool:
+        match self.process:
+            case multiprocessing.Process():
+                return self.process.is_alive()
+            case subprocess.Popen():
+                return self.process.poll() is None
+
+    @property
+    def pid(self) -> int | None:
+        return self.process.pid
+
+
+def handle_shutdown(logger: Logger, processes: list[ProcessInfo]) -> None:
+    logger.log_info("received shutdown command, shutting down sub-processes")
+    for proc_info in processes:
+        if proc_info.is_alive:
+            proc_info.process.terminate()
+
+    shutdown_start = time.time()
+    still_living_processes = processes
+    while (
+        time.time() - shutdown_start < SHUTDOWN_TIMEOUT_SECS
+        and len(still_living_processes) > 0
+    ):
+        current_loop_processes = [*still_living_processes]
+        logger.log_info(
+            "waiting for sub-processes to shut down",
+            attributes={
+                "still_living_processes": [
+                    proc_info.name for proc_info in still_living_processes
+                ]
+            },
+        )
+        still_living_processes = []
+        for proc_info in current_loop_processes:
+            if not proc_info.is_alive:
+                logger.log_info(f"{proc_info.name} shut down successfully")
+            else:
+                still_living_processes.append(proc_info)
+        time.sleep(1)
+
+    for proc_info in still_living_processes:
+        logger.log_warning(
+            f"{proc_info.name} failed to shut down after {SHUTDOWN_TIMEOUT_SECS} seconds, forcefully terminating"
+        )
+        proc_info.process.kill()
+
+
+def check_process_alive(logger: Logger, processes: list[ProcessInfo]) -> None:
+    for proc_info in processes:
+        if not proc_info.is_alive:
+            logger.log_error(
+                f"process {proc_info.name} shut down unexpectedly! shutting down scheduler"
+            )
+            handle_shutdown(logger, processes)
+            sys.exit(1)
+
+
+def _wait_queue_runner_online() -> None:
+    _MAX_QUEUE_RUNNER_HEALTH_CHECKS = 10
+    _QUEUE_RUNNER_HEALTH_CHECK_DELAY_SECS = 1
+
+    num_attempts = 0
+    before = datetime.now(timezone.utc)
+    while num_attempts < _MAX_QUEUE_RUNNER_HEALTH_CHECKS:
+        try:
+            if check_health(port=get_local_admin_server_port()):
+                return
+        except CommandServerTimeout:
+            pass
+        num_attempts += 1
+        time.sleep(_QUEUE_RUNNER_HEALTH_CHECK_DELAY_SECS)
+    after = datetime.now(timezone.utc)
+    duration_secs = (after - before).seconds
+    raise Exception(f"queue runner failed to come online after {duration_secs} seconds")
+
+
+def main() -> None:
+    logger = Logger(get_current_span())
+    processes: list[ProcessInfo] = []
+
+    def add_process(process: ProcessInfo) -> None:
+        processes.append(process)
+        logger.log_info(f"started process {process.name}")
+
+    runner_process = multiprocessing.Process(target=start_queue_runner)
+    runner_process.start()
+    add_process(ProcessInfo(name="queue runner", process=runner_process))
+
+    try:
+        _wait_queue_runner_online()
+    except Exception as e:
+        logger.log_exception(e)
+        handle_shutdown(logger, processes=processes)
+        return
+
+    cron_process = multiprocessing.Process(target=cron_target)
+    cron_process.start()
+    add_process(ProcessInfo(name="cron server", process=cron_process))
+
+    uwsgi_process = subprocess.Popen([
+        "/app/env/bin/uwsgi",
+        "-H",
+        "/app/env",
+        "--die-on-term",
+    ])
+    add_process(ProcessInfo(name="uwsgi", process=uwsgi_process))
+
+    try:
+        while True:
+            check_process_alive(logger, processes=processes)
+            time.sleep(1)
+    except KeyboardInterrupt:
+        handle_shutdown(logger, processes=processes)
+
+
+main()

uncountable/integration/webhook_server/entrypoint.py

@@ -1,4 +1,5 @@
 import hmac
+import typing
 from dataclasses import dataclass
 
 import flask
@@ -6,15 +7,21 @@ import simplejson
 from flask.typing import ResponseReturnValue
 from flask.wrappers import Response
 from opentelemetry.trace import get_current_span
-from uncountable.core.async_batch import AsyncBatchProcessor
-from uncountable.core.environment import get_integration_env, get_webhook_server_port
-from uncountable.integration.construct_client import construct_uncountable_client
-from uncountable.integration.executors.executors import execute_job
-from uncountable.integration.job import WebhookJobArguments
+from uncountable.core.environment import (
+    get_integration_env,
+    get_local_admin_server_port,
+    get_webhook_server_port,
+)
+from uncountable.integration.queue_runner.command_server.command_client import (
+    send_job_queue_message,
+)
+from uncountable.integration.queue_runner.command_server.types import (
+    CommandServerException,
+)
 from uncountable.integration.scan_profiles import load_profiles
 from uncountable.integration.secret_retrieval.retrieve_secret import retrieve_secret
-from uncountable.integration.telemetry import JobLogger, Logger, get_otel_tracer
-from uncountable.types import job_definition_t, webhook_job_t
+from uncountable.integration.telemetry import Logger
+from uncountable.types import base_t, job_definition_t, queued_job_t, webhook_job_t
 
 from pkgs.argument_parser import CachedParser
 
@@ -66,7 +73,7 @@ class WebhookException(BaseException):
 
 def _parse_webhook_payload(
     *, raw_request_body: bytes, signature_key: str, passed_signature: str
-) -> webhook_job_t.WebhookEventBody:
+) -> base_t.JsonValue:
     request_body_signature = hmac.new(
         signature_key.encode("utf-8"), msg=raw_request_body, digestmod="sha256"
     ).hexdigest()
@@ -76,7 +83,7 @@ def _parse_webhook_payload(
 
     try:
         request_body = simplejson.loads(raw_request_body.decode())
-        return webhook_payload_parser.parse_api(request_body)
+        return typing.cast(base_t.JsonValue, request_body)
     except (simplejson.JSONDecodeError, ValueError) as e:
         raise WebhookException.body_parse_error() from e
 
@@ -110,31 +117,20 @@ def register_route(
                     passed_signature=passed_signature,
                 )
 
-                with get_otel_tracer().start_as_current_span(
-                    "webhook_executor"
-                ) as span:
-                    job_logger = JobLogger(
-                        profile_metadata=profile_metadata,
-                        job_definition=job,
-                        base_span=span,
-                    )
-                    client = construct_uncountable_client(
-                        profile_meta=profile_meta, job_logger=job_logger
-                    )
-                    execute_job(
-                        job_definition=job,
-                        profile_metadata=profile_meta,
-                        args=WebhookJobArguments(
-                            job_definition=job,
-                            profile_metadata=profile_metadata,
-                            client=client,
-                            batch_processor=AsyncBatchProcessor(client=client),
-                            logger=job_logger,
-                            payload=webhook_payload,
+                try:
+                    send_job_queue_message(
+                        job_ref_name=job.id,
+                        payload=queued_job_t.QueuedJobPayload(
+                            invocation_context=queued_job_t.InvocationContextWebhook(
+                                webhook_payload=webhook_payload
+                            )
                         ),
+                        port=get_local_admin_server_port(),
                     )
+                except CommandServerException as e:
+                    raise WebhookException.unknown_error() from e
 
-                    return flask.jsonify(WebhookResponse())
+                return flask.jsonify(WebhookResponse())
             except WebhookException as e:
                 server_logger.log_exception(e)
                 return e.make_error_response()
@@ -145,20 +141,24 @@ def register_route(
     server_logger.log_info(f"job {job.id} webhook registered at: {route}")
 
 
-profiles = load_profiles()
-for profile in profiles:
-    server_logger = Logger(get_current_span())
-    profile_metadata = job_definition_t.ProfileMetadata(
-        name=profile.name,
-        auth_retrieval=profile.definition.auth_retrieval,
-        base_url=profile.definition.base_url,
-        client_options=profile.definition.client_options,
-    )
-    for job in profile.definition.jobs:
-        if isinstance(job, job_definition_t.WebhookJobDefinition):
-            register_route(
-                server_logger=server_logger, profile_meta=profile_metadata, job=job
-            )
+def main() -> None:
+    profiles = load_profiles()
+    for profile in profiles:
+        server_logger = Logger(get_current_span())
+        profile_metadata = job_definition_t.ProfileMetadata(
+            name=profile.name,
+            auth_retrieval=profile.definition.auth_retrieval,
+            base_url=profile.definition.base_url,
+            client_options=profile.definition.client_options,
+        )
+        for job in profile.definition.jobs:
+            if isinstance(job, job_definition_t.WebhookJobDefinition):
+                register_route(
+                    server_logger=server_logger, profile_meta=profile_metadata, job=job
+                )
+
+
+main()
 
 
 if __name__ == "__main__":

uncountable/types/__init__.py

@@ -63,6 +63,7 @@ from . import overrides_t as overrides_t
 from . import permissions_t as permissions_t
 from . import phases_t as phases_t
 from . import post_base_t as post_base_t
+from . import queued_job_t as queued_job_t
 from . import recipe_identifiers_t as recipe_identifiers_t
 from . import recipe_inputs_t as recipe_inputs_t
 from . import recipe_links_t as recipe_links_t
@@ -86,6 +87,7 @@ from .api.inputs import set_intermediate_type as set_intermediate_type_t
 from .api.recipes import set_recipe_inputs as set_recipe_inputs_t
 from .api.recipes import set_recipe_metadata as set_recipe_metadata_t
 from .api.recipes import set_recipe_output_annotations as set_recipe_output_annotations_t
+from .api.recipes import set_recipe_output_file as set_recipe_output_file_t
 from .api.recipes import set_recipe_outputs as set_recipe_outputs_t
 from .api.recipes import set_recipe_tags as set_recipe_tags_t
 from .api.entity import set_values as set_values_t
@@ -162,6 +164,7 @@ __all__: list[str] = [
     "permissions_t",
     "phases_t",
     "post_base_t",
+    "queued_job_t",
     "recipe_identifiers_t",
     "recipe_inputs_t",
     "recipe_links_t",
@@ -185,6 +188,7 @@ __all__: list[str] = [
     "set_recipe_inputs_t",
     "set_recipe_metadata_t",
     "set_recipe_output_annotations_t",
+    "set_recipe_output_file_t",
     "set_recipe_outputs_t",
     "set_recipe_tags_t",
     "set_values_t",

uncountable/types/api/recipes/get_recipes_data.py

@@ -97,6 +97,7 @@ class RecipeInput:
     curve_id: typing.Optional[base_t.ObjectId]
     actual_quantity_json: base_t.JsonValue
     behavior: str
+    ingredient_role_id: typing.Optional[base_t.ObjectId]
     quantity_dec: typing.Optional[Decimal] = None
     actual_quantity_dec: typing.Optional[Decimal] = None
 

uncountable/types/api/recipes/set_recipe_output_file.py

@@ -0,0 +1,46 @@
+# DO NOT MODIFY -- This file is generated by type_spec
+# flake8: noqa: F821
+# ruff: noqa: E402 Q003
+# fmt: off
+# isort: skip_file
+from __future__ import annotations
+import typing  # noqa: F401
+import datetime  # noqa: F401
+from decimal import Decimal  # noqa: F401
+import dataclasses
+from ... import base_t
+from ... import response_t
+
+__all__: list[str] = [
+    "Arguments",
+    "Data",
+    "ENDPOINT_METHOD",
+    "ENDPOINT_PATH",
+    "RecipeOutputFileValue",
+]
+
+ENDPOINT_METHOD = "POST"
+ENDPOINT_PATH = "api/external/recipes/external_set_recipe_output_file"
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@dataclasses.dataclass(kw_only=True)
+class RecipeOutputFileValue:
+    recipe_id: base_t.ObjectId
+    output_id: base_t.ObjectId
+    experiment_num: int
+    condition_id: typing.Optional[base_t.ObjectId] = None
+    file_id: typing.Optional[base_t.ObjectId] = None
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@dataclasses.dataclass(kw_only=True)
+class Arguments:
+    output_file_data: RecipeOutputFileValue
+
+
+# DO NOT MODIFY -- This file is generated by type_spec
+@dataclasses.dataclass(kw_only=True)
+class Data(response_t.Response):
+    pass
+# DO NOT MODIFY -- This file is generated by type_spec