pyrlutils 0.1.2__py3-none-any.whl

pyrlutils/td/state_td.py

@@ -0,0 +1,111 @@
+
+from typing import Annotated
+
+import numpy as np
+from npdict import NumpyNDArrayWrappedDict
+
+from .utils import decay_schedule, TimeDifferencePathElements, AbstractStateValueFunctionTemporalDifferenceLearner
+
+
+class SingleStepTemporalDifferenceLearner(AbstractStateValueFunctionTemporalDifferenceLearner):
+    def learn(
+            self,
+            episodes: int
+    ) -> tuple[Annotated[NumpyNDArrayWrappedDict, "1D Array"], Annotated[NumpyNDArrayWrappedDict, "2D Array"]]:
+        V = NumpyNDArrayWrappedDict(
+            [self._state.get_all_possible_state_values()],
+            default_initial_value=0.0
+        )
+        V_track = NumpyNDArrayWrappedDict(
+            [list(range(episodes)), self._state.get_all_possible_state_values()],
+            default_initial_value=0.0
+        )
+        V_array, V_track_array = V.to_numpy(), V_track.to_numpy()
+        alphas = decay_schedule(
+            self.init_alpha, self.min_alpha, self.alpha_decay_ratio, episodes
+        )
+
+        for i in range(episodes):
+            self._state.state_index = self.initial_state_index
+            done = False
+            while not done:
+                old_state_value = self._state.state_value
+                action_value = self._policy.get_action_value(self._state.state_value)
+                action_func = self._actions_dict[action_value]
+                self._state = action_func(self._state)
+                new_state_value = self._state.state_value
+                reward = self._indrewardfcn(old_state_value, action_value, new_state_value)
+                done = self._state.is_terminal
+
+                td_target = reward + self.gamma * V[new_state_value] * (not done)
+                td_error = td_target - V[old_state_value]
+                V[old_state_value] = V[old_state_value] + alphas[i] * td_error
+
+            V_track_array[i, :] = V_array
+
+        return V, V_track
+
+
+class MultipleStepTemporalDifferenceLearner(AbstractStateValueFunctionTemporalDifferenceLearner):
+    def learn(
+            self,
+            episodes: int,
+            n_steps: int=3
+    ) -> tuple[Annotated[NumpyNDArrayWrappedDict, "1D Array"], Annotated[NumpyNDArrayWrappedDict, "2D Array"]]:
+        V = NumpyNDArrayWrappedDict(
+            [self._state.get_all_possible_state_values()],
+            default_initial_value=0.0
+        )
+        V_track = NumpyNDArrayWrappedDict(
+            [list(range(episodes)), self._state.get_all_possible_state_values()],
+            default_initial_value=0.0
+        )
+        V_array, V_track_array = V.to_numpy(), V_track.to_numpy()
+        alphas = decay_schedule(
+            self.init_alpha, self.min_alpha, self.alpha_decay_ratio, episodes
+        )
+        discounts = np.logspace(0, n_steps-1, num=n_steps+1, base=self.gamma, endpoint=False)
+
+        for i in range(episodes):
+            self._state.state_index = self.initial_state_index
+            done = False
+            path = []
+
+            while not done or path is not None:
+                path = path[1:]     # worth revisiting this line
+
+                new_state_value = self._state._get_state_value_from_index(self._state.nb_state_values-1)
+                while not done and len(path) < n_steps:
+                    old_state_value = self._state.state_value
+                    action_value = self._policy.get_action_value(self._state.state_value)
+                    action_func = self._actions_dict[action_value]
+                    self._state = action_func(self._state)
+                    new_state_value = self._state.state_value
+                    reward = self._indrewardfcn(old_state_value, action_value, new_state_value)
+                    done = self._state.is_terminal
+
+                    path.append(
+                        TimeDifferencePathElements(
+                            this_state_value=old_state_value,
+                            reward=reward,
+                            next_state_value=new_state_value,
+                            done=done
+                        )
+                    )
+                    if done:
+                        break
+
+                n = len(path)
+                estimated_state_value = path[0].this_state_value
+                rewards = np.array([this_moment.reward for this_moment in path])
+                partial_return = discounts[n:] * rewards
+                bs_val = discounts[-1] * V[new_state_value] * (not done)
+                ntd_target = np.sum(np.append(partial_return, bs_val))
+                ntd_error = ntd_target - V[estimated_state_value]
+                V[(estimated_state_value,)] = V[estimated_state_value] + alphas[i] * ntd_error
+                if len(path) == 1 and path[0].done:
+                    path = None
+
+            V_track_array[i, :] = V_array
+
+        return V, V_track

pyrlutils/td/utils.py

@@ -0,0 +1,258 @@
+
+from typing import Annotated, Union, Optional
+from dataclasses import dataclass
+from abc import ABC, abstractmethod
+
+import numpy as np
+from numpy.typing import NDArray
+from npdict import NumpyNDArrayWrappedDict
+
+from ..state import DiscreteStateValueType
+from ..action import DiscreteActionValueType
+from ..policy import DiscretePolicy
+from ..transition import TransitionProbabilityFactory
+
+
+def decay_schedule(
+        init_value: float,
+        min_value: float,
+        decay_ratio: float,
+        max_steps: int,
+        log_start: int=-2,
+        log_base: int=10
+) -> Annotated[NDArray[np.float64], "1D Array"]:
+    decay_steps = int(max_steps*decay_ratio)
+    rem_steps = max_steps - decay_steps
+
+    values = np.logspace(log_start, 0, decay_steps, base=log_base, endpoint=True)[::-1]
+    values = (values - values.min()) / (values.max() - values.min())
+    values = (init_value - min_value) * values + min_value
+    values = np.pad(values, (0, rem_steps), 'edge')
+    return values
+
+
+def select_action(
+        state_value: DiscreteStateValueType,
+        Q: Union[Annotated[NDArray[np.float64], "2D Array"], NumpyNDArrayWrappedDict],
+        epsilon: float,
+) -> Union[DiscreteActionValueType, int]:
+    if np.random.random() <= epsilon:
+        if isinstance(Q, NumpyNDArrayWrappedDict):
+            return np.random.choice(Q._lists_keystrings[1])
+        else:
+            return np.random.choice(np.arange(Q.shape[1]))
+
+    q_matrix = Q.to_numpy() if isinstance(Q, NumpyNDArrayWrappedDict) else Q
+    state_index = Q.get_key_index(0, state_value) if isinstance(Q, NumpyNDArrayWrappedDict) else state_value
+    max_index = np.argmax(q_matrix[state_index, :])
+
+    if isinstance(Q, NumpyNDArrayWrappedDict):
+        return Q._lists_keystrings[1][max_index]
+    else:
+        return max_index
+
+
+@dataclass
+class TimeDifferencePathElements:
+    this_state_value: DiscreteStateValueType
+    reward: float
+    next_state_value: DiscreteStateValueType
+    done: bool
+
+
+class AbstractStateValueFunctionTemporalDifferenceLearner(ABC):
+    def __init__(
+            self,
+            transprobfac: TransitionProbabilityFactory,
+            gamma: float=1.0,
+            init_alpha: float=0.5,
+            min_alpha: float=0.01,
+            alpha_decay_ratio: float=0.3,
+            policy: Optional[DiscretePolicy]=None,
+            initial_state_index: int=0
+    ):
+        self._gamma = gamma
+        self._init_alpha = init_alpha
+        self._min_alpha = min_alpha
+        try:
+            assert 0.0 <= alpha_decay_ratio <= 1.0
+        except AssertionError:
+            raise ValueError("alpha_decay_ratio must be between 0 and 1!")
+        self._alpha_decay_ratio = alpha_decay_ratio
+        self._transprobfac = transprobfac
+        self._state, self._actions_dict, self._indrewardfcn = self._transprobfac.generate_mdp_objects()
+        self._action_names = list(self._actions_dict.keys())
+        self._actions_to_indices = {action_value: idx for idx, action_value in enumerate(self._action_names)}
+        self._policy = policy
+        try:
+            assert 0 <= initial_state_index < self._state.nb_state_values
+        except AssertionError:
+            raise ValueError(f"Initial state index must be between 0 and {self._state.nb_state_values}")
+        self._init_state_index = initial_state_index
+
+    @abstractmethod
+    def learn(self, *args, **kwargs) -> tuple[Annotated[NDArray[np.float64], "1D Array"], Annotated[NDArray[np.float64], "2D Array"]]:
+        raise NotImplementedError()
+
+    @property
+    def nb_states(self) -> int:
+        return self._state.nb_state_values
+
+    @property
+    def policy(self) -> DiscretePolicy:
+        return self._policy
+
+    @policy.setter
+    def policy(self, val: DiscretePolicy):
+        self._policy = val
+
+    @property
+    def gamma(self) -> float:
+        return self._gamma
+
+    @gamma.setter
+    def gamma(self, val: float):
+        self._gamma = val
+
+    @property
+    def init_alpha(self) -> float:
+        return self._init_alpha
+
+    @init_alpha.setter
+    def init_alpha(self, val: float):
+        self._init_alpha = val
+
+    @property
+    def min_alpha(self) -> float:
+        return self._min_alpha
+
+    @min_alpha.setter
+    def min_alpha(self, val: float):
+        self._min_alpha = val
+
+    @property
+    def alpha_decay_ratio(self) -> float:
+        return self._alpha_decay_ratio
+
+    @property
+    def initial_state_index(self) -> int:
+        return self._init_state_index
+
+    @initial_state_index.setter
+    def initial_state_index(self, val: int):
+        self._init_state_index = val
+
+
+
+class AbstractStateActionValueFunctionTemporalDifferenceLearner(ABC):
+    def __init__(
+            self,
+            transprobfac: TransitionProbabilityFactory,
+            gamma: float=1.0,
+            init_alpha: float=0.5,
+            min_alpha: float=0.01,
+            alpha_decay_ratio: float=0.3,
+            init_epsilon: float=1.0,
+            min_epsilon: float=0.1,
+            epsilon_decay_ratio: float=0.9,
+            policy: Optional[DiscretePolicy]=None,
+            initial_state_index: int=0
+    ):
+        self._gamma = gamma
+        self._init_alpha = init_alpha
+        self._min_alpha = min_alpha
+        try:
+            assert 0.0 <= alpha_decay_ratio <= 1.0
+        except AssertionError:
+            raise ValueError("alpha_decay_ratio must be between 0 and 1!")
+        self._alpha_decay_ratio = alpha_decay_ratio
+        self._init_epsilon = init_epsilon
+        self._min_epsilon = min_epsilon
+        self._epsilon_decay_ratio = epsilon_decay_ratio
+
+        self._transprobfac = transprobfac
+        self._state, self._actions_dict, self._indrewardfcn = self._transprobfac.generate_mdp_objects()
+        self._action_names = list(self._actions_dict.keys())
+        self._actions_to_indices = {action_value: idx for idx, action_value in enumerate(self._action_names)}
+        self._policy = policy
+        try:
+            assert 0 <= initial_state_index < self._state.nb_state_values
+        except AssertionError:
+            raise ValueError(f"Initial state index must be between 0 and {self._state.nb_state_values}")
+        self._init_state_index = initial_state_index
+
+    @abstractmethod
+    def learn(self, *args, **kwargs) -> tuple[Annotated[NDArray[np.float64], "1D Array"], Annotated[NDArray[np.float64], "2D Array"]]:
+        raise NotImplementedError()
+
+    @property
+    def nb_states(self) -> int:
+        return self._state.nb_state_values
+
+    @property
+    def policy(self) -> DiscretePolicy:
+        return self._policy
+
+    @policy.setter
+    def policy(self, val: DiscretePolicy):
+        self._policy = val
+
+    @property
+    def gamma(self) -> float:
+        return self._gamma
+
+    @gamma.setter
+    def gamma(self, val: float):
+        self._gamma = val
+
+    @property
+    def init_alpha(self) -> float:
+        return self._init_alpha
+
+    @init_alpha.setter
+    def init_alpha(self, val: float):
+        self._init_alpha = val
+
+    @property
+    def min_alpha(self) -> float:
+        return self._min_alpha
+
+    @min_alpha.setter
+    def min_alpha(self, val: float):
+        self._min_alpha = val
+
+    @property
+    def alpha_decay_ratio(self) -> float:
+        return self._alpha_decay_ratio
+
+    @property
+    def init_epsilon(self) -> float:
+        return self._init_epsilon
+
+    @init_epsilon.setter
+    def init_epsilon(self, val: float):
+        self._init_epsilon = val
+
+    @property
+    def min_epsilon(self) -> float:
+        return self._min_epsilon
+
+    @min_epsilon.setter
+    def min_epsilon(self, val: float):
+        self._min_epsilon = val
+
+    @property
+    def epsilon_decay_ratio(self) -> float:
+        return self._epsilon_decay_ratio
+
+    @epsilon_decay_ratio.setter
+    def epsilon_decay_ratio(self, val: float):
+        self._epsilon_decay_ratio = val
+
+    @property
+    def initial_state_index(self) -> int:
+        return self._init_state_index
+
+    @initial_state_index.setter
+    def initial_state_index(self, val: int):
+        self._init_state_index = val

pyrlutils/transition.py

@@ -0,0 +1,155 @@
+
+from types import LambdaType, FunctionType
+from typing import Union
+from dataclasses import dataclass
+
+import numpy as np
+
+from .state import DiscreteState, DiscreteStateValueType
+from .reward import IndividualRewardFunction
+from .action import Action, DiscreteActionValueType
+
+
+@dataclass
+class NextStateTuple:
+    next_state_value: DiscreteStateValueType
+    probability: float
+    reward: float
+    terminal: bool
+
+
+class TransitionProbabilityFactory:
+    def __init__(self):
+        self._transprobs = {}
+        self._all_state_values = []
+        self._all_action_values = []
+        self._objects_generated = False
+
+    def add_state_transitions(
+            self,
+            state_value: DiscreteStateValueType,
+            action_values_to_next_state: dict[DiscreteActionValueType, Union[list[NextStateTuple], dict]]
+    ):
+        if state_value not in self._all_state_values:
+            self._all_state_values.append(state_value)
+
+        this_state_transition_dict = {}
+
+        for action_value, next_state_tuples in action_values_to_next_state.items():
+            this_state_transition_dict[action_value] = []
+            for next_state_tuple in next_state_tuples:
+                if action_value not in self._all_action_values:
+                    self._all_action_values.append(action_value)
+                if not isinstance(next_state_tuple, NextStateTuple):
+                    if isinstance(next_state_tuple, dict):
+                        next_state_tuple = NextStateTuple(
+                            next_state_tuple['next_state_value'],
+                            next_state_tuple['probability'],
+                            next_state_tuple['reward'],
+                            next_state_tuple['terminal']
+                        )
+                    else:
+                        raise TypeError('"action_values_to_next_state" has to be a dictionary or NextStateTuple instance.')
+
+                if next_state_tuple.next_state_value not in self._all_state_values:
+                    self._all_state_values.append(next_state_tuple.next_state_value)
+
+                this_state_transition_dict[action_value].append(next_state_tuple)
+
+        self._transprobs[state_value] = this_state_transition_dict
+
+    def _get_probs_for_eachstate(
+            self,
+            action_value: DiscreteActionValueType
+    ) -> dict[DiscreteStateValueType, list[NextStateTuple]]:
+        state_nexttuples = {}
+        for state_value, action_nexttuples_pair in self._transprobs.items():
+            for this_action_value, nexttuples in action_nexttuples_pair.items():
+                if this_action_value == action_value:
+                    state_nexttuples[state_value] = nexttuples
+        return state_nexttuples
+
+    def _generate_action_function(
+            self,
+            state_nexttuples: dict[DiscreteStateValueType, list[NextStateTuple]]
+    ) -> Union[FunctionType, LambdaType]:
+
+        def _action_function(state: DiscreteState) -> DiscreteState:
+            nexttuples = state_nexttuples[state.state_value]
+            nextstates = [nexttuple.next_state_value for nexttuple in nexttuples]
+            probs = [nexttuple.probability for nexttuple in nexttuples]
+            next_state_value = np.random.choice(nextstates, p=probs)
+            state.set_state_value(next_state_value)
+            return state
+
+        return _action_function
+
+    def _generate_individual_reward_function(self) -> IndividualRewardFunction:
+
+        def _individual_reward_function(
+                state_value: DiscreteStateValueType,
+                action_value: DiscreteActionValueType,
+                next_state_value: DiscreteStateValueType
+        ) -> float:
+            if state_value not in self._transprobs.keys():
+                return 0.
+
+            if action_value not in self._transprobs[state_value].keys():
+                return 0.
+
+            reward = 0.
+            for next_tuple in self._transprobs[state_value][action_value]:
+                if next_tuple.next_state_value == next_state_value:
+                    reward += next_tuple.reward
+            return reward
+
+        class ThisIndividualRewardFunction(IndividualRewardFunction):
+            def reward(
+                    self,
+                    state_value: DiscreteStateValueType,
+                    action_value: DiscreteActionValueType,
+                    next_state_value: DiscreteStateValueType
+            ) -> float:
+                return _individual_reward_function(state_value, action_value, next_state_value)
+
+        return ThisIndividualRewardFunction()
+
+    def get_probability(
+            self,
+            state_value: DiscreteStateValueType,
+            action_value: DiscreteActionValueType,
+            new_state_value: DiscreteStateValueType
+    ) -> float:
+        if state_value not in self._transprobs.keys():
+            return 0.
+
+        if action_value not in self._transprobs[state_value]:
+            return 0.
+
+        probs = 0.
+        for next_state_tuple in self._transprobs[state_value][action_value]:
+            if next_state_tuple.next_state_value == new_state_value:
+                probs += next_state_tuple.probability
+        return probs
+
+    @property
+    def transition_probabilities(self) -> dict[DiscreteStateValueType, dict[DiscreteActionValueType, list[NextStateTuple]]]:
+        return self._transprobs
+
+    def generate_mdp_objects(self) -> tuple[DiscreteState, dict[DiscreteActionValueType, Action], IndividualRewardFunction]:
+        state = DiscreteState(self._all_state_values)
+        actions_dict = {}
+        for action_value in self._all_action_values:
+            state_nexttuple = self._get_probs_for_eachstate(action_value)
+            actions_dict[action_value] = Action(self._generate_action_function(state_nexttuple))
+            for next_tuples in state_nexttuple.values():
+                for next_tuple in next_tuples:
+                    state._terminal_dict[next_tuple.next_state_value] = next_tuple.terminal
+
+        individual_reward_fcn = self._generate_individual_reward_function()
+        self._objects_generated = True
+        return state, actions_dict, individual_reward_fcn
+
+    @property
+    def objects_generated(self) -> bool:
+        return self._objects_generated

pyrlutils-0.1.2.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: pyrlutils
+Version: 0.1.2
+Summary: Utility and Helpers for Reinformcement Learning
+Author-email: Kwan Yuet Stephen Ho <stephenhky@yahoo.com.hk>
+License: MIT
+Project-URL: Repository, https://github.com/stephenhky/PyRLUtils
+Project-URL: Issues, https://github.com/stephenhky/PyRLUtils/issues
+Keywords: machine learning,reinforcement leaning,artificial intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: npdict>=0.0.7
+Requires-Dist: typing-extensions
+Provides-Extra: openaigym
+Requires-Dist: gymnasium; extra == "openaigym"
+Provides-Extra: test
+Requires-Dist: unittest; extra == "test"
+Dynamic: license-file
+
+# PyRLUtils 
+
+[![CircleCI](https://circleci.com/gh/stephenhky/PyRLUtils.svg?style=svg)](https://circleci.com/gh/stephenhky/PyRLUtils.svg)
+[![GitHub release](https://img.shields.io/github/release/stephenhky/PyRLUtils.svg?maxAge=3600)](https://github.com/stephenhky/pyqentangle/PyRLUtils)
+[![pypi](https://img.shields.io/pypi/v/PyRLUtils.svg?maxAge=3600)](https://pypi.org/project/pyqentangle/)
+[![download](https://img.shields.io/pypi/dm/PyRLUtils.svg?maxAge=2592000&label=installs&color=%2327B1FF)](https://pypi.org/project/PyRLUtils/)
+[![Updates](https://pyup.io/repos/github/stephenhky/PyRLUtils/shield.svg)](https://pyup.io/repos/github/stephenhky/PyRLUtils/)
+[![Python 3](https://pyup.io/repos/github/stephenhky/PyRLUtils/python-3-shield.svg)](https://pyup.io/repos/github/stephenhky/PyRLUtils/)
+
+
+This is a Python package with utility classes and helper functions for
+that facilitates the development of any reinformecement learning projects.

pyrlutils-0.1.2.dist-info/RECORD

@@ -0,0 +1,26 @@
+pyrlutils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyrlutils/action.py,sha256=QoBdtcGtK_EkYAjb50bruhoB_XIz0agLpQjdGFnGbRQ,732
+pyrlutils/policy.py,sha256=A9bj2eVd6XjNNkClSYVJDoxoGuGkyoYVr1DpVdI0wzs,5120
+pyrlutils/reward.py,sha256=are0swsobMqI1IbrBVBaPMYXWpJnp6lZwAyfgBEm2zg,1211
+pyrlutils/state.py,sha256=h-OGrezt0fWfVdM9-BTfqdhx1Ert_utG0ORpIwHwXCw,11902
+pyrlutils/transition.py,sha256=_32jxeYbsiKyaHR9Y2XceUQYbb1jslLCQO2AWL61_EU,6260
+pyrlutils/bandit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyrlutils/bandit/algo.py,sha256=X2Pn4DOi-RXWz5CNg1h0RJCoV3VlAwEGHRMjkfbckfw,3969
+pyrlutils/bandit/reward.py,sha256=l2H_gZk2qqDxZioHe1M28pD8N47fgSR-K0Q6muchVd0,282
+pyrlutils/dp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyrlutils/dp/valuefcns.py,sha256=0T7vzdKRIKhLMsaq7JgPqONMmq4lWRGPj7xPtuxVtbE,6546
+pyrlutils/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyrlutils/helpers/exceptions.py,sha256=4fPGW839BChfap-Gd7b-75Dz-Ed3foqbJQ1lg15TZ-4,192
+pyrlutils/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyrlutils/openai/utils.py,sha256=PJc9WHZM8aM4Z9MlACUxUC8TO7VARp8taatba_ikhew,1056
+pyrlutils/td/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyrlutils/td/doubleqlearn.py,sha256=BbNOBaTUSiKD9z_IPFjl2R40bEf_xzZESv1fNEn7-Jg,4375
+pyrlutils/td/qlearn.py,sha256=ZibW_fuB89ZAST5snNYLe5H_zUIMZ93vuJXguXpccyo,3374
+pyrlutils/td/sarsa.py,sha256=jtnfMdPHld9C8yzDMQd3xyLZ3BwGL6ShvDq5WpHfZEo,3281
+pyrlutils/td/state_td.py,sha256=gMX-RuSZQ-UIoTWnsmR7xLZvL2jndRknXTExWnhixpM,4778
+pyrlutils/td/utils.py,sha256=VM5MAfWLQIk6a_qENU-iWHglp1azlaP68qkHvl4jXro,8022
+pyrlutils-0.1.2.dist-info/licenses/LICENSE,sha256=bnQPjIcaeBdr2ZofX-_j-nELs8pAx5fQ4Cdfgeaspew,1063
+pyrlutils-0.1.2.dist-info/METADATA,sha256=wjoPuC3G6WLmZdBUd8eqjgjI32FYuBejiUkT-CAs7JY,2214
+pyrlutils-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyrlutils-0.1.2.dist-info/top_level.txt,sha256=gOBuxugE2MA4WDXlLhzkQh_rUonZU6nvJnMuomeHMCU,10
+pyrlutils-0.1.2.dist-info/RECORD,,

pyrlutils-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyrlutils-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2023 Kwan Yuet Stephen Ho
+
+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.

pyrlutils-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyrlutils