valanga 0.1.11__py3-none-any.whl → 0.1.14__py3-none-any.whl

valanga/__init__.py

@@ -20,23 +20,23 @@ from .representation_factory import RepresentationFactory
 from .represention_for_evaluation import ContentRepresentation
 
 __all__ = [
-    "ForcedOutcome",
-    "FloatyStateEvaluation",
-    "StateEvaluation",
-    "EvalItem",
-    "OverEvent",
-    "Color",
-    "WHITE",
     "BLACK",
+    "WHITE",
+    "BranchKey",
+    "BranchKeyGeneratorP",
+    "Color",
     "ColorIndex",
-    "HasTurn",
-    "TurnState",
     "ContentRepresentation",
+    "EvalItem",
+    "FloatyStateEvaluation",
+    "ForcedOutcome",
+    "HasTurn",
+    "OverEvent",
+    "PlayerProgressMessage",
     "RepresentationFactory",
     "State",
+    "StateEvaluation",
     "StateModifications",
-    "BranchKeyGeneratorP",
-    "BranchKey",
-    "PlayerProgressMessage",
     "StateTag",
+    "TurnState",
 ]

valanga/evaluations.py

@@ -1,6 +1,4 @@
-"""
-Evaluation-related classes and types.
-"""
+"""Evaluation-related classes and types."""
 
 from dataclasses import dataclass
 from typing import Protocol
@@ -13,8 +11,8 @@ from .represention_for_evaluation import ContentRepresentation
 
 
 class EvalItem[StateT: State](Protocol):
-    """
-    The protocol for an evaluation item.
+    """Define the protocol for an evaluation item.
+
     An evaluation item is something that has a state and optionally a representation of that state.
     """
 
@@ -33,9 +31,7 @@ class EvalItem[StateT: State](Protocol):
 
 @dataclass
 class ForcedOutcome:
-    """
-    The class
-    """
+    """The class."""
 
     # The forced outcome with optimal play by both sides.
     outcome: OverEvent
@@ -46,13 +42,13 @@ class ForcedOutcome:
 
 @dataclass
 class FloatyStateEvaluation:
-    """
-    The class to defines what is an evaluation of a board.
+    """Define what is an evaluation of a board.
+
     By convention is it always evaluated from the view point of the white side.
     """
 
     # The evaluation value for the white side when the outcome is not certain. Typically, a float.
-    # todo can we remove the None option?
+    # TODO(victor): can we remove the None option? see issue #642
     value_white: float | None
 
 

valanga/game.py

@@ -1,11 +1,9 @@
-"""
-Common types and utilities representing game objects shared by multiple libraries.
-"""
+"""Common types and utilities representing game objects shared by multiple libraries."""
 
-from collections.abc import Hashable
+from collections.abc import Hashable, Iterator, Sequence
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Annotated, Any, Iterator, Protocol, Self, Sequence, TypeVar
+from typing import Annotated, Any, Protocol, Self, TypeVar
 
 type Seed = Annotated[int, "seed"]
 
@@ -33,34 +31,36 @@ class BranchKeyGeneratorP(Protocol[T_co]):
 
     @property
     def all_generated_keys(self) -> Sequence[T_co] | None:
-        """Returns all generated branch keys if available, otherwise None."""
+        """Return all generated branch keys if available, otherwise None."""
         ...
 
     def __iter__(self) -> Iterator[T_co]:
-        """Returns an iterator over the branch keys."""
+        """Return an iterator over the branch keys."""
         ...
 
     def __next__(self) -> T_co:
-        """Returns the next branch key."""
+        """Return the next branch key."""
         ...
 
     def more_than_one(self) -> bool:
-        """Checks if there is more than one branch available.
+        """Check if there is more than one branch available.
 
         Returns:
             bool: True if there is more than one branch, False otherwise.
+
         """
         ...
 
     def get_all(self) -> Sequence[T_co]:
-        """Returns a list of all branch keys."""
+        """Return a list of all branch keys."""
         ...
 
     def copy_with_reset(self) -> Self:
-        """Creates a copy of the legal move generator with an optional reset of generated moves.
+        """Create a copy of the legal move generator with an optional reset of generated moves.
 
         Returns:
             Self: A new instance of the legal move generator with the specified generated moves.
+
         """
         ...
 
@@ -70,54 +70,59 @@ class State(Protocol):
 
     @property
     def tag(self) -> StateTag:
-        """Returns the tag of the content.
+        """Return the tag of the content.
 
         Returns:
             StateTag: The tag of the content.
+
         """
         ...
 
     @property
     def branch_keys(self) -> BranchKeyGeneratorP[BranchKey]:
-        """Returns the branch keys associated with the content.
+        """Return the branch keys associated with the content.
 
         Returns:
             BranchKeyGeneratorP: The branch keys associated with the content.
+
         """
         ...
 
     def branch_name_from_key(self, key: BranchKey) -> str:
-        """Returns the branch name corresponding to the given branch key.
+        """Return the branch name corresponding to the given branch key.
 
         Args:
             key (BranchKey): The branch key.
 
         Returns:
             str: The branch name corresponding to the given branch key.
+
         """
         ...
 
     def branch_key_from_name(self, name: str) -> BranchKey:
-        """Returns the branch key corresponding to the given branch name.
+        """Return the branch key corresponding to the given branch name.
 
         Args:
             name (str): The branch name.
+
         Returns:
             BranchKey: The branch key corresponding to the given branch name.
+
         """
         ...
 
     def is_game_over(self) -> bool:
-        """Checks if the game represented by the content is over.
+        """Check if the game represented by the content is over.
 
         Returns:
             bool: True if the game is over, False otherwise.
+
         """
         ...
 
     def copy(self, stack: bool, deep_copy_legal_moves: bool = True) -> Self:
-        """
-        Create a copy of the current board.
+        """Create a copy of the current board.
 
         Args:
             stack (bool): Whether to copy the previous action stack as well. Important in some games.
@@ -125,25 +130,28 @@ class State(Protocol):
 
         Returns:
             BoardChi: A new instance of the BoardChi class with the copied board.
+
         """
         ...
 
     def step(self, branch_key: BranchKey) -> StateModifications | None:
-        """Advances the state by applying the action corresponding to the given branch key.
+        """Advance the state by applying the action corresponding to the given branch key.
 
         Args:
             branch_key (BranchKey): The branch key representing the action to be applied.
 
         Returns:
             StateModifications | None: The modifications to the state after applying the action, or None if the action is invalid.
+
         """
         ...
 
     def pprint(self) -> str:
-        """Returns a pretty-printed string representation of the content.
+        """Return a pretty-printed string representation of the content.
 
         Returns:
             str: A pretty-printed string representation of the content.
+
         """
         ...
 
@@ -185,10 +193,11 @@ class HasTurn(Protocol):
 
     @property
     def turn(self) -> Color:
-        """Returns the tag of the content.
+        """Return the tag of the content.
 
         Returns:
             ContentTag: The tag of the content.
+
         """
         ...
 

valanga/over_event.py

@@ -1,13 +1,23 @@
-"""
-Module for handling game over events.
-"""
+"""Module for handling game over events."""
 
 from dataclasses import dataclass
-from enum import Enum
+from enum import Enum, StrEnum
 
 from .game import Color
 
 
+class WinnerNotProperlyDefinedError(ValueError):
+    """Winner is not properly defined."""
+
+
+class OverNotProperlyDefinedError(ValueError):
+    """Over is not properly defined."""
+
+
+class OverEventInvariantError(ValueError):
+    """OverEvent reached an invalid state."""
+
+
 class HowOver(Enum):
     """Represents the possible outcomes of a game.
 
@@ -15,6 +25,7 @@ class HowOver(Enum):
         WIN (int): Indicates a win.
         DRAW (int): Indicates a draw.
         DO_NOT_KNOW_OVER (int): Indicates that the outcome is unknown.
+
     """
 
     WIN = 1
@@ -37,6 +48,7 @@ class Winner(Enum):
         is_none() -> bool: Checks if the winner is None.
         is_white() -> bool: Checks if the winner is white.
         is_black() -> bool: Checks if the winner is black.
+
     """
 
     WHITE = Color.WHITE
@@ -48,6 +60,7 @@ class Winner(Enum):
 
         Returns:
             bool: True if the winner is NO_KNOWN_WINNER, False otherwise.
+
         """
         return self is Winner.NO_KNOWN_WINNER
 
@@ -56,12 +69,10 @@ class Winner(Enum):
 
         Returns:
             bool: True if the winner is white, False otherwise.
+
         """
         is_white_bool: bool
-        if not self.is_none():
-            is_white_bool = self is Winner.WHITE
-        else:
-            is_white_bool = False
+        is_white_bool = self is Winner.WHITE if not self.is_none() else False
         return is_white_bool
 
     def is_black(self) -> bool:
@@ -69,17 +80,15 @@ class Winner(Enum):
 
         Returns:
             bool: True if the winner is black, False otherwise.
+
         """
         is_black_bool: bool
 
-        if not self.is_none():
-            is_black_bool = self is Winner.BLACK
-        else:
-            is_black_bool = False
+        is_black_bool = self is Winner.BLACK if not self.is_none() else False
         return is_black_bool
 
 
-class OverTags(str, Enum):
+class OverTags(StrEnum):
     """Represents the possible tags for game over events.
 
     Attributes:
@@ -87,6 +96,7 @@ class OverTags(str, Enum):
         TAG_WIN_BLACK (str): Tag indicating a win for the black player.
         TAG_DRAW (str): Tag indicating a draw.
         TAG_DO_NOT_KNOW (str): Tag indicating an unknown outcome.
+
     """
 
     TAG_WIN_WHITE = "Win-Wh"
@@ -119,6 +129,7 @@ class OverEvent:
         is_winner: Checks if the specified player is the winner.
         print_info: Prints information about the `OverEvent` object.
         test: Performs tests on the `OverEvent` object.
+
     """
 
     how_over: HowOver = HowOver.DO_NOT_KNOW_OVER
@@ -126,6 +137,7 @@ class OverEvent:
     termination: Enum | None = None  # Optional termination reason
 
     def __post_init__(self) -> None:
+        """Validate the initial over event state."""
         assert self.how_over in HowOver
         assert self.who_is_winner in Winner
 
@@ -142,24 +154,27 @@ class OverEvent:
         termination: Enum | None,
         who_is_winner: Winner = Winner.NO_KNOWN_WINNER,
     ) -> None:
-        """Sets the `how_over` and `who_is_winner` attributes.
+        """Set the `how_over` and `who_is_winner` attributes.
 
         Args:
             how_over (HowOver): The way the game ended.
+            termination (Enum | None): Optional termination reason.
             who_is_winner (Winner, optional): The winner of the game. Defaults to `Winner.NO_KNOWN_WINNER`.
+
         """
         self.how_over = how_over
         self.who_is_winner = who_is_winner
         self.termination = termination
 
     def get_over_tag(self) -> OverTags:
-        """Returns a tag string used in databases.
+        """Return a tag string used in databases.
 
         Returns:
             OverTags: The tag string representing the game outcome.
 
         Raises:
             Exception: If the winner is not properly defined.
+
         """
         over_tag: OverTags
         if self.how_over == HowOver.WIN:
@@ -168,49 +183,53 @@ class OverEvent:
             elif self.who_is_winner.is_black():
                 over_tag = OverTags.TAG_WIN_BLACK
             else:
-                raise ValueError("error: winner is not properly defined.")
+                raise WinnerNotProperlyDefinedError
         elif self.how_over == HowOver.DRAW:
             over_tag = OverTags.TAG_DRAW
         elif self.how_over == HowOver.DO_NOT_KNOW_OVER:
             over_tag = OverTags.TAG_DO_NOT_KNOW
         else:
-            raise ValueError("error: over is not properly defined.")
+            raise OverNotProperlyDefinedError
         return over_tag
 
     def __bool__(self) -> None:
-        """Raises an exception.
+        """Raise an exception.
 
         Raises:
             Exception: Always raises an exception.
+
         """
-        raise ValueError("Nooooooooooo  in over ebvent.py")
+        raise OverEventInvariantError
 
     def is_over(self) -> bool:
-        """Checks if the game is over.
+        """Check if the game is over.
 
         Returns:
             bool: True if the game is over, False otherwise.
+
         """
         return self.how_over in {HowOver.WIN, HowOver.DRAW}
 
     def is_win(self) -> bool:
-        """Checks if the game ended with a win.
+        """Check if the game ended with a win.
 
         Returns:
             bool: True if the game ended with a win, False otherwise.
+
         """
         return self.how_over == HowOver.WIN
 
     def is_draw(self) -> bool:
-        """Checks if the game ended with a draw.
+        """Check if the game ended with a draw.
 
         Returns:
             bool: True if the game ended with a draw, False otherwise.
+
         """
         return self.how_over == HowOver.DRAW
 
     def is_winner(self, player: Color) -> bool:
-        """Checks if the specified player is the winner.
+        """Check if the specified player is the winner.
 
         Args:
             player (chess.Color): The player to check.
@@ -220,23 +239,25 @@ class OverEvent:
 
         Raises:
             AssertionError: If the `player` argument is not a valid value from the `chess.Color` enum.
+
         """
         assert player in {Color.WHITE, Color.BLACK}
 
         is_winner: bool
         if self.how_over == HowOver.WIN:
-            is_winner = bool(
-                self.who_is_winner == Winner.WHITE
-                and player == Color.WHITE
-                or self.who_is_winner == Winner.BLACK
-                and player == Color.BLACK
-            )
+            winner_color = {
+                Winner.WHITE: Color.WHITE,
+                Winner.BLACK: Color.BLACK,
+            }.get(self.who_is_winner)
+
+            is_winner = player == winner_color
+
         else:
             is_winner = False
         return is_winner
 
     def print_info(self) -> None:
-        """Prints information about the `OverEvent` object."""
+        """Print information about the `OverEvent` object."""
         print(
             "over_event:",
             "how_over:",

valanga/policy.py

@@ -1,19 +1,18 @@
-"""
-Policy-related classes and protocols for branch selection in game trees.
-"""
+"""Policy-related classes and protocols for branch selection in game trees."""
 
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
-from typing import Mapping, Protocol
+from typing import Protocol, TypeVar
 
 from valanga.evaluations import StateEvaluation
 from valanga.game import BranchKey, BranchName, Seed, State
 
+NotifyProgressCallable = Callable[[int], None] | None
+
 
 @dataclass(frozen=True, slots=True)
 class BranchPolicy:
-    """
-    Represents a probability distribution over branches.
-    """
+    """Represents a probability distribution over branches."""
 
     probs: Mapping[BranchKey, float]  # should sum to ~1.0
 
@@ -28,15 +27,27 @@ class Recommendation:
     branch_evals: Mapping[BranchName, StateEvaluation] | None = None
 
 
-class BranchSelector[StateT: State](Protocol):
+StateT_contra = TypeVar("StateT_contra", bound=State, contravariant=True)
+
+
+class BranchSelector(Protocol[StateT_contra]):
     """Protocol for a branch selector."""
 
-    def recommend(self, state: StateT, seed: Seed) -> Recommendation:
+    def recommend(
+        self,
+        state: StateT_contra,
+        seed: Seed,
+        notify_progress: NotifyProgressCallable | None = None,
+    ) -> Recommendation:
         """Given a state and a seed, recommends a branch to take.
+
         Args:
             state (State): The current state of the game.
             seed (Seed): A seed for any randomness involved in the selection.
+            notify_progress (NotifyProgressCallable | None): Optional callback for progress updates.
+
         Returns:
             Recommendation: The recommended branch to take.
+
         """
         ...

valanga/progress_messsage.py

@@ -1,6 +1,4 @@
-"""
-Module for the ProgressMessage class.
-"""
+"""Module for the ProgressMessage class."""
 
 from dataclasses import dataclass
 
@@ -9,11 +7,11 @@ from .game import Color
 
 @dataclass
 class PlayerProgressMessage:
-    """
-    Represents a message containing evaluation information.
+    """Represents a message containing evaluation information.
 
     Attributes:
         evaluation_stock (Any): The evaluation for the stock.
+
     """
 
     progress_percent: int | None

valanga/representation_factory.py

@@ -1,6 +1,4 @@
-"""
-Factory for creating content representations from game states and state modifications.
-"""
+"""Factory for creating content representations from game states and state modifications."""
 
 from dataclasses import dataclass
 from typing import Protocol
@@ -11,32 +9,34 @@ from .game import State
 
 
 class CreateFromState[StateT: State, EvalIn](Protocol):
-    """
-    Protocol for creating a state representation from a state.
-    """
+    """Protocol for creating a state representation from a state."""
 
-    def __call__(self, state: StateT) -> ContentRepresentation[StateT, EvalIn]: ...
+    def __call__(self, state: StateT) -> ContentRepresentation[StateT, EvalIn]:
+        """Create a content representation from a state."""
+        ...
 
 
 class CreateFromStateAndModifications[StateT: State, EvalIn, StateModT](Protocol):
-    """
-    Protocol for creating a state representation from a state and modifications.
-    """
+    """Protocol for creating a state representation from a state and modifications."""
 
     def __call__(
         self,
         state: StateT,
         state_modifications: StateModT,
         previous_state_representation: ContentRepresentation[StateT, EvalIn],
-    ) -> ContentRepresentation[StateT, EvalIn]: ...
+    ) -> ContentRepresentation[StateT, EvalIn]:
+        """Create a content representation from state modifications."""
+        ...
 
 
 @dataclass
 class RepresentationFactory[StateT: State, EvalIn, StateModT]:
     """Factory for creating content representations from states and state modifications.
+
     Attributes:
         create_from_state: Function to create a content representation from a state.
         create_from_state_and_modifications: Function to create a content representation from a state and state modifications.
+
     """
 
     create_from_state: CreateFromState[StateT, EvalIn]
@@ -50,13 +50,16 @@ class RepresentationFactory[StateT: State, EvalIn, StateModT]:
         previous_state_representation: ContentRepresentation[StateT, EvalIn] | None,
         modifications: StateModT | None,
     ) -> ContentRepresentation[StateT, EvalIn]:
-        """Creates a content representation from a state transition.
+        """Create a content representation from a state transition.
+
         Args:
             state: The current state of the game.
             previous_state_representation: The content representation of the previous state, or None if not available.
             modifications: The modifications applied to the previous state to reach the current state, or None if not available.
+
         Returns:
             ContentRepresentation[StateT, EvalIn]: The content representation of the current state.
+
         """
         if previous_state_representation is None or modifications is None:
             return self.create_from_state(state)

valanga/represention_for_evaluation.py

@@ -1,6 +1,4 @@
-"""
-Contains the definition of the ContentRepresentation protocol for content representations used in evaluations.
-"""
+"""Contains the definition of the ContentRepresentation protocol for content representations used in evaluations."""
 
 from typing import Protocol, TypeVar
 
@@ -16,19 +14,23 @@ EvalIn_co = TypeVar(
 
 
 class ContentRepresentation[StateT_contra, EvalIn_co](Protocol):
-    """
-    Protocol defining the interface for a content representation.
+    """Define the interface for a content representation.
+
     It is a function returning the proper input for evaluation by the content evaluator.
     """
 
     def get_evaluator_input(self, state: StateT_contra) -> EvalIn_co:
-        """
-        Returns the evaluator input tensor for the content. Content representations have generally a compressed view and complemetary view of state info so to avoid redundancy and have all the necessary info we also give the state as input.
+        """Return the evaluator input tensor for the content.
+
+        Content representations have generally a compressed view and complementary view
+        of state info so to avoid redundancy and have all the necessary info we also
+        give the state as input.
 
         Args:
             state: The current state of the game.
 
         Returns:
             The evaluator input tensor.
+
         """
         ...

{valanga-0.1.11.dist-info → valanga-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valanga
-Version: 0.1.11
+Version: 0.1.14
 Summary: Shared types and utilities for evaluation
 Author-email: Victor Gabillon <victorgabillon@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -684,11 +684,11 @@ Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: test
-Requires-Dist: pytest>=8.4.1; extra == "test"
+Requires-Dist: pytest>=9.0.2; extra == "test"
 Requires-Dist: coverage; extra == "test"
 Requires-Dist: pytest-cov>=6.0.0; extra == "test"
 Provides-Extra: lint
-Requires-Dist: ruff>=0.14.10; extra == "lint"
+Requires-Dist: ruff>=0.15.0; extra == "lint"
 Requires-Dist: pylint>=4.0.4; extra == "lint"
 Provides-Extra: typecheck
 Requires-Dist: mypy>=1.19.1; extra == "typecheck"
@@ -696,7 +696,7 @@ Requires-Dist: pyright[nodejs]>=1.1.408; extra == "typecheck"
 Provides-Extra: dev
 Requires-Dist: tox>=4.32.0; extra == "dev"
 Requires-Dist: types-PyYAML>=6.0.12.12; extra == "dev"
-Requires-Dist: ruff>=0.14.10; extra == "dev"
+Requires-Dist: ruff>=0.15.0; extra == "dev"
 Requires-Dist: pylint>=4.0.4; extra == "dev"
 Requires-Dist: black>=25.12.0; extra == "dev"
 Requires-Dist: mypy>=1.19.1; extra == "dev"

valanga-0.1.14.dist-info/RECORD

@@ -0,0 +1,15 @@
+valanga/__init__.py,sha256=EIZeHs7lEHU-6tyxJWRSNcTTXuZxJzec7Q5eY1Xy7x0,945
+valanga/evaluations.py,sha256=Ul_Z6H6BvMK17dg62PO0FhJdTksKyL1Gbax56EAl5Do,1459
+valanga/evaluator_types.py,sha256=dRNY297Up2BSIM2557jy6cz0cINzfUHOpqkr1T6SSQM,344
+valanga/game.py,sha256=-zIkTFckqDC3UgJQW8eeUXzFrDgFxJ33hL_ECRPdlS4,6073
+valanga/over_event.py,sha256=E41uIvDXV2f10ZkHbJ85prJupXCM2cbJdfflexhiAac,8114
+valanga/policy.py,sha256=E5SKLAyoaDrIQIzHHPuRJlRSI7cAkYWjhsCi8k2DNkk,1615
+valanga/progress_messsage.py,sha256=sxeLxEYroERh4D9FXPGK7JQCj0aUFpjauCPf2OQNme4,355
+valanga/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valanga/representation_factory.py,sha256=v6Itq7ynCdoy4T2ZvTRxcu6EghLGhgrW_kmxHhG4s5k,2594
+valanga/represention_for_evaluation.py,sha256=2PdnKTjhQgbcTndkCGm4YgvSFMBC62oyFGC_W3M6Ahs,1135
+valanga-0.1.14.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+valanga-0.1.14.dist-info/METADATA,sha256=5tCYgA_Ci8jcmA8PyROrg4BA153I4-X8jsa8Vl5jj8U,44644
+valanga-0.1.14.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+valanga-0.1.14.dist-info/top_level.txt,sha256=cKFLhxKDTqygHnc0xc_L8jDx6oNu5hSHqZ4UExU4xPo,8
+valanga-0.1.14.dist-info/RECORD,,

valanga-0.1.11.dist-info/RECORD

@@ -1,15 +0,0 @@
-valanga/__init__.py,sha256=EFoB5P_lGQCXM1tLTc9ZvO5mt_Ui_MXStEpcPwptwd8,945
-valanga/evaluations.py,sha256=kGq8oU6cV-dlMvX_lSU_AAAWCXlvEGhsXdRt_CmuYvc,1461
-valanga/evaluator_types.py,sha256=dRNY297Up2BSIM2557jy6cz0cINzfUHOpqkr1T6SSQM,344
-valanga/game.py,sha256=7vFLJL0AhG9EqG_Po0hpyFU685YVMWnKYXn-QR2yiOo,6086
-valanga/over_event.py,sha256=jUqN3CXq3e55TvDZatZKFlEOzJfho7M1Zr7VjZUhP6M,7908
-valanga/policy.py,sha256=aYEVRLd9uQGz61vPh0O9KRSmQ6jvzjdmefXgOUVKfmk,1245
-valanga/progress_messsage.py,sha256=3LnOXSgyU84UkwcpsakcbPt_d3el2ojRSUClAwoPyEk,361
-valanga/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valanga/representation_factory.py,sha256=bVG3i3jBqI6vvvbsoBroYUw7gno7Xeu8vkxPmNCooHE,2464
-valanga/represention_for_evaluation.py,sha256=9yCCOuN-h9FnoLJrffKGQ-oXiiXzZT3rP4e5wwMYfys,1135
-valanga-0.1.11.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-valanga-0.1.11.dist-info/METADATA,sha256=nDQ_HBCGwm3_SPPZm3LM9zCHDYzqrAtot5gGFDuXt5o,44646
-valanga-0.1.11.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-valanga-0.1.11.dist-info/top_level.txt,sha256=cKFLhxKDTqygHnc0xc_L8jDx6oNu5hSHqZ4UExU4xPo,8
-valanga-0.1.11.dist-info/RECORD,,