skillforge-client 0.3.0__py3-none-any.whl

skillforge_client/models/job_detail.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.job_status import JobStatus
+
+if TYPE_CHECKING:
+    from ..models.job_detail_payload import JobDetailPayload
+
+
+T = TypeVar("T", bound="JobDetail")
+
+
+@_attrs_define
+class JobDetail:
+    """Full read view of a single job, including its ``payload``.
+
+    Attributes:
+        attempt (int):
+        available_at (datetime.datetime):
+        claimed_at (datetime.datetime | None):
+        claimed_by (None | str):
+        completed_at (datetime.datetime | None):
+        created_at (datetime.datetime):
+        failed_at (datetime.datetime | None):
+        job_id (UUID):
+        kind (str):
+        last_error (None | str):
+        max_attempts (int):
+        payload (JobDetailPayload):
+        status (JobStatus):
+        updated_at (datetime.datetime):
+    """
+
+    attempt: int
+    available_at: datetime.datetime
+    claimed_at: datetime.datetime | None
+    claimed_by: None | str
+    completed_at: datetime.datetime | None
+    created_at: datetime.datetime
+    failed_at: datetime.datetime | None
+    job_id: UUID
+    kind: str
+    last_error: None | str
+    max_attempts: int
+    payload: JobDetailPayload
+    status: JobStatus
+    updated_at: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        attempt = self.attempt
+
+        available_at = self.available_at.isoformat()
+
+        claimed_at: None | str
+        if isinstance(self.claimed_at, datetime.datetime):
+            claimed_at = self.claimed_at.isoformat()
+        else:
+            claimed_at = self.claimed_at
+
+        claimed_by: None | str
+        claimed_by = self.claimed_by
+
+        completed_at: None | str
+        if isinstance(self.completed_at, datetime.datetime):
+            completed_at = self.completed_at.isoformat()
+        else:
+            completed_at = self.completed_at
+
+        created_at = self.created_at.isoformat()
+
+        failed_at: None | str
+        if isinstance(self.failed_at, datetime.datetime):
+            failed_at = self.failed_at.isoformat()
+        else:
+            failed_at = self.failed_at
+
+        job_id = str(self.job_id)
+
+        kind = self.kind
+
+        last_error: None | str
+        last_error = self.last_error
+
+        max_attempts = self.max_attempts
+
+        payload = self.payload.to_dict()
+
+        status = self.status.value
+
+        updated_at = self.updated_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "attempt": attempt,
+                "available_at": available_at,
+                "claimed_at": claimed_at,
+                "claimed_by": claimed_by,
+                "completed_at": completed_at,
+                "created_at": created_at,
+                "failed_at": failed_at,
+                "job_id": job_id,
+                "kind": kind,
+                "last_error": last_error,
+                "max_attempts": max_attempts,
+                "payload": payload,
+                "status": status,
+                "updated_at": updated_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.job_detail_payload import JobDetailPayload
+
+        d = dict(src_dict)
+        attempt = d.pop("attempt")
+
+        available_at = datetime.datetime.fromisoformat(d.pop("available_at"))
+
+        def _parse_claimed_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                claimed_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return claimed_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        claimed_at = _parse_claimed_at(d.pop("claimed_at"))
+
+        def _parse_claimed_by(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        claimed_by = _parse_claimed_by(d.pop("claimed_by"))
+
+        def _parse_completed_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                completed_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return completed_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        completed_at = _parse_completed_at(d.pop("completed_at"))
+
+        created_at = datetime.datetime.fromisoformat(d.pop("created_at"))
+
+        def _parse_failed_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                failed_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return failed_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        failed_at = _parse_failed_at(d.pop("failed_at"))
+
+        job_id = UUID(d.pop("job_id"))
+
+        kind = d.pop("kind")
+
+        def _parse_last_error(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        last_error = _parse_last_error(d.pop("last_error"))
+
+        max_attempts = d.pop("max_attempts")
+
+        payload = JobDetailPayload.from_dict(d.pop("payload"))
+
+        status = JobStatus(d.pop("status"))
+
+        updated_at = datetime.datetime.fromisoformat(d.pop("updated_at"))
+
+        job_detail = cls(
+            attempt=attempt,
+            available_at=available_at,
+            claimed_at=claimed_at,
+            claimed_by=claimed_by,
+            completed_at=completed_at,
+            created_at=created_at,
+            failed_at=failed_at,
+            job_id=job_id,
+            kind=kind,
+            last_error=last_error,
+            max_attempts=max_attempts,
+            payload=payload,
+            status=status,
+            updated_at=updated_at,
+        )
+
+        job_detail.additional_properties = d
+        return job_detail
+
+    @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

skillforge_client/models/job_detail_payload.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="JobDetailPayload")
+
+
+@_attrs_define
+class JobDetailPayload:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        job_detail_payload = cls()
+
+        job_detail_payload.additional_properties = d
+        return job_detail_payload
+
+    @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

skillforge_client/models/job_fail_request.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="JobFailRequest")
+
+
+@_attrs_define
+class JobFailRequest:
+    """
+    Attributes:
+        error (None | str | Unset):
+        retry (bool | Unset):  Default: False.
+    """
+
+    error: None | str | Unset = UNSET
+    retry: bool | Unset = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error: None | str | Unset
+        if isinstance(self.error, Unset):
+            error = UNSET
+        else:
+            error = self.error
+
+        retry = self.retry
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if error is not UNSET:
+            field_dict["error"] = error
+        if retry is not UNSET:
+            field_dict["retry"] = retry
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_error(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        error = _parse_error(d.pop("error", UNSET))
+
+        retry = d.pop("retry", UNSET)
+
+        job_fail_request = cls(
+            error=error,
+            retry=retry,
+        )
+
+        job_fail_request.additional_properties = d
+        return job_fail_request
+
+    @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

skillforge_client/models/job_kind_counts.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.job_status_counts import JobStatusCounts
+
+
+T = TypeVar("T", bound="JobKindCounts")
+
+
+@_attrs_define
+class JobKindCounts:
+    """Queue funnel for a single job kind: depth (``total``/``open``) and the status breakdown.
+
+    Attributes:
+        kind (str):
+        open_ (int):
+        statuses (JobStatusCounts): Job counts for every status in the queue funnel, zero-filled (no silent gaps).
+        total (int):
+    """
+
+    kind: str
+    open_: int
+    statuses: JobStatusCounts
+    total: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        kind = self.kind
+
+        open_ = self.open_
+
+        statuses = self.statuses.to_dict()
+
+        total = self.total
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "kind": kind,
+                "open": open_,
+                "statuses": statuses,
+                "total": total,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.job_status_counts import JobStatusCounts
+
+        d = dict(src_dict)
+        kind = d.pop("kind")
+
+        open_ = d.pop("open")
+
+        statuses = JobStatusCounts.from_dict(d.pop("statuses"))
+
+        total = d.pop("total")
+
+        job_kind_counts = cls(
+            kind=kind,
+            open_=open_,
+            statuses=statuses,
+            total=total,
+        )
+
+        job_kind_counts.additional_properties = d
+        return job_kind_counts
+
+    @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

skillforge_client/models/job_list_item.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.job_status import JobStatus
+
+T = TypeVar("T", bound="JobListItem")
+
+
+@_attrs_define
+class JobListItem:
+    """List view of a job. Omits the ``payload`` -- fetch a single job by id for that.
+
+    Attributes:
+        attempt (int):
+        available_at (datetime.datetime):
+        claimed_at (datetime.datetime | None):
+        claimed_by (None | str):
+        completed_at (datetime.datetime | None):
+        created_at (datetime.datetime):
+        failed_at (datetime.datetime | None):
+        job_id (UUID):
+        kind (str):
+        last_error (None | str):
+        max_attempts (int):
+        status (JobStatus):
+        updated_at (datetime.datetime):
+    """
+
+    attempt: int
+    available_at: datetime.datetime
+    claimed_at: datetime.datetime | None
+    claimed_by: None | str
+    completed_at: datetime.datetime | None
+    created_at: datetime.datetime
+    failed_at: datetime.datetime | None
+    job_id: UUID
+    kind: str
+    last_error: None | str
+    max_attempts: int
+    status: JobStatus
+    updated_at: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        attempt = self.attempt
+
+        available_at = self.available_at.isoformat()
+
+        claimed_at: None | str
+        if isinstance(self.claimed_at, datetime.datetime):
+            claimed_at = self.claimed_at.isoformat()
+        else:
+            claimed_at = self.claimed_at
+
+        claimed_by: None | str
+        claimed_by = self.claimed_by
+
+        completed_at: None | str
+        if isinstance(self.completed_at, datetime.datetime):
+            completed_at = self.completed_at.isoformat()
+        else:
+            completed_at = self.completed_at
+
+        created_at = self.created_at.isoformat()
+
+        failed_at: None | str
+        if isinstance(self.failed_at, datetime.datetime):
+            failed_at = self.failed_at.isoformat()
+        else:
+            failed_at = self.failed_at
+
+        job_id = str(self.job_id)
+
+        kind = self.kind
+
+        last_error: None | str
+        last_error = self.last_error
+
+        max_attempts = self.max_attempts
+
+        status = self.status.value
+
+        updated_at = self.updated_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "attempt": attempt,
+                "available_at": available_at,
+                "claimed_at": claimed_at,
+                "claimed_by": claimed_by,
+                "completed_at": completed_at,
+                "created_at": created_at,
+                "failed_at": failed_at,
+                "job_id": job_id,
+                "kind": kind,
+                "last_error": last_error,
+                "max_attempts": max_attempts,
+                "status": status,
+                "updated_at": updated_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        attempt = d.pop("attempt")
+
+        available_at = datetime.datetime.fromisoformat(d.pop("available_at"))
+
+        def _parse_claimed_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                claimed_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return claimed_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        claimed_at = _parse_claimed_at(d.pop("claimed_at"))
+
+        def _parse_claimed_by(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        claimed_by = _parse_claimed_by(d.pop("claimed_by"))
+
+        def _parse_completed_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                completed_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return completed_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        completed_at = _parse_completed_at(d.pop("completed_at"))
+
+        created_at = datetime.datetime.fromisoformat(d.pop("created_at"))
+
+        def _parse_failed_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                failed_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return failed_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        failed_at = _parse_failed_at(d.pop("failed_at"))
+
+        job_id = UUID(d.pop("job_id"))
+
+        kind = d.pop("kind")
+
+        def _parse_last_error(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        last_error = _parse_last_error(d.pop("last_error"))
+
+        max_attempts = d.pop("max_attempts")
+
+        status = JobStatus(d.pop("status"))
+
+        updated_at = datetime.datetime.fromisoformat(d.pop("updated_at"))
+
+        job_list_item = cls(
+            attempt=attempt,
+            available_at=available_at,
+            claimed_at=claimed_at,
+            claimed_by=claimed_by,
+            completed_at=completed_at,
+            created_at=created_at,
+            failed_at=failed_at,
+            job_id=job_id,
+            kind=kind,
+            last_error=last_error,
+            max_attempts=max_attempts,
+            status=status,
+            updated_at=updated_at,
+        )
+
+        job_list_item.additional_properties = d
+        return job_list_item
+
+    @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