PyHiveLMS 1.0.0__py3-none-any.whl

pyhive/src/types/enums/sync_status_enum.py

@@ -0,0 +1,15 @@
+"""Enumeration for synchronization status (auto-generated)."""
+
+from enum import Enum
+
+
+class SyncStatusEnum(str, Enum):
+    """Enumeration of possible synchronization statuses."""
+
+    CREATING = "Creating"
+    DELETING = "Deleting"
+    ERROR = "Error"
+    NORMAL = "Normal"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/visibility_enum.py

@@ -0,0 +1,14 @@
+"""Enumeration for visibility levels of help requests."""
+
+from enum import Enum
+
+
+class VisibilityEnum(str, Enum):
+    """Enumeration of visibility levels for help requests."""
+
+    ALL_STAFF = "All Staff"
+    ALL_STAFF_AND_CHECKERS = "All Staff And Checkers"
+    AUTHOR_ONLY = "Author Only"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/event.py

@@ -0,0 +1,140 @@
+"""Model definition for calendar events in the Hive system.
+
+Represents a scheduled item such as a lecture, workshop, or PATBAS session,
+including timing, participants, subject, and related module.
+"""
+
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar, cast
+
+from attrs import define
+from dateutil.parser import isoparse
+from .common import UNSET, Unset
+from .core_item import HiveCoreItem
+from .enums.event_type_enum import EventTypeEnum
+
+if TYPE_CHECKING:
+    from ...client import HiveClient
+    from .event_attendees_type_0_item import EventAttendeesType0Item
+
+T = TypeVar("T", bound="Event")
+
+
+@define
+class Event(HiveCoreItem):
+    """Calendar event model.
+
+    Attributes:
+        start: Event start datetime (ISO 8601).
+        end: Event end datetime.
+        title: Optional title.
+        attendees: Optional list of attendees.
+        subject_id: Optional related subject ID.
+        subject_name: Optional subject display name.
+        color: Optional display color for UI.
+        type_: Event type (e.g. Patbas, Lecture).
+        module_id: Optional associated module ID.
+        lesson_name: Optional lesson name.
+        location: Optional physical or virtual location.
+
+    """
+
+    start: datetime.datetime
+    end: datetime.datetime
+    title: None | str
+    attendees: None | list["EventAttendeesType0Item"]
+    subject_id: None | int
+    subject_name: None | str
+    color: None | str
+    type_: EventTypeEnum
+    module_id: None | int
+    lesson_name: None | str
+    location: None | Unset | str = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        start = self.start.isoformat()
+        end = self.end.isoformat()
+
+        attendees: None | list[dict[str, Any]]
+        attendees = (
+            [a.to_dict() for a in self.attendees]
+            if isinstance(self.attendees, list)
+            else self.attendees
+        )
+
+        location = UNSET if isinstance(self.location, Unset) else self.location
+
+        field_dict: dict[str, Any] = {
+            "start": start,
+            "end": end,
+            "title": self.title,
+            "attendees": attendees,
+            "subject_id": self.subject_id,
+            "subject_name": self.subject_name,
+            "color": self.color,
+            "type": self.type_.value,
+            "module_id": self.module_id,
+            "lesson_name": self.lesson_name,
+        }
+
+        if location is not UNSET:
+            field_dict["location"] = location
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any], hive_client: "HiveClient") -> Self:
+        from .event_attendees_type_0_item import EventAttendeesType0Item  # pylint: disable=import-outside-toplevel
+
+        d = dict(src_dict)
+
+        def _parse_optional_str(data: object) -> None | str:
+            return data if data is None else cast("str", data)
+
+        def _parse_optional_int(data: object) -> None | int:
+            return data if data is None else cast("int", data)
+
+        def _parse_optional_list(data: object) -> None | list[EventAttendeesType0Item]:
+            if data is None:
+                return None
+            try:
+                return [EventAttendeesType0Item.from_dict(item, hive_client=hive_client) for item in data]
+            except Exception: # pylint: disable=broad-except
+                return cast("None | list[EventAttendeesType0Item]", data)
+
+        def _parse_optional_unset_str(data: object) -> None | Unset | str:
+            if data is None or isinstance(data, Unset):
+                return data
+            return cast("str", data)
+
+        return cls(
+            start=isoparse(d.pop("start")),
+            end=isoparse(d.pop("end")),
+            title=_parse_optional_str(d.pop("title")),
+            attendees=_parse_optional_list(d.pop("attendees")),
+            subject_id=_parse_optional_int(d.pop("subject_id")),
+            subject_name=_parse_optional_str(d.pop("subject_name")),
+            color=_parse_optional_str(d.pop("color")),
+            type_=EventTypeEnum(d.pop("type")),
+            module_id=_parse_optional_int(d.pop("module_id")),
+            lesson_name=_parse_optional_str(d.pop("lesson_name")),
+            location=_parse_optional_unset_str(d.pop("location", UNSET)),
+        )
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, Event):
+            return False
+        return (
+            self.start == value.start
+            and self.end == value.end
+            and self.title == value.title
+            and self.attendees == value.attendees
+            and self.subject_id == value.subject_id
+            and self.subject_name == value.subject_name
+            and self.color == value.color
+            and self.type_ == value.type_
+            and self.module_id == value.module_id
+            and self.lesson_name == value.lesson_name
+            and self.location == value.location
+        )

pyhive/src/types/event_attendees_type_0_item.py

@@ -0,0 +1,69 @@
+"""EventAttendeesType0Item type class module."""
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define
+
+from .core_item import HiveCoreItem
+from .common import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ...client import HiveClient
+
+T = TypeVar("T", bound="EventAttendeesType0Item")
+
+
+@define
+class EventAttendeesType0Item(HiveCoreItem):
+    """Attributes:
+    name (str):
+    id (int):
+    description (Union[Unset, str]):
+
+    """
+
+    hive_client: "HiveClient"
+    name: str
+    id: int
+    description: Unset | str = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        id = self.id
+
+        description = self.description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(
+            {
+                "name": name,
+                "id": id,
+            },
+        )
+        if description is not UNSET:
+            field_dict["description"] = description
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any], hive_client: "HiveClient") -> Self:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        id = d.pop("id")
+
+        description = d.pop("description", UNSET)
+
+        return cls(
+            name=name,
+            id=id,
+            description=description,
+            hive_client=hive_client,
+        )
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, EventAttendeesType0Item):
+            return False
+        return self.id == value.id

pyhive/src/types/event_color.py

@@ -0,0 +1,63 @@
+"""Module for EventColor type."""
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define
+from .core_item import HiveCoreItem
+
+if TYPE_CHECKING:
+    from ...client import HiveClient
+
+T = TypeVar("T", bound="EventColor")
+
+
+@define
+class EventColor(HiveCoreItem):
+    """Attributes:
+    id (int):
+    name (str):
+    color (str):
+
+    """
+
+    id: int
+    name: str
+    color: str
+    hive_client: "HiveClient"
+
+    def to_dict(self) -> dict[str, Any]:
+        """Converts the EventColor instance to a dictionary."""
+        id = self.id
+
+        name = self.name
+
+        color = self.color
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "color": color,
+            },
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any], hive_client: "HiveClient") -> Self:
+        """Creates an EventColor instance from a dictionary."""
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name = d.pop("name")
+
+        color = d.pop("color")
+
+        return cls(
+            id=id,
+            name=name,
+            color=color,
+            hive_client=hive_client,
+        )

pyhive/src/types/exercise.py

@@ -0,0 +1,216 @@
+"""Model for exercises in course modules."""
+
+from typing import Generator, TYPE_CHECKING, Any, Self, TypeVar, cast
+
+from attrs import define, field
+from .common import UNSET, Unset
+from .core_item import HiveCoreItem
+from .enums.exercise_patbas_enum import PatbasEnum
+from .enums.exercise_preview_types import ExercisePreviewTypes
+from .enums.sync_status_enum import SyncStatusEnum
+
+if TYPE_CHECKING:
+    from ...client import HiveClient
+    from .module import Module
+    from .subject import Subject
+    from .assignment import Assignment
+
+T = TypeVar("T", bound="Exercise")
+
+
+@define
+class Exercise(HiveCoreItem):
+    """Represents an exercise in a course module.
+
+    Attributes:
+        id: Unique exercise ID.
+        name: Exercise name.
+        parent_module_id: ID of the module the exercise belongs to.
+        parent_subject_id: ID of the subject the exercise belongs to.
+        parent_module_name: Name of the module.
+        parent_subject_symbol: Symbol of the subject.
+        parent_subject_color: Color tag of the subject.
+        download: Whether the exercise is downloadable.
+        preview: The preview method.
+        parent_subject_name: Name of the subject.
+        parent_module_order: Display order of the module.
+        order: Display order of the exercise.
+        tags: List of tag strings.
+        patbas: PATBAS mode.
+        sync_status: Synchronization status.
+        sync_message: Optional sync error message.
+        segel_path: Path to the exercise on the staff network.
+        patbas_preview: Optional preview type for PATBAS.
+        patbas_download: Whether PATBAS allows download.
+        is_lecture: Whether this is a lecture.
+        style: Optional style.
+        on_creation_data: Optional metadata used on creation.
+        autocheck_tag: Optional tag for auto-checking.
+        autodone: Whether it can be automatically marked done.
+        expected_duration: Optional string representing duration.
+        segel_brief: Optional brief description.
+
+    """
+
+    hive_client: "HiveClient"
+    id: int
+    name: str
+    parent_module_id: int
+    parent_subject_id: int
+    parent_module_name: str
+    parent_subject_symbol: str
+    parent_subject_color: str
+    download: bool
+    preview: ExercisePreviewTypes
+    parent_subject_name: str
+    parent_module_order: str
+    order: str
+    tags: list[str]
+    patbas: PatbasEnum
+    sync_status: SyncStatusEnum
+    sync_message: None | str
+    segel_path: str
+    patbas_preview: Unset | ExercisePreviewTypes = UNSET
+    patbas_download: Unset | bool = UNSET
+    is_lecture: Unset | bool = UNSET
+    style: None | Unset | str = UNSET
+    on_creation_data: Unset | Any = UNSET
+    autocheck_tag: None | Unset | str = UNSET
+    autodone: Unset | bool = UNSET
+    expected_duration: None | Unset | str = UNSET
+    segel_brief: Unset | str = UNSET
+
+    _parent_module: "Module | None" = field(init=False, default=None)
+    _parent_subject: "Subject | None" = field(init=False, default=None)
+
+    @property
+    def parent_module(self) -> "Module":
+        """Lazily load the module this exercise belongs to."""
+        if self._parent_module is None:
+            self._parent_module = self.hive_client.get_module(self.parent_module_id)
+        return self._parent_module
+
+    @property
+    def parent_subject(self) -> "Subject":
+        """Lazily load the subject this exercise belongs to."""
+        if self._parent_subject is None:
+            self._parent_subject = self.hive_client.get_subject(self.parent_subject_id)
+        return self._parent_subject
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize the Exercise to a dictionary."""
+        result: dict[str, Any] = {
+            "id": self.id,
+            "name": self.name,
+            "parent_module": self.parent_module_id,
+            "parent_subject": self.parent_subject_id,
+            "parent_module_name": self.parent_module_name,
+            "parent_subject_symbol": self.parent_subject_symbol,
+            "parent_subject_color": self.parent_subject_color,
+            "download": self.download,
+            "preview": self.preview.value,
+            "parent_subject_name": self.parent_subject_name,
+            "parent_module_order": self.parent_module_order,
+            "order": self.order,
+            "tags": self.tags,
+            "patbas": self.patbas.value,
+            "sync_status": self.sync_status.value,
+            "sync_message": self.sync_message,
+            "segel_path": self.segel_path,
+        }
+
+        if not isinstance(self.patbas_preview, Unset):
+            result["patbas_preview"] = self.patbas_preview.value
+        if not isinstance(self.patbas_download, Unset):
+            result["patbas_download"] = self.patbas_download
+        if not isinstance(self.is_lecture, Unset):
+            result["is_lecture"] = self.is_lecture
+        if not isinstance(self.style, Unset):
+            result["style"] = self.style
+        if not isinstance(self.on_creation_data, Unset):
+            result["on_creation_data"] = self.on_creation_data
+        if not isinstance(self.autocheck_tag, Unset):
+            result["autocheck_tag"] = self.autocheck_tag
+        if not isinstance(self.autodone, Unset):
+            result["autodone"] = self.autodone
+        if not isinstance(self.expected_duration, Unset):
+            result["expected_duration"] = self.expected_duration
+        if not isinstance(self.segel_brief, Unset):
+            result["segel_brief"] = self.segel_brief
+
+        return result
+
+    @classmethod
+    def from_dict(cls, src_dict: dict[str, Any], hive_client: "HiveClient") -> Self:
+        """Deserialize Exercise from dictionary."""
+        d = dict(src_dict)
+
+        return cls(
+            hive_client=hive_client,
+            id=d["id"],
+            name=d["name"],
+            parent_module_id=d["parent_module"],
+            parent_subject_id=d["parent_subject"],
+            parent_module_name=d["parent_module_name"],
+            parent_subject_symbol=d["parent_subject_symbol"],
+            parent_subject_color=d["parent_subject_color"],
+            download=d["download"],
+            preview=ExercisePreviewTypes(d["preview"]),
+            parent_subject_name=d["parent_subject_name"],
+            parent_module_order=d["parent_module_order"],
+            order=d["order"],
+            tags=cast("list[str]", d["tags"]),
+            patbas=PatbasEnum(d["patbas"]),
+            sync_status=SyncStatusEnum(d["sync_status"]),
+            sync_message=cast("str | None", d["sync_message"]),
+            segel_path=d["segel_path"],
+            patbas_preview=(
+                UNSET
+                if isinstance((val := d.get("patbas_preview", UNSET)), Unset)
+                else ExercisePreviewTypes(val)
+            ),
+            patbas_download=d.get("patbas_download", UNSET),
+            is_lecture=d.get("is_lecture", UNSET),
+            style=cast("str | None | Unset", d.get("style", UNSET)),
+            on_creation_data=d.get("on_creation_data", UNSET),
+            autocheck_tag=cast("str | None | Unset", d.get("autocheck_tag", UNSET)),
+            autodone=d.get("autodone", UNSET),
+            expected_duration=cast(
+                "str | None | Unset", d.get("expected_duration", UNSET)
+            ),
+            segel_brief=cast("str | Unset", d.get("segel_brief", UNSET)),
+        )
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, Exercise):
+            return False
+        return self.id == value.id and self.parent_module == value.parent_module
+
+    def __lt__(self, value: object) -> bool:
+        if not isinstance(value, Exercise):
+            return NotImplemented
+        return self.order < value.order
+
+    def get_assignments(self) -> Generator["Assignment", None, None]:
+        """Fetch all assignments associated with this exercise."""
+        return self.hive_client.get_assignments(
+            exercise__id=self.id,
+            exercise__parent_module__id=self.parent_module_id,
+            exercise__parent_module__parent_subject__id=self.parent_subject_id,
+        )
+
+    def __iter__(self) -> Generator["Assignment", None, None]:
+        """Allow iteration over this Exercise to yield its assignments."""
+        yield from self.get_assignments()
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.id,
+                self.parent_module_id,
+                self.parent_subject_id,
+            )
+        )
+
+
+ExerciseLike = TypeVar("ExerciseLike", Exercise, int)

pyhive/src/types/form_field.py

@@ -0,0 +1,152 @@
+"""Model definition for a form field used in questionnaires or structured input forms within Hive.
+
+Represents a field definition with constraints and metadata,
+including optional validation and visibility toggles.
+"""
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar, cast
+
+from attrs import define
+from attrs import field
+from .common import UNSET, Unset
+from .core_item import HiveCoreItem
+from .enums.form_field_type_enum import FormFieldTypeEnum
+
+if TYPE_CHECKING:
+    from ...client import HiveClient
+    from .program import Class
+
+T = TypeVar("T", bound="FormField")
+
+
+@define
+class FormField(HiveCoreItem):
+    """Represents a single field in a dynamic form.
+
+    Attributes:
+        id: Field ID.
+        name: Name of the field.
+        type_: Field type (e.g., text, number, multiple).
+        order: Position of the field in the form.
+        required: Whether this field must be filled out.
+        staff_responses: Whether staff members can respond.
+        hanich_responses: Whether students can respond.
+        has_value: Whether the field currently holds a value.
+        segel_only: Whether the field is visible only to Segel (staff).
+        description: Optional description of the field.
+        lower_limit: Optional lower numeric limit.
+        upper_limit: Optional upper numeric limit.
+        choices: Optional list of string choices (for multiple/multiResponse).
+        metadata: Additional arbitrary metadata for the field.
+        groups: Optional list of group IDs the field is associated with.
+
+    """
+
+    hive_client: "HiveClient"
+    id: int
+    name: str
+    type_: FormFieldTypeEnum
+    order: int
+    required: bool
+    staff_responses: bool
+    hanich_responses: bool
+    has_value: bool
+    segel_only: bool
+    description: Unset | str = UNSET
+    lower_limit: None | Unset | int = UNSET
+    upper_limit: None | Unset | int = UNSET
+    choices: None | Unset | list[str] = UNSET
+    metadata: Unset | Any = UNSET
+    group_ids: Unset | list[int] = UNSET
+    _groups: "list[Class] | None" = field(init=False, default=None)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "type": self.type_.value,
+            "order": self.order,
+            "required": self.required,
+            "staff_responses": self.staff_responses,
+            "hanich_responses": self.hanich_responses,
+            "has_value": self.has_value,
+            "segel_only": self.segel_only,
+            **(
+                {"description": self.description}
+                if self.description is not UNSET
+                else {}
+            ),
+            **(
+                {"lower_limit": self.lower_limit}
+                if self.lower_limit is not UNSET
+                else {}
+            ),
+            **(
+                {"upper_limit": self.upper_limit}
+                if self.upper_limit is not UNSET
+                else {}
+            ),
+            **({"choices": self.choices} if self.choices is not UNSET else {}),
+            **({"metadata": self.metadata} if self.metadata is not UNSET else {}),
+            **({"groups": self.group_ids} if self.group_ids is not UNSET else {}),
+        }
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any], hive_client: "HiveClient") -> Self:
+        d = dict(src_dict)
+
+        def _parse_optional_int(data: object) -> None | Unset | int:
+            if data is None or isinstance(data, Unset):
+                return data
+            return cast("int", data)
+
+        def _parse_choices(data: object) -> None | Unset | list[str]:
+            if data is None or isinstance(data, Unset):
+                return data
+            if not isinstance(data, list):
+                return UNSET
+            return cast("list[str]", data)
+
+        return cls(
+            hive_client=hive_client,
+            id=d.pop("id"),
+            name=d.pop("name"),
+            type_=FormFieldTypeEnum(d.pop("type")),
+            order=d.pop("order"),
+            required=d.pop("required"),
+            staff_responses=d.pop("staff_responses"),
+            hanich_responses=d.pop("hanich_responses"),
+            has_value=d.pop("has_value"),
+            segel_only=d.pop("segel_only"),
+            description=d.pop("description", UNSET),
+            lower_limit=_parse_optional_int(d.pop("lower_limit", UNSET)),
+            upper_limit=_parse_optional_int(d.pop("upper_limit", UNSET)),
+            choices=_parse_choices(d.pop("choices", UNSET)),
+            metadata=d.pop("metadata", UNSET),
+            group_ids=cast("Unset | list[int]", d.pop("groups", UNSET)),
+        )
+
+    @property
+    def groups(self) -> list["Class"]:
+        """Return the list of Classes which this field is relevant to."""
+        if isinstance(self.group_ids, Unset):
+            return []
+        if self._groups is None:
+            self._groups = [
+                self.hive_client.get_class(group_id) for group_id in self.group_ids
+            ]
+        return self._groups
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, FormField):
+            return False
+        return self.id == value.id
+
+    def __lt__(self, value: object) -> bool:
+        if not isinstance(value, FormField):
+            return NotImplemented
+        return self.order < value.order
+
+    def __hash__(self) -> int:
+        return hash((self.id,))