dungeoncoder 0.2.0__py3-none-any.whl

dungeoncoder/_generated/models/boolean_result_status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class BooleanResultStatus(str, Enum):
+    SUCCESS = "success"
+
+    def __str__(self) -> str:
+        return str(self.value)

dungeoncoder/_generated/models/configure_params.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+
+
+
+
+
+T = TypeVar("T", bound="ConfigureParams")
+
+
+
+@_attrs_define
+class ConfigureParams:
+    """ 
+        Attributes:
+            name (str): Display name shown above the hero.
+            type_number (int): Selects the hero sprite variant.
+     """
+
+    name: str
+    type_number: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        type_number = self.type_number
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "name": name,
+            "typeNumber": type_number,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        type_number = d.pop("typeNumber")
+
+        configure_params = cls(
+            name=name,
+            type_number=type_number,
+        )
+
+
+        configure_params.additional_properties = d
+        return configure_params
+
+    @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

dungeoncoder/_generated/models/distance_param.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+
+
+
+
+
+T = TypeVar("T", bound="DistanceParam")
+
+
+
+@_attrs_define
+class DistanceParam:
+    """ 
+        Attributes:
+            distance (int): How many fields ahead, in the direction the hero faces (1 = the field in front).
+     """
+
+    distance: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        distance = self.distance
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "distance": distance,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        distance = d.pop("distance")
+
+        distance_param = cls(
+            distance=distance,
+        )
+
+
+        distance_param.additional_properties = d
+        return distance_param
+
+    @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

dungeoncoder/_generated/models/name_param.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+
+
+
+
+
+T = TypeVar("T", bound="NameParam")
+
+
+
+@_attrs_define
+class NameParam:
+    """ 
+        Attributes:
+            name (str): Item name, as returned by get_items_at_position/get_inventory.
+     """
+
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "name": name,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        name_param = cls(
+            name=name,
+        )
+
+
+        name_param.additional_properties = d
+        return name_param
+
+    @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

dungeoncoder/_generated/models/nullable_integer_result.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.nullable_integer_result_status import NullableIntegerResultStatus
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="NullableIntegerResult")
+
+
+
+@_attrs_define
+class NullableIntegerResult:
+    """ 
+        Attributes:
+            status (NullableIntegerResultStatus):
+            message (str):
+            result (int | None):
+     """
+
+    status: NullableIntegerResultStatus
+    message: str
+    result: int | None
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        message = self.message
+
+        result: int | None
+        result = self.result
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "status": status,
+            "message": message,
+            "result": result,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = NullableIntegerResultStatus(d.pop("status"))
+
+
+
+
+        message = d.pop("message")
+
+        def _parse_result(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        result = _parse_result(d.pop("result"))
+
+
+        nullable_integer_result = cls(
+            status=status,
+            message=message,
+            result=result,
+        )
+
+
+        nullable_integer_result.additional_properties = d
+        return nullable_integer_result
+
+    @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

dungeoncoder/_generated/models/nullable_integer_result_status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class NullableIntegerResultStatus(str, Enum):
+    SUCCESS = "success"
+
+    def __str__(self) -> str:
+        return str(self.value)

dungeoncoder/_generated/models/nullable_string_result.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.nullable_string_result_status import NullableStringResultStatus
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="NullableStringResult")
+
+
+
+@_attrs_define
+class NullableStringResult:
+    """ 
+        Attributes:
+            status (NullableStringResultStatus):
+            message (str):
+            result (None | str):
+     """
+
+    status: NullableStringResultStatus
+    message: str
+    result: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        message = self.message
+
+        result: None | str
+        result = self.result
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "status": status,
+            "message": message,
+            "result": result,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = NullableStringResultStatus(d.pop("status"))
+
+
+
+
+        message = d.pop("message")
+
+        def _parse_result(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        result = _parse_result(d.pop("result"))
+
+
+        nullable_string_result = cls(
+            status=status,
+            message=message,
+            result=result,
+        )
+
+
+        nullable_string_result.additional_properties = d
+        return nullable_string_result
+
+    @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

dungeoncoder/_generated/models/nullable_string_result_status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class NullableStringResultStatus(str, Enum):
+    SUCCESS = "success"
+
+    def __str__(self) -> str:
+        return str(self.value)

dungeoncoder/_generated/models/pace_params.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+
+
+
+
+
+T = TypeVar("T", bound="PaceParams")
+
+
+
+@_attrs_define
+class PaceParams:
+    """ 
+        Attributes:
+            factor (float): Multiplier applied to movement/turn animation speed.
+     """
+
+    factor: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        factor = self.factor
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "factor": factor,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        factor = d.pop("factor")
+
+        pace_params = cls(
+            factor=factor,
+        )
+
+
+        pace_params.additional_properties = d
+        return pace_params
+
+    @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