textpolicy 0.1.0__tar.gz → 0.1.1__tar.gz

{textpolicy-0.1.0/textpolicy.egg-info → textpolicy-0.1.1}/PKG-INFO

@@ -1,7 +1,17 @@
 Metadata-Version: 2.4
 Name: textpolicy
-Version: 0.1.0
-Summary: MLX-optimized reward and verification system for text generation RL
+Version: 0.1.1
+Summary: Reinforcement learning for text generation on MLX (Apple Silicon): GRPO/GSPO, environments, rollout, rewards, LoRA/QLoRA
+Project-URL: Homepage, https://github.com/teilomillet/textpolicy
+Project-URL: Repository, https://github.com/teilomillet/textpolicy
+Project-URL: Documentation, https://github.com/teilomillet/textpolicy#readme
+Project-URL: Changelog, https://github.com/teilomillet/textpolicy/blob/main/CHANGELOG.md
+Keywords: reinforcement-learning,text-generation,mlx,apple-silicon,lora,qlora,grpo,gspo,rlhf
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE

textpolicy-0.1.1/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["textpolicy*"]
+
+[project]
+name = "textpolicy"
+version = "0.1.1"
+description = "Reinforcement learning for text generation on MLX (Apple Silicon): GRPO/GSPO, environments, rollout, rewards, LoRA/QLoRA"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "numpy>=2.3.2",
+    "mlx>=0.21.0", # Core MLX framework for Apple Silicon acceleration
+    "mlx-lm>=0.21.0", # MLX language models for inference
+    "gymnasium>=0.29.0", 
+    "psutil>=7.0.0",
+    "wandb>=0.21.1",
+    "aiohttp>=3.12.15",
+    "pytest>=8.4.1",
+]
+
+keywords = [
+    "reinforcement-learning",
+    "text-generation",
+    "mlx",
+    "apple-silicon",
+    "lora",
+    "qlora",
+    "grpo",
+    "gspo",
+    "rlhf",
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: MacOS",
+    "Intended Audience :: Developers",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+Homepage = "https://github.com/teilomillet/textpolicy"
+Repository = "https://github.com/teilomillet/textpolicy"
+Documentation = "https://github.com/teilomillet/textpolicy#readme"
+Changelog = "https://github.com/teilomillet/textpolicy/blob/main/CHANGELOG.md"
+
+[project.scripts]
+textpolicy = "textpolicy.cli:main"
+
+[project.optional-dependencies]
+external = ["aiohttp>=3.8.0", "pydantic>=2.0.0"]
+dev = ["pytest>=7.0.0", "black>=22.0.0", "ruff>=0.1.0"]

textpolicy-0.1.1/tests/test_issue_fixes.py

@@ -0,0 +1,218 @@
+"""
+Tests for GitHub Issues #2 and #3 fixes.
+
+Issue #2: TextGenerationEnv cannot pass example metadata to reward functions
+Issue #3: Export @verifier decorator at top level for API consistency
+"""
+
+import pytest
+
+
+class TestIssue3VerifierExport:
+    """Test that @verifier decorator is exported at top level (Issue #3)."""
+
+    def test_verifier_accessible_at_top_level(self):
+        """tp.verifier should be accessible without deep import."""
+        import textpolicy as tp
+
+        assert hasattr(tp, "verifier"), "verifier should be exported at top level"
+        assert callable(tp.verifier), "verifier should be callable"
+
+    def test_verifier_same_as_deep_import(self):
+        """tp.verifier should be the same function as deep import."""
+        import textpolicy as tp
+        from textpolicy.rewards import verifier
+
+        assert tp.verifier is verifier, "tp.verifier should be same as textpolicy.rewards.verifier"
+
+    def test_verifier_decorator_works(self):
+        """@tp.verifier should work as a decorator."""
+        import textpolicy as tp
+
+        @tp.verifier
+        def my_test_verifier(prompt, completion, example, **kwargs):
+            return len(completion) > 0
+
+        # Verify it's registered and callable
+        assert callable(my_test_verifier)
+        result = my_test_verifier("test prompt", "test completion", {})
+        assert isinstance(result, bool)
+
+    def test_reward_and_verifier_both_at_top_level(self):
+        """Both @reward and @verifier should be at top level for API consistency."""
+        import textpolicy as tp
+
+        assert hasattr(tp, "reward"), "reward should be at top level"
+        assert hasattr(tp, "verifier"), "verifier should be at top level"
+
+
+@pytest.mark.integration
+class TestIssue2ExamplesParameter:
+    """Test that TextGenerationEnv passes example metadata to reward functions (Issue #2)."""
+
+    @pytest.fixture
+    def dummy_tokenizer(self):
+        """Provide a minimal tokenizer for tests."""
+        class DummyTokenizer:
+            def encode(self, text):
+                return [ord(c) % 256 for c in text]
+
+            def decode(self, ids):
+                return "".join(chr(int(i) % 256) for i in ids)
+
+        return DummyTokenizer()
+
+    def test_env_accepts_examples_parameter(self, dummy_tokenizer):
+        """TextGenerationEnv should accept an examples parameter."""
+        from textpolicy.environment.text_generation import TextGenerationEnv
+
+        prompts = ["Hello", "World"]
+        examples = [{"key": "value1"}, {"key": "value2"}]
+
+        def reward_fn(prompt, completion, example, **kwargs):
+            return 1.0
+
+        # Should not raise
+        env = TextGenerationEnv(
+            prompts=prompts,
+            reward_fn=reward_fn,
+            tokenizer=dummy_tokenizer,
+            examples=examples,
+        )
+        assert env.examples == examples
+
+    def test_env_defaults_to_empty_dicts_when_no_examples(self, dummy_tokenizer):
+        """When examples not provided, should default to empty dicts."""
+        from textpolicy.environment.text_generation import TextGenerationEnv
+
+        prompts = ["Hello", "World"]
+
+        def reward_fn(prompt, completion, example, **kwargs):
+            return 1.0
+
+        env = TextGenerationEnv(
+            prompts=prompts, reward_fn=reward_fn, tokenizer=dummy_tokenizer
+        )
+
+        assert env.examples == [{}, {}]
+
+    def test_env_validates_examples_length(self, dummy_tokenizer):
+        """Should raise ValueError if examples length != prompts length."""
+        from textpolicy.environment.text_generation import TextGenerationEnv
+
+        prompts = ["Hello", "World"]
+        examples = [{"key": "value1"}]  # Wrong length
+
+        def reward_fn(prompt, completion, example, **kwargs):
+            return 1.0
+
+        with pytest.raises(ValueError, match="examples length.*must match prompts length"):
+            TextGenerationEnv(
+                prompts=prompts,
+                reward_fn=reward_fn,
+                tokenizer=dummy_tokenizer,
+                examples=examples,
+            )
+
+    def test_example_passed_to_reward_function(self, dummy_tokenizer):
+        """Reward function should receive the correct example for each prompt."""
+        from textpolicy.environment.text_generation import TextGenerationEnv
+
+        prompts = ["Question 1", "Question 2"]
+        examples = [
+            {"db_id": "database_1", "gold_sql": "SELECT 1"},
+            {"db_id": "database_2", "gold_sql": "SELECT 2"},
+        ]
+
+        received_examples = []
+
+        def capture_reward(prompt, completion, example, **kwargs):
+            received_examples.append(example.copy())
+            return 1.0
+
+        env = TextGenerationEnv(
+            prompts=prompts,
+            reward_fn=capture_reward,
+            tokenizer=dummy_tokenizer,
+            examples=examples,
+        )
+
+        # Episode 0 should use examples[0]
+        env.reset()
+        env.step("some response")
+        assert received_examples[0] == {"db_id": "database_1", "gold_sql": "SELECT 1"}
+
+        # Episode 1 should use examples[1]
+        env.reset()
+        env.step("another response")
+        assert received_examples[1] == {"db_id": "database_2", "gold_sql": "SELECT 2"}
+
+    def test_examples_cycle_with_prompts(self, dummy_tokenizer):
+        """Examples should cycle correctly when prompts cycle."""
+        from textpolicy.environment.text_generation import TextGenerationEnv
+
+        prompts = ["P1", "P2"]
+        examples = [{"idx": 0}, {"idx": 1}]
+
+        received_indices = []
+
+        def capture_reward(prompt, completion, example, **kwargs):
+            received_indices.append(example.get("idx"))
+            return 1.0
+
+        env = TextGenerationEnv(
+            prompts=prompts,
+            reward_fn=capture_reward,
+            tokenizer=dummy_tokenizer,
+            examples=examples,
+        )
+
+        # Run 4 episodes (should cycle through prompts twice)
+        for _ in range(4):
+            env.reset()
+            env.step("response")
+
+        # Should have received [0, 1, 0, 1]
+        assert received_indices == [0, 1, 0, 1]
+
+    def test_litmus_test_from_issue(self, dummy_tokenizer):
+        """Run the exact litmus test from Issue #2."""
+        from textpolicy.environment.text_generation import TextGenerationEnv
+        import textpolicy as tp
+
+        examples = [
+            {"db_id": "concert_singer", "gold_sql": "SELECT COUNT(*) FROM singer"},
+            {"db_id": "pets_1", "gold_sql": "SELECT COUNT(*) FROM pets"},
+        ]
+        prompts = [
+            "Schema: singer(id, name)\nQuestion: How many singers?",
+            "Schema: pets(id, name)\nQuestion: How many pets?",
+        ]
+
+        captured_db_ids = []
+
+        @tp.reward
+        def check_example(prompt, completion, example, **kwargs):
+            db_id = example.get("db_id")
+            captured_db_ids.append(db_id)
+            return 1.0
+
+        env = TextGenerationEnv(prompts, check_example, examples=examples, tokenizer=dummy_tokenizer)
+
+        # First episode
+        env.reset()
+        env.step("some action")
+
+        # Should have captured 'concert_singer'
+        assert captured_db_ids[0] == "concert_singer", f"Expected 'concert_singer', got {captured_db_ids[0]}"
+
+        # Second episode
+        env.reset()
+        env.step("another action")
+
+        # Should have captured 'pets_1'
+        assert captured_db_ids[1] == "pets_1", f"Expected 'pets_1', got {captured_db_ids[1]}"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

{textpolicy-0.1.0 → textpolicy-0.1.1}/textpolicy/__init__.py

@@ -30,7 +30,7 @@ from .validate import validate_installation
 
 # Export core reward functions and the reward decorator
 from .rewards.basic import length_reward, keyword_reward, perplexity_reward, accuracy_reward
-from .rewards.registry import reward
+from .rewards.registry import reward, verifier
 
 # Build __all__ combining submodule __all__ lists and additional symbols
 __all__ = (
@@ -48,5 +48,6 @@ __all__ = (
         "perplexity_reward",
         "accuracy_reward",
         "reward",
+        "verifier",
     ]
 )

{textpolicy-0.1.0 → textpolicy-0.1.1}/textpolicy/environment/text_generation.py

@@ -630,24 +630,31 @@ class TextGenerationEnv(Environment):
         reward_fn: Callable[[str, str, dict], float],
         max_tokens: int = 25,
         seed: int = 42,
-        tokenizer: Any = None
+        tokenizer: Any = None,
+        examples: Optional[List[dict]] = None
     ):
         """
         Initialize simple text generation environment.
-        
+
         Args:
             prompts: List of prompts to cycle through
             reward_fn: Function that computes reward from (prompt, completion, example)
             max_tokens: Maximum tokens to generate per response
             seed: Random seed for reproducible behavior
             tokenizer: Tokenizer for converting prompts to tokens (required for MLX compatibility)
+            examples: Optional list of example dicts to pass to reward function. If provided,
+                      must have same length as prompts. examples[i] is passed when prompts[i] is used.
         """
         super().__init__()
         
         if tokenizer is None:
             raise ValueError("tokenizer is required for TextGenerationEnv to work with MLX rollout system")
-        
+
+        if examples is not None and len(examples) != len(prompts):
+            raise ValueError(f"examples length ({len(examples)}) must match prompts length ({len(prompts)})")
+
         self.prompts = prompts
+        self.examples = examples if examples is not None else [{} for _ in prompts]
         self.reward_fn = reward_fn
         self.max_tokens = max_tokens
         self.tokenizer = tokenizer
@@ -735,10 +742,11 @@ class TextGenerationEnv(Environment):
         
         # Compute reward using provided reward function
         # Pass tokenizer for EOS token detection and truncation detection
+        prompt_index = self.current_episode % len(self.prompts)
         reward = self.reward_fn(
             prompt=self.current_prompt,
             completion=response_text,
-            example={},
+            example=self.examples[prompt_index],
             tokenizer=self.tokenizer,  # Pass tokenizer for EOS detection
             truncated=truncated        # Pass truncation flag from environment
         )

{textpolicy-0.1.0 → textpolicy-0.1.1/textpolicy.egg-info}/PKG-INFO

@@ -1,7 +1,17 @@
 Metadata-Version: 2.4
 Name: textpolicy
-Version: 0.1.0
-Summary: MLX-optimized reward and verification system for text generation RL
+Version: 0.1.1
+Summary: Reinforcement learning for text generation on MLX (Apple Silicon): GRPO/GSPO, environments, rollout, rewards, LoRA/QLoRA
+Project-URL: Homepage, https://github.com/teilomillet/textpolicy
+Project-URL: Repository, https://github.com/teilomillet/textpolicy
+Project-URL: Documentation, https://github.com/teilomillet/textpolicy#readme
+Project-URL: Changelog, https://github.com/teilomillet/textpolicy/blob/main/CHANGELOG.md
+Keywords: reinforcement-learning,text-generation,mlx,apple-silicon,lora,qlora,grpo,gspo,rlhf
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE

{textpolicy-0.1.0 → textpolicy-0.1.1}/textpolicy.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 tests/test_gspo_verification.py
 tests/test_integration_e2e_training.py
+tests/test_issue_fixes.py
 tests/test_reward_signatures.py
 tests/test_rollout_rewards.py
 tests/test_runner_step_enforcement.py

textpolicy-0.1.0/pyproject.toml

@@ -1,30 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[tool.setuptools.packages.find]
-include = ["textpolicy*"]
-
-[project]
-name = "textpolicy"
-version = "0.1.0"
-description = "MLX-optimized reward and verification system for text generation RL"
-readme = "README.md"
-requires-python = ">=3.12"
-dependencies = [
-    "numpy>=2.3.2",
-    "mlx>=0.21.0", # Core MLX framework for Apple Silicon acceleration
-    "mlx-lm>=0.21.0", # MLX language models for inference
-    "gymnasium>=0.29.0", 
-    "psutil>=7.0.0",
-    "wandb>=0.21.1",
-    "aiohttp>=3.12.15",
-    "pytest>=8.4.1",
-]
-
-[project.scripts]
-textpolicy = "textpolicy.cli:main"
-
-[project.optional-dependencies]
-external = ["aiohttp>=3.8.0", "pydantic>=2.0.0"]
-dev = ["pytest>=7.0.0", "black>=22.0.0", "ruff>=0.1.0"]