hexo 0.1.0__py3-none-any.whl

hexo/__init__.py

@@ -0,0 +1,30 @@
+"""
+Expose the public API for the Hexo engine package.
+
+This module configures package-level logging and re-exports the primary engine
+types so users can import them directly from `hexo` instead of internal modules.
+"""
+
+import logging
+from pedros.logger import setup_logging
+
+from hexo.engine import Hexo
+from hexo.errors import HexoError, IllegalTurnError
+from hexo.geometry import hex_distance
+from hexo.types import AXES, Coord, EngineConfig, GameStatus, Player, State, TurnRecord
+
+setup_logging(level=logging.INFO)
+
+__all__ = [
+    "Coord",
+    "EngineConfig",
+    "GameStatus",
+    "Hexo",
+    "HexoError",
+    "IllegalTurnError",
+    "AXES",
+    "Player",
+    "State",
+    "TurnRecord",
+    "hex_distance",
+]

hexo/engine.py

@@ -0,0 +1,428 @@
+"""
+Implement the core Hexo game state and rule validation logic.
+
+This module provides the single public `Hexo` class and state transition logic.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from hexo.errors import IllegalTurnError
+from hexo.geometry import hex_distance
+from hexo.types import (
+    AXES,
+    Coord,
+    EngineConfig,
+    GameStatus,
+    Player,
+    State,
+    TurnRecord,
+    UndoSnapshot,
+)
+
+
+class Hexo:
+    """
+    Single public API for Hexo.
+
+    The opening stone for P1 is automatically placed at (0, 0) on init.
+
+    :param config:
+        Optional engine configuration. When omitted, defaults are used.
+    """
+
+    def __init__(self, config: EngineConfig | None = None) -> None:
+        """
+        Initialize a new Hexo game with the opening center pre-applied.
+
+        :param config:
+            Optional engine configuration. When omitted, defaults are used.
+        """
+        self.config = config or EngineConfig()
+        self._board: dict[Coord, Player] = {self.config.opening_center: Player.P1}
+        self._stones_by_player: dict[Player, set[Coord]] = {
+            Player.P1: {self.config.opening_center},
+            Player.P2: set(),
+        }
+        self._turn_history: list[TurnRecord] = []
+        self._undo_stack: list[UndoSnapshot] = []
+        self._pending: list[Coord] = []
+        self._winner: Player | None = None
+        self._to_move = Player.P2
+        self._legal_moves_cache: set[Coord] = set()
+        self._legal_moves_tuple_cache: tuple[Coord, ...] | None = None
+        self._expand_legal_cache_from(self.config.opening_center)
+
+    @classmethod
+    def new(cls, config: EngineConfig | None = None) -> Hexo:
+        """
+        Create a new game instance.
+
+        :param config:
+            Optional engine configuration. When omitted, defaults are used.
+        :return:
+            A newly initialized `Hexo` game object.
+        """
+        return cls(config=config)
+
+    @classmethod
+    def from_state(cls, state: State, config: EngineConfig | None = None) -> Hexo:
+        """
+        Rebuild a game from serialized move history.
+
+        :param state:
+            Serialized state with `turns` and optional `pending` arrays.
+        :param config:
+            Optional engine configuration to use for validation.
+        :return:
+            A reconstructed `Hexo` game after replaying all serialized moves.
+        """
+        game = cls.new(config=config)
+        for raw_turn in state.get("turns", []):
+            if len(raw_turn) not in (1, 2):
+                raise IllegalTurnError(
+                    "state contains invalid turn size; each turn must have 1 or 2 coordinates"
+                )
+            for raw_coord in raw_turn:
+                game.push((int(raw_coord[0]), int(raw_coord[1])))
+        for raw_coord in state.get("pending", []):
+            game.push((int(raw_coord[0]), int(raw_coord[1])))
+        return game
+
+    def to_state(self) -> State:
+        """
+        Serialize the current game into a portable dictionary representation.
+
+        :return:
+            A state dictionary containing replayable turn history and pending placements.
+        """
+        turns = [
+            [[coord[0], coord[1]] for coord in record.placements]
+            for record in self._turn_history
+        ]
+        pending = [[coord[0], coord[1]] for coord in self._pending]
+        return {"turns": turns, "pending": pending}
+
+    def turn(self) -> Player:
+        """
+        Return the player expected to move next.
+
+        :return:
+            The current side to move.
+        """
+        return self._to_move
+
+    def moves_left_in_turn(self) -> int:
+        """
+        Return how many placements remain for the current player's turn.
+
+        :return:
+            Number of stones left to place in the current turn.
+        """
+        return 2 - len(self._pending)
+
+    def pending_moves(self) -> tuple[Coord, ...]:
+        """
+        Return coordinates already placed in the current unfinished turn.
+
+        :return:
+            Tuple containing zero or one coordinates for the active turn.
+        """
+        return tuple(self._pending)
+
+    def status(self) -> GameStatus:
+        """
+        Report whether the game is ongoing or won.
+
+        :return:
+            Current game status.
+        """
+        if self._winner is Player.P1:
+            return GameStatus.P1_WON
+        if self._winner is Player.P2:
+            return GameStatus.P2_WON
+        return GameStatus.ONGOING
+
+    def is_legal(self, move: Sequence[Coord]) -> tuple[bool, str | None]:
+        """
+        Validate whether a two-stone turn is currently legal.
+
+        :param move:
+            Candidate move containing exactly two coordinates.
+        :return:
+            Tuple `(is_legal, reason)` where `reason` is `None` when legal.
+        """
+        if self._winner is not None:
+            return False, "game is over"
+
+        if self._pending:
+            return False, "cannot play a full move while a partial turn is in progress"
+
+        if len(move) != 2:
+            return False, "each turn must place exactly 2 stones"
+
+        a, b = move[0], move[1]
+        if a == b:
+            return False, "duplicate coordinates in same turn"
+        if a in self._board:
+            return False, f"occupied cell: {a}"
+        if b in self._board:
+            return False, f"occupied cell: {b}"
+        if a not in self._legal_moves_cache:
+            return (
+                False,
+                f"placement {a} has no occupied cell within distance <= {self.config.placement_radius}",
+            )
+        if (
+            b not in self._legal_moves_cache
+            and hex_distance(a, b) > self.config.placement_radius
+        ):
+            return (
+                False,
+                f"placement {b} has no occupied cell within distance <= {self.config.placement_radius}",
+            )
+
+        return True, None
+
+    def is_legal_move(self, coord: Coord) -> tuple[bool, str | None]:
+        """
+        Validate a single placement for submove-based play.
+
+        :param coord:
+            Candidate coordinate to place for the current player.
+        :return:
+            Tuple `(is_legal, reason)` where `reason` is `None` when legal.
+        """
+        if self._winner is not None:
+            return False, "game is over"
+        if len(self._pending) >= 2:
+            return False, "current turn already has two placements"
+        if coord in self._board:
+            return False, f"occupied cell: {coord}"
+        if coord in self._legal_moves_cache:
+            return True, None
+        return (
+            False,
+            f"placement {coord} has no occupied cell within distance <= {self.config.placement_radius}",
+        )
+
+    def play(self, move: Sequence[Coord]) -> TurnRecord:
+        """
+        Apply a legal move and update game state.
+
+        :param move:
+            Sequence containing exactly two coordinates for the current player.
+        :return:
+            Immutable record describing the applied turn.
+        """
+        legal, reason = self.is_legal(move)
+        if not legal:
+            raise IllegalTurnError(reason or "illegal move")
+
+        self.push(move[0])
+        if self._winner is not None:
+            return self._turn_history[-1]
+        self.push(move[1])
+        return self._turn_history[-1]
+
+    def push(self, coord: Coord) -> TurnRecord | None:
+        """
+        Place one stone for the current player as a submove.
+
+        This method enables search workflows that evaluate positions between the
+        first and second placement of a turn.
+
+        :param coord:
+            Coordinate to place for the current player.
+        :return:
+            `TurnRecord` when a turn is completed (or wins early), otherwise `None`.
+        """
+        legal, reason = self.is_legal_move(coord)
+        if not legal:
+            raise IllegalTurnError(reason or "illegal placement")
+
+        prev_to_move = self._to_move
+        prev_winner = self._winner
+        prev_pending = tuple(self._pending)
+        prev_history_len = len(self._turn_history)
+        removed_from_cache = coord in self._legal_moves_cache
+
+        self._board[coord] = self._to_move
+        self._stones_by_player[self._to_move].add(coord)
+        self._legal_moves_cache.discard(coord)
+        added_legal = self._expand_legal_cache_from(coord)
+        self._legal_moves_tuple_cache = None
+        self._pending.append(coord)
+        self._undo_stack.append(
+            (
+                coord,
+                prev_to_move,
+                prev_winner,
+                prev_pending,
+                prev_history_len,
+                removed_from_cache,
+                tuple(added_legal),
+            )
+        )
+
+        won = self._has_winning_line(self._to_move, (coord, coord))
+        if won:
+            record = TurnRecord(
+                player=self._to_move, placements=tuple(self._pending), won=True
+            )
+            self._winner = self._to_move
+            self._turn_history.append(record)
+            self._pending.clear()
+            return record
+
+        if len(self._pending) == 2:
+            record = TurnRecord(
+                player=self._to_move, placements=tuple(self._pending), won=False
+            )
+            self._turn_history.append(record)
+            self._pending.clear()
+            self._to_move = self._to_move.opponent
+            return record
+
+        return None
+
+    def undo(self) -> TurnRecord:
+        """
+        Revert the last applied placement.
+
+        :return:
+            Record of the affected turn before the undo.
+        """
+        if not self._undo_stack:
+            raise IllegalTurnError("cannot undo: no placement has been played")
+
+        affected = (
+            self._turn_history[-1]
+            if self._turn_history
+            else TurnRecord(self._to_move, tuple(self._pending), False)
+        )
+        (
+            coord,
+            prev_to_move,
+            prev_winner,
+            prev_pending,
+            prev_history_len,
+            removed_from_cache,
+            added_legal,
+        ) = self._undo_stack.pop()
+        self._board.pop(coord, None)
+        self._stones_by_player[prev_to_move].discard(coord)
+        self._to_move = prev_to_move
+        self._winner = prev_winner
+        self._pending = list(prev_pending)
+        if removed_from_cache:
+            self._legal_moves_cache.add(coord)
+        for added in added_legal:
+            self._legal_moves_cache.discard(added)
+        self._legal_moves_tuple_cache = None
+        if len(self._turn_history) > prev_history_len:
+            self._turn_history = self._turn_history[:prev_history_len]
+        return affected
+
+    def at(self, coord: Coord) -> Player | None:
+        """
+        Return the occupant of a specific coordinate.
+
+        :param coord:
+            Coordinate to inspect.
+        :return:
+            Occupying player or `None` if the cell is empty.
+        """
+        return self._board.get(coord)
+
+    def board(self) -> dict[Coord, Player]:
+        """
+        Return a snapshot of current board occupancy.
+
+        :return:
+            New dictionary mapping occupied coordinates to owning players.
+        """
+        return dict(self._board)
+
+    def legal_moves(self) -> tuple[Coord, ...]:
+        """
+        Return all currently legal single-placement candidates.
+
+        :return:
+            Tuple of legal coordinates.
+        """
+        if self._winner is not None:
+            return ()
+        if self._legal_moves_tuple_cache is None:
+            self._legal_moves_tuple_cache = tuple(self._legal_moves_cache)
+        return self._legal_moves_tuple_cache
+
+    def _expand_legal_cache_from(self, anchor: Coord) -> set[Coord]:
+        """
+        Expand legal move cache from one occupied anchor coordinate.
+
+        :param anchor:
+            Occupied coordinate used to generate new reachable empty cells.
+        :return:
+            Coordinates that were newly introduced in the legal-move cache.
+        """
+        radius = self.config.placement_radius
+        aq, ar = anchor
+        added: set[Coord] = set()
+        for dq in range(-radius, radius + 1):
+            dr_min = max(-radius, -dq - radius)
+            dr_max = min(radius, -dq + radius)
+            for dr in range(dr_min, dr_max + 1):
+                coord = (aq + dq, ar + dr)
+                if coord in self._board:
+                    continue
+                if coord not in self._legal_moves_cache:
+                    self._legal_moves_cache.add(coord)
+                    added.add(coord)
+        return added
+
+    def _has_winning_line(self, player: Player, newly_placed: Sequence[Coord]) -> bool:
+        """
+        Determine whether the latest move creates a winning alignment.
+
+        :param player:
+            Player whose board alignment should be evaluated.
+        :param newly_placed:
+            Two coordinates placed by `player` in the current turn.
+        :return:
+            `True` if the move creates a line meeting the win length.
+        """
+        needed = self.config.win_length
+        player_cells = self._stones_by_player[player]
+        for center in newly_placed:
+            for axis in AXES:
+                run = (
+                    1
+                    + self._count_direction(player_cells, center, axis)
+                    + self._count_direction(player_cells, center, (-axis[0], -axis[1]))
+                )
+                if run >= needed:
+                    return True
+        return False
+
+    @staticmethod
+    def _count_direction(cells: set[Coord], origin: Coord, step: Coord) -> int:
+        """
+        Count contiguous stones in one direction from an origin.
+
+        :param cells:
+            Set of coordinates occupied by one player.
+        :param origin:
+            Starting coordinate for the directional scan.
+        :param step:
+            Axis step increment used for scanning.
+        :return:
+            Number of contiguous cells encountered along the direction.
+        """
+        count = 0
+        cur = (origin[0] + step[0], origin[1] + step[1])
+        while cur in cells:
+            count += 1
+            cur = (cur[0] + step[0], cur[1] + step[1])
+        return count

hexo/errors.py

@@ -0,0 +1,21 @@
+"""
+Define exception types used by the Hexo engine.
+"""
+
+
+class HexoError(Exception):
+    """
+    Represent the base exception for all Hexo engine failures.
+
+    This exception is used as the root class for domain-specific errors raised
+    by the package so callers can catch all Hexo-related exceptions with one type.
+    """
+
+
+class IllegalTurnError(HexoError):
+    """
+    Signal that a move or turn violates Hexo game rules.
+
+    This exception is raised when validation fails during state reconstruction,
+    move application, or other rule-checked operations.
+    """

hexo/geometry.py

@@ -0,0 +1,21 @@
+"""
+Provide geometry helpers for the axial hex grid used by Hexo.
+"""
+
+from hexo.types import Coord
+
+
+def hex_distance(a: Coord, b: Coord) -> int:
+    """
+    Compute hex-grid distance between two axial coordinates.
+
+    :param a:
+        First coordinate as `(q, r)`.
+    :param b:
+        Second coordinate as `(q, r)`.
+    :return:
+        Hex distance between `a` and `b`.
+    """
+    dq = a[0] - b[0]
+    dr = a[1] - b[1]
+    return (abs(dq) + abs(dr) + abs(dq + dr)) // 2

hexo/py.typed

@@ -0,0 +1 @@
+

hexo/types.py

@@ -0,0 +1,109 @@
+"""
+Provide core type definitions used by the Hexo engine.
+
+This module centralizes enums, coordinate aliases, and immutable records that
+describe game configuration and turn history.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Any
+
+Coord = tuple[int, int]
+"""Represent an axial hex-grid coordinate as `(q, r)` integers."""
+
+State = dict[str, Any]
+"""Represent a serialized Hexo game state."""
+
+AXES: tuple[Coord, ...] = ((1, 0), (0, 1), (1, -1))
+"""Define the three principal axes used for straight-line win detection."""
+
+
+class Player(Enum):
+    """
+    Identify one of the two players in a Hexo game.
+    """
+
+    P1 = auto()
+    P2 = auto()
+
+    @property
+    def opponent(self) -> Player:
+        """
+        Return the opponent of the current player.
+
+        :return:
+            `Player.P2` when called on `Player.P1`, otherwise `Player.P1`.
+        """
+        return Player.P1 if self is Player.P2 else Player.P2
+
+
+class GameStatus(Enum):
+    """
+    Describe the global game state from a terminal-condition perspective.
+    """
+
+    ONGOING = auto()
+    P1_WON = auto()
+    P2_WON = auto()
+
+
+@dataclass(frozen=True, slots=True)
+class EngineConfig:
+    """
+    Store immutable configuration values for a Hexo game instance.
+
+    :param win_length:
+        Number of aligned stones required for a win.
+    :param placement_radius:
+        Maximum hex distance from an occupied cell allowed for a new placement.
+    :param opening_center:
+        Fixed coordinate of the pre-placed opening stone for `P1`.
+    """
+
+    win_length: int = 6
+    placement_radius: int = 8
+    opening_center: Coord = (0, 0)
+
+
+@dataclass(frozen=True, slots=True)
+class TurnRecord:
+    """
+    Record the outcome of a single executed turn.
+
+    :param player:
+        Player who performed the turn.
+    :param placements:
+        Coordinates placed during the turn, in application order.
+    :param won:
+        Whether this turn produced a winning line for `player`.
+    """
+
+    player: Player
+    placements: tuple[Coord, ...]
+    won: bool
+
+
+UndoSnapshot = tuple[
+    Coord,
+    Player,
+    Player | None,
+    tuple[Coord, ...],
+    int,
+    bool,
+    tuple[Coord, ...],
+]
+"""
+Capture all state required to undo one `push` operation.
+
+Fields:
+- pushed coordinate
+- previous player to move
+- previous winner
+- previous pending moves
+- previous turn-history length
+- whether pushed coordinate was removed from legal cache
+- coordinates newly added to legal cache by the push
+"""

hexo-0.1.0.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: hexo
+Version: 0.1.0
+Summary: A fast, reusable Python engine for Hexo on an infinite hex grid.
+Author: Pierre LAPOLLA
+License: MIT License
+        
+        Copyright (c) [2025] [Pierre LAPOLLA]
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: ai,board-game,connect-six,game-engine,hex-grid,hexo
+Requires-Python: >=3.10
+Requires-Dist: pedros>=0.12.3
+Description-Content-Type: text/markdown
+
+![Ruff](https://img.shields.io/badge/ruff-enabled-brightgreen)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+# Hexo Engine
+
+Hexo is a Python engine for the Hexo game played on an infinite hex grid.
+
+The goal of this repository is to provide a clean, reusable engine API (similar in spirit to `python-chess`) so others can build bots, analysis tools, and frontends without re-implementing game logic.
+
+Game rules are documented in [RULES.md](RULES.md).
+Agent handoff context is documented in [AGENT_CONTEXT.md](AGENT_CONTEXT.md).
+
+## Features
+
+- Deterministic game engine with strict rule validation
+- Infinite hex-grid coordinate model
+- Opening and turn rules enforced by the engine
+- Win detection (connect 6 on any hex axis)
+- Undo support for search algorithms
+
+## Installation
+
+### Requirements
+
+- [UV](https://docs.astral.sh/uv/) package manager
+
+### Clone the repository
+
+```bash
+  git clone https://github.com/<your-org>/hexo.git
+  cd hexo
+```
+
+### Initialize your environment
+
+```bash
+  uv sync
+  uv run pre-commit install
+```
+
+## API
+
+Public entry point is the `Hexo` class.
+
+- `Hexo.new(config=None) -> Hexo`: create a new game with `P1` already placed at `(0, 0)`.
+- `Hexo.from_state(state, config=None) -> Hexo`: restore a game from serialized state.
+- `game.to_state() -> dict`: serialize committed turns and any in-progress partial turn.
+- `game.turn() -> Player`: return the player currently placing stones.
+- `game.status() -> GameStatus`: return `ONGOING`, `P1_WON`, or `P2_WON`.
+- `game.moves_left_in_turn() -> int`: return remaining moves in current turn (`2` or `1`).
+- `game.pending_moves() -> tuple[Coord, ...]`: return moves already made in the current turn.
+- `game.is_legal_move(coord) -> tuple[bool, str | None]`: validate one submove.
+- `game.legal_moves() -> tuple[Coord, ...]`: return legal single-move candidates.
+- `game.push(coord) -> TurnRecord | None`: play one move; returns `None` if turn is still partial, or `TurnRecord` when the turn completes (or wins early).
+- `game.is_legal(move) -> tuple[bool, str | None]`: validate a full 2-stone move (only when no partial turn is active).
+- `game.play(move) -> TurnRecord`: convenience wrapper that places two stones in sequence.
+- `game.undo() -> TurnRecord`: undo the last placement (works for both partial and completed turns).
+- `game.at(coord) -> Player | None`: inspect occupancy at a coordinate.
+- `game.board() -> dict[Coord, Player]`: get a snapshot of all occupied coordinates.
+
+Notes:
+
+- `Hexo.new()` starts with `P1` already placed at `(0, 0)`.
+- Every played turn is a 2-stone move.
+
+## Quickstart
+
+```python
+from hexo import Hexo
+
+game = Hexo.new()
+print(game.turn())  # Player.P2
+
+legal, reason = game.is_legal_move((1, 0))
+if not legal:
+    raise ValueError(reason)
+game.push((1, 0))
+
+# Hook point for engines: run a search after first placement.
+# ... search code here ...
+
+record = game.push((0, 1))  # turn completes here
+print(record)  # TurnRecord
+print(game.moves_left_in_turn())  # 2
+
+state = game.to_state()
+restored = Hexo.from_state(state)
+print(restored.turn())
+```
+
+## Tests, linting and formatting
+
+```bash
+uv run pytest
+```
+
+```bash
+uvx ruff check . --fix
+```
+
+```bash
+uvx ruff format .
+```
+
+Run all hooks manually:
+
+```bash
+uv run pre-commit run --all-files
+```
+
+## Benchmarks
+
+Benchmarking uses `pytest-benchmark` and is kept separate from normal tests.
+
+Run benchmarks:
+
+```bash
+uv run pytest benchmarks --benchmark-only
+```
+
+Save a baseline:
+
+```bash
+uv run pytest benchmarks --benchmark-only --benchmark-save=baseline
+```
+
+Compare with a saved baseline:
+
+```bash
+uv run pytest benchmarks --benchmark-only --benchmark-compare=baseline
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for:
+
+- issue reporting guidelines
+- feature proposal flow
+- pull request requirements
+- code style and testing expectations
+
+## License
+
+This project is licensed under the MIT [LICENSE](LICENSE)

hexo-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+hexo/__init__.py,sha256=RUHHdinuCNCwa6-Zb26-nPAyg_kt07k9c1dST6PJD0Q,716
+hexo/engine.py,sha256=EvjFsST6Pkee20_FbycciFNBl6vabk-ObMFiItDFeus,14290
+hexo/errors.py,sha256=3JfVy-JbtKguGAs31ICdRPkB6ZUxAGLLudmemzLDNEU,575
+hexo/geometry.py,sha256=lFBFalxU6ZEPL29mBFB5-KmOsZxb227D8Bv4CMD8wfw,478
+hexo/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+hexo/types.py,sha256=aVoiv_-sLSwgqbVc5K2wgSCEvvtVitYkVI0PuzaNRwI,2546
+hexo-0.1.0.dist-info/METADATA,sha256=fTuF20nnnqX8lUjsRokU6Lzcb2hgArs8dAw_zi1SpDM,5490
+hexo-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+hexo-0.1.0.dist-info/licenses/LICENSE,sha256=nn79lpyhivZG3JTP7Se7d53Pbv3hKpfGC35BM4GkR2c,1075
+hexo-0.1.0.dist-info/RECORD,,

hexo-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

hexo-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [Pierre LAPOLLA]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.