codeapi-client 0.4.1__py3-none-any.whl

codeapi/types/_env.py

@@ -0,0 +1,65 @@
+import json
+from io import BytesIO, IOBase
+from pathlib import Path
+from typing import BinaryIO
+
+import dotenv
+
+
+class EnvVars(dict[str, str]):
+    def __init__(self, env_vars: dict[str, str] | str | None = None):
+        super().__init__()
+        if isinstance(env_vars, str):
+            self.update(json.loads(env_vars))
+        elif env_vars:
+            self.update(env_vars)
+
+    def __setitem__(self, key, value) -> None:
+        if not isinstance(key, str) or not isinstance(value, str):
+            raise TypeError("EnvVars keys and values must be strings")
+        super().__setitem__(key, value)
+
+    @property
+    def json_str(self) -> str:
+        return json.dumps(self)
+
+    def dump(self) -> str:
+        return self.json_str
+
+    def print(self) -> None:
+        print("\n".join([f"{k}={v}" for k, v in self.items()]))
+
+    @staticmethod
+    def _replace_none_values(dotenv_values: dict[str, str | None]) -> dict[str, str]:
+        return {k: ("" if v is None else v) for k, v in dotenv_values.items()}
+
+    @classmethod
+    def from_bytes(cls, data_bytes: bytes | BinaryIO) -> "EnvVars":
+        if isinstance(data_bytes, (BinaryIO, IOBase)):
+            data_bytes.seek(0)
+            data_bytes = data_bytes.read()
+        dotenv_values = json.loads(data_bytes)
+        return cls(cls._replace_none_values(dotenv_values))
+
+    @classmethod
+    def from_str(cls, json_str: str) -> "EnvVars":
+        return cls(json.loads(json_str))
+
+    @classmethod
+    def from_file(cls, path: Path | str) -> "EnvVars":
+        dotenv_values = dotenv.dotenv_values(dotenv_path=path)
+        return cls(cls._replace_none_values(dotenv_values))
+
+    @classmethod
+    def from_dict(cls, env_vars: dict[str, str]) -> "EnvVars":
+        return cls(env_vars)
+
+    def to_file(self, path: Path | str) -> None:
+        data = [f"{k}={v}" for k, v in self.items()]
+        Path(path).write_text("\n".join(data))
+
+    def to_bytesio(self) -> BytesIO:
+        return BytesIO(json.dumps(self).encode())
+
+    def to_dict(self) -> dict[str, str]:
+        return dict(self)

codeapi/types/_exc.py

@@ -0,0 +1,35 @@
+from fastapi import HTTPException
+
+from ._enums import CodeAPIError
+
+
+class CodeAPIException(HTTPException):
+    def __init__(self, error: CodeAPIError, message: str = ""):
+        self.error: CodeAPIError = error
+        self.message: str = message
+
+        status_code = self._get_status_code()
+        detail = {"error": self.error.name, "message": message}
+        super().__init__(status_code=status_code, detail=detail)
+
+    def _get_status_code(self) -> int:
+        if self.error == CodeAPIError.CODE_NOT_FOUND:
+            return 404
+        elif self.error == CodeAPIError.JOB_FAILED:
+            return 500
+        elif self.error == CodeAPIError.JOB_NOT_FINISHED:
+            return 400
+        elif self.error == CodeAPIError.JOB_NOT_FOUND:
+            return 404
+        elif self.error == CodeAPIError.JOB_STILL_QUEUED:
+            return 503
+        elif self.error == CodeAPIError.JOB_TIMED_OUT:
+            return 408
+        elif self.error == CodeAPIError.NO_ASSOCIATED_CODE_ID:
+            return 404
+        elif self.error == CodeAPIError.NO_JOB_META:
+            return 404
+        elif self.error == CodeAPIError.NO_STORAGE_BACKEND:
+            return 501
+        else:
+            return 500

codeapi/types/_job.py

@@ -0,0 +1,67 @@
+from pydantic import BaseModel, Field
+
+from ._enums import JobStage, JobStatus, JobType
+
+
+class Job(BaseModel):
+    job_id: str
+    job_type: JobType
+    job_status: JobStatus
+    job_error: str | None = Field(default=None)
+    job_traceback: str | None = Field(default=None, repr=False)
+    code_id: str | None = None
+
+    @property
+    def job_stage(self) -> JobStage:
+        return self.job_status.stage
+
+    @property
+    def is_queued(self) -> bool:
+        return self.job_stage == JobStatus.QUEUED
+
+    @property
+    def is_scheduled(self) -> bool:
+        return self.job_stage == JobStatus.SCHEDULED
+
+    @property
+    def is_pre_running(self) -> bool:
+        return self.job_stage == JobStage.PRE_RUNNING
+
+    @property
+    def is_running(self) -> bool:
+        return self.job_stage == JobStage.RUNNING
+
+    @property
+    def is_post_running(self) -> bool:
+        return self.job_stage == JobStage.POST_RUNNING
+
+    @property
+    def has_finished(self) -> bool:
+        return self.job_status == JobStatus.FINISHED
+
+    @property
+    def has_failed(self) -> bool:
+        return self.is_post_running and not self.has_finished
+
+    @property
+    def has_timed_out(self) -> bool:
+        return self.job_status == JobStatus.TIMEOUT
+
+    @property
+    def has_been_stopped(self) -> bool:
+        return self.job_status == JobStatus.STOPPED
+
+    @property
+    def has_been_canceled(self) -> bool:
+        return self.job_status == JobStatus.CANCELED
+
+    @property
+    def has_been_deferred(self) -> bool:
+        return self.job_status == JobStatus.DEFERRED
+
+    def __str__(self):
+        fields = self.__class__.__pydantic_fields__
+        field_values = ", ".join(
+            f"{k}={repr(v)}" for k, v in self.model_dump().items() if fields[k].repr
+        )
+        return f"{self.__class__.__name__}({field_values})"

codeapi/types/_json.py

@@ -0,0 +1,67 @@
+import json
+from io import BytesIO, IOBase
+from pathlib import Path
+from typing import Any, BinaryIO, OrderedDict
+
+
+class JsonData(dict):
+    def __init__(self, data: dict | Path | str | bytes | None = None):
+        super().__init__()
+        if data is None:
+            pass
+        elif isinstance(data, (str, bytes)):
+            self.update(json.loads(data))
+        elif isinstance(data, Path):
+            if data.is_file():
+                self.update(json.loads(data.read_text()))
+            else:
+                raise ValueError(f"{data} is not a file")
+        elif isinstance(data, dict):
+            self.update(data)
+        else:
+            raise TypeError("Invalid data type for JsonData")
+
+    @property
+    def json_str(self) -> str:
+        return json.dumps(self)
+
+    def dump(self) -> str:
+        return self.json_str
+
+    def print(self, indent: int = 4) -> None:
+        print(json.dumps(self, indent=indent))
+
+    def add_key(self, key: Any, value: Any, prepend: bool = False) -> None:
+        new_data = OrderedDict()
+        if prepend:
+            new_data[key] = value
+            new_data.update(self)
+        else:
+            new_data.update(self)
+            new_data[key] = value
+        self.clear()
+        self.update(new_data)
+
+    def remove_key(self, key: Any) -> None:
+        self.pop(key, None)
+
+    @classmethod
+    def from_file(cls, path: Path | str) -> "JsonData":
+        return cls(json.loads(Path(path).read_text()))
+
+    @classmethod
+    def from_str(cls, json_str: str) -> "JsonData":
+        return cls(json_str)
+
+    @classmethod
+    def from_bytes(cls, data_bytes: bytes | BinaryIO) -> "JsonData":
+        if isinstance(data_bytes, (BinaryIO, IOBase)):
+            data_bytes.seek(0)
+            data_bytes = data_bytes.read()
+        return cls(json.loads(data_bytes))
+
+    def to_file(self, path: Path | str) -> None:
+        Path(path).write_text(json.dumps(self, indent=4))
+
+    def to_bytesio(self) -> BytesIO:
+        return BytesIO(json.dumps(self).encode())

codeapi/types/_stream.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+from typing import Any, Literal
+
+from pydantic import BaseModel, field_validator
+
+
+class StreamOutput(BaseModel):
+    sid: str
+    stream: Literal["stdout", "stderr"]
+    text: str
+
+    @property
+    def timestamp(self) -> float:
+        return int(self.sid.split("-")[0]) / 1000
+
+    @property
+    def datetime(self) -> datetime:
+        return datetime.fromtimestamp(self.timestamp)
+
+    @property
+    def seq_number(self) -> int:
+        return int(self.sid.split("-")[1])
+
+    @field_validator("stream", "text", mode="before")
+    @classmethod
+    def decode_bytes(cls, v: Any) -> str:
+        if isinstance(v, bytes):
+            return v.decode()
+        return v
+
+    def __str__(self):
+        fields = self.__class__.__pydantic_fields__
+        field_values = ", ".join(
+            f"{k}={repr(v)}" for k, v in self.model_dump().items() if fields[k].repr
+        )
+        return f"{self.__class__.__name__}({field_values})"

codeapi/types/_swarm.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import Literal
+
+import psutil
+from pydantic import BaseModel, Field
+
+
+class HiveHeartbeat(BaseModel):
+    hostname: str
+    host: str
+    timestamp: float
+    status: Literal["alive", "busy", "idle", "dead"]
+
+    cpu_count: int = Field(description="Number of CPU cores")
+    cpu_usage: float = Field(description="Current CPU usage percentage")
+
+    memory_total: float = Field(description="Total RAM in GB")
+    memory_used: float = Field(description="Used RAM in GB")
+    memory_free: float = Field(description="Free RAM in GB")
+    memory_usage: float = Field(description="Memory usage percentage")
+
+    disk_total: float = Field(description="Total disk space in GB")
+    disk_used: float = Field(description="Used disk space in GB")
+    disk_free: float = Field(description="Free disk space in GB")
+    disk_usage: float = Field(description="Disk usage percentage")
+
+    load_avg_1min: float | None = Field(
+        default=None, description="1-minute load average"
+    )
+    load_avg_5min: float | None = Field(
+        default=None, description="5-minute load average"
+    )
+    load_avg_15min: float | None = Field(
+        default=None, description="15-minute load average"
+    )
+
+    @classmethod
+    def create(
+        cls,
+        hostname: str,
+        host: str,
+        timestamp: float,
+        status: Literal["alive", "busy", "idle", "dead"],
+    ) -> HiveHeartbeat:
+        cpu_usage = psutil.cpu_percent(interval=1)
+        memory = psutil.virtual_memory()
+        disk = psutil.disk_usage("/")
+
+        try:
+            load_avg = psutil.getloadavg()
+            load_1, load_5, load_15 = load_avg
+        except (AttributeError, OSError):
+            load_1 = load_5 = load_15 = None
+
+        return cls(
+            hostname=hostname,
+            host=host,
+            timestamp=timestamp,
+            status=status,
+            cpu_count=psutil.cpu_count(),
+            cpu_usage=cpu_usage,
+            memory_total=memory.total / (1024**3),
+            memory_used=memory.used / (1024**3),
+            memory_free=memory.available / (1024**3),
+            memory_usage=memory.percent,
+            disk_total=disk.total / (1024**3),
+            disk_used=disk.used / (1024**3),
+            disk_free=disk.free / (1024**3),
+            disk_usage=disk.percent,
+            load_avg_1min=load_1,
+            load_avg_5min=load_5,
+            load_avg_15min=load_15,
+        )
+
+
+class SwarmStats(BaseModel):
+    total_hives: int = 0
+    active_hives: int = 0
+    busy_hives: int = 0
+    idle_hives: int = 0
+    total_cpu_cores: int = 0
+    avg_cpu_usage: float = 0.0
+    total_memory_gb: float = 0.0
+    avg_memory_usage: float = 0.0

codeapi/types/_time.py

@@ -0,0 +1,46 @@
+from enum import IntEnum
+
+
+class T_SECONDS(IntEnum):
+    ONE_MINUTE = 60
+    ONE_HOUR = 3600
+    ONE_DAY = 86400
+    ONE_WEEK = 604800
+    TWO_WEEKS = 1209600
+    FOUR_WEEKS = 2419200
+    SIX_WEEKS = 3628800
+    ONE_MONTH = 2592000
+    THREE_MONTHS = 7776000
+    SIX_MONTHS = 15552000
+    ONE_YEAR = 31536000
+    TEN_YEARS = 315360000
+    INFINITE = 2147483647
+
+
+class T_MINUTES(IntEnum):
+    ONE_HOUR = 60
+    ONE_DAY = 1440
+    ONE_WEEK = 10080
+    TWO_WEEKS = 20160
+    FOUR_WEEKS = 40320
+    SIX_WEEKS = 60480
+    ONE_MONTH = 43200
+    THREE_MONTHS = 129600
+    SIX_MONTHS = 259200
+    ONE_YEAR = 525600
+    TEN_YEARS = 5256000
+    INFINITE = 2147483647
+
+
+class T_HOURS(IntEnum):
+    ONE_DAY = 24
+    ONE_WEEK = 168
+    TWO_WEEKS = 336
+    FOUR_WEEKS = 672
+    SIX_WEEKS = 1008
+    ONE_MONTH = 720
+    THREE_MONTHS = 2160
+    SIX_MONTHS = 4320
+    ONE_YEAR = 8760
+    TEN_YEARS = 87600
+    INFINITE = 2147483647