dfa-gym 0.1.0__py3-none-any.whl

dfa_gym/__init__.py

@@ -0,0 +1,16 @@
+from dfa_gym.dfa_env import *
+from dfa_gym.dfa_wrapper import *
+
+from dfa_samplers import RADSampler
+from gymnasium.envs.registration import register
+
+register(
+    id='DFAEnv-v0',
+    entry_point='dfa_gym.dfa_env:DFAEnv',
+    kwargs = {"sampler": RADSampler(n_tokens=12), "timeout": 75}
+)
+
+register(
+    id='DFAEnv-v1',
+    entry_point='dfa_gym.dfa_env:DFAEnv'
+)

dfa_gym/dfa_env.py

@@ -0,0 +1,45 @@
+import numpy as np
+import gymnasium as gym
+from gymnasium import spaces
+from dfa_samplers import DFASampler, RADSampler
+
+from typing import Any
+
+__all__ = ["DFAEnv"]
+
+class DFAEnv(gym.Env):
+    def __init__(
+        self,
+        sampler: DFASampler | None = None,
+        timeout: int = 100
+    ):
+        super().__init__()
+        self.sampler = sampler if sampler is not None else RADSampler()
+        self.size_bound = self.sampler.get_size_bound()
+        self.action_space = spaces.Discrete(self.sampler.n_tokens)
+        self.observation_space = spaces.Box(low=0, high=9, shape=(self.size_bound,), dtype=np.int64)
+        self.dfa = None
+        self.timeout = timeout
+        self.t = None
+
+    def reset(self, seed: int | None = None, options: dict[str, Any] | None = None) -> tuple[np.ndarray, dict[str, Any]]:
+        np.random.seed(seed)
+        self.dfa = self.sampler.sample()
+        self.t = 0
+        return self._get_dfa_obs(), {}
+
+    def step(self, action: int) -> tuple[np.ndarray, int, bool, bool, dict[str, Any]]:
+        self.dfa = self.dfa.advance([action]).minimize()
+        reward = 0
+        if self.dfa._label(self.dfa.start):
+            reward = 1
+        elif self.dfa.find_word() is None:
+            reward = -1
+        self.t += 1
+        done = reward != 0 or self.t > self.timeout
+        return self._get_dfa_obs(), reward, done, False, {}
+
+    def _get_dfa_obs(self) -> np.ndarray:
+        dfa_obs = np.array([int(i) for i in str(self.dfa.to_int())])
+        obs = np.pad(dfa_obs, (self.size_bound - dfa_obs.shape[0], 0), constant_values=0)
+        return obs

dfa_gym/dfa_wrapper.py

@@ -0,0 +1,57 @@
+import numpy as np
+import gymnasium as gym
+from gymnasium import spaces
+from dfa_samplers import DFASampler, RADSampler
+
+from typing import Any
+
+__all__ = ["DFAWrapper"]
+
+class DFAWrapper(gym.Wrapper):
+    def __init__(
+        self,
+        env_id: str,
+        sampler: DFASampler | None = None,
+        label_f: callable = None,
+        r_agg_f: callable = None
+    ):
+        super().__init__(gym.make(env_id))
+        self.sampler = sampler if sampler is not None else RADSampler()
+        self.label_f = label_f if label_f is not None else lambda obs: np.random.choice(self.sampler.n_tokens)
+        self.r_agg_f = r_agg_f if r_agg_f is not None else lambda _, dfa_reward: dfa_reward
+        self.size_bound = self.sampler.get_size_bound()
+        self.action_space = self.env.action_space
+        self.observation_space = spaces.Dict({
+            "obs": self.env.observation_space,
+            "dfa_obs": spaces.Box(low=0, high=9, shape=(self.size_bound,), dtype=np.int64),
+        })
+        self.dfa = None
+
+    def reset(self, seed: int | None = None, options: dict[str, Any] | None = None) -> tuple[np.ndarray, dict[str, Any]]:
+        np.random.seed(seed)
+        obs, info = self.env.reset(seed=seed, options=options)
+        self.dfa = self.sampler.sample()
+        dfa_obs = self._get_dfa_obs()
+        obs = {"obs": obs, "dfa_obs": dfa_obs}
+        return obs, info
+
+    def step(self, action: int) -> tuple[np.ndarray, int, bool, bool, dict[str, Any]]:
+        obs, reward, done, truncated, info = self.env.step(action)
+        symbol = self.label_f(obs)
+        if symbol is not None:
+            self.dfa = self.dfa.advance([symbol]).minimize()
+        dfa_obs = self._get_dfa_obs()
+        obs = {"obs": obs, "dfa_obs": dfa_obs}
+        dfa_reward = 0
+        if self.dfa._label(self.dfa.start):
+            dfa_reward = 1
+        elif self.dfa.find_word() is None:
+            dfa_reward = -1
+        reward = self.r_agg_f(reward, dfa_reward)
+        done = done or dfa_reward != 0
+        return obs, reward, done, truncated, info
+
+    def _get_dfa_obs(self) -> np.ndarray:
+        dfa_arr = np.array([int(i) for i in str(self.dfa.to_int())])
+        dfa_obs = np.pad(dfa_arr, (self.size_bound - dfa_arr.shape[0], 0), constant_values=0)
+        return dfa_obs

dfa_gym-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: dfa-gym
+Version: 0.1.0
+Summary: Gymnasium environment for solving DFAs and wrapping other environments with DFA goals
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: dfa-samplers>=0.1.0
+Requires-Dist: gymnasium>=1.0.0
+Description-Content-Type: text/markdown
+
+# dfa-gym

dfa_gym-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+dfa_gym/__init__.py,sha256=tLY48NluNVv66znFnlR7j9o-pRW5caaO766W724__HY,364
+dfa_gym/dfa_env.py,sha256=u-mOCPhXRljp2t-VmvDfsHbKIdHdn59UGomHxUa_BxQ,1601
+dfa_gym/dfa_wrapper.py,sha256=11eqfyl6g2v-wILGMWLg9L2sMJYnwl5rMn11p9YbQF0,2283
+dfa_gym-0.1.0.dist-info/METADATA,sha256=W_S2r-zMFEX9oeVJa3kCVCStnhQ91rNj-tA_FO6oBm8,309
+dfa_gym-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dfa_gym-0.1.0.dist-info/licenses/LICENSE,sha256=Cvu0BZqt3rcFFv70hcFDgD_y8ryOKW85F-qGRfYI4iM,1071
+dfa_gym-0.1.0.dist-info/RECORD,,

dfa_gym-0.1.0.dist-info/WHEEL

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

dfa_gym-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RAD-Embeddings
+
+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.