dungeoncoder 0.2.0__py3-none-any.whl

dungeoncoder/_generated/models/statistics.py

@@ -0,0 +1,217 @@
+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 ..types import UNSET, Unset
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="Statistics")
+
+
+
+@_attrs_define
+class Statistics:
+    """ Counters since the level was (re)loaded.
+
+        Attributes:
+            moves (int): successful move() steps
+            turns (int): turn_left() turns
+            bumps (int): move() calls that were blocked
+            keyboard_moves (int): steps made by hand (WASD)
+            interactions (int): interact() calls
+            pickups (int): successful pickup() calls
+            drops (int): successful drop() calls
+            sensor_calls (int): calls of is_*_in_front, is_facing_north, is_at_goal and get_items_at_position
+            reads (int): calls of read_item_value and peek_item_value
+            questions (int): calls of ask_oracle
+            at_goal (bool): the hero stands on the goal field
+            game_over (bool): the hero fell into an abyss or was caught by a guard
+            level_complete (bool): goal reached and every win condition of the level met
+            missing (list[str]): unmet win conditions, e.g. "3 sweets"
+            moves_left (int | None | Unset): move() calls left in a level with the map property max_moves (null without a
+                budget)
+            heroes (int | Unset): number of heroes in the level (co-op levels have more than one)
+     """
+
+    moves: int
+    turns: int
+    bumps: int
+    keyboard_moves: int
+    interactions: int
+    pickups: int
+    drops: int
+    sensor_calls: int
+    reads: int
+    questions: int
+    at_goal: bool
+    game_over: bool
+    level_complete: bool
+    missing: list[str]
+    moves_left: int | None | Unset = UNSET
+    heroes: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        moves = self.moves
+
+        turns = self.turns
+
+        bumps = self.bumps
+
+        keyboard_moves = self.keyboard_moves
+
+        interactions = self.interactions
+
+        pickups = self.pickups
+
+        drops = self.drops
+
+        sensor_calls = self.sensor_calls
+
+        reads = self.reads
+
+        questions = self.questions
+
+        at_goal = self.at_goal
+
+        game_over = self.game_over
+
+        level_complete = self.level_complete
+
+        missing = self.missing
+
+
+
+        moves_left: int | None | Unset
+        if isinstance(self.moves_left, Unset):
+            moves_left = UNSET
+        else:
+            moves_left = self.moves_left
+
+        heroes = self.heroes
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "moves": moves,
+            "turns": turns,
+            "bumps": bumps,
+            "keyboard_moves": keyboard_moves,
+            "interactions": interactions,
+            "pickups": pickups,
+            "drops": drops,
+            "sensor_calls": sensor_calls,
+            "reads": reads,
+            "questions": questions,
+            "at_goal": at_goal,
+            "game_over": game_over,
+            "level_complete": level_complete,
+            "missing": missing,
+        })
+        if moves_left is not UNSET:
+            field_dict["moves_left"] = moves_left
+        if heroes is not UNSET:
+            field_dict["heroes"] = heroes
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        moves = d.pop("moves")
+
+        turns = d.pop("turns")
+
+        bumps = d.pop("bumps")
+
+        keyboard_moves = d.pop("keyboard_moves")
+
+        interactions = d.pop("interactions")
+
+        pickups = d.pop("pickups")
+
+        drops = d.pop("drops")
+
+        sensor_calls = d.pop("sensor_calls")
+
+        reads = d.pop("reads")
+
+        questions = d.pop("questions")
+
+        at_goal = d.pop("at_goal")
+
+        game_over = d.pop("game_over")
+
+        level_complete = d.pop("level_complete")
+
+        missing = cast(list[str], d.pop("missing"))
+
+
+        def _parse_moves_left(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        moves_left = _parse_moves_left(d.pop("moves_left", UNSET))
+
+
+        heroes = d.pop("heroes", UNSET)
+
+        statistics = cls(
+            moves=moves,
+            turns=turns,
+            bumps=bumps,
+            keyboard_moves=keyboard_moves,
+            interactions=interactions,
+            pickups=pickups,
+            drops=drops,
+            sensor_calls=sensor_calls,
+            reads=reads,
+            questions=questions,
+            at_goal=at_goal,
+            game_over=game_over,
+            level_complete=level_complete,
+            missing=missing,
+            moves_left=moves_left,
+            heroes=heroes,
+        )
+
+
+        statistics.additional_properties = d
+        return statistics
+
+    @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/statistics_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.statistics_result_status import StatisticsResultStatus
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.statistics import Statistics
+
+
+
+
+
+T = TypeVar("T", bound="StatisticsResult")
+
+
+
+@_attrs_define
+class StatisticsResult:
+    """ 
+        Attributes:
+            status (StatisticsResultStatus):
+            message (str):
+            result (Statistics): Counters since the level was (re)loaded.
+     """
+
+    status: StatisticsResultStatus
+    message: str
+    result: Statistics
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.statistics import Statistics
+        status = self.status.value
+
+        message = self.message
+
+        result = self.result.to_dict()
+
+
+        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:
+        from ..models.statistics import Statistics
+        d = dict(src_dict)
+        status = StatisticsResultStatus(d.pop("status"))
+
+
+
+
+        message = d.pop("message")
+
+        result = Statistics.from_dict(d.pop("result"))
+
+
+
+
+        statistics_result = cls(
+            status=status,
+            message=message,
+            result=result,
+        )
+
+
+        statistics_result.additional_properties = d
+        return statistics_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/statistics_result_status.py

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

dungeoncoder/_generated/models/string_array_result.py

@@ -0,0 +1,100 @@
+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.string_array_result_status import StringArrayResultStatus
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="StringArrayResult")
+
+
+
+@_attrs_define
+class StringArrayResult:
+    """ 
+        Attributes:
+            status (StringArrayResultStatus):
+            message (str):
+            result (list[str]):
+     """
+
+    status: StringArrayResultStatus
+    message: str
+    result: list[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 = 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 = StringArrayResultStatus(d.pop("status"))
+
+
+
+
+        message = d.pop("message")
+
+        result = cast(list[str], d.pop("result"))
+
+
+        string_array_result = cls(
+            status=status,
+            message=message,
+            result=result,
+        )
+
+
+        string_array_result.additional_properties = d
+        return string_array_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/string_array_result_status.py

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

dungeoncoder/_generated/models/tiled_level.py

@@ -0,0 +1,67 @@
+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="TiledLevel")
+
+
+
+@_attrs_define
+class TiledLevel:
+    """ A Tiled (mapeditor.org) JSON map export. Not fully modeled here - the game engine (game/src/game.js) is the source
+    of truth for what it accepts.
+
+     """
+
+    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)
+        tiled_level = cls(
+        )
+
+
+        tiled_level.additional_properties = d
+        return tiled_level
+
+    @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/version_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.version_result_status import VersionResultStatus
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.version_result_result import VersionResultResult
+
+
+
+
+
+T = TypeVar("T", bound="VersionResult")
+
+
+
+@_attrs_define
+class VersionResult:
+    """ 
+        Attributes:
+            status (VersionResultStatus):
+            message (str):
+            result (VersionResultResult):
+     """
+
+    status: VersionResultStatus
+    message: str
+    result: VersionResultResult
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.version_result_result import VersionResultResult
+        status = self.status.value
+
+        message = self.message
+
+        result = self.result.to_dict()
+
+
+        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:
+        from ..models.version_result_result import VersionResultResult
+        d = dict(src_dict)
+        status = VersionResultStatus(d.pop("status"))
+
+
+
+
+        message = d.pop("message")
+
+        result = VersionResultResult.from_dict(d.pop("result"))
+
+
+
+
+        version_result = cls(
+            status=status,
+            message=message,
+            result=result,
+        )
+
+
+        version_result.additional_properties = d
+        return version_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/version_result_result.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="VersionResultResult")
+
+
+
+@_attrs_define
+class VersionResultResult:
+    """ 
+        Attributes:
+            extension (str): version of the extension (package.json), e.g. 0.1.0
+            api (str): version of this API description (info.version)
+     """
+
+    extension: str
+    api: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        extension = self.extension
+
+        api = self.api
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "extension": extension,
+            "api": api,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        extension = d.pop("extension")
+
+        api = d.pop("api")
+
+        version_result_result = cls(
+            extension=extension,
+            api=api,
+        )
+
+
+        version_result_result.additional_properties = d
+        return version_result_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/version_result_status.py

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