skillforge-client 0.3.0__py3-none-any.whl

skillforge_client/models/operational_profile.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.contact_info_profile import ContactInfoProfile
+    from ..models.external_accounts_profile import ExternalAccountsProfile
+    from ..models.person_profile import PersonProfile
+    from ..models.relation_profile import RelationProfile
+
+
+T = TypeVar("T", bound="OperationalProfile")
+
+
+@_attrs_define
+class OperationalProfile:
+    """Operational view of a party. Intentionally excludes billing/finance data.
+
+    Attributes:
+        party_id (UUID):
+        contact_infos (list[ContactInfoProfile] | Unset):
+        external_accounts (ExternalAccountsProfile | Unset):
+        person (None | PersonProfile | Unset):
+        relations (list[RelationProfile] | Unset):
+        subjects (list[str] | Unset):
+    """
+
+    party_id: UUID
+    contact_infos: list[ContactInfoProfile] | Unset = UNSET
+    external_accounts: ExternalAccountsProfile | Unset = UNSET
+    person: None | PersonProfile | Unset = UNSET
+    relations: list[RelationProfile] | Unset = UNSET
+    subjects: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.person_profile import PersonProfile
+
+        party_id = str(self.party_id)
+
+        contact_infos: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.contact_infos, Unset):
+            contact_infos = []
+            for contact_infos_item_data in self.contact_infos:
+                contact_infos_item = contact_infos_item_data.to_dict()
+                contact_infos.append(contact_infos_item)
+
+        external_accounts: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.external_accounts, Unset):
+            external_accounts = self.external_accounts.to_dict()
+
+        person: dict[str, Any] | None | Unset
+        if isinstance(self.person, Unset):
+            person = UNSET
+        elif isinstance(self.person, PersonProfile):
+            person = self.person.to_dict()
+        else:
+            person = self.person
+
+        relations: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.relations, Unset):
+            relations = []
+            for relations_item_data in self.relations:
+                relations_item = relations_item_data.to_dict()
+                relations.append(relations_item)
+
+        subjects: list[str] | Unset = UNSET
+        if not isinstance(self.subjects, Unset):
+            subjects = self.subjects
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "party_id": party_id,
+            }
+        )
+        if contact_infos is not UNSET:
+            field_dict["contact_infos"] = contact_infos
+        if external_accounts is not UNSET:
+            field_dict["external_accounts"] = external_accounts
+        if person is not UNSET:
+            field_dict["person"] = person
+        if relations is not UNSET:
+            field_dict["relations"] = relations
+        if subjects is not UNSET:
+            field_dict["subjects"] = subjects
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.contact_info_profile import ContactInfoProfile
+        from ..models.external_accounts_profile import ExternalAccountsProfile
+        from ..models.person_profile import PersonProfile
+        from ..models.relation_profile import RelationProfile
+
+        d = dict(src_dict)
+        party_id = UUID(d.pop("party_id"))
+
+        _contact_infos = d.pop("contact_infos", UNSET)
+        contact_infos: list[ContactInfoProfile] | Unset = UNSET
+        if _contact_infos is not UNSET:
+            contact_infos = []
+            for contact_infos_item_data in _contact_infos:
+                contact_infos_item = ContactInfoProfile.from_dict(contact_infos_item_data)
+
+                contact_infos.append(contact_infos_item)
+
+        _external_accounts = d.pop("external_accounts", UNSET)
+        external_accounts: ExternalAccountsProfile | Unset
+        if isinstance(_external_accounts, Unset):
+            external_accounts = UNSET
+        else:
+            external_accounts = ExternalAccountsProfile.from_dict(_external_accounts)
+
+        def _parse_person(data: object) -> None | PersonProfile | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                person_type_0 = PersonProfile.from_dict(data)
+
+                return person_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | PersonProfile | Unset, data)
+
+        person = _parse_person(d.pop("person", UNSET))
+
+        _relations = d.pop("relations", UNSET)
+        relations: list[RelationProfile] | Unset = UNSET
+        if _relations is not UNSET:
+            relations = []
+            for relations_item_data in _relations:
+                relations_item = RelationProfile.from_dict(relations_item_data)
+
+                relations.append(relations_item)
+
+        subjects = cast(list[str], d.pop("subjects", UNSET))
+
+        operational_profile = cls(
+            party_id=party_id,
+            contact_infos=contact_infos,
+            external_accounts=external_accounts,
+            person=person,
+            relations=relations,
+            subjects=subjects,
+        )
+
+        operational_profile.additional_properties = d
+        return operational_profile
+
+    @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/party_relation_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class PartyRelationType(str, Enum):
+    PARENT_OF = "parent_of"
+    PAYS_FOR = "pays_for"
+    TUTOR_OF = "tutor_of"
+
+    def __str__(self) -> str:
+        return str(self.value)

skillforge_client/models/person_profile.py

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

@@ -0,0 +1,84 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.bot_principal import BotPrincipal
+
+
+T = TypeVar("T", bound="PrincipalBatch")
+
+
+@_attrs_define
+class PrincipalBatch:
+    """Partial-result envelope: resolved principals plus the requested ids that did not resolve.
+
+    Attributes:
+        found (list[BotPrincipal]):
+        missing (list[int]):
+    """
+
+    found: list[BotPrincipal]
+    missing: list[int]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        found = []
+        for found_item_data in self.found:
+            found_item = found_item_data.to_dict()
+            found.append(found_item)
+
+        missing = self.missing
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "found": found,
+                "missing": missing,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.bot_principal import BotPrincipal
+
+        d = dict(src_dict)
+        found = []
+        _found = d.pop("found")
+        for found_item_data in _found:
+            found_item = BotPrincipal.from_dict(found_item_data)
+
+            found.append(found_item)
+
+        missing = cast(list[int], d.pop("missing"))
+
+        principal_batch = cls(
+            found=found,
+            missing=missing,
+        )
+
+        principal_batch.additional_properties = d
+        return principal_batch
+
+    @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/relation_profile.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.party_relation_type import PartyRelationType
+from ..models.relation_profile_direction import RelationProfileDirection
+
+T = TypeVar("T", bound="RelationProfile")
+
+
+@_attrs_define
+class RelationProfile:
+    """
+    Attributes:
+        counterparty_party_id (UUID):
+        direction (RelationProfileDirection):
+        type_ (PartyRelationType):
+    """
+
+    counterparty_party_id: UUID
+    direction: RelationProfileDirection
+    type_: PartyRelationType
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        counterparty_party_id = str(self.counterparty_party_id)
+
+        direction = self.direction.value
+
+        type_ = self.type_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "counterparty_party_id": counterparty_party_id,
+                "direction": direction,
+                "type": type_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        counterparty_party_id = UUID(d.pop("counterparty_party_id"))
+
+        direction = RelationProfileDirection(d.pop("direction"))
+
+        type_ = PartyRelationType(d.pop("type"))
+
+        relation_profile = cls(
+            counterparty_party_id=counterparty_party_id,
+            direction=direction,
+            type_=type_,
+        )
+
+        relation_profile.additional_properties = d
+        return relation_profile
+
+    @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/relation_profile_direction.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class RelationProfileDirection(str, Enum):
+    INCOMING = "incoming"
+    OUTGOING = "outgoing"
+
+    def __str__(self) -> str:
+        return str(self.value)

skillforge_client/models/student_activation_commit_request.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="StudentActivationCommitRequest")
+
+
+@_attrs_define
+class StudentActivationCommitRequest:
+    """
+    Attributes:
+        channel_id (int):
+    """
+
+    channel_id: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        channel_id = self.channel_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "channel_id": channel_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")
+
+        student_activation_commit_request = cls(
+            channel_id=channel_id,
+        )
+
+        student_activation_commit_request.additional_properties = d
+        return student_activation_commit_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/student_activation_prepare_request.py

@@ -0,0 +1,77 @@
+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="StudentActivationPrepareRequest")
+
+
+@_attrs_define
+class StudentActivationPrepareRequest:
+    """
+    Attributes:
+        guild_id (int):
+        student_discord_id (int):
+        tutor_discord_id (int):
+    """
+
+    guild_id: int
+    student_discord_id: int
+    tutor_discord_id: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        guild_id = self.guild_id
+
+        student_discord_id = self.student_discord_id
+
+        tutor_discord_id = self.tutor_discord_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "guild_id": guild_id,
+                "student_discord_id": student_discord_id,
+                "tutor_discord_id": tutor_discord_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        guild_id = d.pop("guild_id")
+
+        student_discord_id = d.pop("student_discord_id")
+
+        tutor_discord_id = d.pop("tutor_discord_id")
+
+        student_activation_prepare_request = cls(
+            guild_id=guild_id,
+            student_discord_id=student_discord_id,
+            tutor_discord_id=tutor_discord_id,
+        )
+
+        student_activation_prepare_request.additional_properties = d
+        return student_activation_prepare_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/student_channel_state.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class StudentChannelState(str, Enum):
+    ARCHIVE_CATEGORY = "archive_category"
+    TUTOR_CATEGORY = "tutor_category"
+
+    def __str__(self) -> str:
+        return str(self.value)