BSander Endpoint and Clients

Ezequiel-Valencia · Ezequiel-Valencia · commit 42302ccc16cd · 2025-09-15T14:56:36.000-04:00
diff --git a/compose_api/api/client/api/simulations/analyze_simulation_omex.py b/compose_api/api/client/api/simulations/analyze_simulation_omex.py
@@ -0,0 +1,170 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.body_analyze_simulation_omex import BodyAnalyzeSimulationOmex
+from ...models.http_validation_error import HTTPValidationError
+from typing import cast
+
+
+def _get_kwargs(
+    *,
+    body: BodyAnalyzeSimulationOmex,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/core/simulation/analyze",
+    }
+
+    _kwargs["files"] = body.to_multipart()
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[HTTPValidationError, str]]:
+    if response.status_code == 200:
+        response_200 = response.text
+        return response_200
+    if response.status_code == 422:
+        response_422 = HTTPValidationError.from_dict(response.json())
+
+        return response_422
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[HTTPValidationError, str]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: BodyAnalyzeSimulationOmex,
+) -> Response[Union[HTTPValidationError, str]]:
+    """Analyze a simulation, and determine what containers should be built to execute it.
+
+     Resulting container definition file
+
+    Args:
+        body (BodyAnalyzeSimulationOmex):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[HTTPValidationError, str]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: BodyAnalyzeSimulationOmex,
+) -> Optional[Union[HTTPValidationError, str]]:
+    """Analyze a simulation, and determine what containers should be built to execute it.
+
+     Resulting container definition file
+
+    Args:
+        body (BodyAnalyzeSimulationOmex):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[HTTPValidationError, str]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: BodyAnalyzeSimulationOmex,
+) -> Response[Union[HTTPValidationError, str]]:
+    """Analyze a simulation, and determine what containers should be built to execute it.
+
+     Resulting container definition file
+
+    Args:
+        body (BodyAnalyzeSimulationOmex):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[HTTPValidationError, str]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: BodyAnalyzeSimulationOmex,
+) -> Optional[Union[HTTPValidationError, str]]:
+    """Analyze a simulation, and determine what containers should be built to execute it.
+
+     Resulting container definition file
+
+    Args:
+        body (BodyAnalyzeSimulationOmex):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[HTTPValidationError, str]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed
diff --git a/compose_api/api/client/models/__init__.py b/compose_api/api/client/models/__init__.py
@@ -1,5 +1,6 @@
 """Contains all the data models used in inputs/outputs"""
 
+from .body_analyze_simulation_omex import BodyAnalyzeSimulationOmex
 from .body_run_simulation import BodyRunSimulation
 from .check_health_health_get_response_check_health_health_get import CheckHealthHealthGetResponseCheckHealthHealthGet
 from .hpc_run import HpcRun
@@ -11,6 +12,7 @@
 from .validation_error import ValidationError
 
 __all__ = (
+    "BodyAnalyzeSimulationOmex",
     "BodyRunSimulation",
     "CheckHealthHealthGetResponseCheckHealthHealthGet",
     "HpcRun",
diff --git a/compose_api/api/client/models/body_analyze_simulation_omex.py b/compose_api/api/client/models/body_analyze_simulation_omex.py
@@ -0,0 +1,75 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Optional, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+import json
+from .. import types
+
+from ..types import UNSET, Unset
+
+from ..types import File, FileTypes
+from io import BytesIO
+
+
+T = TypeVar("T", bound="BodyAnalyzeSimulationOmex")
+
+
+@_attrs_define
+class BodyAnalyzeSimulationOmex:
+    """
+    Attributes:
+        uploaded_file (File):
+    """
+
+    uploaded_file: File
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uploaded_file = self.uploaded_file.to_tuple()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "uploaded_file": uploaded_file,
+        })
+
+        return field_dict
+
+    def to_multipart(self) -> types.RequestFiles:
+        files: types.RequestFiles = []
+
+        files.append(("uploaded_file", self.uploaded_file.to_tuple()))
+
+        for prop_name, prop in self.additional_properties.items():
+            files.append((prop_name, (None, str(prop).encode(), "text/plain")))
+
+        return files
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        uploaded_file = File(payload=BytesIO(d.pop("uploaded_file")))
+
+        body_analyze_simulation_omex = cls(
+            uploaded_file=uploaded_file,
+        )
+
+        body_analyze_simulation_omex.additional_properties = d
+        return body_analyze_simulation_omex
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties
diff --git a/compose_api/api/routers/core.py b/compose_api/api/routers/core.py
@@ -3,8 +3,14 @@
 from pathlib import Path
 
 from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query, UploadFile
-from starlette.responses import FileResponse
+from starlette.responses import FileResponse, PlainTextResponse
 
+from compose_api.btools.bsander.bsandr_utils.input_types import (
+    ContainerizationEngine,
+    ContainerizationTypes,
+    ProgramArguments,
+)
+from compose_api.btools.bsander.execution import execute_bsander
 from compose_api.common.gateway.models import Namespace, RouterConfig, ServerMode
 from compose_api.common.ssh.ssh_service import get_ssh_service
 from compose_api.config import get_settings
@@ -143,6 +149,41 @@ async def submit_simulation(background_tasks: BackgroundTasks, uploaded_file: Up
 #         raise HTTPException(status_code=500, detail=str(e)) from e
 
 
+@config.router.post(
+    path="/simulation/analyze",
+    response_class=PlainTextResponse,
+    description="Resulting container definition file",
+    operation_id="analyze-simulation-omex",
+    tags=["Simulations"],
+    summary="Analyze a simulation, and determine what containers should be built to execute it.",
+)
+async def analyze_simulation(uploaded_file: UploadFile) -> str:
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        contents = await uploaded_file.read()
+        uploaded_file_path = f"{tmp_dir}/{uploaded_file.filename}"
+        with open(uploaded_file_path, "wb") as fh:
+            fh.write(contents)
+        singularity_rep, experiment_dep = execute_bsander(
+            ProgramArguments(
+                input_file_path=uploaded_file_path,
+                output_dir=tmp_dir,
+                containerization_type=ContainerizationTypes.SINGLE,
+                containerization_engine=ContainerizationEngine.APPTAINER,
+                passlist_entries=[
+                    "pypi::git+https://github.com/biosimulators/bspil-basico.git@initial_work",
+                    "pypi::cobra",
+                    "pypi::tellurium",
+                    "pypi::copasi-basico",
+                    "pypi::smoldyn",
+                    "pypi::numpy",
+                    "pypi::matplotlib",
+                    "pypi::scipy",
+                ],
+            )
+        )
+    return singularity_rep.representation
+
+
 @config.router.get(
     path="/simulation/run/status",
     response_model=HpcRun,
diff --git a/compose_api/api/spec/openapi_3_1_0_generated.yaml b/compose_api/api/spec/openapi_3_1_0_generated.yaml
@@ -28,6 +28,33 @@ paths:
             application/json:
               schema:
                 $ref: '#/components/schemas/HTTPValidationError'
+  /core/simulation/analyze:
+    post:
+      tags:
+      - Simulations
+      summary: Analyze a simulation, and determine what containers should be built
+        to execute it.
+      description: Resulting container definition file
+      operationId: analyze-simulation-omex
+      requestBody:
+        content:
+          multipart/form-data:
+            schema:
+              $ref: '#/components/schemas/Body_analyze-simulation-omex'
+        required: true
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            text/plain:
+              schema:
+                type: string
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
   /core/simulation/run/status:
     get:
       tags:
@@ -138,6 +165,16 @@ paths:
                 title: Response Get Version Version Get
 components:
   schemas:
+    Body_analyze-simulation-omex:
+      properties:
+        uploaded_file:
+          type: string
+          format: binary
+          title: Uploaded File
+      type: object
+      required:
+      - uploaded_file
+      title: Body_analyze-simulation-omex
     Body_run-simulation:
       properties:
         uploaded_file:
