Resolve dependencies (#2)

- Update pyproject.toml (488d2c34fcc65af31ff45339403e85af10bc73c9)
- Update pyproject.toml (aae3f5aa4a517d1a2a4664a3a1d883f1f9117d5a)
- Update Dockerfile (c139fd5ccdb6779b75fb9f5b0e083f0156664bd5)
- update dockerfile (1c018017c14f1998b048fcf40787e723399e5bd1)
- Merge branch 'main' of https://huggingface.co/spaces/ZhiyuanZeng/RLVE_Gym into pr/1 (e5afc3dc9032bc912d3764054a8a66c59bf5fb82)
- fix imports for use (72f5a1d937aa5d17215c90902a7f0b36529ba30b)
- restore toml (3efe9a1b0c0cac285c7f22b85d7d1651deacd790)
- fix toml syntax (aa7b820ccff91b81fbc49425b56ce7f7c4be7593)
- return to non package install (9567311e9b798914cddb7d9d827235dbd3e43b0b)
- add torch (be431d9958efa0b4e9262987a261a612f9987140)
- more dependencies (a68ff1452bd150267373538d7269f6aa90b451b4)


Co-authored-by: ben burtenshaw <[email protected]>

Dockerfile

@@ -78,4 +78,4 @@ HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
 # Run the FastAPI server
 # The module path is constructed to work with the /app/env structure
 ENV ENABLE_WEB_INTERFACE=true
-CMD ["sh", "-c", "cd /app/env && uvicorn RLVE_Gym.server.app:app --host 0.0.0.0 --port 8000"]
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

pyproject.toml

@@ -21,10 +21,10 @@ dependencies = [
     "uvicorn>=0.24.0",
     "requests>=2.31.0",
     # Environment-specific dependencies
+    "torch>=2.0.0",
+    "numpy>=1.19.0",
     # Add all dependencies needed for your environment here
     # Examples:
-    # "numpy>=1.19.0",
-    # "torch>=2.0.0",
     # "gymnasium>=0.29.0",
     # "openspiel>=1.0.0",
     # "smolagents>=1.22.0,<2",
@@ -42,5 +42,11 @@ dev = [
 server = "RLVE_Gym.server.app:main"
 
 [tool.setuptools]
-packages = ["RLVE_Gym", "RLVE_Gym.server"]
-package-dir = { "RLVE_Gym" = ".", "RLVE_Gym.server" = "server" }
+include-package-data = true
+
+[tool.setuptools.package-dir]
+"RLVE_Gym" = "."
+"RLVE_Gym.server" = "server"
+
+[tool.setuptools.packages.find]
+include = ["RLVE_Gym*"]

server/RLVE_Gym_environment.py

@@ -7,17 +7,17 @@
 """
 RLVE-Gym Environment Implementation.
 """
-from openenv_core.env_server.interfaces import Environment
-
-from ..models import RlveGymState, RlveGymAction, RlveGymObservation
 
 from typing import Optional, Tuple
-
 import random
-from .Gym.environment import VerifiableEnvironment
-from .Gym.parameter_controller import ParameterController
-from .Gym.environments import identifier2environment
-from .Gym.parameter_controllers import identifier2controller
+
+from openenv_core.env_server.interfaces import Environment
+
+from models import RlveGymState, RlveGymAction, RlveGymObservation
+from server.Gym.environment import VerifiableEnvironment
+from server.Gym.parameter_controller import ParameterController
+from server.Gym.environments import identifier2environment
+from server.Gym.parameter_controllers import identifier2controller
 
 
 class RlveGymEnvironment(Environment):
@@ -26,26 +26,26 @@ class RlveGymEnvironment(Environment):
     """
 
     def __init__(
-            self,
-            environment_identifier : str = "Multiplication",
-            difficulty : int = 0,
-            answer_markers : Optional[Tuple[str, str]] = None,
-            initial_seed : int = 0,
-            ):
+        self,
+        environment_identifier: str = "Multiplication",
+        difficulty: int = 0,
+        answer_markers: Optional[Tuple[str, str]] = None,
+        initial_seed: int = 0,
+    ):
         """Initialize the RLVE_Gym environment."""
-        
+
         self._state = RlveGymState(
-            seed = initial_seed,
-            problem_input = None,
-            num_samples = 0, sum_accuracy = 0,
+            seed=initial_seed,
+            problem_input=None,
+            num_samples=0,
+            sum_accuracy=0,
         )
-        
+
         self.environment_identifier = environment_identifier
         self.difficulty = difficulty
         self.answer_markers = answer_markers
-        
-        self.problem = None
 
+        self.problem = None
 
     def reset(self) -> RlveGymObservation:
         """
@@ -57,75 +57,78 @@ class RlveGymEnvironment(Environment):
             success: Boolean indicating if the reset was successful
             message: Message indicating the result of the reset
         """
-        if (self.environment_identifier not in identifier2environment) or (self.environment_identifier not in identifier2controller) :
+        if (self.environment_identifier not in identifier2environment) or (
+            self.environment_identifier not in identifier2controller
+        ):
             return RlveGymObservation(
-                problem_input = None,
-                verifier_result = None,
-                success = False,
-                message = "Invalid environment identifier.",
-                reward = None,
+                problem_input=None,
+                verifier_result=None,
+                success=False,
+                message="Invalid environment identifier.",
+                reward=None,
             )
-        if not (isinstance(self.difficulty, int) and self.difficulty >= 0) :
+        if not (isinstance(self.difficulty, int) and self.difficulty >= 0):
             return RlveGymObservation(
-                problem_input = None,
-                verifier_result = None,
-                success = False,
-                message = "Difficulty should be a non-negative integer.",
-                reward = None,
+                problem_input=None,
+                verifier_result=None,
+                success=False,
+                message="Difficulty should be a non-negative integer.",
+                reward=None,
             )
-        if not (isinstance(self._state.seed, int) and self._state.seed >= 0) :
+        if not (isinstance(self._state.seed, int) and self._state.seed >= 0):
             return RlveGymObservation(
-                problem_input = None,
-                verifier_result = None,
-                success = False,
-                message = "Seed should be a non-negative integer.",
-                reward = None,
+                problem_input=None,
+                verifier_result=None,
+                success=False,
+                message="Seed should be a non-negative integer.",
+                reward=None,
+            )
+
+        try:
+            problem: VerifiableEnvironment = identifier2environment[self.environment_identifier](
+                answer_markers=self.answer_markers
             )
-        
-        try :
-            problem : VerifiableEnvironment = identifier2environment[self.environment_identifier](answer_markers = self.answer_markers)
-        except Exception as e :
+        except Exception as e:
             return RlveGymObservation(
-                problem_input = None,
-                verifier_result = None,
-                success = False,
-                message = f"Failed to initialize environment: {e}",
-                reward = None,
+                problem_input=None,
+                verifier_result=None,
+                success=False,
+                message=f"Failed to initialize environment: {e}",
+                reward=None,
             )
 
-        controller : ParameterController = identifier2controller[self.environment_identifier]()
-        for _ in range(self.difficulty) :
+        controller: ParameterController = identifier2controller[self.environment_identifier]()
+        for _ in range(self.difficulty):
             controller.update()
         random.seed(self._state.seed)
         parameter = random.choice(controller.get_parameter_list())
 
-        if problem.generator(seed = self._state.seed, parameter = parameter) :
+        if problem.generator(seed=self._state.seed, parameter=parameter):
             self._state.problem_input = problem.prompt_generator()
             self.problem = problem
-        else :
+        else:
             self._state.problem_input = None
             self.problem = None
-        
+
         self._state.seed += 1
         self._state.num_samples = self._state.sum_accuracy = 0
 
-        if self.problem is not None :
+        if self.problem is not None:
             return RlveGymObservation(
-                problem_input = self._state.problem_input,
-                verifier_result = None,
-                success = True,
-                message = "Problem generated successfully.",
-                reward = None,
+                problem_input=self._state.problem_input,
+                verifier_result=None,
+                success=True,
+                message="Problem generated successfully.",
+                reward=None,
             )
-        else :
+        else:
             return RlveGymObservation(
-                problem_input = None,
-                verifier_result = None,
-                success = False,
-                message = "Problem generation failed. Please try decreasing difficulty or changing seed.",
-                reward = None,
+                problem_input=None,
+                verifier_result=None,
+                success=False,
+                message="Problem generation failed. Please try decreasing difficulty or changing seed.",
+                reward=None,
             )
-        
 
     def step(self, action: RlveGymAction) -> RlveGymObservation:  # type: ignore[override]
         """
@@ -140,38 +143,37 @@ class RlveGymEnvironment(Environment):
             success: Boolean indicating if the step was successful
             message: Message indicating the result of the step
         """
-        if self.problem is None :
+        if self.problem is None:
             return RlveGymObservation(
-                problem_input = None,
-                verifier_result = None,
-                success = False,
-                message = "Problem not ready. Please reset the environment.",
-                reward = None,
+                problem_input=None,
+                verifier_result=None,
+                success=False,
+                message="Problem not ready. Please reset the environment.",
+                reward=None,
             )
-        
-        try :
+
+        try:
             verifier_result = self.problem.verifier(action.output)
-        except Exception as e :
+        except Exception as e:
             return RlveGymObservation(
-                problem_input = self._state.problem_input,
-                verifier_result = None,
-                success = False,
-                message = f"Verification failed with error: {e}",
-                reward = None,
+                problem_input=self._state.problem_input,
+                verifier_result=None,
+                success=False,
+                message=f"Verification failed with error: {e}",
+                reward=None,
             )
-        
+
         self._state.num_samples += 1
         self._state.sum_accuracy += verifier_result["accuracy"]
-        
+
         return RlveGymObservation(
-            problem_input = self._state.problem_input,
-            verifier_result = verifier_result,
-            success = True,
-            message = "Verification completed.",
-            reward = verifier_result["reward"],
+            problem_input=self._state.problem_input,
+            verifier_result=verifier_result,
+            success=True,
+            message="Verification completed.",
+            reward=verifier_result["reward"],
         )
 
-
     @property
     def state(self) -> RlveGymState:
         """

server/app.py

@@ -26,8 +26,8 @@ try:
 except Exception as e:  # pragma: no cover
     raise ImportError("openenv_core is required for the web interface. Install dependencies with '\n    uv sync\n'") from e
 
-from .RLVE_Gym_environment import RlveGymEnvironment
-from ..models import RlveGymAction, RlveGymObservation
+from server.RLVE_Gym_environment import RlveGymEnvironment
+from models import RlveGymAction, RlveGymObservation
 
 # Create the environment instance
 env = RlveGymEnvironment()