noyainrain / feini Goto Github PK

class Space:
    ITEM_CATEGORIES = {'food': ['🥕', '🍲']}

class Pet:
    async def feed(self, food: str) -> None:
        """Feed the pet with *food*."""

class Space:
    async def get_blueprints(self) -> list[str]:
        """Get known blueprints."""

    async def craft(self, blueprint: str) -> str | Object:
        """Craft a new object given by *blueprint*."""

class Space:
    """Item categories."""
    ITEM_CATEGORIES = {
        'resource': ['🥕', '🪨', '🪵', '🧶'],
        'clothing': ['🕶️', '🎀']
    }

class Pet:
    """Clothing the pet is wearing."""
    clothing: str | None

    async def dress(self, clothing: str | None) -> None:
        """Dress the pet in the given *clothing*."""

class Space:
    """Weights by which sewing patterns are ordered."""
    PATTERN_WEIGHTS: dict[str, int]

    async def get_patterns(self) -> list[str]:
        """Get known sewing patterns."""

class Schedule:
    """Simulation schedule of a :class:`Space`."""

    """Related space."""
    space: Space

    class DateMethod:
        """Simulate an annual date."""

        """Annotated function."""
        func: Callable[[Schedule], Awaitable[None]]
        """Month of the date."""
        month: int
        """Day of the date."""
        day: int

    @staticmethod
    def date(month: int, day: int) -> Callable[[Callable[[Schedule], Awaitable[None]]], DateMethod]:
        """Decorator to define an annual date on *day* of *month*."""
        return partial(Schedule.DateMethod, month=month, day=day)

    async def run(self) -> None:
        """Simulate all scheduled dates."""

    # Example
    @date(31, 10)
    async def start_jenseits_festival(self) -> None: ...

class Space:
    """Simulation schedule."""
    schedule: Schedule

@dataclass
class Content:
    """Media content."""

    """Title of the content."""
    title: str

    # Future reference
    """URL of the content or information about it."""
    url: str
    """Short summary."""
    summary: str | None = None

    @staticmethod
    def parse(data: str) -> Content:
        """Parse the string representation *data* into media content."""

class TMDB:
    """The Movie Database source."""

    """Time to live for cached content."""
    CACHE_TTL = timedelta(days=1)

    """API key to fetch the current popular TV shows."""
    key: str | None = None

    """Current TV shows, ordered by popularity, highest first."""
    shows: list[Content] = [Content('Buffy the Vampire Slayer')]

    async def close(self) -> None:
        """Close the source."""

class DW:
    """Deutsche Welle source."""

    """Time to live for cached content."""
    CACHE_TTL = timedelta(days=1)

    """Current news articles, ordered by time, latest first."""
    news: list[Content] = [Content('Digital pet Tamagotchi turns 25')]

    async def close(self) -> None:
        """Close the source."""

class Bot:
    """The Movie Database source."""
    tmdb: TMDB

    """Deutsche Welle source."""
    dw: DW

class Event:
    """Game event."""

    """Type of the event."""
    type: str

    """ID of the :class:`Space` where the event happened."""
    space_id: str

    @staticmethod
    def parse(data: str) -> Event:
        """Parse the string representation *data* into an event."""

    async def get_space(self) -> Space:
        """Get the space where the event happened."""

class Bot:
    async def events(self) -> AsyncIterator[Event]:
        """Stream of game events."""

# Future reference
class NudgeEvent(Event):
    """Event about a nudge from the pet."""

    """Activity emoji or ID of the furniture piece to engage with."""
    activity_id: str

    @staticmethod
    def parse(data: str) -> NudgeEvent: ...

    async def get_activity(self) -> Furniture | str:
        """Get the activity emoji or ID of the furniture piece to engage with."""

class Pet:
    """Available stand-alone activities."""
    ACTIVITIES: set[str]

    async def engage(self, activity: Furniture | str) -> None:
        """Engage the pet in the given *activity*."""

class Space:
    """Material needed for clothing items."""
    CLOTHING_MATERIAL: dict[str, list[str]]

    def sew(self, pattern: str) -> str:
        """Sew a new clothing item given by *pattern*."""

_F = TypeVar('_F', bound=Callable[..., object])

class Pet:
    """Level at which the relationship with the player feels completely reciprocal."""
    RECIPROCITY_MAX = 72

    """Current reciprocity level of the relationship to the player."""
    reciprocity: int

    @staticmethod
    def social(func: _F) -> _F:
        """Decorator to make a social interaction between the player and the pet.

        Social interactions influence the :attr:`reciprocity`.
        """

class Space:
    """
    .. describe:: space-nudge

       Dispatched when the pet nudges the player.
    """

class NudgeEvent(Event):
    """Event about a nudge from the pet."""

    """Intended activity emoji or ID of the furniture piece to engage with."""
    activity_id: str

    @staticmethod
    def parse(data: str) -> NudgeEvent: ...

    async def get_activity(self) -> Furniture | str:
        """Get the intended activity emoji or ID of the furniture piece to engage with."""

class FurnitureProperties(TypedDict):
    """Properties of a furniture piece."""

    """Indicates if the furniture piece is portable or fixed."""
    portable: bool

    # Future reference
    """Needed material."""
    material: list[str]

"""Properties of each furniture piece."""
FURNITURE_PROPERTIES: dict[str, FurnitureProperties]

class Message:
    """Blueprint or pattern the character teaches to the player."""
    lesson: str

@dataclass
class Message:
    """Dialogue message."""

    """Message ID."""
    id: str
    """Items the character currently needs, if any."""
    request: list[str]
    """Items the player has just given to the character, if any."""
    taken: list[str]

    @staticmethod
    def parse(data: str) -> Message:
        """Parse the string representation *data* into a message."""

    def encode(self) -> str:
        """Return a string representation of the message."""

class Character:
    """Character."""

    """Character ID."""
    id: str
    """Related :class:`Space` ID."""
    space_id: str
    """Avatar emoji."""
    avatar: str

    async def get_dialogue(self) -> list[Message]:
        """Get the ongoing dialogue, starting from the most recent message."""

    async def talk(self) -> Message:
        """Talk to the character and return their reply.

        If the character has requested some items, give the items to them or repeat the request
        message.
        """

class Space:
    async def get_characters(self) -> list[Character]:
        """Get the present characters."""

class Story:
    """Short story."""

    """Story ID."""
    id: str
    """Related :class:`Space` ID."""
    space_id: str
    """Current point in the story."""
    state: str
    """Tick the state was updated at."""
    update_tick: int

    async def tell(self) -> None:
        """Continue to the next point in the story if the relevant conditions are met."""
        raise NotImplementedError()

class Space:
    async def get_stories(self) -> set[Story]:
        """Get all active stories."""