textpolicy 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

textpolicy/validate.py

@@ -0,0 +1,101 @@
+"""
+Lightweight programmatic installation validation for TextPolicy.
+
+This module provides a fast health check without network or model downloads.
+It verifies critical imports, environment step contracts, and basic rollout
+plumbing using a minimal text generation environment.
+
+Usage:
+    from textpolicy.validate import validate_installation
+    report = validate_installation()
+    assert report["status"] == "ok"
+"""
+
+from typing import Any, Dict, List
+
+
+def validate_installation(verbose: bool = True) -> Dict[str, Any]:
+    """
+    Run a series of quick validation checks.
+
+    - Import checks: mlx, gymnasium, mlx_lm (optional)
+    - Environment contract: TextGenerationEnv reset/step returns
+    - Rollout shape sanity: basic reward extraction path
+
+    Returns:
+        A dictionary with keys:
+            status: "ok" or "fail"
+            checks: mapping of check name to details
+            errors: list of error messages
+    """
+    checks: Dict[str, Any] = {}
+    errors: List[str] = []
+
+    # 1) Import checks: MLX (required for policies), gymnasium (adapters), mlx_lm (optional)
+    try:
+        import mlx.core as mx  # type: ignore
+        checks["mlx"] = {"available": True, "version": getattr(mx, "__version__", "unknown")}
+    except Exception as e:  # pragma: no cover - environment dependent
+        checks["mlx"] = {"available": False, "error": str(e)}
+        errors.append("MLX not available: install 'mlx' for full functionality")
+
+    try:
+        import gymnasium as gym  # type: ignore
+        checks["gymnasium"] = {"available": True, "version": getattr(gym, "__version__", "unknown")}
+    except Exception as e:  # pragma: no cover
+        checks["gymnasium"] = {"available": False, "error": str(e)}
+
+    try:
+        import mlx_lm  # type: ignore
+        checks["mlx_lm"] = {"available": True, "version": getattr(mlx_lm, "__version__", "unknown")}
+    except Exception:  # pragma: no cover
+        checks["mlx_lm"] = {"available": False}
+
+    # 2) Environment contract + reward path using a dummy tokenizer
+    try:
+        from textpolicy.environment.text_generation import TextGenerationEnv
+
+        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)
+
+        def _reward(prompt: str, completion: str, example: dict, **kwargs) -> float:
+            return float(len(completion.split()))
+
+        env = TextGenerationEnv(["Hello"], _reward, tokenizer=_DummyTokenizer())
+        obs, info = env.reset()
+        step_result = env.step("a b c")
+        ok = (
+            isinstance(step_result, dict)
+            and {"observation", "reward", "terminated", "truncated", "info"}.issubset(step_result.keys())
+            and step_result["reward"] > 0
+        )
+        checks["environment_contract"] = {"ok": ok}
+        if not ok:
+            errors.append("Environment.step did not return the required dict shape or reward")
+    except Exception as e:
+        checks["environment_contract"] = {"ok": False, "error": str(e)}
+        errors.append(f"Environment contract failed: {e}")
+
+    status = "ok" if not errors else "fail"
+
+    report = {"status": status, "checks": checks, "errors": errors}
+    if verbose:
+        _print_report(report)
+    return report
+
+
+def _print_report(report: Dict[str, Any]) -> None:
+    """Pretty-print validation results with high signal-to-noise."""
+    status = report.get("status", "fail")
+    print(f"TextPolicy validation: {status}")
+    for name, detail in report.get("checks", {}).items():
+        print(f"- {name}: {detail}")
+    if report.get("errors"):
+        print("Errors:")
+        for msg in report["errors"]:
+            print(f"  - {msg}")
+

textpolicy/validation/__init__.py

@@ -0,0 +1,13 @@
+# textpolicy/validation/__init__.py
+"""
+Validation utilities for TextPolicy RL training system.
+
+Validation functions to ensure training components work correctly.
+"""
+
+from .logprob_validation import validate_logprob_implementation, LogprobValidator
+
+__all__ = [
+    "validate_logprob_implementation",
+    "LogprobValidator"
+]

textpolicy/validation/logprob_validation.py

@@ -0,0 +1,315 @@
+# textpolicy/validation/logprob_validation.py
+"""
+Critical Logprob Validation for MLX RL Training.
+
+This module provides rigorous testing of logprob extraction to ensure
+policy gradient algorithms receive correct probability values.
+
+Incorrect logprob computation is the #1 cause of RL training failure.
+This validation catches errors before they break training.
+"""
+
+import mlx.core as mx
+import mlx.nn as nn
+from typing import Tuple, Dict, Any, List
+import numpy as np
+
+from ..generation.mlx_generation import compute_logprobs
+
+
+class LogprobValidator:
+    """
+    Comprehensive validation of logprob extraction correctness.
+    
+    This class implements multiple tests to ensure logprob functions
+    compute the correct values needed for policy gradient training.
+    """
+    
+    @staticmethod
+    def create_test_model(vocab_size: int = 100, hidden_size: int = 64) -> nn.Module:
+        """Create a simple test model for logprob validation."""
+        class SimpleTestModel(nn.Module):
+            def __init__(self, vocab_size: int, hidden_size: int):
+                super().__init__()
+                self.embedding = nn.Embedding(vocab_size, hidden_size)
+                self.linear = nn.Linear(hidden_size, vocab_size)
+                self.vocab_size = vocab_size
+            
+            def __call__(self, x):
+                # Simple model for testing
+                if x.ndim == 1:
+                    x = x[None]  # Add batch dimension
+                
+                # Get embeddings and average them (simple pooling)
+                h = self.embedding(x)  # [batch, seq, hidden]
+                h = mx.mean(h, axis=1)  # [batch, hidden]
+                
+                # Expand back to sequence length for autoregressive simulation
+                seq_len = x.shape[1]  # type: ignore
+                h_expanded = mx.broadcast_to(h[:, None, :], (h.shape[0], seq_len, h.shape[1]))  # type: ignore
+                
+                # Generate logits for each position
+                logits = self.linear(h_expanded)  # [batch, seq, vocab]
+                
+                return logits
+        
+        return SimpleTestModel(vocab_size, hidden_size)
+    
+    @staticmethod
+    def test_autoregressive_indexing():
+        """
+        Test that logprob extraction uses correct autoregressive indexing.
+        
+        This test verifies autoregressive indexing. Incorrect indexing breaks training.
+        """
+        print("Testing autoregressive indexing...")
+        
+        model = LogprobValidator.create_test_model()
+        
+        # Create test data
+        prompt_tokens = mx.array([1, 2, 3])  # 3 tokens
+        response_tokens = mx.array([4, 5])   # 2 tokens
+        
+        # Test the logprob computation
+        try:
+            logprobs = compute_logprobs(model, prompt_tokens, response_tokens)
+            
+            # Validate output shape
+            assert logprobs.shape == (2,), f"Expected shape (2,), got {logprobs.shape}"
+            
+            # Validate logprobs are reasonable (negative values)
+            assert mx.all(logprobs <= 0), "Logprobs should be <= 0 (log of probabilities)"
+            
+            print("Autoregressive indexing test passed")
+            return True
+            
+        except Exception as e:
+            print(f"Autoregressive indexing test failed: {e}")
+            return False
+    
+    @staticmethod
+    def test_teacher_forcing_consistency():
+        """
+        Test that logprobs match teacher-forcing computation.
+        
+        When we provide the full sequence [prompt + response] to the model,
+        the logprobs should match what the model actually computed.
+        """
+        print("Testing teacher-forcing consistency...")
+        
+        model = LogprobValidator.create_test_model()
+        
+        prompt_tokens = mx.array([10, 20])
+        response_tokens = mx.array([30, 40, 50])
+        
+        try:
+            # Method 1: Our logprob function
+            computed_logprobs = compute_logprobs(model, prompt_tokens, response_tokens)
+            
+            # Method 2: Manual teacher-forcing computation
+            full_sequence = mx.concatenate([prompt_tokens, response_tokens])
+            logits = model(full_sequence[None])  # [1, seq_len, vocab_size]
+            
+            # Extract the same logits our function should use
+            prompt_len = len(prompt_tokens)
+            manual_logits = logits[0, prompt_len-1:prompt_len-1+len(response_tokens), :]
+            manual_log_probs = manual_logits - mx.logsumexp(manual_logits, axis=-1, keepdims=True)
+            manual_selected = manual_log_probs[mx.arange(len(response_tokens)), response_tokens]
+            
+            # Compare results
+            diff = mx.abs(computed_logprobs - manual_selected)
+            max_diff = float(mx.max(diff))
+            
+            assert max_diff < 1e-6, f"Logprob mismatch: max difference {max_diff}"
+            
+            print(f"Teacher-forcing consistency test passed (max diff: {max_diff:.2e})")
+            return True
+            
+        except Exception as e:
+            print(f"Teacher-forcing consistency test failed: {e}")
+            return False
+    
+    @staticmethod
+    def test_batch_processing():
+        """Test logprob extraction works correctly with batched inputs."""
+        print("Testing batch processing...")
+        
+        model = LogprobValidator.create_test_model()
+        
+        try:
+            # Test single sequence
+            prompt1 = mx.array([1, 2])
+            response1 = mx.array([3, 4])
+            logprobs1 = compute_logprobs(model, prompt1, response1)
+            
+            # Test another sequence
+            prompt2 = mx.array([5, 6])  
+            response2 = mx.array([7, 8])
+            logprobs2 = compute_logprobs(model, prompt2, response2)
+            
+            # Results should be consistent shapes
+            assert logprobs1.shape == logprobs2.shape, "Batch processing shape inconsistency"
+            
+            print("Batch processing test passed")
+            return True
+            
+        except Exception as e:
+            print(f"Batch processing test failed: {e}")
+            return False
+    
+    @staticmethod
+    def test_edge_cases():
+        """Test edge cases that could break training."""
+        print("Testing edge cases...")
+        
+        model = LogprobValidator.create_test_model()
+        
+        try:
+            # Test empty response
+            prompt = mx.array([1, 2, 3])
+            empty_response = mx.array([])
+            logprobs_empty = compute_logprobs(model, prompt, empty_response)
+            assert len(logprobs_empty) == 0, "Empty response should return empty logprobs"
+            
+            # Test single token response
+            single_response = mx.array([4])
+            logprobs_single = compute_logprobs(model, prompt, single_response)
+            assert len(logprobs_single) == 1, "Single token response should return single logprob"
+            
+            # Test a short prompt
+            short_prompt = mx.array([1])
+            response = mx.array([2, 3])
+            logprobs_short = compute_logprobs(model, short_prompt, response)
+            assert len(logprobs_short) == 2, "Should handle short prompts correctly"
+            
+            print("Edge cases test passed")
+            return True
+            
+        except Exception as e:
+            print(f"Edge cases test failed: {e}")
+            return False
+    
+    @staticmethod
+    def test_numerical_stability():
+        """Test numerical stability of logprob computation."""
+        print("Testing numerical stability...")
+        
+        model = LogprobValidator.create_test_model()
+        
+        try:
+            prompt = mx.array([1, 2, 3])
+            response = mx.array([4, 5, 6])
+            
+            logprobs = compute_logprobs(model, prompt, response)
+            
+            # Check for NaN or Inf values
+            assert not mx.any(mx.isnan(logprobs)), "NaN values detected in logprobs"
+            assert not mx.any(mx.isinf(logprobs)), "Inf values detected in logprobs"
+            
+            # Check logprobs are reasonable (log-probabilities are non-positive)
+            assert mx.all(logprobs <= 0), "Logprobs should be negative (log probabilities)"
+            assert mx.all(logprobs >= -50), "Logprobs should not be too negative"
+            
+            print("Numerical stability test passed")
+            return True
+            
+        except Exception as e:
+            print(f"Numerical stability test failed: {e}")
+            return False
+    
+    @staticmethod
+    def test_gradient_computation():
+        """Test that gradients can flow through logprob computation when needed."""
+        print("Testing gradient computation...")
+        
+        model = LogprobValidator.create_test_model()
+        
+        try:
+            prompt = mx.array([1, 2])
+            response = mx.array([3, 4])
+            
+            # Test that we can compute gradients through the model
+            def loss_fn(model_params):
+                # Forward pass
+                full_seq = mx.concatenate([prompt, response])
+                logits = model(full_seq[None])
+                
+                # Simple loss (not using our logprob function, just testing model)
+                return mx.mean(logits)
+            
+            # Test gradient computation
+            grads = mx.grad(loss_fn)(model.parameters())
+            
+            # Should get gradients for all parameters
+            assert len(grads) > 0, "No gradients computed"
+            
+            print("Gradient computation test passed")
+            return True
+            
+        except Exception as e:
+            print(f"Gradient computation test failed: {e}")
+            return False
+    
+    @staticmethod
+    def run_full_validation() -> bool:
+        """
+        Run complete logprob validation suite.
+        
+        Returns:
+            True if all tests pass, False otherwise
+        """
+        print("=" * 60)
+        print("LOGPROB VALIDATION")
+        print("=" * 60)
+        print("Testing logprob extraction correctness for RL training...")
+        print()
+        
+        tests = [
+            LogprobValidator.test_autoregressive_indexing,
+            LogprobValidator.test_teacher_forcing_consistency,
+            LogprobValidator.test_batch_processing,
+            LogprobValidator.test_edge_cases,
+            LogprobValidator.test_numerical_stability,
+            LogprobValidator.test_gradient_computation
+        ]
+        
+        passed = 0
+        total = len(tests)
+        
+        for test in tests:
+            try:
+                if test():
+                    passed += 1
+                print()
+            except Exception as e:
+                print(f"Test {test.__name__} crashed: {e}")
+                print()
+        
+        print("=" * 60)
+        print(f"VALIDATION RESULTS: {passed}/{total} tests passed")
+        
+        if passed == total:
+            print("ALL LOGPROB TESTS PASSED!")
+            print("Logprob extraction is correct for RL training")
+            return True
+        else:
+            print("LOGPROB VALIDATION FAILED!")
+            print("RL training may not work correctly with the current implementation")
+            return False
+
+
+def validate_logprob_implementation() -> bool:
+    """
+    Main entry point for logprob validation.
+    
+    This function should be called before starting any RL training
+    to ensure logprob extraction is implemented correctly.
+    
+    Returns:
+        True if validation passes, False otherwise
+    """
+    return LogprobValidator.run_full_validation()
+
+
+if __name__ == "__main__":
+    validate_logprob_implementation()

textpolicy-0.1.0.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: textpolicy
+Version: 0.1.0
+Summary: MLX-optimized reward and verification system for text generation RL
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.3.2
+Requires-Dist: mlx>=0.21.0
+Requires-Dist: mlx-lm>=0.21.0
+Requires-Dist: gymnasium>=0.29.0
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: wandb>=0.21.1
+Requires-Dist: aiohttp>=3.12.15
+Requires-Dist: pytest>=8.4.1
+Provides-Extra: external
+Requires-Dist: aiohttp>=3.8.0; extra == "external"
+Requires-Dist: pydantic>=2.0.0; extra == "external"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# TextPolicy
+
+Reinforcement learning toolkit for text generation on MLX (Apple Silicon).
+TextPolicy provides algorithms (GRPO/GSPO), text-generation environments, a rollout runner,
+reward functions with a decorator registry, and LoRA/QLoRA utilities.
+
+## Install (uv)
+
+```bash
+uv add textpolicy
+```
+
+Optional model integration:
+
+```bash
+uv add mlx mlx-lm
+```
+
+## Quickstart
+
+Working example using a real model and tokenizer (mlx-lm required):
+
+```python
+import mlx.core as mx
+import textpolicy as tp
+from textpolicy import load_model, create_policy
+from textpolicy.environment.text_generation import TextGenerationEnv
+from textpolicy.rollout import RolloutRunner, create_strategy
+
+# 1) Load model and tokenizer (mlx-lm)
+model, tokenizer = load_model("Qwen/Qwen3-0.6B")
+
+# 2) Create a policy (controls generation)
+generation_params = {"max_tokens": 25, "temperature": 0.7}
+policy_fn = create_policy(model, tokenizer, generation_params)
+
+# 3) Define a reward function (env uses this to score responses)
+@tp.reward
+def length_reward(prompt: str, completion: str, example: dict, **kwargs) -> float:
+    return float(len(completion.split()))
+
+# 4) Create an environment (requires a tokenizer)
+env = TextGenerationEnv(["What is AI?"], length_reward, tokenizer=tokenizer)
+
+# 5) Collect one rollout step
+strategy = create_strategy('grpo')
+runner = RolloutRunner(env, policy=policy_fn, strategy=strategy, max_steps=1)
+buffer = runner.collect()
+print(len(buffer.episodes))
+```
+
+Docs:
+- Quickstart: `docs/QUICKSTART_UV.md`
+- LoRA/QLoRA: `docs/10_lora_qlora.md`
+- Full index: `docs/index.md`
+
+FAQ:
+- Do I need a model? 
+    - Yes for generation with `create_policy`. 
+    Use `load_model()` (mlx‑lm) to get `(model, tokenizer)`. 
+    For reward‑only code (no generation), a model is not required.
+- Do I need a tokenizer? 
+    - Yes. 
+    Both `TextGenerationEnv` and `TextGenerationEnvironment` require a tokenizer. 
+    `load_model()` returns one for mlx‑lm models.
+- How do I control generation? 
+    - Pass `generation_params` to `create_policy` (for example, `max_tokens`, `temperature`, `top_p`, `repetition_penalty`).
+- What does `step()` return? 
+    - A dict with `observation`, `reward`, `terminated`, `truncated`, `info`. The runner enforces this.
+
+Examples:
+- 01–06: reward functions, batch processing, minimal training
+- 08: GRPO training with rollout + buffer
+- 09–10: length reduction (GRPO/GSPO)
+- 11: LoRA/QLoRA configuration

textpolicy-0.1.0.dist-info/RECORD

@@ -0,0 +1,66 @@
+textpolicy/__init__.py,sha256=u4u0fIHfAvXFN2ATHCsG0Tx4xGfOcfuOITBTmKbGhrw,1576
+textpolicy/__main__.py,sha256=IlGmjJaW-DJUC7yhxUhbwNOZA3GxkeQGkVbFdS3_wBI,136
+textpolicy/cli.py,sha256=3CcJzrRlin1pgd6Mh312Xp3-EihHtTSvhakyYpdfacs,2107
+textpolicy/validate.py,sha256=lxmegz83B_c-PS3cFHaaL3c9fgWrEaLsDLkpPFtSj8Y,3780
+textpolicy/algorithms/__init__.py,sha256=muJSuiJkaGg-zSaGIYkaB7UbLh6UJYMdI60SGqTgNWM,1257
+textpolicy/algorithms/grpo.py,sha256=1j_C70Bgwrnr_BCAl_qvAsH3Mg9yMOW-D4vhPUxUpFQ,26261
+textpolicy/algorithms/gspo.py,sha256=OWvJolldTSTEOsCIwio3ER0hTWkYsJ1e0BBJElgJ2mc,23485
+textpolicy/buffer/__init__.py,sha256=bnSkX9Oe1ajau-yqC2PYNF4a4ELVP05zjlkDmIerXlw,569
+textpolicy/buffer/buffer.py,sha256=mDie8ZiWgsjNJ4LiKyfpQNLzN1K0UICxI8XaqQacUMM,7917
+textpolicy/buffer/episode.py,sha256=iNyVqeMLzOMauz1Z3fs9JUyL7g7IEC9t8GN1eypThy4,15875
+textpolicy/buffer/sampling.py,sha256=aE92R69TQe8c5V0WL_EaKHLXSSxbI2wDlgvtR80fJDc,17598
+textpolicy/buffer/storage.py,sha256=dYdROkL4KHx0w3XAqJFvRs6gRbYs3dAsiHqdMnwBMAI,9248
+textpolicy/environment/__init__.py,sha256=TzhkXiAq10iC9PGGJ-gn2Bm2ttmJHpQ8d3Lxf_wUnNg,1685
+textpolicy/environment/base.py,sha256=7Bh5tlFz20RC-iPQhnpv-zigHf8a6cEwBC3ISV-HS1Y,2829
+textpolicy/environment/environment.py,sha256=o8-RY6wj5xrzDBp77HoY2At3XlBwvreF3DKpDFpC7js,1240
+textpolicy/environment/factory.py,sha256=pebQo1_M3sMF8Pdc9yvpdXzRXfIDllKJoAQAjQbif0E,3124
+textpolicy/environment/gym.py,sha256=P8Bi8PlDtcWWa9uLuCjkhZnYRVs-mg6iSJVSBkG99f8,3186
+textpolicy/environment/task_suites.py,sha256=ssPnw2Y3eGYaskWf8dUab4rNu_Bx5L284b3VdhgvSPM,1544
+textpolicy/environment/text_generation.py,sha256=BXSJS_05Q89cPFfdXcUKxOXSZm3HBR3KMi55BnOdoLY,31258
+textpolicy/environment/vectorized.py,sha256=ZROtpmdbh1Oi8c0b0D_vmVzqI16Cp2WZTmkjkRbMoDg,9932
+textpolicy/generation/__init__.py,sha256=J3dc0SPAZChJTsRn47tz8FfIp3XwNgZ-8_H9VBpQYvQ,1266
+textpolicy/generation/lora.py,sha256=xSKRczJY20BrkkU1SSgBtDc30tZjdFE7FhEZPUEoiyg,13747
+textpolicy/generation/mlx_generation.py,sha256=r__oXHiAtAQ4xq4ODUwS7FrXL40Hu9cwoS5sZOhsAfs,20468
+textpolicy/generation/reload.py,sha256=-eJE3LXmN-kDatUQjM0--VZp0jjqWgBslYcmNcQZ_A8,7998
+textpolicy/rewards/__init__.py,sha256=mg_wL7oedL_5KLsnaJuPVc_ZHZqZKXRHg9ws2gSifMk,4769
+textpolicy/rewards/adapters.py,sha256=Ffwi9eF_mx6DdCoRRmzl7TdhqNJycpz1TovJXa0XxXk,12843
+textpolicy/rewards/basic.py,sha256=xlMMfCmLm3TrDJsxpJ-h9vlc-m27tTrvnZ-JGUOD89A,6921
+textpolicy/rewards/integrated_system.py,sha256=eGK69J2cAfJD4GoL_ANivA8ZWpXHLtu6A0YoMwGTAzI,11243
+textpolicy/rewards/mlx_batch_processor.py,sha256=97jFIHwqq75q7-LADVIBCbNqZJTU8jpbs8xcyUrJNfQ,16850
+textpolicy/rewards/registry.py,sha256=azuz4HpbacBUss2-FS0Wji_FOUs7NLtwgpsEynqq7ds,11437
+textpolicy/rewards/rollout_rewards.py,sha256=7bSkbBJwsb9MLOQ-YMutocpIgGI_AZdgFjRCh2xv0iY,13805
+textpolicy/rewards/verifiers.py,sha256=Xnb9FC5Lc0CE34Wwoc99AwKRt0Ut0gDliImr_YDChiY,11596
+textpolicy/rollout/__init__.py,sha256=PKjY1NmsARTPmUwzNLSp2tFU4NvgJ4NUP1VPy2g3nxI,1229
+textpolicy/rollout/aggregator.py,sha256=U2ywEPWwBHGgpEPHxmu2ywSibSa_pkD_GuHN3JGcwck,4467
+textpolicy/rollout/base.py,sha256=CuyzsHM_yn3eRKldLCcEDfmnqFnHoq-rJ7k0f-nYHw8,2919
+textpolicy/rollout/rollout.py,sha256=h3gs_U-NfoIKpBVf1NFeZGInvSki8RDATsq1__ne8Qo,4499
+textpolicy/rollout/runner.py,sha256=9bB0B1GlEGNtr8bhEYQbpY1WBzJQK0MoFrsbZTQ-Lzw,10993
+textpolicy/rollout/strategy.py,sha256=Q97wxgq-FCienL15P1l-pXYEWiUZrh861UmtStj4x3E,7577
+textpolicy/rollout/worker.py,sha256=aXOKRtkivKwDks8g8VtaWUv-wQMPR72idZxPuNtwmSE,6939
+textpolicy/training/__init__.py,sha256=TmcW2BqmwO4DaDDr4n2g1QOtHeVPxgw6xZdeYTmzjD8,282
+textpolicy/training/metrics.py,sha256=fmY1ZBdyEgYrfH18H3fOZ-dieMtjVNzjxjdxd7yo7OU,7582
+textpolicy/training/rollout_manager.py,sha256=ETD7WTbbaQ8uUzrHPBCDX-PawmEJfSK6Kd5N-dvIZRY,2328
+textpolicy/training/trainer.py,sha256=kG7tduOKHPFVVewyspgm360enowTpNpwaLhZWuIc9vo,29268
+textpolicy/utils/__init__.py,sha256=v0ji-jnegGRydzmAOccKY4XC0nkBbBZqdHXzk-i6ers,1220
+textpolicy/utils/benchmarking.py,sha256=YDN24vU8SL_EsrANQWF1qbmXtfhF4Woj8yjez-h-Io0,18682
+textpolicy/utils/data.py,sha256=KJoPzYWYVAJawvDX1BHzwBZEpCXLSBC168rjud7MSB0,1413
+textpolicy/utils/debug.py,sha256=ir_5DF88_yZbU43w-o_o05EivgPv9AgNVRovL-adNIE,6139
+textpolicy/utils/environment.py,sha256=LyYQgpZVfEDyPlD7774_AHR9crOC6NNGjd6J37ltLGM,13319
+textpolicy/utils/memory.py,sha256=H8mfUY52iU5VRPhOLPdanWvBgEGLtLCoUE0xpJIMcfM,3391
+textpolicy/utils/performance.py,sha256=YzLMT_bAPs9TnVwmrPvWOEwi4UAy5Bmbr5zTpJacmGA,17823
+textpolicy/utils/timing.py,sha256=MUCBUC22zQ3nMVxhif_XhHlyZUxYGhheFMs7bf6ZKg8,4869
+textpolicy/utils/logging/__init__.py,sha256=YeJ18H7suPzYPgXlfSsE90GaAVF_5lOcbGCDCy8tvuA,512
+textpolicy/utils/logging/base.py,sha256=3BBg318dEPNIHYtoJnFiJcktvS5KMcIUNXBKKfn8x_g,1304
+textpolicy/utils/logging/console.py,sha256=WIcOO-tT2FhrqKhWO89qSSNmLA06up_KenrN6TGoyo8,1680
+textpolicy/utils/logging/factory.py,sha256=vAkMShn7bnVRDuZNOKaVXNmF6XPUNeqaFFPF4dZw70E,3920
+textpolicy/utils/logging/multi.py,sha256=kIxuoXiZ4nf_p8JlnzYxtqA0r82LJaqHnO5mEHlJdgM,2501
+textpolicy/utils/logging/tensorboard.py,sha256=aY9YMReSJkWEhy6SdAAUlHSB4lzDecivBC8K7CZPcO4,1949
+textpolicy/utils/logging/wandb.py,sha256=U4pxuZNOz2l8XiymK8OFbCpiRTBOLNtnZakC_udttfQ,2206
+textpolicy/validation/__init__.py,sha256=KcyppNi91w0bF51gZ0ykUIKEiF7z6TT37uuavMFScnA,328
+textpolicy/validation/logprob_validation.py,sha256=G_CCy5NRDUTmo7WZIChhNVM3NtP1VmWAjdd5z6TIvos,11749
+textpolicy-0.1.0.dist-info/licenses/LICENSE,sha256=AYDHSNRbiqZt4HHH1gaOoQ2hjYjK4bqw4Vd9UyKzx18,1065
+textpolicy-0.1.0.dist-info/METADATA,sha256=XdyIh8e2IIRymRf31vu1MuVM2aaut2qsZ5PcsjHrl9Y,3199
+textpolicy-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+textpolicy-0.1.0.dist-info/entry_points.txt,sha256=d0Cj5boT6k_l_beVPWPt9LZMllsN4kbIUmsNsn1BANE,51
+textpolicy-0.1.0.dist-info/top_level.txt,sha256=Ww6_QEF71dI-AYCaugiGeGcgMoFAixSOszSoRsyX-E0,11
+textpolicy-0.1.0.dist-info/RECORD,,

textpolicy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+textpolicy = textpolicy.cli:main

textpolicy-0.0.1.dist-info/METADATA

@@ -1,10 +0,0 @@
-Metadata-Version: 2.4
-Name: textpolicy
-Version: 0.0.1
-Summary: Add your description here
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# textpolicy

textpolicy-0.0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-textpolicy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-textpolicy-0.0.1.dist-info/licenses/LICENSE,sha256=AYDHSNRbiqZt4HHH1gaOoQ2hjYjK4bqw4Vd9UyKzx18,1065
-textpolicy-0.0.1.dist-info/METADATA,sha256=Hm0fs04Q8V79bM4-GI0QMPDPEWN97oe5ULRex1orYDQ,211
-textpolicy-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-textpolicy-0.0.1.dist-info/top_level.txt,sha256=Ww6_QEF71dI-AYCaugiGeGcgMoFAixSOszSoRsyX-E0,11
-textpolicy-0.0.1.dist-info/RECORD,,