weiss-sim 0.1.3__cp312-cp312-win_amd64.whl → 0.2.0__cp312-cp312-win_amd64.whl

weiss_sim/__init__.py

@@ -1,18 +1,238 @@
 from __future__ import annotations
 
+import json
 import numpy as np
 
 from .weiss_sim import (
     ACTION_SPACE_SIZE,
+    ACTOR_NONE,
+    DECISION_KIND_NONE,
+    POLICY_VERSION,
     OBS_LEN,
     PASS_ACTION_ID,
     SPEC_HASH,
+    BatchOutMinimalI16,
+    BatchOutMinimalI16LegalIds,
     BatchOutDebug,
     BatchOutMinimal,
+    BatchOutMinimalNoMask,
+    BatchOutTrajectory,
+    BatchOutTrajectoryI16,
+    BatchOutTrajectoryI16LegalIds,
+    BatchOutTrajectoryNoMask,
     EnvPool,
+    action_spec_json,
+    build_info,
+    decode_action_id,
+    observation_spec_json,
     __version__,
 )
-from .rl import RlStep, pass_action_id_for_decision_kind, reset_rl, step_rl
+from .rl import (
+    RlStepI16LegalIds,
+    RlStep,
+    RlStepNoMask,
+    pass_action_id_for_decision_kind,
+    reset_rl,
+    reset_rl_into,
+    reset_rl_nomask,
+    reset_rl_nomask_into,
+    reset_rl_i16_legal_ids,
+    reset_rl_i16_legal_ids_into,
+    step_rl,
+    step_rl_into,
+    step_rl_nomask,
+    step_rl_nomask_into,
+    step_rl_i16_legal_ids,
+    step_rl_i16_legal_ids_into,
+    step_rl_select_from_logits_i16_legal_ids,
+    step_rl_select_from_logits_i16_legal_ids_into,
+    step_rl_sample_from_logits_i16_legal_ids,
+    step_rl_sample_from_logits_i16_legal_ids_into,
+)
+
+_PROFILE_FAST = "fast"
+_PROFILE_BALANCED = "balanced"
+_PROFILE_EVAL = "eval"
+_PROFILE_DEBUG = "debug"
+
+
+def _resolve_profile(profile: str):
+    profile_norm = profile.lower().strip()
+    if profile_norm == _PROFILE_FAST:
+        return profile_norm, False, True, True, True
+    if profile_norm in (_PROFILE_BALANCED, _PROFILE_EVAL, _PROFILE_DEBUG):
+        return profile_norm, True, False, False, False
+    raise ValueError(f"unknown profile '{profile}' (expected fast, balanced, eval, debug)")
+
+
+def make_train_pool(
+    num_envs: int,
+    db_path: str,
+    deck_lists,
+    deck_ids=None,
+    max_decisions: int = 2000,
+    max_ticks: int = 100_000,
+    seed: int = 0,
+    curriculum_json: str | None = None,
+    reward_json: str | None = None,
+    error_policy: str | None = None,
+    num_threads: int | None = None,
+    debug_fingerprint_every_n: int = 0,
+    debug_event_ring_capacity: int = 0,
+    *,
+    profile: str = _PROFILE_FAST,
+    output_masks: bool | None = None,
+    use_i16: bool | None = None,
+    legal_ids: bool | None = None,
+    unsafe_i16: bool | None = None,
+    rollout_steps: int | None = None,
+):
+    """Create an RL training pool plus preallocated buffers with sensible defaults.
+
+    Profiles:
+    - fast: masks off + i16 obs + legal ids (highest throughput)
+    - balanced/eval/debug: masks on + i32 obs (easier debugging)
+
+    Returns: (pool, buffers)
+    """
+    _, profile_masks, profile_i16, profile_legal_ids, profile_unsafe_i16 = _resolve_profile(profile)
+    if output_masks is None:
+        output_masks = profile_masks
+    if use_i16 is None:
+        use_i16 = profile_i16
+    if legal_ids is None:
+        legal_ids = profile_legal_ids
+    if unsafe_i16 is None:
+        unsafe_i16 = profile_unsafe_i16
+    if legal_ids:
+        if output_masks:
+            raise ValueError("legal_ids requires output_masks=False")
+        if use_i16 is False:
+            raise ValueError("legal_ids currently requires use_i16=True")
+        output_masks = False
+        use_i16 = True
+    if unsafe_i16 and not use_i16:
+        raise ValueError("unsafe_i16 requires use_i16=True")
+    pool = EnvPool.new_rl_train(
+        num_envs,
+        db_path,
+        deck_lists,
+        deck_ids=deck_ids,
+        max_decisions=max_decisions,
+        max_ticks=max_ticks,
+        seed=seed,
+        curriculum_json=curriculum_json,
+        reward_json=reward_json,
+        error_policy=error_policy,
+        num_threads=num_threads,
+        output_masks=output_masks,
+        debug_fingerprint_every_n=debug_fingerprint_every_n,
+        debug_event_ring_capacity=debug_event_ring_capacity,
+    )
+    if legal_ids:
+        pool.set_output_mask_bits_enabled(False)
+    if unsafe_i16:
+        pool.set_i16_clamp_enabled(False)
+    if rollout_steps is not None:
+        if legal_ids:
+            return pool, EnvPoolTrajectoryBuffersI16LegalIds(pool, rollout_steps)
+        if use_i16:
+            return pool, EnvPoolTrajectoryBuffersI16(pool, rollout_steps)
+        if output_masks:
+            return pool, EnvPoolTrajectoryBuffers(pool, rollout_steps)
+        return pool, EnvPoolTrajectoryBuffersNoMask(pool, rollout_steps)
+    if legal_ids:
+        return pool, EnvPoolBuffersI16LegalIds(pool)
+    if use_i16:
+        return pool, EnvPoolBuffersI16(pool)
+    if output_masks:
+        return pool, EnvPoolBuffers(pool)
+    return pool, EnvPoolBuffersNoMask(pool)
+
+
+def make_eval_pool(
+    num_envs: int,
+    db_path: str,
+    deck_lists,
+    deck_ids=None,
+    max_decisions: int = 2000,
+    max_ticks: int = 100_000,
+    seed: int = 0,
+    curriculum_json: str | None = None,
+    reward_json: str | None = None,
+    error_policy: str | None = None,
+    num_threads: int | None = None,
+    debug_fingerprint_every_n: int = 0,
+    debug_event_ring_capacity: int = 0,
+    *,
+    profile: str = _PROFILE_BALANCED,
+    output_masks: bool | None = None,
+    use_i16: bool | None = None,
+    legal_ids: bool | None = None,
+    unsafe_i16: bool | None = None,
+    rollout_steps: int | None = None,
+):
+    """Create an RL eval/debug pool plus preallocated buffers with sensible defaults.
+
+    Profiles:
+    - balanced/eval/debug: masks on + i32 obs
+    - fast: masks off + i16 obs + legal ids (opt-in)
+
+    Returns: (pool, buffers)
+    """
+    _, profile_masks, profile_i16, profile_legal_ids, profile_unsafe_i16 = _resolve_profile(profile)
+    if output_masks is None:
+        output_masks = profile_masks
+    if use_i16 is None:
+        use_i16 = profile_i16
+    if legal_ids is None:
+        legal_ids = profile_legal_ids
+    if unsafe_i16 is None:
+        unsafe_i16 = profile_unsafe_i16
+    if legal_ids:
+        if output_masks:
+            raise ValueError("legal_ids requires output_masks=False")
+        if use_i16 is False:
+            raise ValueError("legal_ids currently requires use_i16=True")
+        output_masks = False
+        use_i16 = True
+    if unsafe_i16 and not use_i16:
+        raise ValueError("unsafe_i16 requires use_i16=True")
+    pool = EnvPool.new_rl_eval(
+        num_envs,
+        db_path,
+        deck_lists,
+        deck_ids=deck_ids,
+        max_decisions=max_decisions,
+        max_ticks=max_ticks,
+        seed=seed,
+        curriculum_json=curriculum_json,
+        reward_json=reward_json,
+        error_policy=error_policy,
+        num_threads=num_threads,
+        output_masks=output_masks,
+        debug_fingerprint_every_n=debug_fingerprint_every_n,
+        debug_event_ring_capacity=debug_event_ring_capacity,
+    )
+    if legal_ids:
+        pool.set_output_mask_bits_enabled(False)
+    if unsafe_i16:
+        pool.set_i16_clamp_enabled(False)
+    if rollout_steps is not None:
+        if legal_ids:
+            return pool, EnvPoolTrajectoryBuffersI16LegalIds(pool, rollout_steps)
+        if use_i16:
+            return pool, EnvPoolTrajectoryBuffersI16(pool, rollout_steps)
+        if output_masks:
+            return pool, EnvPoolTrajectoryBuffers(pool, rollout_steps)
+        return pool, EnvPoolTrajectoryBuffersNoMask(pool, rollout_steps)
+    if legal_ids:
+        return pool, EnvPoolBuffersI16LegalIds(pool)
+    if use_i16:
+        return pool, EnvPoolBuffersI16(pool)
+    if output_masks:
+        return pool, EnvPoolBuffers(pool)
+    return pool, EnvPoolBuffersNoMask(pool)
 
 
 class EnvPoolBuffers:
@@ -28,11 +248,13 @@ class EnvPoolBuffers:
         self.terminated = self.out.terminated
         self.truncated = self.out.truncated
         self.actor = self.out.actor
+        self.decision_kind = self.out.decision_kind
         self.decision_id = self.out.decision_id
         self.engine_status = self.out.engine_status
         self.spec_hash = self.out.spec_hash
         self.legal_ids = np.empty(num_envs * pool.action_space, dtype=np.uint16)
         self.legal_offsets = np.zeros(num_envs + 1, dtype=np.uint32)
+        self.actions = np.empty(num_envs, dtype=np.uint32)
 
     def reset(self):
         self.pool.reset_into(self.out)
@@ -46,27 +268,520 @@ class EnvPoolBuffers:
         self.pool.reset_done_into(done_mask, self.out)
         return self.out
 
+    def reset_indices_with_episode_seeds(self, indices, episode_seeds):
+        self.pool.reset_indices_with_episode_seeds_into(
+            list(indices), list(episode_seeds), self.out
+        )
+        return self.out
+
     def step(self, actions):
         self.pool.step_into(actions, self.out)
         return self.out
 
+    def step_first_legal(self):
+        self.pool.step_first_legal_into(self.actions, self.out)
+        return self.out, self.actions
+
+    def step_random_legal(self, seeds):
+        self.pool.step_sample_legal_action_ids_uniform_into(seeds, self.actions, self.out)
+        return self.out, self.actions
+
+    def step_select_from_logits(self, logits):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        self.pool.step_select_from_logits_into(logits, self.actions, self.out)
+        return self.out, self.actions
+
+    def step_sample_from_logits(self, logits, seeds):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.step_sample_from_logits_into(logits, seeds, self.actions, self.out)
+        return self.out, self.actions
+
+    def select_actions_from_logits(self, logits):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        self.pool.select_actions_from_logits_into(logits, self.actions)
+        return self.actions
+
+    def sample_actions_from_logits(self, logits, seeds):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.sample_actions_from_logits_into(logits, seeds, self.actions)
+        return self.actions
+
+    def set_output_mask_enabled(self, enabled: bool):
+        self.pool.set_output_mask_enabled(enabled)
+        if not enabled:
+            self.out.masks.fill(0)
+
+    def set_output_mask_bits_enabled(self, enabled: bool):
+        self.pool.set_output_mask_bits_enabled(enabled)
+
+    def set_i16_overflow_counter_enabled(self, enabled: bool):
+        self.pool.set_i16_overflow_counter_enabled(enabled)
+
+    def i16_overflow_count(self) -> int:
+        return int(self.pool.i16_overflow_count())
+
+    def reset_i16_overflow_count(self) -> None:
+        self.pool.reset_i16_overflow_count()
+
     def legal_action_ids(self):
         count = self.pool.legal_action_ids_into(self.legal_ids, self.legal_offsets)
         return self.legal_ids[:count], self.legal_offsets
 
+    def legal_action_ids_and_sample_uniform(self, seeds):
+        count = self.pool.legal_action_ids_and_sample_uniform_into(
+            self.legal_ids, self.legal_offsets, seeds, self.actions
+        )
+        return self.legal_ids[:count], self.legal_offsets, self.actions
+
+
+class EnvPoolBuffersNoMask:
+    """Preallocated numpy buffers for stepping without dense masks."""
+
+    def __init__(self, pool: EnvPool) -> None:
+        self.pool = pool
+        num_envs = pool.envs_len
+        self.out = BatchOutMinimalNoMask(num_envs)
+        self.obs = self.out.obs
+        self.rewards = self.out.rewards
+        self.terminated = self.out.terminated
+        self.truncated = self.out.truncated
+        self.actor = self.out.actor
+        self.decision_kind = self.out.decision_kind
+        self.decision_id = self.out.decision_id
+        self.engine_status = self.out.engine_status
+        self.spec_hash = self.out.spec_hash
+        self.legal_ids = np.empty(num_envs * pool.action_space, dtype=np.uint16)
+        self.legal_offsets = np.zeros(num_envs + 1, dtype=np.uint32)
+        self.actions = np.empty(num_envs, dtype=np.uint32)
+
+    def reset(self):
+        self.pool.reset_into_nomask(self.out)
+        return self.out
+
+    def reset_indices(self, indices):
+        self.pool.reset_indices_into_nomask(list(indices), self.out)
+        return self.out
+
+    def reset_done(self, done_mask):
+        self.pool.reset_done_into_nomask(done_mask, self.out)
+        return self.out
+
+    def reset_indices_with_episode_seeds(self, indices, episode_seeds):
+        self.pool.reset_indices_with_episode_seeds_into_nomask(
+            list(indices), list(episode_seeds), self.out
+        )
+        return self.out
+
+    def step(self, actions):
+        self.pool.step_into_nomask(actions, self.out)
+        return self.out
+
+    def step_first_legal(self):
+        self.pool.step_first_legal_into_nomask(self.actions, self.out)
+        return self.out, self.actions
+
+    def step_random_legal(self, seeds):
+        self.pool.step_sample_legal_action_ids_uniform_into_nomask(seeds, self.actions, self.out)
+        return self.out, self.actions
+
+    def step_select_from_logits(self, logits):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        self.pool.step_select_from_logits_into_nomask(logits, self.actions, self.out)
+        return self.out, self.actions
+
+    def step_sample_from_logits(self, logits, seeds):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.step_sample_from_logits_into_nomask(logits, seeds, self.actions, self.out)
+        return self.out, self.actions
+
+    def select_actions_from_logits(self, logits):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        self.pool.select_actions_from_logits_into(logits, self.actions)
+        return self.actions
+
+    def sample_actions_from_logits(self, logits, seeds):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.sample_actions_from_logits_into(logits, seeds, self.actions)
+        return self.actions
+
+    def set_output_mask_bits_enabled(self, enabled: bool):
+        self.pool.set_output_mask_bits_enabled(enabled)
+
+    def set_i16_overflow_counter_enabled(self, enabled: bool):
+        self.pool.set_i16_overflow_counter_enabled(enabled)
+
+    def i16_overflow_count(self) -> int:
+        return int(self.pool.i16_overflow_count())
+
+    def reset_i16_overflow_count(self) -> None:
+        self.pool.reset_i16_overflow_count()
+
+    def legal_action_ids(self):
+        count = self.pool.legal_action_ids_into(self.legal_ids, self.legal_offsets)
+        return self.legal_ids[:count], self.legal_offsets
+
+    def legal_action_ids_and_sample_uniform(self, seeds):
+        count = self.pool.legal_action_ids_and_sample_uniform_into(
+            self.legal_ids, self.legal_offsets, seeds, self.actions
+        )
+        return self.legal_ids[:count], self.legal_offsets, self.actions
+
+
+class EnvPoolBuffersI16:
+    """Preallocated numpy buffers for high-throughput stepping with i16 obs."""
+
+    def __init__(self, pool: EnvPool) -> None:
+        self.pool = pool
+        num_envs = pool.envs_len
+        self.out = BatchOutMinimalI16(num_envs)
+        self.obs = self.out.obs
+        self.masks = self.out.masks
+        self.rewards = self.out.rewards
+        self.terminated = self.out.terminated
+        self.truncated = self.out.truncated
+        self.actor = self.out.actor
+        self.decision_kind = self.out.decision_kind
+        self.decision_id = self.out.decision_id
+        self.engine_status = self.out.engine_status
+        self.spec_hash = self.out.spec_hash
+        self.legal_ids = np.empty(num_envs * pool.action_space, dtype=np.uint16)
+        self.legal_offsets = np.zeros(num_envs + 1, dtype=np.uint32)
+        self.actions = np.empty(num_envs, dtype=np.uint32)
+
+    def reset(self):
+        self.pool.reset_into_i16(self.out)
+        return self.out
+
+    def reset_indices(self, indices):
+        self.pool.reset_indices_into_i16(list(indices), self.out)
+        return self.out
+
+    def reset_done(self, done_mask):
+        self.pool.reset_done_into_i16(done_mask, self.out)
+        return self.out
+
+    def reset_indices_with_episode_seeds(self, indices, episode_seeds):
+        self.pool.reset_indices_with_episode_seeds_into_i16(
+            list(indices), list(episode_seeds), self.out
+        )
+        return self.out
+
+    def step(self, actions):
+        self.pool.step_into_i16(actions, self.out)
+        return self.out
+
+    def step_first_legal(self):
+        self.pool.step_first_legal_into_i16(self.actions, self.out)
+        return self.out, self.actions
+
+    def step_random_legal(self, seeds):
+        self.pool.step_sample_legal_action_ids_uniform_into_i16(seeds, self.actions, self.out)
+        return self.out, self.actions
+
+    def step_select_from_logits(self, logits):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        self.pool.step_select_from_logits_into_i16(logits, self.actions, self.out)
+        return self.out, self.actions
+
+    def step_sample_from_logits(self, logits, seeds):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.step_sample_from_logits_into_i16(logits, seeds, self.actions, self.out)
+        return self.out, self.actions
+
+    def select_actions_from_logits(self, logits):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        self.pool.select_actions_from_logits_into(logits, self.actions)
+        return self.actions
+
+    def sample_actions_from_logits(self, logits, seeds):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.sample_actions_from_logits_into(logits, seeds, self.actions)
+        return self.actions
+
+    def set_output_mask_bits_enabled(self, enabled: bool):
+        self.pool.set_output_mask_bits_enabled(enabled)
+
+    def set_i16_clamp_enabled(self, enabled: bool):
+        self.pool.set_i16_clamp_enabled(enabled)
+
+    def set_i16_overflow_counter_enabled(self, enabled: bool):
+        self.pool.set_i16_overflow_counter_enabled(enabled)
+
+    def i16_overflow_count(self) -> int:
+        return int(self.pool.i16_overflow_count())
+
+    def reset_i16_overflow_count(self) -> None:
+        self.pool.reset_i16_overflow_count()
+
+    def legal_action_ids(self):
+        count = self.pool.legal_action_ids_into(self.legal_ids, self.legal_offsets)
+        return self.legal_ids[:count], self.legal_offsets
+
+    def legal_action_ids_and_sample_uniform(self, seeds):
+        count = self.pool.legal_action_ids_and_sample_uniform_into(
+            self.legal_ids, self.legal_offsets, seeds, self.actions
+        )
+        return self.legal_ids[:count], self.legal_offsets, self.actions
+
+
+class EnvPoolBuffersI16LegalIds:
+    """Preallocated numpy buffers for stepping with i16 obs + legal ids."""
+
+    def __init__(self, pool: EnvPool) -> None:
+        self.pool = pool
+        num_envs = pool.envs_len
+        self.out = BatchOutMinimalI16LegalIds(num_envs)
+        self.obs = self.out.obs
+        self.legal_ids = self.out.legal_ids
+        self.legal_offsets = self.out.legal_offsets
+        self.rewards = self.out.rewards
+        self.terminated = self.out.terminated
+        self.truncated = self.out.truncated
+        self.actor = self.out.actor
+        self.decision_kind = self.out.decision_kind
+        self.decision_id = self.out.decision_id
+        self.engine_status = self.out.engine_status
+        self.spec_hash = self.out.spec_hash
+        self.actions = np.empty(num_envs, dtype=np.uint32)
+
+    def reset(self):
+        self.pool.reset_into_i16_legal_ids(self.out)
+        return self.out
+
+    def reset_indices(self, indices):
+        self.pool.reset_indices_into_i16_legal_ids(list(indices), self.out)
+        return self.out
+
+    def reset_done(self, done_mask):
+        self.pool.reset_done_into_i16_legal_ids(done_mask, self.out)
+        return self.out
+
+    def reset_indices_with_episode_seeds(self, indices, episode_seeds):
+        self.pool.reset_indices_with_episode_seeds_into_i16_legal_ids(
+            list(indices), list(episode_seeds), self.out
+        )
+        return self.out
+
+    def step(self, actions):
+        self.pool.step_into_i16_legal_ids(actions, self.out)
+        return self.out
+
+    def step_first_legal(self):
+        self.pool.step_first_legal_into_i16_legal_ids(self.actions, self.out)
+        return self.out, self.actions
+
+    def step_random_legal(self, seeds):
+        self.pool.step_sample_legal_action_ids_uniform_into_i16_legal_ids(
+            seeds, self.actions, self.out
+        )
+        return self.out, self.actions
+
+    def step_select_from_logits(self, logits):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        self.pool.step_select_from_logits_into_i16_legal_ids(logits, self.actions, self.out)
+        return self.out, self.actions
+
+    def step_sample_from_logits(self, logits, seeds):
+        logits = np.ascontiguousarray(logits, dtype=np.float32)
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.step_sample_from_logits_into_i16_legal_ids(logits, seeds, self.actions, self.out)
+        return self.out, self.actions
+
+    def set_i16_overflow_counter_enabled(self, enabled: bool):
+        self.pool.set_i16_overflow_counter_enabled(enabled)
+
+    def i16_overflow_count(self) -> int:
+        return int(self.pool.i16_overflow_count())
+
+    def reset_i16_overflow_count(self) -> None:
+        self.pool.reset_i16_overflow_count()
+
+
+class EnvPoolTrajectoryBuffers:
+    """Preallocated numpy buffers for multi-step rollouts with masks."""
+
+    def __init__(self, pool: EnvPool, steps: int) -> None:
+        self.pool = pool
+        self.out = BatchOutTrajectory(steps, pool.envs_len)
+        self.steps = steps
+        self.obs = self.out.obs
+        self.masks = self.out.masks
+        self.rewards = self.out.rewards
+        self.terminated = self.out.terminated
+        self.truncated = self.out.truncated
+        self.actor = self.out.actor
+        self.decision_kind = self.out.decision_kind
+        self.decision_id = self.out.decision_id
+        self.engine_status = self.out.engine_status
+        self.spec_hash = self.out.spec_hash
+        self.actions = self.out.actions
+
+    def rollout_first_legal(self):
+        self.pool.rollout_first_legal_into(self.steps, self.out)
+        return self.out
+
+    def rollout_random_legal(self, seeds):
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.rollout_sample_legal_action_ids_uniform_into(self.steps, seeds, self.out)
+        return self.out
+
+
+class EnvPoolTrajectoryBuffersI16:
+    """Preallocated numpy buffers for multi-step rollouts with i16 obs."""
+
+    def __init__(self, pool: EnvPool, steps: int) -> None:
+        self.pool = pool
+        self.out = BatchOutTrajectoryI16(steps, pool.envs_len)
+        self.steps = steps
+        self.obs = self.out.obs
+        self.masks = self.out.masks
+        self.rewards = self.out.rewards
+        self.terminated = self.out.terminated
+        self.truncated = self.out.truncated
+        self.actor = self.out.actor
+        self.decision_kind = self.out.decision_kind
+        self.decision_id = self.out.decision_id
+        self.engine_status = self.out.engine_status
+        self.spec_hash = self.out.spec_hash
+        self.actions = self.out.actions
+
+    def rollout_first_legal(self):
+        self.pool.rollout_first_legal_into_i16(self.steps, self.out)
+        return self.out
+
+    def rollout_random_legal(self, seeds):
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.rollout_sample_legal_action_ids_uniform_into_i16(self.steps, seeds, self.out)
+        return self.out
+
+
+class EnvPoolTrajectoryBuffersI16LegalIds:
+    """Preallocated numpy buffers for multi-step rollouts with i16 obs + legal ids."""
+
+    def __init__(self, pool: EnvPool, steps: int) -> None:
+        self.pool = pool
+        self.out = BatchOutTrajectoryI16LegalIds(steps, pool.envs_len)
+        self.steps = steps
+        self.obs = self.out.obs
+        self.legal_ids = self.out.legal_ids
+        self.legal_offsets = self.out.legal_offsets
+        self.rewards = self.out.rewards
+        self.terminated = self.out.terminated
+        self.truncated = self.out.truncated
+        self.actor = self.out.actor
+        self.decision_kind = self.out.decision_kind
+        self.decision_id = self.out.decision_id
+        self.engine_status = self.out.engine_status
+        self.spec_hash = self.out.spec_hash
+        self.actions = self.out.actions
+
+    def rollout_first_legal(self):
+        self.pool.rollout_first_legal_into_i16_legal_ids(self.steps, self.out)
+        return self.out
+
+    def rollout_random_legal(self, seeds):
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.rollout_sample_legal_action_ids_uniform_into_i16_legal_ids(
+            self.steps, seeds, self.out
+        )
+        return self.out
+
+
+class EnvPoolTrajectoryBuffersNoMask:
+    """Preallocated numpy buffers for multi-step rollouts without masks."""
+
+    def __init__(self, pool: EnvPool, steps: int) -> None:
+        self.pool = pool
+        self.out = BatchOutTrajectoryNoMask(steps, pool.envs_len)
+        self.steps = steps
+        self.obs = self.out.obs
+        self.rewards = self.out.rewards
+        self.terminated = self.out.terminated
+        self.truncated = self.out.truncated
+        self.actor = self.out.actor
+        self.decision_kind = self.out.decision_kind
+        self.decision_id = self.out.decision_id
+        self.engine_status = self.out.engine_status
+        self.spec_hash = self.out.spec_hash
+        self.actions = self.out.actions
+
+    def rollout_first_legal(self):
+        self.pool.rollout_first_legal_into_nomask(self.steps, self.out)
+        return self.out
+
+    def rollout_random_legal(self, seeds):
+        seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+        self.pool.rollout_sample_legal_action_ids_uniform_into_nomask(self.steps, seeds, self.out)
+        return self.out
+
+
+def spec_bundle():
+    return {
+        "policy_version": POLICY_VERSION,
+        "spec_hash": SPEC_HASH,
+        "observation": json.loads(observation_spec_json()),
+        "action": json.loads(action_spec_json()),
+    }
+
 
 __all__ = [
     "EnvPool",
     "EnvPoolBuffers",
+    "EnvPoolBuffersNoMask",
+    "EnvPoolBuffersI16",
+    "EnvPoolBuffersI16LegalIds",
+    "EnvPoolTrajectoryBuffers",
+    "EnvPoolTrajectoryBuffersI16",
+    "EnvPoolTrajectoryBuffersI16LegalIds",
+    "EnvPoolTrajectoryBuffersNoMask",
     "BatchOutMinimal",
+    "BatchOutMinimalI16",
+    "BatchOutMinimalI16LegalIds",
+    "BatchOutMinimalNoMask",
+    "BatchOutTrajectory",
+    "BatchOutTrajectoryI16",
+    "BatchOutTrajectoryI16LegalIds",
+    "BatchOutTrajectoryNoMask",
     "BatchOutDebug",
     "ACTION_SPACE_SIZE",
+    "ACTOR_NONE",
+    "DECISION_KIND_NONE",
+    "POLICY_VERSION",
     "OBS_LEN",
     "SPEC_HASH",
     "RlStep",
+    "RlStepNoMask",
+    "RlStepI16LegalIds",
     "reset_rl",
+    "reset_rl_into",
+    "reset_rl_nomask",
+    "reset_rl_nomask_into",
+    "reset_rl_i16_legal_ids",
+    "reset_rl_i16_legal_ids_into",
     "step_rl",
+    "step_rl_into",
+    "step_rl_nomask",
+    "step_rl_nomask_into",
+    "step_rl_i16_legal_ids",
+    "step_rl_i16_legal_ids_into",
+    "step_rl_select_from_logits_i16_legal_ids",
+    "step_rl_select_from_logits_i16_legal_ids_into",
+    "step_rl_sample_from_logits_i16_legal_ids",
+    "step_rl_sample_from_logits_i16_legal_ids_into",
     "pass_action_id_for_decision_kind",
     "PASS_ACTION_ID",
+    "observation_spec_json",
+    "action_spec_json",
+    "decode_action_id",
+    "build_info",
+    "make_train_pool",
+    "make_eval_pool",
+    "spec_bundle",
     "__version__",
 ]

weiss_sim/rl.py

@@ -1,10 +1,31 @@
+"""Lightweight RL helpers for the Weiss simulator.
+
+Spec exports:
+- `weiss_sim.observation_spec_json()` and `weiss_sim.action_spec_json()` for
+  the stable layout and versioned encoding contract.
+- `weiss_sim.spec_bundle()` for a combined, self-describing spec payload.
+
+Episode metadata:
+- `EnvPool.episode_seed_batch()`, `episode_index_batch()`, `env_index_batch()`,
+  `starting_player_batch()` for deterministic bookkeeping.
+
+Replay controls:
+- `EnvPool.enable_replay_sampling(..., visibility_mode="public"|"full")`
+"""
+
 from __future__ import annotations
 
 from dataclasses import dataclass
 
 import numpy as np
 
-from .weiss_sim import PASS_ACTION_ID, BatchOutMinimal, EnvPool
+from .weiss_sim import (
+    PASS_ACTION_ID,
+    BatchOutMinimal,
+    BatchOutMinimalI16LegalIds,
+    BatchOutMinimalNoMask,
+    EnvPool,
+)
 
 
 @dataclass(frozen=True)
@@ -15,6 +36,35 @@ class RlStep:
     terminated: np.ndarray
     truncated: np.ndarray
     actor: np.ndarray
+    decision_kind: np.ndarray
+    decision_id: np.ndarray
+    engine_status: np.ndarray
+    spec_hash: np.ndarray
+
+
+@dataclass(frozen=True)
+class RlStepNoMask:
+    obs: np.ndarray
+    rewards: np.ndarray
+    terminated: np.ndarray
+    truncated: np.ndarray
+    actor: np.ndarray
+    decision_kind: np.ndarray
+    decision_id: np.ndarray
+    engine_status: np.ndarray
+    spec_hash: np.ndarray
+
+
+@dataclass(frozen=True)
+class RlStepI16LegalIds:
+    obs: np.ndarray
+    legal_ids: np.ndarray
+    legal_offsets: np.ndarray
+    rewards: np.ndarray
+    terminated: np.ndarray
+    truncated: np.ndarray
+    actor: np.ndarray
+    decision_kind: np.ndarray
     decision_id: np.ndarray
     engine_status: np.ndarray
     spec_hash: np.ndarray
@@ -25,7 +75,19 @@ def pass_action_id_for_decision_kind(decision_kind):
 
 
 def reset_rl(pool: EnvPool) -> RlStep:
+    """Reset the pool and return a minimal step bundle."""
+    out = BatchOutMinimal(pool.envs_len)
+    return reset_rl_into(pool, out)
+
+
+def step_rl(pool: EnvPool, actions) -> RlStep:
+    """Step the pool once with one action per env and return a minimal bundle."""
     out = BatchOutMinimal(pool.envs_len)
+    return step_rl_into(pool, actions, out)
+
+
+def reset_rl_into(pool: EnvPool, out: BatchOutMinimal) -> RlStep:
+    """Reset the pool into a preallocated BatchOutMinimal."""
     pool.reset_into(out)
     return RlStep(
         obs=out.obs,
@@ -34,14 +96,15 @@ def reset_rl(pool: EnvPool) -> RlStep:
         terminated=out.terminated,
         truncated=out.truncated,
         actor=out.actor,
+        decision_kind=out.decision_kind,
         decision_id=out.decision_id,
         engine_status=out.engine_status,
         spec_hash=out.spec_hash,
     )
 
 
-def step_rl(pool: EnvPool, actions) -> RlStep:
-    out = BatchOutMinimal(pool.envs_len)
+def step_rl_into(pool: EnvPool, actions, out: BatchOutMinimal) -> RlStep:
+    """Step the pool into a preallocated BatchOutMinimal."""
     pool.step_into(actions, out)
     return RlStep(
         obs=out.obs,
@@ -50,7 +113,167 @@ def step_rl(pool: EnvPool, actions) -> RlStep:
         terminated=out.terminated,
         truncated=out.truncated,
         actor=out.actor,
+        decision_kind=out.decision_kind,
+        decision_id=out.decision_id,
+        engine_status=out.engine_status,
+        spec_hash=out.spec_hash,
+    )
+
+
+def reset_rl_nomask(pool: EnvPool) -> RlStepNoMask:
+    """Reset the pool and return a minimal bundle without dense masks."""
+    out = BatchOutMinimalNoMask(pool.envs_len)
+    return reset_rl_nomask_into(pool, out)
+
+
+def step_rl_nomask(pool: EnvPool, actions) -> RlStepNoMask:
+    """Step the pool once without dense masks."""
+    out = BatchOutMinimalNoMask(pool.envs_len)
+    return step_rl_nomask_into(pool, actions, out)
+
+
+def reset_rl_nomask_into(pool: EnvPool, out: BatchOutMinimalNoMask) -> RlStepNoMask:
+    """Reset the pool into a preallocated BatchOutMinimalNoMask."""
+    pool.reset_into_nomask(out)
+    return RlStepNoMask(
+        obs=out.obs,
+        rewards=out.rewards,
+        terminated=out.terminated,
+        truncated=out.truncated,
+        actor=out.actor,
+        decision_kind=out.decision_kind,
+        decision_id=out.decision_id,
+        engine_status=out.engine_status,
+        spec_hash=out.spec_hash,
+    )
+
+
+def step_rl_nomask_into(pool: EnvPool, actions, out: BatchOutMinimalNoMask) -> RlStepNoMask:
+    """Step the pool into a preallocated BatchOutMinimalNoMask."""
+    pool.step_into_nomask(actions, out)
+    return RlStepNoMask(
+        obs=out.obs,
+        rewards=out.rewards,
+        terminated=out.terminated,
+        truncated=out.truncated,
+        actor=out.actor,
+        decision_kind=out.decision_kind,
+        decision_id=out.decision_id,
+        engine_status=out.engine_status,
+        spec_hash=out.spec_hash,
+    )
+
+
+def reset_rl_i16_legal_ids(pool: EnvPool) -> RlStepI16LegalIds:
+    """Reset the pool and return an i16+legal-ids step bundle."""
+    out = BatchOutMinimalI16LegalIds(pool.envs_len)
+    return reset_rl_i16_legal_ids_into(pool, out)
+
+
+def step_rl_i16_legal_ids(pool: EnvPool, actions) -> RlStepI16LegalIds:
+    """Step the pool once with one action per env and return i16+legal-ids bundle."""
+    out = BatchOutMinimalI16LegalIds(pool.envs_len)
+    return step_rl_i16_legal_ids_into(pool, actions, out)
+
+
+def reset_rl_i16_legal_ids_into(
+    pool: EnvPool, out: BatchOutMinimalI16LegalIds
+) -> RlStepI16LegalIds:
+    """Reset the pool into a preallocated BatchOutMinimalI16LegalIds."""
+    pool.reset_into_i16_legal_ids(out)
+    return RlStepI16LegalIds(
+        obs=out.obs,
+        legal_ids=out.legal_ids,
+        legal_offsets=out.legal_offsets,
+        rewards=out.rewards,
+        terminated=out.terminated,
+        truncated=out.truncated,
+        actor=out.actor,
+        decision_kind=out.decision_kind,
+        decision_id=out.decision_id,
+        engine_status=out.engine_status,
+        spec_hash=out.spec_hash,
+    )
+
+
+def step_rl_i16_legal_ids_into(
+    pool: EnvPool, actions, out: BatchOutMinimalI16LegalIds
+) -> RlStepI16LegalIds:
+    """Step the pool into a preallocated BatchOutMinimalI16LegalIds."""
+    pool.step_into_i16_legal_ids(actions, out)
+    return RlStepI16LegalIds(
+        obs=out.obs,
+        legal_ids=out.legal_ids,
+        legal_offsets=out.legal_offsets,
+        rewards=out.rewards,
+        terminated=out.terminated,
+        truncated=out.truncated,
+        actor=out.actor,
+        decision_kind=out.decision_kind,
         decision_id=out.decision_id,
         engine_status=out.engine_status,
         spec_hash=out.spec_hash,
     )
+
+
+def step_rl_select_from_logits_i16_legal_ids(pool: EnvPool, logits):
+    """Select actions from logits in Rust, step envs, return i16+legal-ids bundle."""
+    out = BatchOutMinimalI16LegalIds(pool.envs_len)
+    actions = np.empty(pool.envs_len, dtype=np.uint32)
+    return step_rl_select_from_logits_i16_legal_ids_into(pool, logits, actions, out)
+
+
+def step_rl_sample_from_logits_i16_legal_ids(pool: EnvPool, logits, seeds):
+    """Sample actions from logits in Rust, step envs, return i16+legal-ids bundle."""
+    out = BatchOutMinimalI16LegalIds(pool.envs_len)
+    actions = np.empty(pool.envs_len, dtype=np.uint32)
+    return step_rl_sample_from_logits_i16_legal_ids_into(pool, logits, seeds, actions, out)
+
+
+def step_rl_select_from_logits_i16_legal_ids_into(
+    pool: EnvPool, logits, actions, out: BatchOutMinimalI16LegalIds
+):
+    """Select actions from logits into preallocated buffers."""
+    logits = np.ascontiguousarray(logits, dtype=np.float32)
+    pool.step_select_from_logits_into_i16_legal_ids(logits, actions, out)
+    return (
+        RlStepI16LegalIds(
+            obs=out.obs,
+            legal_ids=out.legal_ids,
+            legal_offsets=out.legal_offsets,
+            rewards=out.rewards,
+            terminated=out.terminated,
+            truncated=out.truncated,
+            actor=out.actor,
+            decision_kind=out.decision_kind,
+            decision_id=out.decision_id,
+            engine_status=out.engine_status,
+            spec_hash=out.spec_hash,
+        ),
+        actions,
+    )
+
+
+def step_rl_sample_from_logits_i16_legal_ids_into(
+    pool: EnvPool, logits, seeds, actions, out: BatchOutMinimalI16LegalIds
+):
+    """Sample actions from logits into preallocated buffers."""
+    logits = np.ascontiguousarray(logits, dtype=np.float32)
+    seeds = np.asarray(seeds, dtype=np.uint64).ravel()
+    pool.step_sample_from_logits_into_i16_legal_ids(logits, seeds, actions, out)
+    return (
+        RlStepI16LegalIds(
+            obs=out.obs,
+            legal_ids=out.legal_ids,
+            legal_offsets=out.legal_offsets,
+            rewards=out.rewards,
+            terminated=out.terminated,
+            truncated=out.truncated,
+            actor=out.actor,
+            decision_kind=out.decision_kind,
+            decision_id=out.decision_id,
+            engine_status=out.engine_status,
+            spec_hash=out.spec_hash,
+        ),
+        actions,
+    )

{weiss_sim-0.1.3.dist-info → weiss_sim-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weiss-sim
-Version: 0.1.3
+Version: 0.2.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -12,17 +12,19 @@ Classifier: Programming Language :: Rust
 Classifier: Topic :: Games/Entertainment
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Dist: numpy>=1.23
+License-File: LICENSE-APACHE
+License-File: LICENSE-MIT
 Summary: Deterministic Weiss Schwarz simulator with a Rust core and Python bindings.
 Keywords: weiss-schwarz,reinforcement-learning,simulation,pyo3,rl
 Author: Lallan
 License: MIT OR Apache-2.0
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Homepage, https://github.com/victorwp288/weiss-schwarz-simulator
-Project-URL: Repository, https://github.com/victorwp288/weiss-schwarz-simulator
+Project-URL: Changelog, https://github.com/victorwp288/weiss-schwarz-simulator/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://victorwp288.github.io/weiss-schwarz-simulator/rustdoc/
+Project-URL: Homepage, https://github.com/victorwp288/weiss-schwarz-simulator
 Project-URL: Issues, https://github.com/victorwp288/weiss-schwarz-simulator/issues
-Project-URL: Changelog, https://github.com/victorwp288/weiss-schwarz-simulator/blob/main/CHANGELOG.md
+Project-URL: Repository, https://github.com/victorwp288/weiss-schwarz-simulator
 
 # Weiss Schwarz Simulator (Rust core + Python bindings)
 
@@ -91,22 +93,22 @@ in GitHub Actions secrets; otherwise you can manually run the `Wheels` workflow
 ### Benchmark Snapshot (main, top 12)
 
 <!-- BENCHMARKS:START -->
-_Last updated: 2026-01-05 00:44 UTC_
+_Last updated: 2026-02-04 08:56 UTC_
 
 | Benchmark | Time |
 | --- | --- |
-| rust/advance_until_decision | 63280 ns/iter |
-| rust/step_batch_64 | 26268 ns/iter |
-| rust/step_batch_fast_256_priority_off | 111592 ns/iter |
-| rust/step_batch_fast_256_priority_on | 109646 ns/iter |
-| rust/legal_actions | 44 ns/iter |
-| rust/legal_actions_forced | 43 ns/iter |
-| rust/on_reverse_decision_frequency_on | 1534 ns/iter |
-| rust/on_reverse_decision_frequency_off | 1540 ns/iter |
-| rust/observation_encode | 228 ns/iter |
-| rust/observation_encode_forced | 233 ns/iter |
-| rust/mask_construction | 455 ns/iter |
-| rust/mask_construction_forced | 412 ns/iter |
+| rust/advance_until_decision | 31245 ns/iter |
+| rust/step_batch_64 | 15036 ns/iter |
+| rust/step_batch_fast_256_priority_off | 74182 ns/iter |
+| rust/step_batch_fast_256_priority_on | 67407 ns/iter |
+| rust/legal_actions | 12 ns/iter |
+| rust/legal_actions_forced | 12 ns/iter |
+| rust/on_reverse_decision_frequency_on | 1098 ns/iter |
+| rust/on_reverse_decision_frequency_off | 1094 ns/iter |
+| rust/observation_encode | 172 ns/iter |
+| rust/observation_encode_forced | 171 ns/iter |
+| rust/mask_construction | 407 ns/iter |
+| rust/mask_construction_forced | 408 ns/iter |
 <!-- BENCHMARKS:END -->
 
 
@@ -272,6 +274,10 @@ Convenience properties:
 Python helper:
 - `EnvPoolBuffers(pool)` allocates persistent numpy buffers and exposes `reset()`, `step()`, and `legal_action_ids()`.
 - `reset_rl(pool)` / `step_rl(pool, actions)` return a `RlStep` dataclass with named fields.
+- `RlStepI16LegalIds` is like `RlStep` but uses `int16` observations and `uint16` legal action IDs to save memory. The `I16` name refers to the observation dtype; legal IDs are still unsigned. Use `reset_rl_i16_legal_ids` / `step_rl_i16_legal_ids` when you want compact 16-bit legal IDs, and use `reset_rl` / `step_rl` for the standard `RlStep` representation.
+- `*_i16_legal_ids` APIs require `ACTION_SPACE_SIZE <= 65535` (fits in `uint16`) and raise `ValueError` if the action space exceeds that limit.
+- `reset_rl_i16_legal_ids(pool)` / `step_rl_i16_legal_ids(pool, actions)` return `RlStepI16LegalIds`.
+- `step_rl_select_from_logits_i16_legal_ids(pool, logits)` selects actions in Rust and returns `(RlStepI16LegalIds, actions)`. `logits` must be a `np.ndarray` of `float32` with shape `(num_envs, action_space)`, and `actions` is a `np.ndarray` of `uint32` with shape `(num_envs,)`. Type hint example (requires `from numpy.typing import NDArray` and `import numpy as np`): `step_rl_select_from_logits_i16_legal_ids(pool: EnvPool, logits: NDArray[np.float32]) -> tuple[RlStepI16LegalIds, NDArray[np.uint32]]`
 - `pass_action_id_for_decision_kind(decision_kind)` returns `PASS_ACTION_ID` for convenience.
 
 ---

weiss_sim-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+weiss_sim\__init__.py,sha256=4h_nXIvfgsOCzHPn3htbOj1YlsbIMJkqIcR2dCu2ENw,28782
+weiss_sim\rl.py,sha256=Xi9VjI5_khkiBEoKcKu5hQrQIPihY0ceFMNB91_Phh0,9078
+weiss_sim\weiss_sim.cp312-win_amd64.pyd,sha256=UnTcX-yFrLv3jP_jF1HLzDfHxk8qCPHkIQhgOieVUfI,2033664
+weiss_sim-0.2.0.dist-info\METADATA,sha256=Y0A9RFwrVZTDDgx604VDCa3fICFWvdK2v5f_PGkYb3k,16725
+weiss_sim-0.2.0.dist-info\WHEEL,sha256=xGRyMfC2nQGcuDMHm_QfSkv2HVaAAAo1DvjuUmalQqw,97
+weiss_sim-0.2.0.dist-info\licenses\LICENSE-APACHE,sha256=-ZG9DmEHrv435__Y2U--eTa6XO4tkE36MBOrSbq30os,10975
+weiss_sim-0.2.0.dist-info\licenses\LICENSE-MIT,sha256=q1kMWmXeoM3k6opAnUoxADX62Z_qbvQCYKrGoRF8BVI,1114
+weiss_sim-0.2.0.dist-info\RECORD,,

{weiss_sim-0.1.3.dist-info → weiss_sim-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.10.2)
+Generator: maturin (1.11.5)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64

weiss_sim-0.2.0.dist-info/licenses/LICENSE-APACHE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright (c) 2025 Weiss Schwarz Simulator contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

weiss_sim-0.2.0.dist-info/licenses/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Weiss Schwarz Simulator contributors
+
+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.

weiss_sim-0.1.3.dist-info/RECORD

@@ -1,6 +0,0 @@
-weiss_sim-0.1.3.dist-info/METADATA,sha256=EVgOL0kkb-25UMNjZT69AsvDN3ZA2GvLM2ONM5jih6U,15555
-weiss_sim-0.1.3.dist-info/WHEEL,sha256=MicGETHZ2NSvTN4l4NAAzDXbOHnrlOKS0CnBsnFTiLs,97
-weiss_sim/__init__.py,sha256=1pcn5K4wCGxSycm-JmR0B5x3n2EZdXAOClvDwTafXDM,2025
-weiss_sim/rl.py,sha256=Ylh0NTOgf2XEubEw-LZNawNTzHZv5SRKMpXBISqTQAI,1395
-weiss_sim/weiss_sim.cp312-win_amd64.pyd,sha256=mXCWFlFnec9-IVI5MF5yY63R0mIfNq0hfTMJE_3E6oE,1466368
-weiss_sim-0.1.3.dist-info/RECORD,,