skillforge-client 0.3.0__py3-none-any.whl

skillforge_client/models/authorization_check_response.py

@@ -0,0 +1,61 @@
+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="AuthorizationCheckResponse")
+
+
+@_attrs_define
+class AuthorizationCheckResponse:
+    """
+    Attributes:
+        allowed (bool):
+    """
+
+    allowed: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        allowed = self.allowed
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "allowed": allowed,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        allowed = d.pop("allowed")
+
+        authorization_check_response = cls(
+            allowed=allowed,
+        )
+
+        authorization_check_response.additional_properties = d
+        return authorization_check_response
+
+    @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/body_create_token_api_v1_auth_token_post.py

@@ -0,0 +1,123 @@
+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="BodyCreateTokenApiV1AuthTokenPost")
+
+
+@_attrs_define
+class BodyCreateTokenApiV1AuthTokenPost:
+    """
+    Attributes:
+        grant_type (str):
+        client_id (None | str | Unset):
+        client_secret (None | str | Unset):
+        scope (None | str | Unset):
+    """
+
+    grant_type: str
+    client_id: None | str | Unset = UNSET
+    client_secret: None | str | Unset = UNSET
+    scope: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        grant_type = self.grant_type
+
+        client_id: None | str | Unset
+        if isinstance(self.client_id, Unset):
+            client_id = UNSET
+        else:
+            client_id = self.client_id
+
+        client_secret: None | str | Unset
+        if isinstance(self.client_secret, Unset):
+            client_secret = UNSET
+        else:
+            client_secret = self.client_secret
+
+        scope: None | str | Unset
+        if isinstance(self.scope, Unset):
+            scope = UNSET
+        else:
+            scope = self.scope
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "grant_type": grant_type,
+            }
+        )
+        if client_id is not UNSET:
+            field_dict["client_id"] = client_id
+        if client_secret is not UNSET:
+            field_dict["client_secret"] = client_secret
+        if scope is not UNSET:
+            field_dict["scope"] = scope
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        grant_type = d.pop("grant_type")
+
+        def _parse_client_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        client_id = _parse_client_id(d.pop("client_id", UNSET))
+
+        def _parse_client_secret(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        client_secret = _parse_client_secret(d.pop("client_secret", UNSET))
+
+        def _parse_scope(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        scope = _parse_scope(d.pop("scope", UNSET))
+
+        body_create_token_api_v1_auth_token_post = cls(
+            grant_type=grant_type,
+            client_id=client_id,
+            client_secret=client_secret,
+            scope=scope,
+        )
+
+        body_create_token_api_v1_auth_token_post.additional_properties = d
+        return body_create_token_api_v1_auth_token_post
+
+    @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/bot_job.py

@@ -0,0 +1,119 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.bot_job_payload import BotJobPayload
+
+
+T = TypeVar("T", bound="BotJob")
+
+
+@_attrs_define
+class BotJob:
+    """Processing view returned when a job is claimed.
+
+    Attributes:
+        attempt (int):
+        claimed_at (datetime.datetime | None):
+        job_id (UUID):
+        kind (str):
+        payload (BotJobPayload):
+    """
+
+    attempt: int
+    claimed_at: datetime.datetime | None
+    job_id: UUID
+    kind: str
+    payload: BotJobPayload
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        attempt = self.attempt
+
+        claimed_at: None | str
+        if isinstance(self.claimed_at, datetime.datetime):
+            claimed_at = self.claimed_at.isoformat()
+        else:
+            claimed_at = self.claimed_at
+
+        job_id = str(self.job_id)
+
+        kind = self.kind
+
+        payload = self.payload.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "attempt": attempt,
+                "claimed_at": claimed_at,
+                "job_id": job_id,
+                "kind": kind,
+                "payload": payload,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.bot_job_payload import BotJobPayload
+
+        d = dict(src_dict)
+        attempt = d.pop("attempt")
+
+        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"))
+
+        job_id = UUID(d.pop("job_id"))
+
+        kind = d.pop("kind")
+
+        payload = BotJobPayload.from_dict(d.pop("payload"))
+
+        bot_job = cls(
+            attempt=attempt,
+            claimed_at=claimed_at,
+            job_id=job_id,
+            kind=kind,
+            payload=payload,
+        )
+
+        bot_job.additional_properties = d
+        return bot_job
+
+    @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/bot_job_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="BotJobPayload")
+
+
+@_attrs_define
+class BotJobPayload:
+    """ """
+
+    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)
+        bot_job_payload = cls()
+
+        bot_job_payload.additional_properties = d
+        return bot_job_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/bot_principal.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.member_role import MemberRole
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.operational_profile import OperationalProfile
+
+
+T = TypeVar("T", bound="BotPrincipal")
+
+
+@_attrs_define
+class BotPrincipal:
+    """
+    Attributes:
+        active (bool):
+        discord_id (int):
+        display_name (str):
+        role (MemberRole):
+        groups (list[str] | Unset):
+        permissions (list[str] | Unset):
+        profile (None | OperationalProfile | Unset):
+    """
+
+    active: bool
+    discord_id: int
+    display_name: str
+    role: MemberRole
+    groups: list[str] | Unset = UNSET
+    permissions: list[str] | Unset = UNSET
+    profile: None | OperationalProfile | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.operational_profile import OperationalProfile
+
+        active = self.active
+
+        discord_id = self.discord_id
+
+        display_name = self.display_name
+
+        role = self.role.value
+
+        groups: list[str] | Unset = UNSET
+        if not isinstance(self.groups, Unset):
+            groups = self.groups
+
+        permissions: list[str] | Unset = UNSET
+        if not isinstance(self.permissions, Unset):
+            permissions = self.permissions
+
+        profile: dict[str, Any] | None | Unset
+        if isinstance(self.profile, Unset):
+            profile = UNSET
+        elif isinstance(self.profile, OperationalProfile):
+            profile = self.profile.to_dict()
+        else:
+            profile = self.profile
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "active": active,
+                "discord_id": discord_id,
+                "display_name": display_name,
+                "role": role,
+            }
+        )
+        if groups is not UNSET:
+            field_dict["groups"] = groups
+        if permissions is not UNSET:
+            field_dict["permissions"] = permissions
+        if profile is not UNSET:
+            field_dict["profile"] = profile
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.operational_profile import OperationalProfile
+
+        d = dict(src_dict)
+        active = d.pop("active")
+
+        discord_id = d.pop("discord_id")
+
+        display_name = d.pop("display_name")
+
+        role = MemberRole(d.pop("role"))
+
+        groups = cast(list[str], d.pop("groups", UNSET))
+
+        permissions = cast(list[str], d.pop("permissions", UNSET))
+
+        def _parse_profile(data: object) -> None | OperationalProfile | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                profile_type_0 = OperationalProfile.from_dict(data)
+
+                return profile_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | OperationalProfile | Unset, data)
+
+        profile = _parse_profile(d.pop("profile", UNSET))
+
+        bot_principal = cls(
+            active=active,
+            discord_id=discord_id,
+            display_name=display_name,
+            role=role,
+            groups=groups,
+            permissions=permissions,
+            profile=profile,
+        )
+
+        bot_principal.additional_properties = d
+        return bot_principal
+
+    @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/command_env_channel_response.py

@@ -0,0 +1,100 @@
+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 ..models.command_env_kind import CommandEnvKind
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CommandEnvChannelResponse")
+
+
+@_attrs_define
+class CommandEnvChannelResponse:
+    """
+    Attributes:
+        channel_id (int):
+        guild_id (int):
+        kind (CommandEnvKind):
+        owner_discord_id (int | None | Unset):
+    """
+
+    channel_id: int
+    guild_id: int
+    kind: CommandEnvKind
+    owner_discord_id: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        channel_id = self.channel_id
+
+        guild_id = self.guild_id
+
+        kind = self.kind.value
+
+        owner_discord_id: int | None | Unset
+        if isinstance(self.owner_discord_id, Unset):
+            owner_discord_id = UNSET
+        else:
+            owner_discord_id = self.owner_discord_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "channel_id": channel_id,
+                "guild_id": guild_id,
+                "kind": kind,
+            }
+        )
+        if owner_discord_id is not UNSET:
+            field_dict["owner_discord_id"] = owner_discord_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        channel_id = d.pop("channel_id")
+
+        guild_id = d.pop("guild_id")
+
+        kind = CommandEnvKind(d.pop("kind"))
+
+        def _parse_owner_discord_id(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        owner_discord_id = _parse_owner_discord_id(d.pop("owner_discord_id", UNSET))
+
+        command_env_channel_response = cls(
+            channel_id=channel_id,
+            guild_id=guild_id,
+            kind=kind,
+            owner_discord_id=owner_discord_id,
+        )
+
+        command_env_channel_response.additional_properties = d
+        return command_env_channel_response
+
+    @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/command_env_kind.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class CommandEnvKind(str, Enum):
+    ADMIN_CMD = "admin_cmd"
+    TUTOR_CMD = "tutor_cmd"
+
+    def __str__(self) -> str:
+        return str(self.value)

skillforge_client/models/command_env_upsert_request.py

@@ -0,0 +1,100 @@
+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 ..models.command_env_kind import CommandEnvKind
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CommandEnvUpsertRequest")
+
+
+@_attrs_define
+class CommandEnvUpsertRequest:
+    """
+    Attributes:
+        channel_id (int):
+        guild_id (int):
+        kind (CommandEnvKind):
+        owner_discord_id (int | None | Unset):
+    """
+
+    channel_id: int
+    guild_id: int
+    kind: CommandEnvKind
+    owner_discord_id: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        channel_id = self.channel_id
+
+        guild_id = self.guild_id
+
+        kind = self.kind.value
+
+        owner_discord_id: int | None | Unset
+        if isinstance(self.owner_discord_id, Unset):
+            owner_discord_id = UNSET
+        else:
+            owner_discord_id = self.owner_discord_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "channel_id": channel_id,
+                "guild_id": guild_id,
+                "kind": kind,
+            }
+        )
+        if owner_discord_id is not UNSET:
+            field_dict["owner_discord_id"] = owner_discord_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        channel_id = d.pop("channel_id")
+
+        guild_id = d.pop("guild_id")
+
+        kind = CommandEnvKind(d.pop("kind"))
+
+        def _parse_owner_discord_id(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        owner_discord_id = _parse_owner_discord_id(d.pop("owner_discord_id", UNSET))
+
+        command_env_upsert_request = cls(
+            channel_id=channel_id,
+            guild_id=guild_id,
+            kind=kind,
+            owner_discord_id=owner_discord_id,
+        )
+
+        command_env_upsert_request.additional_properties = d
+        return command_env_upsert_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