PyHiveLMS 1.0.0__py3-none-any.whl

pyhive/src/types/assignment_response_content.py

@@ -0,0 +1,131 @@
+"""AssignmentResponseContent type definition."""
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, TYPE_CHECKING
+from attrs import define, field as _attrs_field
+
+from .core_item import HiveCoreItem
+
+if TYPE_CHECKING:
+    from ...client import HiveClient
+    from .form_field import FormField
+    from .assignment import Assignment
+    from .assignment import AssignmentLike
+    from .assignment_response import AssignmentResponse
+
+T = TypeVar("T", bound="AssignmentResponseContent")
+
+
+@define
+class AssignmentResponseContent(HiveCoreItem):
+    """
+    Attributes:
+        content (str):
+        field_id (int):
+    """
+
+    hive_client: "HiveClient"
+    assignment_id: int
+    assignment_response_id: int
+    raw_content: str
+    field_id: int
+
+    # Lazy-loaded objects
+    _content: "str | int | list[str | int] | None" = _attrs_field(
+        init=False, default=None
+    )
+    _field: "FormField | None" = _attrs_field(init=False, default=None)
+    _assignment: "Assignment | None" = _attrs_field(init=False, default=None)
+    _assignment_response: "AssignmentResponse | None" = _attrs_field(
+        init=False, default=None
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+        raw_content = self.raw_content
+
+        field_id = self.field_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(
+            {
+                "content": raw_content,
+                "field": field_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(  # pylint: disable=arguments-differ
+        cls: type[T],
+        src_dict: Mapping[str, Any],
+        assignment: "AssignmentLike",
+        assignment_response_id: int,
+        hive_client: "HiveClient",
+    ) -> T:
+        d = dict(src_dict)
+        raw_content = d.pop("content")
+        field_id = d.pop("field")
+
+        return cls(
+            hive_client=hive_client,
+            assignment_id=(
+                assignment.id if isinstance(assignment, HiveCoreItem) else assignment
+            ),
+            assignment_response_id=assignment_response_id,
+            raw_content=raw_content,
+            field_id=field_id,
+        )
+
+    @property
+    def field(self) -> "FormField":
+        """Lazily load and return the field this assignment belongs to."""
+        if self._field is None:
+            self._field = self.hive_client.get_exercise_field(
+                exercise=self.assignment.exercise_id, field_id=self.field_id
+            )
+        return self._field
+
+    @property
+    def assignment(self) -> "Assignment":
+        """Lazily load and return the assignment this content belongs to."""
+        if self._assignment is None:
+            self._assignment = self.hive_client.get_assignment(
+                assignment_id=self.assignment_id
+            )
+        return self._assignment
+
+    @property
+    def assignment_response(self) -> "AssignmentResponse":
+        """Lazily load and return the assignment response this content belongs to."""
+        if self._assignment_response is None:
+            self._assignment_response = self.hive_client.get_assignment_response(
+                assignment=self.assignment_id,
+                response_id=self.assignment_response_id,
+            )
+        return self._assignment_response
+
+    @property
+    def content(self) -> "str | int | list[str | int]":
+        """Lazily parse and return the content based on the field type."""
+        from .enums.form_field_type_enum import (
+            FormFieldTypeEnum,
+        )  # pylint: disable=import-outside-toplevel
+
+        if self._content is None:
+            if self.field.type_ is FormFieldTypeEnum.NUMBER:
+                self._content = int(self.raw_content)
+            elif self.field.type_ is FormFieldTypeEnum.TEXT:
+                self._content = str(self.raw_content)
+            elif self.field.type_ is FormFieldTypeEnum.MULTIPLE:
+                self._content = self.field.choices[int(self.raw_content)]
+            elif self.field.type_ is FormFieldTypeEnum.MULTIRESPONSE:
+                self._content = list(
+                    self.field.choices[int(i)] for i in self.raw_content.split(",")
+                )
+            else:
+                raise ValueError(f"Unsupported form field type: {self.field.type_}")
+        return self._content
+
+    def __str__(self):
+        return str(self.content)

pyhive/src/types/autocheck_status.py

@@ -0,0 +1,94 @@
+"""AutoCheckStatus type definition."""
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast, TYPE_CHECKING
+from attrs import define
+from dateutil.parser import isoparse
+
+from .core_item import HiveCoreItem
+from .enums.action_enum import ActionEnum
+from .common import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ...client import HiveClient
+
+T = TypeVar("T", bound="AutoCheckStatus")
+
+
+@define
+class AutoCheckStatus(HiveCoreItem):
+    """
+
+    Attributes:
+        id (int):
+        time (datetime.datetime):
+        action (ActionEnum):
+            * `Handling` - Handling
+            * `No Check` - Nocheck
+            * `Built` - Built
+            * `Finished` - Finished
+            * `Sending` - Sending
+            * `Error` - Error
+            * `Success` - Success
+        payload (Union[None, Unset, str]):
+
+    """
+
+    hive_client: "HiveClient"
+    id: int
+    time: datetime.datetime
+    action: ActionEnum
+    payload: Union[None, Unset, str] = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+        time = self.time.isoformat()
+        action = self.action.value
+        payload: Union[None, Unset, str]
+
+        if isinstance(self.payload, Unset):
+            payload = UNSET
+        else:
+            payload = self.payload
+        field_dict: dict[str, Any] = {}
+        field_dict.update(
+            {
+                "id": id,
+                "time": time,
+                "action": action,
+            }
+        )
+
+        if payload is not UNSET:
+            field_dict["payload"] = payload
+
+        return field_dict
+
+    @classmethod
+    def from_dict(
+        cls: type[T],
+        src_dict: Mapping[str, Any],
+        hive_client: "HiveClient",
+    ) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+        time = isoparse(d.pop("time"))
+        action = ActionEnum(d.pop("action"))
+
+        def _parse_payload(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        payload = _parse_payload(d.pop("payload", UNSET))
+
+        return cls(
+            hive_client=hive_client,
+            id=id,
+            time=time,
+            action=action,
+            payload=payload,
+        )

pyhive/src/types/class_.py

@@ -0,0 +1,113 @@
+"""
+Defines the Class type representing a school class/group in a program,
+including serialization and lazy-loading of related objects.
+"""
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar, cast
+
+from attrs import define, field
+from .common import UNSET, Unset
+from .core_item import HiveCoreItem
+from .enums.class_type_enum import ClassTypeEnum
+
+if TYPE_CHECKING:
+    from ...client import HiveClient
+    from .program import Program
+    from .user import User
+
+T = TypeVar("T", bound="Class")
+
+
+@define
+class Class(HiveCoreItem):
+    """Represents a school class/group in a program.
+
+    Attributes:
+        id: Unique class ID.
+        name: Internal name.
+        display_name: Display name for UI.
+        program_id: ID of the associated program.
+        user_ids: List of user IDs assigned to this class.
+        program_name: Name of the program.
+        email: Optional class email address.
+        type_: Type of class, e.g., Room or Student Group.
+        description: Optional description text.
+
+    """
+
+    hive_client: "HiveClient"
+    id: int
+    name: str
+    display_name: str
+    program_id: int
+    user_ids: list[int]
+    program_name: str
+    email: Unset | str = UNSET
+    type_: Unset | ClassTypeEnum = UNSET
+    description: None | Unset | str = UNSET
+
+    # Lazy-loaded fields
+    _program: "Program | None" = field(init=False, default=None)
+    _users: "list[User] | None" = field(init=False, default=None)
+
+    @property
+    def program(self) -> "Program":
+        """Lazily load the associated Program object."""
+        if self._program is None:
+            self._program = self.hive_client.get_program(self.program_id)
+        return self._program
+
+    @property
+    def users(self) -> list["User"]:
+        """Lazily load the list of User objects in this class."""
+        if self._users is None:
+            self._users = [self.hive_client.get_user(uid) for uid in self.user_ids]
+        return self._users
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize Class to dictionary form."""
+        result: dict[str, Any] = {
+            "id": self.id,
+            "name": self.name,
+            "display_name": self.display_name,
+            "program": self.program_id,
+            "users": self.user_ids,
+            "program__name": self.program_name,
+        }
+
+        if not isinstance(self.email, Unset):
+            result["email"] = self.email
+        if not isinstance(self.type_, Unset):
+            result["type"] = self.type_.value
+        if not isinstance(self.description, Unset):
+            result["description"] = self.description
+
+        return result
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any], hive_client: "HiveClient") -> Self:
+        """Deserialize Class from dictionary form."""
+        d = dict(src_dict)
+
+        return cls(
+            hive_client=hive_client,
+            id=d["id"],
+            name=d["name"],
+            display_name=d["display_name"],
+            program_id=d["program"],
+            user_ids=cast("list[int]", d["users"]),
+            program_name=d["program__name"],
+            email=d.get("email", UNSET),
+            type_=(
+                UNSET
+                if isinstance((type_val := d.get("type", UNSET)), Unset)
+                else ClassTypeEnum(type_val)
+            ),
+            description=cast("None | Unset | str", d.get("description", UNSET)),
+        )
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, Class):
+            return False
+        return self.id == value.id and self.program_id == value.program_id

pyhive/src/types/common.py

@@ -0,0 +1,56 @@
+"""Contains some shared types for properties."""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, TypeVar, Union
+
+from attrs import define
+
+
+class Unset:  # pylint: disable=too-few-public-methods
+    """Sentinel type for unset optional values."""
+
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = Union[IO[bytes], bytes, str]
+FileTypes = Union[
+    # (filename, file (or bytes), content_type)
+    tuple[str | None, FileContent, str | None],
+    # (filename, file (or bytes), content_type, headers)
+    tuple[str | None, FileContent, str | None, Mapping[str, str]],
+]
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+    """Contains information for file uploads."""
+
+    payload: BinaryIO
+    file_name: str | None = None
+    mime_type: str | None = None
+
+    def to_tuple(self) -> FileTypes:
+        """Return a tuple representation that httpx will accept for multipart/form-data ."""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint."""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: T | None
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

pyhive/src/types/core_item.py

@@ -0,0 +1,22 @@
+"""Base class for Hive core items."""
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self
+
+if TYPE_CHECKING:
+    from ...client import HiveClient
+
+
+class HiveCoreItem:
+    """Base class for Hive core items."""
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize this HiveCoreItem instance to a plain dictionary."""
+        raise NotImplementedError
+
+    @classmethod
+    def from_dict(
+        cls, src_dict: Mapping[str, Any], hive_client: "HiveClient"
+    ) -> Self:  # noqa: D102
+        """Deserialize a HiveCoreItem instance from a mapping."""
+        raise NotImplementedError

pyhive/src/types/enums/action_enum.py

@@ -0,0 +1,18 @@
+"""Enumeration of possible action states for auto-tests."""
+
+from enum import Enum
+
+
+class ActionEnum(str, Enum):
+    """Enumeration of possible action states for auto-tests."""
+
+    BUILT = "Built"
+    ERROR = "Error"
+    FINISHED = "Finished"
+    HANDLING = "Handling"
+    NO_CHECK = "No Check"
+    SENDING = "Sending"
+    SUCCESS = "Success"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/assignment_response_type_enum.py

@@ -0,0 +1,17 @@
+"""Enumeration for Assignment Response Types."""
+
+from enum import Enum
+
+
+class AssignmentResponseTypeEnum(str, Enum):
+    """Enumeration of possible assignment response types."""
+
+    AUTOCHECK = "AutoCheck"
+    COMMENT = "Comment"
+    DONE = "Done"
+    REDO = "Redo"
+    SUBMISSION = "Submission"
+    WORK_IN_PROGRESS = "Work In Progress"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/assignment_status_enum.py

@@ -0,0 +1,17 @@
+"""Enumeration for assignment statuses (auto-generated)."""
+
+from enum import Enum
+
+
+class AssignmentStatusEnum(str, Enum):
+    """The status of an assignment."""
+
+    AUTOCHECKED = "AutoChecked"
+    DONE = "Done"
+    NEW = "New"
+    REDO = "Redo"
+    SUBMITTED = "Submitted"
+    WORK_IN_PROGRESS = "Work In Progress"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/class_type_enum.py

@@ -0,0 +1,13 @@
+"""Enumeration of class types."""
+
+from enum import Enum
+
+
+class ClassTypeEnum(str, Enum):
+    """Enumeration of class types."""
+
+    ROOM = "Room"
+    STUDENT_GROUP = "Student Group"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/clearance_enum.py

@@ -0,0 +1,16 @@
+"""Enumeration for user clearance levels."""
+
+from enum import IntEnum
+
+
+class ClearanceEnum(IntEnum):
+    """Enumeration of user clearance levels in the Hive system."""
+
+    # TODO: Replace VALUE_X with actual clearance level names
+    VALUE_1 = 1
+    VALUE_2 = 2
+    VALUE_3 = 3
+    VALUE_5 = 5
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/event_type_enum.py

@@ -0,0 +1,14 @@
+"""Enumeration for event types (auto-generated)."""
+
+from enum import Enum
+
+
+class EventTypeEnum(str, Enum):
+    """Enumeration of possible event types in the Hive system."""
+
+    הרצאה = "הרצאה"  # pylint: disable=non-ascii-name
+    עע = "עע"  # pylint: disable=non-ascii-name
+    פתבס = "פתבס"  # pylint: disable=non-ascii-name
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/exercise_patbas_enum.py

@@ -0,0 +1,15 @@
+"""Enumeration for PATBAS settings (auto-generated)."""
+
+from enum import Enum
+
+
+class PatbasEnum(str, Enum):
+    """PATBAS settings."""
+
+    ALWAYS = "Always"
+    NEVER = "Never"
+    ON_DONE = "On Done"
+    STAFF_ONLY = "Staff Only"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/exercise_preview_types.py

@@ -0,0 +1,15 @@
+"""Enumeration for exercise preview types.
+This is the document type of the instructions for an exercise (auto-generated)."""
+
+from enum import Enum
+
+
+class ExercisePreviewTypes(str, Enum):
+    """Exercise preview types."""
+
+    DISABLED = "Disabled"
+    MARKDOWN = "Markdown"
+    PDF = "PDF"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/form_field_type_enum.py

@@ -0,0 +1,15 @@
+"""Enumeration for form field types (auto-generated)."""
+
+from enum import Enum
+
+
+class FormFieldTypeEnum(str, Enum):
+    """Enumeration of possible form field types."""
+
+    MULTIPLE = "multiple"
+    MULTIRESPONSE = "multiResponse"
+    NUMBER = "number"
+    TEXT = "text"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/gender_enum.py

@@ -0,0 +1,14 @@
+"""Enumeration for gender types."""
+
+from enum import Enum
+
+
+class GenderEnum(str, Enum):
+    """Enumeration of gender types."""
+
+    FEMALE = "Female"
+    MALE = "Male"
+    NONBINARY = "NonBinary"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/help_response_type_enum.py

@@ -0,0 +1,14 @@
+"""Enumeration for help response types (auto-generated)."""
+
+from enum import Enum
+
+
+class HelpResponseTypeEnum(str, Enum):
+    """Enumeration of possible help response types."""
+
+    COMMENT = "Comment"
+    OPEN = "Open"
+    RESOLVE = "Resolve"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/help_status_enum.py

@@ -0,0 +1,13 @@
+"""Help Status Enum"""
+
+from enum import Enum
+
+
+class HelpStatusEnum(str, Enum):
+    """Help Status Enum"""
+
+    OPEN = "Open"
+    RESOLVED = "Resolved"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/help_type_enum.py

@@ -0,0 +1,18 @@
+"""Enumeration for help request types (auto-generated)."""
+
+from enum import Enum
+
+
+class HelpTypeEnum(str, Enum):
+    """Enumeration of possible help request types."""
+
+    CHAT = "Chat"
+    ERROR = "Error"
+    EXERCISE = "Exercise"
+    MEDICAL = "Medical"
+    MUSIC = "Music"
+    OTHER = "Other"
+    REQUEST = "Request"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/queue_rule_enum.py

@@ -0,0 +1,15 @@
+"""Enumeration for exercise Queue Rules."""
+
+from enum import Enum
+
+
+class QueueRuleEnum(str, Enum):
+    """Enumeration for exercise Queue Rules."""
+
+    CHOOSE = "Choose"
+    WAIT_FOR_AUTOCHECKS = "Wait For AutoChecks"
+    WAIT_FOR_DONE = "Wait For Done"
+    WAIT_FOR_SUBMITTED = "Wait For Submitted"
+
+    def __str__(self) -> str:
+        return str(self.value)

pyhive/src/types/enums/status_enum.py

@@ -0,0 +1,21 @@
+"""StatusEnum class representing various user statuses."""
+
+from enum import Enum
+
+
+class StatusEnum(str, Enum):
+    """Enumeration of user statuses."""
+
+    HOME = "Home"
+    MEDICAL = "Medical"
+    PERSONAL_TALK = "Personal Talk"
+    PRAYER = "Prayer"
+    PRESENT = "Present"
+    RAISED_HAND = "Raised Hand"
+    ROOM = "Room"
+    TOILET = "Toilet"
+    TOILET_REQUEST = "Toilet Request"
+    WORK_TALK = "Work Talk"
+
+    def __str__(self) -> str:
+        return str(self.value)