codeapi-client 0.4.1__py3-none-any.whl

codeapi/client/_async/_web.py

@@ -0,0 +1,343 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+import httpx
+
+from codeapi.types import (
+    CodeInfo,
+    CodeType,
+    CodeZip,
+    Job,
+    JobStage,
+    JobStatus,
+    JobType,
+    JsonData,
+)
+
+if TYPE_CHECKING:
+    from . import AsyncClient
+
+
+class AsyncStoredWebClient:
+    def __init__(self, client: AsyncClient):
+        self._client = client
+
+    async def run(
+        self,
+        code_id: str,
+    ) -> Job:
+        """Runs a stored Web page.
+
+        Args:
+            code_id (str): The code ID.
+
+        Returns:
+            Job: The created job.
+
+        Raises:
+            HTTPException: If the request fails.
+        """
+        url = f"{self._client.base_url}/jobs/code/{code_id}/run/web"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    url,
+                    headers=self._client.api_key_header,
+                )
+                response.raise_for_status()
+                return Job(**response.json())
+            except httpx.HTTPStatusError as e:
+                raise self._client._get_http_exception(httpx_error=e)
+
+    async def list_info(self) -> list[CodeInfo]:
+        """List all stored Web code.
+
+        Returns:
+            list[CodeInfo]: List of Web code info.
+        """
+        return await self._client.code.list_info(code_type=CodeType.WEB)
+
+    async def delete(self, code_id: str) -> str:
+        """Delete stored Web code.
+
+        Args:
+            code_id (str): The code ID to delete.
+
+        Returns:
+            str: Deletion confirmation message.
+
+        Raises:
+            ValueError: If the code_id is not Web code.
+        """
+        # Verify this is actually Web code
+        code_info = await self._client.code.get_info(code_id)
+        if code_info.code_type != CodeType.WEB:
+            raise ValueError(
+                f"Code '{code_id}' is {code_info.code_type}, not Web code. "
+                "Cannot delete non-Web code from Web client."
+            )
+
+        return await self._client.code.delete(code_id)
+
+
+class AsyncWebJobsClient:
+    def __init__(self, client):
+        self._client = client
+
+    async def list(
+        self,
+        job_status: JobStatus | None = None,
+        job_stage: JobStage | None = None,
+    ) -> List[Job]:
+        """List Web jobs.
+
+        Args:
+            job_status (JobStatus | None): Filter by job status.
+            job_stage (JobStage | None): Filter by job stage.
+
+        Returns:
+            list[Job]: List of Web jobs.
+        """
+        return await self._client.jobs.list(
+            job_type=JobType.RUN_WEB,
+            job_status=job_status,
+            job_stage=job_stage,
+        )
+
+    async def get_latest(self) -> Job | None:
+        """Get the most recent Web job.
+
+        Returns:
+            Job | None: The most recent Web job, or None if no jobs exist.
+        """
+        jobs = await self.list()
+        return jobs[0] if jobs else None
+
+    async def list_queued(self) -> List[Job]:
+        """Get all queued Web jobs.
+
+        Returns:
+            List[Job]: List of queued Web jobs.
+        """
+        return await self.list(job_status=JobStatus.QUEUED)
+
+    async def list_scheduled(self) -> List[Job]:
+        """Get all scheduled Web jobs.
+
+        Returns:
+            List[Job]: List of scheduled Web jobs.
+        """
+        return await self.list(job_status=JobStatus.SCHEDULED)
+
+    async def list_started(self) -> List[Job]:
+        """Get all started Web jobs.
+
+        Returns:
+            list[Job]: List of started Web jobs.
+        """
+        return await self.list(job_status=JobStatus.STARTED)
+
+    async def list_deferred(self) -> List[Job]:
+        """Get all deferred Web jobs.
+
+        Returns:
+            List[Job]: List of deferred Web jobs.
+        """
+        return await self.list(job_status=JobStatus.DEFERRED)
+
+    async def list_canceled(self) -> List[Job]:
+        """Get all canceled Web jobs.
+
+        Returns:
+            List[Job]: List of canceled Web jobs.
+        """
+        return await self.list(job_status=JobStatus.CANCELED)
+
+    async def list_stopped(self) -> List[Job]:
+        """Get all stopped Web jobs.
+
+        Returns:
+            List[Job]: List of stopped Web jobs.
+        """
+        return await self.list(job_status=JobStatus.STOPPED)
+
+    async def list_failed(self) -> List[Job]:
+        """Get all failed Web jobs.
+
+        Returns:
+            list[Job]: List of failed Web jobs.
+        """
+        return await self.list(job_status=JobStatus.FAILED)
+
+    async def list_finished(self) -> List[Job]:
+        """Get all finished Web jobs.
+
+        Returns:
+            list[Job]: List of finished Web jobs.
+        """
+        return await self.list(job_status=JobStatus.FINISHED)
+
+    async def list_timed_out(self) -> List[Job]:
+        """Get all timed out Web jobs.
+
+        Returns:
+            List[Job]: List of timed out Web jobs.
+        """
+        return await self.list(job_status=JobStatus.TIMEOUT)
+
+    async def list_pre_running(self) -> List[Job]:
+        """Get all pre-running Web jobs.
+
+        Returns:
+            List[Job]: List of pre-running Web jobs.
+        """
+        return await self.list(job_stage=JobStage.PRE_RUNNING)
+
+    async def list_running(self) -> List[Job]:
+        """Get all running Web jobs.
+
+        Returns:
+            List[Job]: List of running Web jobs.
+        """
+        return await self.list(job_stage=JobStage.RUNNING)
+
+    async def list_post_running(self) -> List[Job]:
+        """Get all post-running Web jobs.
+
+        Returns:
+            List[Job]: List of post-running Web jobs.
+        """
+        return await self.list(job_stage=JobStage.POST_RUNNING)
+
+
+class AsyncWebClient:
+    def __init__(self, client: AsyncClient):
+        self._client = client
+        self.stored = AsyncStoredWebClient(client)
+        self.jobs = AsyncWebJobsClient(client)
+
+    async def run(
+        self,
+        code_zip: CodeZip,
+    ) -> Job:
+        """Runs a Web page from code zip.
+
+        Args:
+            code_zip (CodeZip): The code zip.
+
+        Returns:
+            Job: The created job.
+
+        Raises:
+            HTTPException: If the request fails.
+        """
+        url = f"{self._client.base_url}/jobs/code/run/web"
+
+        files = self._client._prepare_files(code_zip=code_zip)
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    url,
+                    headers=self._client.api_key_header,
+                    files=files,
+                )
+                response.raise_for_status()
+                return Job(**response.json())
+            except httpx.HTTPStatusError as e:
+                raise self._client._get_http_exception(httpx_error=e)
+
+    def get_url(self, job_id: str) -> str:
+        """Gets the URL for a Web page.
+
+        Args:
+            job_id (str): The job ID.
+
+        Returns:
+            str: The Web page URL.
+        """
+        return self._client.get_subdomain_proxy_url(job_id)
+
+    async def upload(
+        self,
+        code_zip: CodeZip,
+        code_name: str,
+        metadata: JsonData | dict | None = None,
+    ) -> str:
+        """Upload Web code.
+
+        Args:
+            code_zip (CodeZip): The code zip.
+            code_name (str): The name of the code.
+            metadata (JsonData | dict | None): The JSON metadata of the code.
+
+        Returns:
+            str: The code ID.
+        """
+        return await self._client.code.upload(
+            code_zip=code_zip,
+            code_name=code_name,
+            code_type=CodeType.WEB,
+            metadata=metadata,
+        )
+
+    async def is_healthy(self, job_id: str) -> bool:
+        """Checks whether launched Web page is healthy.
+
+        Args:
+            job_id (str): The ID of the Web page launch job.
+
+        Returns:
+            bool: True if Web page is healthy else False.
+
+        Raises:
+            HTTPException: If the request fails.
+        """
+        return await self._client.jobs.is_healthy(job_id=job_id)
+
+    async def await_healthy(self, job_id: str, timeout: float | None = None) -> Job:
+        """Waits for a Web page to become healthy.
+
+        Args:
+            job_id (str): The ID of the Web page run job.
+            timeout (float | None): Maximum time to wait in seconds. If None, waits indefinitely.
+
+        Returns:
+            Job: The job object of the Web page run job.
+
+        Raises:
+            HTTPException: If the request fails.
+            APIException: If the job enters stage POST_RUNNING unexpectedly.
+            TimeoutError: If the timeout is exceeded.
+        """
+        return await self._client.jobs.await_healthy(job_id=job_id, timeout=timeout)
+
+    async def ingest(
+        self,
+        code_zip: CodeZip,
+        code_name: str,
+        metadata: JsonData | dict | None = None,
+        build_pexenv: bool = False,
+        pexenv_python: str | None = None,
+    ) -> Job:
+        """Ingest Web code.
+
+        Args:
+            code_zip (CodeZip): The code zip.
+            code_name (str): The name of the code.
+            metadata (JsonData | dict | None): The JSON metadata of the code.
+            build_pexenv (bool): Whether to build the pex venv.
+            pexenv_python: (str | None): Python interpreter for the pex venv.
+
+        Returns:
+            Job: The code ingestion job.
+        """
+        return await self._client.code.ingest(
+            code_zip=code_zip,
+            code_name=code_name,
+            code_type=CodeType.WEB,
+            metadata=metadata,
+            build_pexenv=build_pexenv,
+            pexenv_python=pexenv_python,
+        )

codeapi/client/_base.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import json
+import socket
+from abc import ABC
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+from fastapi import HTTPException
+
+from codeapi.client._utils import write_bytes, write_bytes_async
+from codeapi.types import API_KEY_HEADER, CodeAPIError, CodeAPIException, JsonData
+
+
+class ClientBase(ABC):
+    def __init__(self, base_url: str, api_key: str = ""):
+        """Initializes the CodeAPI Client.
+
+        Args:
+            base_url (str): The base URL of the CodeAPI.
+            api_key (str): The CodeAPI key.
+        """
+        parsed_url = urlparse(base_url)
+        self.protocol = parsed_url.scheme
+        if parsed_url.hostname == "0.0.0.0":
+            self.host = "localhost"
+        else:
+            try:
+                self.host = socket.gethostbyaddr(str(parsed_url.hostname))[0]
+            except Exception:
+                self.host = str(parsed_url.hostname)
+        self.port = parsed_url.port
+        self.base_url = f"{self.protocol}://{self.host}:{self.port}"
+        self.api_key = api_key
+
+    @property
+    def api_key_header(self) -> dict[str, str]:
+        return {API_KEY_HEADER: self.api_key}
+
+    def _get_response_detail(self, response: httpx.Response) -> str | None:
+        try:
+            return response.json()["detail"]
+        except Exception:
+            return None
+
+    def _get_http_exception(
+        self, httpx_error: httpx.HTTPStatusError
+    ) -> HTTPException | CodeAPIException:
+        status_code = httpx_error.response.status_code
+        detail = httpx_error.response.json()["detail"]
+        if isinstance(detail, dict) and detail.keys() == set(["error", "message"]):
+            return CodeAPIException(
+                error=CodeAPIError(detail["error"]), message=detail["message"]
+            )
+        return HTTPException(status_code=status_code, detail=detail)
+
+    def get_proxy_url(self, job_id: str):
+        return f"{self.base_url}/{job_id}"
+
+    def get_subdomain_proxy_url(self, job_id: str):
+        return f"{self.protocol}://{job_id.lower()}.{self.host}:{self.port}"
+
+    def _prepare_files(self, **kwargs: Any) -> dict[str, tuple[str, BytesIO, str]]:
+        """Prepare files for multipart upload."""
+        files = {}
+        for key, value in kwargs.items():
+            if value is not None:
+                if key.endswith("_zip"):
+                    name = f"{key.replace('_zip', '')}.zip"
+                    files[f"{key}file"] = (name, value.to_bytesio(), "application/zip")
+                elif key == "metadata":
+                    files["metadata"] = (
+                        "metadata.json",
+                        JsonData(value).to_bytesio(),
+                        "application/json",
+                    )
+        return files
+
+    def _handle_stream_download(
+        self, response: httpx.Response, zip_path: Path | str | None = None
+    ) -> bytes:
+        """Handle streaming download with optional file saving."""
+        mem_bytes = BytesIO()
+        try:
+            for chunk in response.iter_bytes():
+                mem_bytes.write(chunk)
+            if response.is_error:
+                error_content = mem_bytes.getvalue().decode()
+                detail = json.loads(error_content)["detail"]
+                raise HTTPException(status_code=response.status_code, detail=detail)
+            zip_bytes = mem_bytes.getvalue()
+            if zip_path:
+                write_bytes(path=zip_path, data=zip_bytes)
+            return zip_bytes
+        finally:
+            mem_bytes.close()
+
+    async def _handle_stream_download_async(
+        self, response: httpx.Response, zip_path: Path | str | None = None
+    ) -> bytes:
+        """Handle streaming download with optional file saving."""
+        mem_bytes = BytesIO()
+        try:
+            async for chunk in response.aiter_bytes():
+                mem_bytes.write(chunk)
+            if response.is_error:
+                error_content = mem_bytes.getvalue().decode()
+                detail = json.loads(error_content)["detail"]
+                raise HTTPException(status_code=response.status_code, detail=detail)
+            zip_bytes = mem_bytes.getvalue()
+            if zip_path:
+                await write_bytes_async(path=zip_path, data=zip_bytes)
+            return zip_bytes
+        finally:
+            mem_bytes.close()