diff --git a/.github/ISSUE_TEMPLATE/01_bug_report.md b/.github/ISSUE_TEMPLATE/01_bug_report.md
new file mode 100644
index 00000000..8495c6cb
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/01_bug_report.md
@@ -0,0 +1,21 @@
+---
+name: 🐜 Bug report
+about: If something isn't working 🔧
+---
+
+### Subject of the issue
+Describe your issue here.
+
+### Your environment
+* Version of detectmate
+* Version of python
+* Docker or manual installation?
+
+### Steps to reproduce
+Tell us how to reproduce this issue.
+
+### Expected behaviour
+Tell us what should happen
+
+### Actual behaviour
+Tell us what happens instead
diff --git a/.github/ISSUE_TEMPLATE/02_feature_request.md b/.github/ISSUE_TEMPLATE/02_feature_request.md
new file mode 100644
index 00000000..442b05cd
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/02_feature_request.md
@@ -0,0 +1,20 @@
+---
+name: 🚀 Feature request
+about: If you have a feature request 💡
+---
+
+**Context**
+
+What are you trying to do and how would you want to do it differently? Is it something you currently you cannot do? Is this related to an issue/problem?
+
+**Alternatives**
+
+Can you achieve the same result doing it in an alternative way? Is the alternative considerable?
+
+**Has the feature been requested before?**
+
+Please provide a link to the issue.
+
+**If the feature request is approved, would you be willing to submit a PR?**
+
+Yes / No _(Help can be provided if you need assistance submitting a PR)_
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..3ba13e0c
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1 @@
+blank_issues_enabled: false
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 00000000..53dec300
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,19 @@
+# Task
+<!-- Please add link a relevant issue or task -->
+
+# Description
+<!-- Please include a summary of the change -->
+<!-- Any details that you think are important to review this PR? -->
+<!-- Are there other PRs related to this one? -->
+
+# How Has This Been Tested?
+<!-- Please describe how you tested your changes -->
+
+# Checklist
+<!-- Go over all the following points, and put an `x` in all the boxes that apply -->
+
+- [ ] This Pull-Request goes to the **development** branch.
+- [ ] I have successfully run prek locally.
+- [ ] I have added tests to cover my changes.
+- [ ] I have linked the issue-id to the task-description.
+- [ ] I have performed a self-review of my own code.
diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
new file mode 100644
index 00000000..c4f6d829
--- /dev/null
+++ b/.github/workflows/python-publish.yml
@@ -0,0 +1,26 @@
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package distributions to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
diff --git a/.gitignore b/.gitignore
index 3113ce1a..f9e5cbf7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,8 +7,6 @@ __pycache__/
 # C extensions
 *.so
 
-dummy*
-
 # Distribution / packaging
 .Python
 build/
@@ -199,3 +197,9 @@ cython_debug/
 local/
 test.ipynb
 test.py
+
+# claude code
+CLAUDE.md
+docs/superpowers/
+docs/design/
+.claude/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index b651b0ed..50901a6f 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -26,7 +26,7 @@ repos:
   hooks:
     - id: mypy
       args: [--strict, --ignore-missing-imports]
-      exclude: ^(docs/|tests/)
+      exclude: ^(docs/|detectmatelibrary_tests/)
       additional_dependencies:
         - pydantic
         - types-PyYAML
@@ -58,7 +58,7 @@ repos:
   rev: 1.8.6
   hooks:
     - id: bandit
-      exclude: (^tests/|.*/test_.*|^test_.*)
+      exclude: (^detectmatelibrary_tests/|.*/test_.*|^test_.*)
 
 # Unused code detection
 - repo: https://github.com/jendrikseipp/vulture
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..b13c3dcb
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,199 @@
+# AGENTS.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+DetectMateLibrary is a Python library for log processing and anomaly detection. It provides composable, stream-friendly components (parsers and detectors) that communicate via Protobuf-based schemas. The library is designed for both single-process and microservice deployments.
+
+## Development Commands
+
+```bash
+# Install dependencies and pre-commit hooks
+uv sync --dev
+uv run prek install
+
+# Run tests
+uv run pytest -q
+uv run pytest -s                                      # verbose with stdout
+uv run pytest --cov=. --cov-report=term-missing       # with coverage
+uv run pytest detectmatelibrary_tests/test_foo.py                       # single test file
+
+# Run linting/formatting (all pre-commit hooks)
+uv run prek run -a
+
+# Recompile Protobuf (only if schemas.proto is modified)
+protoc --proto_path=src/detectmatelibrary/schemas/ \
+  --python_out=src/detectmatelibrary/schemas/ \
+  src/detectmatelibrary/schemas/schemas.proto
+
+# Scaffold a new component workspace
+mate create --type <parser|detector> --name <name> --dir <target_dir>
+```
+
+## Architecture
+
+### Data Flow
+
+```
+Raw Logs → Parser → ParserSchema → Detector → DetectorSchema (Alerts)
+```
+
+All data flows through typed Protobuf-backed schema objects. Components are stateful and support an optional training phase before detection.
+
+### Core Abstractions (`src/detectmatelibrary/common/`)
+
+- **`CoreComponent`** — base class managing buffering, ID generation, and training state
+  - **`CoreParser(CoreComponent)`** — parse raw logs into `ParserSchema`
+  - **`CoreDetector(CoreComponent)`** — detect anomalies in `ParserSchema`, emit `DetectorSchema`
+- **`CoreConfig`** / **`CoreParserConfig`** / **`CoreDetectorConfig`** — Pydantic-based configuration hierarchy (`extra="forbid"`)
+
+#### Component Lifecycle (FitLogic)
+
+Each `process()` call passes through a state machine controlled by config fields:
+
+| Config field | Meaning |
+|---|---|
+| `data_use_configure` | How many items to run through `configure()` before training. `None` = skip. |
+| `data_use_training` | How many items to run through `train()` before detection. `None` = skip. |
+
+Phases in order: **CONFIGURE → TRAIN → DETECT** (phases are skipped when the corresponding field is `None`).
+
+State control enums allow overriding automatic transitions: `TrainState.KEEP_TRAINING` / `STOP_TRAINING` and `ConfigState.KEEP_CONFIGURE` / `STOP_CONFIGURE` on the component's `fit_logic`.
+
+#### CoreDetectorConfig: EventsConfig
+
+Detectors use a nested `events` structure to select which variables to track per event ID, plus `global_instances` for event-ID-independent variables (e.g., hostname, level):
+
+```yaml
+detectors:
+  MyDetector:
+    method_type: new_value_detector
+    auto_config: false          # true = auto-discover variables from training data
+    persist:                    # optional — omit to disable state saving
+      path: ./state             # base path; detector name is appended automatically
+      interval_seconds: 300     # save every N seconds
+      events_until_save: null   # also save after N ingested events (null = disabled)
+      auto_load: false          # restore saved state on construction
+      storage_options: {}       # fsspec credentials (S3, Azure, GCS, etc.)
+    events:
+      login_failure:            # named event ID (string) or integer EventID
+        instance_label:         # arbitrary instance name
+          params: {}
+          variables:
+            - pos: pid          # named wildcard label OR integer position in ParserSchema.variables[]
+              name: pid
+          header_variables:
+            - pos: Type         # key in ParserSchema.logFormatVariables{}
+              params: {}
+    global:                     # event-ID-independent instances (GLOBAL_EVENT_ID = "*")
+      global_monitor:
+        header_variables:
+          - pos: Level
+            params: {}
+```
+
+Named event IDs (strings) and named variable positions require templates loaded from a CSV with an `EventId` column. Call `TemplateMatcher.compile_detector_config(config)` to resolve names to integers at setup time.
+
+Use `generate_detector_config()` (`src/detectmatelibrary/common/_config/_compile.py`) to build this programmatically:
+
+```python
+from detectmatelibrary.common._config import generate_detector_config
+
+config = generate_detector_config(
+    variable_selection={1: ["var_0", "var_1"]},
+    detector_name="MyDetector",
+    method_type="new_value_detector",
+)
+```
+
+Load/save configs via `BasicConfig.from_dict(d, method_id=...)` and `.to_dict(method_id=...)` for YAML round-trip compatibility.
+
+After training completes, detectors with `auto_config=False` automatically call `validate_config_coverage()` (`src/detectmatelibrary/common/detector.py`), which logs warnings when configured EventIDs or variable positions were never observed in training data. This catches config/data mismatches early — check logs after the training phase when adding new detector configs.
+
+### Schema System (`src/detectmatelibrary/schemas/`)
+
+- `BaseSchema` wraps generated Protobuf messages with dict-like access (`schema["field"]`)
+- Key schemas: `LogSchema`, `ParserSchema`, `DetectorSchema`
+- Support serialization to/from bytes for transport and persistence
+
+### Buffering Modes (`src/detectmatelibrary/utils/data_buffer.py`)
+
+Three modes via `ArgsBuffer` config:
+- **NO_BUF** — one item at a time (default)
+- **BATCH** — accumulate N items, process as batch
+- **WINDOW** — sliding window of size N
+
+### Implementations
+
+- **Parsers** (`src/detectmatelibrary/parsers/`): `JsonParser`, `LogBatcherParser`, `DummyParser`, `MatcherParser` (Drain3 template mining; supports named wildcards `<username>` alongside positional `<*>`)
+- **Detectors** (`src/detectmatelibrary/detectors/`): `NewValueDetector`, `NewValueComboDetector`, `RandomDetector`, `DummyDetector`
+- **Utilities** (`src/detectmatelibrary/utils/`): `DataBuffer`, `EventPersistency`, `KeyExtractor`, `TimeFormatHandler`, `IdGenerator`
+- Uses the `regex` package (not stdlib `re`) — relevant when writing type annotations or imports involving patterns
+
+## Extending the Library
+
+Implement a custom detector by subclassing `CoreDetector`:
+
+```python
+class MyDetectorConfig(CoreDetectorConfig):
+    method_type: str = "my_detector"
+    my_param: int = 10
+
+class MyDetector(CoreDetector):
+    def __init__(self, name="MyDetector", config=MyDetectorConfig()):
+        super().__init__(name=name, config=config)
+
+    def train(self, input_: ParserSchema) -> None:
+        pass  # optional
+
+    def detect(self, input_: ParserSchema, output_: DetectorSchema) -> bool:
+        output_["detectorID"] = self.name
+        output_["score"] = 0.0
+        return False  # True = anomaly detected
+```
+
+Same pattern applies for `CoreParser` — implement `parse(input_: LogSchema, output_: ParserSchema) -> bool`.
+
+### Wiring persist support into a new detector
+
+Detectors that maintain an `EventPersistency` instance must do two things to support the `persist:` config block:
+
+**1. Call `_register_persistency()` at the end of `__init__`:**
+
+```python
+def __init__(self, name="MyDetector", config=MyDetectorConfig()):
+    super().__init__(name=name, config=config)
+    self.persistency = EventPersistency(event_data_class=EventStabilityTracker)
+    self._register_persistency(self.persistency)  # must be last
+```
+
+**2. Preserve `config.persist` across `set_configuration()` rebuilds:**
+
+`set_configuration()` replaces `self.config` via `from_dict()`, which produces a config with no `persist` key — silently dropping the user's persist settings. Save and restore it:
+
+```python
+def set_configuration(self) -> None:
+    old_persist = self.config.persist
+    # ... build config_dict, call from_dict() ...
+    self.config = MyDetectorConfig.from_dict(config_dict, self.name)
+    self.config.persist = old_persist
+```
+
+Omitting either step means a `persist:` block in the YAML is silently ignored with no error.
+
+## Code Quality
+
+Pre-commit hooks enforce:
+- **mypy** strict mode
+- **flake8** linting, **autopep8** formatting (max line 110)
+- **bandit** security checks, **vulture** dead-code detection (70% threshold)
+- **docformatter** docstring style
+
+Python 3.12 is required (see `.python-version`).
+
+
+# Git
+NEVER include "Co-Authored-By ..." in your commit or PR messages.
+
+Design documents (files under `docs/design/`) must NEVER be committed to the repository.
diff --git a/CLAUDE.md b/CLAUDE.md
deleted file mode 100644
index 95c372c9..00000000
--- a/CLAUDE.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-DetectMateLibrary is a Python library for log processing and anomaly detection. It provides composable, stream-friendly components (parsers and detectors) that communicate via Protobuf-based schemas. The library is designed for both single-process and microservice deployments.
-
-## Development Commands
-
-```bash
-# Install dependencies and pre-commit hooks
-uv sync --dev
-uv run prek install
-
-# Run tests
-uv run pytest -q
-uv run pytest -s                                      # verbose with stdout
-uv run pytest --cov=. --cov-report=term-missing       # with coverage
-uv run pytest tests/test_foo.py                       # single test file
-
-# Run linting/formatting (all pre-commit hooks)
-uv run prek run -a
-
-# Recompile Protobuf (only if schemas.proto is modified)
-protoc --proto_path=src/detectmatelibrary/schemas/ \
-  --python_out=src/detectmatelibrary/schemas/ \
-  src/detectmatelibrary/schemas/schemas.proto
-
-# Scaffold a new component workspace
-mate create --type <parser|detector> --name <name> --dir <target_dir>
-```
-
-## Architecture
-
-### Data Flow
-
-```
-Raw Logs → Parser → ParserSchema → Detector → DetectorSchema (Alerts)
-```
-
-All data flows through typed Protobuf-backed schema objects. Components are stateful and support an optional training phase before detection.
-
-### Core Abstractions (`src/detectmatelibrary/common/`)
-
-- **`CoreComponent`** — base class managing buffering, ID generation, and training state
-  - **`CoreParser(CoreComponent)`** — parse raw logs into `ParserSchema`
-  - **`CoreDetector(CoreComponent)`** — detect anomalies in `ParserSchema`, emit `DetectorSchema`
-- **`CoreConfig`** / **`CoreParserConfig`** / **`CoreDetectorConfig`** — Pydantic-based configuration hierarchy
-
-### Schema System (`src/detectmatelibrary/schemas/`)
-
-- `BaseSchema` wraps generated Protobuf messages with dict-like access (`schema["field"]`)
-- Key schemas: `LogSchema`, `ParserSchema`, `DetectorSchema`
-- Support serialization to/from bytes for transport and persistence
-
-### Buffering Modes (`src/detectmatelibrary/utils/data_buffer.py`)
-
-Three modes via `ArgsBuffer` config:
-- **NO_BUF** — one item at a time (default)
-- **BATCH** — accumulate N items, process as batch
-- **WINDOW** — sliding window of size N
-
-### Implementations
-
-- **Parsers** (`src/detectmatelibrary/parsers/`): `JsonParser`, `DummyParser`, `TemplateMatcherParser` (uses Drain3 for template mining)
-- **Detectors** (`src/detectmatelibrary/detectors/`): `NewValueDetector`, `NewValueComboDetector`, `RandomDetector`, `DummyDetector`
-- **Utilities** (`src/detectmatelibrary/utils/`): `DataBuffer`, `EventPersistency`, `KeyExtractor`, `TimeFormatHandler`, `IdGenerator`
-
-## Extending the Library
-
-Implement a custom detector by subclassing `CoreDetector`:
-
-```python
-class MyDetectorConfig(CoreDetectorConfig):
-    method_type: str = "my_detector"
-    my_param: int = 10
-
-class MyDetector(CoreDetector):
-    def __init__(self, name="MyDetector", config=MyDetectorConfig()):
-        super().__init__(name=name, config=config)
-
-    def train(self, input_: ParserSchema) -> None:
-        pass  # optional
-
-    def detect(self, input_: ParserSchema, output_: DetectorSchema) -> bool:
-        output_["detectorID"] = self.name
-        output_["score"] = 0.0
-        return False  # True = anomaly detected
-```
-
-Same pattern applies for `CoreParser` — implement `parse(input_: LogSchema, output_: ParserSchema) -> bool`.
-
-## Code Quality
-
-Pre-commit hooks enforce:
-- **mypy** strict mode
-- **flake8** linting, **autopep8** formatting (max line 110)
-- **bandit** security checks, **vulture** dead-code detection (70% threshold)
-- **docformatter** docstring style
-
-Python 3.12 is required (see `.python-version`).
diff --git a/README.md b/README.md
index 75442afa..c9ccb822 100644
--- a/README.md
+++ b/README.md
@@ -96,3 +96,19 @@ workspaces/custom_parser/          # workspace root
 ├── pyproject.toml                 # minimal project + dev extras
 └── README.md                      # setup instructions
 ```
+
+## Documentation
+
+- [Project Documentation](https://ait-detectmate.github.io/DetectMateLibrary/latest/)
+
+## Contribution
+
+We're happily taking patches and other contributions. Please see the following links for how to get started:
+
+- [GitHub Workflow](https://ait-detectmate.github.io/DetectMateLibrary/latest/contribution/)
+
+If you encounter any bugs, please create an issue on [Github](https://github.com/ait-detectmate/DetectMateLibrary/issues).
+
+## License
+
+[EUPL-1.2](https://github.com/ait-detectmate/DetectMateLibrary/blob/main/LICENSE.md)
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000..e7cbac59
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,32 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.x.x   | :white_check_mark: |
+| < 1.0.0   | :x:                |
+
+> [!IMPORTANT]
+> Currently DetectMateService is a work in progress and heavily under development. Possible vulnerabilities will not be treated any special and can be issued using [GitHub-Issues](https://github.com/ait-detectmate/DetectMateService/issues)
+
+## Reporting a Vulnerability
+
+Please email reports about any security related issues you find to aecid@ait.ac.at. This mail is delivered to a small developer team. Your email will be acknowledged within one business day, and you'll receive a more detailed response to your email within 7 days indicating the next steps in handling your report.
+
+Please use a descriptive subject line for your report email. After the initial reply to your report, our team will endeavor to keep you informed of the progress being made towards a fix and announcement.
+
+In addition, please include the following information along with your report:
+
+* Your name and affiliation (if any).
+* A description of the technical details of the vulnerabilities. It is very important to let us know how we can reproduce your findings.
+* An explanation who can exploit this vulnerability, and what they gain when doing so -- write an attack scenario. This will help us evaluate your report quickly, especially if the issue is complex.
+* Whether this vulnerability public or known to third parties. If it is, please provide details.
+* Whether we could mention your name in the changelogs.
+
+Once an issue is reported we use the following disclosure process:
+
+* When a report is received, we confirm the issue and determine its severity.
+* If we know of specific third-party services or software based on DetectMateService that require mitigation before publication, those projects will be notified.
+* Fixes are prepared for the last minor release of the latest major release.
+* Patch releases are published for all fixed released versions.
diff --git a/config/pipeline_config_default.yaml b/config/pipeline_config_default.yaml
index 04754958..c9888068 100644
--- a/config/pipeline_config_default.yaml
+++ b/config/pipeline_config_default.yaml
@@ -2,13 +2,13 @@ parsers:
     MatcherParser:
         method_type: matcher_parser
         auto_config: False
-        log_format: "type=<Type> msg=audit(<Time>:*): <Content>"
+        log_format: "type=<Type> msg=audit(<Time>:<Line>): <Content>"
         time_format: null
         params:
             remove_spaces: True
             remove_punctuation: True
             lowercase: True
-            path_templates: tests/test_folder/audit_templates.txt
+            path_templates: detectmatelibrary_tests/test_folder/audit_templates.txt
 
     JsonMatcherParser:
         method_type: matcher_parser
@@ -68,8 +68,59 @@ detectors:
     NewValueComboDetector:
         method_type: new_value_combo_detector
         auto_config: False
+        events:
+            1:
+                test:
+                    params: {}
+                    variables:
+                        - pos: 0
+                          name: var1
+                    header_variables:
+                        - pos: level
+
+    NewEventDetector:
+        method_type: new_event_detector
+        auto_config: False
+        params: {}
+
+
+    ValueRangeDetector:
+        method_type: value_range_detector
+        auto_config: False
         params:
-            comb_size: 3
+            ignore_non_numerical_val: True
+        events:
+            1:
+                test:
+                    params: {}
+                    variables:
+                        - pos: 1
+                          name: test
+
+    BigramFrequencyDetector:
+        method_type: bigram_frequency_detector
+        auto_config: False
+        params:
+            prob_thresh: 0.05
+            default_freqs: True
+            skip_repetitions: True
+        events:
+            1:
+                test:
+                    params: {}
+                    variables:
+                        - pos: 0
+                          name: var1
+                          params:
+                              threshold: 0.
+                    header_variables:
+                        - pos: level
+                          params: {}
+
+    CharsetDetector:
+        method_type: charset_detector
+        auto_config: False
+        params: {}
         events:
             1:
                 test:
@@ -77,5 +128,8 @@ detectors:
                     variables:
                         - pos: 0
                           name: var1
+                          params:
+                              threshold: 0.
                     header_variables:
                         - pos: level
+                          params: {}
diff --git a/src/tools/__init__.py b/detectmatelibrary_tests/__init__.py
similarity index 100%
rename from src/tools/__init__.py
rename to detectmatelibrary_tests/__init__.py
diff --git a/src/tools/workspace/__init__.py b/detectmatelibrary_tests/test_common/__init__.py
similarity index 100%
rename from src/tools/workspace/__init__.py
rename to detectmatelibrary_tests/test_common/__init__.py
diff --git a/tests/test_common/test_config.py b/detectmatelibrary_tests/test_common/test_config.py
similarity index 98%
rename from tests/test_common/test_config.py
rename to detectmatelibrary_tests/test_common/test_config.py
index 7d53d97c..bf7f3d14 100644
--- a/tests/test_common/test_config.py
+++ b/detectmatelibrary_tests/test_common/test_config.py
@@ -19,7 +19,7 @@
 
 
 def load_test_config() -> dict:
-    with open("tests/test_folder/test_config.yaml", 'r') as file:
+    with open("detectmatelibrary_tests/test_folder/test_config.yaml", 'r') as file:
         return yaml.safe_load(file)
 
 
diff --git a/tests/test_common/test_config_roundtrip.py b/detectmatelibrary_tests/test_common/test_config_roundtrip.py
similarity index 75%
rename from tests/test_common/test_config_roundtrip.py
rename to detectmatelibrary_tests/test_common/test_config_roundtrip.py
index 24359ffe..6659a9e1 100644
--- a/tests/test_common/test_config_roundtrip.py
+++ b/detectmatelibrary_tests/test_common/test_config_roundtrip.py
@@ -25,7 +25,7 @@ class MockupDetectorConfig(BasicConfig):
 
 
 def load_test_config() -> dict:
-    with open("tests/test_folder/test_config.yaml", 'r') as file:
+    with open("detectmatelibrary_tests/test_folder/test_config.yaml", 'r') as file:
         return yaml.safe_load(file)
 
 
@@ -290,3 +290,90 @@ def test_parser_true_roundtrip(self):
 
         # Dicts should be identical
         assert dict1 == dict2
+
+
+class TestNamedVariablesRoundtrip:
+    """Test that named wildcard positions and named event IDs round-trip
+    correctly."""
+
+    def test_named_pos_preserved_as_string(self):
+        """String pos values must survive yaml -> pydantic -> yaml
+        unchanged."""
+        config_yaml = load_test_config()
+        method_id = "detector_named_pos"
+
+        config = MockupDetectorConfig.from_dict(config_yaml, method_id)
+        result_dict = config.to_dict(method_id)
+
+        original = config_yaml["detectors"][method_id]
+        result = result_dict["detectors"][method_id]
+
+        orig_vars = original["events"][1]["example_detector_1"]["variables"]
+        result_vars = result["events"][1]["example_detector_1"]["variables"]
+
+        assert len(result_vars) == len(orig_vars)
+        for orig_var, result_var in zip(orig_vars, result_vars):
+            assert result_var["pos"] == orig_var["pos"]
+            assert isinstance(result_var["pos"], str)  # must stay a string, not coerced to int
+
+    def test_named_pos_no_name_field_when_omitted(self):
+        """Variables with only a label pos must not emit a 'name' key."""
+        config_yaml = load_test_config()
+        config = MockupDetectorConfig.from_dict(config_yaml, "detector_named_pos")
+        result_dict = config.to_dict("detector_named_pos")
+
+        instance = result_dict["detectors"]["detector_named_pos"]["events"][1]["example_detector_1"]
+        no_params_var = instance["variables"][0]  # pos: pid, no params
+
+        assert "pos" in no_params_var
+        assert no_params_var["pos"] == "pid"
+        assert "name" not in no_params_var
+
+    def test_named_pos_params_preserved(self):
+        """Named pos variable with params must preserve those params."""
+        config_yaml = load_test_config()
+        config = MockupDetectorConfig.from_dict(config_yaml, "detector_named_pos")
+        result_dict = config.to_dict("detector_named_pos")
+
+        instance = result_dict["detectors"]["detector_named_pos"]["events"][1]["example_detector_1"]
+        with_params_var = instance["variables"][1]  # pos: op, params: {threshold: 0.5}
+
+        assert with_params_var["pos"] == "op"
+        assert with_params_var["params"] == {"threshold": 0.5}
+
+    def test_named_event_id_preserved_as_string(self):
+        """String event ID keys must survive yaml -> pydantic -> yaml
+        unchanged."""
+        config_yaml = load_test_config()
+        method_id = "detector_named_event_id"
+
+        config = MockupDetectorConfig.from_dict(config_yaml, method_id)
+        result_dict = config.to_dict(method_id)
+
+        result_events = result_dict["detectors"][method_id]["events"]
+        assert "login_failure" in result_events
+        assert isinstance(list(result_events.keys())[0], str)
+
+    def test_named_pos_true_roundtrip(self):
+        """Yaml -> pydantic -> yaml -> pydantic produces identical objects."""
+        config_yaml = load_test_config()
+        method_id = "detector_named_pos"
+
+        config1 = MockupDetectorConfig.from_dict(config_yaml, method_id)
+        dict1 = config1.to_dict(method_id)
+        config2 = MockupDetectorConfig.from_dict(dict1, method_id)
+        dict2 = config2.to_dict(method_id)
+
+        assert dict1 == dict2
+
+    def test_named_event_id_true_roundtrip(self):
+        """Yaml -> pydantic -> yaml -> pydantic produces identical objects."""
+        config_yaml = load_test_config()
+        method_id = "detector_named_event_id"
+
+        config1 = MockupDetectorConfig.from_dict(config_yaml, method_id)
+        dict1 = config1.to_dict(method_id)
+        config2 = MockupDetectorConfig.from_dict(dict1, method_id)
+        dict2 = config2.to_dict(method_id)
+
+        assert dict1 == dict2
diff --git a/tests/test_common/test_core.py b/detectmatelibrary_tests/test_common/test_core.py
similarity index 54%
rename from tests/test_common/test_core.py
rename to detectmatelibrary_tests/test_common/test_core.py
index f8d0183c..114a74bc 100644
--- a/tests/test_common/test_core.py
+++ b/detectmatelibrary_tests/test_common/test_core.py
@@ -1,8 +1,9 @@
-from detectmatelibrary.common._core_op._fit_logic import ConfigState, TrainState
+from detectmatelibrary.common._core_op._fit_logic import FitLogicState
+
 from detectmatelibrary.common.core import CoreConfig, CoreComponent
 from detectmatelibrary.common._config import BasicConfig
 
-from detectmatelibrary.utils.data_buffer import ArgsBuffer
+from detectmatelibrary.utils.data_buffer import ArgsBuffer, BufferMode
 
 import detectmatelibrary.schemas._op as op_schemas
 import detectmatelibrary.schemas as schemas
@@ -29,10 +30,20 @@ class MockConfigWithTraining(CoreConfig):
     "auto_config": False,
     "start_id": 10,
     "data_use_training": None,
-    "data_use_configure": None
+    "data_use_configure": None,
+    "use_config_data_as_training": True
 }
 
 
+def _make_log(i: int) -> schemas.LogSchema:
+    return schemas.LogSchema({
+        "__version__": "1.0.0",
+        "logID": str(i),
+        "logSource": "test",
+        "hostname": "test_hostname"
+    })
+
+
 class MockComponent(CoreComponent):
     def __init__(self, name: str, config: MockConfig = MockConfig()) -> None:
         super().__init__(name=name, type_="Dummy", config=config)
@@ -234,12 +245,38 @@ def test_training(self) -> None:
             })
             assert expected == log
 
+    def test_training_use_config_data(self) -> None:
+        config = MockConfigWithTraining(
+            data_use_configure=4, use_config_data_as_training=True
+        )
+        component = MockComponentWithTraining(name="Dummy4.2", config=config)
+
+        for i in range(10):
+            component.process(
+                schemas.LogSchema({
+                    "__version__": "1.0.0",
+                    "logID": str(i),
+                    "logSource": "test",
+                    "hostname": "test_hostname"
+                })
+            )
+        total = component.fitlogic.data_use_training + component.fitlogic.data_use_configure
+        assert len(component.train_data) == total
+        for i, log in enumerate(component.train_data):
+            expected = schemas.LogSchema({
+                "__version__": "1.0.0",
+                "logID": str(i),
+                "logSource": "test",
+                "hostname": "test_hostname"
+            })
+            assert expected == log
+
     def test_training_force_stop(self) -> None:
         component = MockComponentWithTraining(name="Dummy5")
 
         for i in range(10):
             if i == 2:
-                component.fitlogic.train_state = TrainState.STOP_TRAINING
+                component.update_state("stop_training")
             component.process(
                 schemas.LogSchema({
                     "__version__": "1.0.0",
@@ -253,7 +290,7 @@ def test_training_force_stop(self) -> None:
 
     def test_training_keep_training(self) -> None:
         component = MockComponentWithTraining(name="Dummy6")
-        component.fitlogic.train_state = TrainState.KEEP_TRAINING
+        component.update_state("keep_training")
 
         for i in range(10):
             component.process(
@@ -267,18 +304,10 @@ def test_training_keep_training(self) -> None:
 
         assert len(component.train_data) == 10
 
-    def _make_log(self, i: int) -> schemas.LogSchema:
-        return schemas.LogSchema({
-            "__version__": "1.0.0",
-            "logID": str(i),
-            "logSource": "test",
-            "hostname": "test_hostname"
-        })
-
     def test_configuration(self) -> None:
         component = MockComponentWithConfigure(name="DummyCfg1")
 
-        results = [component.process(self._make_log(i)) for i in range(10)]
+        results = [component.process(_make_log(i)) for i in range(10)]
 
         assert component.fitlogic.data_used_configure == 3
         assert len(component.configure_data) == 3
@@ -288,45 +317,208 @@ def test_configuration(self) -> None:
     def test_configuration_returns_none_during_configure(self) -> None:
         component = MockComponentWithConfigure(name="DummyCfg2")
 
-        results = [component.process(self._make_log(i)) for i in range(3)]
+        results = [component.process(_make_log(i)) for i in range(3)]
 
         assert all(r is None for r in results)
 
+    def test_wrong_update_state(self) -> None:
+        component = MockComponentWithConfigure(name="DummyCfg3")
+        with pytest.warns(UserWarning):
+            component.update_state("incorrect_state")
+
     def test_configuration_force_stop(self) -> None:
         component = MockComponentWithConfigure(name="DummyCfg3")
-        component.fitlogic.configure_state = ConfigState.STOP_CONFIGURE
+        component.update_state("stop_configuring")
 
         for i in range(10):
-            component.process(self._make_log(i))
+            component.process(_make_log(i))
 
         assert len(component.configure_data) == 0
         assert component.set_configuration_called == 0
 
     def test_configuration_keep_configure(self) -> None:
         component = MockComponentWithConfigure(name="DummyCfg4")
-        component.fitlogic.configure_state = ConfigState.KEEP_CONFIGURE
+        component.update_state("keep_configuring")
 
         for i in range(10):
-            component.process(self._make_log(i))
+            component.process(_make_log(i))
 
         assert len(component.configure_data) == 10
         assert component.set_configuration_called == 0
 
     def test_configuration_before_training(self) -> None:
-        config = CoreConfig(data_use_configure=2, data_use_training=3)
+        config = CoreConfig(
+            data_use_configure=2, data_use_training=3, use_config_data_as_training=False
+        )
         component = MockComponentWithConfigureAndTraining(name="DummyCfg5", config=config)
 
         for i in range(10):
-            component.process(self._make_log(i))
+            component.process(_make_log(i))
 
         assert len(component.configure_data) == 2
         assert len(component.train_data) == 3
         assert component.set_configuration_called == 1
 
+    def test_configuration_before_training_with_buffer(self) -> None:
+        config = CoreConfig(
+            data_use_configure=2, data_use_training=3, use_config_data_as_training=True
+        )
+        component = MockComponentWithConfigureAndTraining(name="DummyCfg5", config=config)
+
+        for i in range(10):
+            component.process(_make_log(i))
+
+        assert len(component.configure_data) == 2
+        assert len(component.train_data) == 5
+        assert component.set_configuration_called == 1
+
     def test_set_configuration_called_once(self) -> None:
         component = MockComponentWithConfigure(name="DummyCfg6")
 
         for i in range(component.config.data_use_configure + 5):  # type: ignore[operator]
-            component.process(self._make_log(i))
+            component.process(_make_log(i))
 
         assert component.set_configuration_called == 1
+
+
+class MockConfigWithPostTrain(CoreConfig):
+    data_use_training: int | None = 3
+
+
+class MockComponentWithPostTrain(CoreComponent):
+    def __init__(self, name: str, config: CoreConfig = MockConfigWithPostTrain()) -> None:
+        super().__init__(
+            name=name, type_="Dummy", config=config, input_schema=schemas.LogSchema
+        )
+        self.post_train_called: int = 0
+
+    def train(self, input_) -> None:
+        pass
+
+    def post_train(self) -> None:
+        self.post_train_called += 1
+
+    def run(self, input_, output_) -> bool:
+        return False
+
+
+class TestPostTrain:
+    def test_post_train_called_once_after_training(self) -> None:
+        component = MockComponentWithPostTrain(name="PostTrain1")
+        for i in range(10):
+            component.process(_make_log(i))
+        assert component.post_train_called == 1
+
+    def test_post_train_not_called_without_training(self) -> None:
+        component = MockComponentWithPostTrain(name="PostTrain2", config=CoreConfig())
+        for i in range(10):
+            component.process(_make_log(i))
+        assert component.post_train_called == 0
+
+    def test_post_train_called_on_first_detection_item(self) -> None:
+        """post_train fires on the item immediately after training ends."""
+        component = MockComponentWithPostTrain(name="PostTrain3")
+        # data_use_training=3, so 4th item triggers post_train
+        for i in range(3):
+            component.process(_make_log(i))
+        assert component.post_train_called == 0
+        component.process(_make_log(3))
+        assert component.post_train_called == 1
+        # subsequent items don't re-trigger it
+        component.process(_make_log(4))
+        assert component.post_train_called == 1
+
+
+class TestCaseState:
+    def test_normal_behaviour(self) -> None:
+        config = CoreConfig(
+            data_use_configure=2, data_use_training=3, use_config_data_as_training=True
+        )
+        component = MockComponentWithConfigureAndTraining(name="DummyCfg5", config=config)
+
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.DO_CONFIG.describe()
+
+        component.process(_make_log(1))
+        component.process(_make_log(2))
+        assert component.get_state() == FitLogicState.DO_TRAIN.describe()
+
+        component.process(_make_log(1))
+        component.process(_make_log(2))
+        component.process(_make_log(3))
+        assert component.get_state() == FitLogicState.NOTHING.describe()
+
+    def test_nothing_going_on(self) -> None:
+        config = CoreConfig(use_config_data_as_training=True)
+        component = MockComponentWithConfigureAndTraining(name="DummyCfg5", config=config)
+
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.NOTHING.describe()
+
+    def test_change_state(self) -> None:
+        config = CoreConfig(use_config_data_as_training=True)
+        component = MockComponentWithConfigureAndTraining(name="DummyCfg5", config=config)
+
+        assert component.get_state() == FitLogicState.NOTHING.describe()
+
+        component.update_state("keep_configuring")
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.DO_CONFIG.describe()
+
+        component.update_state("stop_configuring")
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.NOTHING.describe()
+
+        component.update_state("keep_training")
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.DO_TRAIN.describe()
+
+        component.update_state("stop_training")
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.NOTHING.describe()
+
+    def test_change_state_weird_cases(self) -> None:
+        config = CoreConfig(use_config_data_as_training=True)
+        component = MockComponentWithConfigureAndTraining(name="DummyCfg5", config=config)
+
+        assert component.get_state() == FitLogicState.NOTHING.describe()
+
+        component.update_state("keep_configuring")
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.DO_CONFIG.describe()
+
+        component.update_state("stop_training")
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.DO_CONFIG.describe()
+
+        component.update_state("keep_training")
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.DO_CONFIG.describe()
+
+        component.update_state("stop_configuring")
+        component.update_state("keep_training")
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.DO_TRAIN.describe()
+
+        component.update_state("keep_configuring")
+        component.process(_make_log(0))
+        assert component.get_state() == FitLogicState.DO_CONFIG.describe()
+
+
+class TestCoreComponentContextManager:
+    def test_can_be_used_as_context_manager(self):
+        component = CoreComponent(name="test", config=CoreConfig(), args_buffer=ArgsBuffer(BufferMode.NO_BUF))
+        with component as c:
+            assert c is component
+
+    def test_exit_calls_saver_stop_when_set(self):
+        stopped = {"called": False}
+
+        class FakeSaver:
+            def stop(self): stopped["called"] = True
+
+        component = CoreComponent(name="test", config=CoreConfig(), args_buffer=ArgsBuffer(BufferMode.NO_BUF))
+        component.saver = FakeSaver()
+        with component:
+            pass
+        assert stopped["called"]
diff --git a/tests/test_common/test_core_detector.py b/detectmatelibrary_tests/test_common/test_core_detector.py
similarity index 100%
rename from tests/test_common/test_core_detector.py
rename to detectmatelibrary_tests/test_common/test_core_detector.py
diff --git a/tests/test_common/test_core_parser.py b/detectmatelibrary_tests/test_common/test_core_parser.py
similarity index 100%
rename from tests/test_common/test_core_parser.py
rename to detectmatelibrary_tests/test_common/test_core_parser.py
diff --git a/tests/test_common/test_extract_timestamp.py b/detectmatelibrary_tests/test_common/test_extract_timestamp.py
similarity index 100%
rename from tests/test_common/test_extract_timestamp.py
rename to detectmatelibrary_tests/test_common/test_extract_timestamp.py
diff --git a/detectmatelibrary_tests/test_common/test_fit_logic.py b/detectmatelibrary_tests/test_common/test_fit_logic.py
new file mode 100644
index 00000000..11e96c49
--- /dev/null
+++ b/detectmatelibrary_tests/test_common/test_fit_logic.py
@@ -0,0 +1,62 @@
+"""Tests for FitLogic training lifecycle hooks."""
+
+from detectmatelibrary.common._core_op._fit_logic import (
+    FitLogic, FitLogicState, TrainState
+)
+
+
+class TestFinishTraining:
+    """Test that finish_training() fires exactly once after bounded training."""
+
+    def test_finish_training_fires_once_after_bounded_training(self) -> None:
+        logic = FitLogic(data_use_configure=None, data_use_training=3)
+        finish_calls = []
+        for _ in range(6):
+            logic.run()
+            finish_calls.append(logic.finish_training())
+        assert finish_calls.count(True) == 1
+
+    def test_finish_training_fires_on_first_nothing_after_training(self) -> None:
+        logic = FitLogic(data_use_configure=None, data_use_training=2)
+        states = []
+        finishes = []
+        for _ in range(5):
+            state = logic.run()
+            states.append(state)
+            finishes.append(logic.finish_training())
+        # First two calls are DO_TRAIN, third is first NOTHING
+        assert states[:2] == [FitLogicState.DO_TRAIN, FitLogicState.DO_TRAIN]
+        assert states[2] == FitLogicState.NOTHING
+        assert finishes[2] is True
+        assert all(not f for f in finishes[:2])
+        assert all(not f for f in finishes[3:])
+
+    def test_finish_training_not_called_without_training(self) -> None:
+        logic = FitLogic(data_use_configure=None, data_use_training=None)
+        for _ in range(5):
+            logic.run()
+            assert logic.finish_training() is False
+
+    def test_finish_training_not_called_during_training(self) -> None:
+        logic = FitLogic(data_use_configure=None, data_use_training=5)
+        for _ in range(5):
+            state = logic.run()
+            assert state == FitLogicState.DO_TRAIN
+            assert logic.finish_training() is False
+
+    def test_finish_training_not_called_with_keep_training(self) -> None:
+        logic = FitLogic(data_use_configure=None, data_use_training=None)
+        logic.train_state = TrainState.KEEP_TRAINING
+        for _ in range(10):
+            state = logic.run()
+            assert state == FitLogicState.DO_TRAIN
+            assert logic.finish_training() is False
+
+    def test_finish_training_after_configure_and_training(self) -> None:
+        """finish_training fires correctly even when configure phase precedes training."""
+        logic = FitLogic(data_use_configure=2, data_use_training=3)
+        finish_calls = []
+        for _ in range(8):
+            logic.run()
+            finish_calls.append(logic.finish_training())
+        assert finish_calls.count(True) == 1
diff --git a/detectmatelibrary_tests/test_common/test_persist_config.py b/detectmatelibrary_tests/test_common/test_persist_config.py
new file mode 100644
index 00000000..9b38b3bd
--- /dev/null
+++ b/detectmatelibrary_tests/test_common/test_persist_config.py
@@ -0,0 +1,145 @@
+import warnings
+
+import fsspec
+import pytest
+from pydantic import ValidationError
+
+from detectmatelibrary.common._config._compile import MissingParamsWarning
+from detectmatelibrary.common.detector import CoreDetector, CoreDetectorConfig, PersistConfig
+from detectmatelibrary.detectors.new_value_detector import NewValueDetectorConfig
+from detectmatelibrary.utils.persistency.event_data_structures.trackers import EventStabilityTracker
+from detectmatelibrary.utils.persistency.event_persistency import EventPersistency
+
+
+class TestPersistConfig:
+    def test_defaults(self):
+        cfg = PersistConfig()
+        assert cfg.path == "./state"
+        assert cfg.interval_seconds == 300
+        assert cfg.events_until_save is None
+        assert cfg.auto_load is False
+        assert cfg.storage_options == {}
+
+    def test_custom_values(self):
+        cfg = PersistConfig(path="./my-path", interval_seconds=60, auto_load=True)
+        assert cfg.path == "./my-path"
+        assert cfg.interval_seconds == 60
+        assert cfg.auto_load is True
+
+    def test_events_until_save_accepts_int(self):
+        cfg = PersistConfig(events_until_save=500)
+        assert cfg.events_until_save == 500
+
+    def test_extra_fields_rejected(self):
+        with pytest.raises(ValidationError):
+            PersistConfig(unknown_field="value")  # type: ignore
+
+
+class TestCoreDetectorConfigPersistField:
+    def test_persist_is_none_by_default(self):
+        cfg = CoreDetectorConfig()
+        assert cfg.persist is None
+
+    def test_persist_accepts_persist_config(self):
+        cfg = CoreDetectorConfig(persist=PersistConfig(path="./custom"))
+        assert cfg.persist is not None
+        assert cfg.persist.path == "./custom"
+
+    def test_persist_accepts_none_explicitly(self):
+        cfg = CoreDetectorConfig(persist=None)
+        assert cfg.persist is None
+
+
+class TestRegisterPersistency:
+    def test_noop_when_persist_is_none(self):
+        det = CoreDetector()
+        p = EventPersistency(event_data_class=EventStabilityTracker)
+        det._register_persistency(p)
+        assert det.saver is None
+
+    def test_creates_saver_when_persist_configured(self):
+        config = CoreDetectorConfig(
+            persist=PersistConfig(path="memory://regpersist_create/state")
+        )
+        det = CoreDetector(config=config)
+        p = EventPersistency(event_data_class=EventStabilityTracker)
+        det._register_persistency(p)
+        assert det.saver is not None
+        det.saver.stop()
+
+    def test_saver_path_includes_detector_name(self):
+        config = CoreDetectorConfig(
+            persist=PersistConfig(path="memory://regpersist_path/state")
+        )
+        det = CoreDetector(name="MyDetector", config=config)
+        p = EventPersistency(event_data_class=EventStabilityTracker)
+        det._register_persistency(p)
+        assert det.saver is not None
+        det.saver.stop()  # stop() calls save() as final save
+        fs = fsspec.filesystem("memory")
+        assert fs.exists("regpersist_path/state/MyDetector/metadata.json")
+
+
+class TestPersistConfigSerialization:
+    def test_to_dict_places_persist_at_top_level(self):
+        config = NewValueDetectorConfig(
+            auto_config=True,
+            persist=PersistConfig(path="./my-state", interval_seconds=60),
+        )
+        result = config.to_dict("MyDet")
+        inner = result["detectors"]["MyDet"]
+        assert "persist" in inner
+        assert inner["persist"]["path"] == "./my-state"
+        assert inner["persist"]["interval_seconds"] == 60
+        assert "persist" not in inner.get("params", {})
+
+    def test_to_dict_omits_persist_when_none(self):
+        config = NewValueDetectorConfig(auto_config=True)
+        result = config.to_dict("MyDet")
+        inner = result["detectors"]["MyDet"]
+        assert "persist" not in inner
+
+    def test_from_dict_loads_persist_block(self):
+        config_dict = {
+            "detectors": {
+                "MyDet": {
+                    "method_type": "new_value_detector",
+                    "auto_config": True,
+                    "persist": {"path": "./my-state", "interval_seconds": 60},
+                }
+            }
+        }
+        config = NewValueDetectorConfig.from_dict(config_dict, "MyDet")
+        assert config.persist is not None
+        assert config.persist.path == "./my-state"
+        assert config.persist.interval_seconds == 60
+
+    def test_roundtrip_yaml_to_pydantic_to_yaml(self):
+        config_dict = {
+            "detectors": {
+                "MyDet": {
+                    "method_type": "new_value_detector",
+                    "auto_config": True,
+                    "persist": {"path": "./my-state"},
+                }
+            }
+        }
+        config = NewValueDetectorConfig.from_dict(config_dict, "MyDet")
+        result = config.to_dict("MyDet")
+        assert result["detectors"]["MyDet"]["persist"]["path"] == "./my-state"
+
+    def test_no_missing_params_warning_with_persist_only(self):
+        config_dict = {
+            "detectors": {
+                "MyDet": {
+                    "method_type": "new_value_detector",
+                    "auto_config": False,
+                    "persist": {"path": "./state"},
+                }
+            }
+        }
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            NewValueDetectorConfig.from_dict(config_dict, "MyDet")
+        missing_params_warnings = [x for x in w if issubclass(x.category, MissingParamsWarning)]
+        assert len(missing_params_warnings) == 0
diff --git a/src/tools/workspace/templates/__init__.py b/detectmatelibrary_tests/test_detectors/__init__.py
similarity index 100%
rename from src/tools/workspace/templates/__init__.py
rename to detectmatelibrary_tests/test_detectors/__init__.py
diff --git a/src/detectmatelibrary/detectors/dummy_detector.py b/detectmatelibrary_tests/test_detectors/dummy_detector.py
similarity index 100%
rename from src/detectmatelibrary/detectors/dummy_detector.py
rename to detectmatelibrary_tests/test_detectors/dummy_detector.py
diff --git a/detectmatelibrary_tests/test_detectors/test_bigram_frequency_detector.py b/detectmatelibrary_tests/test_detectors/test_bigram_frequency_detector.py
new file mode 100644
index 00000000..3e678d47
--- /dev/null
+++ b/detectmatelibrary_tests/test_detectors/test_bigram_frequency_detector.py
@@ -0,0 +1,596 @@
+"""Tests for BigramFrequencyDetector class.
+
+This module tests the BigramFrequencyDetector implementation including:
+- Initialization and configuration
+- Training functionality to learn known values
+- Detection logic for unexpected values
+- Event-specific configuration handling
+- Input/output schema validation
+"""
+
+from detectmatelibrary.common._core_op._fit_logic import TrainState
+from detectmatelibrary.detectors.bigram_frequency_detector import (
+    BigramFrequencyDetector, BigramFrequencyDetectorConfig, BufferMode
+)
+from detectmatelibrary.common._core_op._fit_logic import ConfigState
+from detectmatelibrary.constants import GLOBAL_EVENT_ID
+from detectmatelibrary.parsers.template_matcher import MatcherParser
+from detectmatelibrary.helper.from_to import From
+import detectmatelibrary.schemas as schemas
+from detectmatelibrary.utils.aux import time_test_mode
+from detectmatelibrary_tests.test_pipelines.test_configuration_engine import AUDIT_LOG
+# Set time test mode for consistent timestamps
+time_test_mode()
+
+
+_SKIP_REPETITIONS_CONFIG = {
+    "detectors": {
+        "MultipleDetector": {
+            "method_type": "bigram_frequency_detector",
+            "auto_config": False,
+            "params": {"skip_repetitions": True},
+            "events": {
+                1: {
+                    "test": {
+                        "params": {},
+                        "variables": [{"pos": 1, "name": "test", "params": {}}],
+                        "header_variables": [{"pos": "level", "params": {}}],
+                    }
+                }
+            },
+        }
+    }
+}
+
+
+config = {
+    "detectors": {
+        "CustomInit": {
+            "method_type": "bigram_frequency_detector",
+            "auto_config": False,
+            "params": {},
+            "events": {
+                1: {
+                    "instance1": {
+                        "params": {},
+                        "variables": [{
+                            "pos": 0, "name": "sad", "params": {}
+                        }]
+                    }
+                }
+            }
+        },
+        "MultipleDetector": {
+            "method_type": "bigram_frequency_detector",
+            "auto_config": False,
+            "params": {},
+            "events": {
+                1: {
+                    "test": {
+                        "params": {},
+                        "variables": [{
+                            "pos": 1, "name": "test", "params": {}
+                        }],
+                        "header_variables": [{
+                            "pos": "level", "params": {}
+                        }]
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+class TestBigramFrequencyDetectorInitialization:
+    """Test BigramFrequencyDetector initialization and configuration."""
+
+    def test_default_initialization(self):
+        """Test detector initialization with default parameters."""
+        detector = BigramFrequencyDetector()
+
+        assert detector.name == "BigramFrequencyDetector"
+        assert hasattr(detector, 'config')
+        assert detector.data_buffer.mode == BufferMode.NO_BUF
+        assert detector.input_schema == schemas.ParserSchema
+        assert detector.output_schema == schemas.DetectorSchema
+        assert hasattr(detector, 'persistency')
+
+    def test_custom_config_initialization(self):
+        """Test detector initialization with custom configuration."""
+        detector = BigramFrequencyDetector(name="CustomInit", config=config)
+
+        assert detector.name == "CustomInit"
+        assert hasattr(detector, 'persistency')
+        assert isinstance(detector.persistency.events_data, dict)
+
+
+class TestBigramFrequencyDetectorTraining:
+    """Test BigramFrequencyDetector training functionality."""
+
+    def test_train_multiple_values(self):
+        """Test training with multiple different values."""
+        detector = BigramFrequencyDetector(config=config, name="MultipleDetector")
+        # Train with multiple values (only event 1 should be tracked per config)
+        for event in range(3):
+            for level in ["INFO", "WARNING", "ERROR"]:
+                parser_data = schemas.ParserSchema({
+                    "parserType": "test",
+                    "EventID": event,
+                    "template": "test template",
+                    "variables": ["0", "assa"],
+                    "logID": "1",
+                    "parsedLogID": "1",
+                    "parserID": "test_parser",
+                    "log": "test log message",
+                    "logFormatVariables": {"level": level}
+                })
+                detector.train(parser_data)
+
+        # Only event 1 should be tracked (based on events config)
+        assert len(detector.persistency.events_data) == 1
+        event_data = detector.persistency.get_event_data(1)
+        assert event_data is not None
+        # Check the level values
+        assert "INFO" in event_data["level"].unique_set
+        assert "WARNING" in event_data["level"].unique_set
+        assert "ERROR" in event_data["level"].unique_set
+        # Check the variable at position 1 (named "test")
+        assert "assa" in event_data["test"].unique_set
+
+
+class TestBigramFrequencyDetectorDetection:
+    """Test BigramFrequencyDetector detection functionality."""
+
+    def test_detect_known_value_no_alert(self):
+        detector = BigramFrequencyDetector(config=config, name="MultipleDetector")
+
+        # Train with a value
+        train_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["adsasd", "asdasd"],
+            "logID": "1",
+            "parsedLogID": "1",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "INFO"}
+        })
+        detector.train(train_data)
+
+        # Detect with the same value
+        test_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 12,
+            "template": "test template",
+            "variables": ["adsasd"],
+            "logID": "2",
+            "parsedLogID": "2",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "CRITICAL"}
+        })
+        output = schemas.DetectorSchema()
+
+        result = detector.detect(test_data, output)
+
+        assert not result
+        assert output.score == 0.0
+
+    def test_detect_known_value_alert(self):
+        detector = BigramFrequencyDetector(config=config, name="MultipleDetector")
+
+        # Train with a value
+        train_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["adsasd", "asdasd"],
+            "logID": "1",
+            "parsedLogID": "1",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "INFO"}
+        })
+        detector.train(train_data)
+
+        # Detect with the same value
+        test_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["adsasd", "asdasd"],
+            "logID": "2",
+            "parsedLogID": "2",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "CRITICAL"}
+        })
+        output = schemas.DetectorSchema()
+
+        result = detector.detect(test_data, output)
+
+        assert result
+        assert output.score == 1.0
+
+
+_PARSER_CONFIG = {
+    "parsers": {
+        "MatcherParser": {
+            "method_type": "matcher_parser",
+            "auto_config": False,
+            "log_format": "type=<Type> msg=audit(<Time>): <Content>",
+            "time_format": None,
+            "params": {
+                "remove_spaces": True,
+                "remove_punctuation": True,
+                "lowercase": True,
+                "path_templates": "detectmatelibrary_tests/test_folder/audit_templates.txt",
+            },
+        }
+    }
+}
+
+
+class TestBigramFrequencyDetectorEndToEnd:
+    """Regression test: full configure/train/detect pipeline on audit.log."""
+
+    def test_audit_log_anomalies(self):
+        parser = MatcherParser(config=_PARSER_CONFIG)
+        detector = BigramFrequencyDetector()
+
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
+
+        for log in logs[:1800]:
+            detector.configure(log)
+        detector.set_configuration()
+
+        for log in logs[:1800]:
+            detector.train(log)
+
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            output = schemas.DetectorSchema()
+            if detector.detect(log, output_=output):
+                detected_ids.add(log["logID"])
+
+        assert detected_ids == {'1859', '1860', '1861', '1862', '1864', '1865', '1866', '1867'}
+
+
+class TestBigramFrequencyDetectorAutoConfig:
+    """Test that process() drives configure/set_configuration/train/detect
+    automatically."""
+
+    def test_audit_log_anomalies_via_process(self):
+        parser = MatcherParser(config=_PARSER_CONFIG)
+        detector = BigramFrequencyDetector()
+
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
+
+        # Phase 1: configure — keep configuring for logs[:1800]
+        detector.fitlogic.configure_state = ConfigState.KEEP_CONFIGURE
+        for log in logs[:1800]:
+            detector.process(log)
+
+        # Transition: stop configure so next process() call triggers set_configuration()
+        detector.fitlogic.configure_state = ConfigState.STOP_CONFIGURE
+
+        # Phase 2: train — keep training for logs[:1800]
+        detector.fitlogic.train_state = TrainState.KEEP_TRAINING
+        for log in logs[:1800]:
+            detector.process(log)
+
+        # Phase 3: detect — stop training so process() only calls detect()
+        detector.fitlogic.train_state = TrainState.STOP_TRAINING
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            if detector.process(log) is not None:
+                detected_ids.add(log["logID"])
+
+        assert detected_ids == {'1859', '1860', '1861', '1862', '1864', '1865', '1866', '1867'}
+
+
+class TestBigramFrequencyDetectorGlobalInstances:
+    """Tests event-ID-independent global instance detection."""
+
+    def test_global_instance_detects_new_type(self):
+        """Global instance monitoring Type detects CRED_REFR, USER_AUTH,
+        USER_CMD which only appear after the training window (line 1800+)."""
+        parser = MatcherParser(config=_PARSER_CONFIG)
+        config_dict = {
+            "detectors": {
+                "BigramFrequencyDetector": {
+                    "method_type": "bigram_frequency_detector",
+                    "prob_thresh": 0.2,
+                    "auto_config": False,
+                    "global": {
+                        "test": {
+                            "header_variables": [{"pos": "Type"}]
+                        }
+                    }
+                }
+            }
+        }
+        config = BigramFrequencyDetectorConfig.from_dict(config_dict, "BigramFrequencyDetector")
+        detector = BigramFrequencyDetector(config=config)
+
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
+
+        for log in logs[:1800]:
+            detector.train(log)
+
+        # Global tracker must be populated under the sentinel event ID
+        assert GLOBAL_EVENT_ID in detector.persistency.get_events_data()
+
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            output = schemas.DetectorSchema()
+            if detector.detect(log, output_=output):
+                assert all(key.startswith("Global -") for key in output["alertsObtain"])
+                detected_ids.add(log["logID"])
+
+        assert len(detected_ids) > 0
+
+
+class TestBigramFrequencyDetectorPersistencyRegistration:
+    def test_register_persistency_is_called(self):
+        """Persistency must be registered so `persist:` config takes effect."""
+        from unittest.mock import patch
+
+        with patch.object(
+            BigramFrequencyDetector,
+            "_register_persistency",
+            autospec=True,
+        ) as mock_reg:
+            detector = BigramFrequencyDetector()
+
+        mock_reg.assert_called_once()
+        _, called_persistency = mock_reg.call_args[0]  # (self, persistency)
+        assert called_persistency is detector.persistency
+
+
+class TestBigramFrequencyDetectorSetConfigurationPersist:
+    def test_set_configuration_preserves_persist(self):
+        """Auto-config must not silently drop the persist sub-config."""
+        from detectmatelibrary.common.detector import PersistConfig
+        detector = BigramFrequencyDetector()
+        sentinel_persist = PersistConfig(path="/tmp/sentinel")
+        detector.config.persist = sentinel_persist
+        detector.set_configuration()
+        assert detector.config.persist == sentinel_persist
+
+
+def _parser_data(event_id, level, var_value):
+    return schemas.ParserSchema({
+        "parserType": "test",
+        "EventID": event_id,
+        "template": "test template",
+        "variables": ["0", var_value],
+        "logID": "1",
+        "parsedLogID": "1",
+        "parserID": "test_parser",
+        "log": "test log message",
+        "logFormatVariables": {"level": level},
+    })
+
+
+class TestBigramFrequencyDetectorTrainBugFixes:
+    def test_first_occurrence_of_new_event_is_trained(self):
+        """Review #4: the very first training call for a new EventID must
+        update the per-variable freq table."""
+        detector = BigramFrequencyDetector(config=config, name="MultipleDetector")
+        detector.train(_parser_data(1, "INFO", "abc"))
+
+        event_data = detector.persistency.get_event_data(1)
+        # 'test' is the variable at pos 1, configured in `config` fixture
+        tracker = event_data["test"]
+        freq = tracker.extra_state.get("freq", {})
+        # "abc" produces bigrams: (-1,'a'), ('a','b'), ('b','c'), ('c',-1)
+        assert "a" in freq
+        assert "b" in freq["a"]
+        assert freq["a"]["b"] == 1
+
+    def test_skip_repetitions_does_not_skip_first_occurrence(self):
+        """skip_repetitions must train on the first occurrence of a value even
+        when the event was just registered."""
+        detector = BigramFrequencyDetector(config=_SKIP_REPETITIONS_CONFIG, name="MultipleDetector")
+        detector.train(_parser_data(1, "INFO", "abc"))
+
+        tracker = detector.persistency.get_event_data(1)["test"]
+        freq = tracker.extra_state.get("freq", {})
+        # First occurrence must still be trained: "abc" should produce the bigrams above
+        assert freq.get("a", {}).get("b") == 1
+
+    def test_skip_repetitions_skips_repeat_value(self):
+        """A repeated value with skip_repetitions=True must not double-count
+        bigrams."""
+        detector = BigramFrequencyDetector(config=_SKIP_REPETITIONS_CONFIG, name="MultipleDetector")
+        detector.train(_parser_data(1, "INFO", "abc"))
+        detector.train(_parser_data(1, "INFO", "abc"))  # same value
+
+        tracker = detector.persistency.get_event_data(1)["test"]
+        freq = tracker.extra_state.get("freq", {})
+        # Only one training pass should have happened: ('a','b') count is 1, not 2
+        assert freq.get("a", {}).get("b") == 1
+
+
+class TestBigramFrequencyDetectorDetectFixes:
+    def test_detect_helper_survives_missing_variable(self):
+        """Review #5: variables.get(var_name) returning None must not raise."""
+        detector = BigramFrequencyDetector(config=config, name="MultipleDetector")
+        # Train so the tracker for var 'test' exists
+        detector.train(_parser_data(1, "INFO", "abc"))
+
+        # Detect with a parser line that lacks the 'test' variable
+        test_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["0"],  # only pos 0 — no value at pos 1
+            "logID": "2",
+            "parsedLogID": "2",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "INFO"},
+        })
+        output = schemas.DetectorSchema()
+        # Must not raise TypeError
+        result = detector.detect(test_data, output)
+        assert isinstance(result, bool)
+
+    def test_default_freqs_false_does_not_consult_fallback(self):
+        """default_freqs=False (the default): no fallback consultation."""
+        detector = BigramFrequencyDetector(config=config, name="MultipleDetector")
+        assert detector.config.default_freqs is False
+        # Train a tracker on a value with no overlap to English text
+        detector.train(_parser_data(1, "INFO", "qqq"))
+
+        # Detect a typical English-looking value. Without fallback, sparse
+        # per-var table → low prob → alert expected.
+        test_data = _parser_data(1, "INFO", "the")
+        output = schemas.DetectorSchema()
+        result = detector.detect(test_data, output)
+        assert result is True
+
+    def test_default_freqs_true_consults_fallback(self):
+        """default_freqs=True: when the per-var table misses, fall back to the
+        English bigram table — common English bigrams should not alert."""
+        cfg = {
+            "detectors": {
+                "MultipleDetector": {
+                    "method_type": "bigram_frequency_detector",
+                    "auto_config": False,
+                    "params": {"default_freqs": True, "prob_thresh": 0.001},
+                    "events": {
+                        1: {
+                            "test": {
+                                "params": {},
+                                "variables": [{"pos": 1, "name": "test", "params": {}}],
+                                "header_variables": [{"pos": "level", "params": {}}],
+                            }
+                        }
+                    },
+                }
+            }
+        }
+        detector = BigramFrequencyDetector(config=cfg, name="MultipleDetector")
+        # Train so the tracker exists (with sparse data — fallback will dominate)
+        detector.train(_parser_data(1, "INFO", "x"))
+
+        # Detect a common English word — fallback should produce non-zero probs
+        test_data = _parser_data(1, "INFO", "the")
+        output = schemas.DetectorSchema()
+        result = detector.detect(test_data, output)
+        assert result is False
+
+
+class TestBigramFrequencyDetectorPersistenceRoundTrip:
+    def test_freq_table_survives_save_and_load(self):
+        """The learned bigram model must round-trip through
+        PersistencySaver."""
+        base_path = "memory://bigram_roundtrip/state"
+
+        cfg_dict = {
+            "detectors": {
+                "MultipleDetector": {
+                    "method_type": "bigram_frequency_detector",
+                    "auto_config": False,
+                    "persist": {"path": base_path},
+                    "params": {},
+                    "events": {
+                        1: {
+                            "test": {
+                                "params": {},
+                                "variables": [{"pos": 1, "name": "test", "params": {}}],
+                                "header_variables": [{"pos": "level", "params": {}}],
+                            }
+                        }
+                    },
+                }
+            }
+        }
+        det1 = BigramFrequencyDetector(config=cfg_dict, name="MultipleDetector")
+        det1.train(_parser_data(1, "INFO", "abc"))
+        det1.train(_parser_data(1, "INFO", "abd"))
+        assert det1.saver is not None
+        det1.saver.save()
+        det1.saver.stop()
+
+        cfg_dict_reload = {
+            "detectors": {
+                "MultipleDetector": {
+                    "method_type": "bigram_frequency_detector",
+                    "auto_config": False,
+                    "persist": {"path": base_path, "auto_load": True},
+                    "params": {},
+                    "events": {
+                        1: {
+                            "test": {
+                                "params": {},
+                                "variables": [{"pos": 1, "name": "test", "params": {}}],
+                                "header_variables": [{"pos": "level", "params": {}}],
+                            }
+                        }
+                    },
+                }
+            }
+        }
+        det2 = BigramFrequencyDetector(config=cfg_dict_reload, name="MultipleDetector")
+
+        a_tracker = det1.persistency.get_event_data(1)["test"]
+        b_tracker = det2.persistency.get_event_data(1)["test"]
+        assert b_tracker.extra_state.get("freq") == a_tracker.extra_state.get("freq")
+        assert b_tracker.extra_state.get("total_freq") == a_tracker.extra_state.get("total_freq")
+        det2.saver.stop()
+
+
+class TestBigramFrequencyDetectorPerVarIsolation:
+    def test_two_variables_have_independent_freq_tables(self):
+        """Training on one variable must not affect another variable's
+        table."""
+        cfg = {
+            "detectors": {
+                "TwoVarDetector": {
+                    "method_type": "bigram_frequency_detector",
+                    "auto_config": False,
+                    "params": {},
+                    "events": {
+                        1: {
+                            "test": {
+                                "params": {},
+                                "variables": [
+                                    {"pos": 0, "name": "a", "params": {}},
+                                    {"pos": 1, "name": "b", "params": {}},
+                                ],
+                            }
+                        }
+                    },
+                }
+            }
+        }
+        detector = BigramFrequencyDetector(config=cfg, name="TwoVarDetector")
+        parser_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["abc", "xyz"],
+            "logID": "1",
+            "parsedLogID": "1",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {},
+        })
+        detector.train(parser_data)
+
+        a_tracker = detector.persistency.get_event_data(1)["a"]
+        b_tracker = detector.persistency.get_event_data(1)["b"]
+        a_freq = a_tracker.extra_state["freq"]
+        b_freq = b_tracker.extra_state["freq"]
+
+        # 'a' learned bigrams from "abc": (a,b), (b,c), plus boundaries
+        assert "a" in a_freq and "b" in a_freq["a"]
+        # 'b' should NOT have learned anything from "abc"
+        assert "a" not in b_freq
+        # 'b' DID learn from "xyz"
+        assert "x" in b_freq and "y" in b_freq["x"]
diff --git a/detectmatelibrary_tests/test_detectors/test_charset_detector.py b/detectmatelibrary_tests/test_detectors/test_charset_detector.py
new file mode 100644
index 00000000..d88fdfdd
--- /dev/null
+++ b/detectmatelibrary_tests/test_detectors/test_charset_detector.py
@@ -0,0 +1,422 @@
+"""Tests for CharsetDetector class.
+
+This module tests the CharsetDetector implementation including:
+- Initialization and configuration
+- Training functionality to learn known characters
+- Detection logic for new/unknown characters
+- Event-specific configuration handling
+- Input/output schema validation
+"""
+
+from detectmatelibrary.common._core_op._fit_logic import TrainState
+from detectmatelibrary.detectors.charset_detector import CharsetDetector, CharsetDetectorConfig, BufferMode
+from detectmatelibrary.common._core_op._fit_logic import ConfigState
+from detectmatelibrary.constants import GLOBAL_EVENT_ID
+from detectmatelibrary.parsers.template_matcher import MatcherParser
+from detectmatelibrary.helper.from_to import From
+import detectmatelibrary.schemas as schemas
+from detectmatelibrary.utils.aux import time_test_mode
+from detectmatelibrary_tests.test_pipelines.test_configuration_engine import AUDIT_LOG
+
+# Set time test mode for consistent timestamps
+time_test_mode()
+
+
+config = {
+    "detectors": {
+        "CustomInit": {
+            "method_type": "charset_detector",
+            "auto_config": False,
+            "params": {},
+            "events": {
+                1: {
+                    "instance1": {
+                        "params": {},
+                        "variables": [{
+                            "pos": 0, "name": "sad", "params": {}
+                        }]
+                    }
+                }
+            }
+        },
+        "MultipleDetector": {
+            "method_type": "charset_detector",
+            "auto_config": False,
+            "params": {},
+            "events": {
+                1: {
+                    "test": {
+                        "params": {},
+                        "variables": [{
+                            "pos": 1, "name": "test", "params": {}
+                        }],
+                        "header_variables": [{
+                            "pos": "level", "params": {}
+                        }]
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+class TestCharsetDetectorInitialization:
+    """Test CharsetDetector initialization and configuration."""
+
+    def test_default_initialization(self):
+        """Test detector initialization with default parameters."""
+        detector = CharsetDetector()
+
+        assert detector.name == "CharsetDetector"
+        assert hasattr(detector, 'config')
+        assert detector.data_buffer.mode == BufferMode.NO_BUF
+        assert detector.input_schema == schemas.ParserSchema
+        assert detector.output_schema == schemas.DetectorSchema
+        assert hasattr(detector, 'persistency')
+
+    def test_custom_config_initialization(self):
+        """Test detector initialization with custom configuration."""
+        detector = CharsetDetector(name="CustomInit", config=config)
+
+        assert detector.name == "CustomInit"
+        assert hasattr(detector, 'persistency')
+        assert isinstance(detector.persistency.events_data, dict)
+
+    def test_persistency_uses_expand_value(self):
+        """Main persistency must accumulate characters; auto_conf must not."""
+        detector = CharsetDetector()
+        # Ingest a sample so a SingleStabilityTracker is materialized
+        detector.persistency.ingest_event(
+            event_id=1,
+            event_template="t",
+            named_variables={"v": "hello"},
+        )
+        single = detector.persistency.get_event_data(1)["v"]
+        assert single.expand_value is True
+        assert single.unique_set == {"h", "e", "l", "o"}
+
+    def test_auto_conf_persistency_does_not_expand(self):
+        detector = CharsetDetector()
+        detector.auto_conf_persistency.ingest_event(
+            event_id=1,
+            event_template="t",
+            named_variables={"v": "hello"},
+        )
+        single = detector.auto_conf_persistency.get_event_data(1)["v"]
+        assert single.expand_value is False
+        assert single.unique_set == {"hello"}
+
+    def test_register_persistency_was_called(self):
+        """Main persistency should be registered so persist/load round-trips
+        work."""
+        from detectmatelibrary.common.detector import PersistConfig
+        cfg = CharsetDetectorConfig(
+            persist=PersistConfig(path="memory://charset_regpersist/state")
+        )
+        detector = CharsetDetector(config=cfg)
+        # _register_persistency builds a PersistencySaver bound to detector.persistency
+        assert detector.saver is not None
+        assert detector.saver._persistency is detector.persistency
+        detector.saver.stop()
+
+
+class TestCharsetDetectorTraining:
+    """Test CharsetDetector training functionality."""
+
+    def test_train_multiple_values(self):
+        """Test training with multiple different values."""
+        detector = CharsetDetector(config=config, name="MultipleDetector")
+        # Train with multiple values (only event 1 should be tracked per config)
+        for event in range(3):
+            for level in ["INFO", "WARNING", "ERROR"]:
+                parser_data = schemas.ParserSchema({
+                    "parserType": "test",
+                    "EventID": event,
+                    "template": "test template",
+                    "variables": ["0", "assa"],
+                    "logID": "1",
+                    "parsedLogID": "1",
+                    "parserID": "test_parser",
+                    "log": "test log message",
+                    "logFormatVariables": {"level": level}
+                })
+                detector.train(parser_data)
+
+        # Only event 1 should be tracked (based on events config)
+        assert len(detector.persistency.events_data) == 1
+        event_data = detector.persistency.get_event_data(1)
+        assert event_data is not None
+        # With expand_value=True, unique_set contains individual characters
+        assert set("INFO") <= event_data["level"].unique_set
+        assert set("WARNING") <= event_data["level"].unique_set
+        assert set("ERROR") <= event_data["level"].unique_set
+        assert set("assa") <= event_data["test"].unique_set
+
+
+class TestCharsetDetectorDetection:
+    """Test CharsetDetector detection functionality."""
+
+    def test_detect_known_value_no_alert(self):
+        detector = CharsetDetector(config=config, name="MultipleDetector")
+
+        # Train with a value
+        train_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["adsasd", "asdasd"],
+            "logID": "1",
+            "parsedLogID": "1",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "INFO"}
+        })
+        detector.train(train_data)
+
+        # Detect with the same value
+        test_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 12,
+            "template": "test template",
+            "variables": ["adsasddddddaaa"],
+            "logID": "2",
+            "parsedLogID": "2",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "CRITICAL"}
+        })
+        output = schemas.DetectorSchema()
+
+        result = detector.detect(test_data, output)
+
+        assert not result
+        assert output.score == 0.0
+
+    def test_detect_known_value_alert(self):
+        detector = CharsetDetector(config=config, name="MultipleDetector")
+
+        # Train with a value
+        train_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["adsasd", "asdasd"],
+            "logID": "1",
+            "parsedLogID": "1",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "INFO"}
+        })
+        detector.train(train_data)
+
+        # Detect with the same value
+        test_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["asas", "adsd"],
+            "logID": "2",
+            "parsedLogID": "2",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "CRITICAL"}
+        })
+        output = schemas.DetectorSchema()
+
+        result = detector.detect(test_data, output)
+
+        assert result
+        assert output.score == 1.0
+
+    def test_detect_unknown_chars_reported_per_variable(self):
+        """Train on a known alphabet; detect a value with unknown chars and
+        confirm the alert string lists the unknown chars sorted."""
+        cfg = {
+            "detectors": {
+                "Single": {
+                    "method_type": "charset_detector",
+                    "auto_config": False,
+                    "params": {},
+                    "events": {
+                        1: {
+                            "test": {
+                                "params": {},
+                                "variables": [{"pos": 0, "name": "v", "params": {}}],
+                            }
+                        }
+                    },
+                }
+            }
+        }
+        detector = CharsetDetector(config=cfg, name="Single")
+
+        train = schemas.ParserSchema({
+            "parserType": "test", "EventID": 1, "template": "t",
+            "variables": ["abc"], "logID": "1", "parsedLogID": "1",
+            "parserID": "p", "log": "l", "logFormatVariables": {},
+        })
+        detector.train(train)
+
+        # All known chars
+        ok = schemas.ParserSchema({
+            "parserType": "test", "EventID": 1, "template": "t",
+            "variables": ["cba"], "logID": "2", "parsedLogID": "2",
+            "parserID": "p", "log": "l", "logFormatVariables": {},
+        })
+        out = schemas.DetectorSchema()
+        assert not detector.detect(ok, out)
+        assert out.score == 0.0
+
+        # Unknown chars 'x' and 'y'
+        bad = schemas.ParserSchema({
+            "parserType": "test", "EventID": 1, "template": "t",
+            "variables": ["axy"], "logID": "3", "parsedLogID": "3",
+            "parserID": "p", "log": "l", "logFormatVariables": {},
+        })
+        out = schemas.DetectorSchema()
+        assert detector.detect(bad, out)
+        assert out.score == 1.0
+        assert any("'x'" in msg and "'y'" in msg for msg in out["alertsObtain"].values())
+
+
+_PARSER_CONFIG = {
+    "parsers": {
+        "MatcherParser": {
+            "method_type": "matcher_parser",
+            "auto_config": False,
+            "log_format": "type=<Type> msg=audit(<Time>): <Content>",
+            "time_format": None,
+            "params": {
+                "remove_spaces": True,
+                "remove_punctuation": True,
+                "lowercase": True,
+                "path_templates": "detectmatelibrary_tests/test_folder/audit_templates.txt",
+            },
+        }
+    }
+}
+
+
+class TestCharsetDetectorEndToEnd:
+    """Regression test: full configure/train/detect pipeline on audit.log."""
+
+    def test_audit_log_anomalies(self):
+        parser = MatcherParser(config=_PARSER_CONFIG)
+        detector = CharsetDetector()
+
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
+
+        for log in logs[:1800]:
+            detector.configure(log)
+        detector.set_configuration()
+
+        for log in logs[:1800]:
+            detector.train(log)
+
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            output = schemas.DetectorSchema()
+            if detector.detect(log, output_=output):
+                detected_ids.add(log["logID"])
+
+        assert detected_ids == {'1859', '1860', '1861', '1862', '1864', '1865', '1866', '1867'}
+
+
+class TestCharsetDetectorAutoConfig:
+    """Test that process() drives configure/set_configuration/train/detect
+    automatically."""
+
+    def test_audit_log_anomalies_via_process(self):
+        parser = MatcherParser(config=_PARSER_CONFIG)
+        detector = CharsetDetector()
+
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
+
+        # Phase 1: configure — keep configuring for logs[:1800]
+        detector.fitlogic.configure_state = ConfigState.KEEP_CONFIGURE
+        for log in logs[:1800]:
+            detector.process(log)
+
+        # Transition: stop configure so next process() call triggers set_configuration()
+        detector.fitlogic.configure_state = ConfigState.STOP_CONFIGURE
+
+        # Phase 2: train — keep training for logs[:1800]
+        detector.fitlogic.train_state = TrainState.KEEP_TRAINING
+        for log in logs[:1800]:
+            detector.process(log)
+
+        # Phase 3: detect — stop training so process() only calls detect()
+        detector.fitlogic.train_state = TrainState.STOP_TRAINING
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            if detector.process(log) is not None:
+                detected_ids.add(log["logID"])
+
+        assert detected_ids == {'1859', '1860', '1861', '1862', '1864', '1865', '1866', '1867'}
+
+
+class TestCharsetDetectorGlobalInstances:
+    """Tests event-ID-independent global instance detection."""
+
+    def test_global_instance_detects_new_type(self):
+        """Global instance monitoring Type detects CRED_REFR, USER_AUTH,
+        USER_CMD which only appear after the training window (line 1800+)."""
+        parser = MatcherParser(config=_PARSER_CONFIG)
+        config_dict = {
+            "detectors": {
+                "CharsetDetector": {
+                    "method_type": "charset_detector",
+                    "auto_config": False,
+                    "params": {},
+                    "global": {
+                        "test": {
+                            "header_variables": [{"pos": "Type"}]
+                        }
+                    }
+                }
+            }
+        }
+        config = CharsetDetectorConfig.from_dict(config_dict, "CharsetDetector")
+        detector = CharsetDetector(config=config)
+
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
+
+        for log in logs[:1800]:
+            detector.train(log)
+
+        # Global tracker must be populated under the sentinel event ID
+        assert GLOBAL_EVENT_ID in detector.persistency.get_events_data()
+
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            output = schemas.DetectorSchema()
+            if detector.detect(log, output_=output):
+                assert all(key.startswith("Global -") for key in output["alertsObtain"])
+                detected_ids.add(log["logID"])
+
+        assert len(detected_ids) > 0
+
+
+class TestCharsetDetectorSetConfigurationPreservesPersist:
+    def test_persist_flag_survives_set_configuration(self):
+        from detectmatelibrary.common.detector import PersistConfig
+
+        detector = CharsetDetector()
+        # Simulate persist being enabled by an earlier config load
+        detector.config.persist = PersistConfig(path="./state")
+
+        # Feed configure() with a couple of stable-variable samples
+        for _ in range(5):
+            sample = schemas.ParserSchema({
+                "parserType": "test", "EventID": 1, "template": "t",
+                "variables": ["abc"], "logID": "x", "parsedLogID": "x",
+                "parserID": "p", "log": "l",
+                "logFormatVariables": {"level": "INFO"},
+            })
+            detector.configure(sample)
+
+        detector.set_configuration()
+
+        assert detector.config.persist is not None
+        assert detector.config.persist.path == "./state"
diff --git a/detectmatelibrary_tests/test_detectors/test_mismatch_warnings.py b/detectmatelibrary_tests/test_detectors/test_mismatch_warnings.py
new file mode 100644
index 00000000..40242b0b
--- /dev/null
+++ b/detectmatelibrary_tests/test_detectors/test_mismatch_warnings.py
@@ -0,0 +1,218 @@
+"""Tests for config-data mismatch warnings in detectors.
+
+Covers two warning levels:
+1. Configured EventID never seen in training data.
+2. EventID seen in training data but configured variables not extracted.
+
+Also covers the auto_config=True empty-config warning.
+"""
+
+import logging
+import pytest
+import detectmatelibrary.schemas as schemas
+from detectmatelibrary.detectors.new_value_detector import NewValueDetector
+from detectmatelibrary.detectors.new_value_combo_detector import NewValueComboDetector
+
+
+def _make_parser_schema(
+    event_id: int,
+    variables: list,
+    log_format_variables: dict,
+) -> schemas.ParserSchema:
+    return schemas.ParserSchema({
+        "parserType": "test",
+        "EventID": event_id,
+        "template": "test template",
+        "variables": variables,
+        "logID": "1",
+        "parsedLogID": "1",
+        "parserID": "test_parser",
+        "log": "test log message",
+        "logFormatVariables": log_format_variables,
+    })
+
+
+# ---- Config fixtures --------------------------------------------------------
+
+def _nvd_config(event_id: int, pos: int = 0, header: str | None = None) -> dict:
+    """Build a minimal NewValueDetector config targeting one variable."""
+    instance: dict = {"params": {}}
+    if header is not None:
+        instance["header_variables"] = [{"pos": header, "params": {}}]
+    else:
+        instance["variables"] = [{"pos": pos, "name": f"var_{pos}", "params": {}}]
+    return {
+        "detectors": {
+            "TestDetector": {
+                "method_type": "new_value_detector",
+                "auto_config": False,
+                "params": {},
+                "events": {event_id: {"inst": instance}},
+            }
+        }
+    }
+
+
+# ---- NewValueDetector warning tests -----------------------------------------
+
+class TestNewValueDetectorMismatchWarnings:
+
+    def test_warn_event_id_never_seen(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Warn when configured EventID is not present in training data at
+        all."""
+        detector = NewValueDetector(name="TestDetector", config=_nvd_config(event_id=99))
+        # Train on EventID=1 only — EventID=99 is never seen
+        for _ in range(3):
+            detector.train(_make_parser_schema(1, ["val"], {"status": "ok"}))
+
+        with caplog.at_level(logging.WARNING):
+            detector.post_train()
+
+        assert any("99" in r.message and "never observed" in r.message for r in caplog.records)
+
+    def test_warn_event_id_seen_but_no_variables_extracted(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Warn when EventID is seen but configured positional variable is out
+        of bounds."""
+        # Config expects var at position 0, but data has empty variables list
+        detector = NewValueDetector(name="TestDetector", config=_nvd_config(event_id=1, pos=0))
+        for _ in range(3):
+            # EventID=1 IS seen, but variables=[] so get_configured_variables returns {}
+            detector.train(_make_parser_schema(1, [], {"status": "ok"}))
+
+        with caplog.at_level(logging.WARNING):
+            detector.post_train()
+
+        assert any(
+            "1" in r.message and "no configured variables were extracted" in r.message
+            for r in caplog.records
+        )
+
+    def test_warn_header_variable_not_in_log_format(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Warn when EventID is seen but configured header_variable key is
+        absent."""
+        # Config expects header 'Time', but data has only 'status'
+        detector = NewValueDetector(
+            name="TestDetector", config=_nvd_config(event_id=1, header="Time")
+        )
+        for _ in range(3):
+            detector.train(_make_parser_schema(1, [], {"status": "ok"}))
+
+        with caplog.at_level(logging.WARNING):
+            detector.post_train()
+
+        assert any("no configured variables were extracted" in r.message for r in caplog.records)
+
+    def test_no_warning_when_config_matches_data(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """No warning when configured variables are correctly extracted during
+        training."""
+        detector = NewValueDetector(
+            name="TestDetector", config=_nvd_config(event_id=1, header="status")
+        )
+        for _ in range(3):
+            detector.train(_make_parser_schema(1, [], {"status": "ok"}))
+
+        with caplog.at_level(logging.WARNING):
+            detector.post_train()
+
+        assert not any(r.levelno == logging.WARNING for r in caplog.records)
+
+    def test_auto_config_skips_mismatch_check(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """post_train() does not run coverage check for auto_config=True
+        detectors."""
+        detector = NewValueDetector()  # auto_config=True by default
+        # Train on some data — no mismatch check should fire because auto_config=True
+        for _ in range(3):
+            detector.train(_make_parser_schema(1, ["x"], {"status": "ok"}))
+
+        with caplog.at_level(logging.WARNING):
+            detector.post_train()
+
+        mismatch_warnings = [
+            r for r in caplog.records
+            if "never observed" in r.message or "no configured variables" in r.message
+        ]
+        assert not mismatch_warnings
+
+    def test_auto_config_empty_config_warning(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Warn in set_configuration() when auto_config produces an empty
+        events config."""
+        detector = NewValueDetector()
+        # configure() with no data → auto_conf_persistency is empty → empty config
+        with caplog.at_level(logging.WARNING):
+            detector.set_configuration()
+
+        assert any("empty configuration" in r.message for r in caplog.records)
+
+
+# ---- NewValueComboDetector warning tests ------------------------------------
+
+class TestNewValueComboDetectorMismatchWarnings:
+
+    def test_warn_event_id_never_seen(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Warn when configured EventID is not present in combo detector
+        training data."""
+        config = {
+            "detectors": {
+                "ComboDetector": {
+                    "method_type": "new_value_combo_detector",
+                    "auto_config": False,
+                    "params": {},
+                    "events": {
+                        99: {
+                            "inst": {
+                                "params": {},
+                                "header_variables": [{"pos": "status", "params": {}}],
+                            }
+                        }
+                    },
+                }
+            }
+        }
+        detector = NewValueComboDetector(name="ComboDetector", config=config)
+        for _ in range(3):
+            detector.train(_make_parser_schema(1, ["val"], {"status": "ok"}))
+
+        with caplog.at_level(logging.WARNING):
+            detector.post_train()
+
+        assert any("99" in r.message and "never observed" in r.message for r in caplog.records)
+
+    def test_no_warning_when_config_matches(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """No warning when combo detector config matches training data."""
+        config = {
+            "detectors": {
+                "ComboDetector": {
+                    "method_type": "new_value_combo_detector",
+                    "auto_config": False,
+                    "params": {},
+                    "events": {
+                        1: {
+                            "inst": {
+                                "params": {},
+                                "header_variables": [{"pos": "status", "params": {}}],
+                            }
+                        }
+                    },
+                }
+            }
+        }
+        detector = NewValueComboDetector(name="ComboDetector", config=config)
+        for _ in range(3):
+            detector.train(_make_parser_schema(1, [], {"status": "ok"}))
+
+        with caplog.at_level(logging.WARNING):
+            detector.post_train()
+
+        assert not any(r.levelno == logging.WARNING for r in caplog.records)
diff --git a/detectmatelibrary_tests/test_detectors/test_new_event_detector.py b/detectmatelibrary_tests/test_detectors/test_new_event_detector.py
new file mode 100644
index 00000000..1ca4065b
--- /dev/null
+++ b/detectmatelibrary_tests/test_detectors/test_new_event_detector.py
@@ -0,0 +1,250 @@
+"""Tests for NewEventDetector class.
+
+This module tests the NewEventDetector implementation including:
+- Initialization and configuration
+- Training functionality to learn known values
+- Detection logic for new/unknown values
+- Event-specific configuration handling
+- Input/output schema validation
+"""
+
+from detectmatelibrary.detectors.new_event_detector import NewEventDetector, NewEventDetectorConfig, \
+    BufferMode
+from detectmatelibrary.parsers.template_matcher import MatcherParser
+from detectmatelibrary.helper.from_to import From
+import detectmatelibrary.schemas as schemas
+from detectmatelibrary.utils.aux import time_test_mode
+from detectmatelibrary.common._core_op._fit_logic import ConfigState, TrainState
+from detectmatelibrary.constants import GLOBAL_EVENT_ID
+from detectmatelibrary_tests.test_pipelines.test_configuration_engine import AUDIT_LOG
+
+
+# Set time test mode for consistent timestamps
+time_test_mode()
+
+
+config = {
+    "detectors": {
+        "CustomInit": {
+            "method_type": "new_event_detector",
+            "auto_config": False,
+            "params": {}
+        },
+        "MultipleDetector": {
+            "method_type": "new_event_detector",
+            "auto_config": False,
+            "params": {}
+        },
+        "NewEventDetector": {
+            "method_type": "new_event_detector",
+            "auto_config": False,
+            "params": {}
+        }
+    }
+}
+
+
+class TestNewEventDetectorInitialization:
+    """Test NewEventDetector initialization and configuration."""
+
+    def test_default_initialization(self):
+        """Test detector initialization with default parameters."""
+        detector = NewEventDetector()
+
+        assert detector.name == "NewEventDetector"
+        assert hasattr(detector, 'config')
+        assert detector.data_buffer.mode == BufferMode.NO_BUF
+        assert detector.input_schema == schemas.ParserSchema
+        assert detector.output_schema == schemas.DetectorSchema
+        assert hasattr(detector, 'persistency')
+
+    def test_custom_config_initialization(self):
+        """Test detector initialization with custom configuration."""
+        detector = NewEventDetector(name="CustomInit", config=config)
+
+        assert detector.name == "CustomInit"
+        assert hasattr(detector, 'persistency')
+        assert isinstance(detector.persistency.events_data, dict)
+
+
+class TestNewEventDetectorTraining:
+    """Test NewEventDetector training functionality."""
+
+    def test_train_multiple_event_ids(self):
+        """Test training with multiple different event ids."""
+        detector = NewEventDetector(config=config, name="MultipleDetector")
+        event_ids = {0, 3, 8, 9}
+        for event in event_ids:
+            parser_data = schemas.ParserSchema({
+                "parserType": "test",
+                "EventID": event,
+                "template": "test template",
+                "variables": ["0", "assa"],
+                "logID": "1",
+                "parsedLogID": "1",
+                "parserID": "test_parser",
+                "log": "test log message",
+                "logFormatVariables": {"level": "INFO"}
+            })
+            detector.train(parser_data)
+
+        assert len(detector.persistency.events_seen) == len(event_ids)
+        event_seen = detector.persistency.get_events_seen()
+        assert event_seen == event_ids
+
+
+class TestNewEventDetectorDetection:
+    """Test NewEventDetector detection functionality."""
+
+    def test_detect_known_event_id_no_alert(self):
+        detector = NewEventDetector(config=config, name="MultipleDetector")
+
+        # Train with an event_id
+        train_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["adsasd", "asdasd"],
+            "logID": "1",
+            "parsedLogID": "1",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "INFO"}
+        })
+        detector.train(train_data)
+
+        # Detect with the same event_id
+        test_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["adsasd"],
+            "logID": "2",
+            "parsedLogID": "2",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "CRITICAL"}
+        })
+        output = schemas.DetectorSchema()
+
+        result = detector.detect(test_data, output)
+
+        assert not result
+        assert output.score == 0.0
+
+
+_PARSER_CONFIG = {
+    "parsers": {
+        "MatcherParser": {
+            "method_type": "matcher_parser",
+            "auto_config": False,
+            "log_format": "type=<Type> msg=audit(<Time>:*): <Content>",
+            "time_format": None,
+            "params": {
+                "remove_spaces": True,
+                "remove_punctuation": True,
+                "lowercase": True,
+                "path_templates": "detectmatelibrary_tests/test_folder/audit_templates.txt",
+            },
+        }
+    }
+}
+
+
+class TestNewEventDetectorEndToEnd:
+    """Regression test: full configure/train/detect pipeline on audit.log."""
+
+    def test_audit_log_anomalies(self):
+        pars = MatcherParser(config=_PARSER_CONFIG)
+        detector = NewEventDetector(config=config, name="NewEventDetector")
+
+        logs = list(From.log(pars, in_path=AUDIT_LOG, do_process=True))
+
+        for log in logs[:1800]:
+            detector.configure(log)
+        detector.set_configuration()
+
+        for log in logs[:1800]:
+            detector.train(log)
+
+        detected_ids: set[str] = set()
+        for i, log in enumerate(logs[1800:]):
+            output = schemas.DetectorSchema()
+            if detector.detect(log, output_=output):
+                detected_ids.add(log["logID"])
+
+        assert detected_ids == {"1863"}
+
+
+class TestNewEventDetectorAutoConfig:
+    """Test that process() drives configure/set_configuration/train/detect
+    automatically."""
+
+    def test_audit_log_anomalies_via_process(self):
+        pars = MatcherParser(config=_PARSER_CONFIG)
+        detector = NewEventDetector()
+
+        logs = list(From.log(pars, in_path=AUDIT_LOG, do_process=True))
+
+        # Phase 1: configure — keep configuring for logs[:1800]
+        detector.fitlogic.configure_state = ConfigState.KEEP_CONFIGURE
+        for log in logs[:1800]:
+            detector.process(log)
+
+        # Transition: stop configure so next process() call triggers set_configuration()
+        detector.fitlogic.configure_state = ConfigState.STOP_CONFIGURE
+
+        # Phase 2: train — keep training for logs[:1800]
+        detector.fitlogic.train_state = TrainState.KEEP_TRAINING
+        for log in logs[:1800]:
+            detector.process(log)
+
+        # Phase 3: detect — stop training so process() only calls detect()
+        detector.fitlogic.train_state = TrainState.STOP_TRAINING
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            if detector.process(log) is not None:
+                detected_ids.add(log["logID"])
+
+        assert detected_ids == {"1863"}
+
+
+class TestNewEventDetectorGlobalInstances:
+    """Tests event-ID-independent global instance detection."""
+
+    def test_global_instance_detects_new_type(self):
+        """Global instance monitoring Type detects CRED_REFR, USER_AUTH,
+        USER_CMD which only appear after the training window (line 1800+)."""
+        pars = MatcherParser(config=_PARSER_CONFIG)
+        config_dict = {
+            "detectors": {
+                "NewEventDetector": {
+                    "method_type": "new_event_detector",
+                    "auto_config": False,
+                    "global": {
+                        "test": {
+                            "header_variables": [{"pos": "Type"}]
+                        }
+                    }
+                }
+            }
+        }
+        config = NewEventDetectorConfig.from_dict(config_dict, "NewEventDetector")
+        detector = NewEventDetector(config=config)
+
+        logs = list(From.log(pars, in_path=AUDIT_LOG, do_process=True))
+
+        for log in logs[:1800]:
+            detector.train(log)
+
+        # Global tracker must be populated under the sentinel event ID
+        assert GLOBAL_EVENT_ID in detector.persistency.get_events_seen()
+
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            output = schemas.DetectorSchema()
+            if detector.detect(log, output_=output):
+                assert all(key.startswith("Global -") for key in output["alertsObtain"])
+                detected_ids.add(log["logID"])
+
+        assert len(detected_ids) > 0
diff --git a/tests/test_detectors/test_new_value_combo_detector.py b/detectmatelibrary_tests/test_detectors/test_new_value_combo_detector.py
similarity index 95%
rename from tests/test_detectors/test_new_value_combo_detector.py
rename to detectmatelibrary_tests/test_detectors/test_new_value_combo_detector.py
index af45bd79..a6b93811 100644
--- a/tests/test_detectors/test_new_value_combo_detector.py
+++ b/detectmatelibrary_tests/test_detectors/test_new_value_combo_detector.py
@@ -1,15 +1,11 @@
 
-from detectmatelibrary.detectors.new_value_combo_detector import (
-    NewValueComboDetector, BufferMode
-)
+from detectmatelibrary.detectors.new_value_combo_detector import NewValueComboDetector, BufferMode
 from detectmatelibrary.common._config import generate_detector_config
 from detectmatelibrary.parsers.template_matcher import MatcherParser
 from detectmatelibrary.helper.from_to import From
 import detectmatelibrary.schemas as schemas
-
 from detectmatelibrary.utils.aux import time_test_mode
-
-import pytest
+from detectmatelibrary_tests.test_pipelines.test_configuration_engine import AUDIT_LOG
 
 # Set time test mode for consistent timestamps
 time_test_mode()
@@ -21,7 +17,7 @@
             "method_type": "new_value_combo_detector",
             "auto_config": False,
             "params": {
-                "comb_size": 4
+                "max_combo_size": 4
             },
             "events": {
                 1: {
@@ -38,7 +34,7 @@
             "method_type": "new_value_combo_detector",
             "auto_config": False,
             "params": {
-                "comb_size": 2
+                "max_combo_size": 2
             },
             "events": {
                 1: {
@@ -72,7 +68,7 @@ def test_custom_config_initialization(self):
         detector = NewValueComboDetector(name="CustomInit", config=config)
 
         assert detector.name == "CustomInit"
-        assert detector.config.comb_size == 4
+        assert detector.config.max_combo_size == 4
 
 
 class TestNewValueComboDetectorTraining:
@@ -215,14 +211,14 @@ def test_generate_detector_config_basic(self):
             variable_selection=variable_selection,
             detector_name="TestDetector",
             method_type="new_value_combo_detector",
-            comb_size=2
+            max_combo_size=2
         )
 
         assert "detectors" in config_dict
         assert "TestDetector" in config_dict["detectors"]
         detector_config = config_dict["detectors"]["TestDetector"]
         assert detector_config["method_type"] == "new_value_combo_detector"
-        assert detector_config["params"]["comb_size"] == 2
+        assert detector_config["params"]["max_combo_size"] == 2
         assert len(detector_config["events"]) == 1
 
     def test_generate_detector_config_multiple_events(self):
@@ -291,7 +287,7 @@ def test_set_configuration_updates_config(self):
 
         # Verify config was updated
         assert detector.config.events is not None
-        assert detector.config.comb_size == 2
+        assert detector.config.max_combo_size == 2
 
     def test_configuration_workflow(self):
         """Test complete configuration workflow like in notebook."""
@@ -362,8 +358,8 @@ def test_set_configuration_with_combo_size(self):
         # Set configuration with specific combo size
         detector.set_configuration(max_combo_size=4)
 
-        # Verify comb_size was updated
-        assert detector.config.comb_size == 4
+        # Verify max_combo_size was updated
+        assert detector.config.max_combo_size == 4
 
     def test_configuration_with_no_stable_variables(self):
         """Test configuration when no stable variables are found."""
@@ -551,14 +547,8 @@ def test_configure_only_selects_stable_event_types(self):
         "MatcherParser": {
             "method_type": "matcher_parser",
             "auto_config": False,
-            "log_format": "type=<Type> msg=audit\\(<Time>\\): <Content>",
-            "time_format": None,
-            "params": {
-                "remove_spaces": True,
-                "remove_punctuation": True,
-                "lowercase": True,
-                "path_templates": "tests/test_folder/audit_templates.txt",
-            },
+            "log_format": "type=<Type> msg=audit(<Time>): <Content>",
+            "params": {"path_templates": "detectmatelibrary_tests/test_folder/audit_templates.txt"},
         }
     }
 }
@@ -566,12 +556,11 @@ def test_configure_only_selects_stable_event_types(self):
 
 class TestNewValueComboDetectorEndToEndWithRealData:
     """Regression test: full configure/train/detect pipeline on audit.log."""
-    @pytest.mark.skip(reason="no way of currently testing this")
     def test_audit_log_anomalies(self):
-        parser = MatcherParser(config=_PARSER_CONFIG)
+        pars = MatcherParser(config=_PARSER_CONFIG)
         detector = NewValueComboDetector()
 
-        logs = list(From.log(parser, in_path="tests/test_folder/audit.log", do_process=True))
+        logs = list(From.log(pars, in_path=AUDIT_LOG, do_process=True))
 
         for log in logs[:1800]:
             detector.configure(log)
@@ -586,4 +575,4 @@ def test_audit_log_anomalies(self):
             if detector.detect(log, output_=output):
                 detected_ids.add(log["logID"])
 
-        print(detected_ids)
+        assert detected_ids == {"1859", "1862", "1865", "1866"}
diff --git a/tests/test_detectors/test_new_value_detector.py b/detectmatelibrary_tests/test_detectors/test_new_value_detector.py
similarity index 94%
rename from tests/test_detectors/test_new_value_detector.py
rename to detectmatelibrary_tests/test_detectors/test_new_value_detector.py
index 99dcc955..08ea56cc 100644
--- a/tests/test_detectors/test_new_value_detector.py
+++ b/detectmatelibrary_tests/test_detectors/test_new_value_detector.py
@@ -9,18 +9,15 @@
 """
 
 from detectmatelibrary.common._core_op._fit_logic import TrainState
-from detectmatelibrary.detectors.new_value_detector import (
-    NewValueDetector, NewValueDetectorConfig, BufferMode
-)
+from detectmatelibrary.detectors.new_value_detector import NewValueDetector, NewValueDetectorConfig, \
+    BufferMode
 from detectmatelibrary.common._core_op._fit_logic import ConfigState
 from detectmatelibrary.constants import GLOBAL_EVENT_ID
 from detectmatelibrary.parsers.template_matcher import MatcherParser
 from detectmatelibrary.helper.from_to import From
 import detectmatelibrary.schemas as schemas
-
 from detectmatelibrary.utils.aux import time_test_mode
-
-import pytest
+from detectmatelibrary_tests.test_pipelines.test_configuration_engine import AUDIT_LOG
 
 # Set time test mode for consistent timestamps
 time_test_mode()
@@ -209,7 +206,7 @@ def test_detect_known_value_alert(self):
                 "remove_spaces": True,
                 "remove_punctuation": True,
                 "lowercase": True,
-                "path_templates": "tests/test_folder/audit_templates.txt",
+                "path_templates": "detectmatelibrary_tests/test_folder/audit_templates.txt",
             },
         }
     }
@@ -223,7 +220,7 @@ def test_audit_log_anomalies(self):
         parser = MatcherParser(config=_PARSER_CONFIG)
         detector = NewValueDetector()
 
-        logs = list(From.log(parser, in_path="tests/test_folder/audit.log", do_process=True))
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
 
         for log in logs[:1800]:
             detector.configure(log)
@@ -245,12 +242,11 @@ class TestNewValueDetectorAutoConfig:
     """Test that process() drives configure/set_configuration/train/detect
     automatically."""
 
-    @pytest.mark.skip(reason="This test is too late")
     def test_audit_log_anomalies_via_process(self):
         parser = MatcherParser(config=_PARSER_CONFIG)
         detector = NewValueDetector()
 
-        logs = list(From.log(parser, in_path="tests/test_folder/audit.log", do_process=True))
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
 
         # Phase 1: configure — keep configuring for logs[:1800]
         detector.fitlogic.configure_state = ConfigState.KEEP_CONFIGURE
@@ -278,7 +274,6 @@ def test_audit_log_anomalies_via_process(self):
 class TestNewValueDetectorGlobalInstances:
     """Tests event-ID-independent global instance detection."""
 
-    @pytest.mark.skip(reason="This test is too late")
     def test_global_instance_detects_new_type(self):
         """Global instance monitoring Type detects CRED_REFR, USER_AUTH,
         USER_CMD which only appear after the training window (line 1800+)."""
@@ -299,7 +294,7 @@ def test_global_instance_detects_new_type(self):
         config = NewValueDetectorConfig.from_dict(config_dict, "NewValueDetector")
         detector = NewValueDetector(config=config)
 
-        logs = list(From.log(parser, in_path="tests/test_folder/audit.log", do_process=True))
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
 
         for log in logs[:1800]:
             detector.train(log)
diff --git a/detectmatelibrary_tests/test_detectors/test_persist_integration.py b/detectmatelibrary_tests/test_detectors/test_persist_integration.py
new file mode 100644
index 00000000..a32767da
--- /dev/null
+++ b/detectmatelibrary_tests/test_detectors/test_persist_integration.py
@@ -0,0 +1,132 @@
+from detectmatelibrary.detectors.new_value_detector import NewValueDetector, NewValueDetectorConfig
+from detectmatelibrary.detectors.new_value_combo_detector import (
+    NewValueComboDetector,
+    NewValueComboDetectorConfig,
+)
+from detectmatelibrary.detectors.new_event_detector import NewEventDetector, NewEventDetectorConfig
+from detectmatelibrary.common.detector import PersistConfig
+from detectmatelibrary.utils.persistency.persistency_saver import PersistencySaver
+
+
+class TestNewValueDetectorPersist:
+    def test_no_saver_by_default(self):
+        det = NewValueDetector()
+        assert det.saver is None
+
+    def test_saver_created_when_persist_configured(self):
+        config = NewValueDetectorConfig(
+            auto_config=True,
+            persist=PersistConfig(path="memory://nvd_saver/state"),
+        )
+        det = NewValueDetector(name="NVD1", config=config)
+        assert det.saver is not None
+        det.saver.stop()
+
+    def test_save_and_reload(self):
+        base_path = "memory://nvd_reload/state"
+        det_name = "NVD_Reload"
+
+        det1 = NewValueDetector(
+            name=det_name,
+            config=NewValueDetectorConfig(
+                auto_config=False,
+                persist=PersistConfig(path=base_path),
+            ),
+        )
+        det1.persistency.ingest_event(
+            event_id=1,
+            event_template="login <*>",
+            named_variables={"user": "alice"},
+        )
+        assert det1.saver is not None
+        assert isinstance(det1.saver, PersistencySaver)
+        det1.saver.save()
+        det1.saver.stop()
+
+        det2 = NewValueDetector(
+            name=det_name,
+            config=NewValueDetectorConfig(
+                auto_config=False,
+                persist=PersistConfig(path=base_path, auto_load=True),
+            ),
+        )
+        assert 1 in det2.persistency.get_events_seen()
+        assert det2.saver is not None
+        det2.saver.stop()
+
+    def test_set_configuration_preserves_persist_config(self):
+        """Persist field must survive an auto-config set_configuration()
+        rebuild."""
+        config = NewValueDetectorConfig(
+            auto_config=True,
+            persist=PersistConfig(path="memory://set_config_preserve/state"),
+        )
+        det = NewValueDetector(name="SetConfigTest", config=config)
+        assert det.config.persist is not None  # sanity: persist is set before
+        det.set_configuration()
+        assert det.config.persist is not None  # must survive config rebuild
+        assert det.config.persist.path == "memory://set_config_preserve/state"
+        assert det.saver is not None
+        det.saver.stop()
+
+
+class TestNewValueComboDetectorPersist:
+    def test_no_saver_by_default(self):
+        det = NewValueComboDetector()
+        assert det.saver is None
+
+    def test_saver_created_when_persist_configured(self):
+        config = NewValueComboDetectorConfig(
+            auto_config=True,
+            persist=PersistConfig(path="memory://nvcd_saver/state"),
+        )
+        det = NewValueComboDetector(name="NVCD1", config=config)
+        assert det.saver is not None
+        det.saver.stop()
+
+    def test_save_and_reload(self):
+        base_path = "memory://nvcd_reload/state"
+        det_name = "NVCD_Reload"
+
+        det1 = NewValueComboDetector(
+            name=det_name,
+            config=NewValueComboDetectorConfig(
+                auto_config=False,
+                persist=PersistConfig(path=base_path),
+            ),
+        )
+        det1.persistency.ingest_event(
+            event_id=1,
+            event_template="login <*>",
+            named_variables={"user": "alice"},
+        )
+        assert det1.saver is not None
+        assert isinstance(det1.saver, PersistencySaver)
+        det1.saver.save()
+        det1.saver.stop()
+
+        det2 = NewValueComboDetector(
+            name=det_name,
+            config=NewValueComboDetectorConfig(
+                auto_config=False,
+                persist=PersistConfig(path=base_path, auto_load=True),
+            ),
+        )
+        assert 1 in det2.persistency.get_events_seen()
+        assert det2.saver is not None
+        det2.saver.stop()
+
+
+class TestNewEventDetectorPersist:
+    def test_no_saver_by_default(self):
+        det = NewEventDetector()
+        assert det.saver is None
+
+    def test_saver_created_when_persist_configured(self):
+        config = NewEventDetectorConfig(
+            auto_config=True,
+            persist=PersistConfig(path="memory://ned_saver/state"),
+        )
+        det = NewEventDetector(name="NED1", config=config)
+        assert det.saver is not None
+        det.saver.stop()
diff --git a/tests/test_detectors/test_random_detector.py b/detectmatelibrary_tests/test_detectors/test_random_detector.py
similarity index 100%
rename from tests/test_detectors/test_random_detector.py
rename to detectmatelibrary_tests/test_detectors/test_random_detector.py
diff --git a/detectmatelibrary_tests/test_detectors/test_rule_detector.py b/detectmatelibrary_tests/test_detectors/test_rule_detector.py
new file mode 100644
index 00000000..5cb023f0
--- /dev/null
+++ b/detectmatelibrary_tests/test_detectors/test_rule_detector.py
@@ -0,0 +1,179 @@
+import detectmatelibrary.detectors.rule_detector as rd
+import detectmatelibrary.schemas as schemas
+
+import pytest
+
+
+class TestCaseRules:
+    def test_template_not_found(self) -> None:
+        parsed_log = schemas.ParserSchema({"EventID": -1})
+        alert, msg = rd.template_not_found(parsed_log)
+        assert alert
+        assert "No template found by parser" == msg
+
+        parsed_log = schemas.ParserSchema({"EventID": 2})
+        alert, _ = rd.template_not_found(parsed_log)
+        assert not alert
+
+    def test_find_keyword(self) -> None:
+        keywords = ["hello", "ciao"]
+
+        parsed_log = schemas.ParserSchema({"log": "hello world"})
+        alert, msg = rd.find_keyword(parsed_log, keywords)
+        assert alert
+        assert "Found word 'hello' in the logs" == msg
+
+        parsed_log = schemas.ParserSchema({"log": "ciao world"})
+        alert, msg = rd.find_keyword(parsed_log, keywords)
+        assert alert
+        assert "Found word 'ciao' in the logs" == msg
+
+        parsed_log = schemas.ParserSchema({"log": "world"})
+        alert, _ = rd.find_keyword(parsed_log, keywords)
+        assert not alert
+
+    def test_find_exceptions(self) -> None:
+        parsed_log = schemas.ParserSchema({"log": "hello Exception"})
+        alert, msg = rd.exceptions(parsed_log)
+        assert alert
+        assert "Found word 'exception' in the logs" == msg
+
+        parsed_log = schemas.ParserSchema({"log": "world"})
+        alert, _ = rd.exceptions(parsed_log)
+        assert not alert
+
+    def test_error_log(self) -> None:
+        parsed_log = schemas.ParserSchema(
+            {"logFormatVariables": {"Level": "Error"}}
+        )
+        alert, msg = rd.error_log(parsed_log)
+        assert alert
+        assert "Error found" == msg
+
+        parsed_log = schemas.ParserSchema(
+            {"logFormatVariables": {"Level": "Info"}}
+        )
+        alert, _ = rd.error_log(parsed_log)
+        assert not alert
+
+        parsed_log = schemas.ParserSchema({"log": "hello world"})
+        alert, _ = rd.error_log(parsed_log)
+        assert not alert
+
+
+class TestCaseRuleDetector:
+    def test_run_all_rules(self) -> None:
+        rule_detector = rd.RuleDetector()
+
+        assert rule_detector.process(schemas.ParserSchema()) is None
+
+        alert1 = rule_detector.process(schemas.ParserSchema(
+            {
+                "EventID": -1,
+                "log": "fail exception",
+                "logFormatVariables": {"Level": "Error"}
+            }
+        ))
+        assert alert1 is not None
+        assert alert1["alertsObtain"] == {
+            "R001 - TemplateNotFound": "No template found by parser",
+            "R003 - CheckForExceptions": "Found word 'exception' in the logs",
+            "R004 - ErrorLevelFound": "Error found",
+        }
+        assert alert1["score"] == 3
+
+    def test_all_rules_serialize(self) -> None:
+        rule_detector = rd.RuleDetector()
+
+        assert rule_detector.process(schemas.ParserSchema().serialize()) is None
+
+        alert1 = rule_detector.process(schemas.ParserSchema(
+            {
+                "EventID": -1,
+                "log": "fail exception",
+                "logFormatVariables": {"Level": "Error"}
+            }
+        ).serialize())
+        assert alert1 is not None
+
+        (alert := schemas.DetectorSchema()).deserialize(alert1)
+        assert alert["alertsObtain"] == {
+            "R001 - TemplateNotFound": "No template found by parser",
+            "R003 - CheckForExceptions": "Found word 'exception' in the logs",
+            "R004 - ErrorLevelFound": "Error found",
+        }
+        assert alert["score"] == 3
+
+    def test_run_single_rule(self) -> None:
+        rule_detector = rd.RuleDetector(
+            name="RuleDetector",
+            config={
+                "detectors": {
+                    "RuleDetector": {
+                        "method_type": "rule_detector",
+                        "auto_config": False,
+                        "params": {
+                            "rules": [
+                                {"rule": "R001 - TemplateNotFound"}
+                            ]
+                        }
+                    }
+                }
+            }
+        )
+
+        assert rule_detector.process(schemas.ParserSchema()) is None
+
+        alert1 = rule_detector.process(schemas.ParserSchema(
+            {
+                "EventID": -1,
+                "log": "fail exception",
+                "logFormatVariables": {"Level": "Error"}
+            }
+        ))
+        assert alert1 is not None
+        assert alert1["alertsObtain"] == {
+            "R001 - TemplateNotFound": "No template found by parser",
+        }
+        assert alert1["score"] == 1
+
+    def test_run_single_rule_with_args(self) -> None:
+        rule_detector = rd.RuleDetector(
+            name="RuleDetector",
+            config={
+                "detectors": {
+                    "RuleDetector": {
+                        "method_type": "rule_detector",
+                        "auto_config": False,
+                        "params": {
+                            "rules": [
+                                {"rule": "R002 - SpecificKeyword", "args": ["hi", "kenobi"]}
+                            ]
+                        }
+                    }
+                }
+            }
+        )
+
+        assert rule_detector.process(schemas.ParserSchema({"log": "ciao"})) is None
+        assert rule_detector.process(schemas.ParserSchema({"log": "hi"})) is not None
+
+    def test_rule_not_found(self) -> None:
+
+        with pytest.raises(rd.RuleNotFound):
+            rd.RuleDetector(
+                name="RuleDetector",
+                config={
+                    "detectors": {
+                        "RuleDetector": {
+                            "method_type": "rule_detector",
+                            "auto_config": False,
+                            "params": {
+                                "rules": [
+                                    {"rule": "Rule made up"}
+                                ]
+                            }
+                        }
+                    }
+                }
+            )
diff --git a/detectmatelibrary_tests/test_detectors/test_value_range_detector.py b/detectmatelibrary_tests/test_detectors/test_value_range_detector.py
new file mode 100644
index 00000000..30e24803
--- /dev/null
+++ b/detectmatelibrary_tests/test_detectors/test_value_range_detector.py
@@ -0,0 +1,427 @@
+"""Tests for ValueRangeDetector class.
+
+This module tests the ValueRangeDetector implementation including:
+- Initialization and configuration
+- Training functionality to learn known values
+- Detection logic for new/unknown values
+- Event-specific configuration handling
+- Input/output schema validation
+"""
+import logging
+import random
+import pytest
+from detectmatelibrary.common._core_op._fit_logic import TrainState
+from detectmatelibrary.detectors.value_range_detector import (ValueRangeDetector, ValueRangeDetectorConfig,
+                                                              BufferMode)
+from detectmatelibrary.common._core_op._fit_logic import ConfigState
+from detectmatelibrary.constants import GLOBAL_EVENT_ID
+from detectmatelibrary.parsers.template_matcher import MatcherParser
+from detectmatelibrary.helper.from_to import From
+import detectmatelibrary.schemas as schemas
+from detectmatelibrary.utils.aux import time_test_mode
+from detectmatelibrary_tools.logging import logger
+from detectmatelibrary_tests.test_pipelines.test_configuration_engine import AUDIT_LOG
+# Set time test mode for consistent timestamps
+time_test_mode()
+
+
+config = {
+    "detectors": {
+        "CustomInit": {
+            "method_type": "value_range_detector",
+            "auto_config": False,
+            "params": {"ignore_non_numerical_val": False},
+            "events": {
+                1: {
+                    "instance1": {
+                        "params": {},
+                        "variables": [{
+                            "pos": 1, "name": "test", "params": {}
+                        }]
+                    }
+                }
+            }
+        },
+        "MultipleDetector": {
+            "method_type": "value_range_detector",
+            "auto_config": False,
+            "params": {"ignore_non_numerical_val": True},
+            "events": {
+                1: {
+                    "test": {
+                        "params": {},
+                        "variables": [{
+                            "pos": 1, "name": "test", "params": {}
+                        }]
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+class TestValueRangeDetectorInitialization:
+    """Test ValueRangeDetector initialization and configuration."""
+
+    def test_default_initialization(self):
+        """Test detector initialization with default parameters."""
+        detector = ValueRangeDetector()
+
+        assert detector.name == "ValueRangeDetector"
+        assert hasattr(detector, 'config')
+        assert detector.data_buffer.mode == BufferMode.NO_BUF
+        assert detector.input_schema == schemas.ParserSchema
+        assert detector.output_schema == schemas.DetectorSchema
+        assert hasattr(detector, 'persistency')
+
+    def test_custom_config_initialization(self):
+        """Test detector initialization with custom configuration."""
+        detector = ValueRangeDetector(name="CustomInit", config=config)
+
+        assert detector.name == "CustomInit"
+        assert hasattr(detector, 'persistency')
+        assert isinstance(detector.persistency.events_data, dict)
+
+
+class TestValueRangeDetectorTraining:
+    """Test ValueRangeDetector training functionality."""
+
+    def test_train_multiple_values(self):
+        """Test training with multiple different values."""
+        detector = ValueRangeDetector(config=config, name="MultipleDetector")
+        # Train with multiple values (the minimum and maximum value should be captured)
+        min_val = 100000
+        max_val = 0
+        for event in range(3):
+            for _ in range(300):
+                value = random.randint(0, 300)
+                if event == 1:
+                    min_val = min(min_val, value)
+                    max_val = max(max_val, value)
+                parser_data = schemas.ParserSchema({
+                    "parserType": "test",
+                    "EventID": event,
+                    "template": "test template",
+                    "variables": ["val0", str(value), "val2", "val3", "val4"],
+                    "logID": "1",
+                    "parsedLogID": "1",
+                    "parserID": "test_parser",
+                    "log": "test log message",
+                    "logFormatVariables": {}
+                })
+                detector.train(parser_data)
+
+            for _ in range(300):
+                value = random.uniform(0, 300)
+                if event == 1:
+                    min_val = min(min_val, value)
+                    max_val = max(max_val, value)
+                parser_data = schemas.ParserSchema({
+                    "parserType": "test",
+                    "EventID": event,
+                    "template": "test template",
+                    "variables": ["val0", str(value), "val2", "val3", "val4"],
+                    "logID": "1",
+                    "parsedLogID": "1",
+                    "parserID": "test_parser",
+                    "log": "test log message",
+                    "logFormatVariables": {}
+                })
+                detector.train(parser_data)
+
+        # Only event 1 should be tracked (based on events config)
+        assert len(detector.persistency.events_data) == 1
+        event_data = detector.persistency.get_event_data(1)
+        assert event_data is not None
+        # Check the variable at position 1 (named "test")
+        assert min(event_data["test"].unique_set) == min_val
+        assert max(event_data["test"].unique_set) == max_val
+
+    def test_train_detect_non_numeric_exit(self):
+        """Test training with non-numeric values and not ignoring them."""
+
+        detector = ValueRangeDetector(config=config, name="CustomInit")
+        # Train with multiple values (the minimum and maximum value should be captured)
+        parser_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["val0", f"val{random.randint(0, 300)}", "val2", "val3", "val4"],
+            "logID": "1",
+            "parsedLogID": "1",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {}
+        })
+        with pytest.raises(SystemExit) as excinfo:
+            detector.train(parser_data)
+        assert excinfo.value.code == 1
+        normal_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["val0", f"{random.randint(0, 300)}", "val2", "val3", "val4"],
+            "logID": "1",
+            "parsedLogID": "1",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {}
+        })
+        detector.train(normal_data)
+        with pytest.raises(SystemExit) as excinfo:
+            output = schemas.DetectorSchema()
+            detector.detect(parser_data, output)
+        assert excinfo.value.code == 1
+
+    def test_train_detect_non_numeric_ignore(self):
+        """Test training with non-numeric values and ignoring them."""
+
+        detector = ValueRangeDetector(config=config, name="MultipleDetector")
+        # Train with multiple values (the minimum and maximum value should be captured)
+        parser_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["val0", f"val{random.randint(0, 300)}", "val2", "val3", "val4"],
+            "logID": "1",
+            "parsedLogID": "1",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {}
+        })
+        detector.train(parser_data)
+        normal_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["val0", f"{random.randint(0, 300)}", "val2", "val3", "val4"],
+            "logID": "1",
+            "parsedLogID": "1",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {}
+        })
+        detector.train(normal_data)
+        output = schemas.DetectorSchema()
+        detector.detect(parser_data, output)
+
+
+class TestValueRangeDetectorDetection:
+    """Test ValueRangeDetector detection functionality."""
+
+    def test_detect_learned_value_range_no_alert(self):
+        detector = ValueRangeDetector(config=config, name="MultipleDetector")
+
+        # Train with values
+        for val in ["1", "5000", "2130"]:
+            train_data = schemas.ParserSchema({
+                "parserType": "test",
+                "EventID": 1,
+                "template": "test template",
+                "variables": ["adsasd", val],
+                "logID": "1",
+                "parsedLogID": "1",
+                "parserID": "test_parser",
+                "log": "test log message",
+                "logFormatVariables": {"level": "INFO"}
+            })
+            detector.train(train_data)
+
+        # Detect with the same value
+        test_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["adsasd", "4321"],
+            "logID": "2",
+            "parsedLogID": "2",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "CRITICAL"}
+        })
+        output = schemas.DetectorSchema()
+
+        result = detector.detect(test_data, output)
+
+        assert not result
+        assert output.score == 0.0
+
+    def test_detect_known_value_ranges_alert(self):
+        detector = ValueRangeDetector(config=config, name="MultipleDetector")
+
+        # Train with values
+        for val in ["1", "5000", "2130"]:
+            train_data = schemas.ParserSchema({
+                "parserType": "test",
+                "EventID": 1,
+                "template": "test template",
+                "variables": ["adsasd", val],
+                "logID": "1",
+                "parsedLogID": "1",
+                "parserID": "test_parser",
+                "log": "test log message",
+                "logFormatVariables": {"level": "INFO"}
+            })
+            detector.train(train_data)
+
+        # Detect with the different value
+        test_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["adsasd", "5001"],
+            "logID": "2",
+            "parsedLogID": "2",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "CRITICAL"}
+        })
+        output = schemas.DetectorSchema()
+
+        result = detector.detect(test_data, output)
+
+        assert result
+        assert output.score == 1.0
+
+        # Detect with the different value
+        test_data = schemas.ParserSchema({
+            "parserType": "test",
+            "EventID": 1,
+            "template": "test template",
+            "variables": ["adsasd", "0"],
+            "logID": "2",
+            "parsedLogID": "2",
+            "parserID": "test_parser",
+            "log": "test log message",
+            "logFormatVariables": {"level": "CRITICAL"}
+        })
+        output = schemas.DetectorSchema()
+
+        result = detector.detect(test_data, output)
+
+        assert result
+        assert output.score == 1.0
+
+
+_PARSER_CONFIG = {
+    "parsers": {
+        "MatcherParser": {
+            "method_type": "matcher_parser",
+            "auto_config": False,
+            "log_format": "type=<Type> msg=audit(<Time>:<Line>): <Content>",
+            "time_format": None,
+            "params": {
+                "remove_spaces": True,
+                "remove_punctuation": True,
+                "lowercase": True,
+                "path_templates": "detectmatelibrary_tests/test_folder/audit_templates.txt",
+            },
+        }
+    }
+}
+
+
+class TestValueRangeDetectorEndToEnd:
+    """Regression test: full configure/train/detect pipeline on audit.log."""
+
+    def test_audit_log_anomalies(self):
+        parser = MatcherParser(config=_PARSER_CONFIG)
+        detector = ValueRangeDetector()
+
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
+
+        for log in logs[:1800]:
+            detector.configure(log)
+        detector.set_configuration()
+
+        for log in logs[:1800]:
+            logger.setLevel(logging.CRITICAL)
+            detector.train(log)
+            logger.setLevel(logging.DEBUG)
+
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            output = schemas.DetectorSchema()
+            if detector.detect(log, output_=output):
+                detected_ids.add(log["logID"])
+
+        # uid is not always 0 for event id 0. uid=1002 in line 1864 is a different event id.
+        assert detected_ids == {'1859', '1860', '1861', '1862'}
+
+
+class TestValueRangeDetectorAutoConfig:
+    """Test that process() drives configure/set_configuration/train/detect
+    automatically."""
+
+    def test_audit_log_anomalies_via_process(self):
+        parser = MatcherParser(config=_PARSER_CONFIG)
+        detector = ValueRangeDetector()
+
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
+
+        # Phase 1: configure — keep configuring for logs[:1800]
+        detector.fitlogic.configure_state = ConfigState.KEEP_CONFIGURE
+        for log in logs[:1800]:
+            detector.process(log)
+
+        # Transition: stop configure so next process() call triggers set_configuration()
+        detector.fitlogic.configure_state = ConfigState.STOP_CONFIGURE
+
+        # Phase 2: train — keep training for logs[:1800]
+        detector.fitlogic.train_state = TrainState.KEEP_TRAINING
+        for log in logs[:1800]:
+            logger.setLevel(logging.CRITICAL)
+            detector.process(log)
+            logger.setLevel(logging.DEBUG)
+
+        # Phase 3: detect — stop training so process() only calls detect()
+        detector.fitlogic.train_state = TrainState.STOP_TRAINING
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            if detector.process(log) is not None:
+                detected_ids.add(log["logID"])
+
+        assert detected_ids == {'1859', '1860', '1861', '1862'}
+
+
+class TestValueRangeDetectorGlobalInstances:
+    """Tests event-ID-independent global instance detection."""
+
+    def test_global_instance_detects_new_type(self):
+        """Global instance monitoring Type detects CRED_REFR, USER_AUTH,
+        USER_CMD which only appear after the training window (line 1800+)."""
+        parser = MatcherParser(config=_PARSER_CONFIG)
+        config_dict = {
+            "detectors": {
+                "ValueRangeDetector": {
+                    "method_type": "value_range_detector",
+                    "auto_config": False,
+                    "params": {"ignore_non_numerical_val": True},
+                    "global": {
+                        "test": {
+                            "header_variables": [{"pos": "Time"}]
+                        }
+                    }
+                }
+            }
+        }
+        config = ValueRangeDetectorConfig.from_dict(config_dict, "ValueRangeDetector")
+        detector = ValueRangeDetector(config=config)
+
+        logs = list(From.log(parser, in_path=AUDIT_LOG, do_process=True))
+
+        for log in logs[:1800]:
+            detector.train(log)
+
+        # Global tracker must be populated under the sentinel event ID
+        assert GLOBAL_EVENT_ID in detector.persistency.get_events_data()
+
+        detected_ids: set[str] = set()
+        for log in logs[1800:]:
+            output = schemas.DetectorSchema()
+            if detector.detect(log, output_=output):
+                assert all(key.startswith("Global -") for key in output["alertsObtain"])
+                detected_ids.add(log["logID"])
+
+        assert len(detected_ids) > 0
diff --git a/src/tools/workspace/templates/test_templates/__init__.py b/detectmatelibrary_tests/test_folder/__init__.py
similarity index 100%
rename from src/tools/workspace/templates/test_templates/__init__.py
rename to detectmatelibrary_tests/test_folder/__init__.py
diff --git a/tests/test_folder/audit.log b/detectmatelibrary_tests/test_folder/audit.log
similarity index 100%
rename from tests/test_folder/audit.log
rename to detectmatelibrary_tests/test_folder/audit.log
diff --git a/tests/test_folder/audit_anomaly_labels.log b/detectmatelibrary_tests/test_folder/audit_anomaly_labels.log
similarity index 100%
rename from tests/test_folder/audit_anomaly_labels.log
rename to detectmatelibrary_tests/test_folder/audit_anomaly_labels.log
diff --git a/tests/test_folder/audit_templates.txt b/detectmatelibrary_tests/test_folder/audit_templates.txt
similarity index 100%
rename from tests/test_folder/audit_templates.txt
rename to detectmatelibrary_tests/test_folder/audit_templates.txt
diff --git a/tests/test_folder/logs.log b/detectmatelibrary_tests/test_folder/logs.log
similarity index 100%
rename from tests/test_folder/logs.log
rename to detectmatelibrary_tests/test_folder/logs.log
diff --git a/tests/test_folder/test_config.yaml b/detectmatelibrary_tests/test_folder/test_config.yaml
similarity index 85%
rename from tests/test_folder/test_config.yaml
rename to detectmatelibrary_tests/test_folder/test_config.yaml
index ff679b11..45889f84 100644
--- a/tests/test_folder/test_config.yaml
+++ b/detectmatelibrary_tests/test_folder/test_config.yaml
@@ -16,7 +16,7 @@ parsers:
     method_type: matcher_parser
     auto_config: false
     params:
-      path_templates: "tests/test_folder/test_templates.txt"
+      path_templates: "detectmatelibrary_tests/test_folder/test_templates.txt"
 
 detectors:
   detector_variables:
@@ -165,3 +165,35 @@ detectors:
     method_type: new_value_combo_detector
     parser: example_parser_1
     auto_config: true
+
+  detector_named_pos:
+    method_type: ExampleDetector
+    parser: example_parser_1
+    auto_config: false
+    params: {}
+    events:
+      1:  # positional event_id; named wildcards in .txt templates use int event keys
+        example_detector_1:
+          params: {}
+          variables:
+            - pos: pid  # named label; no 'name' field needed
+            - pos: op
+              params:
+                threshold: 0.5
+          header_variables:
+            - pos: Level
+              params:
+                threshold: 0.2
+
+  detector_named_event_id:
+    method_type: ExampleDetector
+    parser: example_parser_1
+    auto_config: false
+    params: {}
+    events:
+      login_failure:  # named event_id; only valid for CSV templates with an EventId column
+        example_detector_1:
+          params: {}
+          variables:
+            - pos: pid
+            - pos: uid
diff --git a/detectmatelibrary_tests/test_folder/test_named_templates.csv b/detectmatelibrary_tests/test_folder/test_named_templates.csv
new file mode 100644
index 00000000..3ce1622a
--- /dev/null
+++ b/detectmatelibrary_tests/test_folder/test_named_templates.csv
@@ -0,0 +1,2 @@
+EventId,EventTemplate
+login_failure,"pid=<pid> uid=<uid> auid=<auid> ses=<ses> msg='op=PAM:<op> acct=<acct>"
diff --git a/detectmatelibrary_tests/test_folder/test_named_templates.txt b/detectmatelibrary_tests/test_folder/test_named_templates.txt
new file mode 100644
index 00000000..1ef130f2
--- /dev/null
+++ b/detectmatelibrary_tests/test_folder/test_named_templates.txt
@@ -0,0 +1 @@
+pid=<pid> uid=<uid> auid=<auid> ses=<ses> msg='op=PAM:<op> acct=<acct>
diff --git a/tests/test_folder/test_templates.txt b/detectmatelibrary_tests/test_folder/test_templates.txt
similarity index 100%
rename from tests/test_folder/test_templates.txt
rename to detectmatelibrary_tests/test_folder/test_templates.txt
diff --git a/detectmatelibrary_tests/test_helper/__init__.py b/detectmatelibrary_tests/test_helper/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_helper/test_from_to.py b/detectmatelibrary_tests/test_helper/test_from_to.py
similarity index 64%
rename from tests/test_helper/test_from_to.py
rename to detectmatelibrary_tests/test_helper/test_from_to.py
index e375cef7..ef9d10af 100644
--- a/tests/test_helper/test_from_to.py
+++ b/detectmatelibrary_tests/test_helper/test_from_to.py
@@ -1,10 +1,13 @@
 from detectmatelibrary.helper.from_to import From, To, FromTo
 
-from detectmatelibrary.detectors.dummy_detector import DummyDetector
-from detectmatelibrary.parsers.dummy_parser import DummyParser
+from detectmatelibrary_tests.test_detectors.dummy_detector import DummyDetector
+from detectmatelibrary_tests.test_parsers.dummy_parser import DummyParser
 
 import detectmatelibrary.schemas as schemas
 
+import detectmateperformance as dmp
+
+import polars as pl
 import json
 import yaml
 import os
@@ -12,14 +15,14 @@
 
 expected_log = "pid=<*> uid=<*> auid=<*> ses=<*> msg='op=<*> "
 expected_log += "acct=<*> exe=<*> hostname=<*> addr=<*> terminal=<*> res=<*>'"
-log_path = "tests/test_folder/audit_templates.txt"
+log_path = "detectmatelibrary_tests/test_folder/audit_templates.txt"
 
-binary_path = "tests/test_folder/dummy.txt"
-binary_path2 = "tests/test_folder/dummy2.txt"
-json_path = "tests/test_folder/dummy.json"
-json_path2 = "tests/test_folder/dummy2.json"
-yaml_path = "tests/test_folder/dummy.yaml"
-yaml_path2 = "tests/test_folder/dummy2.yaml"
+binary_path = "detectmatelibrary_tests/test_folder/dummy.txt"
+binary_path2 = "detectmatelibrary_tests/test_folder/dummy2.txt"
+json_path = "detectmatelibrary_tests/test_folder/dummy.json"
+json_path2 = "detectmatelibrary_tests/test_folder/dummy2.json"
+yaml_path = "detectmatelibrary_tests/test_folder/dummy.yaml"
+yaml_path2 = "detectmatelibrary_tests/test_folder/dummy2.yaml"
 
 
 def remove_files(func):
@@ -136,6 +139,64 @@ def test_fromyaml(self):
 
         assert log1 == log2
 
+    def test_frompolars(self):
+        table = pl.DataFrame({
+            "Type": ["A", "B"],
+            "Content": ["hello there", "general kenobi"],
+            "ParamList": [["a", "b"], ["c", "d"]],
+            "Templates": ["hello <*>", "<*> kenobi"],
+            "EventIDs": [0, 1]
+        })
+        gen = From.polars(DummyDetector(), df=table, do_process=False)
+
+        parsed1 = next(gen)
+        schema1 = schemas.ParserSchema({
+            "log": "hello there",
+            "variables": ["a", "b"],
+            "template": "hello <*>",
+            "EventID": 0,
+            "logFormatVariables": {"Type": "A"}
+        })
+        for field in ["log", "variables", "template", "EventID", "logFormatVariables"]:
+            assert parsed1[field] == schema1[field], field
+        assert parsed1["logID"] == "0"
+
+        parsed2 = next(gen)
+        schema2 = schemas.ParserSchema({
+            "log": "general kenobi",
+            "variables": ["c", "d"],
+            "template": "<*> kenobi",
+            "EventID": 1,
+            "logFormatVariables": {"Type": "B"}
+        })
+        for field in ["log", "variables", "template", "EventID", "logFormatVariables"]:
+            assert parsed2[field] == schema2[field], field
+        assert parsed2["logID"] == "1"
+
+    def test_frompolars_rename(self):
+        table = pl.DataFrame({
+            "Type": ["A", "B"],
+            "Content": ["hello there", "general kenobi"],
+            "Vars": [["a", "b"], ["c", "d"]],
+            "Templates": ["hello <*>", "<*> kenobi"],
+            "EventIDs": [0, 1]
+        })
+        renames = {
+            "Content": "log", "Vars": "variables", "EventIDs": "EventID", "Templates": "template"
+        }
+        gen = From.polars(DummyDetector(), df=table, do_process=False, renames=renames)
+
+        parsed1 = next(gen)
+        schema1 = schemas.ParserSchema({
+            "log": "hello there",
+            "variables": ["a", "b"],
+            "template": "hello <*>",
+            "EventID": 0,
+            "logFormatVariables": {"Type": "A"}
+        })
+        for field in ["log", "variables", "template", "EventID", "logFormatVariables"]:
+            assert parsed1[field] == schema1[field], field
+
 
 class TestCaseFromTo:
     @remove_files
@@ -309,9 +370,60 @@ def test_yaml2yaml(self):
         with open(yaml_path2) as f:
             assert 5 == len(yaml.safe_load(f))
 
+    @remove_files
+    def test_polars2binary(self):
+        detector = DummyDetector()
+        table = pl.DataFrame({
+            "Type": ["A", "B"],
+            "Content": ["hello there", "general kenobi"],
+            "ParamList": [["a", "b"], ["c", "d"]],
+            "Templates": ["hello <*>", "<*> kenobi"],
+            "EventIDs": [0, 1]
+        })
+        gen = FromTo.polars2binary_file(detector, df=table, out_path=binary_path)
+        for _ in gen:
+            pass
+
+        with open(binary_path) as f:
+            assert 1 == len(f.readlines())
+
+    @remove_files
+    def test_polars2json(self):
+        detector = DummyDetector()
+        table = pl.DataFrame({
+            "Type": ["A", "B"],
+            "Content": ["hello there", "general kenobi"],
+            "ParamList": [["a", "b"], ["c", "d"]],
+            "Templates": ["hello <*>", "<*> kenobi"],
+            "EventIDs": [0, 1]
+        })
+        gen = FromTo.polars2json(detector, df=table, out_path=json_path)
+        for _ in gen:
+            pass
+
+        with open(json_path) as f:
+            assert 1 == len(json.load(f))
+
+    @remove_files
+    def test_polars2yaml(self):
+        detector = DummyDetector()
+        table = pl.DataFrame({
+            "Type": ["A", "B"],
+            "Content": ["hello there", "general kenobi"],
+            "ParamList": [["a", "b"], ["c", "d"]],
+            "Templates": ["hello <*>", "<*> kenobi"],
+            "EventIDs": [0, 1]
+        })
+        gen = FromTo.polars2yaml(detector, df=table, out_path=yaml_path)
+        for _ in gen:
+            pass
+
+        with open(yaml_path) as f:
+            assert 1 == len(yaml.safe_load(f))
+
 
 class TestUseCase:
-    # The idea of this tests is to check that they do not crash in normal use
+    # The idea of these tests is to check that they do not crash in normal use
     def test_case1(self):
         detector = DummyDetector()
         parser = DummyParser()
@@ -366,3 +478,20 @@ def test_case3(self):
 
         assert os.path.exists(json_path)
         assert os.path.exists(json_path2)
+
+    @remove_files
+    def test_case4(self):
+        matcher = dmp.match_tree.TreeMatcher(
+            templates=dmp.types_.LogTemplates(["hello <*>"])
+        )
+        detector = DummyDetector()
+
+        df = matcher(["hello there", "general kenobi"], get_var=True)
+        for parsed_log in From.polars(detector, df=df):
+            if parsed_log is not None:
+                assert parsed_log["logIDs"] == ["1"]
+
+        df = matcher(["hello there", "general kenobi"], get_var=False)
+        for parsed_log in From.polars(detector, df=df):
+            if parsed_log is not None:
+                assert parsed_log["logIDs"] == ["1"]
diff --git a/detectmatelibrary_tests/test_others/__init__.py b/detectmatelibrary_tests/test_others/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_others/test_logging.py b/detectmatelibrary_tests/test_others/test_logging.py
similarity index 97%
rename from tests/test_others/test_logging.py
rename to detectmatelibrary_tests/test_others/test_logging.py
index 57254813..fbb56d57 100644
--- a/tests/test_others/test_logging.py
+++ b/detectmatelibrary_tests/test_others/test_logging.py
@@ -3,7 +3,7 @@
 from contextlib import redirect_stdout, redirect_stderr
 import pytest
 
-from tools.logging import setup_logging, logger
+from detectmatelibrary_tools.logging import setup_logging, logger
 
 
 @pytest.fixture(autouse=True)
diff --git a/detectmatelibrary_tests/test_parsers/__init__.py b/detectmatelibrary_tests/test_parsers/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/detectmatelibrary/parsers/dummy_parser.py b/detectmatelibrary_tests/test_parsers/dummy_parser.py
similarity index 100%
rename from src/detectmatelibrary/parsers/dummy_parser.py
rename to detectmatelibrary_tests/test_parsers/dummy_parser.py
diff --git a/tests/test_parsers/test_json_parser.py b/detectmatelibrary_tests/test_parsers/test_json_parser.py
similarity index 98%
rename from tests/test_parsers/test_json_parser.py
rename to detectmatelibrary_tests/test_parsers/test_json_parser.py
index 16e619a3..ea2530b1 100644
--- a/tests/test_parsers/test_json_parser.py
+++ b/detectmatelibrary_tests/test_parsers/test_json_parser.py
@@ -138,7 +138,7 @@ def test_parse_with_content_parser(self):
                 "JsonMatcherParser": {
                     "auto_config": True,
                     "method_type": "matcher_parser",
-                    "path_templates": "tests/test_folder/test_templates.txt"
+                    "path_templates": "detectmatelibrary_tests/test_folder/test_templates.txt"
                 }
             }
         }
diff --git a/tests/test_parsers/test_logbatcher_parser.py b/detectmatelibrary_tests/test_parsers/test_logbatcher_parser.py
similarity index 100%
rename from tests/test_parsers/test_logbatcher_parser.py
rename to detectmatelibrary_tests/test_parsers/test_logbatcher_parser.py
diff --git a/detectmatelibrary_tests/test_parsers/test_template_matcher.py b/detectmatelibrary_tests/test_parsers/test_template_matcher.py
new file mode 100644
index 00000000..6b241171
--- /dev/null
+++ b/detectmatelibrary_tests/test_parsers/test_template_matcher.py
@@ -0,0 +1,241 @@
+import pytest
+from detectmatelibrary.parsers.template_matcher import MatcherParser, MatcherParserConfig, \
+    TemplatesNotFoundError
+from detectmatelibrary.parsers.template_matcher._parser import _compile_templates
+from detectmatelibrary.common._config._formats import EventsConfig
+from detectmatelibrary import schemas
+
+NAMED_TEMPLATES_TXT = "detectmatelibrary_tests/test_folder/test_named_templates.txt"
+NAMED_TEMPLATES_CSV = "detectmatelibrary_tests/test_folder/test_named_templates.csv"
+test_template = ["pid=<*> uid=<*> auid=<*> ses=<*> msg='op=PAM:<*> acct=<*>"]
+test_log_match = 'pid=9699 uid=0 auid=4294967295 ses=4294967295 msg=\'op=PAM:accounting acct="root"'
+test_log_no_match = 'this is not matching'
+
+
+class TestMatcherParserBasic:
+    def test_no_path_templates(self):
+        config_dict = {
+            "parsers": {
+                "MatcherParser": {
+                    "auto_config": True,
+                    "method_type": "matcher_parser",
+                }
+            }
+        }
+        parser = MatcherParser(name="MatcherParser", config=config_dict)
+        input_log = schemas.LogSchema({"log": test_log_match})
+        output_data = schemas.ParserSchema()
+        parser.parse(input_log, output_data)
+
+        assert output_data.template == "<Not Found>"
+        assert output_data.EventID == -1
+        assert output_data.variables == []
+
+    def test_templates_not_found(self):
+        config_dict = {
+            "parsers": {
+                "MatcherParser": {
+                    "auto_config": True,
+                    "method_type": "matcher_parser",
+                    "path_templates": "non_existent_file.txt"
+                }
+            }
+        }
+        with pytest.raises(TemplatesNotFoundError):
+            MatcherParser(name="MatcherParser", config=config_dict)
+
+    def test_successful_match(self):
+        config_dict = {
+            "parsers": {
+                "MatcherParser": {
+                    "auto_config": True,
+                    "method_type": "matcher_parser",
+                    "path_templates": "detectmatelibrary_tests/test_folder/test_templates.txt"
+                }
+            }
+        }
+        parser = MatcherParser(name="MatcherParser", config=config_dict)
+        input_log = schemas.LogSchema({"log": test_log_match})
+        output_data = schemas.ParserSchema()
+        parser.parse(input_log, output_data)
+
+        assert output_data.template == test_template[0]
+        assert output_data.EventID == 0
+        assert len(output_data.variables) > 0
+
+    def test_no_match(self):
+        config_dict = {
+            "parsers": {
+                "MatcherParser": {
+                    "auto_config": True,
+                    "method_type": "matcher_parser",
+                    "path_templates": "detectmatelibrary_tests/test_folder/test_templates.txt"
+                }
+            }
+        }
+        parser = MatcherParser(name="MatcherParser", config=config_dict)
+        input_log = schemas.LogSchema({"log": test_log_no_match})
+        output_data = schemas.ParserSchema()
+        parser.parse(input_log, output_data)
+
+        assert output_data.template == "<Not Found>"
+        assert output_data.EventID == -1
+        assert output_data.variables == []
+
+    def test_custom_preprocessing_flags(self):
+        config = MatcherParserConfig(
+            remove_spaces=False,
+            remove_punctuation=False,
+            lowercase=False,
+            path_templates="detectmatelibrary_tests/test_folder/test_templates.txt"
+        )
+        parser = MatcherParser(name="MatcherParser", config=config)
+        input_log = schemas.LogSchema({"log": test_log_match})
+        output_data = schemas.ParserSchema()
+        parser.parse(input_log, output_data)
+        # Still matches template even with preprocessing disabled
+        assert output_data.template == test_template[0]
+
+
+class TestCompileTemplates:
+    def test_named_wildcards_compiled_to_anon(self):
+        raw = ["pid=<pid> uid=<uid> auid=<auid>"]
+        compiled, metadata = _compile_templates(raw)
+        assert compiled == ["pid=<*> uid=<*> auid=<*>"]
+        assert metadata[0]["labels"] == ["pid", "uid", "auid"]
+        assert metadata[0]["event_id_label"] is None
+
+    def test_anonymous_wildcards_unchanged(self):
+        raw = ["pid=<*> uid=<*>"]
+        compiled, metadata = _compile_templates(raw)
+        assert compiled == ["pid=<*> uid=<*>"]
+        assert metadata[0]["labels"] == []
+        assert metadata[0]["event_id_label"] is None
+
+    def test_event_id_label_stored(self):
+        raw = ["pid=<pid> uid=<uid>"]
+        eid_labels: list[str | None] = ["login_failure"]
+        compiled, metadata = _compile_templates(raw, eid_labels)
+        assert compiled == ["pid=<*> uid=<*>"]
+        assert metadata[0]["event_id_label"] == "login_failure"
+        assert metadata[0]["labels"] == ["pid", "uid"]
+
+    def test_mixing_raises_value_error(self):
+        raw = ["pid=<*> uid=<uid>"]
+        with pytest.raises(ValueError, match="mixes"):
+            _compile_templates(raw)
+
+    def test_multiple_templates(self):
+        raw = ["pid=<pid> uid=<uid>", "arch=<*> syscall=<*>"]
+        compiled, metadata = _compile_templates(raw)
+        assert compiled[0] == "pid=<*> uid=<*>"
+        assert compiled[1] == "arch=<*> syscall=<*>"
+        assert metadata[0]["labels"] == ["pid", "uid"]
+        assert metadata[1]["labels"] == []
+
+
+class TestNamedWildcardsTxt:
+    """Named wildcards in .txt template files (event IDs remain positional)."""
+
+    named_template_compiled = "pid=<*> uid=<*> auid=<*> ses=<*> msg='op=PAM:<*> acct=<*>"
+
+    def test_match_produces_correct_variables(self):
+        config = MatcherParserConfig(path_templates=NAMED_TEMPLATES_TXT)
+        parser = MatcherParser(name="MatcherParser", config=config)
+        input_log = schemas.LogSchema({"log": test_log_match})
+        output_data = schemas.ParserSchema()
+        parser.parse(input_log, output_data)
+
+        assert output_data.template == self.named_template_compiled
+        assert output_data.EventID == 0
+        assert len(output_data.variables) == 6
+
+    def test_compile_resolves_named_positions(self):
+        config = MatcherParserConfig(path_templates=NAMED_TEMPLATES_TXT)
+        parser = MatcherParser(name="MatcherParser", config=config)
+
+        raw_events: dict = {
+            0: {
+                "my_detector": {
+                    "params": {},
+                    "variables": [
+                        {"pos": "pid"},
+                        {"pos": "op"},
+                    ]
+                }
+            }
+        }
+        events_config = EventsConfig._init(raw_events)
+        compiled = parser.template_matcher.compile_detector_config(events_config)
+
+        # pid is label 0 → pos 0; op is label 4 → pos 4
+        resolved_vars = compiled.events[0].variables
+        assert 0 in resolved_vars
+        assert resolved_vars[0].name == "pid"
+        assert 4 in resolved_vars
+        assert resolved_vars[4].name == "op"
+
+    def test_compile_unknown_label_raises(self):
+        config = MatcherParserConfig(path_templates=NAMED_TEMPLATES_TXT)
+        parser = MatcherParser(name="MatcherParser", config=config)
+
+        raw_events: dict = {
+            0: {"d": {"params": {}, "variables": [{"pos": "nonexistent"}]}}
+        }
+        events_config = EventsConfig._init(raw_events)
+        with pytest.raises(ValueError, match="nonexistent"):
+            parser.template_matcher.compile_detector_config(events_config)
+
+
+class TestNamedEventIdCsv:
+    """Named event IDs via CSV EventId column."""
+
+    named_template_compiled = "pid=<*> uid=<*> auid=<*> ses=<*> msg='op=PAM:<*> acct=<*>"
+
+    def test_match_produces_correct_variables(self):
+        config = MatcherParserConfig(path_templates=NAMED_TEMPLATES_CSV)
+        parser = MatcherParser(name="MatcherParser", config=config)
+        input_log = schemas.LogSchema({"log": test_log_match})
+        output_data = schemas.ParserSchema()
+        parser.parse(input_log, output_data)
+
+        assert output_data.template == self.named_template_compiled
+        assert output_data.EventID == 0
+        assert len(output_data.variables) == 6
+
+    def test_compile_resolves_named_event_key(self):
+        config = MatcherParserConfig(path_templates=NAMED_TEMPLATES_CSV)
+        parser = MatcherParser(name="MatcherParser", config=config)
+
+        raw_events: dict = {
+            "login_failure": {
+                "my_detector": {
+                    "params": {},
+                    "variables": [
+                        {"pos": "pid"},
+                        {"pos": "uid"},
+                    ]
+                }
+            }
+        }
+        events_config = EventsConfig._init(raw_events)
+        compiled = parser.template_matcher.compile_detector_config(events_config)
+
+        # "login_failure" → int key 0
+        assert 0 in compiled.events
+        resolved_vars = compiled.events[0].variables
+        assert 0 in resolved_vars and resolved_vars[0].name == "pid"
+        assert 1 in resolved_vars and resolved_vars[1].name == "uid"
+
+    def test_positional_int_event_key_still_works(self):
+        config = MatcherParserConfig(path_templates=NAMED_TEMPLATES_CSV)
+        parser = MatcherParser(name="MatcherParser", config=config)
+
+        raw_events: dict = {
+            0: {"d": {"params": {}, "variables": [{"pos": 0, "name": "process_id"}]}}
+        }
+        events_config = EventsConfig._init(raw_events)
+        compiled = parser.template_matcher.compile_detector_config(events_config)
+
+        assert 0 in compiled.events
+        assert compiled.events[0].variables[0].name == "process_id"
diff --git a/detectmatelibrary_tests/test_parsers/test_tree_macther.py b/detectmatelibrary_tests/test_parsers/test_tree_macther.py
new file mode 100644
index 00000000..6fd08596
--- /dev/null
+++ b/detectmatelibrary_tests/test_parsers/test_tree_macther.py
@@ -0,0 +1,47 @@
+"""Most of the functionality is test it in DetectMatePerformance."""
+from detectmatelibrary.parsers.tree_matcher import TemplateCppTreeMatcher
+from detectmatelibrary import schemas
+
+
+test_template = [
+    "pid <*> uid <*> auid <*> ses <*> msg op PAM <*> acct <*>",
+]
+test_log_match = 'pid=9699 uid=0 auid=4294967295 ses=4294967295 msg=\'op=PAM:accounting acct="root"'
+test_log_no_match = 'this is not matching'
+
+
+class TestMatcherParserBasic:
+    def test_no_path_templates(self):
+        config_dict = {
+            "parsers": {
+                "TreeMatcher": {
+                    "method_type": "tree_matcher",
+                }
+            }
+        }
+        parser = TemplateCppTreeMatcher(name="TreeMatcher", config=config_dict)
+        input_log = schemas.LogSchema({"log": test_log_match})
+        output_data = schemas.ParserSchema()
+        parser.parse(input_log, output_data)
+
+        assert output_data.template == "template not found"
+        assert output_data.EventID == -1
+        assert output_data.variables == []
+
+    def test_successful_match(self):
+        config_dict = {
+            "parsers": {
+                "TreeMatcher": {
+                    "method_type": "tree_matcher",
+                    "path_templates": "detectmatelibrary_tests/test_folder/test_templates.txt"
+                }
+            }
+        }
+        parser = TemplateCppTreeMatcher(name="TreeMatcher", config=config_dict)
+        input_log = schemas.LogSchema({"log": test_log_match})
+        output_data = schemas.ParserSchema()
+        parser.parse(input_log, output_data)
+
+        assert output_data.template == test_template[0]
+        assert output_data.EventID == 0
+        assert len(output_data.variables) > 0
diff --git a/detectmatelibrary_tests/test_persistency/__init__.py b/detectmatelibrary_tests/test_persistency/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/detectmatelibrary_tests/test_persistency/test_stability_tracker.py b/detectmatelibrary_tests/test_persistency/test_stability_tracker.py
new file mode 100644
index 00000000..d6aa34a6
--- /dev/null
+++ b/detectmatelibrary_tests/test_persistency/test_stability_tracker.py
@@ -0,0 +1,132 @@
+from detectmatelibrary.utils.persistency.event_data_structures.trackers.stability.stability_tracker import (
+    EventStabilityTracker,
+    SingleStabilityTracker,
+)
+
+
+class TestSingleStabilityTrackerExpandValue:
+    def test_default_add_stores_whole_value(self):
+        tracker = SingleStabilityTracker()
+        tracker.add_value("hello")
+        tracker.add_value("world")
+        assert tracker.unique_set == {"hello", "world"}
+
+    def test_expand_value_unions_characters(self):
+        tracker = SingleStabilityTracker(expand_value=True)
+        tracker.add_value("hello")
+        tracker.add_value("world")
+        assert tracker.unique_set == {"h", "e", "l", "o", "w", "r", "d"}
+
+    def test_expand_value_change_series_tracks_growth(self):
+        tracker = SingleStabilityTracker(expand_value=True)
+        tracker.add_value("ab")           # adds {a, b}, change=True
+        tracker.add_value("ba")           # adds nothing new, change=False
+        tracker.add_value("c")            # adds {c}, change=True
+        assert list(tracker.change_series) == [True, False, True]
+
+    def test_expand_value_round_trip(self):
+        tracker = SingleStabilityTracker(expand_value=True)
+        tracker.add_value("hello")
+        tracker.add_value("world")
+        state = tracker.to_state()
+        restored = SingleStabilityTracker.from_state(state)
+        assert restored.expand_value is True
+        assert restored.unique_set == {"h", "e", "l", "o", "w", "r", "d"}
+        # subsequent ingestion still unions characters
+        restored.add_value("xy")
+        assert {"x", "y"} <= restored.unique_set
+
+    def test_legacy_state_without_expand_value_defaults_false(self):
+        tracker = SingleStabilityTracker()
+        tracker.add_value("hello")
+        state = tracker.to_state()
+        state.pop("expand_value", None)  # simulate pre-flag snapshot
+        restored = SingleStabilityTracker.from_state(state)
+        assert restored.expand_value is False
+        assert restored.unique_set == {"hello"}
+
+
+class TestEventStabilityTrackerExpandValue:
+    def test_default_event_tracker_uses_add_semantics(self):
+        event_tracker = EventStabilityTracker()
+        event_tracker.add_data({"var1": "hello"})
+        single = event_tracker.get_data()["var1"]
+        assert single.expand_value is False
+        assert single.unique_set == {"hello"}
+
+    def test_expand_value_propagates_to_per_variable_trackers(self):
+        event_tracker = EventStabilityTracker(expand_value=True)
+        event_tracker.add_data({"var1": "hello"})
+        event_tracker.add_data({"var1": "world"})
+        single = event_tracker.get_data()["var1"]
+        assert single.expand_value is True
+        assert single.unique_set == {"h", "e", "l", "o", "w", "r", "d"}
+
+    def test_each_new_variable_gets_its_own_configured_tracker(self):
+        event_tracker = EventStabilityTracker(expand_value=True)
+        event_tracker.add_data({"a": "ab", "b": "cd"})
+        a = event_tracker.get_data()["a"]
+        b = event_tracker.get_data()["b"]
+        assert a.expand_value is True
+        assert b.expand_value is True
+        assert a.unique_set == {"a", "b"}
+        assert b.unique_set == {"c", "d"}
+
+    def test_post_load_new_variable_honors_expand_value(self):
+        """After dump/load, a variable that wasn't present at save time should
+        still use expand_value semantics when first ingested."""
+        original = EventStabilityTracker(expand_value=True)
+        original.add_data({"known": "abc"})
+        blob = original.dump()
+        restored = EventStabilityTracker.load(blob, expand_value=True)
+
+        # Ingest a brand-new variable not present in the saved state
+        restored.add_data({"known": "de", "newvar": "xy"})
+
+        new_tracker = restored.get_data()["newvar"]
+        assert new_tracker.expand_value is True
+        assert new_tracker.unique_set == {"x", "y"}
+
+        # And the existing variable continues to expand correctly
+        known_tracker = restored.get_data()["known"]
+        assert known_tracker.expand_value is True
+        assert {"a", "b", "c", "d", "e"} <= known_tracker.unique_set
+
+
+class TestSingleStabilityTrackerExtraState:
+    def test_extra_state_defaults_to_empty_dict(self):
+        tracker = SingleStabilityTracker()
+        assert tracker.extra_state == {}
+
+    def test_extra_state_round_trip(self):
+        tracker = SingleStabilityTracker()
+        tracker.add_value("hello")
+        tracker.extra_state["freq"] = {"a": {"b": 3, "c": 1}}
+        tracker.extra_state["total_freq"] = {"a": 4}
+        state = tracker.to_state()
+        restored = SingleStabilityTracker.from_state(state)
+        assert restored.extra_state == {
+            "freq": {"a": {"b": 3, "c": 1}},
+            "total_freq": {"a": 4},
+        }
+
+    def test_legacy_state_without_extra_state_defaults_empty(self):
+        tracker = SingleStabilityTracker()
+        tracker.add_value("hello")
+        state = tracker.to_state()
+        state.pop("extra_state", None)  # simulate pre-flag snapshot
+        restored = SingleStabilityTracker.from_state(state)
+        assert restored.extra_state == {}
+
+    def test_extra_state_round_trip_through_msgpack(self):
+        event_tracker = EventStabilityTracker()
+        event_tracker.add_data({"var1": "abc"})
+        single = event_tracker.get_data()["var1"]
+        single.extra_state["freq"] = {-1: {"a": 2}, "a": {"b": 1}}
+        single.extra_state["total_freq"] = {-1: 2, "a": 1}
+
+        blob = event_tracker.dump()
+        restored = EventStabilityTracker.load(blob)
+        r_single = restored.get_data()["var1"]
+        assert r_single.extra_state["freq"] == {-1: {"a": 2}, "a": {"b": 1}}
+        assert r_single.extra_state["total_freq"] == {-1: 2, "a": 1}
diff --git a/detectmatelibrary_tests/test_pipelines/__init__.py b/detectmatelibrary_tests/test_pipelines/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_pipelines/test_bad_players.py b/detectmatelibrary_tests/test_pipelines/test_bad_players.py
similarity index 96%
rename from tests/test_pipelines/test_bad_players.py
rename to detectmatelibrary_tests/test_pipelines/test_bad_players.py
index 27f21d82..42997f11 100644
--- a/tests/test_pipelines/test_bad_players.py
+++ b/detectmatelibrary_tests/test_pipelines/test_bad_players.py
@@ -25,7 +25,7 @@
     },
 }
 
-log_path = "tests/test_folder/logs.log"
+log_path = "detectmatelibrary_tests/test_folder/logs.log"
 
 
 class MockupBadParser(CoreParser):
diff --git a/tests/test_pipelines/test_basic_pipelines.py b/detectmatelibrary_tests/test_pipelines/test_basic_pipelines.py
similarity index 95%
rename from tests/test_pipelines/test_basic_pipelines.py
rename to detectmatelibrary_tests/test_pipelines/test_basic_pipelines.py
index 3632be2b..498d09b9 100644
--- a/tests/test_pipelines/test_basic_pipelines.py
+++ b/detectmatelibrary_tests/test_pipelines/test_basic_pipelines.py
@@ -44,7 +44,7 @@ def detect(self, input_, output_):
 }
 
 
-log_path = "tests/test_folder/logs.log"
+log_path = "detectmatelibrary_tests/test_folder/logs.log"
 
 
 class TestCaseBasicPipelines:
@@ -99,7 +99,7 @@ def test_batch_pipeline(self) -> None:
 
 class TestExamples:
     def test_config_example(self) -> None:
-        with open("tests/test_folder/test_config.yaml", 'r') as file:
+        with open("detectmatelibrary_tests/test_folder/test_config.yaml", 'r') as file:
             config = yaml.safe_load(file)
 
         # Nothing should crash
diff --git a/tests/test_pipelines/test_configuration_engine.py b/detectmatelibrary_tests/test_pipelines/test_configuration_engine.py
similarity index 90%
rename from tests/test_pipelines/test_configuration_engine.py
rename to detectmatelibrary_tests/test_pipelines/test_configuration_engine.py
index 875b489e..aeef5740 100644
--- a/tests/test_pipelines/test_configuration_engine.py
+++ b/detectmatelibrary_tests/test_pipelines/test_configuration_engine.py
@@ -2,12 +2,11 @@
 from detectmatelibrary.parsers.template_matcher import MatcherParser
 from detectmatelibrary.helper.from_to import From
 
-import pytest
 import json
 
-AUDIT_LOG = "tests/test_folder/audit.log"
-AUDIT_TEMPLATES = "tests/test_folder/audit_templates.txt"
-ANOMALY_LABELS = "tests/test_folder/audit_anomaly_labels.log"
+AUDIT_LOG = "detectmatelibrary_tests/test_folder/audit.log"
+AUDIT_TEMPLATES = "detectmatelibrary_tests/test_folder/audit_templates.txt"
+ANOMALY_LABELS = "detectmatelibrary_tests/test_folder/audit_anomaly_labels.log"
 LOG_FORMAT = "type=<Type> msg=audit(<Time>): <Content>"
 TRAIN_UNTIL = 1800
 
@@ -33,7 +32,6 @@ def load_expected_anomaly_ids() -> set[str]:
 
 class TestConfigurationEngineManual:
     """Mirrors the manual flow in 05_configuration_engine/detect.py."""
-    @pytest.mark.skip(reason="no way of currently testing this")
     def test_configure_train_detect(self) -> None:
         parser = MatcherParser(config=parser_config)
         detector = NewValueDetector()
@@ -60,7 +58,6 @@ def test_configure_train_detect(self) -> None:
 class TestConfigurationEngineAutomatic:
     """Tests the automated configure phase via process()."""
 
-    @pytest.mark.skip(reason="no way of currently testing this")
     def test_process_configure_train_detect(self) -> None:
         parser = MatcherParser(config=parser_config)
         config = NewValueDetectorConfig(data_use_configure=TRAIN_UNTIL)
diff --git a/tests/test_pipelines/test_dummy_methods.py b/detectmatelibrary_tests/test_pipelines/test_dummy_methods.py
similarity index 92%
rename from tests/test_pipelines/test_dummy_methods.py
rename to detectmatelibrary_tests/test_pipelines/test_dummy_methods.py
index cd89401f..f3148bc9 100644
--- a/tests/test_pipelines/test_dummy_methods.py
+++ b/detectmatelibrary_tests/test_pipelines/test_dummy_methods.py
@@ -1,6 +1,6 @@
 
-from detectmatelibrary.detectors.dummy_detector import DummyDetector, DummyDetectorConfig
-from detectmatelibrary.parsers.dummy_parser import DummyParser, DummyParserConfig
+from detectmatelibrary_tests.test_detectors.dummy_detector import DummyDetector, DummyDetectorConfig
+from detectmatelibrary_tests.test_parsers.dummy_parser import DummyParser, DummyParserConfig
 import detectmatelibrary.schemas as schemas
 
 
diff --git a/detectmatelibrary_tests/test_schemas/__init__.py b/detectmatelibrary_tests/test_schemas/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_schemas/test_default_values.py b/detectmatelibrary_tests/test_schemas/test_default_values.py
similarity index 100%
rename from tests/test_schemas/test_default_values.py
rename to detectmatelibrary_tests/test_schemas/test_default_values.py
diff --git a/tests/test_schemas/test_ops.py b/detectmatelibrary_tests/test_schemas/test_ops.py
similarity index 100%
rename from tests/test_schemas/test_ops.py
rename to detectmatelibrary_tests/test_schemas/test_ops.py
diff --git a/tests/test_schemas/test_schema_class.py b/detectmatelibrary_tests/test_schemas/test_schema_class.py
similarity index 100%
rename from tests/test_schemas/test_schema_class.py
rename to detectmatelibrary_tests/test_schemas/test_schema_class.py
diff --git a/detectmatelibrary_tests/test_utils/__init__.py b/detectmatelibrary_tests/test_utils/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_utils/test_aux.py b/detectmatelibrary_tests/test_utils/test_aux.py
similarity index 89%
rename from tests/test_utils/test_aux.py
rename to detectmatelibrary_tests/test_utils/test_aux.py
index 52c44660..6ef95456 100644
--- a/tests/test_utils/test_aux.py
+++ b/detectmatelibrary_tests/test_utils/test_aux.py
@@ -4,8 +4,6 @@
 from datetime import datetime
 from time import sleep
 
-import pytest
-
 
 class TestTimestamp:
     def test_test_mode(self) -> None:
@@ -16,7 +14,6 @@ def test_no_test_mode(self) -> None:
         time_test_mode(False)
         assert get_timestamp() != 0
 
-    @pytest.mark.skip(reason="This test is too slow")
     def test_get_timestamp(self) -> None:
         time = get_timestamp()
         sleep(1)
diff --git a/tests/test_utils/test_data_buffer.py b/detectmatelibrary_tests/test_utils/test_data_buffer.py
similarity index 100%
rename from tests/test_utils/test_data_buffer.py
rename to detectmatelibrary_tests/test_utils/test_data_buffer.py
diff --git a/tests/test_utils/test_data_normalizer.py b/detectmatelibrary_tests/test_utils/test_data_normalizer.py
similarity index 100%
rename from tests/test_utils/test_data_normalizer.py
rename to detectmatelibrary_tests/test_utils/test_data_normalizer.py
diff --git a/detectmatelibrary_tests/test_utils/test_events_seen.py b/detectmatelibrary_tests/test_utils/test_events_seen.py
new file mode 100644
index 00000000..62467e3d
--- /dev/null
+++ b/detectmatelibrary_tests/test_utils/test_events_seen.py
@@ -0,0 +1,66 @@
+"""Tests for EventPersistency.events_seen tracking."""
+
+from detectmatelibrary.utils.persistency.event_persistency import EventPersistency
+from detectmatelibrary.utils.persistency.event_data_structures.trackers import EventStabilityTracker
+
+
+class TestEventsSeen:
+    """Test that events_seen tracks all event IDs passed to ingest_event()."""
+
+    def setup_method(self) -> None:
+        self.persistency = EventPersistency(event_data_class=EventStabilityTracker)
+
+    def test_events_seen_recorded_on_early_return(self) -> None:
+        """Event ID is tracked even when variables are empty (early-return
+        path)."""
+        self.persistency.ingest_event(
+            event_id="E1",
+            event_template="some template",
+            variables=[],
+            named_variables={}
+        )
+        assert "E1" in self.persistency.get_events_seen()
+        assert "E1" not in self.persistency.get_events_data()
+
+    def test_events_seen_recorded_with_data(self) -> None:
+        """Event ID is tracked when variables are present."""
+        self.persistency.ingest_event(
+            event_id="E2",
+            event_template="some template",
+            named_variables={"status": "ok"}
+        )
+        assert "E2" in self.persistency.get_events_seen()
+        assert "E2" in self.persistency.get_events_data()
+
+    def test_events_seen_not_duplicated(self) -> None:
+        """Repeated calls for the same event ID produce a single entry."""
+        for _ in range(5):
+            self.persistency.ingest_event(
+                event_id=42,
+                event_template="t",
+                named_variables={"x": "v"}
+            )
+        assert len(self.persistency.get_events_seen()) == 1
+        assert 42 in self.persistency.get_events_seen()
+
+    def test_events_seen_tracks_multiple_ids(self) -> None:
+        """Multiple distinct event IDs are all tracked."""
+        for eid in [1, 2, 3]:
+            self.persistency.ingest_event(
+                event_id=eid,
+                event_template="t",
+                named_variables={"x": str(eid)}
+            )
+        assert self.persistency.get_events_seen() == {1, 2, 3}
+
+    def test_get_events_seen_returns_set(self) -> None:
+        """get_events_seen() returns a set."""
+        result = self.persistency.get_events_seen()
+        assert isinstance(result, set)
+
+    def test_events_seen_mixed_empty_and_nonempty(self) -> None:
+        """Events seen with and without data are both in events_seen."""
+        self.persistency.ingest_event(event_id=1, event_template="t")
+        self.persistency.ingest_event(event_id=2, event_template="t", named_variables={"k": "v"})
+        assert {1, 2} == self.persistency.get_events_seen()
+        assert set(self.persistency.get_events_data().keys()) == {2}
diff --git a/tests/test_utils/test_log_format_utils.py b/detectmatelibrary_tests/test_utils/test_log_format_utils.py
similarity index 100%
rename from tests/test_utils/test_log_format_utils.py
rename to detectmatelibrary_tests/test_utils/test_log_format_utils.py
diff --git a/tests/test_utils/test_persistency.py b/detectmatelibrary_tests/test_utils/test_persistency.py
similarity index 94%
rename from tests/test_utils/test_persistency.py
rename to detectmatelibrary_tests/test_utils/test_persistency.py
index 55af32b7..16a829aa 100644
--- a/tests/test_utils/test_persistency.py
+++ b/detectmatelibrary_tests/test_utils/test_persistency.py
@@ -461,3 +461,26 @@ def test_variable_blacklist_across_backends(self):
         assert "var_0" in data2.columns  # First variable
         assert "var_1" not in data2.columns  # Blacklisted
         assert "timestamp" not in data2.columns  # Blacklisted
+
+
+class TestEventPersistencyEventsSinceSave:
+    def test_events_since_save_starts_at_zero(self):
+        p = EventPersistency(event_data_class=EventDataFrame)
+        assert p._events_since_save == 0
+
+    def test_events_since_save_increments_on_ingest(self):
+        p = EventPersistency(event_data_class=EventDataFrame)
+        p.ingest_event(**SAMPLE_EVENT_1)
+        assert p._events_since_save == 1
+
+    def test_events_since_save_increments_for_no_variable_event(self):
+        p = EventPersistency(event_data_class=EventDataFrame)
+        p.ingest_event(event_id="E999", event_template="no vars")
+        assert p._events_since_save == 1
+
+    def test_reset_events_since_save(self):
+        p = EventPersistency(event_data_class=EventDataFrame)
+        p.ingest_event(**SAMPLE_EVENT_1)
+        p.ingest_event(**SAMPLE_EVENT_2)
+        p.reset_events_since_save()
+        assert p._events_since_save == 0
diff --git a/detectmatelibrary_tests/test_utils/test_persistency_dump_load.py b/detectmatelibrary_tests/test_utils/test_persistency_dump_load.py
new file mode 100644
index 00000000..b1655974
--- /dev/null
+++ b/detectmatelibrary_tests/test_utils/test_persistency_dump_load.py
@@ -0,0 +1,190 @@
+import pytest
+import pandas as pd
+import polars as pl
+from dataclasses import dataclass
+
+from detectmatelibrary.utils.persistency.persistency_saver import PersistencyLoadError
+from detectmatelibrary.utils.persistency.event_data_structures.base import (
+    EventDataStructure,
+)
+from detectmatelibrary.utils.persistency.event_data_structures.dataframes.event_dataframe import (
+    EventDataFrame,
+)
+from detectmatelibrary.utils.persistency.event_data_structures.dataframes.chunked_event_dataframe import (
+    ChunkedEventDataFrame,
+)
+from detectmatelibrary.utils.persistency.event_data_structures.trackers.stability.stability_tracker import (
+    SingleStabilityTracker,
+    EventStabilityTracker,
+)
+
+
+def test_persistency_load_error_is_exception():
+    err = PersistencyLoadError("test error")
+    assert isinstance(err, Exception)
+    assert str(err) == "test error"
+
+
+def test_event_data_structure_has_dump_load():
+    assert hasattr(EventDataStructure, "dump")
+    assert hasattr(EventDataStructure, "load")
+
+
+def test_subclass_without_dump_load_cannot_be_instantiated():
+    @dataclass
+    class _Incomplete(EventDataStructure):
+        def add_data(self, data_object): pass
+        def get_data(self): pass
+        def get_variables(self): pass
+        def to_data(self, raw_data): pass
+        # intentionally missing dump() and load()
+
+    with pytest.raises(TypeError):
+        _Incomplete()
+
+
+class TestSingleStabilityTrackerState:
+    def _make_tracker(self) -> SingleStabilityTracker:
+        t = SingleStabilityTracker(min_samples=3)
+        for v in ["a", "b", "a", "c", "a"]:
+            t.add_value(v)
+        return t
+
+    def test_round_trip_preserves_change_series(self):
+        t = self._make_tracker()
+        state = t.to_state()
+        t2 = SingleStabilityTracker.from_state(state)
+        assert list(t2.change_series) == list(t.change_series)
+
+    def test_round_trip_preserves_unique_set(self):
+        t = self._make_tracker()
+        state = t.to_state()
+        t2 = SingleStabilityTracker.from_state(state)
+        assert t2.unique_set == t.unique_set
+
+    def test_round_trip_preserves_min_samples(self):
+        t = self._make_tracker()
+        state = t.to_state()
+        t2 = SingleStabilityTracker.from_state(state)
+        assert t2.min_samples == 3
+
+    def test_round_trip_preserves_classification(self):
+        t = self._make_tracker()
+        state = t.to_state()
+        t2 = SingleStabilityTracker.from_state(state)
+        assert t2.classify().type == t.classify().type
+
+    def test_state_includes_type_and_module(self):
+        t = SingleStabilityTracker()
+        state = t.to_state()
+        assert state["type"] == "SingleStabilityTracker"
+        assert "module" in state
+
+    def test_empty_tracker_round_trip(self):
+        t = SingleStabilityTracker(min_samples=5)
+        state = t.to_state()
+        t2 = SingleStabilityTracker.from_state(state)
+        assert len(t2.change_series) == 0
+        assert len(t2.unique_set) == 0
+
+
+class TestEventTrackerDumpLoad:
+    def _make_tracker(self) -> EventStabilityTracker:
+        t = EventStabilityTracker()
+        for i in range(10):
+            t.add_data({"var_0": f"value_{i % 3}", "var_1": str(i)})
+        return t
+
+    def test_dump_returns_bytes(self):
+        t = self._make_tracker()
+        assert isinstance(t.dump(), bytes)
+
+    def test_round_trip_restores_tracker_keys(self):
+        t = self._make_tracker()
+        t2 = EventStabilityTracker.load(t.dump())
+        assert set(t2.get_data().keys()) == set(t.get_data().keys())
+
+    def test_round_trip_preserves_change_series(self):
+        t = self._make_tracker()
+        t2 = EventStabilityTracker.load(t.dump())
+        for key in t.get_data():
+            original = list(t.get_data()[key].change_series)
+            restored = list(t2.get_data()[key].change_series)
+            assert restored == original
+
+    def test_round_trip_preserves_unique_set(self):
+        t = self._make_tracker()
+        t2 = EventStabilityTracker.load(t.dump())
+        for key in t.get_data():
+            assert t2.get_data()[key].unique_set == t.get_data()[key].unique_set
+
+    def test_empty_tracker_round_trip(self):
+        t = EventStabilityTracker()
+        t2 = EventStabilityTracker.load(t.dump())
+        assert t2.get_data() == {}
+
+
+class TestEventDataFrameDumpLoad:
+    def _make_edf(self) -> EventDataFrame:
+        edf = EventDataFrame()
+        edf.add_data(edf.to_data({"user": "alice", "ip": "192.168.1.1"}))
+        edf.add_data(edf.to_data({"user": "bob",   "ip": "192.168.1.2"}))
+        return edf
+
+    def test_dump_returns_bytes(self):
+        assert isinstance(self._make_edf().dump(), bytes)
+
+    def test_round_trip_preserves_rows(self):
+        edf = self._make_edf()
+        edf2 = EventDataFrame.load(edf.dump())
+        assert len(edf2.get_data()) == 2
+
+    def test_round_trip_preserves_columns(self):
+        edf = self._make_edf()
+        edf2 = EventDataFrame.load(edf.dump())
+        assert list(edf2.get_data().columns) == ["user", "ip"]
+
+    def test_round_trip_preserves_values(self):
+        edf = self._make_edf()
+        edf2 = EventDataFrame.load(edf.dump())
+        assert edf2.get_data()["user"].tolist() == ["alice", "bob"]
+
+    def test_empty_dataframe_round_trip(self):
+        edf = EventDataFrame()
+        edf2 = EventDataFrame.load(edf.dump())
+        assert isinstance(edf2.get_data(), pd.DataFrame)
+        assert len(edf2.get_data()) == 0
+
+
+class TestChunkedEventDataFrameDumpLoad:
+    def _make_cedf(self) -> ChunkedEventDataFrame:
+        cedf = ChunkedEventDataFrame(max_rows=100, compact_every=1000)
+        for i in range(5):
+            cedf.add_data(cedf.to_data({"user": [f"user_{i}"], "val": [i]}))
+        return cedf
+
+    def test_dump_returns_bytes(self):
+        assert isinstance(self._make_cedf().dump(), bytes)
+
+    def test_round_trip_preserves_rows(self):
+        cedf = self._make_cedf()
+        cedf2 = ChunkedEventDataFrame.load(cedf.dump())
+        assert len(cedf2.get_data()) == 5
+
+    def test_round_trip_preserves_columns(self):
+        cedf = self._make_cedf()
+        cedf2 = ChunkedEventDataFrame.load(cedf.dump())
+        assert set(cedf2.get_data().columns) == {"user", "val"}
+
+    def test_round_trip_restores_config(self):
+        cedf = ChunkedEventDataFrame(max_rows=42, compact_every=7)
+        cedf.add_data(cedf.to_data({"x": [1]}))
+        cedf2 = ChunkedEventDataFrame.load(cedf.dump())
+        assert cedf2.max_rows == 42
+        assert cedf2.compact_every == 7
+
+    def test_empty_round_trip(self):
+        cedf = ChunkedEventDataFrame()
+        cedf2 = ChunkedEventDataFrame.load(cedf.dump())
+        assert isinstance(cedf2.get_data(), pl.DataFrame)
+        assert len(cedf2.get_data()) == 0
diff --git a/detectmatelibrary_tests/test_utils/test_persistency_saver.py b/detectmatelibrary_tests/test_utils/test_persistency_saver.py
new file mode 100644
index 00000000..f8aad6c7
--- /dev/null
+++ b/detectmatelibrary_tests/test_utils/test_persistency_saver.py
@@ -0,0 +1,278 @@
+import json
+import time
+import threading
+
+import fsspec
+import pytest
+
+from detectmatelibrary.utils.persistency.event_data_structures.dataframes import EventDataFrame
+from detectmatelibrary.utils.persistency.event_data_structures.trackers import EventStabilityTracker
+from detectmatelibrary.utils.persistency.event_persistency import EventPersistency
+from detectmatelibrary.utils.persistency.persistency_saver import (
+    PersistencySaverConfig,
+    PersistencyLoadError,
+    PersistencySaver,
+    _SaveTimer,
+)
+
+
+class TestPersistencySaverConfig:
+    def test_requires_path(self):
+        cfg = PersistencySaverConfig(path="file:///tmp/test")
+        assert cfg.path == "file:///tmp/test"
+
+    def test_defaults(self):
+        cfg = PersistencySaverConfig(path="file:///tmp/test")
+        assert cfg.save_interval_seconds == 300
+        assert cfg.events_until_save is None
+        assert cfg.auto_load is False
+        assert cfg.storage_options == {}
+
+
+class TestSaveTimer:
+    def test_callback_fires_after_interval(self):
+        fired = threading.Event()
+        timer = _SaveTimer(interval=0.05, callback=fired.set)
+        timer.start()
+        assert fired.wait(timeout=1.0), "callback did not fire"
+        timer.stop()
+        timer.join(timeout=1.0)
+
+    def test_stop_prevents_further_callbacks(self):
+        count = {"n": 0}
+
+        def inc():
+            count["n"] += 1
+
+        timer = _SaveTimer(interval=0.05, callback=inc)
+        timer.start()
+        time.sleep(0.12)
+        timer.stop()
+        timer.join(timeout=1.0)
+        captured = count["n"]
+        time.sleep(0.12)
+        assert count["n"] == captured  # no more fires after stop
+
+
+def _make_persistency_with_data() -> EventPersistency:
+    p = EventPersistency(event_data_class=EventDataFrame)
+    p.ingest_event(event_id="E1", event_template="User <*>", variables=["alice"], named_variables={})
+    p.ingest_event(event_id="E1", event_template="User <*>", variables=["bob"], named_variables={})
+    p.ingest_event(event_id="E2", event_template="Error <*>", variables=["timeout"], named_variables={})
+    return p
+
+
+def _memory_saver(path: str = "memory://test/state") -> tuple[PersistencySaver, EventPersistency]:
+    p = _make_persistency_with_data()
+    cfg = PersistencySaverConfig(path=path)
+    saver = PersistencySaver(p, cfg)
+    return saver, p
+
+
+class TestPersistencySaverSaveLoad:
+    def test_save_creates_metadata_json(self):
+        saver, _ = _memory_saver()
+        saver.save()
+        fs = fsspec.filesystem("memory")
+        assert fs.exists("test/state/metadata.json")
+
+    def test_save_creates_event_files(self):
+        saver, _ = _memory_saver()
+        saver.save()
+        fs = fsspec.filesystem("memory")
+        assert fs.exists("test/state/events/E1.parquet")
+        assert fs.exists("test/state/events/E2.parquet")
+
+    def test_metadata_contains_events_seen(self):
+        saver, _ = _memory_saver()
+        saver.save()
+        fs = fsspec.filesystem("memory")
+        with fs.open("test/state/metadata.json", "r") as f:
+            meta = json.load(f)
+        assert set(meta["events_seen"]) == {"E1", "E2"}
+
+    def test_save_resets_events_since_save(self):
+        saver, p = _memory_saver()
+        assert p._events_since_save == 3
+        saver.save()
+        assert p._events_since_save == 0
+
+    def test_load_restores_events_seen(self):
+        saver, _ = _memory_saver()
+        saver.save()
+
+        p2 = EventPersistency(event_data_class=EventDataFrame)
+        cfg = PersistencySaverConfig(path="memory://test/state")
+        saver2 = PersistencySaver(p2, cfg)
+        saver2.load()
+        assert "E1" in p2.get_events_seen()
+        assert "E2" in p2.get_events_seen()
+
+    def test_load_restores_event_data(self):
+        saver, _ = _memory_saver()
+        saver.save()
+
+        p2 = EventPersistency(event_data_class=EventDataFrame)
+        cfg = PersistencySaverConfig(path="memory://test/state")
+        PersistencySaver(p2, cfg).load()
+        assert len(p2.get_event_data("E1")) == 2
+
+    def test_load_restores_templates(self):
+        saver, _ = _memory_saver()
+        saver.save()
+
+        p2 = EventPersistency(event_data_class=EventDataFrame)
+        PersistencySaver(p2, PersistencySaverConfig(path="memory://test/state")).load()
+        assert p2.get_event_template("E1") == "User <*>"
+
+    def test_load_raises_on_missing_path(self):
+        p = EventPersistency(event_data_class=EventDataFrame)
+        saver = PersistencySaver(p, PersistencySaverConfig(path="memory://nonexistent/path"))
+        with pytest.raises(PersistencyLoadError):
+            saver.load()
+
+
+class TestPersistencySaverTriggers:
+    def test_timer_triggers_save(self):
+        p = _make_persistency_with_data()
+        cfg = PersistencySaverConfig(
+            path="memory://trigger_test/state",
+            save_interval_seconds=0,  # fire immediately
+        )
+        saver = PersistencySaver(p, cfg)
+        saver.start()
+        time.sleep(0.15)
+        saver.stop()
+        fs = fsspec.filesystem("memory")
+        assert fs.exists("trigger_test/state/metadata.json")
+
+    def test_timed_save_resets_events_since_save(self):
+        p = EventPersistency(event_data_class=EventDataFrame)
+        cfg = PersistencySaverConfig(
+            path="memory://dirty_test2/state",
+            save_interval_seconds=0,
+        )
+        saver = PersistencySaver(p, cfg)
+        saver.start()
+
+        p.ingest_event(event_id="E1", event_template="T", variables=["x"], named_variables={})
+        p.ingest_event(event_id="E1", event_template="T", variables=["y"], named_variables={})
+        time.sleep(0.15)
+        saver.stop()
+
+        assert p._events_since_save == 0  # save() was called by the timer, which resets the counter
+
+    def test_stop_does_final_save(self):
+        p = _make_persistency_with_data()
+        cfg = PersistencySaverConfig(
+            path="memory://stop_test/state",
+            save_interval_seconds=9999,
+        )
+        saver = PersistencySaver(p, cfg)
+        saver.start()
+        saver.stop()
+        fs = fsspec.filesystem("memory")
+        assert fs.exists("stop_test/state/metadata.json")
+
+    def test_events_until_save_triggers_save(self):
+        p = EventPersistency(event_data_class=EventDataFrame)
+        cfg = PersistencySaverConfig(
+            path="memory://events_count_test/state",
+            save_interval_seconds=9999,
+            events_until_save=3,
+        )
+        PersistencySaver(p, cfg)  # no start() needed — callback fires on ingest
+        for i in range(3):
+            p.ingest_event(event_id="E1", event_template="T", variables=[str(i)], named_variables={})
+        fs = fsspec.filesystem("memory")
+        assert fs.exists("events_count_test/state/metadata.json")
+
+    def test_events_until_save_no_save_before_threshold(self):
+        p = EventPersistency(event_data_class=EventDataFrame)
+        cfg = PersistencySaverConfig(
+            path="memory://events_count_test2/state",
+            save_interval_seconds=9999,
+            events_until_save=5,
+        )
+        PersistencySaver(p, cfg)
+        for i in range(4):
+            p.ingest_event(event_id="E1", event_template="T", variables=[str(i)], named_variables={})
+        fs = fsspec.filesystem("memory")
+        assert not fs.exists("events_count_test2/state/metadata.json")
+
+    def test_events_until_save_resets_counter_and_retrigggers(self):
+        p = EventPersistency(event_data_class=EventDataFrame)
+        cfg = PersistencySaverConfig(
+            path="memory://events_count_test3/state",
+            save_interval_seconds=9999,
+            events_until_save=2,
+        )
+        PersistencySaver(p, cfg)
+        for i in range(4):
+            p.ingest_event(event_id="E1", event_template="T", variables=[str(i)], named_variables={})
+        # counter should be 0 — two saves fired (at event 2 and event 4)
+        assert p._events_since_save == 0
+
+    def test_auto_load_on_init(self):
+        # First: save some state
+        p1 = _make_persistency_with_data()
+        PersistencySaver(p1, PersistencySaverConfig(path="memory://autoload/state")).save()
+
+        # Then: create new persistency with auto_load=True
+        p2 = EventPersistency(event_data_class=EventDataFrame)
+        PersistencySaver(p2, PersistencySaverConfig(path="memory://autoload/state", auto_load=True))
+        assert "E1" in p2.get_events_seen()
+
+
+class TestPersistencySaverIntegration:
+    def test_full_cycle_dataframe_backend(self):
+        """Train → save → restore → verify data identical."""
+        p1 = EventPersistency(event_data_class=EventDataFrame)
+        for i in range(20):
+            p1.ingest_event(
+                event_id=f"E{i % 3}",
+                event_template=f"Template {i % 3}",
+                variables=[f"val_{i}"],
+                named_variables={},
+            )
+
+        saver1 = PersistencySaver(p1, PersistencySaverConfig(path="memory://integration/df"))
+        saver1.save()
+
+        p2 = EventPersistency(event_data_class=EventDataFrame)
+        PersistencySaver(p2, PersistencySaverConfig(path="memory://integration/df")).load()
+
+        assert p2.get_events_seen() == p1.get_events_seen()
+        assert p2.get_event_templates() == p1.get_event_templates()
+        for eid in p1.get_events_data():
+            original = p1.get_event_data(eid)
+            restored = p2.get_event_data(eid)
+            assert len(restored) == len(original)
+            assert list(restored.columns) == list(original.columns)
+            assert list(restored["var_0"]) == list(original["var_0"])
+
+    def test_full_cycle_tracker_backend(self):
+        """Train → save → restore → verify tracker state identical."""
+        p1 = EventPersistency(event_data_class=EventStabilityTracker)
+        for i in range(30):
+            p1.ingest_event(
+                event_id="E1",
+                event_template="Tmpl",
+                variables=[f"v_{i % 5}"],
+                named_variables={},
+            )
+
+        saver1 = PersistencySaver(p1, PersistencySaverConfig(path="memory://integration/tracker"))
+        saver1.save()
+
+        p2 = EventPersistency(event_data_class=EventStabilityTracker)
+        PersistencySaver(p2, PersistencySaverConfig(path="memory://integration/tracker")).load()
+
+        original_tracker = p1.get_events_data()["E1"]
+        restored_tracker = p2.get_events_data()["E1"]
+
+        for var_name in original_tracker.get_variables():
+            orig = original_tracker.get_data()[var_name]
+            rest = restored_tracker.get_data()[var_name]
+            assert list(rest.change_series) == list(orig.change_series)
+            assert rest.unique_set == orig.unique_set
diff --git a/tests/test_utils/test_stability_tracking.py b/detectmatelibrary_tests/test_utils/test_stability_tracking.py
similarity index 98%
rename from tests/test_utils/test_stability_tracking.py
rename to detectmatelibrary_tests/test_utils/test_stability_tracking.py
index 1b92a8d1..3da95205 100644
--- a/tests/test_utils/test_stability_tracking.py
+++ b/detectmatelibrary_tests/test_utils/test_stability_tracking.py
@@ -12,7 +12,7 @@
     EventStabilityTracker,
     Classification,
 )
-from detectmatelibrary.utils.RLE_list import RLEList
+from detectmatelibrary.utils.persistency.rle_list import RLEList
 
 
 class TestStabilityClassifier:
@@ -290,7 +290,7 @@ def test_get_stable_variables(self):
                 "random_var": f"unique_{i}",
             })
 
-        stable_vars = trackers.get_variables_by_classification("STABLE")
+        stable_vars = trackers.get_features_by_classification("STABLE")
         assert isinstance(stable_vars, list)
         # "stable_var" should be classified as STATIC
 
@@ -360,7 +360,7 @@ def test_get_stable_variables(self):
                 "random_var": f"unique_{i}",
             })
 
-        stable_vars = evt.get_variables_by_classification("STABLE")
+        stable_vars = evt.get_features_by_classification("STABLE")
         assert isinstance(stable_vars, list)
 
     def test_integration_with_stability_tracker(self):
@@ -377,7 +377,7 @@ def test_integration_with_stability_tracker(self):
 
         # Get data and variables
         var_names = evt.get_variables()
-        stable_vars = evt.get_variables_by_classification("STABLE")
+        stable_vars = evt.get_features_by_classification("STABLE")
 
         assert len(var_names) == 3
         assert isinstance(stable_vars, list)
@@ -529,7 +529,7 @@ def test_event_variable_tracker_real_world_scenario(self):
             })
 
         var_names = evt.get_variables()
-        stable_vars = evt.get_variables_by_classification("STABLE")
+        stable_vars = evt.get_features_by_classification("STABLE")
 
         assert len(var_names) == 5
         assert isinstance(stable_vars, list)
diff --git a/detectmatelibrary_tests/test_workspace/__init__.py b/detectmatelibrary_tests/test_workspace/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_workspace/test_create_workspace.py b/detectmatelibrary_tests/test_workspace/test_create_workspace.py
similarity index 94%
rename from tests/test_workspace/test_create_workspace.py
rename to detectmatelibrary_tests/test_workspace/test_create_workspace.py
index 189a0507..b0642478 100644
--- a/tests/test_workspace/test_create_workspace.py
+++ b/detectmatelibrary_tests/test_workspace/test_create_workspace.py
@@ -3,7 +3,7 @@
 import subprocess
 import pytest
 from pathlib import Path
-from tools.workspace.utils import normalize_package_name
+from detectmatelibrary_tools.workspace.utils import normalize_package_name
 
 
 # Path to the CLI entry point
@@ -22,7 +22,7 @@ def test_create_parser_workspace(temp_dir: Path):
     pkg_name = normalize_package_name(ws_name)  # myparser
     module_name = normalize_package_name(ws_name)  # myparser
     pkg_dir = workspace_root / pkg_name
-    tests_dir = workspace_root / "tests"
+    tests_dir = workspace_root / "detectmatelibrary_tests"
 
     # Run the CLI tool
     subprocess.check_call([
@@ -61,7 +61,7 @@ def test_create_detector_workspace(temp_dir: Path):
     pkg_name = normalize_package_name(ws_name)  # mydetector
     module_name = normalize_package_name(ws_name)  # mydetector
     pkg_dir = workspace_root / pkg_name
-    tests_dir = workspace_root / "tests"
+    tests_dir = workspace_root / "detectmatelibrary_tests"
 
     subprocess.check_call([
         *CLI,
@@ -93,7 +93,7 @@ def test_create_workspace_with_dash_name(temp_dir: Path):
     pkg_name = normalize_package_name(ws_name)  # custom_parser
     module_name = normalize_package_name(ws_name)  # custom_parser
     pkg_dir = workspace_root / pkg_name
-    tests_dir = workspace_root / "tests"
+    tests_dir = workspace_root / "detectmatelibrary_tests"
     test_file = tests_dir / f"test_{ws_name}.py"
 
     subprocess.check_call([
@@ -144,7 +144,7 @@ def test_generated_detector_tests_pass(temp_dir: Path):
     ws_name = "MyCoolThing"
     workspace_root = temp_dir
     pkg_dir = workspace_root / "mycoolthing"
-    tests_dir = workspace_root / "tests"
+    tests_dir = workspace_root / "detectmatelibrary_tests"
     test_file = tests_dir / f"test_{ws_name}.py"
 
     subprocess.check_call([
@@ -178,7 +178,7 @@ def test_generated_parser_tests_pass(temp_dir: Path):
     ws_name = "MyCoolParser"
     workspace_root = temp_dir
     pkg_dir = workspace_root / "mycoolparser"
-    tests_dir = workspace_root / "tests"
+    tests_dir = workspace_root / "detectmatelibrary_tests"
     test_file = tests_dir / f"test_{ws_name}.py"
 
     subprocess.check_call([
diff --git a/tests/test_workspace/test_utils.py b/detectmatelibrary_tests/test_workspace/test_utils.py
similarity index 89%
rename from tests/test_workspace/test_utils.py
rename to detectmatelibrary_tests/test_workspace/test_utils.py
index 8804c3df..de64cf55 100644
--- a/tests/test_workspace/test_utils.py
+++ b/detectmatelibrary_tests/test_workspace/test_utils.py
@@ -1,5 +1,5 @@
 import pytest
-from tools.workspace.utils import normalize_package_name
+from detectmatelibrary_tools.workspace.utils import normalize_package_name
 
 
 @pytest.mark.parametrize("input_name, expected", [
diff --git a/docs/auxiliar/persistency.md b/docs/auxiliar/persistency.md
index 6adc9342..2b8764c8 100644
--- a/docs/auxiliar/persistency.md
+++ b/docs/auxiliar/persistency.md
@@ -1,127 +1,197 @@
 # Persistency
 
-The persistency module provides event-based state management for detectors. It allows detectors to accumulate, store, and query data across their lifecycle — during training, detection, and auto-configuration.
+The persistency module gives a detector a place to remember things about the
+events it sees. State is keyed by `EventID` and survives across training, the
+detection loop, and (optionally) restarts on disk.
 
-## EventPersistency
+This page is structured to read top-to-bottom: first the mental model, then a
+quick start, then the API surface.
 
-`EventPersistency` is the main entry point. It manages one storage backend instance per event ID, so each event type maintains its own isolated state.
+## Mental model
 
-### Creating an instance
+Persistency has three moving parts. Understanding what each one does makes the
+rest of the page much easier to follow.
 
-```python
-from detectmatelibrary.common.persistency import EventPersistency
+### 1. Events
 
-persistency = EventPersistency(
-    event_data_class=MyBackend,          # storage backend class (see below)
-    variable_blacklist=["Content"],      # variable names to exclude (optional)
-    event_data_kwargs={"max_rows": 1000} # extra kwargs forwarded to the backend (optional)
-)
-```
+Logs are grouped by `EventID`. Two events with the same ID share a template
+but have their own variable values. Persistency stores **one independent state
+object per event ID**, so an `EventStabilityTracker` for `EventID=4733` does
+not interfere with one for `EventID=4624`.
 
-| Parameter | Description |
-|---|---|
-| `event_data_class` | An `EventDataStructure` subclass that defines how data is stored and queried. |
-| `variable_blacklist` | Variable names to exclude from storage. Defaults to `["Content"]`. |
-| `event_data_kwargs` | A dictionary of keyword arguments forwarded to the backend constructor. |
+### 2. Backends (`EventDataStructure`)
+
+A backend is the thing that actually stores the per-event state. Persistency
+owns the dict `{event_id: backend}`; the backend itself decides *how* data is
+kept.
+
+Two families ship today:
+
+- **DataFrame backends** (`EventDataFrame`, `ChunkedEventDataFrame`) keeps the
+  raw rows. Very storage heavy and not recommended for production-ready detectors.
+- **Tracker backends** (`EventStabilityTracker`) keep only derived features
+  (e.g. "this variable has been constant for the last 10k events"). Use these
+  when you only need a summary, not the raw history — they cost a fraction of
+  the memory.
+
+All backends implement the same four-method contract: `add_data`, `get_data`,
+`dump`, `load`. That contract is what `EventPersistency` and
+`PersistencySaver` rely on — anything you add later only has to follow it.
+
+### 3. Saver lifecycle (`PersistencySaver`)
 
-### Storing data
+`EventPersistency` itself is in-memory. To survive a process restart, the
+state has to be written somewhere. `PersistencySaver` wraps an
+`EventPersistency` and:
+
+- writes to disk (or any `fsspec` URI) on two triggers — a wall-clock interval
+  and an event-count threshold;
+- optionally `auto_load`s previously saved state during construction;
+- exposes `start()` / `stop()` so the background timer can be torn down
+  cleanly. `stop()` is idempotent and is called automatically when a
+  `Component` is used as a context manager.
+
+In practice a detector never instantiates `PersistencySaver` directly: it sets
+a `persist:` block in its config and `CoreDetector` wires the saver up via
+[`init_persistency`](../../src/detectmatelibrary/common/persist.py).
+
+---
+
+## Quick start
 
 ```python
-persistency.ingest_event(
-    event_id=event_id,
-    event_template=template,
-    variables=positional_vars,        # optional positional variables
-    named_variables=named_vars        # optional named variables
+from detectmatelibrary.utils import persistency
+
+ep = persistency.EventPersistency(
+    event_data_class=persistency.EventStabilityTracker,
 )
+
+ep.ingest_event(
+    event_id="4624",
+    event_template="An account was successfully logged on.",
+    named_variables={"AccountName": "alice", "LogonType": "3"},
+)
+
+tracker = ep.get_event_data("4624")  # or ep["4624"]
 ```
 
-Each call appends data to the backend associated with the given `event_id`. If no backend exists for that ID yet, one is created automatically.
+That snippet covers the whole in-memory API: pick a backend class, ingest
+events, query state.
 
-### Retrieving data
+---
 
-```python
-# Single event
-data = persistency.get_event_data(event_id)
+## API reference
 
-# All events
-all_data = persistency.get_events_data()  # dict[event_id -> backend]
+### `EventPersistency`
 
-# Templates
-template = persistency.get_event_template(event_id)
-all_templates = persistency.get_event_templates()
+| Parameter | Description |
+|---|---|
+| `event_data_class` | An `EventDataStructure` subclass; one instance is created per event ID. |
+| `variable_blacklist` | Variable names to skip when ingesting. Defaults to `["Content"]`. |
+| `event_data_kwargs` | Extra kwargs forwarded to each backend instance. |
 
-# Bracket access
-backend = persistency[event_id]
-```
+Common methods:
 
-## Storage backends
+```python
+ep.ingest_event(event_id, event_template, variables=..., named_variables=...)
+
+ep.get_event_data(event_id)        # backend for a single event
+ep.get_events_data()               # dict[event_id -> backend]
+ep.get_event_template(event_id)
+ep.get_event_templates()
+ep.get_events_seen()               # all event IDs ever ingested
+ep[event_id]                       # alias for get_event_data
+```
 
-The backend determines how ingested data is stored and what queries are available. Choose the backend that fits your detector's needs.
+### Available backends
 
-### DataFrame backends
+| Class | Use when |
+|---|---|
+| `persistency.EventDataFrame` | You need history and a Pandas DataFrame is the natural shape. |
+| `persistency.ChunkedEventDataFrame` | High-volume / streaming workloads — Polars-backed with row-retention and automatic compaction. |
+| `persistency.EventStabilityTracker` | You only care about how variables behave over time (`STATIC` / `STABLE` / `UNSTABLE` / `RANDOM`). Cheapest memory footprint. |
 
-Store raw event data in tabular form. Useful when a detector needs to query or iterate over historical values.
+All three are re-exported from the top of the package — `persistency.X` is the
+canonical import; the deeply nested submodules are an implementation detail.
 
-- **`EventDataFrame`** — Pandas-backed storage. Simple and familiar.
-- **`ChunkedEventDataFrame`** — Polars-backed storage with configurable row retention and automatic compaction. Suited for high-volume or streaming workloads.
+### Persisting to disk
 
 ```python
-from detectmatelibrary.common.persistency.event_data_structures.dataframes import (
-    EventDataFrame,
-    ChunkedEventDataFrame,
+saver = persistency.PersistencySaver(
+    ep,
+    persistency.PersistencySaverConfig(
+        path="./state/my-detector",
+        save_interval_seconds=300,
+        events_until_save=10_000,     # save after this many ingests, too
+        auto_load=False,
+        storage_options={},           # forwarded to fsspec
+    ),
 )
+saver.start()
+# ... detector runs ...
+saver.stop()    # final flush, stops the background timer
 ```
 
-### Tracker backends
-
-Track variable behavior over time rather than storing raw data. Useful when a detector needs to understand how variables evolve (e.g., whether they converge to constant values). Is optimized for space efficiency since only extracted features from the logs are stored.
+`PersistencySaver.save()` is thread-safe, and `stop()` is idempotent. The two
+save triggers (`save_interval_seconds` and `events_until_save`) are
+independent — whichever fires first wins.
 
-- **`EventStabilityTracker`** — Classifies each variable as `STATIC`, `STABLE`, `UNSTABLE`, `RANDOM`, or `INSUFFICIENT_DATA` based on how its values change over time.
+#### Restoring state
 
 ```python
-from detectmatelibrary.common.persistency.event_data_structures.trackers import (
-    EventStabilityTracker,
+saver = persistency.PersistencySaver(
+    ep,
+    persistency.PersistencySaverConfig(path="./state/my-detector", auto_load=True),
 )
+# ep is now pre-populated from disk
 ```
 
-## Usage in detectors
+If `auto_load=True` and no saved state exists, the constructor raises
+`persistency.PersistencyLoadError` immediately — fail-fast rather than
+silently starting empty.
 
-Persistency is **optional**. A detector can function without it. When a detector does need to maintain state across events — for example, to learn normal values during training and flag deviations during detection — it can integrate persistency by following this pattern:
+### Storage backends (fsspec)
 
-### 1. Initialize in `__init__`
+`PersistencySaverConfig.path` accepts any URI fsspec understands: a local path
+(`./state`), `s3://bucket/key`, `gs://...`, `az://...`, and so on. Provider
+credentials and tuning knobs go in `storage_options`.
 
-Create one or more `EventPersistency` instances with the appropriate backend.
+---
 
-```python
-class MyDetector(CoreDetector):
-    def __init__(self, name="MyDetector", config=MyDetectorConfig()):
-        super().__init__(name=name, ...)
-        self.persistency = EventPersistency(
-            event_data_class=EventStabilityTracker,
-        )
-```
+## Using persistency inside a detector
 
-### 2. Accumulate state in `train()`
+The recommended path: declare `persist:` in the detector's config and let
+`CoreDetector._register_persistency` build the saver for you. See
+[Saving state (persist)](../detectors.md#saving-state-persist) for the config
+schema.
 
-During training, ingest each event so the backend builds up its internal state.
+In detector code, the pattern is:
 
 ```python
-def train(self, input_):
-    variables = self.get_configured_variables(input_, self.config.events)
-    self.persistency.ingest_event(
-        event_id=input_["EventID"],
-        event_template=input_["template"],
-        named_variables=variables,
-    )
-```
+from detectmatelibrary.common.detector import CoreDetector
+from detectmatelibrary.utils import persistency
 
-### 3. Query state in `detect()`
+class MyDetector(CoreDetector):
+    def __init__(self, name="MyDetector", config=MyDetectorConfig()):
+        super().__init__(name=name, config=config)
+        self.persistency = persistency.EventPersistency(
+            event_data_class=persistency.EventStabilityTracker,
+        )
+        self._register_persistency(self.persistency)
 
-During detection, query the accumulated state to decide whether the incoming event is anomalous.
+    def train(self, input_):
+        self.persistency.ingest_event(
+            event_id=input_["EventID"],
+            event_template=input_["template"],
+            named_variables={...},
+        )
 
-```python
-def detect(self, input_, output_):
-    for event_id, backend in self.persistency.get_events_data().items():
-        stored_data = backend.get_data()
-        # compare input_ against stored_data to produce alerts
+    def detect(self, input_, output_):
+        tracker = self.persistency.get_events_data().get(input_["EventID"])
+        # compare against tracker to produce alerts
 ```
+
+`_register_persistency` is a one-line wrapper around
+[`init_persistency`](../../src/detectmatelibrary/common/persist.py); the helper
+honours `config.persist` and returns `None` (so `self.saver` stays `None`)
+when persistence is disabled.
diff --git a/docs/basic_idea.md b/docs/basic_idea.md
new file mode 100644
index 00000000..bffbc397
--- /dev/null
+++ b/docs/basic_idea.md
@@ -0,0 +1,66 @@
+# Basic Concepts
+
+DetectMateLibrary is a collection of utilities for detecting anomalies in system logs. This short tutorial explains the core concepts you need to get started.
+
+## What is a log?
+
+Logs are messages produced by logging statements in code that describe events or states during execution.
+
+Example code that produces a log:
+
+```python
+import logging
+
+var1 = "DetectMate getting started"
+var2 = "what is a log"
+
+logging.info(f"hello I am a log about {var1} and about {var2}")
+```
+
+This produces the message:
+
+```
+hello I am a log about DetectMate getting started and about what is a log
+```
+
+A log message can be split into a constant part (the template) and variable parts, for example:
+
+- Template: `hello I am a log about <*> and about <*>`
+- Variables: `["DetectMate getting started", "what is a log"]`
+
+Logs often include a prefix with metadata, such as time stamp, log level, or hostnamem, for example:
+
+```
+INFO [18-05-2005] hello I am a log about DetectMate getting started and about what is a log
+```
+
+To extract the metadata we define a log format. For the example above this would be:
+
+```
+<Level> [<Time>] <Content>
+```
+
+Using that format we can separate the message into the components log level `Level`, time stamp `Time`, and log message `Message`:
+
+- Level: `INFO`
+- Time: `18-05-2005`
+- Message: `hello I am a log about DetectMate getting started and about what is a log`
+
+## What is a parsed log?
+
+A parsed log is a log that has been decomposed into structured fields. Based on the example above:
+
+- log_format: `<Level> [<Time>] <Content>`
+- template: `hello I am a log about <*> and about <*>`
+
+A parsed log would contain fields like:
+
+| Field              | Value                                                                 |
+|--------------------|-----------------------------------------------------------------------|
+| Template           | `hello I am a log about <*> and about <*>`                            |
+| Variables          | `["DetectMate getting started", "what is a log"]`                     |
+| LogFormatVariables | `{"Level": "INFO", "Time": "18-05-2005"}`                              |
+
+Parsed logs expose structured data that downstream detection components use for anomaly detection.
+
+Go back to [Index](index.md)
diff --git a/docs/contribution.md b/docs/contribution.md
new file mode 100644
index 00000000..395929b7
--- /dev/null
+++ b/docs/contribution.md
@@ -0,0 +1,122 @@
+# Contributing
+
+We're happily taking patches and other contributions. Below is a summary of the processes we follow for any contribution.
+
+## Bug reports and enhancement requests
+
+Bug reports and enhancement requests are an important part of making `DetectMateLibrary` more stable and are curated through Github issues.
+Before reporting an issue, check our backlog of open issues to see if anybody else has already reported it.
+If that is the case, you might be able to give additional information on that issue.
+Bug reports are very helpful to us in improving the software, and therefore, they are very welcome. It is very important to give us
+at least the following information in a bug report:
+
+1. Description of the bug. Describe the problem clearly.
+2. Steps to reproduce. With the following configuration, go to.., click.., see error
+3. Expected behavoir. What should happen?
+4. Environment. What was the environment for the test(version, browser, etc..)
+
+*Please don't include any private/sensitive information in your issue! For reporting security-related issues, see [SECURITY.md](https://github.com/ait-detectmate/DetectMateLibrary/blob/main/SECURITY.md)*
+
+## Working on the codebase
+
+To contribute to this project, you must fork the project and create a pull request to the upstream repository.
+
+### 1. Fork
+
+Go to [https://github.com/ait-detectmate/DetectMateLibrary.git](https://github.com/ait-detectmate/DetectMateLibrary.git) and click on fork. Please note that you must login first to GitHub.
+
+### 2. Clone
+
+After forking the repository into your own workspace, clone the development branch of that repository.
+
+```bash
+git clone -b development git@github.com:YOURUSERNAME/DetectMateLibrary.git
+```
+
+### 3. Create a feature branch
+
+Every single workpackage should be developed in it's own feature-branch. Use a name that describes the feature:
+
+```bash
+cd DetectMateLibrary
+git checkout -b feature-some_important_work
+```
+
+### 4. Develop your feature and improvements in the feature-branch
+
+Please make sure that you commit only improvements that are related to the workpage you created the feature-branch for.
+
+### 5. Fetch and merge from the upstream
+
+If your work on this feature-branch is done, make sure that you are in sync with the branch of the upstream:
+
+```bash
+git remote add upstream git@github.com:ait-detectmate/DetectMateLibrary.git
+git pull upstream development
+```
+
+If any conflicts occur, fix them and add them using `git add` and continue with the merge or fast-forward.
+
+Additional infos:
+
+- [https://www.atlassian.com/git/tutorials/merging-vs-rebasing](https://www.atlassian.com/git/tutorials/merging-vs-rebasing)
+- [https://www.atlassian.com/git/tutorials/merging-vs-rebasing#the-golden-rule-of-rebasing](https://www.atlassian.com/git/tutorials/merging-vs-rebasing#the-golden-rule-of-rebasing)
+- [https://dev.to/toogoodyshoes/mastering-rebasing-and-fast-forwarding-in-git-2j19](https://dev.to/toogoodyshoes/mastering-rebasing-and-fast-forwarding-in-git-2j19)
+
+### 6. Push the changes to your GitHub-repository
+
+Before we can push our changes, we have to make sure that we don't have unnecessary commits. First checkout our commits:
+
+```bash
+git log
+```
+
+After that we can squash the last n commits together:
+
+```bash
+git rebase -i HEAD~n
+```
+
+Finally you can push the changes to YOUR github-repository:
+
+```bash
+git push
+```
+
+Additional documentation:
+
+- [https://www.atlassian.com/git/tutorials/merging-vs-rebasing](https://www.atlassian.com/git/tutorials/merging-vs-rebasing)
+
+### 7. Submit your pull-request
+
+Use the GitHub-Webinterface to create a pull-request. Make sure that the target-repository is `ait-detectmate/DetectMateLibrary`.
+
+If your pull-request was accepted and merged into the development branch continue with "8. Update your local development branch". If it wasn't accepted, read the comments and fix the problems. Before pushing the changes make sure that you squashed them with your last commit:
+
+```bash
+git rebase -i HEAD~2
+```
+
+Delete your local feature-branch after the pull-request was merged into the development branch.
+
+### 8. Update your local main branch
+
+Update your local development branch:
+
+```bash
+git fetch upstream development
+git checkout -b development
+git rebase upstream/development
+```
+
+Additional infos:
+
+- [https://www.atlassian.com/git/tutorials/merging-vs-rebasing](https://www.atlassian.com/git/tutorials/merging-vs-rebasing)
+
+### 9. Update your main branch in your github-repository
+
+Please make sure that you updated your local development branch as described in section 8. above. After that push the changes to your github-repository to keep it up2date:
+
+```bash
+git push
+```
diff --git a/docs/detectors.md b/docs/detectors.md
index 3366ab76..dfc75287 100644
--- a/docs/detectors.md
+++ b/docs/detectors.md
@@ -87,10 +87,15 @@ List of detectors:
 * [Random detector](detectors/random_detector.md): Generates random alerts.
 * [New Value](detectors/new_value.md): Detect new values in the variables in the logs.
 * [Combo Detector](detectors/combo.md): Detect new combination of variables in the logs.
+* [New Event](detectors/new_event.md): Detect new events in the variables in the logs.
+* [Value Range](...): Detect numeric value ranges in variables in the logs.
+* [Rule Based](detectors/rule_based.md): Detect anomalies based in a set of rules.
+* [Bigram Frequency](detectors/bigram_frequency.md): Detect bigram-frequency-based anomalies in the logs.
+* [Charset](detectors/charset.md): Detect new characters in the variables in the logs.
 
 ## Configuration
 
-When `auto_config` is set to `False`, the detector expects an explicit `events` block that specifies exactly which variables to monitor:
+When `auto_config` is set to `False`, the detector expects an explicit `events` or `global` block that specifies exactly which variables to monitor. `events`refers to event-specific variables while `global` refers to variables, that are not bound to events (`header_variables`can but don't have to be event bound):
 
 ```yaml
 detectors:
@@ -116,7 +121,9 @@ detectors:
 
 ### Configuration semantics (preliminary)
 
-**`events` key** — The integer key is the `EventID` (or `event_id`) to monitor (see the MatcherParser docs for how EventID is assigned).
+**`events` key** — The integer key is the `EventID` (or `event_id`) to monitor (see the [Template Matcher](parsers/template_matcher.md) docs for how the EventID is assigned.
+
+**`global` key** - This one has a similar functionality as the `events` key but refers to variables, that are not bound to events (thus can only contain `header_variables`).
 
 **`variables[].pos`** — The 0-indexed position of the `<*>` wildcard in the matched template, counting from left to right starting at 0. For example, given:
 
@@ -192,7 +199,7 @@ The `set_configuration()` method queries the tracker results and generates the f
 def set_configuration(self):
     variables = {}
     for event_id, tracker in self.auto_conf_persistency.get_events_data().items():
-        stable_vars = tracker.get_variables_by_classification("STABLE")
+        stable_vars = tracker.get_features_by_classification("STABLE")
         variables[event_id] = stable_vars
 
     config_dict = generate_detector_config(
@@ -215,4 +222,95 @@ def set_configuration(self):
 When `auto_config` is `False`, steps 1 and 2 are skipped entirely.
 
 
+### Saving state (persist)
+
+Detectors can persist their training state to disk (or cloud storage) so it
+can be restored in a later session. Configure this with a top-level `persist:`
+block in the detector config:
+
+```yaml
+detectors:
+  NewValueDetector:
+    method_type: new_value_detector
+    persist:
+      path: ./state               # base path; detector name is appended automatically
+      interval_seconds: 300       # save every N seconds (default: 300)
+      events_until_save: null     # also save after N ingested events (default: disabled)
+      auto_load: false            # restore saved state on startup (default: false)
+      storage_options: {}         # backend credentials (see below)
+    events:
+      ...
+```
+
+All fields are optional — `persist: {}` uses all defaults. Omitting `persist:` entirely
+disables saving (backward compatible).
+
+The detector name is automatically appended to `path`, so `path: ./state` for a detector
+named `NewValueDetector` writes to `./state/NewValueDetector/`.
+
+#### Fields
+
+| Field | Type | Default | Description |
+|---|---|---|---|
+| `path` | `str` | `"./state"` | Base directory or cloud URL. Detector name is appended. |
+| `interval_seconds` | `int` | `300` | Background save interval in seconds. |
+| `events_until_save` | `int \| null` | `null` | Save after this many ingested events. `null` disables event-count triggering. |
+| `auto_load` | `bool` | `false` | Load saved state on construction. Raises `PersistencyLoadError` if no state exists. |
+| `storage_options` | `dict` | `{}` | Credentials and options forwarded to [fsspec](https://filesystem-spec.readthedocs.io/). |
+
+#### Storage options examples
+
+**Local filesystem** — no `storage_options` needed:
+
+```yaml
+persist:
+  path: ./state
+```
+
+**S3**:
+
+```yaml
+persist:
+  path: s3://my-bucket/detector-state
+  storage_options:
+    key: AKIAIOSFODNN7EXAMPLE
+    secret: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+    region_name: eu-west-1
+```
+
+S3-compatible storage (MinIO, etc.):
+
+```yaml
+persist:
+  path: s3://my-bucket/detector-state
+  storage_options:
+    endpoint_url: http://minio:9000
+    key: minioadmin
+    secret: minioadmin
+```
+
+**Azure Blob Storage**:
+
+```yaml
+persist:
+  path: az://my-container/detector-state
+  storage_options:
+    account_name: mystorageaccount
+    account_key: base64encodedkey==
+```
+
+**GCS**:
+
+```yaml
+persist:
+  path: gs://my-bucket/detector-state
+  storage_options:
+    project: my-gcp-project
+    token: /path/to/service-account.json
+```
+
+In practice, credentials are usually supplied via environment variables
+(`AWS_ACCESS_KEY_ID`, etc.) or instance roles — in which case `storage_options`
+stays empty or is omitted.
+
 Go back [Index](index.md)
diff --git a/docs/detectors/bigram_frequency.md b/docs/detectors/bigram_frequency.md
new file mode 100644
index 00000000..4e6099f9
--- /dev/null
+++ b/docs/detectors/bigram_frequency.md
@@ -0,0 +1,62 @@
+# Bigram Frequency Detector
+
+The Bigram Frequency Detector raises alerts when a variable's character bigrams (pairs of adjacent characters) appear improbable under a learned per-variable bigram frequency model. Optionally, an English-language bigram table can be consulted as a fallback for bigrams not yet seen during training.
+
+|            | Schema                     | Description        |
+|------------|----------------------------|--------------------|
+| **Input**  | [ParserSchema](../schemas.md) | Structured log  |
+| **Output** | [DetectorSchema](../schemas.md) | Alert / finding |
+
+## Description
+
+For each configured variable, the detector walks every observed value character-by-character (with virtual boundary characters before the first and after the last) and updates a per-(event, variable) bigram frequency table. At detect time, the average per-bigram conditional probability of a new value is computed against this table. Values scoring below `prob_thresh` (default `0.05`) are flagged. When `default_freqs` is enabled, a built-in English bigram table acts as a fallback for bigrams unseen during training.
+
+
+## Configuration example
+
+```yaml
+detectors:
+    BigramFrequencyDetector:
+        method_type: bigram_frequency_detector
+        auto_config: False
+        params: {}
+        events:
+            1:
+                test:
+                    params: {}
+                    variables:
+                        - pos: 0
+                          name: var1
+                          params:
+                              threshold: 0.
+                    header_variables:
+                        - pos: level
+                          params: {}
+```
+
+
+## Example usage
+
+```python
+from detectmatelibrary.detectors.bigram_frequency_detector import BigramFrequencyDetector, BufferMode
+import detectmatelibrary.schemas as schemas
+
+detector = BigramFrequencyDetector(name="BigramFrequencyTest", config=cfg)
+
+parsed_data = schemas.ParserSchema({
+    "parserType": "test",
+    "EventID": 1,
+    "template": "test template",
+    "variables": ["var1"],
+    "logID": "1",
+    "parsedLogID": "1",
+    "parserID": "test_parser",
+    "log": "test log message",
+    "logFormatVariables": {"timestamp": "123456"}
+})
+
+
+alert = detector.process(parsed_data)
+```
+
+Go back [Index](../index.md)
diff --git a/docs/detectors/charset.md b/docs/detectors/charset.md
new file mode 100644
index 00000000..99f7eb6d
--- /dev/null
+++ b/docs/detectors/charset.md
@@ -0,0 +1,62 @@
+# New Value Detector
+
+The Charset Detector raises alerts when previously unseen characters appear in configured fields. It is useful to detect novelty, configuration drift, or the appearance of new actors in the environment.
+
+|            | Schema                     | Description        |
+|------------|----------------------------|--------------------|
+| **Input**  | [ParserSchema](../schemas.md) | Structured log  |
+| **Output** | [DetectorSchema](../schemas.md) | Alert / finding |
+
+## Description
+
+This detector maintains a lightweight set of observed characters per monitored field and emits an alert when a character not present in the set is seen for the first time (subject to configuration).
+
+
+## Configuration example
+
+```yaml
+detectors:
+    CharsetDetector:
+        method_type: charset_detector
+        auto_config: False
+        params: {}
+        events:
+            1:
+                test:
+                    params: {}
+                    variables:
+                        - pos: 0
+                          name: var1
+                          params:
+                              threshold: 0.
+                    header_variables:
+                        - pos: level
+                          params: {}
+```
+
+
+## Example usage
+
+```python
+from detectmatelibrary.detectors.charset_detector import CharsetDetector
+import detectmatelibrary.schemas as schemas
+
+detector = CharsetDetector(name="CharsetTest", config=cfg)
+
+parsed_data = schemas.ParserSchema({
+    "parserType": "test",
+    "EventID": 1,
+    "template": "test template",
+    "variables": ["var1"],
+    "logID": "1",
+    "parsedLogID": "1",
+    "parserID": "test_parser",
+    "log": "test log message",
+    "logFormatVariables": {"timestamp": "123456"}
+})
+
+
+alert = detector.process(parsed_data)
+```
+
+Go back [Index](../index.md)
diff --git a/docs/detectors/combo.md b/docs/detectors/combo.md
index 02726689..919b62c1 100644
--- a/docs/detectors/combo.md
+++ b/docs/detectors/combo.md
@@ -18,7 +18,7 @@ detectors:
         method_type: new_value_combo_detector
         auto_config: False
         params:
-            comb_size: 3
+            max_combo_size: 3
         events:
             1:
                 test:
@@ -33,9 +33,11 @@ detectors:
 ## Example usage
 
 ```python
-from detectmatelibrary.detectors.combo_detector import ComboDetector, ComboConfig
+from detectmatelibrary.detectors.new_value_combo_detector import NewValueComboDetector, NewValueComboDetectorConfig
 import detectmatelibrary.schemas as schemas
 
+detector = NewValueComboDetector(name="NewValueTest", config=cfg)
+
 test_data = schemas.ParserSchema({
     "parserType": "test",
     "EventID": 12,
diff --git a/docs/detectors/new_event.md b/docs/detectors/new_event.md
new file mode 100644
index 00000000..48b45b95
--- /dev/null
+++ b/docs/detectors/new_event.md
@@ -0,0 +1,50 @@
+# New Event Detector
+
+The New Event Detector raises alerts when previously unseen log templates, distinguished by event IDs, appear in log data. It is useful to detect unexpected types of events in the environment.
+
+|            | Schema                     | Description        |
+|------------|----------------------------|--------------------|
+| **Input**  | [ParserSchema](../schemas.md) | Structured log  |
+| **Output** | [DetectorSchema](../schemas.md) | Alert / finding |
+
+## Description
+
+This detector maintains a lightweight set of observed event IDs and emits an alert when an event ID not present in the set is seen for the first time (subject to configuration).
+
+
+## Configuration example
+
+```yaml
+detectors:
+    NewEventDetector:
+        method_type: new_event_detector
+        auto_config: False
+        params: {}
+```
+
+
+## Example usage
+
+```python
+from detectmatelibrary.detectors.new_event_detector import NewEventDetector, NewEventDetectorConfig
+import detectmatelibrary.schemas as schemas
+
+detector = NewEventDetector(name="NewEventTest", config=cfg)
+
+parser_data = schemas.ParserSchema({
+    "parserType": "test",
+    "EventID": 1,
+    "template": "test template",
+    "variables": ["var1"],
+    "logID": "1",
+    "parsedLogID": "1",
+    "parserID": "test_parser",
+    "log": "test log message",
+    "logFormatVariables": {"timestamp": "123456"}
+})
+
+
+alert = detector.process(parser_data)
+```
+
+Go back [Index](../index.md)
diff --git a/docs/detectors/new_value.md b/docs/detectors/new_value.md
index 5d044c42..de8cd02f 100644
--- a/docs/detectors/new_value.md
+++ b/docs/detectors/new_value.md
@@ -9,7 +9,7 @@ The New Value Detector raises alerts when previously unseen values appear in con
 
 ## Description
 
-This detector maintains a lightweight set of observed values per monitored field and emits an alert when a value not present in the set is seen for the first time (subject to configuration). .
+This detector maintains a lightweight set of observed values per monitored field and emits an alert when a value not present in the set is seen for the first time (subject to configuration).
 
 
 ## Configuration example
@@ -20,6 +20,10 @@ detectors:
         method_type: new_value_detector
         auto_config: False
         params: {}
+        persist:                      # optional — omit to disable saving
+          path: ./state
+          interval_seconds: 300
+          auto_load: false
         events:
             1:
                 test:
@@ -38,9 +42,18 @@ detectors:
 ## Example usage
 
 ```python
-from detectmatelibrary.detectors.new_value_detector import NewValueDetector, BufferMode
+from detectmatelibrary.detectors.new_value_detector import NewValueDetector
 import detectmatelibrary.schemas as schemas
 
+cfg = {
+    "detectors": {
+        "NewValueTest": {
+            "method_type": "new_value_detector",
+            "auto_config": False,
+            "params": {},
+        }
+    }
+}
 detector = NewValueDetector(name="NewValueTest", config=cfg)
 
 parser_data = schemas.ParserSchema({
@@ -56,7 +69,7 @@ parser_data = schemas.ParserSchema({
 })
 
 
-alert = detector.process(parsed_data)
+alert = detector.process(parser_data)
 ```
 
 Go back [Index](../index.md)
diff --git a/docs/detectors/rule_based.md b/docs/detectors/rule_based.md
new file mode 100644
index 00000000..3adf679d
--- /dev/null
+++ b/docs/detectors/rule_based.md
@@ -0,0 +1,69 @@
+# Rule-based Detector
+
+The Rule-based Detector raises alerts based on a configurable set of rules.
+
+|            | Schema                     | Description        |
+|------------|----------------------------|--------------------|
+| **Input**  | [ParserSchema](../schemas.md) | Structured log  |
+| **Output** | [DetectorSchema](../schemas.md) | Alert / finding |
+
+## Description
+
+The detector analyzes parsed logs one by one and checks which rules are triggered. When alerts are produced, the triggered rules and their messages are recorded in the `alertsObtain` field of the output schema. The `score` field contains the number of rules that triggered.
+
+### Available rules
+
+| Rule name | Description | Requires arguments | Enabled by default |
+|---|---|---:|:---:|
+| **R001 - TemplateNotFound** | Check whether the parser assigned a template to the log | No | Yes |
+| **R002 - SpecificKeyword** | Check for one or more user-specified keywords in the log content | list of words | No |
+| **R003 - CheckForExceptions** | Check for words commonly associated with exceptions or failures | No | Yes |
+| **R004 - ErrorLevelFound** | If a Level field exists, check whether it indicates an error level | No | Yes |
+
+Notes on table columns:
+
+- **Rule name**: Identifier used in configuration.
+- **Description**: What the rule checks.
+- **Requires arguments**: Whether the rule needs additional arguments.
+- **Enabled by default**: Whether the rule is active when not explicitly overridden.
+
+## Configuration example
+
+```yaml
+detectors:
+  RuleDetector:
+    method_type: rule_detector
+    auto_config: False
+    params:
+      rules:
+        - rule: "R001 - TemplateNotFound"
+        - rule: "R002 - SpecificKeyword"
+          args:
+            - "critical"
+            - "anomaly"
+```
+
+## Example usage
+
+```python
+import detectmatelibrary.detectors.rule_detector as rd
+from detectmatelibrary import schemas
+
+rule_detector = rd.RuleDetector()
+
+parser_data = schemas.ParserSchema({
+    "parserType": "test",
+    "EventID": 1,
+    "template": "test template",
+    "variables": ["var1"],
+    "logID": "1",
+    "parsedLogID": "1",
+    "parserID": "test_parser",
+    "log": "test log message",
+    "logFormatVariables": {"timestamp": "123456"}
+})
+
+alert = rule_detector.process(parser_data)
+```
+
+Go back [Index](../index.md)
diff --git a/docs/detectors/value_range.md b/docs/detectors/value_range.md
new file mode 100644
index 00000000..a8f97345
--- /dev/null
+++ b/docs/detectors/value_range.md
@@ -0,0 +1,62 @@
+# Value Range Detector
+
+The Value Range Detector raises alerts when numerical values outside of known ranges appear in configured fields. It is useful to detect unexpected changes, configuration drift, or the appearance of new actors in the environment.
+
+|            | Schema                     | Description        |
+|------------|----------------------------|--------------------|
+| **Input**  | [ParserSchema](../schemas.md) | Structured log  |
+| **Output** | [DetectorSchema](../schemas.md) | Alert / finding |
+
+## Description
+
+This detector maintains a lightweight set of observed values per monitored field and emits an alert when a value outside the learned range is seen (subject to configuration).
+
+
+## Configuration example
+
+```yaml
+detectors:
+    ValueRangeDetector:
+        method_type: value_range_detector
+        auto_config: False
+        params: {"ignore_non_numerical_val": True}
+        events:
+            1:
+                test:
+                    params: {}
+                    variables:
+                        - pos: 0
+                          name: var1
+                          params:
+                              threshold: 0.
+                    header_variables:
+                        - pos: level
+                          params: {}
+```
+
+
+## Example usage
+
+```python
+from detectmatelibrary.detectors.value_range_detector import ValueRangeDetector, BufferMode
+import detectmatelibrary.schemas as schemas
+
+detector = ValueRangeDetector(name="NewValueTest", config=cfg)
+
+parser_data = schemas.ParserSchema({
+    "parserType": "test",
+    "EventID": 1,
+    "template": "test template",
+    "variables": ["1", "2", "17"],
+    "logID": "1",
+    "parsedLogID": "1",
+    "parserID": "test_parser",
+    "log": "test log message",
+    "logFormatVariables": {"timestamp": "123456"}
+})
+
+
+alert = detector.process(parser_data)
+```
+
+Go back [Index](../index.md)
diff --git a/docs/development.md b/docs/development.md
new file mode 100644
index 00000000..94239b1b
--- /dev/null
+++ b/docs/development.md
@@ -0,0 +1,43 @@
+# Development
+
+This section describes how to setup a development environment and how to contribute to `DetectMateLibrary`.
+
+!!! note
+
+    Read the [Contribution Guide](contribution.md) to follow and understand the development workflow.
+
+
+## Setup a development environment
+
+For development we recommend using [uv](https://docs.astral.sh/uv/). You can install all optional dependencies:
+
+```bash
+uv sync --dev
+```
+
+*Please note that this step is not necessary. `uv run --dev` will automatically download all dependencies.*
+
+
+## Use prek to run code checks
+
+Every code contributer must use [`prek`](https://github.com/j178/prek) to run basic checks at commit time.
+`prek` is configured via the existing `.pre-commit-config.yaml`
+and can be installed as part of the `dev` extras. To ensure pre-commit hooks run before each commit, run:
+
+```bash
+uv run prek install
+```
+
+To run the checks manually, you can execute:
+
+```bash
+uv run prek run -a
+```
+
+## Add tests and run pytest
+
+In oder to run the tests run the following command:
+
+```bash
+uv run --dev pytest
+```
diff --git a/docs/helper/from_to.md b/docs/helper/from_to.md
index 75a822c8..28dad9ec 100644
--- a/docs/helper/from_to.md
+++ b/docs/helper/from_to.md
@@ -36,6 +36,19 @@ class From:
         component: CoreComponent, in_path: str, do_process: bool = True
     ) -> Iterator[BaseSchema]:
         """Load YAML files as input schemas."""
+
+    @staticmethod
+    def polars(
+        component: CoreComponent,
+        df: DataFrame,
+        do_process: bool = True,
+        renames: dict[str, str] | None = None
+    ) -> Iterator[BaseSchema]:
+        """
+        Load Polars dataframe as input schemas follow DetectMatePerformance format.
+
+        *  renames: allow to rename the dataframe inside the method
+        """
 ```
 
 ### Usage
@@ -166,6 +179,33 @@ class FromTo:
         component: CoreComponent, in_path: str, out_path: str
     ) -> Iterator[BaseSchema]:
         """Load a YAML file and save it to a YAML file."""
+
+    @staticmethod
+    def polars2binary_file(
+        component: CoreComponent,
+        df: DataFrame,
+        out_path: str,
+        renames: dict[str, str] | None = None
+    ) -> Iterator[BaseSchema]:
+        """Load DetectMatePerformance Dataframe to binary file"""
+
+    @staticmethod
+    def polars2json(
+        component: CoreComponent,
+        df: DataFrame,
+        out_path: str,
+        renames: dict[str, str] | None = None
+    ) -> Iterator[BaseSchema]:
+        """Load DetectMatePerformance Dataframe to json"""
+
+    @staticmethod
+    def polars2yaml(
+        component: CoreComponent,
+        df: DataFrame,
+        out_path: str,
+        renames: dict[str, str] | None = None
+    ) -> Iterator[BaseSchema]:
+        """Load DetectMatePerformance Dataframe to yaml"""
 ```
 
 ### Usage
diff --git a/docs/index.md b/docs/index.md
index d8dd0d0e..f92468a5 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -16,6 +16,7 @@ List of steps to follow for new users of the library:
 
 Documentation of the different components:
 
+* [Basic concepts](basic_idea.md): basic concepts need it to understand log anomaly detection.
 * [Overall architecture](overall_architecture.md): overall architecture of the library.
 * [Schemas](schemas.md): documentation of the different schemas in the library.
 * [Parsers](parsers.md): documentation of the different parsers.
@@ -32,3 +33,7 @@ Tools that are used in the different components:
 Tools that their main objective is to help the developer:
 
 * [From_to](helper/from_to.md): set of methods to save and load inputs and outputs from files.
+
+## Other
+
+* [Log Formats](other/log_formats.md): reference catalog of 18 common log formats with parser configuration.
diff --git a/docs/other/log_formats.md b/docs/other/log_formats.md
new file mode 100644
index 00000000..43eb1857
--- /dev/null
+++ b/docs/other/log_formats.md
@@ -0,0 +1,314 @@
+# Log Format Catalog
+
+This catalog covers 18 common log formats and provides ready-to-use `log_format` patterns for the DetectMate parsers, such as the [MatcherParser](../parsers/template_matcher.md).
+
+**Key concept:** `log_format` splits a raw log line into structured header fields that become entries in `ParserSchema.logFormatVariables`. The special `<Content>` token captures the variable message body, which is then matched against your template file to produce `EventID` and `variables`. Formats without `<Content>` are fully structured — no template file is needed.
+
+**Generic configuration:**
+
+```yaml
+parsers:
+  MyParser:
+    method_type: matcher_parser
+    auto_config: false
+    log_format: "<Date> <Time> <Level> <Component>: <Content>"
+    params:
+      path_templates: path/to/templates.txt  # only required when log_format contains <Content>
+```
+
+---
+
+## Quick Reference
+
+| Format | Category | Log source | Has `<Content>` |
+|--------|----------|------------|:--------------:|
+| [audit](#audit) | Security | Linux auditd | yes |
+| [ApacheAccess](#apacheaccess) | Web & Network | Apache httpd access log | no |
+| [OpenSSH](#openssh) | Security | OpenSSH sshd | yes |
+| [Apache](#apache) | Web & Network | Apache httpd error log | yes |
+| [Proxifier](#proxifier) | Web & Network | Proxifier proxy client | yes |
+| [HDFS](#hdfs) | Distributed Systems | Hadoop HDFS daemon | yes |
+| [Hadoop](#hadoop) | Distributed Systems | Hadoop MapReduce | yes |
+| [Spark](#spark) | Distributed Systems | Apache Spark | yes |
+| [Zookeeper](#zookeeper) | Distributed Systems | Apache Zookeeper | yes |
+| [OpenStack](#openstack) | Distributed Systems | OpenStack Nova/etc. | yes |
+| [BGL](#bgl) | HPC / Supercomputers | IBM BlueGene/L | yes |
+| [HPC](#hpc) | HPC / Supercomputers | Generic HPC cluster | yes |
+| [Thunderbird](#thunderbird) | HPC / Supercomputers | Thunderbird supercomputer | yes |
+| [Linux](#linux) | Operating Systems | Linux syslog / auth | yes |
+| [Windows](#windows) | Operating Systems | Windows CBS/Setup | yes |
+| [Mac](#mac) | Operating Systems | macOS system log | yes |
+| [Android](#android) | Operating Systems | Android logcat | yes |
+| [HealthApp](#healthapp) | Application | Mobile health app | yes |
+
+---
+
+## Security
+
+### audit
+
+Linux auditd log. Produced by the kernel audit subsystem; records system calls, authentication, and policy events.
+
+```text
+type=USER_ACCT msg=audit(1642723741.072:375): pid=10125 uid=0 auid=4294967295 ses=4294967295 msg='op=PAM:accounting acct="root" exe="/usr/sbin/cron" hostname=? addr=? terminal=cron res=success'
+```
+
+**`log_format`:** `type=<Type> msg=audit(<Time>): <Content>`
+
+**Variable noise patterns:** Numeric field values (`=\d+`), IP addresses (`(\d+\.){3}\d+`).
+
+---
+
+### OpenSSH
+
+OpenSSH `sshd` authentication log. Records login attempts, key exchanges, and session events.
+
+```text
+Dec 10 07:07:38 LabSZ sshd[24206]: Failed password for invalid user test9 from 192.168.1.1 port 20992 ssh2
+```
+
+**`log_format`:** `<Date> <Day> <Time> <Component> sshd[<Pid>]: <Content>`
+
+**Variable noise patterns:** IP addresses (`(\d+\.){3}\d+`), hostnames (`([\w-]+\.){2,}[\w-]+`).
+
+---
+
+## Web & Network
+
+### ApacheAccess
+
+Apache httpd access log (Combined Log Format). Each line is fully structured — no template file is required.
+
+```text
+64.242.88.10 - - [07/Mar/2004:16:10:02 -0800] "GET /twiki/bin/edit/Main/Double_bounce_sender?topicparent=Main.ConfigurationVariables HTTP/1.1" 401 12846 "-" "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.2) Gecko/20021202"
+```
+
+**`log_format`:** `<IP> - - [<Time>] "<RequestType> <Request> <Version>" <Status> <ResponseSize> "<Referer>" "<UserAgent>"`
+
+> All fields land directly in `logFormatVariables`. Use `header_variables` in your detector config to track e.g. `Status`, `IP`, or `RequestType`.
+
+---
+
+### Apache
+
+Apache httpd error log. Records server errors, warnings, and informational notices.
+
+```text
+[Sun Dec 04 04:47:44 2005] [notice] workerEnv.init() ok /etc/httpd/conf/workers2.properties
+```
+
+**`log_format`:** `[<Time>] [<Level>] <Content>`
+
+**Variable noise patterns:** IP addresses (`(\d+\.){3}\d+`).
+
+---
+
+### Proxifier
+
+Proxifier proxy client log. Records connection open/close events with traffic statistics.
+
+```text
+[10:39:55] Skype.exe - www.bing.com:443 open through proxy 1.2.3.4:8080 OK
+```
+
+**`log_format`:** `[<Time>] <Program> - <Content>`
+
+**Variable noise patterns:** Duration values (`<\d+\ssec`), domain:port pairs (`([\w-]+\.)+[\w-]+(:\d+)?`), transfer sizes (`[KGTM]B`).
+
+---
+
+## Distributed Systems
+
+### HDFS
+
+Hadoop Distributed File System daemon log. Emitted by DataNodes, NameNodes, and other HDFS services.
+
+```text
+081109 203518 148 INFO dfs.DataNode$DataXceiver: Receiving block blk_-1608999687919862906 src: /10.251.73.220:54106 dest: /10.251.73.220:50010
+```
+
+**`log_format`:** `<Date> <Time> <Pid> <Level> <Component>: <Content>`
+
+**Variable noise patterns:** HDFS block IDs (`blk_-?\d+`), IP addresses with optional port (`(\d+\.){3}\d+(:\d+)?`).
+
+---
+
+### Hadoop
+
+Hadoop MapReduce / YARN log. Produced by the ResourceManager, NodeManager, and application containers.
+
+```text
+2015-10-17 15:37:15,811 INFO [main] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: Created MRAppMaster for application appattempt_1443144491176_0001_000001
+```
+
+**`log_format`:** `<Date> <Time> <Level> [<Process>] <Component>: <Content>`
+
+**Variable noise patterns:** IP addresses (`(\d+\.){3}\d+`).
+
+---
+
+### Spark
+
+Apache Spark log. Emitted by driver and executor JVMs.
+
+```text
+15/10/16 03:35:11 INFO storage.BlockManagerMasterActor: Registering block manager 192.168.1.1:61698 with 896.4 MB RAM, BlockManagerId(1, 192.168.1.1, 61698)
+```
+
+**`log_format`:** `<Date> <Time> <Level> <Component>: <Content>`
+
+**Variable noise patterns:** IP addresses, memory size units (`\b[KGTM]?B\b`), domain-like names (`([\w-]+\.){2,}[\w-]+`).
+
+---
+
+### Zookeeper
+
+Apache Zookeeper log. Produced by quorum peers and server threads.
+
+```text
+2015-07-29 17:37:13,090 - INFO  [QuorumPeer:NIOServerCnxn@943] - Closed socket connection for client /192.168.1.8:56613 which had sessionid 0x14eb8e0aac70006
+```
+
+**`log_format`:** `<Date> <Time> - <Level>  [<Node>:<Component>@<Id>] - <Content>`
+
+**Variable noise patterns:** IP addresses with optional port (`(/|)(\d+\.){3}\d+(:\d+)?`).
+
+---
+
+### OpenStack
+
+OpenStack service log (Nova, Neutron, etc.). Structured with a request context field.
+
+```text
+nova-manage.log 2016-09-28 03:51:11.899 25746 INFO nova.metadata.handler [req-5a1f3f8a-fd7a-4dc5-bb32-f642b2de2e74 - - - - -] 127.0.0.1 "GET /openstack/2012-08-10/meta-data/local-ipv4" status: 200 len: 14 time: 0.007720
+```
+
+**`log_format`:** `<Logrecord> <Date> <Time> <Pid> <Level> <Component> [<ADDR>] <Content>`
+
+**Variable noise patterns:** IP addresses (`((\d+\.){3}\d+,?)+`), file paths (`/.+?\s`), numeric values (`\d+`).
+
+---
+
+## HPC / Supercomputers
+
+### BGL
+
+IBM BlueGene/L supercomputer log. Contains hardware-level diagnostic messages with node location identifiers.
+
+```text
+- 1117838570 2005.06.03 R02-M1-N0-C:J12-U11 2005-06-03-15.42.50.363779 R02-M1-N0-C:J12-U11 RAS KERNEL INFO instruction cache parity error corrected
+```
+
+**`log_format`:** `<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>`
+
+**Variable noise patterns:** Core dump references (`core\.\d+`).
+
+---
+
+### HPC
+
+Generic HPC cluster log. Produced by batch schedulers and system daemons on compute nodes.
+
+```text
+5 hpc-lnx-node11 afs RUNNING 1169880007 OK File transfer: 23 files copied 0 bytes in 0.000 secs
+```
+
+**`log_format`:** `<LogId> <Node> <Component> <State> <Time> <Flag> <Content>`
+
+**Variable noise patterns:** Numeric assignments (`=\d+`).
+
+---
+
+### Thunderbird
+
+Thunderbird supercomputer log. Similar to BGL but from a different cluster; includes user and location fields.
+
+```text
+- 1131566401 2005.11.09 admin Nov 9 21:00:01 tbird1 crond[3049]: (root) CMD (/usr/lib/sa/sa1 1 1)
+```
+
+**`log_format`:** `<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>([<PID>])?: <Content>`
+
+**Variable noise patterns:** IP addresses (`(\d+\.){3}\d+`).
+
+---
+
+## Operating Systems
+
+### Linux
+
+Linux syslog format (RFC 3164). Produced by `syslog`, `rsyslog`, and `syslog-ng` — covers auth, cron, kernel messages, and more.
+
+```text
+Jun 14 15:16:02 combo sshd(pam_unix)[19939]: authentication failure; logname= uid=0 euid=0 tty=NODEVssh ruser= rhost=218.188.2.4
+```
+
+**`log_format`:** `<Month> <Date> <Time> <Level> <Component>([<PID>])?: <Content>`
+
+> Note: `<Level>` captures the **hostname** in standard syslog (the field name follows benchmark convention).
+
+**Variable noise patterns:** IP addresses (`(\d+\.){3}\d+`), embedded timestamps (`\d{2}:\d{2}:\d{2}`).
+
+---
+
+### Windows
+
+Windows Component-Based Servicing (CBS) / Setup log. Fixed-width columns with variable spacing.
+
+```text
+2016-09-28 04:30:22, Info                  CBS    Loaded Servicing Stack v6.1.7601.23505 with Core: C:\Windows\winsxs\amd64_microsoft-windows-servicingstack_31bf3856ad364e35_6.1.7601.23505_none_681aa442f6fed7f0\cbscore.dll
+```
+
+**`log_format`:** `<Date> <Time>, <Level>                  <Component>    <Content>`
+
+> Note: The multiple spaces between fields are **literal** and must be preserved in the pattern.
+
+**Variable noise patterns:** Hexadecimal values (`0x.*?\s`).
+
+---
+
+### Mac
+
+macOS unified system log (pre-Unified Logging). Produced by system daemons and user-space processes.
+
+```text
+Jul  9 00:17:03 calvisitor-10-105-160-95 com.apple.backupd[12396] (Error): VSDBUtil: Failed to change_attributes for volume "/Volumes/SanDisk USB Drive"
+```
+
+**`log_format`:** `<Month>  <Date> <Time> <User> <Component>[<PID>]( (<Address>))?: <Content>`
+
+> Note: Double space between `<Month>` and `<Date>` occurs when the day is single-digit (standard macOS padding).
+
+**Variable noise patterns:** Domain names (`([\w-]+\.){2,}[\w-]+`).
+
+---
+
+### Android
+
+Android logcat output. Produced by the Android logging system across all framework and app components.
+
+```text
+01-02 12:23:42.768  1632  2044 E ActivityManager: mDVFSHelper is null
+```
+
+**`log_format`:** `<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>`
+
+**Variable noise patterns:** File system paths (`(/[\w-]+)+`), domain names, hex/numeric values (`\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b`).
+
+---
+
+## Application
+
+### HealthApp
+
+Mobile health application log. Pipe-delimited format from a step-counter app.
+
+```text
+20170201-01:15:35:631|Step_StandCounter|4243|step counts since boot=76149; goal=6000; active=0; distance=45
+```
+
+**`log_format`:** `<Time>|<Component>|<Pid>|<Content>`
+
+---
+
+Go back to [Index](../index.md)
diff --git a/docs/overall_architecture.md b/docs/overall_architecture.md
index a251b8cb..e89b9ff0 100644
--- a/docs/overall_architecture.md
+++ b/docs/overall_architecture.md
@@ -1,6 +1,6 @@
 # Overall architecture
 
-This document describes the high-level design of DetectMateLibrary, how components interact, the data contracts they use, and guidance for deploying and extending the system. The library is built around small, composable components that operate on streaming log data and exchange strongly-typed Schema objects.
+This document describes the high-level design of the DetectMateLibrary, how components interact, the data contracts they use, and guidance for deploying and extending the system. The library is built around small, composable components that operate on streaming log data and exchange strongly-typed Schema objects.
 
 Key goals
 
@@ -14,7 +14,7 @@ Key goals
 The pipeline is strictly directional:
 
 - **Parser**: consumes raw logs and produces parsed log objects (structured fields, timestamps, variables).
-- **Detector**: consumes parsed logs and generates alerts / findings when rules or models match anomalous behavior.
+- **Detector**: consumes parsed logs and generates alerts/findings when rules or models match anomalous behavior.
 
 
 Each arrow represents a stream of [Schema objects](schemas.md). Components are designed to run in the same process for lightweight setups or as separate services for scalable deployments.
@@ -51,6 +51,25 @@ class Component(CoreComponent):
     ) -> None:
     """Train the component with a specific input"""
 
+    def update_state(self, state: StatesL) -> None:
+    """
+    Update the current state by request of the user
+    states:
+    *   keep_training: force to keep training
+    *   stop_training: force to stop training
+    *   keep_configuring: force to keep configuring
+    *   stop_configuring: force to stop configuring
+    """
+
+    def get_state(self) -> str:
+    """
+    Return the current state of the component
+    states:
+    *   Configuring: the component is doing configurations
+    *   Training: the component is training
+    *   Default: the component is just processing data
+    """
+
     def process(self, data: BaseSchema | bytes) -> BaseSchema | bytes | None:
     """Process the data in a stream fashion (Defined in the CoreComponent)"""
 
diff --git a/docs/parsers.md b/docs/parsers.md
index 744419a7..a862c877 100644
--- a/docs/parsers.md
+++ b/docs/parsers.md
@@ -106,6 +106,7 @@ def test_my_parser_parse():
 
 - [JSON Parser](parsers/json_parser.md): extracts structured fields from JSON-formatted logs.
 - [Template Matcher](parsers/template_matcher.md): matches logs against a predefined set of `<*>` templates.
+- [Template Tree Matcher](parsers/template_tree_matcher.md): matches logs against a predefined set of `<*>` templates using a tree structure.
 - [LogBatcher Parser](parsers/logbatcher_parser.md): LLM-based parser that infers templates from raw logs with no training data.
 
 Go back to [Index](index.md)
diff --git a/docs/parsers/json_parser.md b/docs/parsers/json_parser.md
index dc749a32..112cc720 100644
--- a/docs/parsers/json_parser.md
+++ b/docs/parsers/json_parser.md
@@ -1,6 +1,6 @@
 # JSON Parser
 
-Extracts structured information from JSON-formatted logs. Optionally delegates parsing of a specific JSON field (the "content") to another parser (for example, the Template matcher).
+Extracts structured information from JSON-formatted logs. Optionally delegates parsing of a specific JSON field (the "content") to a sibling Template Matcher parser. Nested JSON objects are always flattened to dot-separated keys in `logFormatVariables`.
 
 |            | Schema                     | Description        |
 |------------|----------------------------|--------------------|
@@ -9,14 +9,14 @@ Extracts structured information from JSON-formatted logs. Optionally delegates p
 
 ## Configuration
 
-Relevant config options (example names used by the implementation):
+Relevant config options:
 
-- `method_type` (string): parser type identifier (e.g. `json_parser`).
-- `params.timestamp_name` (string | null): JSON key to use as the received/parsed timestamp.
-- `params.content_name` (string): JSON key that contains the textual content to parse further (default `"message"` or `"content"`).
-- `params.flatten_nested` (bool, default True): flatten nested objects into dot-separated keys in `logFormatVariables`.
-- `params.content_parser` (string | dict): optional parser spec (name or config) to parse the extracted content.
-- `params.ignore_parse_errors` (bool, default True): if True, parser returns gracefully on JSON errors instead of raising.
+- `method_type` (string): parser type identifier — must be `json_parser`.
+- `params.timestamp_name` (string): JSON key to use as the timestamp (default `"time"`).
+- `params.content_name` (string): JSON key whose value is forwarded to the content parser (default `"message"`).
+- `params.content_parser` (string): name of a **sibling** parser entry in the `parsers` section that handles the content field (default `"JsonMatcherParser"`).
+
+The `content_parser` value is a **name**, not an inline config. The referenced parser must be defined as a separate sibling entry at the same level as `JsonParser`.
 
 Example YAML fragment:
 
@@ -27,22 +27,21 @@ parsers:
     params:
       timestamp_name: "time"
       content_name: "message"
-      flatten_nested: True
-      content_parser:
-        method_type: matcher_parser
-        params:
-          path_templates: tests/test_templates.txt
-      ignore_parse_errors: True
+      content_parser: JsonMatcherParser   # optional — defaults to "JsonMatcherParser"
+  JsonMatcherParser:
+    method_type: matcher_parser
+    params:
+      path_templates: tests/test_folder/test_templates.txt
 ```
 
 
 ## Usage examples
 
-Basic usage — parse JSON and extract fields:
+Basic usage — parse JSON and extract fields (no template matching):
 
 ```python
-from detectmatelibrary.parsers.json_parser import JsonParser
-
+import json
+from detectmatelibrary.parsers.json_parser import JsonParser, JsonParserConfig
 import detectmatelibrary.schemas as schemas
 
 
@@ -68,8 +67,53 @@ input_log = schemas.LogSchema({
 output = schemas.ParserSchema()
 parser.parse(input_log, output)
 
-print(output.logFormatVariables["request.method"])  # "GET"
-print(output.logFormatVariables["request.path"])  #"/api/users"
+print(output.logFormatVariables["request.method"])   # "GET"
+print(output.logFormatVariables["request.path"])     # "/api/users"
+```
+
+Dict-based config (from YAML) — with template matching on the `message` field:
+
+```python
+import json
+from detectmatelibrary.parsers.json_parser import JsonParser
+import detectmatelibrary.schemas as schemas
+
+
+config_dict = {
+    "parsers": {
+        "JsonParser": {
+            "method_type": "json_parser",
+            "params": {
+                "timestamp_name": "time",
+                "content_name": "message",
+            }
+        },
+        "JsonMatcherParser": {
+            "method_type": "matcher_parser",
+            "params": {
+                "path_templates": "tests/test_templates.txt"
+            }
+        }
+    }
+}
+parser = JsonParser(name="JsonParser", config=config_dict)
+
+json_log = {
+    "time": "2023-11-18 10:30:00",
+    "message": "pid=9699 uid=0 auid=4294967295 ses=4294967295 msg='op=PAM:accounting acct=\"root\"",
+    "level": "INFO"
+}
+
+input_log = schemas.LogSchema({
+    "logID": "1",
+    "log": json.dumps(json_log)
+})
+
+output = schemas.ParserSchema()
+parser.parse(input_log, output)
+
+print(output.logFormatVariables["level"])  # "INFO"
+print(output.template)                     # "pid=<*> uid=<*> auid=<*> ses=<*> msg='op=PAM:<*> acct=<*>"
 ```
 
 Go back [Index](../index.md)
diff --git a/docs/parsers/template_matcher.md b/docs/parsers/template_matcher.md
index 9b8a64c1..313190e3 100644
--- a/docs/parsers/template_matcher.md
+++ b/docs/parsers/template_matcher.md
@@ -1,6 +1,6 @@
 # Template matcher
 
-Parser that takes a set of templates and matches them to incoming logs. It extracts parameters from positions marked with the <*> wildcard and returns a ParserSchema with the matched template and the extracted variables.
+The template matcher is a parser that takes a set of templates and matches them to incoming logs. It extracts parameters from positions marked with the <*> wildcard and returns a ParserSchema with the matched template and the extracted variables.
 
 |            | Schema                     | Description        |
 |------------|----------------------------|--------------------|
@@ -20,7 +20,7 @@ This parser is deterministic and designed for high-throughput use when templates
 
 ## EventID assignment (preliminary)
 
-The `EventID` (or `event_id`) field in the output `ParserSchema` identifies which template was matched. It equals the **0-indexed line number** of the matching template in the template file:
+The `EventID` (or `event_id`) field in the output `ParserSchema` identifies which template was matched. It equals the **0-indexed line number** of the matching template in the template file, for example:
 
 | Line in template file | EventID |
 |-----------------------|---------|
@@ -29,12 +29,12 @@ The `EventID` (or `event_id`) field in the output `ParserSchema` identifies whic
 | 3rd line              | 2       |
 | ...                   | ...     |
 
-This `EventID` is the integer key used in detector configurations (e.g., `NewValueDetector`) to scope detection rules to logs of a particular template type.
+The `EventID` is the integer key used in detector configurations (e.g., `NewValueDetector`) to scope detection rules to logs of a particular template type.
 
 ## Template format
 
 - Templates are plain text lines in a template file.
-- Use `<*>` for wildcard slots.
+- Templates use `<*>` for wildcard slots.
 
 Example template file (templates.txt):
 ```text
@@ -47,7 +47,7 @@ login success: user=<*> source=<*>
 Typical MatcherParser config options (fields in config class):
 
 - `method_type`: must match the parser type ("matcher_parser" or configured name).
-- `path_templates`: path to the newline-delimited template file.
+- `path_templates`: path to the newline-delimited template file. If `null`, the matcher runs without templates.
 - `remove_spaces` (bool, default True): remove all spaces during matching.
 - `remove_punctuation` (bool, default True): strip punctuation except the `<*>` token.
 - `lowercase` (bool, default True): lowercase logs and templates before matching.
@@ -80,7 +80,7 @@ cfg = {
         "MatcherParser": {
             "method_type": "matcher_parser",
             "params": {
-                "path_templates": "tests/test_folder/test_templates.txt",
+                "path_templates": "detectmatelibrary_tests/test_folder/test_templates.txt",
                 "remove_spaces": True,
                 "remove_punctuation": True,
                 "lowercase": True
diff --git a/docs/parsers/template_tree_matcher.md b/docs/parsers/template_tree_matcher.md
new file mode 100644
index 00000000..afd89add
--- /dev/null
+++ b/docs/parsers/template_tree_matcher.md
@@ -0,0 +1,79 @@
+# Template Tree Matcher
+
+The Template Tree Matcher is a parser that matches incoming logs against a set of templates using a tree-based depth-first search. It provides faster matching for batch workloads compared with the streaming Template Matcher.
+
+This parser wraps functionality from the DetectMatePerformance project: https://github.com/ait-detectmate/DetectMatePerformance. Prefer  use the performance implementation when parsing many log lines in non-stream (batch) mode.
+
+|            | Schema                     | Description        |
+|------------|----------------------------|--------------------|
+| **Input**  | [LogSchema](../schemas.md) | Unstructured log   |
+| **Output** | [ParserSchema](../schemas.md) | Structured log   |
+
+WARNING: This parser is not yet in a stable release and may behave differently across platforms or hardware.
+
+## Template format
+
+- Templates are plain text lines in a template file.
+- Use the token `<*>` to mark wildcard slots.
+
+Example template file (templates.txt):
+```text
+pid=<*> uid=<*> auid=<*> ses=<*> msg='op=PAM:<*> acct=<*>
+login success: user=<*> source=<*>
+```
+
+## Configuration
+
+Typical TemplateTreeMatcher config options:
+
+- `method_type` (string): parser type identifier (for example `"tree_matcher"`).
+- `path_templates` (string or null): path to the newline-delimited template file. If `null`, the matcher runs without templates.
+- `auto_config` (bool): whether to attempt an optional auto-configuration phase (not required).
+
+Note: this matcher removes non-alphanumeric characters from logs and templates before matching, except for the `<*>` token. Ensure your templates are compatible with that normalization.
+
+Example YAML fragment:
+```yaml
+parsers:
+  TemplateTreeMatcher:
+    method_type: tree_matcher
+    auto_config: False
+    params:
+      path_templates: path/to/templates.txt
+```
+
+## Usage example
+
+Simple usage — load templates and match a log:
+
+```python
+from detectmatelibrary.parsers.tree_matcher import TemplateTreeMatcher
+from detectmatelibrary import schemas
+
+# instantiate parser (config can be a dict or a config object)
+cfg = {
+    "parsers": {
+        "TreeMatcher": {
+            "method_type": "tree_matcher",
+            "params": {
+                "path_templates": "detectmatelibrary_tests/test_folder/test_templates.txt"
+            }
+        }
+    }
+}
+
+parser = TemplateTreeMatcher(name="TreeMatcher", config=cfg)
+
+# match a log
+input_log = schemas.LogSchema({
+    "logID": "0",
+    "log": "pid=9699 uid=0 auid=4294967295 ses=4294967295 msg='op=PAM:accounting acct=\"root\"'"
+})
+parsed = parser.process(input_log)  # or call parser.parse / parser.match depending on the API
+
+# parsed is a ParserSchema. Inspect fields:
+print(parsed.template)   # matched template text
+print(parsed.variables)  # list of extracted parameters
+```
+
+Go back to [Index](../index.md)
diff --git a/mkdocs.yml b/mkdocs.yml
index 96f7fbda..c6a496f2 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -11,20 +11,29 @@ nav:
     - Basic usage: basic_usage.md
     - Create new component: create_components.md
   - Components:
+    - Basic concepts: basic_idea.md
     - Overall architecture: overall_architecture.md
     - Schemas: schemas.md
     - Parsers: parsers.md
     - Detectors: detectors.md
   - Parsers Methods:
     - Template Matcher: parsers/template_matcher.md
+    - Template Tree Matcher: parsers/template_tree_matcher.md
     - Json Parser: parsers/json_parser.md
     - LogBatcher Parser: parsers/logbatcher_parser.md
   - Detectors Methods:
     - Random Detector: detectors/random_detector.md
     - New Value: detectors/new_value.md
     - Combo Detector: detectors/combo.md
+    - New Event: detectors/new_event.md
+    - Rule Based: detectors/rule_based.md
   - Auxiliar:
     - Persistency: auxiliar/persistency.md
     - Data buffer: auxiliar/input_buffer.md
   - Helpers:
     - From to: helper/from_to.md
+  - Contribution:
+    - Contributing: contribution.md
+    - Development: development.md
+  - Other:
+    - Log Formats: other/log_formats.md
diff --git a/pyproject.toml b/pyproject.toml
index 2dad01dc..41ffe390 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,16 +1,17 @@
 [project]
 name = "detectmatelibrary"
-version = "0.2.0"
 description = "DetectMate Library for log processing components"
-readme = "README.md"
-dynamic = ["authors"]
+readme = {file = "README.md", content-type = "text/markdown"}
+dynamic = ["version"]
+authors = [{"name" = "André García Gómez"}, {"name" = "Viktor Beck"}, {"name" = "Thorina Boenke"},
+    {"name" = "Wolfgang Hotwagner"}, {"name" = "Anna Erdi"}, {"name" = "Ernst Leierzopf"}]
+license = "EUPL-1.2"
 requires-python = ">=3.12"
 dependencies = [
     "protobuf>=6.32.1",
     "pydantic>=2.13.3",
     "pyyaml>=6.0.3",
     "regex>=2025.11.3",
-    "kafka-python>=2.3.0",
     "openai>=2.26.0",
     "tenacity>=9.1.4",
     "scipy>=1.17.1",
@@ -18,12 +19,15 @@ dependencies = [
     "tiktoken>=0.12.0",
     "numpy>=2.3.2",
     "pandas>=2.3.2",
-    "polars>=1.40.0",
+    "polars>=1.40.1",
+    "detectmateperformance @ git+https://github.com/ait-detectmate/DetectMatePerformance@main",
+    "msgpack>=1.0.0",
+    "fsspec>=2024.1.0",
+    "pyarrow>=24.0.0",
 ]
 
 [dependency-groups]
-# add dependencies in this section with: uv add --optional dev <package>
-# install with all the dev dependencies:  uv pip install -e .[dev]
+# install with all the dev dependencies:  uv pip install --group dev
 dev = [
     "mike>=2.2.0",
     "prek>=0.3.10",
@@ -31,15 +35,28 @@ dev = [
     "pytest-cov>=6.2.1",
 ]
 
+[project.optional-dependencies]
+polars-rtcompat = [
+    "polars[rtcompat]>=1.38.1",
+]
+
+[tool.setuptools.dynamic]
+version = {attr = "detectmatelibrary.metadata.__version__"}
+
+[project.urls]
+Homepage = "https://ait-detectmate.github.io/DetectMateLibrary/latest"
+Repository = "https://github.com/ait-detectmate/DetectMateLibrary"
+
 [build-system]
 requires = ["setuptools>=82.0.1", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools.packages.find]
-where = ["src"]
+where = ["src", "."]
+include = ["detectmatelibrary*"]
 
 [project.scripts]
-mate = "tools.workspace.create_workspace:main"
+mate = "detectmatelibrary_tools.workspace.create_workspace:main"
 
 [[tool.mypy.overrides]]
 module = "detectmatelibrary.schemas.schemas_pb2"
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 7dcd3558..00000000
--- a/setup.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from setuptools import setup, find_packages
-import tomllib
-
-
-def gather_dependencies(toml_path: str = "pyproject.toml") -> list[str]:
-    with open(toml_path, "rb") as f:
-        data = tomllib.load(f)
-
-    # Try Poetry first
-    poetry_deps = data.get("tool", {}).get("poetry", {}).get("dependencies", {})
-    if poetry_deps:
-        return [f"{dep}{version}" for dep, version in poetry_deps.items()]
-
-    # Fall back to PEP 621
-    project_deps: list[str] = data.get("project", {}).get("dependencies", [])
-    return project_deps
-
-
-setup(
-    name="detectmatelibrary",
-    version="0.1.0",
-    package_dir={"": "src"},
-    packages=find_packages(where="src"),
-    description="DetectMate Library for log processing components",
-    author="voice",
-    author_email="voice@example.com",
-    install_requires=gather_dependencies(),
-    data_files=[(
-        "src/tools/workspace/templates/data",
-        [
-            "src/tools/workspace/templates/data/logs.json",
-            "src/tools/workspace/templates/data/parsed_log.json",
-        ]
-    )]
-)
diff --git a/src/detectmatelibrary/__init__.py b/src/detectmatelibrary/__init__.py
index ce6e3bb4..3cfe8053 100644
--- a/src/detectmatelibrary/__init__.py
+++ b/src/detectmatelibrary/__init__.py
@@ -3,11 +3,22 @@
 from . import parsers
 from . import schemas
 from . import utils
+from .metadata import (__authors__, __contact__, __copyright__, __date__, __deprecated__, __website__,
+                       __license__, __status__, __version__)
 
 __all__ = [
     "common",
     "detectors",
     "parsers",
     "schemas",
-    "utils"
+    "utils",
+    "__authors__",
+    "__contact__",
+    "__copyright__",
+    "__date__",
+    "__deprecated__",
+    "__website__",
+    "__license__",
+    "__status__",
+    "__version__"
 ]
diff --git a/src/detectmatelibrary/common/_config/__init__.py b/src/detectmatelibrary/common/_config/__init__.py
index 0ee1ed83..12b86205 100644
--- a/src/detectmatelibrary/common/_config/__init__.py
+++ b/src/detectmatelibrary/common/_config/__init__.py
@@ -68,6 +68,7 @@ def to_dict(self, method_id: str = random_id()) -> Dict[str, Any]:
         params = {}
         events_data = None
         instances_data = None
+        persist_data: dict[str, Any] | None = None
 
         for field_name, field_value in self:
             # Skip meta fields
@@ -88,6 +89,9 @@ def to_dict(self, method_id: str = random_id()) -> Dict[str, Any]:
                     name: inst.to_dict()
                     for name, inst in field_value.items()
                 }
+            elif field_name == "persist":
+                if field_value is not None:
+                    persist_data = field_value.model_dump()
             else:
                 # All other fields go into params
                 params[field_name] = field_value
@@ -104,6 +108,9 @@ def to_dict(self, method_id: str = random_id()) -> Dict[str, Any]:
         if events_data is not None:
             result["events"] = events_data
 
+        if persist_data is not None:
+            result["persist"] = persist_data
+
         # Wrap in the component_type and method_id structure
         return {
             self.component_type: {
diff --git a/src/detectmatelibrary/common/_config/_compile.py b/src/detectmatelibrary/common/_config/_compile.py
index 5a864e84..0097b634 100644
--- a/src/detectmatelibrary/common/_config/_compile.py
+++ b/src/detectmatelibrary/common/_config/_compile.py
@@ -61,7 +61,10 @@ def __init__(self, expected_type: str, actual_type: str) -> None:
 
 class MissingParamsWarning(UserWarning):
     def __init__(self) -> None:
-        super().__init__("'auto_config = False' and no 'params' or 'events' provided. Is that intended?")
+        super().__init__(
+            "'auto_config = False' and no 'params', 'events', 'global', or 'persist' provided. "
+            "Is that intended?"
+        )
 
 
 class AutoConfigWarning(UserWarning):
@@ -94,8 +97,10 @@ def process(config: Dict[str, Any]) -> Dict[str, Any]:
         has_params = "params" in config
         has_events = "events" in config
         has_instances = "global" in config
+        has_persist = "persist" in config
 
-        if not has_params and not has_events and not has_instances and not config.get("auto_config", False):
+        no_data = not has_params and not has_events and not has_instances and not has_persist
+        if no_data and not config.get("auto_config", False):
             warnings.warn(MissingParamsWarning())
 
         if has_params:
@@ -142,7 +147,7 @@ def generate_detector_config(
         detector_name: Name of the detector, used as the base instance_id.
         method_type: Type of detection method (e.g., "new_value_detector").
         **additional_params: Additional parameters for the detector's params
-            dict (e.g., comb_size=3).
+            dict (e.g., max_combo_size=3).
 
     Returns:
         Dictionary with structure compatible with detector config classes.
@@ -162,7 +167,7 @@ def generate_detector_config(
                 variable_selection={1: [("username", "src_ip"), ("var_0", "var_1")]},
                 detector_name="MyDetector",
                 method_type="new_value_combo_detector",
-                comb_size=2,
+                max_combo_size=2,
             )
     """
     var_pattern = re.compile(r"^var_(\d+)$")
diff --git a/src/detectmatelibrary/common/_config/_formats.py b/src/detectmatelibrary/common/_config/_formats.py
index 564d5e53..dcee7e25 100644
--- a/src/detectmatelibrary/common/_config/_formats.py
+++ b/src/detectmatelibrary/common/_config/_formats.py
@@ -6,16 +6,17 @@
 
 # Sub-formats ********************************************************+
 class Variable(BaseModel):
-    pos: int
-    name: str
+    pos: str | int
+    name: str = ""
     params: Dict[str, Any] = {}
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert Variable to YAML-compatible dictionary."""
         result: Dict[str, Any] = {
             "pos": self.pos,
-            "name": self.name,
         }
+        if self.name:
+            result["name"] = self.name
         if self.params:
             result["params"] = self.params
         return result
@@ -38,7 +39,7 @@ def to_dict(self) -> Dict[str, Any]:
 class _EventInstance(BaseModel):
     """Configuration for a specific instance within an event."""
     params: Dict[str, Any] = {}
-    variables: Dict[int, Variable] = {}
+    variables: Dict[str | int, Variable] = {}
     header_variables: Dict[str, Header] = {}
 
     @classmethod
@@ -79,7 +80,7 @@ def _init(cls, instances_dict: Dict[str, Dict[str, Any]]) -> "_EventConfig":
         return cls(instances=instances)
 
     @property
-    def variables(self) -> Dict[int, Variable]:
+    def variables(self) -> Dict[str | int, Variable]:
         """Pass-through to first instance for compatibility."""
         if self.instances:
             return next(iter(self.instances.values())).variables
diff --git a/src/detectmatelibrary/common/_core_op/_fit_logic.py b/src/detectmatelibrary/common/_core_op/_fit_logic.py
index c702524f..62dd264b 100644
--- a/src/detectmatelibrary/common/_core_op/_fit_logic.py
+++ b/src/detectmatelibrary/common/_core_op/_fit_logic.py
@@ -1,5 +1,7 @@
 
+from typing import Literal, get_args
 from enum import Enum
+import warnings
 
 
 class TrainState(Enum):
@@ -28,10 +30,28 @@ def describe(self) -> str:
             "Force stop configuration.",
             "Keep configuring regardless of default behavior."
         ]
-
         return descriptions[self.value]
 
 
+StatesL = Literal["keep_training", "stop_training", "keep_configuring", "stop_configuring"]
+
+def update_state(
+    state: StatesL, train_state: TrainState, config_state: ConfigState
+) -> tuple[TrainState, ConfigState]:
+    if state == "keep_training":
+        train_state = TrainState.KEEP_TRAINING
+    elif state == "stop_training":
+        train_state = TrainState.STOP_TRAINING
+    elif state == "keep_configuring":
+        config_state = ConfigState.KEEP_CONFIGURE
+    elif state == "stop_configuring":
+        config_state = ConfigState.STOP_CONFIGURE
+    else:
+        warnings.warn(f"State {state} unknown, use: {get_args(StatesL)}")
+
+    return train_state, config_state
+
+
 def do_training(
     data_use_training: int | None, index: int, train_state: TrainState
 ) -> bool:
@@ -59,6 +79,14 @@ class FitLogicState(Enum):
     DO_TRAIN = 1
     NOTHING = 2
 
+    def describe(self) -> str:
+        descriptions = [
+            "Configuring",
+            "Training.",
+            "Default"
+        ]
+        return descriptions[self.value]
+
 
 class FitLogic:
     def __init__(
@@ -67,24 +95,36 @@ def __init__(
         
         self.train_state = TrainState.DEFAULT
         self.configure_state = ConfigState.DEFAULT
+        self.last_state = FitLogicState.NOTHING
 
-        self.data_used_train = 0
-        self.data_used_configure = 0
-
-        self._configuration_done = False
-        self.config_finished = False
+        self.data_used_train, self.data_used_configure = 0, 0
+        self._configuration_done, self.config_finished = False, False
+        self._training_done, self.training_finished = False, False
 
         self.data_use_configure = data_use_configure
         self.data_use_training = data_use_training
 
+    def get_last_state(self) -> str:
+        return self.last_state.describe()
+
+    def update_state(self, state: StatesL) -> None:
+        self.train_state, self.configure_state = update_state(
+            state=state, train_state=self.train_state, config_state=self.configure_state
+        )
+
     def finish_config(self) -> bool:
         if self._configuration_done and not self.config_finished:
             self.config_finished = True
             return True
+        return False
 
+    def finish_training(self) -> bool:
+        if self._training_done and not self.training_finished:
+            self.training_finished = True
+            return True
         return False
 
-    def run(self) -> FitLogicState:
+    def __check_state(self) -> FitLogicState:
         if do_configure(
             data_use_configure=self.data_use_configure,
             index=self.data_used_configure,
@@ -103,5 +143,11 @@ def run(self) -> FitLogicState:
             ):
                 self.data_used_train += 1
                 return FitLogicState.DO_TRAIN
+            elif self.data_used_train > 0 and not self._training_done:
+                self._training_done = True
 
-        return FitLogicState.NOTHING
\ No newline at end of file
+        return FitLogicState.NOTHING
+    
+    def run(self) -> FitLogicState:
+        self.last_state = self.__check_state()
+        return self.last_state
\ No newline at end of file
diff --git a/src/detectmatelibrary/common/core.py b/src/detectmatelibrary/common/core.py
index 34d5a008..4e783f26 100644
--- a/src/detectmatelibrary/common/core.py
+++ b/src/detectmatelibrary/common/core.py
@@ -1,4 +1,4 @@
-from detectmatelibrary.common._core_op._fit_logic import FitLogicState
+from detectmatelibrary.common._core_op._fit_logic import FitLogicState, StatesL
 from detectmatelibrary.common._core_op._schema_pipeline import SchemaPipeline
 from detectmatelibrary.common._core_op._fit_logic import FitLogic
 
@@ -9,18 +9,52 @@
 
 from detectmatelibrary.schemas import BaseSchema
 
-from tools.logging import logger, setup_logging
+from detectmatelibrary_tools.logging import logger, setup_logging
 
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Protocol
 
 
 setup_logging()
 
 
+class _Stoppable(Protocol):
+    """Structural type for objects ``Component`` will stop on context-manager
+    exit.
+
+    Decouples ``Component`` from any concrete saver implementation: a subclass
+    may assign anything with a ``stop()`` method to ``self.saver`` (today the
+    only such type is ``PersistencySaver``) without ``common.core`` having to
+    import the persistency package. This preserves the dependency direction
+    detectmate -> persistency, not the reverse.
+    """
+    def stop(self) -> None: ...
+
+
+class TrainBuffer:
+    def __init__(self) -> None:
+        self.buffer: list[BaseSchema | list[BaseSchema]] = []
+
+    def __len__(self) -> int:
+        return len(self.buffer)
+
+    def __add__(self, elem: BaseSchema | list[BaseSchema]) -> "TrainBuffer":
+        self.buffer.append(elem)
+        return self
+
+    def __next__(self) -> BaseSchema | list[BaseSchema]:
+        if len(self.buffer) == 0:
+            raise StopIteration
+        return self.buffer.pop(0)
+
+    def __iter__(self) -> "TrainBuffer":
+        return self
+
+
 class CoreConfig(BasicConfig):
     start_id: int = 10
     data_use_training: int | None = None
     data_use_configure: int | None = None
+    use_config_data_as_training: bool = True
 
 
 class Component:
@@ -32,6 +66,7 @@ def __init__(
         config: CoreConfig = CoreConfig(),
     ) -> None:
         self.name, self.type_, self.config = name, type_, config
+        self.saver: _Stoppable | None = None
 
     def __repr__(self) -> str:
         return f"<{self.type_}> {self.name}: {self.config}"
@@ -54,12 +89,22 @@ def configure(
     def set_configuration(self) -> None:
         pass
 
+    def post_train(self) -> None:
+        pass
+
     def get_config(self) -> Dict[str, Any]:
         return self.config.get_config()
 
     def update_config(self, new_config: Dict[str, Any]) -> None:
         self.config.update_config(new_config)
 
+    def __enter__(self) -> "Component":
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        if self.saver is not None:
+            self.saver.stop()
+
 
 class CoreComponent(Component):
     """Base class for all components in the system."""
@@ -81,6 +126,13 @@ def __init__(
             data_use_configure=self.config.data_use_configure,
             data_use_training=self.config.data_use_training,
         )
+        self.buffer_train = TrainBuffer()
+
+    def update_state(self, state: StatesL) -> None:
+        self.fitlogic.update_state(state)
+
+    def get_state(self) -> str:
+        return self.fitlogic.get_last_state()
 
     def process(self, data: BaseSchema | bytes) -> BaseSchema | bytes | None:
         is_byte, data = SchemaPipeline.preprocess(self.input_schema(), data)
@@ -90,22 +142,29 @@ def process(self, data: BaseSchema | bytes) -> BaseSchema | bytes | None:
             return None
 
         if (fit_state := self.fitlogic.run()) == FitLogicState.DO_CONFIG:
-            logger.info(f"<<{self.name}>> use data for configuration")
+            logger.debug(f"<<{self.name}>> use data for configuration")
             self.configure(input_=data_buffered)
+            if self.config.use_config_data_as_training:
+                self.buffer_train + data_buffered
             return None
         elif self.fitlogic.finish_config():
-            logger.info(f"<<{self.name}>> finalizing configuration")
+            logger.debug(f"<<{self.name}>> finalizing configuration")
             self.set_configuration()
-
+            if self.config.use_config_data_as_training:
+                logger.debug(f"<<{self.name}>> Adding data from config to training")
+                [self.train(input_) for input_ in self.buffer_train]
         if fit_state == FitLogicState.DO_TRAIN:
-            logger.info(f"<<{self.name}>> use data for training")
+            logger.debug(f"<<{self.name}>> use data for training")
             self.train(input_=data_buffered)
+        elif self.fitlogic.finish_training():
+            logger.debug(f"<<{self.name}>> finalizing training")
+            self.post_train()
 
         output_ = self.output_schema()
-        logger.info(f"<<{self.name}>> processing data")
+        logger.debug(f"<<{self.name}>> processing data")
         return_schema = self.run(input_=data_buffered, output_=output_)
         if not return_schema:
-            logger.info(f"<<{self.name}>> returns None")
+            logger.debug(f"<<{self.name}>> returns None")
             return None
 
         logger.debug(f"<<{self.name}>> processed:\n{output_}")
diff --git a/src/detectmatelibrary/common/detector.py b/src/detectmatelibrary/common/detector.py
index e224f68c..ba2067b8 100644
--- a/src/detectmatelibrary/common/detector.py
+++ b/src/detectmatelibrary/common/detector.py
@@ -3,18 +3,33 @@
 
 from detectmatelibrary.utils.data_buffer import ArgsBuffer, BufferMode
 from detectmatelibrary.utils.aux import get_timestamp
+from detectmatelibrary.utils import persistency
+from detectmatelibrary.common.persist import init_persistency
+
+from pydantic import BaseModel, ConfigDict
 
 from detectmatelibrary.schemas import ParserSchema, DetectorSchema
 
 from typing_extensions import override
-from typing import Dict, List, Optional, Any
+from typing import Dict, List, Optional, Any, cast
 
 from detectmatelibrary.utils.time_format_handler import TimeFormatHandler
+from detectmatelibrary_tools.logging import logger
 
 
 _time_handler = TimeFormatHandler()
 
 
+class PersistConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    path: str = "./state"
+    interval_seconds: int = 300
+    events_until_save: int | None = None
+    auto_load: bool = False
+    storage_options: dict[str, Any] = {}
+
+
 def _extract_timestamp(
     input_: List[ParserSchema] | ParserSchema
 ) -> List[int]:
@@ -56,7 +71,7 @@ def get_configured_variables(
     # Extract template variables by position
     if hasattr(event_config, "variables"):
         for pos, var in event_config.variables.items():
-            if pos < len(input_["variables"]):
+            if isinstance(pos, int) and pos < len(input_["variables"]):
                 result[var.name] = input_["variables"][pos]
 
     # Extract header/log format variables by name
@@ -89,6 +104,45 @@ def get_global_variables(
     return result
 
 
+def validate_config_coverage(
+        detector_name: str,
+        config_events: EventsConfig | dict[str, Any],
+        event_persistency: persistency.EventPersistency,
+) -> None:
+    """Log warnings when configured EventIDs or variables have no training
+    data.
+
+    Args:
+        detector_name: Name of the detector (used in warning messages).
+        config_events: The detector's events configuration.
+        persistency: The persistency object populated during training.
+    """
+    config_ids = (
+        config_events.events.keys()
+        if isinstance(config_events, EventsConfig)
+        else config_events.keys()
+    )
+    if not config_ids:
+        return
+
+    events_seen = event_persistency.get_events_seen()
+    events_with_data = set(event_persistency.get_events_data().keys())
+
+    for event_id in config_ids:
+        if event_id not in events_seen:
+            logger.warning(
+                f"[{detector_name}] EventID {event_id!r} is configured but was "
+                "never observed in training data. Verify that EventIDs in your "
+                "config match those produced by the parser."
+            )
+        elif event_id not in events_with_data:
+            logger.warning(
+                f"[{detector_name}] EventID {event_id!r} was observed in training "
+                "data but no configured variables were extracted. Verify that "
+                "variable names/positions in your config match those in the data."
+            )
+
+
 class CoreDetectorConfig(CoreConfig):
     component_type: str = "detectors"
     method_type: str = "core_detector"
@@ -97,6 +151,7 @@ class CoreDetectorConfig(CoreConfig):
     auto_config: bool = True
     events: EventsConfig | dict[str, Any] = {}
     global_instances: Dict[str, _EventInstance] = {}
+    persist: PersistConfig | None = None
 
 
 class CoreDetector(CoreComponent):
@@ -119,6 +174,11 @@ def __init__(
             output_schema=DetectorSchema,
         )
 
+    def _register_persistency(self, event_persistency: persistency.EventPersistency) -> None:
+        self.saver = init_persistency(
+            self.name, cast(CoreDetectorConfig, self.config), event_persistency
+        )
+
     @override
     def run(
         self, input_: List[ParserSchema] | ParserSchema, output_: DetectorSchema  # type: ignore
@@ -158,3 +218,7 @@ def configure(
     @override
     def set_configuration(self) -> None:
         pass
+
+    @override
+    def post_train(self) -> None:
+        pass
diff --git a/src/detectmatelibrary/common/persist.py b/src/detectmatelibrary/common/persist.py
new file mode 100644
index 00000000..2e2d9710
--- /dev/null
+++ b/src/detectmatelibrary/common/persist.py
@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from detectmatelibrary.utils import persistency
+
+if TYPE_CHECKING:
+    from detectmatelibrary.common.detector import CoreDetectorConfig
+
+
+def init_persistency(
+    name: str,
+    config: "CoreDetectorConfig",
+    event_persistency: persistency.EventPersistency,
+) -> persistency.PersistencySaver | None:
+    """Build and start a PersistencySaver for `event_persistency`, or None if
+    disabled."""
+    if config.persist is None:
+        return None
+    p = config.persist
+    saver = persistency.PersistencySaver(
+        event_persistency,
+        persistency.PersistencySaverConfig(
+            path=f"{p.path}/{name}",
+            save_interval_seconds=p.interval_seconds,
+            events_until_save=p.events_until_save,
+            auto_load=p.auto_load,
+            storage_options=p.storage_options,
+        ),
+    )
+    saver.start()
+    return saver
diff --git a/src/detectmatelibrary/constants.py b/src/detectmatelibrary/constants.py
index 6f81780c..8b4729b7 100644
--- a/src/detectmatelibrary/constants.py
+++ b/src/detectmatelibrary/constants.py
@@ -3,3 +3,5 @@
 EVENT_TEMPLATE = "EventTemplate"
 EVENT_ID = "EventId"
 GLOBAL_EVENT_ID = "*"
+# frequencies from https://github.com/markbaggett/freq
+DEFAULT_FREQUENCIES = [["\f", [["f", 2]]], [" ", [[" ", 312527], ["$", 12], ["(", 1520], [",", 6], ["0", 2], ["4", 210], ["8", 75], ["<", 58], ["D", 5449], ["H", 14898], ["L", 6849], ["P", 10276], ["T", 23773], ["X", 290], ["`", 1958], ["d", 74474], ["h", 195782], ["l", 64742], ["p", 65902], ["t", 408490], ["x", 22], ["|", 38], ["#", 6], ["'", 3062], ["+", 2], ["/", 12], ["3", 300], ["7", 134], [";", 8], ["?", 8], ["C", 9334], ["G", 5688], ["K", 2484], ["O", 4266], ["S", 13139], ["W", 9355], ["[", 408], ["_", 220], ["c", 90632], ["g", 44086], ["k", 13940], ["o", 161371], ["s", 182472], ["w", 187994], ["{", 8], ["\"", 22346], ["&", 42], ["*", 112], [".", 2358], ["2", 691], ["6", 180], [":", 14], [">", 2], ["B", 12213], ["F", 8428], ["J", 5957], ["N", 7370], ["R", 5046], ["V", 3389], ["Z", 250], ["b", 109654], ["f", 95818], ["j", 6186], ["n", 56010], ["r", 54486], ["v", 15242], ["z", 238], ["~", 2], ["%", 2], [")", 2], ["-", 550], ["1", 1613], ["5", 132], ["9", 74], ["A", 16635], ["E", 4590], ["I", 45393], ["M", 17353], ["Q", 356], ["U", 753], ["Y", 2574], ["a", 293192], ["e", 47200], ["i", 125201], ["m", 99016], ["q", 5914], ["u", 27850], ["y", 29288]]], ["$", [[" ", 2], ["3", 2], ["2", 6], ["4", 10]]], ["(", [[" ", 2], ["\"", 34], ["$", 12], ["'", 24], ["*", 8], ["1", 28], ["3", 24], ["2", 30], ["5", 2], ["A", 54], ["C", 12], ["B", 32], ["E", 12], ["D", 16], ["G", 6], ["F", 40], ["I", 120], ["H", 48], ["K", 10], ["J", 2], ["M", 48], ["L", 14], ["O", 20], ["N", 26], ["P", 26], ["S", 46], ["U", 8], ["T", 124], ["W", 38], ["V", 2], ["Y", 4], ["_", 14], ["a", 306], ["`", 2], ["c", 22], ["b", 50], ["e", 24], ["d", 18], ["g", 10], ["f", 80], ["i", 122], ["h", 102], ["k", 2], ["j", 2], ["m", 20], ["l", 20], ["o", 86], ["n", 38], ["p", 16], ["s", 106], ["r", 6], ["u", 6], ["t", 240], ["w", 212], ["v", 2], ["y", 6], ["~", 8]]], [",", [["!", 2], [" ", 200706], ["\"", 10148], ["'", 1656], [")", 4], ["*", 18], ["-", 780], [",", 10], ["1", 40], ["0", 263], ["3", 6], ["2", 42], ["5", 44], ["4", 28], ["7", 4], ["6", 20], ["9", 12], ["8", 18], [":", 4], ["A", 4], ["I", 42], ["J", 2], ["M", 2], ["T", 2], ["[", 2], ["a", 328], ["c", 8], ["b", 76], ["e", 6], ["d", 4], ["g", 10], ["f", 60], ["i", 36], ["h", 36], ["k", 6], ["m", 10], ["l", 6], ["o", 22], ["n", 8], ["q", 2], ["p", 2], ["s", 64], ["r", 8], ["t", 84], ["w", 70]]], ["0", [[" ", 512], ["%", 16], ["'", 14], [")", 20], ["-", 20], [",", 155], [".", 70], ["1", 38], ["0", 714], ["3", 17], ["2", 32], ["5", 34], ["4", 13], ["7", 30], ["6", 21], ["9", 34], ["8", 20], [";", 8], [":", 22], ["@", 20], ["I", 6], ["]", 46], ["m", 2], ["s", 6], ["t", 74], ["x", 10], ["}", 18]]], ["4", [[" ", 70], ["'", 4], [")", 2], ["-", 12], [",", 70], [".", 46], ["1", 24], ["0", 82], ["3", 24], ["2", 24], ["5", 34], ["4", 16], ["7", 28], ["6", 16], ["9", 24], ["8", 34], [";", 6], [":", 44], ["@", 8], ["T", 2], ["]", 60], ["t", 64], ["}", 18], ["|", 32]]], ["8", [[" ", 64], ["'", 6], ["-", 12], [",", 68], [".", 28], ["1", 192], ["0", 155], ["3", 132], ["2", 89], ["5", 26], ["4", 56], ["7", 26], ["6", 74], ["9", 37], ["8", 12], [";", 12], [":", 14], ["?", 2], ["@", 10], ["]", 54], ["m", 2], ["t", 56], ["}", 18], ["|", 44]]], ["<", [["A", 64], ["C", 132], ["B", 10], ["E", 18], ["D", 14], ["G", 4], ["F", 20], ["I", 14], ["H", 94], ["K", 2], ["M", 14], ["L", 8], ["O", 14], ["N", 2], ["P", 14], ["S", 14], ["R", 10], ["T", 224], ["W", 24], ["Y", 2], ["m", 2], ["s", 2]]], ["@", [[" ", 102], ["c", 8], ["e", 14], [",", 8], [".", 8], ["u", 6], ["v", 16]]], ["D", [["!", 4], [" ", 358], ["'", 72], ["*", 16], ["-", 64], [",", 14], [".", 66], [";", 2], ["?", 2], ["A", 93], ["C", 2], ["E", 240], ["D", 2], ["G", 10], ["F", 8], ["I", 220], ["M", 2], ["L", 2], ["O", 89], ["N", 14], ["P", 2], ["S", 28], ["R", 70], ["U", 24], ["V", 2], ["Y", 12], ["a", 1027], ["e", 2124], ["i", 779], ["j", 6], ["m", 148], ["o", 2366], ["n", 8], ["r", 642], ["u", 914], ["w", 4], ["y", 20]]], ["H", [[" ", 112], ["'", 14], [",", 8], [".", 210], ["1", 126], ["3", 42], ["2", 54], ["5", 12], ["4", 12], ["7", 12], ["6", 12], ["9", 12], ["8", 12], ["?", 2], ["A", 410], ["E", 722], ["F", 4], ["I", 298], ["M", 4], ["O", 260], ["N", 2], ["Q", 4], ["S", 6], ["R", 20], ["U", 26], ["T", 60], ["Y", 20], ["a", 2890], ["e", 16114], ["i", 2886], ["h", 2], ["m", 2], ["o", 2880], ["s", 4], ["u", 596], ["v", 2], ["y", 24]]], ["L", [["!", 2], [" ", 102], ["'", 40], [")", 2], ["-", 4], [",", 10], [".", 40], ["1", 6], ["2", 8], ["5", 2], ["4", 2], ["6", 2], ["8", 2], [":", 8], ["A", 120], ["C", 14], ["E", 261], ["D", 38], ["G", 14], ["F", 26], ["I", 210], ["H", 4], ["K", 46], ["J", 2], ["M", 6], ["L", 134], ["O", 98], ["N", 2], ["P", 4], ["S", 36], ["R", 6], ["U", 84], ["T", 12], ["W", 2], ["Y", 32], ["a", 2534], ["e", 1957], ["i", 1482], ["h", 70], ["l", 2], ["o", 2216], ["u", 614], ["w", 2], ["y", 30]]], ["P", [["!", 2], [" ", 30], ["-", 4], [".", 72], ["A", 198], ["E", 228], ["G", 8], ["I", 66], ["H", 24], ["K", 2], ["M", 8], ["L", 90], ["O", 110], ["P", 26], ["S", 18], ["R", 198], ["U", 54], ["T", 202], ["Y", 10], ["a", 2387], ["e", 1866], ["f", 50], ["i", 2690], ["h", 472], ["l", 486], ["o", 1094], ["s", 84], ["r", 4898], ["u", 314], ["t", 12], ["w", 2], ["y", 38]]], ["T", [["!", 20], [" ", 496], ["'", 18], ["*", 34], ["-", 20], [",", 66], [".", 132], [":", 6], ["A", 150], ["C", 14], ["B", 2], ["E", 2568], ["F", 2], ["I", 236], ["H", 1216], ["M", 20], ["L", 24], ["O", 330], ["N", 14], ["P", 14], ["S", 62], ["R", 71], ["U", 70], ["T", 106], ["W", 110], ["Y", 144], ["Z", 2], ["a", 643], ["e", 802], ["i", 1134], ["h", 41758], ["o", 3328], ["s", 100], ["r", 532], ["u", 500], ["w", 517], ["v", 8], ["y", 54], ["z", 4]]], ["X", [["A", 2], [" ", 22], ["C", 6], ["E", 2], ["'", 2], ["I", 444], ["-", 2], [",", 4], [".", 84], ["1", 2], ["P", 6], ["2", 2], ["u", 30], ["T", 78], ["V", 302], ["X", 266], [":", 6], ["e", 4]]], ["`", [[" ", 4], ["\"", 2], ["'", 2], ["2", 2], ["A", 122], ["C", 26], ["B", 74], ["E", 14], ["D", 38], ["G", 30], ["F", 28], ["I", 270], ["H", 66], ["K", 4], ["J", 30], ["M", 66], ["L", 44], ["O", 26], ["N", 52], ["P", 34], ["S", 80], ["R", 14], ["U", 6], ["T", 166], ["W", 92], ["V", 4], ["Y", 66], ["_", 2], ["a", 62], ["c", 32], ["b", 40], ["e", 40], ["d", 24], ["g", 28], ["f", 38], ["i", 24], ["h", 26], ["k", 6], ["j", 2], ["m", 40], ["l", 28], ["o", 24], ["n", 14], ["q", 2], ["p", 40], ["s", 34], ["r", 18], ["u", 10], ["t", 98], ["w", 22], ["v", 2], ["y", 8]]], ["d", [["!", 1346], [" ", 316392], ["\"", 78], ["'", 892], [")", 158], ["-", 2110], [",", 27454], [".", 15448], ["1", 6], [";", 2238], [":", 1318], ["?", 904], [">", 32], ["]", 6], ["_", 10], ["a", 15612], ["`", 12], ["c", 64], ["b", 98], ["e", 66856], ["d", 5952], ["g", 2672], ["f", 682], ["i", 36856], ["h", 178], ["k", 152], ["j", 316], ["m", 1162], ["l", 4894], ["o", 27386], ["n", 2680], ["q", 32], ["p", 44], ["s", 12352], ["r", 13004], ["u", 5376], ["t", 176], ["w", 382], ["v", 1300], ["y", 5438], ["z", 4], ["}", 6]]], ["h", [["!", 1480], [" ", 66490], ["\"", 16], ["'", 580], [")", 46], ["-", 674], [",", 7634], [".", 3060], [";", 500], [":", 124], ["?", 354], [">", 8], ["_", 8], ["a", 130321], ["`", 2], ["c", 78], ["b", 454], ["e", 366316], ["d", 180], ["g", 2], ["f", 464], ["i", 118000], ["h", 16], ["k", 98], ["m", 1012], ["l", 810], ["o", 56794], ["n", 878], ["q", 34], ["p", 20], ["s", 1392], ["r", 8693], ["u", 9628], ["t", 23686], ["w", 410], ["v", 4], ["y", 4342], ["z", 2]]], ["l", [["!", 688], [" ", 55493], ["\"", 28], ["'", 776], [")", 58], ["*", 8], ["-", 1168], [",", 9058], ["/", 2], [".", 4175], ["1", 2], ["2", 4], [";", 588], [":", 138], ["?", 512], [">", 18], ["@", 2], ["]", 2], ["_", 14], ["a", 40424], ["c", 880], ["b", 428], ["e", 90647], ["d", 35897], ["g", 498], ["f", 11866], ["i", 53960], ["h", 30], ["k", 3952], ["j", 880], ["m", 2350], ["l", 72010], ["o", 43088], ["n", 488], ["q", 6], ["p", 1936], ["s", 9240], ["r", 1482], ["u", 8878], ["t", 7890], ["w", 1710], ["v", 3288], ["y", 43772], ["x", 2], ["z", 52]]], ["p", [["!", 222], [" ", 12684], ["\"", 12], ["'", 274], [")", 8], ["*", 16], ["-", 458], [",", 2678], [".", 1598], [";", 206], [":", 32], ["?", 102], [">", 2], ["_", 2], ["a", 24384], ["c", 110], ["b", 74], ["e", 40018], ["d", 12], ["g", 26], ["f", 100], ["i", 12578], ["h", 3890], ["k", 248], ["m", 220], ["l", 19938], ["o", 24960], ["n", 82], ["p", 12676], ["s", 4980], ["r", 27372], ["u", 7468], ["t", 8624], ["w", 150], ["y", 1538], ["z", 4]]], ["t", [["!", 1698], [" ", 244288], ["\"", 74], ["'", 4144], [")", 206], ["*", 10], ["-", 2634], [",", 24442], ["/", 22], [".", 15012], ["9", 30], [";", 1952], [":", 386], ["?", 2014], [">", 34], ["@", 16], ["I", 4], ["N", 2], ["]", 6], ["_", 20], ["a", 36864], ["c", 4804], ["b", 164], ["e", 93708], ["d", 32], ["g", 50], ["f", 1186], ["i", 67393], ["h", 380618], ["k", 30], ["j", 2], ["m", 1109], ["l", 15192], ["o", 120320], ["n", 980], ["p", 168], ["s", 20376], ["r", 31046], ["u", 18070], ["t", 25046], ["w", 8348], ["v", 6], ["y", 14950], ["x", 22], ["z", 596]]], ["x", [["!", 16], [" ", 1654], ["'", 108], [")", 6], ["-", 174], [",", 480], ["/", 2], [".", 262], ["1", 10], [";", 40], [":", 6], ["?", 20], ["_", 4], ["a", 1314], ["c", 2462], ["b", 4], ["e", 1456], ["g", 2], ["f", 26], ["i", 1676], ["h", 354], ["l", 20], ["o", 82], ["q", 56], ["p", 3828], ["s", 6], ["u", 144], ["t", 3514], ["w", 4], ["y", 88], ["x", 30]]], ["|", [[" ", 30], ["C", 294]]], ["#", [["1", 6], [" ", 2]]], ["'", [["!", 22], [" ", 5218], ["\"", 130], ["'", 52], [")", 8], ["-", 136], [",", 274], [".", 194], ["9", 24], ["8", 10], [";", 12], [":", 4], ["?", 40], ["A", 506], ["C", 94], ["B", 292], ["E", 88], ["D", 124], ["G", 154], ["F", 90], ["I", 826], ["H", 360], ["K", 12], ["J", 52], ["M", 174], ["L", 102], ["O", 202], ["N", 222], ["Q", 12], ["P", 86], ["S", 328], ["R", 24], ["U", 38], ["T", 922], ["W", 482], ["V", 22], ["Y", 356], ["a", 288], ["c", 614], ["b", 42], ["e", 614], ["d", 2832], ["g", 48], ["f", 28], ["i", 98], ["h", 36], ["k", 6], ["m", 1148], ["l", 1792], ["o", 90], ["n", 44], ["q", 2], ["p", 40], ["s", 16835], ["r", 660], ["u", 62], ["t", 7172], ["w", 60], ["v", 880], ["y", 66], ["}", 2]]], ["+", [[";", 2], ["B", 2], ["-", 4]]], ["/", [[" ", 26], ["\"", 2], ["e", 20], ["I", 14], ["h", 6], ["1", 2], ["s", 2], ["2", 4], ["5", 4], ["4", 2], ["6", 2]]], ["3", [["!", 2], [" ", 76], [")", 18], ["*", 8], ["-", 6], [",", 98], ["/", 2], [".", 66], ["1", 54], ["0", 158], ["3", 44], ["2", 60], ["5", 42], ["4", 18], ["7", 38], ["6", 24], ["9", 26], ["8", 20], [";", 10], [":", 48], ["?", 2], ["@", 4], ["]", 60], ["d", 6], ["i", 4], ["h", 2], ["r", 50], ["t", 26], ["v", 2], ["}", 18], ["|", 38]]], ["7", [["!", 2], [" ", 64], ["'", 10], ["-", 8], [",", 68], ["/", 4], [".", 46], ["1", 21], ["0", 36], ["3", 12], ["2", 35], ["5", 16], ["4", 14], ["7", 32], ["6", 26], ["9", 40], ["8", 34], [";", 10], [":", 28], ["@", 18], ["]", 48], ["h", 2], ["m", 4], ["t", 34], ["}", 18], ["|", 26]]], [";", [[" ", 14368], ["\"", 42], ["'", 54], ["h", 2], ["*", 2], ["-", 146], [",", 2], ["[", 4]]], ["?", [[" ", 5000], ["\"", 7386], ["'", 680], [")", 14], ["-", 90], [",", 2], [".", 118], ["[", 2], ["?", 2], [">", 2]]], ["C", [[" ", 50], ["\"", 14], ["'", 12], ["*", 2], ["-", 4], [",", 6], ["/", 2], [".", 24], ["A", 126], ["C", 22], ["E", 112], ["D", 20], ["I", 76], ["H", 3260], ["K", 60], ["L", 26], ["O", 164], ["P", 6], ["S", 8], ["R", 38], ["U", 26], ["T", 117], ["Y", 16], ["a", 2763], ["e", 294], ["i", 277], ["h", 2428], ["l", 446], ["o", 4926], ["s", 4], ["r", 556], ["u", 212], ["y", 42], ["z", 24]]], ["G", [["!", 2], [" ", 132], ["\"", 8], ["'", 8], ["-", 56], [",", 22], [".", 10], [";", 2], [":", 2], ["?", 4], ["A", 72], ["E", 134], ["G", 10], ["F", 2], ["I", 34], ["H", 70], ["L", 16], ["O", 60], ["N", 14], ["S", 10], ["R", 64], ["U", 92], ["T", 2], ["Y", 2], ["Z", 2], ["a", 744], ["e", 958], ["d", 2], ["i", 460], ["h", 266], ["l", 212], ["o", 2628], ["n", 6], ["r", 1160], ["u", 880], ["w", 2], ["y", 2]]], ["K", [[" ", 28], ["'", 2], [",", 6], [".", 8], ["?", 2], ["A", 4], ["E", 64], ["F", 2], ["I", 44], ["H", 2], ["K", 4], ["L", 12], ["O", 2], ["N", 4], ["S", 12], ["R", 6], ["U", 2], ["W", 4], ["Y", 2], ["a", 442], ["e", 504], ["i", 860], ["h", 122], ["l", 40], ["o", 290], ["n", 96], ["r", 96], ["u", 782], ["y", 10]]], ["O", [["!", 6], [" ", 466], ["\"", 2], ["'", 106], ["-", 4], [",", 12], [".", 38], [":", 2], ["?", 2], ["A", 6], ["C", 47], ["B", 32], ["E", 13], ["D", 52], ["G", 52], ["F", 288], ["I", 18], ["H", 28], ["K", 222], ["J", 50], ["M", 160], ["L", 98], ["O", 78], ["N", 489], ["P", 30], ["S", 64], ["R", 346], ["U", 338], ["T", 104], ["W", 64], ["V", 39], ["Y", 8], ["Z", 2], ["a", 2], ["c", 234], ["b", 128], ["e", 2], ["d", 26], ["g", 14], ["f", 1458], ["i", 6], ["h", 1000], ["k", 2], ["m", 60], ["l", 240], ["o", 44], ["n", 3744], ["p", 86], ["s", 22], ["r", 798], ["u", 554], ["t", 162], ["w", 32], ["v", 74], ["y", 2], ["x", 6], ["z", 68]]], ["S", [["!", 8], [" ", 616], ["'", 12], ["*", 6], ["-", 20], [",", 40], [".", 122], [";", 2], [":", 12], ["?", 2], ["A", 56], ["C", 58], ["E", 296], ["D", 2], ["G", 4], ["F", 4], ["I", 91], ["H", 76], ["K", 8], ["M", 14], ["L", 10], ["O", 98], ["N", 2], ["Q", 4], ["P", 30], ["S", 104], ["R", 2], ["U", 42], ["T", 322], ["W", 4], ["Y", 2], ["a", 2150], ["c", 1208], ["e", 1405], ["i", 968], ["h", 5152], ["k", 34], ["m", 374], ["l", 166], ["o", 4132], ["n", 120], ["q", 44], ["p", 776], ["s", 2], ["u", 1246], ["t", 1564], ["w", 144], ["v", 8], ["y", 126], ["z", 18]]], ["W", [["!", 2], [" ", 58], [")", 2], [",", 10], [".", 28], ["A", 136], ["E", 96], ["D", 4], ["G", 2], ["I", 90], ["H", 128], ["L", 4], ["O", 76], ["N", 12], ["S", 2], ["R", 8], ["Y", 4], ["a", 1096], ["e", 4362], ["i", 2096], ["h", 10098], ["o", 1611], ["r", 58], ["u", 18]]], ["[", [["*", 2], ["1", 112], ["3", 56], ["2", 112], ["5", 30], ["4", 40], ["7", 4], ["6", 34], ["9", 4], ["8", 2], ["A", 12], ["C", 2], ["B", 6], ["E", 24], ["D", 4], ["G", 14], ["F", 2], ["I", 22], ["H", 30], ["J", 34], ["M", 28], ["L", 16], ["N", 4], ["P", 42], ["S", 6], ["R", 36], ["T", 18], ["W", 4], ["a", 2], ["b", 4], ["d", 2], ["g", 2], ["f", 14], ["m", 2], ["l", 4], ["o", 4], ["p", 6], ["s", 4], ["t", 50]]], ["_", [[" ", 100], ["'", 2], ["-", 12], [",", 38], [".", 28], [";", 4], ["A", 14], ["D", 2], ["I", 30], ["H", 4], ["M", 4], ["L", 2], ["O", 2], ["N", 2], ["T", 12], ["_", 736], ["^", 6], ["a", 14], ["c", 12], ["b", 4], ["e", 6], ["d", 6], ["f", 14], ["i", 4], ["h", 2], ["m", 8], ["l", 6], ["o", 2], ["n", 14], ["p", 4], ["s", 10], ["r", 2], ["u", 4], ["t", 10], ["w", 8], ["v", 4], ["y", 4], ["x", 4]]], ["c", [["!", 38], [" ", 2940], ["\"", 6], ["'", 62], ["-", 122], [",", 498], [".", 480], [";", 56], [":", 18], ["?", 22], ["C", 8], ["G", 8], ["F", 2], ["L", 230], ["Q", 2], ["P", 2], ["S", 2], ["a", 38996], ["c", 5012], ["e", 54872], ["d", 38], ["i", 13186], ["h", 55038], ["k", 20111], ["m", 4], ["l", 12408], ["o", 57624], ["n", 26], ["q", 496], ["p", 66], ["s", 944], ["r", 13732], ["u", 9748], ["t", 19868], ["w", 8], ["v", 6], ["y", 1692], ["z", 12]]], ["g", [["!", 572], [" ", 77496], ["\"", 32], ["'", 490], [")", 44], ["-", 1388], [",", 8820], [".", 5284], [";", 654], [":", 276], ["?", 530], [">", 4], ["a", 16556], ["c", 8], ["b", 10], ["e", 31120], ["d", 134], ["g", 3662], ["f", 14], ["i", 11514], ["h", 36708], ["m", 368], ["l", 8714], ["o", 16464], ["n", 4300], ["p", 22], ["s", 6714], ["r", 16774], ["u", 6849], ["t", 1104], ["w", 42], ["y", 516], ["z", 14], ["}", 8]]], ["k", [["!", 306], [" ", 20132], ["\"", 14], ["'", 392], [")", 32], ["-", 554], [",", 4148], [".", 2414], ["1", 2], [";", 294], [":", 60], ["?", 214], [">", 10], ["@", 10], ["a", 870], ["c", 66], ["b", 38], ["e", 34087], ["d", 24], ["g", 58], ["f", 344], ["i", 13220], ["h", 948], ["k", 244], ["j", 22], ["m", 100], ["l", 2880], ["o", 816], ["n", 11134], ["q", 2], ["p", 12], ["s", 4228], ["r", 68], ["u", 68], ["t", 20], ["w", 314], ["v", 10], ["y", 768], ["z", 2]]], ["o", [["!", 648], [" ", 114177], ["\"", 18], ["'", 1162], [")", 38], ["-", 958], [",", 5210], [".", 2232], [";", 354], [":", 58], ["?", 516], ["K", 2], ["J", 2], ["]", 4], ["_", 6], ["a", 7834], ["`", 2], ["c", 9710], ["b", 5854], ["e", 2996], ["d", 16602], ["g", 5294], ["f", 99287], ["i", 10524], ["h", 872], ["k", 14852], ["j", 986], ["m", 51326], ["l", 30027], ["o", 36626], ["n", 131194], ["q", 172], ["p", 16136], ["s", 26802], ["r", 99219], ["u", 128095], ["t", 47116], ["w", 48246], ["v", 20522], ["y", 3366], ["x", 840], ["z", 456], ["}", 2]]], ["s", [["!", 2144], [" ", 245069], ["\"", 154], ["'", 1554], [")", 266], ["*", 14], ["-", 1948], [",", 37726], [".", 19990], ["1", 4], [";", 3000], [":", 928], ["=", 2], ["?", 1424], [">", 50], ["[", 6], ["]", 38], ["_", 24], ["a", 37342], ["c", 11410], ["b", 1092], ["e", 89922], ["d", 372], ["g", 288], ["f", 1206], ["i", 41018], ["h", 48184], ["k", 7002], ["j", 20], ["m", 5638], ["l", 7892], ["o", 41490], ["n", 2836], ["q", 1070], ["p", 17022], ["s", 38918], ["r", 118], ["u", 22362], ["t", 98283], ["w", 5082], ["v", 104], ["y", 2112], ["z", 8]]], ["w", [["!", 302], [" ", 25552], ["\"", 32], ["'", 332], [")", 38], ["-", 630], [",", 4620], ["/", 2], [".", 2130], [";", 296], [":", 56], ["?", 312], [">", 6], ["_", 4], ["a", 69912], ["c", 62], ["b", 88], ["e", 43746], ["d", 980], ["g", 230], ["f", 300], ["i", 50742], ["h", 55558], ["k", 232], ["j", 2], ["m", 12], ["l", 1768], ["o", 28157], ["n", 11280], ["p", 14], ["s", 3452], ["r", 3078], ["u", 116], ["t", 106], ["w", 8], ["y", 240], ["z", 2]]], ["{", [["`", 2], ["c", 2], ["E", 2], ["G", 2], ["s", 6], ["o", 4], ["1", 224], ["3", 226], ["2", 230], ["5", 24], ["4", 34], ["7", 22], ["6", 22], ["9", 22], ["8", 24], ["t", 8]]], ["\"", [[" ", 19496], ["\"", 12], ["'", 120], [")", 34], ["*", 70], ["-", 198], [",", 42], [".", 98], ["1", 4], ["3", 2], ["2", 4], ["5", 4], ["4", 4], ["6", 2], ["8", 6], [";", 74], [":", 2], ["?", 4], ["A", 4542], ["C", 1250], ["B", 2388], ["E", 472], ["D", 1474], ["G", 1096], ["F", 924], ["I", 8984], ["H", 2746], ["K", 138], ["J", 270], ["M", 1850], ["L", 912], ["O", 1848], ["N", 2630], ["Q", 110], ["P", 880], ["S", 1906], ["R", 350], ["U", 236], ["T", 5524], ["W", 6722], ["V", 340], ["Y", 4228], ["X", 4], ["[", 14], ["Z", 6], ["]", 8], ["_", 20], ["a", 732], ["`", 158], ["c", 118], ["b", 452], ["e", 46], ["d", 138], ["g", 54], ["f", 182], ["i", 408], ["h", 256], ["k", 10], ["j", 14], ["m", 148], ["l", 118], ["o", 112], ["n", 94], ["q", 4], ["p", 130], ["s", 230], ["r", 36], ["u", 32], ["t", 1014], ["w", 398], ["v", 22], ["y", 272]]], ["&", [["h", 2], ["c", 8], [" ", 26]]], ["*", [[" ", 206], ["\"", 146], [")", 6], ["*", 636], [",", 12], [".", 4], [":", 8], [">", 2], ["A", 16], ["C", 4], ["B", 16], ["E", 20], ["D", 8], ["G", 2], ["F", 12], ["I", 6], ["H", 4], ["K", 4], ["L", 4], ["O", 6], ["N", 2], ["P", 2], ["S", 16], ["T", 92], ["W", 18], ["V", 14], ["Y", 2], ["[", 36], ["]", 54], ["n", 6]]], [".", [["!", 36], [" ", 88376], ["\"", 12990], ["'", 1624], [")", 132], ["(", 2], ["*", 27], ["-", 436], [",", 236], [".", 4176], ["0", 16], ["2", 8], ["4", 6], ["7", 2], ["6", 2], ["9", 14], [";", 20], [":", 166], ["?", 38], ["A", 46], ["C", 12], ["B", 12], ["E", 20], ["D", 4], ["G", 22], ["F", 12], ["I", 138], ["H", 38], ["K", 2], ["J", 2], ["M", 34], ["L", 10], ["O", 10], ["N", 20], ["Q", 2], ["P", 8], ["S", 38], ["R", 2], ["U", 4], ["T", 108], ["W", 42], ["V", 6], ["Y", 20], ["[", 26], ["]", 10], ["_", 8], ["a", 4], ["`", 6], ["c", 32], ["b", 2], ["e", 36], ["i", 16], ["m", 26], ["o", 2], ["s", 4], ["u", 24], ["t", 40], ["x", 10], ["z", 2]]], ["2", [[" ", 128], ["\"", 2], ["'", 6], [")", 12], ["*", 6], ["-", 20], [",", 132], ["/", 2], [".", 82], ["1", 127], ["0", 229], ["3", 90], ["2", 98], ["5", 112], ["4", 96], ["7", 78], ["6", 88], ["9", 51], ["8", 80], [";", 4], [":", 56], ["@", 14], ["]", 70], ["d", 6], ["n", 28], ["t", 20], ["}", 20], ["|", 66]]], ["6", [[" ", 60], ["-", 12], [",", 70], ["/", 2], [".", 30], ["1", 24], ["0", 76], ["3", 14], ["2", 34], ["5", 26], ["4", 19], ["7", 26], ["6", 32], ["9", 21], ["8", 22], [";", 10], [":", 32], ["?", 2], ["@", 10], ["]", 44], ["m", 4], ["t", 68], ["}", 18], ["|", 52]]], [":", [[" ", 3056], ["\"", 2], ["'", 20], [")", 2], ["(", 8], ["*", 2], ["-", 1142], [".", 260], ["1", 118], ["I", 4], ["3", 44], ["2", 90], ["5", 14], ["4", 30], ["7", 14], ["6", 16], ["9", 12], ["8", 12], ["R", 4], ["r", 4]]], [">", [[" ", 88], ["#", 2], ["\"", 4], ["$", 2], ["-", 2], [",", 2], [":", 2], ["<", 24], ["A", 2], ["@", 2], ["C", 2], ["F", 8], ["I", 10], ["M", 2], ["L", 2], ["T", 14], ["W", 4], ["_", 2], ["^", 2], ["a", 6], ["c", 8], ["f", 10], ["i", 12], ["h", 6], ["m", 8], ["o", 8], ["p", 2], ["s", 8], ["t", 8], ["w", 6], ["v", 2], ["{", 2]]], ["B", [[" ", 16], ["'", 2], [",", 4], [".", 12], ["A", 44], ["C", 38], ["B", 6], ["E", 200], ["I", 62], ["K", 702], ["M", 6], ["L", 69], ["O", 247], ["S", 8], ["R", 26], ["U", 52], ["Y", 62], ["a", 2602], ["e", 3594], ["i", 1068], ["h", 100], ["j", 2], ["l", 520], ["o", 2392], ["r", 974], ["u", 8016], ["w", 2], ["y", 828]]], ["F", [["A", 194], [" ", 300], ["E", 36], ["F", 18], ["I", 98], ["j", 2], ["l", 372], ["O", 166], [",", 2], [">", 2], ["i", 958], ["r", 5046], ["U", 14], ["o", 3334], ["a", 2482], ["e", 430], ["R", 78], [".", 10], ["u", 184], ["L", 20], ["T", 30]]], ["J", [["A", 18], ["a", 1388], ["E", 82], ["d", 2], ["'", 2], ["I", 2], ["-", 2], ["o", 2830], [".", 132], ["i", 314], ["s", 2], ["U", 30], ["O", 54], ["e", 1904], ["u", 1679]]], ["N", [["!", 6], [" ", 451], ["\"", 8], ["'", 28], ["-", 4], [",", 48], [".", 96], [";", 2], [":", 8], ["?", 2], ["A", 108], ["C", 124], ["B", 48], ["E", 247], ["D", 328], ["G", 216], ["F", 2], ["I", 92], ["H", 2], ["K", 22], ["J", 2], ["L", 4], ["O", 186], ["N", 40], ["S", 124], ["R", 13], ["U", 20], ["T", 298], ["V", 13], ["Y", 14], ["a", 3392], ["e", 2202], ["i", 1384], ["o", 4850], ["u", 72]]], ["R", [["!", 2], [" ", 2352], ["\"", 4], ["'", 20], ["*", 6], ["-", 4], [",", 78], [".", 718], [":", 2], ["?", 2], ["A", 178], ["C", 20], ["B", 12], ["E", 320], ["D", 100], ["G", 68], ["F", 4], ["I", 219], ["K", 70], ["M", 30], ["L", 42], ["O", 189], ["N", 84], ["Q", 2], ["P", 18], ["S", 90], ["R", 70], ["U", 34], ["T", 272], ["W", 16], ["V", 14], ["Y", 93], ["a", 374], ["e", 1237], ["i", 323], ["h", 52], ["o", 2304], ["u", 2014], ["t", 2], ["y", 20]]], ["V", [["A", 47], ["a", 1798], ["B", 2], ["E", 276], ["'", 2], [" ", 18], ["I", 587], ["-", 2], [",", 12], ["O", 26], ["l", 30], ["i", 510], ["r", 4], ["U", 2], ["o", 228], ["y", 26], ["e", 465], ["R", 22], [".", 162], ["u", 4], ["Y", 6]]], ["Z", [["a", 32], ["\"", 2], ["E", 16], ["d", 4], ["I", 2], ["h", 68], [",", 4], ["o", 22], ["n", 30], ["i", 26], ["u", 10], ["O", 4], ["e", 124]]], ["b", [["!", 40], [" ", 1058], ["'", 68], [")", 4], ["*", 4], ["-", 98], [",", 414], [".", 244], [";", 24], [":", 6], ["?", 36], [">", 4], ["a", 13924], ["c", 22], ["b", 1618], ["e", 60104], ["d", 78], ["g", 4], ["f", 16], ["i", 6998], ["h", 46], ["j", 990], ["m", 324], ["l", 22082], ["o", 19980], ["n", 44], ["s", 2992], ["r", 13256], ["u", 20366], ["t", 1570], ["w", 30], ["v", 88], ["y", 13906]]], ["f", [["!", 178], [" ", 90391], ["\"", 8], ["'", 72], [")", 16], ["*", 2], ["-", 876], [",", 2770], [".", 1846], [";", 240], [":", 102], ["?", 144], ["G", 2], ["I", 2], ["a", 20108], ["c", 14], ["b", 38], ["e", 23990], ["d", 2], ["g", 10], ["f", 10886], ["i", 22788], ["h", 6], ["k", 12], ["j", 16], ["m", 12], ["l", 7808], ["o", 46468], ["n", 16], ["p", 2], ["s", 464], ["r", 21052], ["u", 10540], ["t", 10202], ["w", 62], ["v", 2], ["y", 396], ["x", 2]]], ["j", [["a", 724], ["!", 2], ["e", 4002], ["'", 2], ["i", 118], ["o", 3558], [".", 4], ["u", 4654]]], ["n", [["!", 1140], [" ", 164227], ["\"", 84], ["'", 9982], [")", 108], ["*", 6], ["-", 2184], [",", 19804], [".", 11592], [";", 1670], [":", 478], ["?", 1178], [">", 50], ["J", 4], ["]", 18], ["_", 4], ["a", 17316], ["c", 30762], ["b", 372], ["e", 74881], ["d", 155134], ["g", 116276], ["f", 3720], ["i", 23814], ["h", 996], ["k", 7828], ["j", 896], ["m", 518], ["l", 7014], ["o", 57750], ["n", 7832], ["q", 950], ["p", 298], ["s", 29725], ["r", 506], ["u", 4864], ["t", 72732], ["w", 558], ["v", 3580], ["y", 9090], ["x", 498], ["z", 154], ["}", 4]]], ["r", [["!", 1102], [" ", 128583], ["\"", 78], ["'", 2438], [")", 108], ["*", 14], ["-", 2050], [",", 18518], [".", 12898], [";", 1346], [":", 332], ["?", 1112], [">", 28], ["A", 2], ["@", 14], ["_", 6], ["a", 45838], ["c", 7992], ["b", 2520], ["e", 175663], ["d", 22490], ["g", 6450], ["f", 3064], ["i", 57977], ["h", 1474], ["k", 6764], ["j", 14], ["m", 12284], ["l", 8396], ["o", 61720], ["n", 15999], ["q", 220], ["p", 3358], ["s", 36440], ["r", 17042], ["u", 12282], ["t", 29678], ["w", 1522], ["v", 4906], ["y", 24200], ["x", 6], ["z", 128]]], ["v", [["!", 34], [" ", 1478], ["'", 360], [")", 2], ["-", 58], [",", 566], [".", 316], [";", 12], [":", 4], ["?", 30], ["_", 2], ["a", 8210], ["e", 85189], ["g", 2], ["i", 17242], ["k", 2], ["m", 16], ["l", 218], ["o", 6350], ["n", 508], ["s", 216], ["r", 658], ["u", 248], ["t", 4], ["v", 22], ["y", 640]]], ["z", [["!", 8], [" ", 344], ["\"", 2], ["'", 14], [")", 4], ["-", 40], [",", 172], [".", 178], [";", 8], [":", 2], ["?", 22], ["a", 592], ["b", 6], ["e", 3788], ["d", 18], ["g", 8], ["i", 920], ["h", 122], ["k", 6], ["m", 104], ["l", 356], ["o", 1122], ["n", 2], ["s", 6], ["r", 2], ["u", 156], ["v", 14], ["y", 202], ["z", 622]]], ["~", [[")", 6]]], ["\t", [["\t", 174], [" ", 136], ["D", 2]]], ["!", [["!", 12], [" ", 7580], ["\"", 6860], ["'", 556], [")", 42], ["*", 12], ["-", 108], [",", 4], [".", 170], ["I", 2], ["v", 6], ["[", 2], ["_", 6]]], ["%", [[" ", 8]]], [")", [[" ", 830], ["-", 56], [",", 506], [".", 102], ["5", 2], ["[", 2], [":", 16], [";", 58], ["?", 2]]], ["-", [["!", 8], [" ", 5090], ["\"", 550], ["'", 68], ["(", 2], ["+", 4], ["-", 6008], [",", 22], [".", 2], ["1", 12], ["2", 16], ["5", 24], ["4", 2], ["7", 4], ["6", 6], ["8", 4], ["?", 22], ["A", 170], ["C", 118], ["B", 200], ["E", 88], ["D", 116], ["G", 118], ["F", 62], ["I", 194], ["H", 172], ["K", 16], ["J", 90], ["M", 196], ["L", 74], ["O", 38], ["N", 44], ["Q", 6], ["P", 134], ["S", 172], ["R", 44], ["T", 160], ["W", 74], ["V", 28], ["Y", 22], ["Z", 4], ["a", 1098], ["`", 16], ["c", 1092], ["b", 1366], ["e", 476], ["d", 942], ["g", 452], ["f", 1014], ["i", 408], ["h", 966], ["k", 224], ["j", 64], ["m", 808], ["l", 922], ["o", 468], ["n", 446], ["q", 40], ["p", 884], ["s", 1836], ["r", 562], ["u", 122], ["t", 1410], ["w", 812], ["v", 66], ["y", 140], ["z", 12]]], ["1", [[" ", 112], ["'", 4], [")", 16], ["*", 10], ["-", 14], [",", 112], ["/", 2], [".", 68], ["1", 246], ["0", 318], ["3", 164], ["2", 280], ["5", 224], ["4", 214], ["7", 188], ["6", 204], ["9", 126], ["8", 572], [";", 4], [":", 40], ["@", 4], ["O", 2], ["]", 48], ["s", 52], ["t", 22], ["}", 18], ["|", 88]]], ["5", [[" ", 98], ["\"", 2], ["'", 2], ["-", 4], [",", 88], [".", 46], ["1", 22], ["0", 140], ["3", 28], ["2", 32], ["5", 32], ["4", 22], ["7", 32], ["6", 16], ["9", 14], ["8", 18], [";", 10], [":", 48], ["?", 2], ["@", 14], ["]", 64], ["t", 82], ["}", 18], ["|", 44]]], ["9", [[" ", 74], ["'", 2], [")", 4], ["-", 6], [",", 40], [".", 22], ["1", 26], ["0", 43], ["3", 48], ["2", 14], ["5", 18], ["4", 15], ["7", 34], ["6", 20], ["9", 18], ["8", 10], [";", 12], [":", 38], ["@", 6], ["]", 44], ["t", 32], ["}", 18], ["|", 46]]], ["=", [["E", 2], ["=", 8], ["T", 14], [" ", 12]]], ["A", [[" ", 4464], ["\"", 2], ["'", 12], ["-", 18], [",", 4], [".", 24], ["A", 6], ["C", 108], ["B", 58], ["E", 22], ["D", 77], ["G", 50], ["F", 18], ["I", 98], ["H", 10], ["K", 18], ["M", 89], ["L", 220], ["N", 497], ["Q", 2], ["P", 2116], ["S", 220], ["R", 481], ["U", 44], ["T", 292], ["W", 18], ["V", 78], ["Y", 66], ["X", 6], ["Z", 2], ["a", 2], ["c", 208], ["b", 496], ["e", 2], ["d", 372], ["g", 352], ["f", 1144], ["i", 66], ["h", 554], ["k", 64], ["j", 4], ["m", 1358], ["l", 3042], ["o", 140], ["n", 12454], ["q", 4], ["p", 230], ["s", 2898], ["r", 1643], ["u", 754], ["t", 3060], ["w", 48], ["v", 60], ["y", 30], ["x", 2], ["z", 30]]], ["E", [["!", 20], [" ", 1253], ["\"", 2], ["'", 18], ["*", 2], ["-", 14], [",", 30], [".", 100], [":", 8], ["?", 4], ["A", 176], ["C", 152], ["B", 30], ["E", 92], ["D", 166], ["G", 32], ["F", 34], ["I", 60], ["H", 6], ["K", 8], ["M", 80], ["L", 142], ["O", 14], ["N", 490], ["Q", 6], ["P", 124], ["S", 360], ["R", 730], ["U", 18], ["T", 184], ["W", 90], ["V", 102], ["Y", 34], ["X", 64], ["a", 450], ["c", 46], ["b", 14], ["d", 90], ["g", 62], ["f", 20], ["i", 64], ["h", 58], ["k", 6], ["m", 1500], ["l", 226], ["o", 4], ["n", 1398], ["q", 20], ["p", 138], ["s", 148], ["r", 118], ["u", 358], ["t", 98], ["v", 1326], ["y", 70], ["x", 298], ["z", 2], ["}", 2]]], ["I", [["!", 34], [" ", 40514], ["\"", 4], ["'", 2748], ["-", 52], [",", 526], [".", 576], [";", 42], [":", 6], ["?", 88], ["A", 76], ["C", 182], ["B", 47], ["E", 82], ["D", 78], ["G", 140], ["F", 78], ["I", 1054], ["K", 12], ["M", 76], ["L", 150], ["O", 134], ["N", 704], ["Q", 4], ["P", 18], ["S", 277], ["R", 122], ["U", 2], ["T", 378], ["V", 298], ["X", 156], ["Z", 8], ["_", 46], ["a", 2], ["c", 146], ["b", 10], ["d", 16], ["g", 48], ["f", 1944], ["m", 196], ["l", 216], ["o", 30], ["n", 5298], ["p", 28], ["s", 930], ["r", 122], ["t", 8656], ["v", 100], ["x", 2], ["z", 2]]], ["M", [["!", 4], [" ", 68], ["\"", 2], ["'", 12], ["-", 4], [",", 12], ["/", 8], [".", 1208], [":", 2], ["A", 346], ["C", 28], ["B", 34], ["E", 243], ["D", 6], ["G", 12], ["I", 130], ["M", 24], ["L", 2], ["O", 117], ["N", 16], ["P", 50], ["S", 26], ["R", 8], ["U", 28], ["W", 6], ["Y", 24], ["a", 8688], ["c", 378], ["e", 1576], ["f", 2], ["i", 2158], ["o", 4266], ["s", 2], ["r", 2578], ["u", 518], ["y", 1492]]], ["Q", [["U", 48], ["C", 2], ["u", 494], [".", 4]]], ["U", [["!", 2], [" ", 106], ["'", 6], [",", 2], [".", 10], ["A", 16], ["C", 48], ["B", 24], ["E", 54], ["D", 44], ["G", 12], ["F", 6], ["I", 12], ["K", 2], ["M", 60], ["L", 68], ["N", 116], ["P", 26], ["S", 130], ["R", 182], ["U", 2], ["T", 156], ["V", 2], ["Z", 6], ["c", 2], ["g", 12], ["h", 34], ["k", 4], ["m", 16], ["l", 30], ["n", 859], ["p", 360], ["s", 32], ["r", 68], ["t", 50], ["v", 16]]], ["Y", [["!", 4], [" ", 260], ["\"", 2], ["'", 4], ["-", 68], [",", 10], [".", 22], [";", 2], ["A", 2], ["B", 2], ["E", 26], ["L", 4], ["O", 112], ["S", 26], ["R", 4], ["T", 2], ["a", 122], ["c", 2], ["e", 1328], ["i", 10], ["o", 3878], ["s", 10], ["u", 26], ["v", 8]]], ["]", [["!", 2], [" ", 322], ["J", 2], ["-", 2], [",", 44], [".", 14], [";", 24], [">", 2]]], ["a", [["!", 310], [" ", 65518], ["\"", 24], ["'", 716], [")", 20], ["*", 1], ["-", 724], [",", 2766], [".", 1558], ["1", 2], [";", 152], [":", 30], ["?", 144], [">", 2], ["S", 2], ["_", 6], ["a", 122], ["`", 6], ["c", 35608], ["b", 19042], ["e", 752], ["d", 56288], ["g", 18377], ["f", 7666], ["i", 47228], ["h", 1140], ["k", 13604], ["j", 480], ["m", 24754], ["l", 68865], ["o", 314], ["n", 216874], ["q", 102], ["p", 18548], ["s", 105951], ["r", 97182], ["u", 12725], ["t", 135418], ["w", 10880], ["v", 25744], ["y", 29029], ["x", 666], ["z", 1906], ["}", 2]]], ["e", [["!", 3010], [" ", 487805], ["\"", 166], ["'", 4249], [")", 336], ["*", 10], ["-", 4298], [",", 40540], [".", 24278], [";", 3704], [":", 890], ["?", 2866], [">", 78], ["B", 2], ["I", 2], ["S", 2], ["[", 6], ["]", 18], ["_", 42], ["a", 79086], ["`", 2], ["c", 27918], ["b", 1598], ["e", 45884], ["d", 142368], ["g", 8394], ["f", 13916], ["i", 18692], ["h", 2842], ["k", 1590], ["j", 380], ["m", 31126], ["l", 54118], ["o", 4898], ["n", 129345], ["q", 1706], ["p", 17078], ["s", 100714], ["r", 205409], ["u", 2658], ["t", 41944], ["w", 11422], ["v", 24561], ["y", 23800], ["x", 14052], ["z", 560], ["}", 4]]], ["i", [["!", 50], [" ", 1222], ["\"", 2], ["'", 184], [")", 4], ["*", 2], ["-", 384], [",", 450], [".", 254], [";", 14], [":", 6], ["?", 14], ["@", 2], ["G", 2], ["Y", 2], ["]", 2], ["_", 8], ["a", 10716], ["c", 45183], ["b", 6986], ["e", 33445], ["d", 40015], ["g", 26388], ["f", 17002], ["i", 24], ["h", 72], ["k", 7006], ["j", 18], ["m", 40198], ["l", 43870], ["o", 33038], ["n", 232657], ["q", 394], ["p", 5884], ["s", 107323], ["r", 32008], ["u", 1844], ["t", 102683], ["w", 38], ["v", 16166], ["y", 2], ["x", 2074], ["z", 2892]]], ["m", [["!", 462], [" ", 35852], ["\"", 24], ["'", 294], [")", 58], ["-", 610], [",", 7564], [".", 6290], ["1", 2], [";", 758], [":", 298], ["?", 470], [">", 22], ["]", 2], ["a", 45673], ["c", 96], ["b", 7420], ["e", 83120], ["d", 36], ["g", 4], ["f", 768], ["i", 24836], ["h", 10], ["k", 22], ["m", 5770], ["l", 522], ["o", 32940], ["n", 1218], ["p", 15046], ["s", 8640], ["r", 202], ["u", 10278], ["t", 200], ["w", 24], ["y", 17480]]], ["q", [["a", 2], [" ", 2], ["u", 12073], [",", 2], ["'", 2]]], ["u", [["!", 428], [" ", 17752], ["\"", 16], ["'", 1182], [")", 6], ["-", 186], [",", 1924], [".", 1140], [";", 124], [":", 18], ["?", 428], ["S", 12], ["T", 2], ["_", 2], ["a", 6632], ["c", 12934], ["b", 5730], ["e", 10797], ["d", 6988], ["g", 18286], ["f", 2056], ["i", 9148], ["h", 30], ["k", 496], ["j", 84], ["m", 8440], ["l", 37068], ["o", 708], ["n", 43221], ["q", 64], ["p", 17232], ["s", 44836], ["r", 48568], ["u", 18], ["t", 49162], ["w", 10], ["v", 428], ["y", 210], ["x", 498], ["z", 722]]], ["y", [["!", 1032], [" ", 118640], ["\"", 62], ["'", 1440], [")", 154], ["-", 2010], [",", 18388], [".", 10860], [";", 1366], [":", 466], ["?", 946], [">", 26], ["]", 2], ["_", 4], ["a", 2624], ["`", 2], ["c", 242], ["b", 640], ["e", 11272], ["d", 206], ["g", 138], ["f", 198], ["i", 4422], ["h", 84], ["k", 76], ["m", 714], ["l", 818], ["o", 28106], ["n", 212], ["p", 410], ["s", 8723], ["r", 738], ["u", 58], ["t", 3028], ["w", 464], ["v", 110], ["x", 14], ["z", 40]]], ["}", [[" ", 6], [",", 2]]]]  # noqa: E501
diff --git a/src/detectmatelibrary/detectors/__init__.py b/src/detectmatelibrary/detectors/__init__.py
index 7ca736ec..361db003 100644
--- a/src/detectmatelibrary/detectors/__init__.py
+++ b/src/detectmatelibrary/detectors/__init__.py
@@ -1,10 +1,19 @@
 from .random_detector import RandomDetector, RandomDetectorConfig
 from .new_value_detector import NewValueDetector, NewValueDetectorConfig
+from .new_event_detector import NewEventDetector, NewEventDetectorConfig
+from .value_range_detector import ValueRangeDetector, ValueRangeDetectorConfig
+from .charset_detector import CharsetDetector, CharsetDetectorConfig
 
 __all__ = [
     "random_detector",
     "RandomDetectorConfig",
     "NewValueDetector",
     "NewValueDetectorConfig",
-    "RandomDetector"
+    "RandomDetector",
+    "NewEventDetector",
+    "NewEventDetectorConfig",
+    "ValueRangeDetector",
+    "ValueRangeDetectorConfig",
+    "CharsetDetector",
+    "CharsetDetectorConfig"
 ]
diff --git a/src/detectmatelibrary/detectors/bigram_frequency_detector.py b/src/detectmatelibrary/detectors/bigram_frequency_detector.py
new file mode 100644
index 00000000..4daf163a
--- /dev/null
+++ b/src/detectmatelibrary/detectors/bigram_frequency_detector.py
@@ -0,0 +1,285 @@
+from typing import Any, cast
+
+from detectmatelibrary.common._config._compile import generate_detector_config
+from detectmatelibrary.common._config._formats import EventsConfig
+from detectmatelibrary.common.detector import (
+    CoreDetectorConfig,
+    CoreDetector,
+    get_configured_variables,
+    get_global_variables,
+    validate_config_coverage,
+)
+from detectmatelibrary.utils.persistency.event_data_structures.trackers.stability.stability_tracker import (
+    EventStabilityTracker,
+    SingleStabilityTracker,
+)
+from detectmatelibrary.utils.persistency.event_persistency import EventPersistency
+from detectmatelibrary.utils.data_buffer import BufferMode
+from detectmatelibrary.schemas import ParserSchema, DetectorSchema
+from detectmatelibrary.constants import GLOBAL_EVENT_ID, DEFAULT_FREQUENCIES
+from typing_extensions import override
+from detectmatelibrary_tools.logging import logger
+
+
+_DEFAULT_FREQ: dict[str, dict[str, int]] | None = None
+_DEFAULT_TOTAL_FREQ: dict[str, int] | None = None
+
+
+def _default_freq_tables() -> tuple[dict[str, dict[str, int]], dict[str, int]]:
+    """Lazily parse DEFAULT_FREQUENCIES into string-keyed lookup tables."""
+    global _DEFAULT_FREQ, _DEFAULT_TOTAL_FREQ
+    if _DEFAULT_FREQ is None or _DEFAULT_TOTAL_FREQ is None:
+        freq: dict[str, dict[str, int]] = {}
+        total: dict[str, int] = {}
+        for first_char_raw, second_list in DEFAULT_FREQUENCIES:
+            first_char = cast(str, first_char_raw)
+            row: dict[str, int] = {}
+            row_total = 0
+            for second_char_raw, count_raw in second_list:
+                second_char = cast(str, second_char_raw)
+                count = cast(int, count_raw)
+                row[second_char] = count
+                row_total += count
+            freq[first_char] = row
+            total[first_char] = row_total
+        _DEFAULT_FREQ = freq
+        _DEFAULT_TOTAL_FREQ = total
+    return _DEFAULT_FREQ, _DEFAULT_TOTAL_FREQ
+
+
+class BigramFrequencyDetectorConfig(CoreDetectorConfig):
+    # documentation see: https://github.com/ernstleierzopf/logdata-anomaly-miner/blob/main/source
+    # /root/usr/lib/logdata-anomaly-miner/aminer/analysis/EntropyDetector.py
+    method_type: str = "bigram_frequency_detector"
+    prob_thresh: float = 0.05
+    default_freqs: bool = False
+    skip_repetitions: bool = False
+
+    use_stable_vars: bool = True
+    use_static_vars: bool = True
+
+
+class BigramFrequencyDetector(CoreDetector):
+    """Detect bigram-frequency-based anomalies in log data."""
+
+    def __init__(
+        self,
+        name: str = "BigramFrequencyDetector",
+        config: BigramFrequencyDetectorConfig = BigramFrequencyDetectorConfig()
+    ) -> None:
+
+        if isinstance(config, dict):
+            config = BigramFrequencyDetectorConfig.from_dict(config, name)
+
+        super().__init__(name=name, buffer_mode=BufferMode.NO_BUF, config=config)
+        self.config: BigramFrequencyDetectorConfig  # type narrowing for IDE
+        self.persistency = EventPersistency(
+            event_data_class=EventStabilityTracker,
+        )
+        # auto config checks if individual variables are stable to select combos from
+        self.auto_conf_persistency = EventPersistency(
+            event_data_class=EventStabilityTracker
+        )
+        self._register_persistency(self.persistency)
+
+    def train(self, input_: ParserSchema) -> None:  # type: ignore
+        """Train the detector by updating per-variable bigram frequencies."""
+        configured_variables = get_configured_variables(input_, self.config.events)
+        current_event_id = input_["EventID"]
+        known_events = cast(
+            dict[int | str, EventStabilityTracker], self.persistency.get_events_data()
+        )
+
+        pre_unique = self._snapshot_unique_sets(
+            known_events.get(current_event_id), configured_variables
+        )
+        self.persistency.ingest_event(
+            event_id=current_event_id,
+            event_template=input_["template"],
+            named_variables=configured_variables,
+        )
+        if configured_variables:
+            known_events = cast(
+                dict[int | str, EventStabilityTracker], self.persistency.get_events_data()
+            )
+            self.train_helper(configured_variables, current_event_id, known_events, pre_unique)
+
+        if self.config.global_instances:
+            global_vars = get_global_variables(input_, self.config.global_instances)
+            if global_vars:
+                pre_unique_global = self._snapshot_unique_sets(
+                    known_events.get(GLOBAL_EVENT_ID), global_vars
+                )
+                self.persistency.ingest_event(
+                    event_id=GLOBAL_EVENT_ID,
+                    event_template=input_["template"],
+                    named_variables=global_vars,
+                )
+                known_events = cast(
+                    dict[int | str, EventStabilityTracker], self.persistency.get_events_data()
+                )
+                self.train_helper(global_vars, GLOBAL_EVENT_ID, known_events, pre_unique_global)
+
+    @staticmethod
+    def _snapshot_unique_sets(
+        event_tracker: "EventStabilityTracker | None",
+        variables: "dict[str, Any]",
+    ) -> "dict[str, set[Any]]":
+        """Capture pre-ingest unique_set membership per variable.
+
+        Used so train_helper's skip_repetitions check sees the
+        unique_set as it was *before* the current value was ingested.
+        Variables without a prior tracker get an empty set, which
+        naturally means skip_repetitions never skips on first
+        occurrence.
+        """
+        if event_tracker is None:
+            return {var: set() for var in variables}
+        existing = cast(dict[str, SingleStabilityTracker], event_tracker.get_data())
+        result: dict[str, set[Any]] = {}
+        for var in variables:
+            tracker = existing.get(var)
+            result[var] = set(tracker.unique_set) if tracker is not None else set()
+        return result
+
+    def train_helper(
+        self,
+        variables: "dict[str, Any]",
+        event_id: "int | str",
+        known_events: "dict[int | str, EventStabilityTracker]",
+        pre_unique: "dict[str, set[Any]]",
+    ) -> None:
+        var_trackers = cast(
+            dict[str, SingleStabilityTracker], known_events[event_id].get_data()
+        )
+        for var_name, value in variables.items():
+            if value is None:
+                continue
+            if self.config.skip_repetitions and value in pre_unique.get(var_name, set()):
+                continue
+            tracker = var_trackers[var_name]
+            freq = tracker.extra_state.setdefault("freq", {})
+            total_freq = tracker.extra_state.setdefault("total_freq", {})
+            for i in range(-1, len(value)):
+                first = -1 if i == -1 else value[i]
+                second = -1 if i == len(value) - 1 else value[i + 1]
+                row = freq.setdefault(first, {})
+                row[second] = row.get(second, 0) + 1
+                total_freq[first] = total_freq.get(first, 0) + 1
+
+    def detect(
+        self, input_: ParserSchema, output_: DetectorSchema  # type: ignore
+    ) -> bool:
+        """Detect bigram-frequency anomalies in the input data."""
+        alerts: dict[str, str] = {}
+        configured_variables = get_configured_variables(input_, self.config.events)
+        overall_score = 0.0
+        current_event_id = input_["EventID"]
+        known_events = cast(
+            dict[int | str, EventStabilityTracker], self.persistency.get_events_data()
+        )
+        if current_event_id in known_events:
+            overall_score = self.detect_helper(
+                alerts, configured_variables, current_event_id, known_events, overall_score
+            )
+        if self.config.global_instances and GLOBAL_EVENT_ID in known_events:
+            global_vars = get_global_variables(input_, self.config.global_instances)
+            overall_score = self.detect_helper(
+                alerts, global_vars, GLOBAL_EVENT_ID, known_events, overall_score
+            )
+        if overall_score > 0:
+            output_["score"] = overall_score
+            output_["description"] = f"{self.name} anomalies in the bigram frequencies."
+            output_["alertsObtain"].update(alerts)
+            return True
+        return False
+
+    def detect_helper(
+        self,
+        alerts: dict[str, str],
+        variables: dict[str, Any],
+        event_id: "int | str",
+        known_events: "dict[int | str, EventStabilityTracker]",
+        overall_score: float,
+    ) -> float:
+        anomaly = False
+        default_freq, default_total = (
+            _default_freq_tables() if self.config.default_freqs else ({}, {})
+        )
+        var_trackers = cast(
+            dict[str, SingleStabilityTracker], known_events[event_id].get_data()
+        )
+        for var_name, single_tracker in var_trackers.items():
+            value: Any = variables.get(var_name)
+            if value is None:
+                continue
+            freq: dict[Any, dict[Any, int]] = single_tracker.extra_state.get("freq", {})
+            total_freq: dict[Any, int] = single_tracker.extra_state.get("total_freq", {})
+            probs: list[float] = []
+            for i in range(-1, len(value)):
+                first: Any = -1 if i == -1 else value[i]
+                second: Any = -1 if i == len(value) - 1 else value[i + 1]
+                prob = 0.0
+                if first in freq and second in freq[first] and total_freq.get(first, 0) > 0:
+                    prob = freq[first][second] / total_freq[first]
+                elif self.config.default_freqs:
+                    if (first in default_freq and second in default_freq[first]
+                            and default_total.get(first, 0) > 0):
+                        prob = default_freq[first][second] / default_total[first]
+                probs.append(prob)
+            if not probs:
+                continue
+            critical_val = sum(probs) / len(probs)
+            if critical_val < self.config.prob_thresh:
+                k = f"EventID {event_id} - {var_name}"
+                if event_id == GLOBAL_EVENT_ID:
+                    k = f"Global - {var_name}"
+                alerts[k] = (
+                    f"Bigram frequency anomaly with value {value}, critical_val {critical_val} and "
+                    f"threshold {self.config.prob_thresh}."
+                )
+                anomaly = True
+        if anomaly:
+            overall_score += 1.0
+        return overall_score
+
+    def configure(self, input_: ParserSchema) -> None:  # type: ignore
+        self.auto_conf_persistency.ingest_event(
+            event_id=input_["EventID"],
+            event_template=input_["template"],
+            variables=input_["variables"],
+            named_variables=input_["logFormatVariables"],
+        )
+
+    @override
+    def post_train(self) -> None:
+        if not self.config.auto_config:
+            validate_config_coverage(self.name, self.config.events, self.persistency)
+
+    def set_configuration(self) -> None:
+        variables = {}
+        for event_id, tracker in self.auto_conf_persistency.get_events_data().items():
+            stable = []
+            if self.config.use_stable_vars:
+                stable = tracker.get_features_by_classification("STABLE")  # type: ignore
+            static = []
+            if self.config.use_static_vars:
+                static = tracker.get_features_by_classification("STATIC")  # type: ignore
+            vars_ = stable + static
+            if len(vars_) > 0:
+                variables[event_id] = vars_
+        config_dict = generate_detector_config(
+            variable_selection=variables,
+            detector_name=self.name,
+            method_type=self.config.method_type,
+        )
+        old_persist = self.config.persist
+        self.config = BigramFrequencyDetectorConfig.from_dict(config_dict, self.name)
+        self.config.persist = old_persist
+        events = self.config.events
+        if isinstance(events, EventsConfig) and not events.events:
+            logger.warning(
+                f"[{self.name}] auto_config=True generated an empty configuration. "
+                "No stable variables were found in configure-phase data. "
+                "The detector will produce no alerts."
+            )
diff --git a/src/detectmatelibrary/detectors/charset_detector.py b/src/detectmatelibrary/detectors/charset_detector.py
new file mode 100644
index 00000000..d3b48f5d
--- /dev/null
+++ b/src/detectmatelibrary/detectors/charset_detector.py
@@ -0,0 +1,158 @@
+from detectmatelibrary.common._config._compile import generate_detector_config
+from detectmatelibrary.common._config._formats import EventsConfig
+from detectmatelibrary.common.detector import (
+    CoreDetectorConfig,
+    CoreDetector,
+    get_configured_variables,
+    get_global_variables,
+    validate_config_coverage,
+)
+from detectmatelibrary.utils.persistency.event_data_structures.trackers.stability.stability_tracker import (
+    EventStabilityTracker
+)
+from detectmatelibrary.utils.persistency.event_persistency import EventPersistency
+from detectmatelibrary.utils.data_buffer import BufferMode
+from detectmatelibrary.schemas import ParserSchema, DetectorSchema
+from detectmatelibrary.constants import GLOBAL_EVENT_ID
+from typing_extensions import override
+from detectmatelibrary_tools.logging import logger
+
+
+class CharsetDetectorConfig(CoreDetectorConfig):
+    method_type: str = "charset_detector"
+
+    use_stable_vars: bool = True
+    use_static_vars: bool = True
+
+
+class CharsetDetector(CoreDetector):
+    """Detect new values in log data as anomalies based on learned values."""
+
+    def __init__(
+        self,
+        name: str = "CharsetDetector",
+        config: CharsetDetectorConfig = CharsetDetectorConfig()
+    ) -> None:
+
+        if isinstance(config, dict):
+            config = CharsetDetectorConfig.from_dict(config, name)
+
+        super().__init__(name=name, buffer_mode=BufferMode.NO_BUF, config=config)
+        self.config: CharsetDetectorConfig  # type narrowing for IDE
+        self.persistency = EventPersistency(
+            event_data_class=EventStabilityTracker,
+            event_data_kwargs={"expand_value": True},
+        )
+        # auto config checks if individual variables are stable to select combos from
+        self.auto_conf_persistency = EventPersistency(event_data_class=EventStabilityTracker)
+        self._register_persistency(self.persistency)
+
+    def train(self, input_: ParserSchema) -> None:  # type: ignore
+        """Train the detector by learning characters from the input data."""
+        configured_variables = get_configured_variables(input_, self.config.events)
+        self.persistency.ingest_event(
+            event_id=input_["EventID"],
+            event_template=input_["template"],
+            named_variables=configured_variables
+        )
+        if self.config.global_instances:
+            global_vars = get_global_variables(input_, self.config.global_instances)
+            if global_vars:
+                self.persistency.ingest_event(
+                    event_id=GLOBAL_EVENT_ID,
+                    event_template=input_["template"],
+                    named_variables=global_vars
+                )
+
+    def detect(
+        self, input_: ParserSchema, output_: DetectorSchema  # type: ignore
+    ) -> bool:
+        """Detect characters in the input data that were not seen in
+        training."""
+        alerts: dict[str, str] = {}
+        configured_variables = get_configured_variables(input_, self.config.events)
+        overall_score = 0.0
+
+        current_event_id = input_["EventID"]
+        known_events = self.persistency.get_events_data()
+
+        if current_event_id in known_events:
+            event_tracker = known_events[current_event_id]
+            for var_name, single_tracker in event_tracker.get_data().items():
+                v = configured_variables.get(var_name)
+                if v is None:
+                    continue
+                unknown = set(v) - single_tracker.unique_set
+                if unknown:
+                    alerts[f"EventID {current_event_id} - {var_name}"] = (
+                        "Unknown character(s): "
+                        + ", ".join(f"'{c}'" for c in sorted(unknown))
+                    )
+                    overall_score += 1.0
+
+        if self.config.global_instances and GLOBAL_EVENT_ID in known_events:
+            global_vars = get_global_variables(input_, self.config.global_instances)
+            global_tracker = known_events[GLOBAL_EVENT_ID]
+            for var_name, single_tracker in global_tracker.get_data().items():
+                v = global_vars.get(var_name)
+                if v is None:
+                    continue
+                unknown = set(v) - single_tracker.unique_set
+                if unknown:
+                    alerts[f"Global - {var_name}"] = (
+                        "Unknown character(s): "
+                        + ", ".join(f"'{c}'" for c in sorted(unknown))
+                    )
+                    overall_score += 1.0
+
+        if overall_score > 0:
+            output_["score"] = overall_score
+            output_["description"] = (
+                f"{self.name} detects characters not encountered in training as anomalies."
+            )
+            output_["alertsObtain"].update(alerts)
+            return True
+
+        return False
+
+    def configure(self, input_: ParserSchema) -> None:  # type: ignore
+        self.auto_conf_persistency.ingest_event(
+            event_id=input_["EventID"],
+            event_template=input_["template"],
+            variables=input_["variables"],
+            named_variables=input_["logFormatVariables"],
+        )
+
+    @override
+    def post_train(self) -> None:
+        if not self.config.auto_config:
+            validate_config_coverage(self.name, self.config.events, self.persistency)
+
+    def set_configuration(self) -> None:
+        variables = {}
+        for event_id, tracker in self.auto_conf_persistency.get_events_data().items():
+            stable = []
+            if self.config.use_stable_vars:
+                stable = tracker.get_features_by_classification("STABLE")  # type: ignore
+            static = []
+            if self.config.use_static_vars:
+                static = tracker.get_features_by_classification("STATIC")  # type: ignore
+            vars_ = stable + static
+            if len(vars_) > 0:
+                variables[event_id] = vars_
+        old_persist = self.config.persist
+        config_dict = generate_detector_config(
+            variable_selection=variables,
+            detector_name=self.name,
+            method_type=self.config.method_type,
+        )
+        # Update the config object from the dictionary instead of replacing it
+        self.config = CharsetDetectorConfig.from_dict(config_dict, self.name)
+        self.config.persist = old_persist
+        events = self.config.events
+        if isinstance(events, EventsConfig) and not events.events:
+            logger.warning(
+                f"[{self.name}] auto_config=True generated an empty configuration. "
+                "No stable variables were found in configure-phase data. "
+                "The detector will produce no alerts."
+            )
diff --git a/src/detectmatelibrary/detectors/new_event_detector.py b/src/detectmatelibrary/detectors/new_event_detector.py
new file mode 100644
index 00000000..8932f4a7
--- /dev/null
+++ b/src/detectmatelibrary/detectors/new_event_detector.py
@@ -0,0 +1,96 @@
+from detectmatelibrary.common._config._compile import generate_detector_config
+from detectmatelibrary.common.detector import CoreDetectorConfig, CoreDetector, get_configured_variables, \
+    get_global_variables
+from detectmatelibrary.utils import persistency
+from detectmatelibrary.constants import GLOBAL_EVENT_ID
+from detectmatelibrary.utils.data_buffer import BufferMode
+from detectmatelibrary.schemas import ParserSchema, DetectorSchema
+
+
+class NewEventDetectorConfig(CoreDetectorConfig):
+    method_type: str = "new_event_detector"
+
+
+class NewEventDetector(CoreDetector):
+    """Detect new values in log data as anomalies based on learned values."""
+
+    def __init__(
+        self,
+        name: str = "NewEventDetector",
+        config: NewEventDetectorConfig = NewEventDetectorConfig()
+    ) -> None:
+
+        if isinstance(config, dict):
+            config = NewEventDetectorConfig.from_dict(config, name)
+
+        super().__init__(name=name, buffer_mode=BufferMode.NO_BUF, config=config)
+        self.config: NewEventDetectorConfig
+        self.persistency = persistency.EventPersistency(
+            event_data_class=persistency.EventStabilityTracker,
+        )
+        # auto config checks if individual variables are stable to select combos from
+        self.auto_conf_persistency = persistency.EventPersistency(
+            event_data_class=persistency.EventStabilityTracker
+        )
+        self._register_persistency(self.persistency)
+
+    def train(self, input_: ParserSchema) -> None:  # type: ignore
+        """Train the detector by learning values from the input data."""
+        self.persistency.ingest_event(
+            event_id=input_["EventID"],
+            event_template=input_["template"]
+        )
+        if self.config.global_instances:
+            global_vars = get_global_variables(input_, self.config.global_instances)
+            if global_vars:
+                self.persistency.ingest_event(
+                    event_id=GLOBAL_EVENT_ID,
+                    event_template=input_["template"]
+                )
+
+    def detect(
+        self, input_:  ParserSchema, output_: DetectorSchema  # type: ignore
+    ) -> bool:
+        """Detect new values in the input data."""
+        alerts: dict[str, str] = {}
+        overall_score = 0.0
+
+        current_event_id = input_["EventID"]
+        known_events = self.persistency.get_events_seen()
+
+        if self.config.global_instances and GLOBAL_EVENT_ID in known_events:
+            global_vars = get_global_variables(input_, self.config.global_instances)
+            alerts[f"Global - {global_vars}"] = f"Unknown event ID: '{current_event_id}'"
+            overall_score += 1.0
+        elif current_event_id not in known_events:
+            configured_variables = get_configured_variables(input_, self.config.events)
+            alerts[f"EventID {current_event_id} - {configured_variables}"] = (
+                f"Unknown event ID: '{current_event_id}'"
+            )
+            overall_score += 1.0
+
+        if overall_score > 0:
+            output_["score"] = overall_score
+            output_["description"] = \
+                f"{self.name} detects event IDs not encountered in training as anomalies."
+            output_["alertsObtain"].update(alerts)
+            return True
+
+        return False
+
+    def configure(self, input_: ParserSchema) -> None:  # type: ignore
+        self.auto_conf_persistency.ingest_event(
+            event_id=input_["EventID"],
+            event_template=input_["template"]
+        )
+
+    def set_configuration(self) -> None:
+        old_persist = self.config.persist
+        config_dict = generate_detector_config(
+            variable_selection={},
+            detector_name=self.name,
+            method_type=self.config.method_type
+        )
+        # Update the config object from the dictionary instead of replacing it
+        self.config = NewEventDetectorConfig.from_dict(config_dict, self.name)
+        self.config.persist = old_persist
diff --git a/src/detectmatelibrary/detectors/new_value_combo_detector.py b/src/detectmatelibrary/detectors/new_value_combo_detector.py
index c461526c..d956b51a 100644
--- a/src/detectmatelibrary/detectors/new_value_combo_detector.py
+++ b/src/detectmatelibrary/detectors/new_value_combo_detector.py
@@ -1,17 +1,16 @@
 from detectmatelibrary.common._config import generate_detector_config
+from detectmatelibrary.common._config._formats import EventsConfig
 
 from detectmatelibrary.common.detector import (
     CoreDetectorConfig,
     CoreDetector,
     get_configured_variables,
-    get_global_variables
+    get_global_variables,
+    validate_config_coverage,
 )
 
 from detectmatelibrary.utils.data_buffer import BufferMode
-from detectmatelibrary.utils.persistency.event_data_structures.trackers import (
-    EventStabilityTracker
-)
-from detectmatelibrary.utils.persistency.event_persistency import EventPersistency
+from detectmatelibrary.utils import persistency
 
 from detectmatelibrary.schemas import ParserSchema, DetectorSchema
 from detectmatelibrary.constants import GLOBAL_EVENT_ID
@@ -19,6 +18,9 @@
 from typing import Any, Dict, Sequence, cast, Tuple
 from itertools import combinations
 
+from typing_extensions import override
+from detectmatelibrary_tools.logging import logger
+
 
 def get_combo(variables: Dict[str, Any]) -> Dict[Tuple[str, ...], Tuple[Any, ...]]:
     """Get a single combination of all variables as a key-value pair."""
@@ -52,7 +54,9 @@ def get_all_possible_combos(
 class NewValueComboDetectorConfig(CoreDetectorConfig):
     method_type: str = "new_value_combo_detector"
 
-    comb_size: int = 2
+    max_combo_size: int = 3
+    use_stable_vars: bool = True
+    use_static_vars: bool = False
 
 
 class NewValueComboDetector(CoreDetector):
@@ -67,19 +71,20 @@ def __init__(
         super().__init__(name=name, buffer_mode=BufferMode.NO_BUF, config=config)
 
         self.config = cast(NewValueComboDetectorConfig, self.config)
-        self.persistency = EventPersistency(
-            event_data_class=EventStabilityTracker,
+        self.persistency = persistency.EventPersistency(
+            event_data_class=persistency.EventStabilityTracker,
             event_data_kwargs={"converter_function": get_combo}
         )
         # auto config checks if individual variables are stable to select combos from
-        self.auto_conf_persistency = EventPersistency(
-            event_data_class=EventStabilityTracker
+        self.auto_conf_persistency = persistency.EventPersistency(
+            event_data_class=persistency.EventStabilityTracker
         )
-        self.auto_conf_persistency_combos = EventPersistency(
-            event_data_class=EventStabilityTracker,
+        self.auto_conf_persistency_combos = persistency.EventPersistency(
+            event_data_class=persistency.EventStabilityTracker,
             event_data_kwargs={"converter_function": get_all_possible_combos}
         )
         self.inputs: list[ParserSchema] = []
+        self._register_persistency(self.persistency)
 
     def train(self, input_: ParserSchema) -> None:  # type: ignore
         config = cast(NewValueComboDetectorConfig, self.config)
@@ -144,6 +149,12 @@ def detect(
             return True
         return False
 
+    @override
+    def post_train(self) -> None:
+        config = cast(NewValueComboDetectorConfig, self.config)
+        if not config.auto_config:
+            validate_config_coverage(self.name, config.events, self.persistency)
+
     def configure(self, input_: ParserSchema) -> None:  # type: ignore
         """Configure the detector based on the stability of individual
         variables, then learn value combinations based on that
@@ -159,7 +170,7 @@ def configure(self, input_: ParserSchema) -> None:  # type: ignore
             named_variables=input_["logFormatVariables"],
         )
 
-    def set_configuration(self, max_combo_size: int = 3) -> None:
+    def set_configuration(self, max_combo_size: int | None = None) -> None:
         """Set the detector configuration based on the stability of variable
         combinations.
 
@@ -169,17 +180,19 @@ def set_configuration(self, max_combo_size: int = 3) -> None:
         3. Re-ingest all events to learn the stability of these combos (testing all possible combos right away
         would explode combinatorially).
         """
+        config = cast(NewValueComboDetectorConfig, self.config)
+        old_persist = config.persist
         # run WITH auto_conf_persistency
         variable_combos = {}
         for event_id, tracker in self.auto_conf_persistency.get_events_data().items():
-            stable_vars = tracker.get_variables_by_classification("STABLE")  # type: ignore
+            stable_vars = tracker.get_features_by_classification("STABLE")  # type: ignore
             if len(stable_vars) > 1:
                 variable_combos[event_id] = stable_vars
         config_dict = generate_detector_config(
             variable_selection=variable_combos,
             detector_name=self.name,
             method_type=self.config.method_type,
-            comb_size=max_combo_size
+            max_combo_size=max_combo_size or config.max_combo_size
         )
         # Update the config object from the dictionary instead of replacing it
         self.config = NewValueComboDetectorConfig.from_dict(config_dict, self.name)
@@ -196,15 +209,29 @@ def set_configuration(self, max_combo_size: int = 3) -> None:
         # rerun to set final config WITH auto_conf_persistency_combos
         combo_selection = {}
         for event_id, tracker in self.auto_conf_persistency_combos.get_events_data().items():
-            stable_combos = tracker.get_variables_by_classification("STABLE")  # type: ignore
+            stable_combos = []
+            if self.config.use_stable_vars:
+                stable_combos = tracker.get_features_by_classification("STABLE")  # type: ignore
+            static_combos = []
+            if self.config.use_static_vars:
+                static_combos = tracker.get_features_by_classification("STATIC")  # type: ignore
+            combos = stable_combos + static_combos
             # Keep combos as tuples - each will become a separate config entry
-            if len(stable_combos) >= 1:
-                combo_selection[event_id] = stable_combos
+            if len(combos) > 0:
+                combo_selection[event_id] = combos
         config_dict = generate_detector_config(
             variable_selection=combo_selection,
             detector_name=self.name,
             method_type=self.config.method_type,
-            comb_size=max_combo_size
+            max_combo_size=max_combo_size or self.config.max_combo_size
         )
         # Update the config object from the dictionary instead of replacing it
         self.config = NewValueComboDetectorConfig.from_dict(config_dict, self.name)
+        self.config.persist = old_persist
+        events = self.config.events
+        if isinstance(events, EventsConfig) and not events.events:
+            logger.warning(
+                f"[{self.name}] auto_config=True generated an empty configuration. "
+                "No stable variable combinations were found in configure-phase data. "
+                "The detector will produce no alerts."
+            )
diff --git a/src/detectmatelibrary/detectors/new_value_detector.py b/src/detectmatelibrary/detectors/new_value_detector.py
index e9fe7c6a..fbe8739c 100644
--- a/src/detectmatelibrary/detectors/new_value_detector.py
+++ b/src/detectmatelibrary/detectors/new_value_detector.py
@@ -1,24 +1,29 @@
 from detectmatelibrary.common._config._compile import generate_detector_config
+from detectmatelibrary.common._config._formats import EventsConfig
 
 from detectmatelibrary.common.detector import (
     CoreDetectorConfig,
     CoreDetector,
     get_configured_variables,
-    get_global_variables
+    get_global_variables,
+    validate_config_coverage,
 )
-from detectmatelibrary.utils.persistency.event_data_structures.trackers.stability.stability_tracker import (
-    EventStabilityTracker
-)
-from detectmatelibrary.utils.persistency.event_persistency import EventPersistency
+from detectmatelibrary.utils import persistency
 from detectmatelibrary.utils.data_buffer import BufferMode
 
 from detectmatelibrary.schemas import ParserSchema, DetectorSchema
 from detectmatelibrary.constants import GLOBAL_EVENT_ID
 
+from typing_extensions import override
+from detectmatelibrary_tools.logging import logger
+
 
 class NewValueDetectorConfig(CoreDetectorConfig):
     method_type: str = "new_value_detector"
 
+    use_stable_vars: bool = True
+    use_static_vars: bool = True
+
 
 class NewValueDetector(CoreDetector):
     """Detect new values in log data as anomalies based on learned values."""
@@ -34,13 +39,14 @@ def __init__(
 
         super().__init__(name=name, buffer_mode=BufferMode.NO_BUF, config=config)
         self.config: NewValueDetectorConfig  # type narrowing for IDE
-        self.persistency = EventPersistency(
-            event_data_class=EventStabilityTracker,
+        self.persistency = persistency.EventPersistency(
+            event_data_class=persistency.EventStabilityTracker,
         )
         # auto config checks if individual variables are stable to select combos from
-        self.auto_conf_persistency = EventPersistency(
-            event_data_class=EventStabilityTracker
+        self.auto_conf_persistency = persistency.EventPersistency(
+            event_data_class=persistency.EventStabilityTracker
         )
+        self._register_persistency(self.persistency)
 
     def train(self, input_: ParserSchema) -> None:  # type: ignore
         """Train the detector by learning values from the input data."""
@@ -109,11 +115,24 @@ def configure(self, input_: ParserSchema) -> None:  # type: ignore
             named_variables=input_["logFormatVariables"],
         )
 
+    @override
+    def post_train(self) -> None:
+        if not self.config.auto_config:
+            validate_config_coverage(self.name, self.config.events, self.persistency)
+
     def set_configuration(self) -> None:
         variables = {}
         for event_id, tracker in self.auto_conf_persistency.get_events_data().items():
-            stable_vars = tracker.get_variables_by_classification("STABLE")  # type: ignore
-            variables[event_id] = stable_vars
+            stable = []
+            if self.config.use_stable_vars:
+                stable = tracker.get_features_by_classification("STABLE")  # type: ignore
+            static = []
+            if self.config.use_static_vars:
+                static = tracker.get_features_by_classification("STATIC")  # type: ignore
+            vars_ = stable + static
+            if len(vars_) > 0:
+                variables[event_id] = vars_
+        old_persist = self.config.persist
         config_dict = generate_detector_config(
             variable_selection=variables,
             detector_name=self.name,
@@ -121,3 +140,11 @@ def set_configuration(self) -> None:
         )
         # Update the config object from the dictionary instead of replacing it
         self.config = NewValueDetectorConfig.from_dict(config_dict, self.name)
+        self.config.persist = old_persist
+        events = self.config.events
+        if isinstance(events, EventsConfig) and not events.events:
+            logger.warning(
+                f"[{self.name}] auto_config=True generated an empty configuration. "
+                "No stable variables were found in configure-phase data. "
+                "The detector will produce no alerts."
+            )
diff --git a/src/detectmatelibrary/detectors/rule_detector.py b/src/detectmatelibrary/detectors/rule_detector.py
new file mode 100644
index 00000000..06292645
--- /dev/null
+++ b/src/detectmatelibrary/detectors/rule_detector.py
@@ -0,0 +1,104 @@
+"""Copy and paste to create new rules.
+
+def template_rule(
+    input_: schemas.ParserSchema, *args: list[Any]
+) -> tuple[bool, str]:
+
+    raise_alert = False  # Add here rule
+    message = ""  # Rule message
+    return raise_alert, message
+"""
+from detectmatelibrary.common.detector import CoreDetector, CoreDetectorConfig
+
+from detectmatelibrary.utils.data_buffer import BufferMode
+
+from detectmatelibrary import schemas
+
+from typing import Any, Callable
+
+
+def template_not_found(input_: schemas.ParserSchema, *args: list[Any]) -> tuple[bool, str]:
+    raise_alert = input_["EventID"] == -1
+    message = "No template found by parser"
+    return raise_alert, message
+
+
+def find_keyword(input_: schemas.ParserSchema, args: list[str]) -> tuple[bool, str]:
+    log: str = input_["log"]
+    log = log.lower()
+
+    for k in args:
+        if k in log:
+            return True, f"Found word '{k}' in the logs"
+    return False, ""
+
+
+def exceptions(input_: schemas.ParserSchema, *args: list[Any]) -> tuple[bool, str]:
+    return find_keyword(input_, ["exception", "fail", "error", "raise"])
+
+
+def error_log(input_: schemas.ParserSchema, *args: list[Any]) -> tuple[bool, str]:
+    vars_: dict[str, str] = input_["logFormatVariables"]
+    raise_alert = "Level" in vars_ and "error" == vars_["Level"].lower()
+    message = "Error found"
+    return raise_alert, message
+
+
+rules: dict[str, Callable[[schemas.ParserSchema, list[str]], tuple[bool, str]]] = {
+    "R001 - TemplateNotFound": template_not_found,
+    "R002 - SpecificKeyword": find_keyword,
+    "R003 - CheckForExceptions": exceptions,
+    "R004 - ErrorLevelFound": error_log,
+}
+
+
+class RuleNotFound(Exception):
+    def __init__(self, rule: str) -> None:
+        super().__init__(f"Rule -> ([{rule}]) not found")
+
+
+class RuleDetectorConfig(CoreDetectorConfig):
+    method_type: str = "rule_detector"
+    rules: list[dict[str, list[str] | str]] = [
+        {"rule": "R001 - TemplateNotFound"},
+        {"rule": "R003 - CheckForExceptions"},
+        {"rule": "R004 - ErrorLevelFound"},
+    ]
+
+
+class RuleDetector(CoreDetector):
+    def __init__(
+        self,
+        name: str = "RuleDetector",
+        config: RuleDetectorConfig | dict[str, Any] = RuleDetectorConfig()
+    ) -> None:
+
+        if isinstance(config, dict):
+            config = RuleDetectorConfig.from_dict(config, name)
+        super().__init__(name=name, buffer_mode=BufferMode.NO_BUF, config=config)
+        self.config: RuleDetectorConfig
+
+        for rule in self.config.rules:
+            if rule["rule"] not in rules:
+                raise RuleNotFound(rule)
+
+            if "args" not in rule:
+                rule["args"] = []
+
+    def detect(
+        self, input_: schemas.ParserSchema, output_: schemas.DetectorSchema  # type: ignore
+    ) -> bool:
+
+        anomaly = False
+        output_["score"] = 0
+
+        for rule in self.config.rules:
+            alert, msg = rules[rule["rule"]](input_, rule["args"])  # type: ignore
+
+            if alert:
+                output_["alertsObtain"][rule["rule"]] = msg
+                output_["score"] += 1
+
+            anomaly = anomaly or alert
+
+        return anomaly
diff --git a/src/detectmatelibrary/detectors/value_range_detector.py b/src/detectmatelibrary/detectors/value_range_detector.py
new file mode 100644
index 00000000..bc3a0815
--- /dev/null
+++ b/src/detectmatelibrary/detectors/value_range_detector.py
@@ -0,0 +1,184 @@
+from detectmatelibrary.common._config._compile import generate_detector_config
+from detectmatelibrary.common._config._formats import EventsConfig
+from detectmatelibrary.common.detector import (
+    CoreDetectorConfig,
+    CoreDetector,
+    get_configured_variables,
+    get_global_variables,
+    validate_config_coverage,
+)
+from detectmatelibrary.utils.persistency.event_data_structures.trackers.stability.stability_tracker import (
+    EventStabilityTracker
+)
+from detectmatelibrary.utils.persistency.event_persistency import EventPersistency
+from detectmatelibrary.utils.data_buffer import BufferMode
+from detectmatelibrary.schemas import ParserSchema, DetectorSchema
+from detectmatelibrary.constants import GLOBAL_EVENT_ID
+from typing_extensions import override
+from detectmatelibrary_tools.logging import logger
+from typing import Dict, List, Any
+
+
+class ValueRangeDetectorConfig(CoreDetectorConfig):
+    method_type: str = "value_range_detector"
+
+    ignore_non_numerical_val: bool = True
+    use_stable_vars: bool = True
+    use_static_vars: bool = True
+
+
+class ValueRangeDetector(CoreDetector):
+    """Detect new value ranges in logs as anomalies based on learned values."""
+
+    def __init__(
+        self,
+        name: str = "ValueRangeDetector",
+        config: ValueRangeDetectorConfig = ValueRangeDetectorConfig()
+    ) -> None:
+
+        if isinstance(config, dict):
+            config = ValueRangeDetectorConfig.from_dict(config, name)
+
+        super().__init__(name=name, buffer_mode=BufferMode.NO_BUF, config=config)
+        self.config: ValueRangeDetectorConfig  # type narrowing for IDE
+        self.persistency = EventPersistency(
+            event_data_class=EventStabilityTracker,
+        )
+        # auto config checks if individual variables are stable to select combos from
+        self.auto_conf_persistency = EventPersistency(
+            event_data_class=EventStabilityTracker
+        )
+
+    def cast_val_to_numeric(self, configured_variables: Dict[str, Any], k: str, remove: List[str],
+                            stage: str) -> bool:
+        v = configured_variables[k]
+        if not isinstance(v, (int, float)):
+            try:
+                configured_variables[k] = int(v)
+            except ValueError:
+                try:
+                    configured_variables[k] = float(v)
+                except ValueError:
+                    logger.error(f"Non-numeric value '{v}' appeared in {stage} of {self.__class__.__name__}"
+                                 f" with the name {self.name}.")
+                    if not self.config.ignore_non_numerical_val:
+                        exit(1)
+                    remove.append(k)
+                    return False
+        return True
+
+    def train(self, input_: ParserSchema) -> None:  # type: ignore
+        """Train the detector by learning values from the input data."""
+        configured_variables = get_configured_variables(input_, self.config.events)
+        remove: List[str] = []
+        for k in configured_variables.keys():
+            self.cast_val_to_numeric(configured_variables, k, remove, "training")
+        for k in remove:
+            del configured_variables[k]
+        self.persistency.ingest_event(
+            event_id=input_["EventID"],
+            event_template=input_["template"],
+            named_variables=configured_variables
+        )
+        if self.config.global_instances:
+            global_vars = get_global_variables(input_, self.config.global_instances)
+            if global_vars:
+                self.persistency.ingest_event(
+                    event_id=GLOBAL_EVENT_ID,
+                    event_template=input_["template"],
+                    named_variables=global_vars
+                )
+
+    def detect(
+        self, input_:  ParserSchema, output_: DetectorSchema  # type: ignore
+    ) -> bool:
+        """Detect new value ranges in the input data."""
+        alerts: dict[str, str] = {}
+        configured_variables = get_configured_variables(input_, self.config.events)
+        overall_score = 0.0
+
+        current_event_id = input_["EventID"]
+        known_events = self.persistency.get_events_data()
+
+        if current_event_id in known_events:
+            event_tracker = known_events[current_event_id]
+            for var_name, multi_tracker in event_tracker.get_data().items():
+                cast = self.cast_val_to_numeric(configured_variables, var_name, [], "detection")
+                value = configured_variables.get(var_name)
+                if value is None or not cast:
+                    continue
+                min_ = min(multi_tracker.unique_set)
+                max_ = max(multi_tracker.unique_set)
+                if value < min_ or value > max_:
+                    alerts[f"EventID {current_event_id} - {var_name}"] = (
+                        f"Out of range value: '{value}' ({min_} - {max_})"
+                    )
+                    overall_score += 1.0
+
+        if self.config.global_instances and GLOBAL_EVENT_ID in known_events:
+            global_vars = get_global_variables(input_, self.config.global_instances)
+            global_tracker = known_events[GLOBAL_EVENT_ID]
+            for var_name, multi_tracker in global_tracker.get_data().items():
+                cast = self.cast_val_to_numeric(global_vars, var_name, [], "detection")
+                value = global_vars.get(var_name)
+                if value is None or not cast:
+                    continue
+                min_ = min(multi_tracker.unique_set)
+                max_ = max(multi_tracker.unique_set)
+                if isinstance(value, float):
+                    min_ = float(min_)
+                    max_ = float(max_)
+                else:
+                    min_ = int(min_)
+                    max_ = int(max_)
+                if value < min_ or value > max_:
+                    alerts[f"Global - {var_name}"] = f"Out of range value: '{value}' ({min_} - {max_})"
+                    overall_score += 1.0
+
+        if overall_score > 0:
+            output_["score"] = overall_score
+            output_["description"] = f"{self.name} detects values not encountered in training as anomalies."
+            output_["alertsObtain"].update(alerts)
+            return True
+
+        return False
+
+    def configure(self, input_: ParserSchema) -> None:  # type: ignore
+        self.auto_conf_persistency.ingest_event(
+            event_id=input_["EventID"],
+            event_template=input_["template"],
+            variables=input_["variables"],
+            named_variables=input_["logFormatVariables"],
+        )
+
+    @override
+    def post_train(self) -> None:
+        if not self.config.auto_config:
+            validate_config_coverage(self.name, self.config.events, self.persistency)
+
+    def set_configuration(self) -> None:
+        variables = {}
+        for event_id, tracker in self.auto_conf_persistency.get_events_data().items():
+            stable = []
+            if self.config.use_stable_vars:
+                stable = tracker.get_features_by_classification("STABLE")  # type: ignore
+            static = []
+            if self.config.use_static_vars:
+                static = tracker.get_features_by_classification("STATIC")  # type: ignore
+            vars_ = stable + static
+            if len(vars_) > 0:
+                variables[event_id] = vars_
+        config_dict = generate_detector_config(
+            variable_selection=variables,
+            detector_name=self.name,
+            method_type=self.config.method_type,
+        )
+        # Update the config object from the dictionary instead of replacing it
+        self.config = ValueRangeDetectorConfig.from_dict(config_dict, self.name)
+        events = self.config.events
+        if isinstance(events, EventsConfig) and not events.events:
+            logger.warning(
+                f"[{self.name}] auto_config=True generated an empty configuration. "
+                "No stable variables were found in configure-phase data. "
+                "The detector will produce no alerts."
+            )
diff --git a/src/detectmatelibrary/helper/from_to.py b/src/detectmatelibrary/helper/from_to.py
index 3f5f15de..dfaf27e0 100644
--- a/src/detectmatelibrary/helper/from_to.py
+++ b/src/detectmatelibrary/helper/from_to.py
@@ -5,6 +5,7 @@
 from ast import literal_eval
 import os
 
+from polars import DataFrame
 from typing import Iterator
 import yaml
 import json
@@ -129,6 +130,35 @@ def __generator():  # type: ignore
 
         return From._yield(component, __generator(), do_process=do_process)  # type: ignore
 
+    @staticmethod
+    def polars(
+        component: CoreComponent,
+        df: DataFrame,
+        do_process: bool = True,
+        renames: dict[str, str] | None = None
+    ) -> Iterator[BaseSchema]:
+        def __generator():  # type: ignore
+            for i in range(len(df)):
+                data = df.row(i, named=True)
+                if len(df_vars) > 0:
+                    data["logFormatVariables"] = df_vars.row(i, named=True)
+                data["logID"] = str(i)
+                schema = component.input_schema(data)
+                yield schema
+
+        renames = {
+            "Content": "log", "ParamList": "variables", "EventIDs": "EventID", "Templates": "template"
+        } if renames is None else renames
+        if "ParamList" not in df.columns and "ParamList" in renames:
+            del renames["ParamList"]
+
+        columns = list(renames.values())
+        df = df.rename(renames)
+        format_vars = [colum for colum in df.columns if colum not in columns]
+        df_vars, df = df[format_vars], df[columns]
+
+        return From._yield(component, __generator(), do_process=do_process)  # type: ignore
+
 
 class FromTo:
     @staticmethod
@@ -237,3 +267,39 @@ def yaml2yaml(
 
         for log in gen:
             yield To.yaml(log, out_path=out_path)  # type: ignore
+
+    @staticmethod
+    def polars2binary_file(
+        component: CoreComponent,
+        df: DataFrame,
+        out_path: str,
+        renames: dict[str, str] | None = None
+    ) -> Iterator[BaseSchema]:
+        gen = From.polars(component, df=df, renames=renames, do_process=True)
+
+        for log in gen:
+            yield To.binary_file(log, out_path=out_path)  # type: ignore
+
+    @staticmethod
+    def polars2json(
+        component: CoreComponent,
+        df: DataFrame,
+        out_path: str,
+        renames: dict[str, str] | None = None
+    ) -> Iterator[BaseSchema]:
+        gen = From.polars(component, df=df, renames=renames, do_process=True)
+
+        for log in gen:
+            yield To.json(log, out_path=out_path)  # type: ignore
+
+    @staticmethod
+    def polars2yaml(
+        component: CoreComponent,
+        df: DataFrame,
+        out_path: str,
+        renames: dict[str, str] | None = None
+    ) -> Iterator[BaseSchema]:
+        gen = From.polars(component, df=df, renames=renames, do_process=True)
+
+        for log in gen:
+            yield To.yaml(log, out_path=out_path)  # type: ignore
diff --git a/src/detectmatelibrary/metadata.py b/src/detectmatelibrary/metadata.py
new file mode 100644
index 00000000..99b40c1b
--- /dev/null
+++ b/src/detectmatelibrary/metadata.py
@@ -0,0 +1,12 @@
+__authors__ = ["André García Gómez", "Viktor Beck", "Thorina Boenke", "Wolfgang Hotwagner", "Anna Erdi",
+               "Ernst Leierzopf"]
+__contact__ = "aecid@ait.ac.at"
+__copyright__ = "Copyright 2026, AIT Austrian Institute of Technology GmbH"
+__date__ = "2026/05/18"
+__deprecated__ = False
+__website__ = "https://aecid.ait.ac.at"
+__license__ = "EUPL-1.2"
+__status__ = "Development"
+__version__ = "0.2.0"
+__all__ = ['__authors__', '__contact__', '__copyright__', '__date__', '__deprecated__', '__website__',
+           '__license__', '__status__', '__version__']
diff --git a/src/detectmatelibrary/parsers/json_parser.py b/src/detectmatelibrary/parsers/json_parser.py
index 713b8f2e..29677e87 100644
--- a/src/detectmatelibrary/parsers/json_parser.py
+++ b/src/detectmatelibrary/parsers/json_parser.py
@@ -58,10 +58,10 @@ def __init__(
     ) -> None:
 
         if isinstance(config, dict):
-            content_parser_name = config.get("content_parser", "JsonMatcherParser")
-            content_parser_config = MatcherParserConfig.from_dict(config, content_parser_name)
+            cfg_dict = JsonParserConfig.from_dict(config, name)
+            content_parser_config = MatcherParserConfig.from_dict(config, cfg_dict.content_parser)
             self.content_parser = MatcherParser(config=content_parser_config)
-            config = JsonParserConfig.from_dict(config, name)
+            config = cfg_dict
         super().__init__(name=name, config=config)
 
         self.time_extractor = KeyExtractor(key_substr=config.timestamp_name)
diff --git a/src/detectmatelibrary/parsers/logbatcher/engine/parser.py b/src/detectmatelibrary/parsers/logbatcher/engine/parser.py
index 76fcb982..180135c2 100644
--- a/src/detectmatelibrary/parsers/logbatcher/engine/parser.py
+++ b/src/detectmatelibrary/parsers/logbatcher/engine/parser.py
@@ -29,7 +29,7 @@
 
 from openai import OpenAI
 from tenacity import retry, stop_after_attempt, wait_random_exponential
-from tools.logging import logger
+from detectmatelibrary_tools.logging import logger
 from .cluster import Cluster
 from .postprocess import post_process
 from .matching import prune_from_cluster
diff --git a/src/detectmatelibrary/parsers/logbatcher/engine/parsing_base.py b/src/detectmatelibrary/parsers/logbatcher/engine/parsing_base.py
index 25035a17..57d2923e 100644
--- a/src/detectmatelibrary/parsers/logbatcher/engine/parsing_base.py
+++ b/src/detectmatelibrary/parsers/logbatcher/engine/parsing_base.py
@@ -25,7 +25,7 @@
 # Changes from original (parsing_base_old.py):
 # - Returns a result dict (logs_df, templates_df, cache, metrics, template_samples)
 #   instead of writing CSV/JSON files directly to disk.
-# - Replaced print() calls with structured logger (tools.logging.logger).
+# - Replaced print() calls with structured logger (detectmatelibrary_tools.logging.logger).
 # - Made `cache` an optional parameter to support reuse across calls.
 # - Added _extract_template_samples() helper to extract template→sample-log mappings.
 # - Default chunk_size raised from 10 000 to 30 000.
@@ -35,7 +35,7 @@
 from collections import Counter
 from typing import List, Dict, Any, Optional
 from tqdm import tqdm
-from tools.logging import logger
+from detectmatelibrary_tools.logging import logger
 from .vars import vars_update
 from .cluster import Cluster,tokenize, vectorize, cluster, reassign_clusters, process_new_cluster
 from .additional_cluster import hierichical_clustering,meanshift_clustering
diff --git a/src/detectmatelibrary/parsers/template_matcher/_matcher_op.py b/src/detectmatelibrary/parsers/template_matcher/_matcher_op.py
index 8760ab27..0c41a05d 100644
--- a/src/detectmatelibrary/parsers/template_matcher/_matcher_op.py
+++ b/src/detectmatelibrary/parsers/template_matcher/_matcher_op.py
@@ -1,8 +1,17 @@
 from collections import defaultdict
-from typing import Dict, List, Any, Tuple
+from typing import Dict, List, Any, Tuple, TypedDict
 import regex
 import re
 
+from detectmatelibrary.common._config._formats import (
+    EventsConfig, _EventConfig, _EventInstance, Variable
+)
+
+
+class TemplateMetadata(TypedDict):
+    event_id_label: str | None
+    labels: list[str]
+
 
 def safe_search(pattern: str, string: str, timeout: int = 1) -> regex.Match[str] | None:
     """Perform regex search with a timeout to prevent catastrophic
@@ -64,6 +73,7 @@ class TemplatesManager:
     def __init__(
         self,
         template_list: list[str],
+        metadata: dict[int, TemplateMetadata] | None = None,
         remove_spaces: bool = True,
         remove_punctuation: bool = True,
         lowercase: bool = True
@@ -96,6 +106,61 @@ def __init__(
             first = tokens[0] if tokens else ""
             self._prefix_index[first].append(idx)
 
+        _metadata: dict[int, TemplateMetadata] = metadata or {}
+        self._event_label_to_idx: dict[str, int] = {
+            m["event_id_label"]: i
+            for i, m in _metadata.items()
+            if m["event_id_label"]
+        }
+        self._idx_to_var_map: dict[int, dict[str, int]] = {
+            i: {label: pos for pos, label in enumerate(m["labels"])}
+            for i, m in _metadata.items()
+            if m["labels"]
+        }
+
+    def compile_events_config(self, events_config: EventsConfig) -> EventsConfig:
+        """Resolve named event IDs and named variable labels to positional
+        ints.
+
+        Translates user-friendly named format to the internal positional
+        representation. Returns a new EventsConfig with only int keys
+        and int positions.
+        """
+        new_events: Dict[Any, _EventConfig] = {}
+
+        for event_key, event_config in events_config.events.items():
+            if isinstance(event_key, str) and event_key in self._event_label_to_idx:
+                resolved_key: str | int = self._event_label_to_idx[event_key]
+            else:
+                resolved_key = event_key
+
+            var_map = self._idx_to_var_map.get(resolved_key if isinstance(resolved_key, int) else -1, {})
+
+            new_instances: Dict[str, _EventInstance] = {}
+            for instance_id, instance in event_config.instances.items():
+                new_vars: Dict[str | int, Variable] = {}
+                for pos, var in instance.variables.items():
+                    if isinstance(pos, str):
+                        if pos not in var_map:
+                            raise ValueError(
+                                f"Label '{pos}' not found in template for event '{event_key}'. "
+                                f"Available labels: {list(var_map)}"
+                            )
+                        resolved_pos = var_map[pos]
+                        new_vars[resolved_pos] = Variable(
+                            pos=resolved_pos, name=pos, params=var.params
+                        )
+                    else:
+                        new_vars[pos] = var
+                new_instances[instance_id] = _EventInstance(
+                    params=instance.params,
+                    variables=new_vars,
+                    header_variables=instance.header_variables,
+                )
+            new_events[resolved_key] = _EventConfig(instances=new_instances)
+
+        return EventsConfig(events=new_events)
+
     def candidate_indices(self, s: str) -> Tuple[str, List[int]]:
         pre_s = self.preprocess(s)
         candidates = []
@@ -110,17 +175,28 @@ class TemplateMatcher:
     def __init__(
         self,
         template_list: list[str],
+        metadata: dict[int, TemplateMetadata] | None = None,
         remove_spaces: bool = True,
         remove_punctuation: bool = True,
         lowercase: bool = True
     ) -> None:
         self.manager = TemplatesManager(
             template_list=template_list,
+            metadata=metadata,
             remove_spaces=remove_spaces,
             remove_punctuation=remove_punctuation,
             lowercase=lowercase
         )
 
+    def compile_detector_config(self, events_config: EventsConfig) -> EventsConfig:
+        """Resolve named event IDs and variable labels to positional ints.
+
+        Call once at setup time. Returns a new EventsConfig using the
+        internal positional representation, compatible with
+        get_configured_variables().
+        """
+        return self.manager.compile_events_config(events_config)
+
     @staticmethod
     def extract_parameters(log: str, template: str) -> tuple[str, ...] | None:
         """Extract parameters from the log based on the template."""
@@ -129,7 +205,6 @@ def extract_parameters(log: str, template: str) -> tuple[str, ...] | None:
         pattern_parts_escaped = [re.escape(part) for part in pattern_parts]
         regex_pattern = "(.*?)".join(pattern_parts_escaped)
         regex = "^" + regex_pattern + "$"
-        # matches = re.search(regex, log)
         matches = safe_search(regex, log, 1)
         if matches:
             groups: tuple[str, ...] = matches.groups()
diff --git a/src/detectmatelibrary/parsers/template_matcher/_parser.py b/src/detectmatelibrary/parsers/template_matcher/_parser.py
index 3192a84b..edcae997 100644
--- a/src/detectmatelibrary/parsers/template_matcher/_parser.py
+++ b/src/detectmatelibrary/parsers/template_matcher/_parser.py
@@ -1,10 +1,13 @@
-from detectmatelibrary.parsers.template_matcher._matcher_op import TemplateMatcher
+from detectmatelibrary.parsers.template_matcher._matcher_op import TemplateMatcher, TemplateMetadata
 from detectmatelibrary.common.parser import CoreParser, CoreParserConfig
 from detectmatelibrary import schemas
 
 from typing import Any
 import csv
 import os
+import re
+
+_NAMED_WC_RE = re.compile(r'<([A-Za-z_]\w*)>')
 
 
 class TemplatesNotFoundError(Exception):
@@ -15,34 +18,93 @@ class TemplateNoPermissionError(Exception):
     pass
 
 
-def load_templates(path: str) -> list[str]:
+def _compile_templates(
+    raw_templates: list[str],
+    event_id_labels: list[str | None] | None = None,
+) -> tuple[list[str], dict[int, TemplateMetadata]]:
+    """Convert named wildcards to <*> and record label order and event ID
+    labels.
+
+    Args:
+        raw_templates: Raw template strings, possibly containing named wildcards.
+        event_id_labels: Optional per-template event ID labels (from CSV EventId column).
+                         If provided, must have the same length as raw_templates.
+
+    Returns:
+        compiled: Template strings with only <*> wildcards, ready for TemplatesManager.
+        metadata: Mapping of template index to TemplateMetadata.
+
+    Raises:
+        ValueError: If a template mixes <*> and named wildcards.
+    """
+    compiled: list[str] = []
+    metadata: dict[int, TemplateMetadata] = {}
+
+    for i, raw in enumerate(raw_templates):
+        has_anon = "<*>" in raw
+        labels = _NAMED_WC_RE.findall(raw)
+        has_named = bool(labels)
+
+        if has_anon and has_named:
+            raise ValueError(
+                f"Template mixes <*> and named wildcards: {raw!r}. "
+                "Use either <*> (positional) or <label> (named) exclusively."
+            )
+
+        compiled_tpl = _NAMED_WC_RE.sub("<*>", raw) if has_named else raw
+        idx = len(compiled)
+        compiled.append(compiled_tpl)
+        eid_label = event_id_labels[i] if event_id_labels else None
+        metadata[idx] = TemplateMetadata(event_id_label=eid_label, labels=labels)
+
+    return compiled, metadata
+
+
+def load_templates(path: str) -> tuple[list[str], list[str | None]]:
+    """Load templates from a .txt or .csv file.
+
+    Returns:
+        A tuple of (template_strings, event_id_labels). For .txt files, all
+        event_id_labels are None (positional IDs only). For .csv files, an
+        optional EventId column provides named event ID labels.
+    """
     if not os.path.exists(path):
         raise TemplatesNotFoundError(f"Templates file not found at: {path}")
     if not os.access(path, os.R_OK):
         raise TemplateNoPermissionError(
             f"You do not have the permission to access the templates file: {path}"
         )
+    templates: list[str] = []
+    eid_labels: list[str | None] = []
     if path.endswith(".txt"):
         with open(path, "r") as f:
-            templates = [line.strip() for line in f if line.strip()]
+            for line in f:
+                s = line.strip()
+                if s:
+                    templates.append(s)
+                    eid_labels.append(None)
     elif path.endswith(".csv"):
-        templates = []
-        # Use the lightweight built-in csv module instead of pandas
-        # Expect a header with a 'template' column
         with open(path, newline="", encoding="utf-8") as f:
             reader = csv.DictReader(f)
             if reader.fieldnames is None or "EventTemplate" not in reader.fieldnames:
                 raise ValueError("CSV file must contain a 'EventTemplate' column.")
+            has_event_id_col = "EventId" in (reader.fieldnames or [])
             for row in reader:
                 val = row.get("EventTemplate")
                 if val is None:
                     continue
                 s = str(val).strip()
-                if s:
-                    templates.append(s)
+                if not s:
+                    continue
+                templates.append(s)
+                if has_event_id_col:
+                    eid = str(row.get("EventId", "")).strip()
+                    eid_labels.append(eid or None)
+                else:
+                    eid_labels.append(None)
     else:
         raise ValueError("Unsupported template file format. Use .txt or .csv files.")
-    return templates
+    return templates, eid_labels
 
 
 class MatcherParserConfig(CoreParserConfig):
@@ -52,7 +114,7 @@ class MatcherParserConfig(CoreParserConfig):
     remove_punctuation: bool = True
     lowercase: bool = True
 
-    path_templates: str = "<PLACEHOLDER>"
+    path_templates: str | None = None
 
 
 class MatcherParser(CoreParser):
@@ -67,8 +129,14 @@ def __init__(
         super().__init__(name=name, config=config)
         self.config: MatcherParserConfig
 
+        if self.config.path_templates is not None:
+            raw_templates, eid_labels = load_templates(self.config.path_templates)
+        else:
+            raw_templates, eid_labels = [], []
+        compiled_templates, metadata = _compile_templates(raw_templates, eid_labels)
         self.template_matcher = TemplateMatcher(
-            template_list=load_templates(self.config.path_templates),
+            template_list=compiled_templates,
+            metadata=metadata,
             remove_spaces=self.config.remove_spaces,
             remove_punctuation=self.config.remove_punctuation,
             lowercase=self.config.lowercase,
diff --git a/src/detectmatelibrary/parsers/tree_matcher.py b/src/detectmatelibrary/parsers/tree_matcher.py
new file mode 100644
index 00000000..8ac77a58
--- /dev/null
+++ b/src/detectmatelibrary/parsers/tree_matcher.py
@@ -0,0 +1,43 @@
+from detectmatelibrary.common.parser import CoreParser, CoreParserConfig
+from detectmatelibrary import schemas
+
+from detectmateperformance.match_tree import TreeMatcher
+from detectmateperformance.types_ import LogTemplates
+
+from typing import Any
+
+
+class TemplateCppTreeMatcherConfig(CoreParserConfig):
+    method_type: str = "tree_matcher"
+
+    path_templates: str | None = None
+
+
+class TemplateCppTreeMatcher(CoreParser):
+    def __init__(
+        self,
+        name: str = "TreeMatcher",
+        config: TemplateCppTreeMatcherConfig | dict[str, Any] = TemplateCppTreeMatcherConfig()
+    ) -> None:
+
+        if isinstance(config, dict):
+            config = TemplateCppTreeMatcherConfig.from_dict(config, name)
+        super().__init__(name=name, config=config)
+
+        self.config: TemplateCppTreeMatcherConfig
+        if self.config.path_templates is None:
+            self.tree = TreeMatcher(LogTemplates([]))
+        else:
+            self.tree = TreeMatcher.from_file(self.config.path_templates)
+
+    def parse(
+        self,
+        input_: schemas.LogSchema,
+        output_: schemas.ParserSchema
+    ) -> None:
+
+        parsed = self.tree.match_log(input_["log"], get_var=True)[0]
+
+        output_["EventID"] = parsed["EventID"]
+        output_["variables"].extend(parsed["ParamList"])
+        output_["template"] = parsed["Template"]
diff --git a/src/detectmatelibrary/utils/persistency/__init__.py b/src/detectmatelibrary/utils/persistency/__init__.py
index 5ea37cd7..fff0f391 100644
--- a/src/detectmatelibrary/utils/persistency/__init__.py
+++ b/src/detectmatelibrary/utils/persistency/__init__.py
@@ -1,5 +1,17 @@
 from .event_persistency import EventPersistency
+from .persistency_saver import PersistencySaver, PersistencySaverConfig, PersistencyLoadError
+from .event_data_structures.base import EventDataStructure
+from .event_data_structures.dataframes.event_dataframe import EventDataFrame
+from .event_data_structures.dataframes.chunked_event_dataframe import ChunkedEventDataFrame
+from .event_data_structures.trackers.stability.stability_tracker import EventStabilityTracker
 
 __all__ = [
-    "EventPersistency"
+    "EventPersistency",
+    "PersistencySaver",
+    "PersistencySaverConfig",
+    "PersistencyLoadError",
+    "EventDataStructure",
+    "EventDataFrame",
+    "ChunkedEventDataFrame",
+    "EventStabilityTracker",
 ]
diff --git a/src/detectmatelibrary/utils/persistency/event_data_structures/base.py b/src/detectmatelibrary/utils/persistency/event_data_structures/base.py
index 8319e339..08e4909b 100644
--- a/src/detectmatelibrary/utils/persistency/event_data_structures/base.py
+++ b/src/detectmatelibrary/utils/persistency/event_data_structures/base.py
@@ -24,6 +24,20 @@ def to_data(self, raw_data: Any) -> Any:
         """Convert raw data into the appropriate data format for storage."""
         pass
 
+    @abstractmethod
+    def dump(self) -> bytes:
+        """Serialize full state to bytes.
+
+        Format is backend-specific.
+        """
+        ...
+
+    @classmethod
+    @abstractmethod
+    def load(cls, data: bytes, **kwargs: Any) -> "EventDataStructure":
+        """Restore state from bytes produced by dump()."""
+        ...
+
     def get_template(self) -> str:
         return self.template
 
diff --git a/src/detectmatelibrary/utils/persistency/event_data_structures/dataframes/chunked_event_dataframe.py b/src/detectmatelibrary/utils/persistency/event_data_structures/dataframes/chunked_event_dataframe.py
index 8b15bff1..53c32306 100644
--- a/src/detectmatelibrary/utils/persistency/event_data_structures/dataframes/chunked_event_dataframe.py
+++ b/src/detectmatelibrary/utils/persistency/event_data_structures/dataframes/chunked_event_dataframe.py
@@ -1,6 +1,9 @@
+import io
+import struct
 from typing import Any, Dict, List, Optional
 from dataclasses import dataclass, field
 
+import msgpack
 import polars as pl
 
 from ..base import EventDataStructure
@@ -74,6 +77,41 @@ def get_variables(self) -> Any:
     def to_data(self, raw_data: Dict[str, List[Any]]) -> pl.DataFrame:
         return pl.DataFrame(raw_data)
 
+    def dump(self) -> bytes:
+        """Serialize to Parquet bytes with a 4-byte + msgpack config header."""
+        # Layout: [uint32 BE config_len][msgpack(config)][parquet bytes].
+        # msgpack carries the retention/compaction params alongside the
+        # Parquet payload so load() can rebuild the instance with the same
+        # policy (Parquet itself only stores the data).
+        config: bytes = msgpack.packb(
+            {"max_rows": self.max_rows, "compact_every": self.compact_every},
+            use_bin_type=True,
+        )
+        header: bytes = struct.pack(">I", len(config)) + config
+        buf = io.BytesIO()
+        self.get_data().write_parquet(buf)
+        return header + buf.getvalue()
+
+    @classmethod
+    def load(cls, data: bytes, **kwargs: Any) -> "ChunkedEventDataFrame":
+        """Restore from Parquet bytes (with config header).
+
+        Note: event_id and template (base dataclass fields) are not restored;
+        they remain at defaults (-1 and "") as they are managed by EventPersistency.
+        """
+        config_len = struct.unpack(">I", data[:4])[0]
+        config = msgpack.unpackb(data[4:4 + config_len], raw=False)
+        parquet_bytes = data[4 + config_len:]
+        df = pl.read_parquet(io.BytesIO(parquet_bytes)) if parquet_bytes else pl.DataFrame()
+        instance = cls(
+            max_rows=config.get("max_rows", 10_000_000),
+            compact_every=config.get("compact_every", 1000),
+        )
+        if df.height > 0:
+            instance.chunks = [df]
+            instance._rows = df.height
+        return instance
+
     def __repr__(self) -> str:
         return (
             f"ChunkedEventDataFrame(df=..., rows={self._rows}, chunks={len(self.chunks)}, "
diff --git a/src/detectmatelibrary/utils/persistency/event_data_structures/dataframes/event_dataframe.py b/src/detectmatelibrary/utils/persistency/event_data_structures/dataframes/event_dataframe.py
index a823f288..2a024883 100644
--- a/src/detectmatelibrary/utils/persistency/event_data_structures/dataframes/event_dataframe.py
+++ b/src/detectmatelibrary/utils/persistency/event_data_structures/dataframes/event_dataframe.py
@@ -1,5 +1,5 @@
+import io
 from typing import Any, Dict, List
-
 from dataclasses import dataclass, field
 
 import pandas as pd
@@ -7,8 +7,6 @@
 from ..base import EventDataStructure
 
 
-# -------- Pandas backend --------
-
 @dataclass
 class EventDataFrame(EventDataStructure):
     """
@@ -35,5 +33,22 @@ def to_data(self, raw_data: Dict[int | str, Any]) -> pd.DataFrame:
         data = {key: [value] for key, value in raw_data.items()}
         return pd.DataFrame(data)
 
+    def dump(self) -> bytes:
+        """Serialize DataFrame to Parquet bytes."""
+        buf = io.BytesIO()
+        self.data.to_parquet(buf, engine="pyarrow", index=False)
+        return buf.getvalue()
+
+    @classmethod
+    def load(cls, data: bytes, **kwargs: Any) -> "EventDataFrame":
+        """Restore DataFrame from Parquet bytes.
+
+        Note: event_id and template (base dataclass fields) are not restored;
+        they remain at defaults (-1 and "") as they are managed by EventPersistency.
+        """
+        instance = cls()
+        instance.data = pd.read_parquet(io.BytesIO(data), engine="pyarrow")
+        return instance
+
     def __repr__(self) -> str:
         return f"EventDataFrame(df=..., rows={len(self.data)}, variables={self.get_variables()})"
diff --git a/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/event_tracker.py b/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/event_tracker.py
index 7dd474d3..f43a22a7 100644
--- a/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/event_tracker.py
+++ b/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/event_tracker.py
@@ -1,7 +1,10 @@
 """Event data structure that tracks variable behaviors over time/events."""
 
+import importlib
 from typing import Any, Callable, Dict, Type
 
+import msgpack
+
 from detectmatelibrary.utils.preview_helpers import format_dict_repr
 
 from .multi_tracker import MultiTracker
@@ -15,7 +18,7 @@ class EventTracker(EventDataStructure):
 
     def __init__(
         self,
-        single_tracker_type: Type[SingleTracker] = SingleTracker,
+        single_tracker_type: Callable[[], SingleTracker] = SingleTracker,
         multi_tracker_type: Type[MultiTracker] = MultiTracker,
         converter_function: Callable[[Any], Any] = lambda x: x,
     ) -> None:
@@ -40,6 +43,76 @@ def to_data(self, raw_data: Dict[str, Any]) -> Any:
         """Transform raw data into the format expected by the tracker."""
         return self.converter_function(raw_data)
 
+    def dump(self) -> bytes:
+        """Serialize full tracker state to MessagePack bytes.
+
+        Note: converter_function is not serialized (lambdas cannot be pickled).
+        After load(), converter_function is reset to the identity default.
+        """
+        state = {
+            "single_tracker_type": self.single_tracker_type.__name__,
+            "single_tracker_module": self.single_tracker_type.__module__,
+            "multi_tracker_type": self.multi_tracker_type.__name__,
+            "multi_tracker_module": self.multi_tracker_type.__module__,
+            "trackers": {
+                name: tracker.to_state()
+                for name, tracker in self.multi_tracker.get_trackers().items()
+            },
+        }
+        result: bytes = msgpack.packb(state, use_bin_type=True)
+        return result
+
+    @classmethod
+    def load(cls, data: bytes, **kwargs: Any) -> "EventTracker":
+        """Restore tracker state from MessagePack bytes.
+
+        Reconstruction follows two paths. When ``cls is EventTracker`` the
+        legacy path runs: ``__new__`` allocates the instance and the base
+        ``__init__`` is invoked directly with the ``single_tracker_type`` and
+        ``multi_tracker_type`` recorded in the snapshot. For any subclass,
+        ``cls(**kwargs)`` is called instead, which lets subclasses with
+        closure-based factories (e.g. ``EventStabilityTracker``'s
+        ``expand_value``) rebuild their factory so it survives load.
+
+        Contract for subclasses: ``__init__`` must accept the kwargs forwarded
+        to ``load()`` and must not require additional positional arguments.
+
+        Note: event_id and template (base dataclass fields) are not restored;
+        they remain at defaults (-1 and "") as they are managed by EventPersistency.
+        """
+        def _list_keys_to_tuples(pairs: list[tuple[Any, Any]]) -> dict[Any, Any]:
+            """Convert list keys (from msgpack) back to tuples so they can be
+            used as dict keys."""
+            result: dict[Any, Any] = {}
+            for k, v in pairs:
+                if isinstance(k, list):
+                    k = tuple(k)
+                result[k] = v
+            return result
+
+        state = msgpack.unpackb(data, raw=False, strict_map_key=False,
+                                object_pairs_hook=_list_keys_to_tuples)
+        single_tracker_cls = getattr(
+            importlib.import_module(state["single_tracker_module"]),
+            state["single_tracker_type"],
+        )
+        multi_tracker_cls = getattr(
+            importlib.import_module(state["multi_tracker_module"]),
+            state["multi_tracker_type"],
+        )
+        if cls is EventTracker:
+            instance = cls.__new__(cls)
+            EventTracker.__init__(
+                instance,
+                single_tracker_type=single_tracker_cls,
+                multi_tracker_type=multi_tracker_cls,
+            )
+        else:
+            instance = cls(**kwargs)
+        for name, tracker_state in state["trackers"].items():
+            instance.multi_tracker.single_trackers[name] = single_tracker_cls.from_state(tracker_state)
+        return instance
+
     def __repr__(self) -> str:
         strs = format_dict_repr(self.multi_tracker.get_trackers(), indent="\t")
         return f"{self.__class__.__name__}(data={{\n\t{strs}\n}})"
diff --git a/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/multi_tracker.py b/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/multi_tracker.py
index d6fea789..08df8218 100644
--- a/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/multi_tracker.py
+++ b/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/multi_tracker.py
@@ -1,4 +1,4 @@
-from typing import Any, Dict, Type
+from typing import Any, Callable, Dict
 
 from detectmatelibrary.utils.preview_helpers import format_dict_repr
 
@@ -9,9 +9,9 @@ class MultiTracker:
     """Tracks multiple features (e.g. variables or variable combos) using
     individual trackers."""
 
-    def __init__(self, single_tracker_type: Type[SingleTracker] = SingleTracker) -> None:
+    def __init__(self, single_tracker_type: Callable[[], SingleTracker] = SingleTracker) -> None:
         self.single_trackers: Dict[str, SingleTracker] = {}
-        self.single_tracker_type: Type[SingleTracker] = single_tracker_type
+        self.single_tracker_type: Callable[[], SingleTracker] = single_tracker_type
 
     def add_data(self, data_object: Dict[str, Any]) -> None:
         """Add data to the appropriate feature trackers."""
diff --git a/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/single_tracker.py b/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/single_tracker.py
index de6a017c..01808d89 100644
--- a/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/single_tracker.py
+++ b/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/base/single_tracker.py
@@ -1,6 +1,6 @@
 """Tracks whether a variable is converging to a constant value."""
 
-from typing import Any
+from typing import Any, Dict
 from dataclasses import dataclass
 from abc import ABC, abstractmethod
 
@@ -26,3 +26,15 @@ def classify(self) -> Classification:
     @abstractmethod
     def __repr__(self) -> str:
         pass
+
+    @abstractmethod
+    def to_state(self) -> Dict[str, Any]:
+        """Serialize tracker state to a plain dict (must be msgpack-
+        compatible)."""
+        ...
+
+    @classmethod
+    @abstractmethod
+    def from_state(cls, state: Dict[str, Any]) -> "SingleTracker":
+        """Restore tracker from a state dict produced by to_state()."""
+        ...
diff --git a/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/stability/stability_classifier.py b/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/stability/stability_classifier.py
index 5c2237c4..25db8bc2 100644
--- a/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/stability/stability_classifier.py
+++ b/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/stability/stability_classifier.py
@@ -3,7 +3,7 @@
 from typing import List
 import numpy as np
 
-from detectmatelibrary.utils.RLE_list import RLEList
+from detectmatelibrary.utils.persistency.rle_list import RLEList
 
 
 class StabilityClassifier:
diff --git a/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/stability/stability_tracker.py b/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/stability/stability_tracker.py
index a37ab3da..8184cc0a 100644
--- a/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/stability/stability_tracker.py
+++ b/src/detectmatelibrary/utils/persistency/event_data_structures/trackers/stability/stability_tracker.py
@@ -1,9 +1,9 @@
 """Tracks whether a variable is converging to a constant value."""
 
-from typing import Any, Callable, List, Literal, Set
+from typing import Any, Callable, Dict, List, Literal, Set
 
 from detectmatelibrary.utils.preview_helpers import list_preview_str
-from detectmatelibrary.utils.RLE_list import RLEList
+from detectmatelibrary.utils.persistency.rle_list import RLEList
 
 from ..base import SingleTracker, MultiTracker, EventTracker, Classification
 from .stability_classifier import StabilityClassifier
@@ -12,20 +12,24 @@
 class SingleStabilityTracker(SingleTracker):
     """Tracks stability of a single feature."""
 
-    def __init__(self, min_samples: int = 3) -> None:
+    def __init__(self, min_samples: int = 3, expand_value: bool = False) -> None:
         self.min_samples = min_samples
+        self.expand_value = expand_value
         self.change_series: RLEList[bool] = RLEList()
         self.unique_set: Set[Any] = set()
         self.stability_classifier: StabilityClassifier = StabilityClassifier(
             segment_thresholds=[1.1, 0.3, 0.1, 0.01],
         )
+        self._accum = set.update if expand_value else set.add
+        # Opaque slot for detectors to stash per-variable model state that
+        # must survive save/load. Schema-free; the tracker does not interpret it.
+        self.extra_state: Dict[str, Any] = {}
 
     def add_value(self, value: Any) -> None:
         """Add a new value to the tracker."""
-        unique_set_size_before = len(self.unique_set)
-        self.unique_set.add(value)
-        has_changed = len(self.unique_set) - unique_set_size_before > 0
-        self.change_series.append(has_changed)
+        before = len(self.unique_set)
+        self._accum(self.unique_set, value)
+        self.change_series.append(len(self.unique_set) > before)
 
     def classify(self) -> Classification:
         """Classify the variable."""
@@ -58,6 +62,39 @@ def classify(self) -> Classification:
                 reason="No classification matched; variable is unstable"
             )
 
+    def to_state(self) -> Dict[str, Any]:
+        """Serialize tracker state to a plain dict (must be msgpack-
+        compatible)."""
+        return {
+            "type": self.__class__.__name__,
+            "module": self.__class__.__module__,
+            "min_samples": self.min_samples,
+            "expand_value": self.expand_value,
+            "runs": self.change_series.runs(),
+            "unique_set": list(self.unique_set),
+            "segment_thresholds": self.stability_classifier.segment_threshs,
+            "extra_state": self.extra_state,
+        }
+
+    @classmethod
+    def from_state(cls, state: Dict[str, Any]) -> "SingleStabilityTracker":
+        """Restore tracker from a state dict produced by to_state()."""
+        tracker = cls(
+            min_samples=state["min_samples"],
+            expand_value=state.get("expand_value", False),
+        )
+        runs = [(bool(r[0]), int(r[1])) for r in state["runs"]]
+        tracker.change_series._runs = runs
+        tracker.change_series._len = sum(count for _, count in runs)
+        tracker.unique_set = {
+            tuple(v) if isinstance(v, list) else v for v in state["unique_set"]
+        }
+        tracker.stability_classifier = StabilityClassifier(
+            segment_thresholds=state["segment_thresholds"]
+        )
+        tracker.extra_state = state.get("extra_state", {})
+        return tracker
+
     def __repr__(self) -> str:
         # show only part of the series for brevity
         series_str = list_preview_str(self.change_series)
@@ -73,7 +110,7 @@ class MultiStabilityTracker(MultiTracker):
     """Tracks multiple features (e.g. variables or variable combos) using
     individual trackers."""
 
-    def get_variables_by_classification(
+    def get_features_by_classification(
         self,
         classification_type: Literal["INSUFFICIENT_DATA", "STATIC", "RANDOM", "STABLE", "UNSTABLE"]
     ) -> List[str]:
@@ -91,17 +128,30 @@ class EventStabilityTracker(EventTracker):
     """Event data structure that tracks the stability of each event over time /
     number of events."""
 
-    def __init__(self, converter_function: Callable[[Any], Any] = lambda x: x) -> None:
-        self.multi_tracker:  MultiStabilityTracker  # for type hinting
+    def __init__(
+        self,
+        converter_function: Callable[[Any], Any] = lambda x: x,
+        expand_value: bool = False,
+    ) -> None:
+        self.multi_tracker: MultiStabilityTracker  # for type hinting
+
+        def make_tracker() -> SingleStabilityTracker:
+            return SingleStabilityTracker(expand_value=expand_value)
+
+        # Mirror class identity onto the closure so dump()/load() can resolve
+        # the underlying SingleStabilityTracker via its module + qualname.
+        make_tracker.__name__ = SingleStabilityTracker.__name__
+        make_tracker.__module__ = SingleStabilityTracker.__module__
+
         super().__init__(
-            single_tracker_type=SingleStabilityTracker,
+            single_tracker_type=make_tracker,
             multi_tracker_type=MultiStabilityTracker,
             converter_function=converter_function,
         )
 
-    def get_variables_by_classification(
+    def get_features_by_classification(
         self, classification_type: Literal["INSUFFICIENT_DATA", "STATIC", "RANDOM", "STABLE", "UNSTABLE"]
     ) -> List[str]:
         """Get a list of variable names that are classified as the given
         type."""
-        return self.multi_tracker.get_variables_by_classification(classification_type)
+        return self.multi_tracker.get_features_by_classification(classification_type)
diff --git a/src/detectmatelibrary/utils/persistency/event_persistency.py b/src/detectmatelibrary/utils/persistency/event_persistency.py
index c21cb76f..2ad1b52f 100644
--- a/src/detectmatelibrary/utils/persistency/event_persistency.py
+++ b/src/detectmatelibrary/utils/persistency/event_persistency.py
@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Type
+from typing import Any, Callable, Dict, List, Optional, Type
 
 from .event_data_structures.base import EventDataStructure
 
@@ -26,10 +26,13 @@ def __init__(
         event_data_kwargs: Optional[dict[str, Any]] = None,
     ):
         self.events_data: Dict[int | str, EventDataStructure] = {}
+        self.events_seen: set[int | str] = set()
         self.event_data_class = event_data_class
         self.event_data_kwargs = event_data_kwargs or {}
         self.variable_blacklist = variable_blacklist or []
         self.event_templates: Dict[int | str, str] = {}
+        self._events_since_save: int = 0
+        self._on_ingest_callbacks: list[Callable[[], None]] = []
 
     def ingest_event(
         self,
@@ -39,6 +42,10 @@ def ingest_event(
         named_variables: Dict[str, Any] = {}
     ) -> None:
         """Ingest event data into the appropriate EventData store."""
+        self._events_since_save += 1
+        for _cb in self._on_ingest_callbacks:
+            _cb()
+        self.events_seen.add(event_id)
         if not variables and not named_variables:
             return
         self.event_templates[event_id] = event_template
@@ -52,6 +59,19 @@ def ingest_event(
         data = data_structure.to_data(all_variables)
         data_structure.add_data(data)
 
+    def reset_events_since_save(self) -> None:
+        """Reset the events-since-save counter after a successful save."""
+        self._events_since_save = 0
+
+    def register_on_ingest(self, callback: Callable[[], None]) -> None:
+        """Register a callback invoked after every ingest_event call."""
+        self._on_ingest_callbacks.append(callback)
+
+    def get_events_seen(self) -> set[int | str]:
+        """Retrieve all event IDs observed via ingest_event(), regardless of
+        whether variables were extracted."""
+        return self.events_seen
+
     def get_event_data(self, event_id: int | str) -> Any | None:
         """Retrieve the data for a specific event ID."""
         data_structure = self.events_data.get(event_id)
diff --git a/src/detectmatelibrary/utils/persistency/persistency_saver.py b/src/detectmatelibrary/utils/persistency/persistency_saver.py
new file mode 100644
index 00000000..13db6e16
--- /dev/null
+++ b/src/detectmatelibrary/utils/persistency/persistency_saver.py
@@ -0,0 +1,215 @@
+import atexit
+import json
+import signal
+import threading
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Callable
+
+import fsspec
+
+from detectmatelibrary.utils.persistency.event_data_structures.base import EventDataStructure
+from detectmatelibrary.utils.persistency.event_data_structures.dataframes import (
+    EventDataFrame,
+    ChunkedEventDataFrame,
+)
+from detectmatelibrary.utils.persistency.event_data_structures.trackers import (
+    EventTracker,
+    EventStabilityTracker,
+)
+from detectmatelibrary.utils.persistency.event_persistency import EventPersistency
+from detectmatelibrary_tools.logging import logger
+
+_BACKEND_REGISTRY: dict[str, type[EventDataStructure]] = {
+    "EventTracker": EventTracker,
+    "EventStabilityTracker": EventStabilityTracker,
+    "EventDataFrame": EventDataFrame,
+    "ChunkedEventDataFrame": ChunkedEventDataFrame,
+}
+
+_EXTENSION_MAP: dict[str, str] = {
+    "EventTracker": "msgpack",
+    "EventStabilityTracker": "msgpack",
+    "EventDataFrame": "parquet",
+    "ChunkedEventDataFrame": "parquet",
+}
+
+
+def _coerce_event_id(k: str) -> int | str:
+    try:
+        return int(k)
+    except ValueError:
+        return k
+
+
+class PersistencyLoadError(Exception):
+    """Raised when restoring persisted state fails."""
+
+
+@dataclass
+class PersistencySaverConfig:
+    path: str
+    save_interval_seconds: int = 300
+    events_until_save: int | None = None
+    auto_load: bool = False
+    storage_options: dict[str, Any] = field(default_factory=dict)
+
+
+class _SaveTimer(threading.Thread):
+    """Daemon thread that calls callback every interval seconds."""
+
+    def __init__(self, interval: float, callback: Callable[[], None]) -> None:
+        super().__init__(daemon=True)
+        self._interval = interval
+        self._callback = callback
+        self._stop_event = threading.Event()
+
+    def run(self) -> None:
+        while not self._stop_event.wait(self._interval):
+            self._callback()
+
+    def stop(self) -> None:
+        self._stop_event.set()
+
+
+class PersistencySaver:
+    """Saves and restores EventPersistency state to/from configurable storage
+    via fsspec."""
+
+    def __init__(self, persistency: EventPersistency, config: PersistencySaverConfig) -> None:
+        self._persistency = persistency
+        self._config = config
+        self._fs, self._root = fsspec.url_to_fs(config.path, **config.storage_options)
+        self._lock = threading.Lock()
+        self._timer: _SaveTimer | None = None
+
+        if config.events_until_save is not None:
+            persistency.register_on_ingest(self._check_event_count)
+
+        if config.auto_load:
+            self.load()
+
+    def save(self) -> None:
+        """Write full EventPersistency state to storage.
+
+        Thread-safe.
+        """
+        with self._lock:
+            try:
+                self._fs.makedirs(f"{self._root}/events", exist_ok=True)
+                event_backends: dict[str, str] = {}
+                event_extensions: dict[str, str] = {}
+
+                for event_id, data_structure in self._persistency.events_data.items():
+                    backend_name = type(data_structure).__name__
+                    ext = _EXTENSION_MAP.get(backend_name, "bin")
+                    event_backends[str(event_id)] = backend_name
+                    event_extensions[str(event_id)] = ext
+
+                    file_path = f"{self._root}/events/{event_id}.{ext}"
+                    with self._fs.open(file_path, "wb") as f:
+                        f.write(data_structure.dump())
+
+                metadata = {
+                    "version": 1,
+                    "saved_at": datetime.now(timezone.utc).isoformat(),
+                    "events_seen": list(self._persistency.events_seen),
+                    "event_templates": {
+                        str(k): v for k, v in self._persistency.event_templates.items()
+                    },
+                    "event_backends": event_backends,
+                    "event_extensions": event_extensions,
+                    "event_data_kwargs": self._safe_event_data_kwargs(),
+                }
+                with self._fs.open(f"{self._root}/metadata.json", "w") as f:
+                    json.dump(metadata, f, indent=2)
+
+                self._persistency.reset_events_since_save()
+            except Exception as e:
+                logger.warning(f"PersistencySaver: save failed — {e}")
+
+    def load(self) -> None:
+        """Restore EventPersistency state from storage.
+
+        Raises PersistencyLoadError on failure.
+        """
+        meta_path = f"{self._root}/metadata.json"
+        if not self._fs.exists(meta_path):
+            raise PersistencyLoadError(
+                f"No saved state found at '{self._config.path}' (metadata.json missing)"
+            )
+        try:
+            with self._fs.open(meta_path, "r") as f:
+                metadata = json.load(f)
+
+            self._persistency.events_seen = set(metadata["events_seen"])
+            self._persistency.event_templates = {
+                _coerce_event_id(k): v for k, v in metadata["event_templates"].items()
+            }
+            global_kwargs = metadata.get("event_data_kwargs", {})
+
+            for event_id_str, backend_name in metadata["event_backends"].items():
+                event_id = _coerce_event_id(event_id_str)
+                ext = metadata["event_extensions"][event_id_str]
+                file_path = f"{self._root}/events/{event_id_str}.{ext}"
+                with self._fs.open(file_path, "rb") as f:
+                    data = f.read()
+                if backend_name not in _BACKEND_REGISTRY:
+                    raise PersistencyLoadError(
+                        f"Unknown backend '{backend_name}' — cannot restore event '{event_id}'"
+                    )
+                backend_cls = _BACKEND_REGISTRY[backend_name]
+                self._persistency.events_data[event_id] = backend_cls.load(data, **global_kwargs)
+        except PersistencyLoadError:
+            raise
+        except Exception as e:
+            raise PersistencyLoadError(f"Failed to restore state: {e}") from e
+
+    def start(self) -> None:
+        """Start the background save timer and register process-exit hooks."""
+        atexit.register(self.stop)
+        try:
+            signal.signal(signal.SIGTERM, lambda *_: self.stop())
+        except (OSError, ValueError):
+            pass  # not the main thread or signal not available
+
+        self._timer = _SaveTimer(
+            interval=self._config.save_interval_seconds,
+            callback=self._tick,
+        )
+        self._timer.start()
+
+    def stop(self) -> None:
+        """Stop the timer and do a final save."""
+        if self._timer is None:
+            return
+        self._timer.stop()
+        self._timer.join(timeout=5.0)
+        self._timer = None
+        atexit.unregister(self.stop)
+        self.save()
+
+    def _safe_event_data_kwargs(self) -> dict[str, Any]:
+        """Return event_data_kwargs with non-JSON-serializable values
+        excluded."""
+        safe = {}
+        for k, v in self._persistency.event_data_kwargs.items():
+            try:
+                json.dumps(v)
+                safe[k] = v
+            except (TypeError, ValueError):
+                pass
+        return safe
+
+    def _check_event_count(self) -> None:
+        """Trigger a save when ingested-event count reaches
+        events_until_save."""
+        if (
+            self._config.events_until_save is not None
+            and self._persistency._events_since_save >= self._config.events_until_save
+        ):
+            self.save()
+
+    def _tick(self) -> None:
+        """Called by the timer thread each interval."""
+        self.save()
diff --git a/src/detectmatelibrary/utils/RLE_list.py b/src/detectmatelibrary/utils/persistency/rle_list.py
similarity index 97%
rename from src/detectmatelibrary/utils/RLE_list.py
rename to src/detectmatelibrary/utils/persistency/rle_list.py
index 8009433e..586e084a 100644
--- a/src/detectmatelibrary/utils/RLE_list.py
+++ b/src/detectmatelibrary/utils/persistency/rle_list.py
@@ -3,7 +3,7 @@
 
 from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar
 
-from .preview_helpers import list_preview_str
+from ..preview_helpers import list_preview_str
 
 T = TypeVar("T")
 
diff --git a/src/detectmatelibrary_tools/__init__.py b/src/detectmatelibrary_tools/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/tools/logging.py b/src/detectmatelibrary_tools/logging.py
similarity index 100%
rename from src/tools/logging.py
rename to src/detectmatelibrary_tools/logging.py
diff --git a/src/detectmatelibrary_tools/workspace/__init__.py b/src/detectmatelibrary_tools/workspace/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/tools/workspace/create_workspace.py b/src/detectmatelibrary_tools/workspace/create_workspace.py
similarity index 91%
rename from src/tools/workspace/create_workspace.py
rename to src/detectmatelibrary_tools/workspace/create_workspace.py
index 09e286b4..0d79a09d 100644
--- a/src/tools/workspace/create_workspace.py
+++ b/src/detectmatelibrary_tools/workspace/create_workspace.py
@@ -6,14 +6,14 @@
 from .utils import create_readme, create_pyproject, normalize_package_name
 
 # resolve paths relative to this file
-BASE_DIR = Path(__file__).resolve().parent.parent  # tools/
+BASE_DIR = Path(__file__).resolve().parent.parent  # detectmatelibrary_tools/
 PROJECT_ROOT = BASE_DIR.parent.parent  # root of project
 TEMPLATE_DIR = BASE_DIR / "workspace" / "templates"
 
 META_FILES = ["LICENSE.md", ".gitignore", ".pre-commit-config.yaml"]
 DATA_FILES = {
-    "parser": "src/tools/workspace/templates/data/logs.json",
-    "detector": "src/tools/workspace/templates/data/parsed_log.json"
+    "parser": "src/detectmatelibrary_tools/workspace/templates/data/logs.json",
+    "detector": "src/detectmatelibrary_tools/workspace/templates/data/parsed_log.json"
 }
 
 
@@ -33,14 +33,15 @@ def camelize(name: str) -> str:
 
 
 def create_tests(type_: str, name: str, workspace_root: Path, pkg_name: str) -> None:
-    """Create a tests/ directory with a basic pytest file for the component.
+    """Create a detectmatelibrary_tests/ directory with a basic pytest file for
+    the component.
 
-    - Reads template tests from src/tools/workspace/templates/test_templates/
+    - Reads template tests from src/detectmatelibrary_tools/workspace/templates/test_templates/
     - Rewrites the import to point to <pkg_name>.<name>
     - Renames CustomParser/CustomDetector to the camelized class name
     """
 
-    tests_dir = workspace_root / "tests"
+    tests_dir = workspace_root / "detectmatelibrary_tests"
     tests_dir.mkdir(parents=True, exist_ok=True)
     template_file = TEMPLATE_DIR / "test_templates" / f"test_Custom{type_.capitalize()}.py"
     test_file = tests_dir / f"test_{name}.py"
@@ -63,7 +64,7 @@ def create_tests(type_: str, name: str, workspace_root: Path, pkg_name: str) ->
     # replace the import line
     content = template_content.replace(original_import, new_import)
     # replace the remaining occurrences of CustomParser/CustomDetector
-    # with the new class name (inside the tests)
+    # with the new class name (inside the detectmatelibrary_tests)
     content = content.replace(base_class, new_class)
     content = content.replace(f'"custom_{type_}"', f'"{name}_{type_}"')
     content = content.rstrip() + "\n"
diff --git a/src/tools/workspace/templates/CustomDetector.py b/src/detectmatelibrary_tools/workspace/templates/CustomDetector.py
similarity index 100%
rename from src/tools/workspace/templates/CustomDetector.py
rename to src/detectmatelibrary_tools/workspace/templates/CustomDetector.py
diff --git a/src/tools/workspace/templates/CustomParser.py b/src/detectmatelibrary_tools/workspace/templates/CustomParser.py
similarity index 100%
rename from src/tools/workspace/templates/CustomParser.py
rename to src/detectmatelibrary_tools/workspace/templates/CustomParser.py
diff --git a/src/detectmatelibrary_tools/workspace/templates/__init__.py b/src/detectmatelibrary_tools/workspace/templates/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/tools/workspace/templates/data/logs.json b/src/detectmatelibrary_tools/workspace/templates/data/logs.json
similarity index 100%
rename from src/tools/workspace/templates/data/logs.json
rename to src/detectmatelibrary_tools/workspace/templates/data/logs.json
diff --git a/src/tools/workspace/templates/data/parsed_log.json b/src/detectmatelibrary_tools/workspace/templates/data/parsed_log.json
similarity index 100%
rename from src/tools/workspace/templates/data/parsed_log.json
rename to src/detectmatelibrary_tools/workspace/templates/data/parsed_log.json
diff --git a/src/detectmatelibrary_tools/workspace/templates/test_templates/__init__.py b/src/detectmatelibrary_tools/workspace/templates/test_templates/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/tools/workspace/templates/test_templates/test_CustomDetector.py b/src/detectmatelibrary_tools/workspace/templates/test_templates/test_CustomDetector.py
similarity index 100%
rename from src/tools/workspace/templates/test_templates/test_CustomDetector.py
rename to src/detectmatelibrary_tools/workspace/templates/test_templates/test_CustomDetector.py
diff --git a/src/tools/workspace/templates/test_templates/test_CustomParser.py b/src/detectmatelibrary_tools/workspace/templates/test_templates/test_CustomParser.py
similarity index 100%
rename from src/tools/workspace/templates/test_templates/test_CustomParser.py
rename to src/detectmatelibrary_tools/workspace/templates/test_templates/test_CustomParser.py
diff --git a/src/tools/workspace/utils.py b/src/detectmatelibrary_tools/workspace/utils.py
similarity index 100%
rename from src/tools/workspace/utils.py
rename to src/detectmatelibrary_tools/workspace/utils.py
diff --git a/tests/test_parsers/test_template_matcher.py b/tests/test_parsers/test_template_matcher.py
deleted file mode 100644
index c5c892e0..00000000
--- a/tests/test_parsers/test_template_matcher.py
+++ /dev/null
@@ -1,79 +0,0 @@
-
-import pytest
-from detectmatelibrary.parsers.template_matcher import (
-    MatcherParser, MatcherParserConfig, TemplatesNotFoundError
-)
-from detectmatelibrary import schemas
-
-test_template = [
-    "pid=<*> uid=<*> auid=<*> ses=<*> msg='op=PAM:<*> acct=<*>",
-]
-test_log_match = 'pid=9699 uid=0 auid=4294967295 ses=4294967295 msg=\'op=PAM:accounting acct="root"'
-test_log_no_match = 'this is not matching'
-
-
-class TestMatcherParserBasic:
-    def test_templates_not_found(self):
-        config_dict = {
-            "parsers": {
-                "MatcherParser": {
-                    "auto_config": True,
-                    "method_type": "matcher_parser",
-                    "path_templates": "non_existent_file.txt"
-                }
-            }
-        }
-        with pytest.raises(TemplatesNotFoundError):
-            MatcherParser(name="MatcherParser", config=config_dict)
-
-    def test_successful_match(self):
-        config_dict = {
-            "parsers": {
-                "MatcherParser": {
-                    "auto_config": True,
-                    "method_type": "matcher_parser",
-                    "path_templates": "tests/test_folder/test_templates.txt"
-                }
-            }
-        }
-        parser = MatcherParser(name="MatcherParser", config=config_dict)
-        input_log = schemas.LogSchema({"log": test_log_match})
-        output_data = schemas.ParserSchema()
-        parser.parse(input_log, output_data)
-
-        assert output_data.template == test_template[0]
-        assert output_data.EventID == 0
-        assert len(output_data.variables) > 0
-
-    def test_no_match(self):
-        config_dict = {
-            "parsers": {
-                "MatcherParser": {
-                    "auto_config": True,
-                    "method_type": "matcher_parser",
-                    "path_templates": "tests/test_folder/test_templates.txt"
-                }
-            }
-        }
-        parser = MatcherParser(name="MatcherParser", config=config_dict)
-        input_log = schemas.LogSchema({"log": test_log_no_match})
-        output_data = schemas.ParserSchema()
-        parser.parse(input_log, output_data)
-
-        assert output_data.template == "<Not Found>"
-        assert output_data.EventID == -1
-        assert output_data.variables == []
-
-    def test_custom_preprocessing_flags(self):
-        config = MatcherParserConfig(
-            remove_spaces=False,
-            remove_punctuation=False,
-            lowercase=False,
-            path_templates="tests/test_folder/test_templates.txt"
-        )
-        parser = MatcherParser(name="MatcherParser", config=config)
-        input_log = schemas.LogSchema({"log": test_log_match})
-        output_data = schemas.ParserSchema()
-        parser.parse(input_log, output_data)
-        # Still matches template even with preprocessing disabled
-        assert output_data.template == test_template[0]
diff --git a/uv.lock b/uv.lock
index 14d6254c..57f054d2 100644
--- a/uv.lock
+++ b/uv.lock
@@ -5,9 +5,12 @@ resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
     "python_full_version >= '3.14' and sys_platform == 'emscripten'",
     "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
-    "python_full_version < '3.14' and sys_platform == 'win32'",
-    "python_full_version < '3.14' and sys_platform == 'emscripten'",
-    "python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'win32'",
+    "python_full_version < '3.13' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
+    "python_full_version < '3.13' and sys_platform == 'emscripten'",
+    "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version < '3.13' and sys_platform != 'emscripten' and sys_platform != 'win32'",
 ]
 
 [[package]]
@@ -21,109 +24,109 @@ wheels = [
 
 [[package]]
 name = "anyio"
-version = "4.12.1"
+version = "4.13.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
 ]
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.4.22"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", hash = "sha256:8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580", size = 137077, upload-time = "2026-04-22T11:26:11.191Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" },
 ]
 
 [[package]]
 name = "charset-normalizer"
-version = "3.4.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7b/60/e3bec1881450851b087e301bedc3daa9377a4d45f1c26aa90b0b235e38aa/charset_normalizer-3.4.6.tar.gz", hash = "sha256:1ae6b62897110aa7c79ea2f5dd38d1abca6db663687c0b1ad9aed6f6bae3d9d6", size = 143363, upload-time = "2026-03-15T18:53:25.478Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/62/c0815c992c9545347aeea7859b50dc9044d147e2e7278329c6e02ac9a616/charset_normalizer-3.4.6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2ef7fedc7a6ecbe99969cd09632516738a97eeb8bd7258bf8a0f23114c057dab", size = 295154, upload-time = "2026-03-15T18:50:50.88Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/37/bdca6613c2e3c58c7421891d80cc3efa1d32e882f7c4a7ee6039c3fc951a/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a4ea868bc28109052790eb2b52a9ab33f3aa7adc02f96673526ff47419490e21", size = 199191, upload-time = "2026-03-15T18:50:52.658Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/92/9934d1bbd69f7f398b38c5dae1cbf9cc672e7c34a4adf7b17c0a9c17d15d/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:836ab36280f21fc1a03c99cd05c6b7af70d2697e374c7af0b61ed271401a72a2", size = 218674, upload-time = "2026-03-15T18:50:54.102Z" },
-    { url = "https://files.pythonhosted.org/packages/af/90/25f6ab406659286be929fd89ab0e78e38aa183fc374e03aa3c12d730af8a/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f1ce721c8a7dfec21fcbdfe04e8f68174183cf4e8188e0645e92aa23985c57ff", size = 215259, upload-time = "2026-03-15T18:50:55.616Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/ef/79a463eb0fff7f96afa04c1d4c51f8fc85426f918db467854bfb6a569ce3/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e28d62a8fc7a1fa411c43bd65e346f3bce9716dc51b897fbe930c5987b402d5", size = 207276, upload-time = "2026-03-15T18:50:57.054Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/72/d0426afec4b71dc159fa6b4e68f868cd5a3ecd918fec5813a15d292a7d10/charset_normalizer-3.4.6-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:530d548084c4a9f7a16ed4a294d459b4f229db50df689bfe92027452452943a0", size = 195161, upload-time = "2026-03-15T18:50:58.686Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/18/c82b06a68bfcb6ce55e508225d210c7e6a4ea122bfc0748892f3dc4e8e11/charset_normalizer-3.4.6-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:30f445ae60aad5e1f8bdbb3108e39f6fbc09f4ea16c815c66578878325f8f15a", size = 203452, upload-time = "2026-03-15T18:51:00.196Z" },
-    { url = "https://files.pythonhosted.org/packages/44/d6/0c25979b92f8adafdbb946160348d8d44aa60ce99afdc27df524379875cb/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ac2393c73378fea4e52aa56285a3d64be50f1a12395afef9cce47772f60334c2", size = 202272, upload-time = "2026-03-15T18:51:01.703Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/3d/7fea3e8fe84136bebbac715dd1221cc25c173c57a699c030ab9b8900cbb7/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:90ca27cd8da8118b18a52d5f547859cc1f8354a00cd1e8e5120df3e30d6279e5", size = 195622, upload-time = "2026-03-15T18:51:03.526Z" },
-    { url = "https://files.pythonhosted.org/packages/57/8a/d6f7fd5cb96c58ef2f681424fbca01264461336d2a7fc875e4446b1f1346/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e5a94886bedca0f9b78fecd6afb6629142fd2605aa70a125d49f4edc6037ee6", size = 220056, upload-time = "2026-03-15T18:51:05.269Z" },
-    { url = "https://files.pythonhosted.org/packages/16/50/478cdda782c8c9c3fb5da3cc72dd7f331f031e7f1363a893cdd6ca0f8de0/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:695f5c2823691a25f17bc5d5ffe79fa90972cc34b002ac6c843bb8a1720e950d", size = 203751, upload-time = "2026-03-15T18:51:06.858Z" },
-    { url = "https://files.pythonhosted.org/packages/75/fc/cc2fcac943939c8e4d8791abfa139f685e5150cae9f94b60f12520feaa9b/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:231d4da14bcd9301310faf492051bee27df11f2bc7549bc0bb41fef11b82daa2", size = 216563, upload-time = "2026-03-15T18:51:08.564Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/b7/a4add1d9a5f68f3d037261aecca83abdb0ab15960a3591d340e829b37298/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a056d1ad2633548ca18ffa2f85c202cfb48b68615129143915b8dc72a806a923", size = 209265, upload-time = "2026-03-15T18:51:10.312Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/18/c094561b5d64a24277707698e54b7f67bd17a4f857bbfbb1072bba07c8bf/charset_normalizer-3.4.6-cp312-cp312-win32.whl", hash = "sha256:c2274ca724536f173122f36c98ce188fd24ce3dad886ec2b7af859518ce008a4", size = 144229, upload-time = "2026-03-15T18:51:11.694Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/20/0567efb3a8fd481b8f34f739ebddc098ed062a59fed41a8d193a61939e8f/charset_normalizer-3.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:c8ae56368f8cc97c7e40a7ee18e1cedaf8e780cd8bc5ed5ac8b81f238614facb", size = 154277, upload-time = "2026-03-15T18:51:13.004Z" },
-    { url = "https://files.pythonhosted.org/packages/15/57/28d79b44b51933119e21f65479d0864a8d5893e494cf5daab15df0247c17/charset_normalizer-3.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:899d28f422116b08be5118ef350c292b36fc15ec2daeb9ea987c89281c7bb5c4", size = 142817, upload-time = "2026-03-15T18:51:14.408Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/1d/4fdabeef4e231153b6ed7567602f3b68265ec4e5b76d6024cf647d43d981/charset_normalizer-3.4.6-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:11afb56037cbc4b1555a34dd69151e8e069bee82e613a73bef6e714ce733585f", size = 294823, upload-time = "2026-03-15T18:51:15.755Z" },
-    { url = "https://files.pythonhosted.org/packages/47/7b/20e809b89c69d37be748d98e84dce6820bf663cf19cf6b942c951a3e8f41/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:423fb7e748a08f854a08a222b983f4df1912b1daedce51a72bd24fe8f26a1843", size = 198527, upload-time = "2026-03-15T18:51:17.177Z" },
-    { url = "https://files.pythonhosted.org/packages/37/a6/4f8d27527d59c039dce6f7622593cdcd3d70a8504d87d09eb11e9fdc6062/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d73beaac5e90173ac3deb9928a74763a6d230f494e4bfb422c217a0ad8e629bf", size = 218388, upload-time = "2026-03-15T18:51:18.934Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/9b/4770ccb3e491a9bacf1c46cc8b812214fe367c86a96353ccc6daf87b01ec/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d60377dce4511655582e300dc1e5a5f24ba0cb229005a1d5c8d0cb72bb758ab8", size = 214563, upload-time = "2026-03-15T18:51:20.374Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/58/a199d245894b12db0b957d627516c78e055adc3a0d978bc7f65ddaf7c399/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:530e8cebeea0d76bdcf93357aa5e41336f48c3dc709ac52da2bb167c5b8271d9", size = 206587, upload-time = "2026-03-15T18:51:21.807Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/70/3def227f1ec56f5c69dfc8392b8bd63b11a18ca8178d9211d7cc5e5e4f27/charset_normalizer-3.4.6-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:a26611d9987b230566f24a0a125f17fe0de6a6aff9f25c9f564aaa2721a5fb88", size = 194724, upload-time = "2026-03-15T18:51:23.508Z" },
-    { url = "https://files.pythonhosted.org/packages/58/ab/9318352e220c05efd31c2779a23b50969dc94b985a2efa643ed9077bfca5/charset_normalizer-3.4.6-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34315ff4fc374b285ad7f4a0bf7dcbfe769e1b104230d40f49f700d4ab6bbd84", size = 202956, upload-time = "2026-03-15T18:51:25.239Z" },
-    { url = "https://files.pythonhosted.org/packages/75/13/f3550a3ac25b70f87ac98c40d3199a8503676c2f1620efbf8d42095cfc40/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ddd609f9e1af8c7bd6e2aca279c931aefecd148a14402d4e368f3171769fd", size = 201923, upload-time = "2026-03-15T18:51:26.682Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/db/c5c643b912740b45e8eec21de1bbab8e7fc085944d37e1e709d3dcd9d72f/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:80d0a5615143c0b3225e5e3ef22c8d5d51f3f72ce0ea6fb84c943546c7b25b6c", size = 195366, upload-time = "2026-03-15T18:51:28.129Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/67/3b1c62744f9b2448443e0eb160d8b001c849ec3fef591e012eda6484787c/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:92734d4d8d187a354a556626c221cd1a892a4e0802ccb2af432a1d85ec012194", size = 219752, upload-time = "2026-03-15T18:51:29.556Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/98/32ffbaf7f0366ffb0445930b87d103f6b406bc2c271563644bde8a2b1093/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:613f19aa6e082cf96e17e3ffd89383343d0d589abda756b7764cf78361fd41dc", size = 203296, upload-time = "2026-03-15T18:51:30.921Z" },
-    { url = "https://files.pythonhosted.org/packages/41/12/5d308c1bbe60cabb0c5ef511574a647067e2a1f631bc8634fcafaccd8293/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2b1a63e8224e401cafe7739f77efd3f9e7f5f2026bda4aead8e59afab537784f", size = 215956, upload-time = "2026-03-15T18:51:32.399Z" },
-    { url = "https://files.pythonhosted.org/packages/53/e9/5f85f6c5e20669dbe56b165c67b0260547dea97dba7e187938833d791687/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6cceb5473417d28edd20c6c984ab6fee6c6267d38d906823ebfe20b03d607dc2", size = 208652, upload-time = "2026-03-15T18:51:34.214Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/11/897052ea6af56df3eef3ca94edafee410ca699ca0c7b87960ad19932c55e/charset_normalizer-3.4.6-cp313-cp313-win32.whl", hash = "sha256:d7de2637729c67d67cf87614b566626057e95c303bc0a55ffe391f5205e7003d", size = 143940, upload-time = "2026-03-15T18:51:36.15Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/5c/724b6b363603e419829f561c854b87ed7c7e31231a7908708ac086cdf3e2/charset_normalizer-3.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:572d7c822caf521f0525ba1bce1a622a0b85cf47ffbdae6c9c19e3b5ac3c4389", size = 154101, upload-time = "2026-03-15T18:51:37.876Z" },
-    { url = "https://files.pythonhosted.org/packages/01/a5/7abf15b4c0968e47020f9ca0935fb3274deb87cb288cd187cad92e8cdffd/charset_normalizer-3.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a4474d924a47185a06411e0064b803c68be044be2d60e50e8bddcc2649957c1f", size = 143109, upload-time = "2026-03-15T18:51:39.565Z" },
-    { url = "https://files.pythonhosted.org/packages/25/6f/ffe1e1259f384594063ea1869bfb6be5cdb8bc81020fc36c3636bc8302a1/charset_normalizer-3.4.6-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9cc6e6d9e571d2f863fa77700701dae73ed5f78881efc8b3f9a4398772ff53e8", size = 294458, upload-time = "2026-03-15T18:51:41.134Z" },
-    { url = "https://files.pythonhosted.org/packages/56/60/09bb6c13a8c1016c2ed5c6a6488e4ffef506461aa5161662bd7636936fb1/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef5960d965e67165d75b7c7ffc60a83ec5abfc5c11b764ec13ea54fbef8b4421", size = 199277, upload-time = "2026-03-15T18:51:42.953Z" },
-    { url = "https://files.pythonhosted.org/packages/00/50/dcfbb72a5138bbefdc3332e8d81a23494bf67998b4b100703fd15fa52d81/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b3694e3f87f8ac7ce279d4355645b3c878d24d1424581b46282f24b92f5a4ae2", size = 218758, upload-time = "2026-03-15T18:51:44.339Z" },
-    { url = "https://files.pythonhosted.org/packages/03/b3/d79a9a191bb75f5aa81f3aaaa387ef29ce7cb7a9e5074ba8ea095cc073c2/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5d11595abf8dd942a77883a39d81433739b287b6aa71620f15164f8096221b30", size = 215299, upload-time = "2026-03-15T18:51:45.871Z" },
-    { url = "https://files.pythonhosted.org/packages/76/7e/bc8911719f7084f72fd545f647601ea3532363927f807d296a8c88a62c0d/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7bda6eebafd42133efdca535b04ccb338ab29467b3f7bf79569883676fc628db", size = 206811, upload-time = "2026-03-15T18:51:47.308Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/40/c430b969d41dda0c465aa36cc7c2c068afb67177bef50905ac371b28ccc7/charset_normalizer-3.4.6-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:bbc8c8650c6e51041ad1be191742b8b421d05bbd3410f43fa2a00c8db87678e8", size = 193706, upload-time = "2026-03-15T18:51:48.849Z" },
-    { url = "https://files.pythonhosted.org/packages/48/15/e35e0590af254f7df984de1323640ef375df5761f615b6225ba8deb9799a/charset_normalizer-3.4.6-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:22c6f0c2fbc31e76c3b8a86fba1a56eda6166e238c29cdd3d14befdb4a4e4815", size = 202706, upload-time = "2026-03-15T18:51:50.257Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/bd/f736f7b9cc5e93a18b794a50346bb16fbfd6b37f99e8f306f7951d27c17c/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7edbed096e4a4798710ed6bc75dcaa2a21b68b6c356553ac4823c3658d53743a", size = 202497, upload-time = "2026-03-15T18:51:52.012Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/ba/2cc9e3e7dfdf7760a6ed8da7446d22536f3d0ce114ac63dee2a5a3599e62/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:7f9019c9cb613f084481bd6a100b12e1547cf2efe362d873c2e31e4035a6fa43", size = 193511, upload-time = "2026-03-15T18:51:53.723Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/cb/5be49b5f776e5613be07298c80e1b02a2d900f7a7de807230595c85a8b2e/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:58c948d0d086229efc484fe2f30c2d382c86720f55cd9bc33591774348ad44e0", size = 220133, upload-time = "2026-03-15T18:51:55.333Z" },
-    { url = "https://files.pythonhosted.org/packages/83/43/99f1b5dad345accb322c80c7821071554f791a95ee50c1c90041c157ae99/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:419a9d91bd238052642a51938af8ac05da5b3343becde08d5cdeab9046df9ee1", size = 203035, upload-time = "2026-03-15T18:51:56.736Z" },
-    { url = "https://files.pythonhosted.org/packages/87/9a/62c2cb6a531483b55dddff1a68b3d891a8b498f3ca555fbcf2978e804d9d/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5273b9f0b5835ff0350c0828faea623c68bfa65b792720c453e22b25cc72930f", size = 216321, upload-time = "2026-03-15T18:51:58.17Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/79/94a010ff81e3aec7c293eb82c28f930918e517bc144c9906a060844462eb/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:0e901eb1049fdb80f5bd11ed5ea1e498ec423102f7a9b9e4645d5b8204ff2815", size = 208973, upload-time = "2026-03-15T18:51:59.998Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/57/4ecff6d4ec8585342f0c71bc03efaa99cb7468f7c91a57b105bcd561cea8/charset_normalizer-3.4.6-cp314-cp314-win32.whl", hash = "sha256:b4ff1d35e8c5bd078be89349b6f3a845128e685e751b6ea1169cf2160b344c4d", size = 144610, upload-time = "2026-03-15T18:52:02.213Z" },
-    { url = "https://files.pythonhosted.org/packages/80/94/8434a02d9d7f168c25767c64671fead8d599744a05d6a6c877144c754246/charset_normalizer-3.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:74119174722c4349af9708993118581686f343adc1c8c9c007d59be90d077f3f", size = 154962, upload-time = "2026-03-15T18:52:03.658Z" },
-    { url = "https://files.pythonhosted.org/packages/46/4c/48f2cdbfd923026503dfd67ccea45c94fd8fe988d9056b468579c66ed62b/charset_normalizer-3.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:e5bcc1a1ae744e0bb59641171ae53743760130600da8db48cbb6e4918e186e4e", size = 143595, upload-time = "2026-03-15T18:52:05.123Z" },
-    { url = "https://files.pythonhosted.org/packages/31/93/8878be7569f87b14f1d52032946131bcb6ebbd8af3e20446bc04053dc3f1/charset_normalizer-3.4.6-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ad8faf8df23f0378c6d527d8b0b15ea4a2e23c89376877c598c4870d1b2c7866", size = 314828, upload-time = "2026-03-15T18:52:06.831Z" },
-    { url = "https://files.pythonhosted.org/packages/06/b6/fae511ca98aac69ecc35cde828b0a3d146325dd03d99655ad38fc2cc3293/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f5ea69428fa1b49573eef0cc44a1d43bebd45ad0c611eb7d7eac760c7ae771bc", size = 208138, upload-time = "2026-03-15T18:52:08.239Z" },
-    { url = "https://files.pythonhosted.org/packages/54/57/64caf6e1bf07274a1e0b7c160a55ee9e8c9ec32c46846ce59b9c333f7008/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:06a7e86163334edfc5d20fe104db92fcd666e5a5df0977cb5680a506fe26cc8e", size = 224679, upload-time = "2026-03-15T18:52:10.043Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/cb/9ff5a25b9273ef160861b41f6937f86fae18b0792fe0a8e75e06acb08f1d/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e1f6e2f00a6b8edb562826e4632e26d063ac10307e80f7461f7de3ad8ef3f077", size = 223475, upload-time = "2026-03-15T18:52:11.854Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/97/440635fc093b8d7347502a377031f9605a1039c958f3cd18dcacffb37743/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95b52c68d64c1878818687a473a10547b3292e82b6f6fe483808fb1468e2f52f", size = 215230, upload-time = "2026-03-15T18:52:13.325Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/24/afff630feb571a13f07c8539fbb502d2ab494019492aaffc78ef41f1d1d0/charset_normalizer-3.4.6-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:7504e9b7dc05f99a9bbb4525c67a2c155073b44d720470a148b34166a69c054e", size = 199045, upload-time = "2026-03-15T18:52:14.752Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/17/d1399ecdaf7e0498c327433e7eefdd862b41236a7e484355b8e0e5ebd64b/charset_normalizer-3.4.6-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:172985e4ff804a7ad08eebec0a1640ece87ba5041d565fff23c8f99c1f389484", size = 211658, upload-time = "2026-03-15T18:52:16.278Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/38/16baa0affb957b3d880e5ac2144caf3f9d7de7bc4a91842e447fbb5e8b67/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4be9f4830ba8741527693848403e2c457c16e499100963ec711b1c6f2049b7c7", size = 210769, upload-time = "2026-03-15T18:52:17.782Z" },
-    { url = "https://files.pythonhosted.org/packages/05/34/c531bc6ac4c21da9ddfddb3107be2287188b3ea4b53b70fc58f2a77ac8d8/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:79090741d842f564b1b2827c0b82d846405b744d31e84f18d7a7b41c20e473ff", size = 201328, upload-time = "2026-03-15T18:52:19.553Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/73/a5a1e9ca5f234519c1953608a03fe109c306b97fdfb25f09182babad51a7/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:87725cfb1a4f1f8c2fc9890ae2f42094120f4b44db9360be5d99a4c6b0e03a9e", size = 225302, upload-time = "2026-03-15T18:52:21.043Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/f6/cd782923d112d296294dea4bcc7af5a7ae0f86ab79f8fefbda5526b6cfc0/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:fcce033e4021347d80ed9c66dcf1e7b1546319834b74445f561d2e2221de5659", size = 211127, upload-time = "2026-03-15T18:52:22.491Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/c5/0b6898950627af7d6103a449b22320372c24c6feda91aa24e201a478d161/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:ca0276464d148c72defa8bb4390cce01b4a0e425f3b50d1435aa6d7a18107602", size = 222840, upload-time = "2026-03-15T18:52:24.113Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/25/c4bba773bef442cbdc06111d40daa3de5050a676fa26e85090fc54dd12f0/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:197c1a244a274bb016dd8b79204850144ef77fe81c5b797dc389327adb552407", size = 216890, upload-time = "2026-03-15T18:52:25.541Z" },
-    { url = "https://files.pythonhosted.org/packages/35/1a/05dacadb0978da72ee287b0143097db12f2e7e8d3ffc4647da07a383b0b7/charset_normalizer-3.4.6-cp314-cp314t-win32.whl", hash = "sha256:2a24157fa36980478dd1770b585c0f30d19e18f4fb0c47c13aa568f871718579", size = 155379, upload-time = "2026-03-15T18:52:27.05Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/7a/d269d834cb3a76291651256f3b9a5945e81d0a49ab9f4a498964e83c0416/charset_normalizer-3.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:cd5e2801c89992ed8c0a3f0293ae83c159a60d9a5d685005383ef4caca77f2c4", size = 169043, upload-time = "2026-03-15T18:52:28.502Z" },
-    { url = "https://files.pythonhosted.org/packages/23/06/28b29fba521a37a8932c6a84192175c34d49f84a6d4773fa63d05f9aff22/charset_normalizer-3.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:47955475ac79cc504ef2704b192364e51d0d473ad452caedd0002605f780101c", size = 148523, upload-time = "2026-03-15T18:52:29.956Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/68/687187c7e26cb24ccbd88e5069f5ef00eba804d36dde11d99aad0838ab45/charset_normalizer-3.4.6-py3-none-any.whl", hash = "sha256:947cf925bc916d90adba35a64c82aace04fa39b46b52d4630ece166655905a69", size = 61455, upload-time = "2026-03-15T18:53:23.833Z" },
+version = "3.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" },
+    { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" },
+    { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" },
+    { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" },
+    { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" },
+    { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" },
+    { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" },
+    { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" },
+    { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" },
+    { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" },
+    { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" },
+    { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" },
+    { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" },
+    { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" },
+    { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" },
+    { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" },
+    { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" },
+    { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" },
 ]
 
 [[package]]
 name = "click"
-version = "8.3.1"
+version = "8.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", hash = "sha256:398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2", size = 328061, upload-time = "2026-04-22T15:11:27.506Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", hash = "sha256:a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613", size = 110502, upload-time = "2026-04-22T15:11:25.044Z" },
 ]
 
 [[package]]
@@ -137,99 +140,102 @@ wheels = [
 
 [[package]]
 name = "coverage"
-version = "7.13.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/24/56/95b7e30fa389756cb56630faa728da46a27b8c6eb46f9d557c68fff12b65/coverage-7.13.4.tar.gz", hash = "sha256:e5c8f6ed1e61a8b2dcdf31eb0b9bbf0130750ca79c1c49eb898e2ad86f5ccc91", size = 827239, upload-time = "2026-02-09T12:59:03.86Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/81/4ce2fdd909c5a0ed1f6dedb88aa57ab79b6d1fbd9b588c1ac7ef45659566/coverage-7.13.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:02231499b08dabbe2b96612993e5fc34217cdae907a51b906ac7fca8027a4459", size = 219449, upload-time = "2026-02-09T12:56:54.889Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/96/5238b1efc5922ddbdc9b0db9243152c09777804fb7c02ad1741eb18a11c0/coverage-7.13.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40aa8808140e55dc022b15d8aa7f651b6b3d68b365ea0398f1441e0b04d859c3", size = 219810, upload-time = "2026-02-09T12:56:56.33Z" },
-    { url = "https://files.pythonhosted.org/packages/78/72/2f372b726d433c9c35e56377cf1d513b4c16fe51841060d826b95caacec1/coverage-7.13.4-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5b856a8ccf749480024ff3bd7310adaef57bf31fd17e1bfc404b7940b6986634", size = 251308, upload-time = "2026-02-09T12:56:57.858Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/a0/2ea570925524ef4e00bb6c82649f5682a77fac5ab910a65c9284de422600/coverage-7.13.4-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c048ea43875fbf8b45d476ad79f179809c590ec7b79e2035c662e7afa3192e3", size = 254052, upload-time = "2026-02-09T12:56:59.754Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/ac/45dc2e19a1939098d783c846e130b8f862fbb50d09e0af663988f2f21973/coverage-7.13.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7b38448866e83176e28086674fe7368ab8590e4610fb662b44e345b86d63ffa", size = 255165, upload-time = "2026-02-09T12:57:01.287Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/4d/26d236ff35abc3b5e63540d3386e4c3b192168c1d96da5cb2f43c640970f/coverage-7.13.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:de6defc1c9badbf8b9e67ae90fd00519186d6ab64e5cc5f3d21359c2a9b2c1d3", size = 257432, upload-time = "2026-02-09T12:57:02.637Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/55/14a966c757d1348b2e19caf699415a2a4c4f7feaa4bbc6326a51f5c7dd1b/coverage-7.13.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7eda778067ad7ffccd23ecffce537dface96212576a07924cbf0d8799d2ded5a", size = 251716, upload-time = "2026-02-09T12:57:04.056Z" },
-    { url = "https://files.pythonhosted.org/packages/77/33/50116647905837c66d28b2af1321b845d5f5d19be9655cb84d4a0ea806b4/coverage-7.13.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e87f6c587c3f34356c3759f0420693e35e7eb0e2e41e4c011cb6ec6ecbbf1db7", size = 253089, upload-time = "2026-02-09T12:57:05.503Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/b4/8efb11a46e3665d92635a56e4f2d4529de6d33f2cb38afd47d779d15fc99/coverage-7.13.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8248977c2e33aecb2ced42fef99f2d319e9904a36e55a8a68b69207fb7e43edc", size = 251232, upload-time = "2026-02-09T12:57:06.879Z" },
-    { url = "https://files.pythonhosted.org/packages/51/24/8cd73dd399b812cc76bb0ac260e671c4163093441847ffe058ac9fda1e32/coverage-7.13.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:25381386e80ae727608e662474db537d4df1ecd42379b5ba33c84633a2b36d47", size = 255299, upload-time = "2026-02-09T12:57:08.245Z" },
-    { url = "https://files.pythonhosted.org/packages/03/94/0a4b12f1d0e029ce1ccc1c800944a9984cbe7d678e470bb6d3c6bc38a0da/coverage-7.13.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:ee756f00726693e5ba94d6df2bdfd64d4852d23b09bb0bc700e3b30e6f333985", size = 250796, upload-time = "2026-02-09T12:57:10.142Z" },
-    { url = "https://files.pythonhosted.org/packages/73/44/6002fbf88f6698ca034360ce474c406be6d5a985b3fdb3401128031eef6b/coverage-7.13.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fdfc1e28e7c7cdce44985b3043bc13bbd9c747520f94a4d7164af8260b3d91f0", size = 252673, upload-time = "2026-02-09T12:57:12.197Z" },
-    { url = "https://files.pythonhosted.org/packages/de/c6/a0279f7c00e786be75a749a5674e6fa267bcbd8209cd10c9a450c655dfa7/coverage-7.13.4-cp312-cp312-win32.whl", hash = "sha256:01d4cbc3c283a17fc1e42d614a119f7f438eabb593391283adca8dc86eff1246", size = 221990, upload-time = "2026-02-09T12:57:14.085Z" },
-    { url = "https://files.pythonhosted.org/packages/77/4e/c0a25a425fcf5557d9abd18419c95b63922e897bc86c1f327f155ef234a9/coverage-7.13.4-cp312-cp312-win_amd64.whl", hash = "sha256:9401ebc7ef522f01d01d45532c68c5ac40fb27113019b6b7d8b208f6e9baa126", size = 222800, upload-time = "2026-02-09T12:57:15.944Z" },
-    { url = "https://files.pythonhosted.org/packages/47/ac/92da44ad9a6f4e3a7debd178949d6f3769bedca33830ce9b1dcdab589a37/coverage-7.13.4-cp312-cp312-win_arm64.whl", hash = "sha256:b1ec7b6b6e93255f952e27ab58fbc68dcc468844b16ecbee881aeb29b6ab4d8d", size = 221415, upload-time = "2026-02-09T12:57:17.497Z" },
-    { url = "https://files.pythonhosted.org/packages/db/23/aad45061a31677d68e47499197a131eea55da4875d16c1f42021ab963503/coverage-7.13.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b66a2da594b6068b48b2692f043f35d4d3693fb639d5ea8b39533c2ad9ac3ab9", size = 219474, upload-time = "2026-02-09T12:57:19.332Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/70/9b8b67a0945f3dfec1fd896c5cefb7c19d5a3a6d74630b99a895170999ae/coverage-7.13.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3599eb3992d814d23b35c536c28df1a882caa950f8f507cef23d1cbf334995ac", size = 219844, upload-time = "2026-02-09T12:57:20.66Z" },
-    { url = "https://files.pythonhosted.org/packages/97/fd/7e859f8fab324cef6c4ad7cff156ca7c489fef9179d5749b0c8d321281c2/coverage-7.13.4-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:93550784d9281e374fb5a12bf1324cc8a963fd63b2d2f223503ef0fd4aa339ea", size = 250832, upload-time = "2026-02-09T12:57:22.007Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/dc/b2442d10020c2f52617828862d8b6ee337859cd8f3a1f13d607dddda9cf7/coverage-7.13.4-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b720ce6a88a2755f7c697c23268ddc47a571b88052e6b155224347389fdf6a3b", size = 253434, upload-time = "2026-02-09T12:57:23.339Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/88/6728a7ad17428b18d836540630487231f5470fb82454871149502f5e5aa2/coverage-7.13.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7b322db1284a2ed3aa28ffd8ebe3db91c929b7a333c0820abec3d838ef5b3525", size = 254676, upload-time = "2026-02-09T12:57:24.774Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/bc/21244b1b8cedf0dff0a2b53b208015fe798d5f2a8d5348dbfece04224fff/coverage-7.13.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f4594c67d8a7c89cf922d9df0438c7c7bb022ad506eddb0fdb2863359ff78242", size = 256807, upload-time = "2026-02-09T12:57:26.125Z" },
-    { url = "https://files.pythonhosted.org/packages/97/a0/ddba7ed3251cff51006737a727d84e05b61517d1784a9988a846ba508877/coverage-7.13.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53d133df809c743eb8bce33b24bcababb371f4441340578cd406e084d94a6148", size = 251058, upload-time = "2026-02-09T12:57:27.614Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/55/e289addf7ff54d3a540526f33751951bf0878f3809b47f6dfb3def69c6f7/coverage-7.13.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76451d1978b95ba6507a039090ba076105c87cc76fc3efd5d35d72093964d49a", size = 252805, upload-time = "2026-02-09T12:57:29.066Z" },
-    { url = "https://files.pythonhosted.org/packages/13/4e/cc276b1fa4a59be56d96f1dabddbdc30f4ba22e3b1cd42504c37b3313255/coverage-7.13.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7f57b33491e281e962021de110b451ab8a24182589be17e12a22c79047935e23", size = 250766, upload-time = "2026-02-09T12:57:30.522Z" },
-    { url = "https://files.pythonhosted.org/packages/94/44/1093b8f93018f8b41a8cf29636c9292502f05e4a113d4d107d14a3acd044/coverage-7.13.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1731dc33dc276dafc410a885cbf5992f1ff171393e48a21453b78727d090de80", size = 254923, upload-time = "2026-02-09T12:57:31.946Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/55/ea2796da2d42257f37dbea1aab239ba9263b31bd91d5527cdd6db5efe174/coverage-7.13.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:bd60d4fe2f6fa7dff9223ca1bbc9f05d2b6697bc5961072e5d3b952d46e1b1ea", size = 250591, upload-time = "2026-02-09T12:57:33.842Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/fa/7c4bb72aacf8af5020675aa633e59c1fbe296d22aed191b6a5b711eb2bc7/coverage-7.13.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9181a3ccead280b828fae232df12b16652702b49d41e99d657f46cc7b1f6ec7a", size = 252364, upload-time = "2026-02-09T12:57:35.743Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/38/a8d2ec0146479c20bbaa7181b5b455a0c41101eed57f10dd19a78ab44c80/coverage-7.13.4-cp313-cp313-win32.whl", hash = "sha256:f53d492307962561ac7de4cd1de3e363589b000ab69617c6156a16ba7237998d", size = 222010, upload-time = "2026-02-09T12:57:37.25Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/0c/dbfafbe90a185943dcfbc766fe0e1909f658811492d79b741523a414a6cc/coverage-7.13.4-cp313-cp313-win_amd64.whl", hash = "sha256:e6f70dec1cc557e52df5306d051ef56003f74d56e9c4dd7ddb07e07ef32a84dd", size = 222818, upload-time = "2026-02-09T12:57:38.734Z" },
-    { url = "https://files.pythonhosted.org/packages/04/d1/934918a138c932c90d78301f45f677fb05c39a3112b96fd2c8e60503cdc7/coverage-7.13.4-cp313-cp313-win_arm64.whl", hash = "sha256:fb07dc5da7e849e2ad31a5d74e9bece81f30ecf5a42909d0a695f8bd1874d6af", size = 221438, upload-time = "2026-02-09T12:57:40.223Z" },
-    { url = "https://files.pythonhosted.org/packages/52/57/ee93ced533bcb3e6df961c0c6e42da2fc6addae53fb95b94a89b1e33ebd7/coverage-7.13.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40d74da8e6c4b9ac18b15331c4b5ebc35a17069410cad462ad4f40dcd2d50c0d", size = 220165, upload-time = "2026-02-09T12:57:41.639Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/e0/969fc285a6fbdda49d91af278488d904dcd7651b2693872f0ff94e40e84a/coverage-7.13.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4223b4230a376138939a9173f1bdd6521994f2aff8047fae100d6d94d50c5a12", size = 220516, upload-time = "2026-02-09T12:57:44.215Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/b8/9531944e16267e2735a30a9641ff49671f07e8138ecf1ca13db9fd2560c7/coverage-7.13.4-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1d4be36a5114c499f9f1f9195e95ebf979460dbe2d88e6816ea202010ba1c34b", size = 261804, upload-time = "2026-02-09T12:57:45.989Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/f3/e63df6d500314a2a60390d1989240d5f27318a7a68fa30ad3806e2a9323e/coverage-7.13.4-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:200dea7d1e8095cc6e98cdabe3fd1d21ab17d3cee6dab00cadbb2fe35d9c15b9", size = 263885, upload-time = "2026-02-09T12:57:47.42Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/67/7654810de580e14b37670b60a09c599fa348e48312db5b216d730857ffe6/coverage-7.13.4-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8eb931ee8e6d8243e253e5ed7336deea6904369d2fd8ae6e43f68abbf167092", size = 266308, upload-time = "2026-02-09T12:57:49.345Z" },
-    { url = "https://files.pythonhosted.org/packages/37/6f/39d41eca0eab3cc82115953ad41c4e77935286c930e8fad15eaed1389d83/coverage-7.13.4-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75eab1ebe4f2f64d9509b984f9314d4aa788540368218b858dad56dc8f3e5eb9", size = 267452, upload-time = "2026-02-09T12:57:50.811Z" },
-    { url = "https://files.pythonhosted.org/packages/50/6d/39c0fbb8fc5cd4d2090811e553c2108cf5112e882f82505ee7495349a6bf/coverage-7.13.4-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c35eb28c1d085eb7d8c9b3296567a1bebe03ce72962e932431b9a61f28facf26", size = 261057, upload-time = "2026-02-09T12:57:52.447Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/a2/60010c669df5fa603bb5a97fb75407e191a846510da70ac657eb696b7fce/coverage-7.13.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb88b316ec33760714a4720feb2816a3a59180fd58c1985012054fa7aebee4c2", size = 263875, upload-time = "2026-02-09T12:57:53.938Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/d9/63b22a6bdbd17f1f96e9ed58604c2a6b0e72a9133e37d663bef185877cf6/coverage-7.13.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7d41eead3cc673cbd38a4417deb7fd0b4ca26954ff7dc6078e33f6ff97bed940", size = 261500, upload-time = "2026-02-09T12:57:56.012Z" },
-    { url = "https://files.pythonhosted.org/packages/70/bf/69f86ba1ad85bc3ad240e4c0e57a2e620fbc0e1645a47b5c62f0e941ad7f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:fb26a934946a6afe0e326aebe0730cdff393a8bc0bbb65a2f41e30feddca399c", size = 265212, upload-time = "2026-02-09T12:57:57.5Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/f2/5f65a278a8c2148731831574c73e42f57204243d33bedaaf18fa79c5958f/coverage-7.13.4-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:dae88bc0fc77edaa65c14be099bd57ee140cf507e6bfdeea7938457ab387efb0", size = 260398, upload-time = "2026-02-09T12:57:59.027Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/80/6e8280a350ee9fea92f14b8357448a242dcaa243cb2c72ab0ca591f66c8c/coverage-7.13.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:845f352911777a8e722bfce168958214951e07e47e5d5d9744109fa5fe77f79b", size = 262584, upload-time = "2026-02-09T12:58:01.129Z" },
-    { url = "https://files.pythonhosted.org/packages/22/63/01ff182fc95f260b539590fb12c11ad3e21332c15f9799cb5e2386f71d9f/coverage-7.13.4-cp313-cp313t-win32.whl", hash = "sha256:2fa8d5f8de70688a28240de9e139fa16b153cc3cbb01c5f16d88d6505ebdadf9", size = 222688, upload-time = "2026-02-09T12:58:02.736Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/43/89de4ef5d3cd53b886afa114065f7e9d3707bdb3e5efae13535b46ae483d/coverage-7.13.4-cp313-cp313t-win_amd64.whl", hash = "sha256:9351229c8c8407645840edcc277f4a2d44814d1bc34a2128c11c2a031d45a5dd", size = 223746, upload-time = "2026-02-09T12:58:05.362Z" },
-    { url = "https://files.pythonhosted.org/packages/35/39/7cf0aa9a10d470a5309b38b289b9bb07ddeac5d61af9b664fe9775a4cb3e/coverage-7.13.4-cp313-cp313t-win_arm64.whl", hash = "sha256:30b8d0512f2dc8c8747557e8fb459d6176a2c9e5731e2b74d311c03b78451997", size = 222003, upload-time = "2026-02-09T12:58:06.952Z" },
-    { url = "https://files.pythonhosted.org/packages/92/11/a9cf762bb83386467737d32187756a42094927150c3e107df4cb078e8590/coverage-7.13.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:300deaee342f90696ed186e3a00c71b5b3d27bffe9e827677954f4ee56969601", size = 219522, upload-time = "2026-02-09T12:58:08.623Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/28/56e6d892b7b052236d67c95f1936b6a7cf7c3e2634bf27610b8cbd7f9c60/coverage-7.13.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:29e3220258d682b6226a9b0925bc563ed9a1ebcff3cad30f043eceea7eaf2689", size = 219855, upload-time = "2026-02-09T12:58:10.176Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/69/233459ee9eb0c0d10fcc2fe425a029b3fa5ce0f040c966ebce851d030c70/coverage-7.13.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:391ee8f19bef69210978363ca930f7328081c6a0152f1166c91f0b5fdd2a773c", size = 250887, upload-time = "2026-02-09T12:58:12.503Z" },
-    { url = "https://files.pythonhosted.org/packages/06/90/2cdab0974b9b5bbc1623f7876b73603aecac11b8d95b85b5b86b32de5eab/coverage-7.13.4-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0dd7ab8278f0d58a0128ba2fca25824321f05d059c1441800e934ff2efa52129", size = 253396, upload-time = "2026-02-09T12:58:14.615Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/15/ea4da0f85bf7d7b27635039e649e99deb8173fe551096ea15017f7053537/coverage-7.13.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78cdf0d578b15148b009ccf18c686aa4f719d887e76e6b40c38ffb61d264a552", size = 254745, upload-time = "2026-02-09T12:58:16.162Z" },
-    { url = "https://files.pythonhosted.org/packages/99/11/bb356e86920c655ca4d61daee4e2bbc7258f0a37de0be32d233b561134ff/coverage-7.13.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:48685fee12c2eb3b27c62f2658e7ea21e9c3239cba5a8a242801a0a3f6a8c62a", size = 257055, upload-time = "2026-02-09T12:58:17.892Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/0f/9ae1f8cb17029e09da06ca4e28c9e1d5c1c0a511c7074592e37e0836c915/coverage-7.13.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4e83efc079eb39480e6346a15a1bcb3e9b04759c5202d157e1dd4303cd619356", size = 250911, upload-time = "2026-02-09T12:58:19.495Z" },
-    { url = "https://files.pythonhosted.org/packages/89/3a/adfb68558fa815cbc29747b553bc833d2150228f251b127f1ce97e48547c/coverage-7.13.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ecae9737b72408d6a950f7e525f30aca12d4bd8dd95e37342e5beb3a2a8c4f71", size = 252754, upload-time = "2026-02-09T12:58:21.064Z" },
-    { url = "https://files.pythonhosted.org/packages/32/b1/540d0c27c4e748bd3cd0bd001076ee416eda993c2bae47a73b7cc9357931/coverage-7.13.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ae4578f8528569d3cf303fef2ea569c7f4c4059a38c8667ccef15c6e1f118aa5", size = 250720, upload-time = "2026-02-09T12:58:22.622Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/95/383609462b3ffb1fe133014a7c84fc0dd01ed55ac6140fa1093b5af7ebb1/coverage-7.13.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:6fdef321fdfbb30a197efa02d48fcd9981f0d8ad2ae8903ac318adc653f5df98", size = 254994, upload-time = "2026-02-09T12:58:24.548Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/ba/1761138e86c81680bfc3c49579d66312865457f9fe405b033184e5793cb3/coverage-7.13.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b0f6ccf3dbe577170bebfce1318707d0e8c3650003cb4b3a9dd744575daa8b5", size = 250531, upload-time = "2026-02-09T12:58:26.271Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/8e/05900df797a9c11837ab59c4d6fe94094e029582aab75c3309a93e6fb4e3/coverage-7.13.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75fcd519f2a5765db3f0e391eb3b7d150cce1a771bf4c9f861aeab86c767a3c0", size = 252189, upload-time = "2026-02-09T12:58:27.807Z" },
-    { url = "https://files.pythonhosted.org/packages/00/bd/29c9f2db9ea4ed2738b8a9508c35626eb205d51af4ab7bf56a21a2e49926/coverage-7.13.4-cp314-cp314-win32.whl", hash = "sha256:8e798c266c378da2bd819b0677df41ab46d78065fb2a399558f3f6cae78b2fbb", size = 222258, upload-time = "2026-02-09T12:58:29.441Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/4d/1f8e723f6829977410efeb88f73673d794075091c8c7c18848d273dc9d73/coverage-7.13.4-cp314-cp314-win_amd64.whl", hash = "sha256:245e37f664d89861cf2329c9afa2c1fe9e6d4e1a09d872c947e70718aeeac505", size = 223073, upload-time = "2026-02-09T12:58:31.026Z" },
-    { url = "https://files.pythonhosted.org/packages/51/5b/84100025be913b44e082ea32abcf1afbf4e872f5120b7a1cab1d331b1e13/coverage-7.13.4-cp314-cp314-win_arm64.whl", hash = "sha256:ad27098a189e5838900ce4c2a99f2fe42a0bf0c2093c17c69b45a71579e8d4a2", size = 221638, upload-time = "2026-02-09T12:58:32.599Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/e4/c884a405d6ead1370433dad1e3720216b4f9fd8ef5b64bfd984a2a60a11a/coverage-7.13.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:85480adfb35ffc32d40918aad81b89c69c9cc5661a9b8a81476d3e645321a056", size = 220246, upload-time = "2026-02-09T12:58:34.181Z" },
-    { url = "https://files.pythonhosted.org/packages/81/5c/4d7ed8b23b233b0fffbc9dfec53c232be2e695468523242ea9fd30f97ad2/coverage-7.13.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:79be69cf7f3bf9b0deeeb062eab7ac7f36cd4cc4c4dd694bd28921ba4d8596cc", size = 220514, upload-time = "2026-02-09T12:58:35.704Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/6f/3284d4203fd2f28edd73034968398cd2d4cb04ab192abc8cff007ea35679/coverage-7.13.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:caa421e2684e382c5d8973ac55e4f36bed6821a9bad5c953494de960c74595c9", size = 261877, upload-time = "2026-02-09T12:58:37.864Z" },
-    { url = "https://files.pythonhosted.org/packages/09/aa/b672a647bbe1556a85337dc95bfd40d146e9965ead9cc2fe81bde1e5cbce/coverage-7.13.4-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14375934243ee05f56c45393fe2ce81fe5cc503c07cee2bdf1725fb8bef3ffaf", size = 264004, upload-time = "2026-02-09T12:58:39.492Z" },
-    { url = "https://files.pythonhosted.org/packages/79/a1/aa384dbe9181f98bba87dd23dda436f0c6cf2e148aecbb4e50fc51c1a656/coverage-7.13.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25a41c3104d08edb094d9db0d905ca54d0cd41c928bb6be3c4c799a54753af55", size = 266408, upload-time = "2026-02-09T12:58:41.852Z" },
-    { url = "https://files.pythonhosted.org/packages/53/5e/5150bf17b4019bc600799f376bb9606941e55bd5a775dc1e096b6ffea952/coverage-7.13.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6f01afcff62bf9a08fb32b2c1d6e924236c0383c02c790732b6537269e466a72", size = 267544, upload-time = "2026-02-09T12:58:44.093Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/ed/f1de5c675987a4a7a672250d2c5c9d73d289dbf13410f00ed7181d8017dd/coverage-7.13.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eb9078108fbf0bcdde37c3f4779303673c2fa1fe8f7956e68d447d0dd426d38a", size = 260980, upload-time = "2026-02-09T12:58:45.721Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/e3/fe758d01850aa172419a6743fe76ba8b92c29d181d4f676ffe2dae2ba631/coverage-7.13.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0e086334e8537ddd17e5f16a344777c1ab8194986ec533711cbe6c41cde841b6", size = 263871, upload-time = "2026-02-09T12:58:47.334Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/76/b829869d464115e22499541def9796b25312b8cf235d3bb00b39f1675395/coverage-7.13.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:725d985c5ab621268b2edb8e50dfe57633dc69bda071abc470fed55a14935fd3", size = 261472, upload-time = "2026-02-09T12:58:48.995Z" },
-    { url = "https://files.pythonhosted.org/packages/14/9e/caedb1679e73e2f6ad240173f55218488bfe043e38da577c4ec977489915/coverage-7.13.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3c06f0f1337c667b971ca2f975523347e63ec5e500b9aa5882d91931cd3ef750", size = 265210, upload-time = "2026-02-09T12:58:51.178Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/10/0dd02cb009b16ede425b49ec344aba13a6ae1dc39600840ea6abcb085ac4/coverage-7.13.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:590c0ed4bf8e85f745e6b805b2e1c457b2e33d5255dd9729743165253bc9ad39", size = 260319, upload-time = "2026-02-09T12:58:53.081Z" },
-    { url = "https://files.pythonhosted.org/packages/92/8e/234d2c927af27c6d7a5ffad5bd2cf31634c46a477b4c7adfbfa66baf7ebb/coverage-7.13.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eb30bf180de3f632cd043322dad5751390e5385108b2807368997d1a92a509d0", size = 262638, upload-time = "2026-02-09T12:58:55.258Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/64/e5547c8ff6964e5965c35a480855911b61509cce544f4d442caa759a0702/coverage-7.13.4-cp314-cp314t-win32.whl", hash = "sha256:c4240e7eded42d131a2d2c4dec70374b781b043ddc79a9de4d55ca71f8e98aea", size = 223040, upload-time = "2026-02-09T12:58:56.936Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/96/38086d58a181aac86d503dfa9c47eb20715a79c3e3acbdf786e92e5c09a8/coverage-7.13.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4c7d3cc01e7350f2f0f6f7036caaf5673fb56b6998889ccfe9e1c1fe75a9c932", size = 224148, upload-time = "2026-02-09T12:58:58.645Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/72/8d10abd3740a0beb98c305e0c3faf454366221c0f37a8bcf8f60020bb65a/coverage-7.13.4-cp314-cp314t-win_arm64.whl", hash = "sha256:23e3f687cf945070d1c90f85db66d11e3025665d8dafa831301a0e0038f3db9b", size = 222172, upload-time = "2026-02-09T12:59:00.396Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/4a/331fe2caf6799d591109bb9c08083080f6de90a823695d412a935622abb2/coverage-7.13.4-py3-none-any.whl", hash = "sha256:1af1641e57cf7ba1bd67d677c9abdbcd6cc2ab7da3bca7fa1e2b7e50e65f2ad0", size = 211242, upload-time = "2026-02-09T12:59:02.032Z" },
+version = "7.13.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
+    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
+    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
+    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
+    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
+    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
+    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
+    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
+    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
+    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
+    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
+    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
+    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
+    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
+    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
+    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
 ]
 
 [[package]]
 name = "detectmatelibrary"
-version = "0.2.0"
 source = { editable = "." }
 dependencies = [
-    { name = "kafka-python" },
+    { name = "detectmateperformance" },
+    { name = "fsspec" },
+    { name = "msgpack" },
     { name = "numpy" },
     { name = "openai" },
     { name = "pandas" },
     { name = "polars" },
-    { name = "protobuf" },
+    { name = "protobuf", version = "6.33.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.14'" },
+    { name = "protobuf", version = "7.34.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.14'" },
+    { name = "pyarrow" },
     { name = "pydantic" },
     { name = "pyyaml" },
     { name = "regex" },
@@ -239,6 +245,11 @@ dependencies = [
     { name = "tiktoken" },
 ]
 
+[package.optional-dependencies]
+polars-rtcompat = [
+    { name = "polars", extra = ["rtcompat"] },
+]
+
 [package.dev-dependencies]
 dev = [
     { name = "mike" },
@@ -249,12 +260,16 @@ dev = [
 
 [package.metadata]
 requires-dist = [
-    { name = "kafka-python", specifier = ">=2.3.0" },
+    { name = "detectmateperformance", git = "https://github.com/ait-detectmate/DetectMatePerformance?rev=main" },
+    { name = "fsspec", specifier = ">=2024.1.0" },
+    { name = "msgpack", specifier = ">=1.0.0" },
     { name = "numpy", specifier = ">=2.3.2" },
     { name = "openai", specifier = ">=2.26.0" },
     { name = "pandas", specifier = ">=2.3.2" },
     { name = "polars", specifier = ">=1.40.0" },
+    { name = "polars", extras = ["rtcompat"], marker = "extra == 'polars-rtcompat'", specifier = ">=1.38.1" },
     { name = "protobuf", specifier = ">=6.32.1" },
+    { name = "pyarrow", specifier = ">=24.0.0" },
     { name = "pydantic", specifier = ">=2.13.3" },
     { name = "pyyaml", specifier = ">=6.0.3" },
     { name = "regex", specifier = ">=2025.11.3" },
@@ -263,6 +278,7 @@ requires-dist = [
     { name = "tenacity", specifier = ">=9.1.4" },
     { name = "tiktoken", specifier = ">=0.12.0" },
 ]
+provides-extras = ["polars-rtcompat"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -272,6 +288,19 @@ dev = [
     { name = "pytest-cov", specifier = ">=6.2.1" },
 ]
 
+[[package]]
+name = "detectmateperformance"
+version = "0.1.0"
+source = { git = "https://github.com/ait-detectmate/DetectMatePerformance?rev=main#4d0d31b898712849fb2bca19089d64b9567e5aac" }
+dependencies = [
+    { name = "levenshtein" },
+    { name = "numpy" },
+    { name = "polars" },
+    { name = "pybind11" },
+    { name = "setuptools" },
+    { name = "tqdm" },
+]
+
 [[package]]
 name = "distro"
 version = "1.9.0"
@@ -281,6 +310,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
 ]
 
+[[package]]
+name = "fsspec"
+version = "2026.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d5/8d/1c51c094345df128ca4a990d633fe1a0ff28726c9e6b3c41ba65087bba1d/fsspec-2026.4.0.tar.gz", hash = "sha256:301d8ac70ae90ef3ad05dcf94d6c3754a097f9b5fe4667d2787aa359ec7df7e4", size = 312760, upload-time = "2026-04-29T20:42:38.635Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d5/0c/043d5e551459da400957a1395e0febbf771446ff34291afcbe3d8be2a279/fsspec-2026.4.0-py3-none-any.whl", hash = "sha256:11ef7bb35dab8a394fde6e608221d5cf3e8499401c249bebaeaad760a1a8dec2", size = 203402, upload-time = "2026-04-29T20:42:36.842Z" },
+]
+
 [[package]]
 name = "ghp-import"
 version = "2.1.0"
@@ -332,6 +370,7 @@ wheels = [
 
 [[package]]
 name = "idna"
+
 version = "3.15"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/82/77/7b3966d0b9d1d31a36ddf1746926a11dface89a83409bf1483f0237aa758/idna-3.15.tar.gz", hash = "sha256:ca962446ea538f7092a95e057da437618e886f4d349216d2b1e294abfdb65fdc", size = 199245, upload-time = "2026-05-12T22:45:57.011Z" }
@@ -362,70 +401,74 @@ wheels = [
 
 [[package]]
 name = "jiter"
-version = "0.13.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", hash = "sha256:f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4", size = 164847, upload-time = "2026-02-02T12:37:56.441Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/30/7687e4f87086829955013ca12a9233523349767f69653ebc27036313def9/jiter-0.13.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:0a2bd69fc1d902e89925fc34d1da51b2128019423d7b339a45d9e99c894e0663", size = 307958, upload-time = "2026-02-02T12:35:57.165Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/27/e57f9a783246ed95481e6749cc5002a8a767a73177a83c63ea71f0528b90/jiter-0.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f917a04240ef31898182f76a332f508f2cc4b57d2b4d7ad2dbfebbfe167eb505", size = 318597, upload-time = "2026-02-02T12:35:58.591Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/52/e5719a60ac5d4d7c5995461a94ad5ef962a37c8bf5b088390e6fad59b2ff/jiter-0.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1e2b199f446d3e82246b4fd9236d7cb502dc2222b18698ba0d986d2fecc6152", size = 348821, upload-time = "2026-02-02T12:36:00.093Z" },
-    { url = "https://files.pythonhosted.org/packages/61/db/c1efc32b8ba4c740ab3fc2d037d8753f67685f475e26b9d6536a4322bcdd/jiter-0.13.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:04670992b576fa65bd056dbac0c39fe8bd67681c380cb2b48efa885711d9d726", size = 364163, upload-time = "2026-02-02T12:36:01.937Z" },
-    { url = "https://files.pythonhosted.org/packages/55/8a/fb75556236047c8806995671a18e4a0ad646ed255276f51a20f32dceaeec/jiter-0.13.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5a1aff1fbdb803a376d4d22a8f63f8e7ccbce0b4890c26cc7af9e501ab339ef0", size = 483709, upload-time = "2026-02-02T12:36:03.41Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/16/43512e6ee863875693a8e6f6d532e19d650779d6ba9a81593ae40a9088ff/jiter-0.13.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b3fb8c2053acaef8580809ac1d1f7481a0a0bdc012fd7f5d8b18fb696a5a089", size = 370480, upload-time = "2026-02-02T12:36:04.791Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/4c/09b93e30e984a187bc8aaa3510e1ec8dcbdcd71ca05d2f56aac0492453aa/jiter-0.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bdaba7d87e66f26a2c45d8cbadcbfc4bf7884182317907baf39cfe9775bb4d93", size = 360735, upload-time = "2026-02-02T12:36:06.994Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/1b/46c5e349019874ec5dfa508c14c37e29864ea108d376ae26d90bee238cd7/jiter-0.13.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7b88d649135aca526da172e48083da915ec086b54e8e73a425ba50999468cc08", size = 391814, upload-time = "2026-02-02T12:36:08.368Z" },
-    { url = "https://files.pythonhosted.org/packages/15/9e/26184760e85baee7162ad37b7912797d2077718476bf91517641c92b3639/jiter-0.13.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e404ea551d35438013c64b4f357b0474c7abf9f781c06d44fcaf7a14c69ff9e2", size = 513990, upload-time = "2026-02-02T12:36:09.993Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/34/2c9355247d6debad57a0a15e76ab1566ab799388042743656e566b3b7de1/jiter-0.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1f4748aad1b4a93c8bdd70f604d0f748cdc0e8744c5547798acfa52f10e79228", size = 548021, upload-time = "2026-02-02T12:36:11.376Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/4a/9f2c23255d04a834398b9c2e0e665382116911dc4d06b795710503cdad25/jiter-0.13.0-cp312-cp312-win32.whl", hash = "sha256:0bf670e3b1445fc4d31612199f1744f67f889ee1bbae703c4b54dc097e5dd394", size = 203024, upload-time = "2026-02-02T12:36:12.682Z" },
-    { url = "https://files.pythonhosted.org/packages/09/ee/f0ae675a957ae5a8f160be3e87acea6b11dc7b89f6b7ab057e77b2d2b13a/jiter-0.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:15db60e121e11fe186c0b15236bd5d18381b9ddacdcf4e659feb96fc6c969c92", size = 205424, upload-time = "2026-02-02T12:36:13.93Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/02/ae611edf913d3cbf02c97cdb90374af2082c48d7190d74c1111dde08bcdd/jiter-0.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:41f92313d17989102f3cb5dd533a02787cdb99454d494344b0361355da52fcb9", size = 186818, upload-time = "2026-02-02T12:36:15.308Z" },
-    { url = "https://files.pythonhosted.org/packages/91/9c/7ee5a6ff4b9991e1a45263bfc46731634c4a2bde27dfda6c8251df2d958c/jiter-0.13.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1f8a55b848cbabf97d861495cd65f1e5c590246fabca8b48e1747c4dfc8f85bf", size = 306897, upload-time = "2026-02-02T12:36:16.748Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/02/be5b870d1d2be5dd6a91bdfb90f248fbb7dcbd21338f092c6b89817c3dbf/jiter-0.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f556aa591c00f2c45eb1b89f68f52441a016034d18b65da60e2d2875bbbf344a", size = 317507, upload-time = "2026-02-02T12:36:18.351Z" },
-    { url = "https://files.pythonhosted.org/packages/da/92/b25d2ec333615f5f284f3a4024f7ce68cfa0604c322c6808b2344c7f5d2b/jiter-0.13.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7e1d61da332ec412350463891923f960c3073cf1aae93b538f0bb4c8cd46efb", size = 350560, upload-time = "2026-02-02T12:36:19.746Z" },
-    { url = "https://files.pythonhosted.org/packages/be/ec/74dcb99fef0aca9fbe56b303bf79f6bd839010cb18ad41000bf6cc71eec0/jiter-0.13.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3097d665a27bc96fd9bbf7f86178037db139f319f785e4757ce7ccbf390db6c2", size = 363232, upload-time = "2026-02-02T12:36:21.243Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/37/f17375e0bb2f6a812d4dd92d7616e41917f740f3e71343627da9db2824ce/jiter-0.13.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d01ecc3a8cbdb6f25a37bd500510550b64ddf9f7d64a107d92f3ccb25035d0f", size = 483727, upload-time = "2026-02-02T12:36:22.688Z" },
-    { url = "https://files.pythonhosted.org/packages/77/d2/a71160a5ae1a1e66c1395b37ef77da67513b0adba73b993a27fbe47eb048/jiter-0.13.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed9bbc30f5d60a3bdf63ae76beb3f9db280d7f195dfcfa61af792d6ce912d159", size = 370799, upload-time = "2026-02-02T12:36:24.106Z" },
-    { url = "https://files.pythonhosted.org/packages/01/99/ed5e478ff0eb4e8aa5fd998f9d69603c9fd3f32de3bd16c2b1194f68361c/jiter-0.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98fbafb6e88256f4454de33c1f40203d09fc33ed19162a68b3b257b29ca7f663", size = 359120, upload-time = "2026-02-02T12:36:25.519Z" },
-    { url = "https://files.pythonhosted.org/packages/16/be/7ffd08203277a813f732ba897352797fa9493faf8dc7995b31f3d9cb9488/jiter-0.13.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5467696f6b827f1116556cb0db620440380434591e93ecee7fd14d1a491b6daa", size = 390664, upload-time = "2026-02-02T12:36:26.866Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/84/e0787856196d6d346264d6dcccb01f741e5f0bd014c1d9a2ebe149caf4f3/jiter-0.13.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:2d08c9475d48b92892583df9da592a0e2ac49bcd41fae1fec4f39ba6cf107820", size = 513543, upload-time = "2026-02-02T12:36:28.217Z" },
-    { url = "https://files.pythonhosted.org/packages/65/50/ecbd258181c4313cf79bca6c88fb63207d04d5bf5e4f65174114d072aa55/jiter-0.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:aed40e099404721d7fcaf5b89bd3b4568a4666358bcac7b6b15c09fb6252ab68", size = 547262, upload-time = "2026-02-02T12:36:29.678Z" },
-    { url = "https://files.pythonhosted.org/packages/27/da/68f38d12e7111d2016cd198161b36e1f042bd115c169255bcb7ec823a3bf/jiter-0.13.0-cp313-cp313-win32.whl", hash = "sha256:36ebfbcffafb146d0e6ffb3e74d51e03d9c35ce7c625c8066cdbfc7b953bdc72", size = 200630, upload-time = "2026-02-02T12:36:31.808Z" },
-    { url = "https://files.pythonhosted.org/packages/25/65/3bd1a972c9a08ecd22eb3b08a95d1941ebe6938aea620c246cf426ae09c2/jiter-0.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:8d76029f077379374cf0dbc78dbe45b38dec4a2eb78b08b5194ce836b2517afc", size = 202602, upload-time = "2026-02-02T12:36:33.679Z" },
-    { url = "https://files.pythonhosted.org/packages/15/fe/13bd3678a311aa67686bb303654792c48206a112068f8b0b21426eb6851e/jiter-0.13.0-cp313-cp313-win_arm64.whl", hash = "sha256:bb7613e1a427cfcb6ea4544f9ac566b93d5bf67e0d48c787eca673ff9c9dff2b", size = 185939, upload-time = "2026-02-02T12:36:35.065Z" },
-    { url = "https://files.pythonhosted.org/packages/49/19/a929ec002ad3228bc97ca01dbb14f7632fffdc84a95ec92ceaf4145688ae/jiter-0.13.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fa476ab5dd49f3bf3a168e05f89358c75a17608dbabb080ef65f96b27c19ab10", size = 316616, upload-time = "2026-02-02T12:36:36.579Z" },
-    { url = "https://files.pythonhosted.org/packages/52/56/d19a9a194afa37c1728831e5fb81b7722c3de18a3109e8f282bfc23e587a/jiter-0.13.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade8cb6ff5632a62b7dbd4757d8c5573f7a2e9ae285d6b5b841707d8363205ef", size = 346850, upload-time = "2026-02-02T12:36:38.058Z" },
-    { url = "https://files.pythonhosted.org/packages/36/4a/94e831c6bf287754a8a019cb966ed39ff8be6ab78cadecf08df3bb02d505/jiter-0.13.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9950290340acc1adaded363edd94baebcee7dabdfa8bee4790794cd5cfad2af6", size = 358551, upload-time = "2026-02-02T12:36:39.417Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/ec/a4c72c822695fa80e55d2b4142b73f0012035d9fcf90eccc56bc060db37c/jiter-0.13.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2b4972c6df33731aac0742b64fd0d18e0a69bc7d6e03108ce7d40c85fd9e3e6d", size = 201950, upload-time = "2026-02-02T12:36:40.791Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/00/393553ec27b824fbc29047e9c7cd4a3951d7fbe4a76743f17e44034fa4e4/jiter-0.13.0-cp313-cp313t-win_arm64.whl", hash = "sha256:701a1e77d1e593c1b435315ff625fd071f0998c5f02792038a5ca98899261b7d", size = 185852, upload-time = "2026-02-02T12:36:42.077Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/f5/f1997e987211f6f9bd71b8083047b316208b4aca0b529bb5f8c96c89ef3e/jiter-0.13.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:cc5223ab19fe25e2f0bf2643204ad7318896fe3729bf12fde41b77bfc4fafff0", size = 308804, upload-time = "2026-02-02T12:36:43.496Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/8f/5482a7677731fd44881f0204981ce2d7175db271f82cba2085dd2212e095/jiter-0.13.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9776ebe51713acf438fd9b4405fcd86893ae5d03487546dae7f34993217f8a91", size = 318787, upload-time = "2026-02-02T12:36:45.071Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/b9/7257ac59778f1cd025b26a23c5520a36a424f7f1b068f2442a5b499b7464/jiter-0.13.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:879e768938e7b49b5e90b7e3fecc0dbec01b8cb89595861fb39a8967c5220d09", size = 353880, upload-time = "2026-02-02T12:36:47.365Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/87/719eec4a3f0841dad99e3d3604ee4cba36af4419a76f3cb0b8e2e691ad67/jiter-0.13.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:682161a67adea11e3aae9038c06c8b4a9a71023228767477d683f69903ebc607", size = 366702, upload-time = "2026-02-02T12:36:48.871Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/65/415f0a75cf6921e43365a1bc227c565cb949caca8b7532776e430cbaa530/jiter-0.13.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a13b68cd1cd8cc9de8f244ebae18ccb3e4067ad205220ef324c39181e23bbf66", size = 486319, upload-time = "2026-02-02T12:36:53.006Z" },
-    { url = "https://files.pythonhosted.org/packages/54/a2/9e12b48e82c6bbc6081fd81abf915e1443add1b13d8fc586e1d90bb02bb8/jiter-0.13.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:87ce0f14c6c08892b610686ae8be350bf368467b6acd5085a5b65441e2bf36d2", size = 372289, upload-time = "2026-02-02T12:36:54.593Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/c1/e4693f107a1789a239c759a432e9afc592366f04e901470c2af89cfd28e1/jiter-0.13.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c365005b05505a90d1c47856420980d0237adf82f70c4aff7aebd3c1cc143ad", size = 360165, upload-time = "2026-02-02T12:36:56.112Z" },
-    { url = "https://files.pythonhosted.org/packages/17/08/91b9ea976c1c758240614bd88442681a87672eebc3d9a6dde476874e706b/jiter-0.13.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1317fdffd16f5873e46ce27d0e0f7f4f90f0cdf1d86bf6abeaea9f63ca2c401d", size = 389634, upload-time = "2026-02-02T12:36:57.495Z" },
-    { url = "https://files.pythonhosted.org/packages/18/23/58325ef99390d6d40427ed6005bf1ad54f2577866594bcf13ce55675f87d/jiter-0.13.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:c05b450d37ba0c9e21c77fef1f205f56bcee2330bddca68d344baebfc55ae0df", size = 514933, upload-time = "2026-02-02T12:36:58.909Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/25/69f1120c7c395fd276c3996bb8adefa9c6b84c12bb7111e5c6ccdcd8526d/jiter-0.13.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:775e10de3849d0631a97c603f996f518159272db00fdda0a780f81752255ee9d", size = 548842, upload-time = "2026-02-02T12:37:00.433Z" },
-    { url = "https://files.pythonhosted.org/packages/18/05/981c9669d86850c5fbb0d9e62bba144787f9fba84546ba43d624ee27ef29/jiter-0.13.0-cp314-cp314-win32.whl", hash = "sha256:632bf7c1d28421c00dd8bbb8a3bac5663e1f57d5cd5ed962bce3c73bf62608e6", size = 202108, upload-time = "2026-02-02T12:37:01.718Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/96/cdcf54dd0b0341db7d25413229888a346c7130bd20820530905fdb65727b/jiter-0.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:f22ef501c3f87ede88f23f9b11e608581c14f04db59b6a801f354397ae13739f", size = 204027, upload-time = "2026-02-02T12:37:03.075Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/f9/724bcaaab7a3cd727031fe4f6995cb86c4bd344909177c186699c8dec51a/jiter-0.13.0-cp314-cp314-win_arm64.whl", hash = "sha256:07b75fe09a4ee8e0c606200622e571e44943f47254f95e2436c8bdcaceb36d7d", size = 187199, upload-time = "2026-02-02T12:37:04.414Z" },
-    { url = "https://files.pythonhosted.org/packages/62/92/1661d8b9fd6a3d7a2d89831db26fe3c1509a287d83ad7838831c7b7a5c7e/jiter-0.13.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:964538479359059a35fb400e769295d4b315ae61e4105396d355a12f7fef09f0", size = 318423, upload-time = "2026-02-02T12:37:05.806Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/3b/f77d342a54d4ebcd128e520fc58ec2f5b30a423b0fd26acdfc0c6fef8e26/jiter-0.13.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e104da1db1c0991b3eaed391ccd650ae8d947eab1480c733e5a3fb28d4313e40", size = 351438, upload-time = "2026-02-02T12:37:07.189Z" },
-    { url = "https://files.pythonhosted.org/packages/76/b3/ba9a69f0e4209bd3331470c723c2f5509e6f0482e416b612431a5061ed71/jiter-0.13.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0e3a5f0cde8ff433b8e88e41aa40131455420fb3649a3c7abdda6145f8cb7202", size = 364774, upload-time = "2026-02-02T12:37:08.579Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/16/6cdb31fa342932602458dbb631bfbd47f601e03d2e4950740e0b2100b570/jiter-0.13.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:57aab48f40be1db920a582b30b116fe2435d184f77f0e4226f546794cedd9cf0", size = 487238, upload-time = "2026-02-02T12:37:10.066Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/b1/956cc7abaca8d95c13aa8d6c9b3f3797241c246cd6e792934cc4c8b250d2/jiter-0.13.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7772115877c53f62beeb8fd853cab692dbc04374ef623b30f997959a4c0e7e95", size = 372892, upload-time = "2026-02-02T12:37:11.656Z" },
-    { url = "https://files.pythonhosted.org/packages/26/c4/97ecde8b1e74f67b8598c57c6fccf6df86ea7861ed29da84629cdbba76c4/jiter-0.13.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1211427574b17b633cfceba5040de8081e5abf114f7a7602f73d2e16f9fdaa59", size = 360309, upload-time = "2026-02-02T12:37:13.244Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/d7/eabe3cf46715854ccc80be2cd78dd4c36aedeb30751dbf85a1d08c14373c/jiter-0.13.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7beae3a3d3b5212d3a55d2961db3c292e02e302feb43fce6a3f7a31b90ea6dfe", size = 389607, upload-time = "2026-02-02T12:37:14.881Z" },
-    { url = "https://files.pythonhosted.org/packages/df/2d/03963fc0804e6109b82decfb9974eb92df3797fe7222428cae12f8ccaa0c/jiter-0.13.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:e5562a0f0e90a6223b704163ea28e831bd3a9faa3512a711f031611e6b06c939", size = 514986, upload-time = "2026-02-02T12:37:16.326Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/6c/8c83b45eb3eb1c1e18d841fe30b4b5bc5619d781267ca9bc03e005d8fd0a/jiter-0.13.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:6c26a424569a59140fb51160a56df13f438a2b0967365e987889186d5fc2f6f9", size = 548756, upload-time = "2026-02-02T12:37:17.736Z" },
-    { url = "https://files.pythonhosted.org/packages/47/66/eea81dfff765ed66c68fd2ed8c96245109e13c896c2a5015c7839c92367e/jiter-0.13.0-cp314-cp314t-win32.whl", hash = "sha256:24dc96eca9f84da4131cdf87a95e6ce36765c3b156fc9ae33280873b1c32d5f6", size = 201196, upload-time = "2026-02-02T12:37:19.101Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/32/4ac9c7a76402f8f00d00842a7f6b83b284d0cf7c1e9d4227bc95aa6d17fa/jiter-0.13.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0a8d76c7524087272c8ae913f5d9d608bd839154b62c4322ef65723d2e5bb0b8", size = 204215, upload-time = "2026-02-02T12:37:20.495Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/8e/7def204fea9f9be8b3c21a6f2dd6c020cf56c7d5ff753e0e23ed7f9ea57e/jiter-0.13.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2c26cf47e2cad140fa23b6d58d435a7c0161f5c514284802f25e87fddfe11024", size = 187152, upload-time = "2026-02-02T12:37:22.124Z" },
-    { url = "https://files.pythonhosted.org/packages/80/60/e50fa45dd7e2eae049f0ce964663849e897300433921198aef94b6ffa23a/jiter-0.13.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:3d744a6061afba08dd7ae375dcde870cffb14429b7477e10f67e9e6d68772a0a", size = 305169, upload-time = "2026-02-02T12:37:50.376Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/73/a009f41c5eed71c49bec53036c4b33555afcdee70682a18c6f66e396c039/jiter-0.13.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:ff732bd0a0e778f43d5009840f20b935e79087b4dc65bd36f1cd0f9b04b8ff7f", size = 303808, upload-time = "2026-02-02T12:37:52.092Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/10/528b439290763bff3d939268085d03382471b442f212dca4ff5f12802d43/jiter-0.13.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab44b178f7981fcaea7e0a5df20e773c663d06ffda0198f1a524e91b2fde7e59", size = 337384, upload-time = "2026-02-02T12:37:53.582Z" },
-    { url = "https://files.pythonhosted.org/packages/67/8a/a342b2f0251f3dac4ca17618265d93bf244a2a4d089126e81e4c1056ac50/jiter-0.13.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7bb00b6d26db67a05fe3e12c76edc75f32077fb51deed13822dc648fa373bc19", size = 343768, upload-time = "2026-02-02T12:37:55.055Z" },
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6e/c1/0cddc6eb17d4c53a99840953f95dd3accdc5cfc7a337b0e9b26476276be9/jiter-0.14.0.tar.gz", hash = "sha256:e8a39e66dac7153cf3f964a12aad515afa8d74938ec5cc0018adcdae5367c79e", size = 165725, upload-time = "2026-04-10T14:28:42.01Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/68/7390a418f10897da93b158f2d5a8bd0bcd73a0f9ec3bb36917085bb759ef/jiter-0.14.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:2fb2ce3a7bc331256dfb14cefc34832366bb28a9aca81deaf43bbf2a5659e607", size = 316295, upload-time = "2026-04-10T14:26:24.887Z" },
+    { url = "https://files.pythonhosted.org/packages/60/a0/5854ac00ff63551c52c6c89534ec6aba4b93474e7924d64e860b1c94165b/jiter-0.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5252a7ca23785cef5d02d4ece6077a1b556a410c591b379f82091c3001e14844", size = 315898, upload-time = "2026-04-10T14:26:26.601Z" },
+    { url = "https://files.pythonhosted.org/packages/41/a1/4f44832650a16b18e8391f1bf1d6ca4909bc738351826bcc198bba4357f4/jiter-0.14.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c409578cbd77c338975670ada777add4efd53379667edf0aceea730cabede6fb", size = 343730, upload-time = "2026-04-10T14:26:28.326Z" },
+    { url = "https://files.pythonhosted.org/packages/48/64/a329e9d469f86307203594b1707e11ae51c3348d03bfd514a5f997870012/jiter-0.14.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7ede4331a1899d604463369c730dbb961ffdc5312bc7f16c41c2896415b1304a", size = 370102, upload-time = "2026-04-10T14:26:30.089Z" },
+    { url = "https://files.pythonhosted.org/packages/94/c1/5e3dfc59635aa4d4c7bd20a820ac1d09b8ed851568356802cf1c08edb3cf/jiter-0.14.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:92cd8b6025981a041f5310430310b55b25ca593972c16407af8837d3d7d2ca01", size = 461335, upload-time = "2026-04-10T14:26:31.911Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/1b/dd157009dbc058f7b00108f545ccb72a2d56461395c4fc7b9cfdccb00af4/jiter-0.14.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:351bf6eda4e3a7ceb876377840c702e9a3e4ecc4624dbfb2d6463c67ae52637d", size = 378536, upload-time = "2026-04-10T14:26:33.595Z" },
+    { url = "https://files.pythonhosted.org/packages/91/78/256013667b7c10b8834f8e6e54cd3e562d4c6e34227a1596addccc05e38c/jiter-0.14.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1dcfbeb93d9ecd9ca128bbf8910120367777973fa193fb9a39c31237d8df165", size = 353859, upload-time = "2026-04-10T14:26:35.098Z" },
+    { url = "https://files.pythonhosted.org/packages/de/d9/137d65ade9093a409fe80955ce60b12bb753722c986467aeda47faf450ad/jiter-0.14.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:ae039aaef8de3f8157ecc1fdd4d85043ac4f57538c245a0afaecb8321ec951c3", size = 357626, upload-time = "2026-04-10T14:26:36.685Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/48/76750835b87029342727c1a268bea8878ab988caf81ee4e7b880900eeb5a/jiter-0.14.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7d9d51eb96c82a9652933bd769fe6de66877d6eb2b2440e281f2938c51b5643e", size = 393172, upload-time = "2026-04-10T14:26:38.097Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/60/456c4e81d5c8045279aefe60e9e483be08793828800a4e64add8fdde7f2a/jiter-0.14.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d824ca4148b705970bf4e120924a212fdfca9859a73e42bd7889a63a4ea6bb98", size = 520300, upload-time = "2026-04-10T14:26:39.532Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/9f/2020e0984c235f678dced38fe4eec3058cf528e6af36ebf969b410305941/jiter-0.14.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ff3a6465b3a0f54b1a430f45c3c0ba7d61ceb45cbc3e33f9e1a7f638d690baf3", size = 553059, upload-time = "2026-04-10T14:26:40.991Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/32/e2d298e1a22a4bbe6062136d1c7192db7dba003a6975e51d9a9eecabc4c2/jiter-0.14.0-cp312-cp312-win32.whl", hash = "sha256:5dec7c0a3e98d2a3f8a2e67382d0d7c3ac60c69103a4b271da889b4e8bb1e129", size = 206030, upload-time = "2026-04-10T14:26:42.517Z" },
+    { url = "https://files.pythonhosted.org/packages/36/ac/96369141b3d8a4a8e4590e983085efe1c436f35c0cda940dd76d942e3e40/jiter-0.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:fc7e37b4b8bc7e80a63ad6cfa5fc11fab27dbfea4cc4ae644b1ab3f273dc348f", size = 201603, upload-time = "2026-04-10T14:26:44.328Z" },
+    { url = "https://files.pythonhosted.org/packages/01/c3/75d847f264647017d7e3052bbcc8b1e24b95fa139c320c5f5066fa7a0bdd/jiter-0.14.0-cp312-cp312-win_arm64.whl", hash = "sha256:ee4a72f12847ef29b072aee9ad5474041ab2924106bdca9fcf5d7d965853e057", size = 191525, upload-time = "2026-04-10T14:26:46Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2a/09f70020898507a89279659a1afe3364d57fc1b2c89949081975d135f6f5/jiter-0.14.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:af72f204cf4d44258e5b4c1745130ac45ddab0e71a06333b01de660ab4187a94", size = 315502, upload-time = "2026-04-10T14:26:47.697Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/be/080c96a45cd74f9fce5db4fd68510b88087fb37ffe2541ff73c12db92535/jiter-0.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4b77da71f6e819be5fbcec11a453fde5b1d0267ef6ed487e2a392fd8e14e4e3a", size = 314870, upload-time = "2026-04-10T14:26:49.149Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/5e/2d0fee155826a968a832cc32438de5e2a193292c8721ca70d0b53e58245b/jiter-0.14.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f4ea612fe8b84b8b04e51d0e78029ecf3466348e25973f953de6e6a59aa4c1", size = 343406, upload-time = "2026-04-10T14:26:50.762Z" },
+    { url = "https://files.pythonhosted.org/packages/70/af/bf9ee0d3a4f8dc0d679fc1337f874fe60cdbf841ebbb304b374e1c9aaceb/jiter-0.14.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:62fe2451f8fcc0240261e6a4df18ecbcd58327857e61e625b2393ea3b468aac9", size = 369415, upload-time = "2026-04-10T14:26:52.188Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/83/8e8561eadba31f4d3948a5b712fb0447ec71c3560b57a855449e7b8ddc98/jiter-0.14.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6112f26f5afc75bcb475787d29da3aa92f9d09c7858f632f4be6ffe607be82e9", size = 461456, upload-time = "2026-04-10T14:26:53.611Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/c9/c5299e826a5fe6108d172b344033f61c69b1bb979dd8d9ddd4278a160971/jiter-0.14.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:215a6cb8fb7dc702aa35d475cc00ddc7f970e5c0b1417fb4b4ac5d82fa2a29db", size = 378488, upload-time = "2026-04-10T14:26:55.211Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/37/c16d9d15c0a471b8644b1abe3c82668092a707d9bedcf076f24ff2e380cd/jiter-0.14.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc4ab96a30fb3cb2c7e0cd33f7616c8860da5f5674438988a54ac717caccdbaa", size = 353242, upload-time = "2026-04-10T14:26:56.705Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ea/8050cb0dc654e728e1bfacbc0c640772f2181af5dedd13ae70145743a439/jiter-0.14.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:3a99c1387b1f2928f799a9de899193484d66206a50e98233b6b088a7f0c1edb2", size = 356823, upload-time = "2026-04-10T14:26:58.281Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/cf71506d270e5f84d97326bf220e47aed9b95e9a4a060758fb07772170ab/jiter-0.14.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ab18d11074485438695f8d34a1b6da61db9754248f96d51341956607a8f39985", size = 392564, upload-time = "2026-04-10T14:27:00.018Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/cc/8c6c74a3efb5bd671bfd14f51e8a73375464ca914b1551bc3b40e26ac2c9/jiter-0.14.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:801028dcfc26ac0895e4964cbc0fd62c73be9fd4a7d7b1aaf6e5790033a719b7", size = 520322, upload-time = "2026-04-10T14:27:01.664Z" },
+    { url = "https://files.pythonhosted.org/packages/41/24/68d7b883ec959884ddf00d019b2e0e82ba81b167e1253684fa90519ce33c/jiter-0.14.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ad425b087aafb4a1c7e1e98a279200743b9aaf30c3e0ba723aec93f061bd9bc8", size = 552619, upload-time = "2026-04-10T14:27:03.316Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/89/b1a0985223bbf3150ff9e8f46f98fc9360c1de94f48abe271bbe1b465682/jiter-0.14.0-cp313-cp313-win32.whl", hash = "sha256:882bcb9b334318e233950b8be366fe5f92c86b66a7e449e76975dfd6d776a01f", size = 205699, upload-time = "2026-04-10T14:27:04.662Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/19/3f339a5a7f14a11730e67f6be34f9d5105751d547b615ef593fa122a5ded/jiter-0.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:9b8c571a5dba09b98bd3462b5a53f27209a5cbbe85670391692ede71974e979f", size = 201323, upload-time = "2026-04-10T14:27:06.139Z" },
+    { url = "https://files.pythonhosted.org/packages/50/56/752dd89c84be0e022a8ea3720bcfa0a8431db79a962578544812ce061739/jiter-0.14.0-cp313-cp313-win_arm64.whl", hash = "sha256:34f19dcc35cb1abe7c369b3756babf8c7f04595c0807a848df8f26ef8298ef92", size = 191099, upload-time = "2026-04-10T14:27:07.564Z" },
+    { url = "https://files.pythonhosted.org/packages/91/28/292916f354f25a1fe8cf2c918d1415c699a4a659ae00be0430e1c5d9ffea/jiter-0.14.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e89bcd7d426a75bb4952c696b267075790d854a07aad4c9894551a82c5b574ab", size = 320880, upload-time = "2026-04-10T14:27:09.326Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/c7/b002a7d8b8957ac3d469bd59c18ef4b1595a5216ae0de639a287b9816023/jiter-0.14.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b25beaa0d4447ea8c7ae0c18c688905d34840d7d0b937f2f7bdd52162c98a40", size = 346563, upload-time = "2026-04-10T14:27:11.287Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/3b/f8d07580d8706021d255a6356b8fab13ee4c869412995550ce6ed4ddf97d/jiter-0.14.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:651a8758dd413c51e3b7f6557cdc6921faf70b14106f45f969f091f5cda990ea", size = 357928, upload-time = "2026-04-10T14:27:12.729Z" },
+    { url = "https://files.pythonhosted.org/packages/47/5b/ac1a974da29e35507230383110ffec59998b290a8732585d04e19a9eb5ba/jiter-0.14.0-cp313-cp313t-win_amd64.whl", hash = "sha256:e1a7eead856a5038a8d291f1447176ab0b525c77a279a058121b5fccee257f6f", size = 203519, upload-time = "2026-04-10T14:27:14.125Z" },
+    { url = "https://files.pythonhosted.org/packages/96/6d/9fc8433d667d2454271378a79747d8c76c10b51b482b454e6190e511f244/jiter-0.14.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e692633a12cda97e352fdcd1c4acc971b1c28707e1e33aeef782b0cbf051975", size = 190113, upload-time = "2026-04-10T14:27:16.638Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/1e/354ed92461b165bd581f9ef5150971a572c873ec3b68a916d5aa91da3cc2/jiter-0.14.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:6f396837fc7577871ca8c12edaf239ed9ccef3bbe39904ae9b8b63ce0a48b140", size = 315277, upload-time = "2026-04-10T14:27:18.109Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/95/8c7c7028aa8636ac21b7a55faef3e34215e6ed0cbf5ae58258427f621aa3/jiter-0.14.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a4d50ea3d8ba4176f79754333bd35f1bbcd28e91adc13eb9b7ca91bc52a6cef9", size = 315923, upload-time = "2026-04-10T14:27:19.603Z" },
+    { url = "https://files.pythonhosted.org/packages/47/40/e2a852a44c4a089f2681a16611b7ce113224a80fd8504c46d78491b47220/jiter-0.14.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce17f8a050447d1b4153bda4fb7d26e6a9e74eb4f4a41913f30934c5075bf615", size = 344943, upload-time = "2026-04-10T14:27:21.262Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/1f/670f92adee1e9895eac41e8a4d623b6da68c4d46249d8b556b60b63f949e/jiter-0.14.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f4f1c4b125e1652aefbc2e2c1617b60a160ab789d180e3d423c41439e5f32850", size = 369725, upload-time = "2026-04-10T14:27:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/01/2f/541c9ba567d05de1c4874a0f8f8c5e3fd78e2b874266623da9a775cf46e0/jiter-0.14.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be808176a6a3a14321d18c603f2d40741858a7c4fc982f83232842689fe86dd9", size = 461210, upload-time = "2026-04-10T14:27:24.315Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/a9/c31cbec09627e0d5de7aeaec7690dba03e090caa808fefd8133137cf45bc/jiter-0.14.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:26679d58ba816f88c3849306dd58cb863a90a1cf352cdd4ef67e30ccf8a77994", size = 380002, upload-time = "2026-04-10T14:27:26.155Z" },
+    { url = "https://files.pythonhosted.org/packages/50/02/3c05c1666c41904a2f607475a73e7a4763d1cbde2d18229c4f85b22dc253/jiter-0.14.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80381f5a19af8fa9aef743f080e34f6b25ebd89656475f8cf0470ec6157052aa", size = 354678, upload-time = "2026-04-10T14:27:27.701Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/97/e15b33545c2b13518f560d695f974b9891b311641bdcf178d63177e8801e/jiter-0.14.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:004df5fdb8ecbd6d99f3227df18ba1a259254c4359736a2e6f036c944e02d7c5", size = 358920, upload-time = "2026-04-10T14:27:29.256Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/d2/8b1461def6b96ba44530df20d07ef7a1c7da22f3f9bf1727e2d611077bf1/jiter-0.14.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cff5708f7ed0fa098f2b53446c6fa74c48469118e5cd7497b4f1cd569ab06928", size = 394512, upload-time = "2026-04-10T14:27:31.344Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/88/837566dd6ed6e452e8d3205355afd484ce44b2533edfa4ed73a298ea893e/jiter-0.14.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:2492e5f06c36a976d25c7cc347a60e26d5470178d44cde1b9b75e60b4e519f28", size = 521120, upload-time = "2026-04-10T14:27:33.299Z" },
+    { url = "https://files.pythonhosted.org/packages/89/6b/b00b45c4d1b4c031777fe161d620b755b5b02cdade1e316dcb46e4471d63/jiter-0.14.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:7609cfbe3a03d37bfdbf5052012d5a879e72b83168a363deae7b3a26564d57de", size = 553668, upload-time = "2026-04-10T14:27:34.868Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/d8/6fe5b42011d19397433d345716eac16728ac241862a2aac9c91923c7509a/jiter-0.14.0-cp314-cp314-win32.whl", hash = "sha256:7282342d32e357543565286b6450378c3cd402eea333fc1ebe146f1fabb306fc", size = 207001, upload-time = "2026-04-10T14:27:36.455Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/43/5c2e08da1efad5e410f0eaaabeadd954812612c33fbbd8fd5328b489139d/jiter-0.14.0-cp314-cp314-win_amd64.whl", hash = "sha256:bd77945f38866a448e73b0b7637366afa814d4617790ecd88a18ca74377e6c02", size = 202187, upload-time = "2026-04-10T14:27:38Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/6e39ac0b4cdfa23e606af5b245df5f9adaa76f35e0c5096790da430ca506/jiter-0.14.0-cp314-cp314-win_arm64.whl", hash = "sha256:f2d4c61da0821ee42e0cdf5489da60a6d074306313a377c2b35af464955a3611", size = 192257, upload-time = "2026-04-10T14:27:39.504Z" },
+    { url = "https://files.pythonhosted.org/packages/05/57/7dbc0ffbbb5176a27e3518716608aa464aee2e2887dc938f0b900a120449/jiter-0.14.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1bf7ff85517dd2f20a5750081d2b75083c1b269cf75afc7511bdf1f9548beb3b", size = 323441, upload-time = "2026-04-10T14:27:41.039Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6e/7b3314398d8983f06b557aa21b670511ec72d3b79a68ee5e4d9bff972286/jiter-0.14.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8ef8791c3e78d6c6b157c6d360fbb5c715bebb8113bc6a9303c5caff012754a", size = 348109, upload-time = "2026-04-10T14:27:42.552Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/4f/8dc674bcd7db6dba566de73c08c763c337058baff1dbeb34567045b27cdc/jiter-0.14.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e74663b8b10da1fe0f4e4703fd7980d24ad17174b6bb35d8498d6e3ebce2ae6a", size = 368328, upload-time = "2026-04-10T14:27:44.574Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/5f/188e09a1f20906f98bbdec44ed820e19f4e8eb8aff88b9d1a5a497587ff3/jiter-0.14.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1aca29ba52913f78362ec9c2da62f22cdc4c3083313403f90c15460979b84d9b", size = 463301, upload-time = "2026-04-10T14:27:46.717Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/f0/19046ef965ed8f349e8554775bb12ff4352f443fbe12b95d31f575891256/jiter-0.14.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8b39b7d87a952b79949af5fef44d2544e58c21a28da7f1bae3ef166455c61746", size = 378891, upload-time = "2026-04-10T14:27:48.32Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/c3/da43bd8431ee175695777ee78cf0e93eacbb47393ff493f18c45231b427d/jiter-0.14.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78d918a68b26e9fab068c2b5453577ef04943ab2807b9a6275df2a812599a310", size = 360749, upload-time = "2026-04-10T14:27:49.88Z" },
+    { url = "https://files.pythonhosted.org/packages/72/26/e054771be889707c6161dbdec9c23d33a9ec70945395d70f07cfea1e9a6f/jiter-0.14.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:b08997c35aee1201c1a5361466a8fb9162d03ae7bf6568df70b6c859f1e654a4", size = 358526, upload-time = "2026-04-10T14:27:51.504Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/0f/7bea65ea2a6d91f2bf989ff11a18136644392bf2b0497a1fa50934c30a9c/jiter-0.14.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:260bf7ca20704d58d41f669e5e9fe7fe2fa72901a6b324e79056f5d52e9c9be2", size = 393926, upload-time = "2026-04-10T14:27:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/b1ff7d70deef61ac0b7c6c2f12d2ace950cdeecb4fdc94500a0926802857/jiter-0.14.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:37826e3df29e60f30a382f9294348d0238ef127f4b5d7f5f8da78b5b9e050560", size = 521052, upload-time = "2026-04-10T14:27:55.058Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/7b/3b0649983cbaf15eda26a414b5b1982e910c67bd6f7b1b490f3cfc76896a/jiter-0.14.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:645be49c46f2900937ba0eaf871ad5183c96858c0af74b6becc7f4e367e36e06", size = 553716, upload-time = "2026-04-10T14:27:57.269Z" },
+    { url = "https://files.pythonhosted.org/packages/97/f8/33d78c83bd93ae0c0af05293a6660f88a1977caef39a6d72a84afab94ce0/jiter-0.14.0-cp314-cp314t-win32.whl", hash = "sha256:2f7877ed45118de283786178eceaf877110abacd04fde31efff3940ae9672674", size = 207957, upload-time = "2026-04-10T14:27:59.285Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/ac/2b760516c03e2227826d1f7025d89bf6bf6357a28fe75c2a2800873c50bf/jiter-0.14.0-cp314-cp314t-win_amd64.whl", hash = "sha256:14c0cb10337c49f5eafe8e7364daca5e29a020ea03580b8f8e6c597fed4e1588", size = 204690, upload-time = "2026-04-10T14:28:00.962Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/2e/a44c20c58aeed0355f2d326969a181696aeb551a25195f47563908a815be/jiter-0.14.0-cp314-cp314t-win_arm64.whl", hash = "sha256:5419d4aa2024961da9fe12a9cfe7484996735dca99e8e090b5c88595ef1951ff", size = 191338, upload-time = "2026-04-10T14:28:02.853Z" },
+    { url = "https://files.pythonhosted.org/packages/21/42/9042c3f3019de4adcb8c16591c325ec7255beea9fcd33a42a43f3b0b1000/jiter-0.14.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:fbd9e482663ca9d005d051330e4d2d8150bb208a209409c10f7e7dfdf7c49da9", size = 308810, upload-time = "2026-04-10T14:28:34.673Z" },
+    { url = "https://files.pythonhosted.org/packages/60/cf/a7e19b308bd86bb04776803b1f01a5f9a287a4c55205f4708827ee487fbf/jiter-0.14.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:33a20d838b91ef376b3a56896d5b04e725c7df5bc4864cc6569cf046a8d73b6d", size = 308443, upload-time = "2026-04-10T14:28:36.658Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/44/e26ede3f0caeff93f222559cb0cc4ca68579f07d009d7b6010c5b586f9b1/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:432c4db5255d86a259efde91e55cb4c8d18c0521d844c9e2e7efcce3899fb016", size = 343039, upload-time = "2026-04-10T14:28:38.356Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e9/1f9ada30cef7b05e74bb06f52127e7a724976c225f46adb65c37b1dadfb6/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67f00d94b281174144d6532a04b66a12cb866cbdc47c3af3bfe2973677f9861a", size = 349613, upload-time = "2026-04-10T14:28:40.066Z" },
 ]
 
 [[package]]
@@ -438,12 +481,69 @@ wheels = [
 ]
 
 [[package]]
-name = "kafka-python"
-version = "2.3.0"
+name = "levenshtein"
+version = "0.27.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/27/5c/d3b6d93ed625d2cb0265e6fe0f507be544f6edde577c1b118f42566389bf/kafka_python-2.3.0.tar.gz", hash = "sha256:de65b596d26b5c894f227c35c7d29a65cea8f8a1c4f0f2b4e3e2ea60d503acc8", size = 358391, upload-time = "2025-11-21T00:47:34.078Z" }
+dependencies = [
+    { name = "rapidfuzz" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/82/56/dcf68853b062e3b94bdc3d011cc4198779abc5b9dc134146a062920ce2e2/levenshtein-0.27.3.tar.gz", hash = "sha256:1ac326b2c84215795163d8a5af471188918b8797b4953ec87aaba22c9c1f9fc0", size = 393269, upload-time = "2025-11-01T12:14:31.04Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4a/db/694fd552295ed091e7418d02b6268ee36092d4c93211136c448fe061fe32/kafka_python-2.3.0-py2.py3-none-any.whl", hash = "sha256:831ba6dff28144d0f1145c874d391f3ebb3c2c3e940cc78d74e83f0183497c98", size = 326260, upload-time = "2025-11-21T00:47:32.561Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/8e/3be9d8e0245704e3af5258fb6cb157c3d59902e1351e95edf6ed8a8c0434/levenshtein-0.27.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2de7f095b0ca8e44de9de986ccba661cd0dec3511c751b499e76b60da46805e9", size = 169622, upload-time = "2025-11-01T12:13:10.026Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/42/a2b2fda5e8caf6ecd5aac142f946a77574a3961e65da62c12fd7e48e5cb1/levenshtein-0.27.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d9b8b29e5d5145a3c958664c85151b1bb4b26e4ca764380b947e6a96a321217c", size = 159183, upload-time = "2025-11-01T12:13:11.197Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/c4/f083fabbd61c449752df1746533538f4a8629e8811931b52f66e6c4290ad/levenshtein-0.27.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fc975465a51b1c5889eadee1a583b81fba46372b4b22df28973e49e8ddb8f54a", size = 133120, upload-time = "2025-11-01T12:13:12.363Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/e5/b6421e04cb0629615b8efd6d4d167dd2b1afb5097b87bb83cd992004dcca/levenshtein-0.27.3-cp312-cp312-manylinux_2_24_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:57573ed885118554770979fdee584071b66103f6d50beddeabb54607a1213d81", size = 114988, upload-time = "2025-11-01T12:13:13.486Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/77/39ee0e8d3028e90178e1031530ccc98563f8f2f0d905ec784669dcf0fa90/levenshtein-0.27.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23aff800a6dd5d91bb3754a6092085aa7ad46b28e497682c155c74f681cfaa2d", size = 153346, upload-time = "2025-11-01T12:13:14.744Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/c0f367bbd260dbd7a4e134fd21f459e0f5eac43deac507952b46a1d8a93a/levenshtein-0.27.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c08a952432b8ad9dccb145f812176db94c52cda732311ddc08d29fd3bf185b0a", size = 1114538, upload-time = "2025-11-01T12:13:15.851Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/ef/ae71433f7b4db0bd2af7974785e36cdec899919203fb82e647c5a6109c07/levenshtein-0.27.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:3bfcb2d78ab9cc06a1e75da8fcfb7a430fe513d66cfe54c07e50f32805e5e6db", size = 1009734, upload-time = "2025-11-01T12:13:17.212Z" },
+    { url = "https://files.pythonhosted.org/packages/27/dc/62c28b812dcb0953fc32ab7adf3d0e814e43c8560bb28d9269a44d874adf/levenshtein-0.27.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba7235f6dcb31a217247468295e2dd4c6c1d3ac81629dc5d355d93e1a5f4c185", size = 1185581, upload-time = "2025-11-01T12:13:18.661Z" },
+    { url = "https://files.pythonhosted.org/packages/56/e8/2e7ab9c565793220edb8e5432f9a846386a157075bdd032a90e9585bce38/levenshtein-0.27.3-cp312-cp312-win32.whl", hash = "sha256:ea80d70f1d18c161a209be556b9094968627cbaae620e102459ef9c320a98cbb", size = 84660, upload-time = "2025-11-01T12:13:19.87Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/a6/907a1fc8587dc91c40156973e09d106ab064c06eb28dc4700ba0fe54d654/levenshtein-0.27.3-cp312-cp312-win_amd64.whl", hash = "sha256:fbaa1219d9b2d955339a37e684256a861e9274a3fe3a6ee1b8ea8724c3231ed9", size = 94909, upload-time = "2025-11-01T12:13:21.323Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/d6/e04f0ddf6a71df3cdd1817b71703490ac874601ed460b2af172d3752c321/levenshtein-0.27.3-cp312-cp312-win_arm64.whl", hash = "sha256:2edbaa84f887ea1d9d8e4440af3fdda44769a7855d581c6248d7ee51518402a8", size = 87358, upload-time = "2025-11-01T12:13:22.393Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/f2/162e9ea7490b36bbf05776c8e3a8114c75aa78546ddda8e8f36731db3da6/levenshtein-0.27.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e55aa9f9453fd89d4a9ff1f3c4a650b307d5f61a7eed0568a52fbd2ff2eba107", size = 169230, upload-time = "2025-11-01T12:13:23.735Z" },
+    { url = "https://files.pythonhosted.org/packages/01/2d/7316ba7f94e3d60e89bd120526bc71e4812866bb7162767a2a10f73f72c5/levenshtein-0.27.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ae4d484453c48939ecd01c5c213530c68dd5cd6e5090f0091ef69799ec7a8a9f", size = 158643, upload-time = "2025-11-01T12:13:25.549Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/87/85433cb1e51c45016f061d96fea3106b6969f700e2cbb56c15de82d0deeb/levenshtein-0.27.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d18659832567ee387b266be390da0de356a3aa6cf0e8bc009b6042d8188e131f", size = 132881, upload-time = "2025-11-01T12:13:26.822Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1c/3ce66c9a7da169a43dd89146d69df9dec935e6f86c70c6404f48d1291d2c/levenshtein-0.27.3-cp313-cp313-manylinux_2_24_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027b3d142cc8ea2ab4e60444d7175f65a94dde22a54382b2f7b47cc24936eb53", size = 114650, upload-time = "2025-11-01T12:13:28.382Z" },
+    { url = "https://files.pythonhosted.org/packages/73/60/7138e98884ca105c76ef192f5b43165d6eac6f32b432853ebe9f09ee50c9/levenshtein-0.27.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ffdca6989368cc64f347f0423c528520f12775b812e170a0eb0c10e4c9b0f3ff", size = 153127, upload-time = "2025-11-01T12:13:29.781Z" },
+    { url = "https://files.pythonhosted.org/packages/df/8f/664ac8b83026d7d1382866b68babae17e92b7b6ff8dc3c6205c0066b8ce1/levenshtein-0.27.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fa00ab389386032b02a1c9050ec3c6aa824d2bbcc692548fdc44a46b71c058c6", size = 1114602, upload-time = "2025-11-01T12:13:31.651Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/c8/8905d96cf2d7ed6af7eb39a8be0925ef335729473c1e9d1f56230ecaffc5/levenshtein-0.27.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:691c9003c6c481b899a5c2f72e8ce05a6d956a9668dc75f2a3ce9f4381a76dc6", size = 1008036, upload-time = "2025-11-01T12:13:33.006Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/57/01c37608121380a6357a297625562adad1c1fc8058d4f62279b735108927/levenshtein-0.27.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:12f7fc8bf0c24492fe97905348e020b55b9fc6dbaab7cd452566d1a466cb5e15", size = 1185338, upload-time = "2025-11-01T12:13:34.452Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/57/bceab41d40b58dee7927a8d1d18ed3bff7c95c5e530fb60093ce741a8c26/levenshtein-0.27.3-cp313-cp313-win32.whl", hash = "sha256:9f4872e4e19ee48eed39f214eea4eca42e5ef303f8a4a488d8312370674dbf3a", size = 84562, upload-time = "2025-11-01T12:13:35.858Z" },
+    { url = "https://files.pythonhosted.org/packages/42/1d/74f1ff589bb687d0cad2bbdceef208dc070f56d1e38a3831da8c00bf13bb/levenshtein-0.27.3-cp313-cp313-win_amd64.whl", hash = "sha256:83aa2422e9a9af2c9d3e56a53e3e8de6bae58d1793628cae48c4282577c5c2c6", size = 94658, upload-time = "2025-11-01T12:13:36.963Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3c/22c86d3c8f254141096fd6089d2e9fdf98b1472c7a5d79d36d3557ec2d83/levenshtein-0.27.3-cp313-cp313-win_arm64.whl", hash = "sha256:d4adaf1edbcf38c3f2e290b52f4dcb5c6deff20308c26ef1127a106bc2d23e9f", size = 86929, upload-time = "2025-11-01T12:13:37.997Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/bc/9b7cf1b5fa098b86844d42de22549304699deff309c5c9e28b9a3fc4076a/levenshtein-0.27.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:272e24764b8210337b65a1cfd69ce40df5d2de1a3baf1234e7f06d2826ba2e7a", size = 170360, upload-time = "2025-11-01T12:13:39.019Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/95/997f2c83bd4712426bf0de8143b5e4403c7ebbafb5d1271983e774de3ae7/levenshtein-0.27.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:329a8e748a4e14d56daaa11f07bce3fde53385d05bad6b3f6dd9ee7802cdc915", size = 159098, upload-time = "2025-11-01T12:13:40.17Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/96/123c3316ae2f72c73be4fba9756924af015da4c0e5b12804f5753c0ee511/levenshtein-0.27.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5fea1a9c6b9cc8729e467e2174b4359ff6bac27356bb5f31898e596b4ce133a", size = 136655, upload-time = "2025-11-01T12:13:41.262Z" },
+    { url = "https://files.pythonhosted.org/packages/45/72/a3180d437736b1b9eacc3100be655a756deafb91de47c762d40eb45a9d91/levenshtein-0.27.3-cp313-cp313t-manylinux_2_24_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3a61aa825819b6356555091d8a575d1235bd9c3753a68316a261af4856c3b487", size = 117511, upload-time = "2025-11-01T12:13:42.647Z" },
+    { url = "https://files.pythonhosted.org/packages/61/f9/ba7c546a4b99347938e6661104064ab6a3651c601d59f241ffdc37510ecc/levenshtein-0.27.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a51de7a514e8183f0a82f2947d01b014d2391426543b1c076bf5a26328cec4e4", size = 155656, upload-time = "2025-11-01T12:13:44.208Z" },
+    { url = "https://files.pythonhosted.org/packages/42/cd/5edd6e1e02c3e47c8121761756dd0f85f816b636f25509118b687e6b0f96/levenshtein-0.27.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:53cbf726d6e92040c9be7e594d959d496bd62597ea48eba9d96105898acbeafe", size = 1116689, upload-time = "2025-11-01T12:13:45.485Z" },
+    { url = "https://files.pythonhosted.org/packages/95/67/25ca0119e0c6ec17226c72638f48ef8887124597ac48ad5da111c0b3a825/levenshtein-0.27.3-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:191b358afead8561c4fcfed22f83c13bb6c8da5f5789e277f0c5aa1c45ca612f", size = 1003166, upload-time = "2025-11-01T12:13:47.126Z" },
+    { url = "https://files.pythonhosted.org/packages/45/64/ab216f3fb3cef1ee7e222665537f9340d828ef84c99409ba31f2ef2a3947/levenshtein-0.27.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ba1318d0635b834b8f0397014a7c43f007e65fce396a47614780c881bdff828b", size = 1189362, upload-time = "2025-11-01T12:13:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/31/58/b150034858de0899a5a222974b6710618ebc0779a0695df070f7ab559a0b/levenshtein-0.27.3-cp313-cp313t-win32.whl", hash = "sha256:8dd9e1db6c3b35567043e155a686e4827c4aa28a594bd81e3eea84d3a1bd5875", size = 86149, upload-time = "2025-11-01T12:13:50.588Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c4/bbe46a11073641450200e6a604b3b62d311166e8061c492612a40e560e85/levenshtein-0.27.3-cp313-cp313t-win_amd64.whl", hash = "sha256:7813ecdac7a6223264ebfea0c8d69959c43d21a99694ef28018d22c4265c2af6", size = 96685, upload-time = "2025-11-01T12:13:51.641Z" },
+    { url = "https://files.pythonhosted.org/packages/23/65/30b362ad9bfc1085741776a08b6ddee3f434e9daac2920daaee2e26271bf/levenshtein-0.27.3-cp313-cp313t-win_arm64.whl", hash = "sha256:8f05a0d23d13a6f802c7af595d0e43f5b9b98b6ed390cec7a35cb5d6693b882b", size = 88538, upload-time = "2025-11-01T12:13:52.757Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/e1/2f705da403f865a5fa3449b155738dc9c53021698fd6926253a9af03180b/levenshtein-0.27.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a6728bfae9a86002f0223576675fc7e2a6e7735da47185a1d13d1eaaa73dd4be", size = 169457, upload-time = "2025-11-01T12:13:53.778Z" },
+    { url = "https://files.pythonhosted.org/packages/76/2c/bb6ef359e007fe7b6b3195b68a94f4dd3ecd1885ee337ee8fbd4df55996f/levenshtein-0.27.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8e5037c4a6f97a238e24aad6f98a1e984348b7931b1b04b6bd02bd4f8238150d", size = 158680, upload-time = "2025-11-01T12:13:55.005Z" },
+    { url = "https://files.pythonhosted.org/packages/51/7b/de1999f4cf1cfebc3fbbf03a6d58498952d6560d9798af4b0a566e6b6f30/levenshtein-0.27.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6cf5ecf9026bf24cf66ad019c6583f50058fae3e1b3c20e8812455b55d597f1", size = 133167, upload-time = "2025-11-01T12:13:56.426Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/da/aaa7f3a0a8ae8744b284043653652db3d7d93595517f9ed8158c03287692/levenshtein-0.27.3-cp314-cp314-manylinux_2_24_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9285084bd2fc19adb47dab54ed4a71f57f78fe0d754e4a01e3c75409a25aed24", size = 114530, upload-time = "2025-11-01T12:13:57.883Z" },
+    { url = "https://files.pythonhosted.org/packages/29/ce/ed422816fb30ffa3bc11597b30d5deca06b4a1388707a04215da73c65b53/levenshtein-0.27.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce3bbbe92172a08b599d79956182c6b7ab6ec8d4adbe7237417a363b968ad87b", size = 153325, upload-time = "2025-11-01T12:13:59.318Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/5a/a225477a0bda154f19f1c07a5e35500d631ae25dfd620b479027d79f0d4c/levenshtein-0.27.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9dac48fab9d166ca90e12fb6cf6c7c8eb9c41aacf7136584411e20f7f136f745", size = 1114956, upload-time = "2025-11-01T12:14:00.543Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/c4/a1be1040f3cce516a5e2be68453fd0c32ac63b2e9d31f476723fd8002c09/levenshtein-0.27.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d37a83722dc5326c93d17078e926c4732dc4f3488dc017c6839e34cd16af92b7", size = 1007610, upload-time = "2025-11-01T12:14:02.036Z" },
+    { url = "https://files.pythonhosted.org/packages/86/d7/6f50e8a307e0c2befd819b481eb3a4c2eacab3dd8101982423003fac8ea3/levenshtein-0.27.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3466cb8294ce586e49dd467560a153ab8d296015c538223f149f9aefd3d9f955", size = 1185379, upload-time = "2025-11-01T12:14:03.385Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/e5/5d8fb1b3ebd5735f53221bf95c923066bcfc132234925820128f7eee5b47/levenshtein-0.27.3-cp314-cp314-win32.whl", hash = "sha256:c848bf2457b268672b7e9e73b44f18f49856420ac50b2564cf115a6e4ef82688", size = 86328, upload-time = "2025-11-01T12:14:04.74Z" },
+    { url = "https://files.pythonhosted.org/packages/30/82/8a9ccbdb4e38bd4d516f2804999dccb8cb4bcb4e33f52851735da0c73ea7/levenshtein-0.27.3-cp314-cp314-win_amd64.whl", hash = "sha256:742633f024362a4ed6ef9d7e75d68f74b041ae738985fcf55a0e6d1d4cade438", size = 96640, upload-time = "2025-11-01T12:14:06.24Z" },
+    { url = "https://files.pythonhosted.org/packages/14/86/f9d15919f59f5d92c6baa500315e1fa0143a39d811427b83c54f038267ca/levenshtein-0.27.3-cp314-cp314-win_arm64.whl", hash = "sha256:9eed6851224b19e8d588ddb8eb8a4ae3c2dcabf3d1213985f0b94a67e517b1df", size = 89689, upload-time = "2025-11-01T12:14:07.379Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/f6/10f44975ae6dc3047b2cd260e3d4c3a5258b8d10690a42904115de24fc51/levenshtein-0.27.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:77de69a345c76227b51a4521cd85442eb3da54c7eb6a06663a20c058fc49e683", size = 170518, upload-time = "2025-11-01T12:14:09.196Z" },
+    { url = "https://files.pythonhosted.org/packages/08/07/fa294a145a0c99a814a9a807614962c1ee0f5749ca691645980462027d5d/levenshtein-0.27.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:eba2756dc1f5b962b0ff80e49abb2153d5e809cc5e7fa5e85be9410ce474795d", size = 159097, upload-time = "2025-11-01T12:14:10.404Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/50/24bdf37813fc30f293e53b46022b091144f4737a6a66663d2235b311bb98/levenshtein-0.27.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c8fcb498287e971d84260f67808ff1a06b3f6212d80fea75cf5155db80606ff", size = 136650, upload-time = "2025-11-01T12:14:11.579Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/a9/0399c7a190b277cdea3acc801129d9d30da57c3fa79519e7b8c3f080d86c/levenshtein-0.27.3-cp314-cp314t-manylinux_2_24_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:f067092c67464faab13e00a5c1a80da93baca8955d4d49579861400762e35591", size = 117515, upload-time = "2025-11-01T12:14:12.877Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/a4/1c27533e97578b385a4b8079abe8d1ce2e514717c761efbe4bf7bbd0ac2e/levenshtein-0.27.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92415f32c68491203f2855d05eef3277d376182d014cf0859c013c89f277fbbf", size = 155711, upload-time = "2025-11-01T12:14:13.985Z" },
+    { url = "https://files.pythonhosted.org/packages/50/35/bbc26638394a72b1e31a685ec251c995ee66a630c7e5c86f98770928b632/levenshtein-0.27.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ef61eeaf1e0a42d7d947978d981fe4b9426b98b3dd8c1582c535f10dee044c3f", size = 1116692, upload-time = "2025-11-01T12:14:15.359Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/83/32fcf28b388f8dc6c36b54552b9bae289dab07d43df104893158c834cbcc/levenshtein-0.27.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:103bb2e9049d1aa0d1216dd09c1c9106ecfe7541bbdc1a0490b9357d42eec8f2", size = 1003167, upload-time = "2025-11-01T12:14:17.469Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/79/1fbf2877ec4b819f373a32ebe3c48a61ee810693593a6015108b0be97b78/levenshtein-0.27.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6a64ddd1986b2a4c468b09544382287315c53585eb067f6e200c337741e057ee", size = 1189417, upload-time = "2025-11-01T12:14:19.081Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ac/dad4e09f1f7459c64172e48e40ed2baf3aa92d38205bcbd1b4ff00853701/levenshtein-0.27.3-cp314-cp314t-win32.whl", hash = "sha256:957244f27dc284ccb030a8b77b8a00deb7eefdcd70052a4b1d96f375780ae9dc", size = 88144, upload-time = "2025-11-01T12:14:20.667Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/61/cd51dc8b8a382e17c559a9812734c3a9afc2dab7d36253516335ee16ae50/levenshtein-0.27.3-cp314-cp314t-win_amd64.whl", hash = "sha256:ccd7eaa6d8048c3ec07c93cfbcdefd4a3ae8c6aca3a370f2023ee69341e5f076", size = 98516, upload-time = "2025-11-01T12:14:21.786Z" },
+    { url = "https://files.pythonhosted.org/packages/27/5e/3fb67e882c1fee01ebb7abc1c0a6669e5ff8acd060e93bfe7229e9ce6e4f/levenshtein-0.27.3-cp314-cp314t-win_arm64.whl", hash = "sha256:1d8520b89b7a27bb5aadbcc156715619bcbf556a8ac46ad932470945dca6e1bd", size = 91020, upload-time = "2025-11-01T12:14:22.944Z" },
 ]
 
 [[package]]
@@ -582,6 +682,50 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/88/29/744136411e785c4b0b744d5413e56555265939ab3a104c6a4b719dad33fd/mkdocs_get_deps-0.2.2-py3-none-any.whl", hash = "sha256:e7878cbeac04860b8b5e0ca31d3abad3df9411a75a32cde82f8e44b6c16ff650", size = 9555, upload-time = "2026-03-10T02:46:32.256Z" },
 ]
 
+[[package]]
+name = "msgpack"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" },
+    { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" },
+    { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" },
+    { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" },
+    { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" },
+    { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" },
+    { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" },
+    { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" },
+    { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" },
+    { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" },
+    { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" },
+    { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" },
+    { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" },
+    { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" },
+]
+
 [[package]]
 name = "numpy"
 version = "2.4.4"
@@ -664,11 +808,11 @@ wheels = [
 
 [[package]]
 name = "packaging"
-version = "26.0"
+version = "26.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
 ]
 
 [[package]]
@@ -725,20 +869,20 @@ wheels = [
 
 [[package]]
 name = "pathspec"
-version = "1.0.4"
+version = "1.1.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" },
 ]
 
 [[package]]
 name = "platformdirs"
-version = "4.9.4"
+version = "4.9.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" },
+    { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" },
 ]
 
 [[package]]
@@ -752,60 +896,109 @@ wheels = [
 
 [[package]]
 name = "polars"
-version = "1.40.0"
+version = "1.40.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "polars-runtime-32" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d9/1b/eea7d6fe6daafc1d784cc0f76c729b28051837ccb2d51ae64a0a3f798142/polars-1.40.0.tar.gz", hash = "sha256:711dd50dcbc35ba42a2625fcadc2a1349e2e9abf48e35631bdabafb90d89874b", size = 732943, upload-time = "2026-04-18T05:25:26.077Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b3/8c/bc9bc948058348ed43117cecc3007cd608f395915dae8a00974579a5dab1/polars-1.40.1.tar.gz", hash = "sha256:ab2694134b137596b5a59bfd7b4c54ebbc9b59f9403127f18e32d363777552e8", size = 733574, upload-time = "2026-04-22T19:15:55.507Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b4/ad/d5ed79269b7fe59a3dbbfbdbecbe1e59a0b56e38d36491e57d2bfb5846c1/polars-1.40.0-py3-none-any.whl", hash = "sha256:60b1d677ca363e2fc6fdea8c3d16c0653fd52cc37f0249e0f29d9536d5aa45ef", size = 828012, upload-time = "2026-04-18T05:23:39.055Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/91/74fc60d94488685a92ac9d49d7ec55f3e91fe9b77942a6235a5fa7f249c3/polars-1.40.1-py3-none-any.whl", hash = "sha256:c0f861219d1319cdea45c4ce4d30355a47176b8f98dcedf95ea8269f131b8abd", size = 828723, upload-time = "2026-04-22T19:14:25.452Z" },
+]
+
+[package.optional-dependencies]
+rtcompat = [
+    { name = "polars-runtime-compat" },
 ]
 
 [[package]]
 name = "polars-runtime-32"
-version = "1.40.0"
+version = "1.40.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/54/ba/26d40f039be9f552b5fd7365a621bdfc0f8e912ef77094ae4693491b0bae/polars_runtime_32-1.40.1.tar.gz", hash = "sha256:37f3065615d1bf90d03b5326222df4c5c1f8a5d33e50470aa588e3465e6eb814", size = 2935843, upload-time = "2026-04-22T19:15:57.26Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7d/46/22c8af5eed68ac2eeb556e0fa3ca8a7b798e984ceff4450888f3b5ac61fd/polars_runtime_32-1.40.1-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:b748ef652270cc49e9e69f99a035e0eb4d5f856d42bcd6ac4d9d80a40142aa1e", size = 52098755, upload-time = "2026-04-22T19:14:28.555Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/3e/48599a38009ca60ff82a6f38c8a621ce3c0286aa7397c7d79e741bd9060e/polars_runtime_32-1.40.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:d249b3743e05986060cec0a7aaa542d020df6c6b876e556023a310efd581f9be", size = 46367542, upload-time = "2026-04-22T19:14:32.433Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e9/384bc069367a1a36ee31c13782c178dbd039b2b873b772d4a0fc23a2373d/polars_runtime_32-1.40.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5987b30e7aa1059d069498496e8dda35afd592b0ac3d46ed87e3ff8df1ad652c", size = 50252104, upload-time = "2026-04-22T19:14:35.945Z" },
+    { url = "https://files.pythonhosted.org/packages/15/ef/7d57ceb0651af74194e97ed6583e148d352f03d696090221b8059cdfc90b/polars_runtime_32-1.40.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d7f42a8b3f16fc66002cc0f6516f7dd7653396886ae0ed362ab95c0b3408b59", size = 56250788, upload-time = "2026-04-22T19:14:39.743Z" },
+    { url = "https://files.pythonhosted.org/packages/10/0f/e4b3ffc748827a14a474ec9c42e45c066050e440fec57e914091d9adda75/polars_runtime_32-1.40.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:e5f7becc237a7ec9d9a10878dc8e54b73bbf4e2d94a2991c37d7a0b38590d8f9", size = 50432590, upload-time = "2026-04-22T19:14:43.388Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/0b/b8d95fbed869fa4caabe9c400e4210374913b376e925e96fdcfa9be6416b/polars_runtime_32-1.40.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:992d14cf191dde043d36fbdbc98a65e43fbc7e9a5024cecd45f838ac4988c1ee", size = 54155564, upload-time = "2026-04-22T19:14:47.239Z" },
+    { url = "https://files.pythonhosted.org/packages/06/d9/d091d8fb5cbed5e9536adfed955c4c89987a4cc3b8e73ae4532402b91c74/polars_runtime_32-1.40.1-cp310-abi3-win_amd64.whl", hash = "sha256:f78bb2abd00101cbb23cc0cb068f7e36e081057a15d2ec2dde3dda280709f030", size = 51829755, upload-time = "2026-04-22T19:14:50.85Z" },
+    { url = "https://files.pythonhosted.org/packages/65/ad/b33c3022a394f3eb55c3310597cec615412a8a33880055eee191d154a628/polars_runtime_32-1.40.1-cp310-abi3-win_arm64.whl", hash = "sha256:b5cbfaf6b085b420b4bfcbe24e8f665076d1cccfdb80c0484c02a023ce205537", size = 45822104, upload-time = "2026-04-22T19:14:54.192Z" },
+]
+
+[[package]]
+name = "polars-runtime-compat"
+version = "1.40.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fb/b2/eae6c1b3d16c7a64ff382f557985ff939cce13455e8c9d056ab8e1e0fc87/polars_runtime_32-1.40.0.tar.gz", hash = "sha256:e31bff8bd37492c714e155e2e1429ac2d9ddf2dd6ec6474cc1cc70ac0b2bd6af", size = 2935285, upload-time = "2026-04-18T05:25:28.038Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/60/f8340030f94a45231ad02abff171c8c10f45df0984e5a4fd0f39a48500f4/polars_runtime_compat-1.40.1.tar.gz", hash = "sha256:6149aa764439cec26a5f883fb9921a50f61a0f6c4549df51c735626701a73a18", size = 2935443, upload-time = "2026-04-22T19:16:00.906Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b0/e4/2325689d2af4f9e70699ff98e8a2543707bebc34af78a5fe0e654107d9ed/polars_runtime_32-1.40.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:cab3ac7ff5bc9e0f4b3b146015569e9417cf0eaff8d3fb71004d73d67b6f09c7", size = 52092528, upload-time = "2026-04-18T05:23:42.341Z" },
-    { url = "https://files.pythonhosted.org/packages/19/a6/82157b19c5c40b2c1ed0493b87b9eaf9b4863cdedca5575ee083488b45ba/polars_runtime_32-1.40.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:d29624c75c4049253300786d00882fce620b3677ce495ebc4199292de8c2ba02", size = 46365073, upload-time = "2026-04-18T05:23:46.7Z" },
-    { url = "https://files.pythonhosted.org/packages/85/b5/5c4f1f2545f56c664cc57bbdd1aa66fcfcb129aa137ed72cc81d58eb480f/polars_runtime_32-1.40.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a034dc0d8481fc1ca0456ab33e98e53a4c6d6cc6a2edb36246cc81c936b925dc", size = 50250561, upload-time = "2026-04-18T05:23:51.316Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/51/cb5eb75394f39c0ec14fddcc9b11adb707e1f28224a552ecbfa72d39b61b/polars_runtime_32-1.40.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70e78c2f13a54a9d92ae30d2625bda759173cc4867ad6a39f85f140058d899c6", size = 56243695, upload-time = "2026-04-18T05:23:55.932Z" },
-    { url = "https://files.pythonhosted.org/packages/16/3a/be1437c0fbecbb07d81b151456089c3cf054eea5a791f849ed39b67611ca/polars_runtime_32-1.40.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1843272c0ef49f4a07435888f0059eca08ec16ab9880219c457195a081df0281", size = 50427843, upload-time = "2026-04-18T05:24:00.159Z" },
-    { url = "https://files.pythonhosted.org/packages/be/c7/ea6449a2161816a13ed1d8aa02177d5a0594e011f0df5ddd2fad8e5bf20e/polars_runtime_32-1.40.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:081237dba07f15d61fc151825f203165480e9503ebe72a474a8c99aa78021962", size = 54153077, upload-time = "2026-04-18T05:24:05.066Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/1a/0b239138afe8b80a1a0b4c95db3884e6afbbe82ec3318918ab03bc57f231/polars_runtime_32-1.40.0-cp310-abi3-win_amd64.whl", hash = "sha256:a916040e0b7f461ce987e4551fed9eea5914b4fbb5af907b1d9e80db71fadeb5", size = 51822748, upload-time = "2026-04-18T05:24:09.384Z" },
-    { url = "https://files.pythonhosted.org/packages/06/ce/c16ef8fd3030b7342032b040fab21a42f6fee57e47ee7f41e2f1a1e36f01/polars_runtime_32-1.40.0-cp310-abi3-win_arm64.whl", hash = "sha256:719c64eecde24a95aa3599eb9c8efc98c1499bab7ef9c01cbbe8939cd583e654", size = 45819617, upload-time = "2026-04-18T05:24:13.214Z" },
+    { url = "https://files.pythonhosted.org/packages/07/c7/978481a2a2f5b50636d485bc176e16084fa1bb3b1d7e7e34f580cef240dc/polars_runtime_compat-1.40.1-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:a683d287237f1dcc3dee95b5b2b6408cec318abbbb412ca49206492513be862f", size = 52016973, upload-time = "2026-04-22T19:15:25.228Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/c9/e308b0bbb331330a762f5f495597d34e9933c965ca6d4026a2eb481ef4ad/polars_runtime_compat-1.40.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:c83750f5593cec088134614fbf783fd10c5a92030d71b35f3dea0fff682d92c6", size = 46246682, upload-time = "2026-04-22T19:15:28.666Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/54/eaecb4747695e2e200ed6d13ce40dd7b0cdc7499d0b9af1e64e83af0e46d/polars_runtime_compat-1.40.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ffa15c4a8b7f67911412c849dc3d3aac313f682d834eb3f374d0f6cb7e080efc", size = 50123217, upload-time = "2026-04-22T19:15:32.321Z" },
+    { url = "https://files.pythonhosted.org/packages/20/87/0a881905d94341111d38e6a7ae94674511e6797cf3be2500998f06963edf/polars_runtime_compat-1.40.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0373dabf942135d13b453d50be7a84b14420b495bd1242570545f58866396e7", size = 55869626, upload-time = "2026-04-22T19:15:37.15Z" },
+    { url = "https://files.pythonhosted.org/packages/be/6e/ac57e39bb94ebd63d6714895881ee0461e39039daa208916e5cad93174f9/polars_runtime_compat-1.40.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:bcdc488472d2c57dd3315a897456b47cdac222a1520fcf3d8d38410a5bf47ec1", size = 50287716, upload-time = "2026-04-22T19:15:40.829Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/f3/b75afc9f79cd4cadff52bdc4566119892b378f739a295573bf6bd0190a6c/polars_runtime_compat-1.40.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:34d03962169fc7c0ef6f6efd324d0a51350e7b5abf3b0cd118eb7a32e4d947ec", size = 53796312, upload-time = "2026-04-22T19:15:44.68Z" },
+    { url = "https://files.pythonhosted.org/packages/67/68/0df61011d894d1c94c915b39423c9aab79b3f7b18b836031ed32987227e0/polars_runtime_compat-1.40.1-cp310-abi3-win_amd64.whl", hash = "sha256:d9ccfe58eeb776567cf9556a83b980b9face9f0b1bb629bf2cd2334f4d9daf57", size = 51696665, upload-time = "2026-04-22T19:15:48.65Z" },
+    { url = "https://files.pythonhosted.org/packages/45/01/1bc7e868d3e4055b1ae756ad8ccc2a5d2bce57d7c88c3b4427babd43450b/polars_runtime_compat-1.40.1-cp310-abi3-win_arm64.whl", hash = "sha256:0c662e6acf5d4e3784eee8e8a1ec6eb185132ac90689cb84034132b5787903b1", size = 45701223, upload-time = "2026-04-22T19:15:52.189Z" },
 ]
 
 [[package]]
 name = "prek"
-version = "0.3.10"
+version = "0.3.11"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a2/31/3e68cd8f45cb5f3f81009ff42d3a3cde0887b83f214a4eb0ded9ae239cc2/prek-0.3.10.tar.gz", hash = "sha256:f4e9c533612bbaa9f89eca0e80ab6e59a05b0fd15ca7c6642a35bb303731ad6f", size = 425926, upload-time = "2026-04-21T11:29:37.122Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6c/60/5b980c70525ca5f0d17942d8eae13b399051aa384413366fe5df229712ea/prek-0.3.11.tar.gz", hash = "sha256:c4cf77848009503c58d80ff216e32af45b63ea49652bb5546748c1ebfd4d9847", size = 433440, upload-time = "2026-04-27T04:22:59.923Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/2a/3392fa7d1fd1ce538915baa7597e7203bbe888367a8b15bfd51ca74d4714/prek-0.3.11-py3-none-linux_armv6l.whl", hash = "sha256:787e605716cfdc86ec01e7c5cf62799f39c28d49de5e37d75595c8e6248cb0f3", size = 5423112, upload-time = "2026-04-27T04:22:52.659Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/b0/3fc653b30b70d6c2714fc56bcfe1c2439437fc38f60b72bc300603ace4cd/prek-0.3.11-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ef1f37187ca52d75ba9c46b53007476c4eab2c3f11bd23defd57a81c62d90442", size = 5801382, upload-time = "2026-04-27T04:23:04.464Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/46/39aedc7843c3703f1f43b686622e4f8cd123e03b87a163e5c8f2fbd56cda/prek-0.3.11-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e0d0828a1b50447502ea1be3f5a84da474fdca558cd5d76a1a5205169bb808c7", size = 5370817, upload-time = "2026-04-27T04:22:49.277Z" },
+    { url = "https://files.pythonhosted.org/packages/15/83/df5f3aeacbdea96a88c4f06c98d3932469711fed4e3bf5b703dd6507abe7/prek-0.3.11-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:bf49464b526ee36d2130baf60ab9580560bfaa60efd2997328e6d6671e209014", size = 5621405, upload-time = "2026-04-27T04:23:10.58Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/f2/e32c9720747a327669863a4f92d05b9e6fadb851e903b0d7310a97c956a4/prek-0.3.11-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac344529f0d34757c7c95f65e66b9f6440a691f826eaf43f503247bd22023558", size = 5339780, upload-time = "2026-04-27T04:22:47.614Z" },
+    { url = "https://files.pythonhosted.org/packages/29/2e/0e2f71b63bc2e5372575d5c1574b0666d2f90d30da51ed706a32cbf465a0/prek-0.3.11-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:83672d963f249e2f246d3bec97f8fd2e8032e70da0a7d9acb2fa38af76dd82d2", size = 5735277, upload-time = "2026-04-27T04:23:12.437Z" },
+    { url = "https://files.pythonhosted.org/packages/09/46/88abf51ac88eeff1ad2fe7d1797ca1fea43eb1ac1ddb8331463ac5b27ed2/prek-0.3.11-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ef70957195d2896a30dd849e64f88344df7bb51af9c950cf16bd11519e7424b0", size = 6622420, upload-time = "2026-04-27T04:23:05.982Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/b6/592028a45b084a68b76c7edef909c789d1c96b26761388f63659beef7166/prek-0.3.11-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4f0cc07d2cdb5fe2882015d5fdafc9af98b4c560d4caa1ae948caeab4341b79", size = 6020038, upload-time = "2026-04-27T04:22:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/f7/e97f55a1645a2e9becffeee28892ad8bb66cd144dabfa4392ea8e2674bbe/prek-0.3.11-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:d7554b436dae2ec97f4351a46817e3561657244307d1c0915f355b859f4fab71", size = 5622539, upload-time = "2026-04-27T04:23:01.314Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e2/f3119eef6b621782ad216a86d449609858ea34c57cf4a40fc6dc80556d7e/prek-0.3.11-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:caba5d635a5b64b7ac64d903f29b043ca5b0d9d9693543a0ef331ade89e6ad3f", size = 5440681, upload-time = "2026-04-27T04:23:07.422Z" },
+    { url = "https://files.pythonhosted.org/packages/04/62/22dd4f59a47654faeebe74651182ecc48d436542646cc92723052dfd9a45/prek-0.3.11-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:c95a63f19dde48e84b70bd63a235670834af15fa4df8b85d8b7894dd5bc419a9", size = 5314773, upload-time = "2026-04-27T04:22:57.912Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/94/a8361462acb8d8f5b8505255b95ffbfc2ee0872a79b4e066eb330692f7be/prek-0.3.11-py3-none-musllinux_1_1_i686.whl", hash = "sha256:7353b45f44a386c676fe96ba72a5ee326b676f789339f405cf6f1d69a1707194", size = 5596208, upload-time = "2026-04-27T04:23:09.08Z" },
+    { url = "https://files.pythonhosted.org/packages/04/0c/5f065b86bbeb9977074a055d8a05e90c7201f6c4c7032dada61739b5f8cb/prek-0.3.11-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:39f4e86176ccbb70c098df6abbc8e36c1d86cb81281abe92fb79dcd572418214", size = 6132833, upload-time = "2026-04-27T04:22:56.054Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0c/8ab0ae140201dcee505f58b60abbe56bd05ac96b821a6866f6f90c4d971f/prek-0.3.11-py3-none-win32.whl", hash = "sha256:35d2361049653a3dcf27227b7f1b340c5c42a12c0e0361c4b785921bfd125839", size = 5120856, upload-time = "2026-04-27T04:23:02.752Z" },
+    { url = "https://files.pythonhosted.org/packages/57/05/9844c1125d3714f6f6c7b475884128a4b0c6c3ee0cd208ead44ca8174687/prek-0.3.11-py3-none-win_amd64.whl", hash = "sha256:a387689cd2e182f92dbb681151ee5a04f494fe97e95d6d783875da90b950e6d5", size = 5510916, upload-time = "2026-04-27T04:22:45.704Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/13/24b0288c553dc8d61f44c4d0746fe9bb1e1bd29d1e70571658536e4c0f72/prek-0.3.11-py3-none-win_arm64.whl", hash = "sha256:e4a8f900378a6657c7eb2fc4b12fa5c934edf209d0a24544539842479ec16e0b", size = 5345988, upload-time = "2026-04-27T04:22:50.918Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "6.33.6"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", hash = "sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135", size = 444531, upload-time = "2026-03-18T19:05:00.988Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/62/b7/306d57aaaf503be1ee58929f9e58e812fbde9bea52c1a578e4996d82425a/prek-0.3.10-py3-none-linux_armv6l.whl", hash = "sha256:7250661f003d902b7b601141d64c7015f93eeeeeb1c485f714374582714d7c51", size = 5416913, upload-time = "2026-04-21T11:29:33.716Z" },
-    { url = "https://files.pythonhosted.org/packages/93/ec/4b4b60d17c5eb639779a059d7f66a8fff5b38c7cb26c9c5b3a853cc6a9c8/prek-0.3.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:9da699368bb11e85fc58b57ae4c1ccc703364b1d95b595bd17a27b27fa6df50d", size = 5784725, upload-time = "2026-04-21T11:29:38.356Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/c3/6d4dcc9446a1630a888e3f105c4775536afe58c20f18833fec8e0d841ac0/prek-0.3.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:f245fa9935cee6ea7d5ba1c6e7dd7546ccf6f01fb7d604bb6a344c8e3b49a9c2", size = 5360071, upload-time = "2026-04-21T11:29:10.743Z" },
-    { url = "https://files.pythonhosted.org/packages/36/2d/d1f63ca15f4a275fcdc712fd9ef64787abb4ba86f2e79986a26108a5f1e7/prek-0.3.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:d321cad394ef4436ed9fce74150076a5eefabe310ed01b3f5735746284b9d046", size = 5615550, upload-time = "2026-04-21T11:29:30.985Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/1b/a925050ba30791e50e7690a6dabe33dc08a0133e7efab4b9d91088261d40/prek-0.3.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25e80017ecf06a11bf9c8ebcb67d38183e0abf2f18e012ee6a5f91d1b9c065d6", size = 5338159, upload-time = "2026-04-21T11:29:25.314Z" },
-    { url = "https://files.pythonhosted.org/packages/56/ec/7d563a333198ead10f9a13fcf72ca910a59135b5d58429ed3b1fff9a0ff9/prek-0.3.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ba24b4c8e40cb9ae96d58efa3eb91813cdff4f10b78b79201c93a0dc6b8763e2", size = 5728600, upload-time = "2026-04-21T11:29:23.687Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/88/10d493ef308f10321b92bb4e65ab60030b3c5c6304790c678be249e383e3/prek-0.3.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aac1c6f8dabb0a202a27516bf78cbfbe8a05b7cfebe2078ff6d0e12e7c77c7d5", size = 6610055, upload-time = "2026-04-21T11:29:27.398Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/14/552b239d99fdd09fd6664b69089359340778f84a9f866a1fecc38b66c811/prek-0.3.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5a9a446e178562e2c3cfc71c8f0b21043b571209533a104042b6b9e36662849e", size = 6007394, upload-time = "2026-04-21T11:29:14.466Z" },
-    { url = "https://files.pythonhosted.org/packages/21/80/12b9de6b6721a27f57ed633a8864435ec2fa7535cba7f48f3ea4a52ce683/prek-0.3.10-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:d7344b2acb88b52592c0e0f3dd33349f75e6a4813d3bb44385aa8c70084990ca", size = 5616625, upload-time = "2026-04-21T11:29:29.511Z" },
-    { url = "https://files.pythonhosted.org/packages/69/02/7235f6b6d65a3e6e036b211a240432bc4f51adfdbbdcc03b5ce60a238a84/prek-0.3.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:f2fe5ca3fe797a647243c10c0a9f9c2c27c1d4a0cdcb7f836a0cb8c5c2c603d8", size = 5431581, upload-time = "2026-04-21T11:29:20.399Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/0c/0dd0013c6a9c6b23d070a57fe5c015c40c7b3e84217e4fb1ca9e465768c6/prek-0.3.10-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:6d39031e4acf7670b905d77ea807e2ce1b6309604d54740f3152d601b71ae5e0", size = 5318252, upload-time = "2026-04-21T11:29:40.34Z" },
-    { url = "https://files.pythonhosted.org/packages/74/d7/5407ca904a7f2ffe63b1333e503d2f21ec23eda93e93fb45a491d78e0d76/prek-0.3.10-py3-none-musllinux_1_1_i686.whl", hash = "sha256:27865f3134dd566ffd76388a9f0de6ee931336794e32741b8e22c90a61f3fc39", size = 5589312, upload-time = "2026-04-21T11:29:18.3Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/05/460b0c498db65e9a2e590b6918aad3395291d8d9f2c080fce7201d12a5de/prek-0.3.10-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:3e6b65338a06add2bc47a86f837607b4705855ade9457f2f50676a7a5a509cd9", size = 6122323, upload-time = "2026-04-21T11:29:12.6Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/63/fd715bcd9ed5debd60dc589d6117ab9eaf0ef0b106e0bb976e1bcaa96e29/prek-0.3.10-py3-none-win32.whl", hash = "sha256:e2529515ce81292c938181702dbfc75516efa5bb1d4dc1295e6f8b2655eec881", size = 5115503, upload-time = "2026-04-21T11:29:35.677Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/0d/a34f57ca3efa228fa75a976fcf698d5705b5b9a750c8dd1b86857b24f3b0/prek-0.3.10-py3-none-win_amd64.whl", hash = "sha256:0846228fa277a8bdf5a3eeea90eb3ac8eff2bf71900919373f12d142e19c8f8c", size = 5496962, upload-time = "2026-04-21T11:29:16.71Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/de/8b9f20f712c21756e52feed95fdacd52f48811a7bc6e3816cd04725b1240/prek-0.3.10-py3-none-win_arm64.whl", hash = "sha256:dedcdb4e5a52ee3e0463c061cabdcb94a7443875053cebfadb8228b3bf917035", size = 5340403, upload-time = "2026-04-21T11:29:22.11Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/9f/2f509339e89cfa6f6a4c4ff50438db9ca488dec341f7e454adad60150b00/protobuf-6.33.6-cp310-abi3-win32.whl", hash = "sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3", size = 425739, upload-time = "2026-03-18T19:04:48.373Z" },
+    { url = "https://files.pythonhosted.org/packages/76/5d/683efcd4798e0030c1bab27374fd13a89f7c2515fb1f3123efdfaa5eab57/protobuf-6.33.6-cp310-abi3-win_amd64.whl", hash = "sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326", size = 437089, upload-time = "2026-03-18T19:04:50.381Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/01/a3c3ed5cd186f39e7880f8303cc51385a198a81469d53d0fdecf1f64d929/protobuf-6.33.6-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a", size = 427737, upload-time = "2026-03-18T19:04:51.866Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2", size = 324610, upload-time = "2026-03-18T19:04:53.096Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/ca/25afc144934014700c52e05103c2421997482d561f3101ff352e1292fb81/protobuf-6.33.6-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3", size = 339381, upload-time = "2026-03-18T19:04:54.616Z" },
+    { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593", size = 323436, upload-time = "2026-03-18T19:04:55.768Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" },
 ]
 
 [[package]]
 name = "protobuf"
 version = "7.34.1"
 source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version == '3.13.*' and sys_platform == 'win32'",
+    "python_full_version < '3.13' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'emscripten'",
+    "python_full_version < '3.13' and sys_platform == 'emscripten'",
+    "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version < '3.13' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
 sdist = { url = "https://files.pythonhosted.org/packages/6b/6b/a0e95cad1ad7cc3f2c6821fcab91671bd5b78bd42afb357bb4765f29bc41/protobuf-7.34.1.tar.gz", hash = "sha256:9ce42245e704cc5027be797c1db1eb93184d44d1cdd71811fb2d9b25ad541280", size = 454708, upload-time = "2026-03-20T17:34:47.036Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/ec/11/3325d41e6ee15bf1125654301211247b042563bcc898784351252549a8ad/protobuf-7.34.1-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:d8b2cc79c4d8f62b293ad9b11ec3aebce9af481fa73e64556969f7345ebf9fc7", size = 429247, upload-time = "2026-03-20T17:34:37.024Z" },
@@ -817,6 +1010,58 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/88/95/608f665226bca68b736b79e457fded9a2a38c4f4379a4a7614303d9db3bc/protobuf-7.34.1-py3-none-any.whl", hash = "sha256:bb3812cd53aefea2b028ef42bd780f5b96407247f20c6ef7c679807e9d188f11", size = 170715, upload-time = "2026-03-20T17:34:45.384Z" },
 ]
 
+[[package]]
+name = "pyarrow"
+version = "24.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/91/13/13e1069b351bdc3881266e11147ffccf687505dbb0ea74036237f5d454a5/pyarrow-24.0.0.tar.gz", hash = "sha256:85fe721a14dd823aca09127acbb06c3ca723efbd436c004f16bca601b04dcc83", size = 1180261, upload-time = "2026-04-21T10:51:25.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/a9/9686d9f07837f91f775e8932659192e02c74f9d8920524b480b85212cc68/pyarrow-24.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:6233c9ed9ab9d1db47de57d9753256d9dcffbf42db341576099f0fd9f6bf4810", size = 34981559, upload-time = "2026-04-21T10:47:22.17Z" },
+    { url = "https://files.pythonhosted.org/packages/80/b6/0ddf0e9b6ead3474ab087ae598c76b031fc45532bf6a63f3a553440fb258/pyarrow-24.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:f7616236ec1bc2b15bfdec22a71ab38851c86f8f05ff64f379e1278cf20c634a", size = 36663654, upload-time = "2026-04-21T10:47:28.315Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/3b/926382efe8ce27ba729071d3566ade6dfb86bdf112f366000196b2f5780a/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:1617043b99bd33e5318ae18eb2919af09c71322ef1ca46566cdafc6e6712fb66", size = 45679394, upload-time = "2026-04-21T10:47:34.821Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/7a/829f7d9dfd37c207206081d6dad474d81dde29952401f07f2ba507814818/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6165461f55ef6314f026de6638d661188e3455d3ec49834556a0ebbdbace18bb", size = 48863122, upload-time = "2026-04-21T10:47:42.056Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e8/f88ce625fe8babaae64e8db2d417c7653adb3019b08aae85c5ed787dc816/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b13dedfe76a0ad2d1d859b0811b53827a4e9d93a0bcb05cf59333ab4980cc7e", size = 49376032, upload-time = "2026-04-21T10:47:48.967Z" },
+    { url = "https://files.pythonhosted.org/packages/36/7a/82c363caa145fff88fb475da50d3bf52bb024f61917be5424c3392eaf878/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:25ea65d868eb04015cd18e6df2fbe98f07e5bda2abefabcb88fce39a947716f6", size = 51929490, upload-time = "2026-04-21T10:47:55.981Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1c/e3e72c8014ad2743ca64a701652c733cc5cbcee15c0463a32a8c55518d9e/pyarrow-24.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:295f0a7f2e242dabd513737cf076007dc5b2d59237e3eca37b05c0c6446f3826", size = 27355660, upload-time = "2026-04-21T10:48:01.718Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d3/a1abf004482026ddc17f4503db227787fa3cfe41ec5091ff20e4fea55e57/pyarrow-24.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:02b001b3ed4723caa44f6cd1af2d5c86aa2cf9971dacc2ffa55b21237713dfba", size = 34976759, upload-time = "2026-04-21T10:48:07.258Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/4a/34f0a36d28a2dd32225301b79daad44e243dc1a2bb77d43b60749be255c4/pyarrow-24.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:04920d6a71aabd08a0417709efce97d45ea8e6fb733d9ca9ecffb13c67839f68", size = 36658471, upload-time = "2026-04-21T10:48:13.347Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/78/543b94712ae8bb1a6023bcc1acf1a740fbff8286747c289cd9468fced2a5/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:a964266397740257f16f7bb2e4f08a0c81454004beab8ff59dd531b73610e9f2", size = 45675981, upload-time = "2026-04-21T10:48:20.201Z" },
+    { url = "https://files.pythonhosted.org/packages/84/9f/8fb7c222b100d314137fa40ec050de56cd8c6d957d1cfff685ce72f15b17/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6f066b179d68c413374294bc1735f68475457c933258df594443bb9d88ddc2a0", size = 48859172, upload-time = "2026-04-21T10:48:27.541Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/d3/1ea72538e6c8b3b475ed78d1049a2c518e655761ea50fe1171fc855fcab7/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1183baeb14c5f587b1ec52831e665718ce632caab84b7cd6b85fd44f96114495", size = 49385733, upload-time = "2026-04-21T10:48:34.7Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/be/c3d8b06a1ba35f2260f8e1f771abbee7d5e345c0937aab90675706b1690a/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:806f24b4085453c197a5078218d1ee08783ebbba271badd153d1ae22a3ee804f", size = 51934335, upload-time = "2026-04-21T10:48:42.099Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/62/89e07a1e7329d2cde3e3c6994ba0839a24977a2beda8be6005ea3d860b99/pyarrow-24.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:e4505fc6583f7b05ab854934896bcac8253b04ac1171a77dfb73efef92076d91", size = 27271748, upload-time = "2026-04-21T10:49:42.532Z" },
+    { url = "https://files.pythonhosted.org/packages/17/1a/cff3a59f80b5b1658549d46611b67163f65e0664431c076ad728bf9d5af4/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:1a4e45017efbf115032e4475ee876d525e0e36c742214fbe405332480ecd6275", size = 35238554, upload-time = "2026-04-21T10:48:48.526Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/99/cce0f42a327bfef2c420fb6078a3eb834826e5d6697bf3009fe11d2ad051/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:7986f1fa71cee060ad00758bcc79d3a93bab8559bf978fab9e53472a2e25a17b", size = 36782301, upload-time = "2026-04-21T10:48:55.181Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/66/8e560d5ff6793ca29aca213c53eec0dd482dd46cb93b2819e5aab52e4252/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:d3e0b61e8efb24ed38898e5cdc5fffa9124be480008d401a1f8071500494ae42", size = 45721929, upload-time = "2026-04-21T10:49:03.676Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0c/a26e25505d030716e078d9f16eb74973cbf0b33b672884e9f9da1c83b871/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:55a3bc1e3df3b5567b7d27ef551b2283f0c68a5e86f1cd56abc569da4f31335b", size = 48825365, upload-time = "2026-04-21T10:49:11.714Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/eb/771f9ecb0c65e73fe9dccdd1717901b9594f08c4515d000c7c62df573811/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:641f795b361874ac9da5294f8f443dfdbee355cf2bd9e3b8d97aaac2306b9b37", size = 49451819, upload-time = "2026-04-21T10:49:21.474Z" },
+    { url = "https://files.pythonhosted.org/packages/48/da/61ae89a88732f5a785646f3ec6125dbb640fa98a540eb2b9889caa561403/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8adc8e6ce5fccf5dc707046ae4914fd537def529709cc0d285d37a7f9cd442ca", size = 51909252, upload-time = "2026-04-21T10:49:31.164Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1a/8dd5cafab7b66573fa91c03d06d213356ad4edd71813aa75e08ce2b3a844/pyarrow-24.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:9b18371ad2f44044b81a8d23bc2d8a9b6a6226dca775e8e16cfee640473d6c5d", size = 27388127, upload-time = "2026-04-21T10:49:37.334Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/80/d022a34ff05d2cbedd8ccf841fc1f532ecfa9eb5ed1711b56d0e0ea71fc9/pyarrow-24.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:1cc9057f0319e26333b357e17f3c2c022f1a83739b48a88b25bfd5fa2dc18838", size = 35007997, upload-time = "2026-04-21T10:49:48.796Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/ff/f01485fda6f4e5d441afb8dd5e7681e4db18826c1e271852f5d3957d6a80/pyarrow-24.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e6f1278ee4785b6db21229374a1c9e54ec7c549de5d1efc9630b6207de7e170b", size = 36678720, upload-time = "2026-04-21T10:49:55.858Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c2/2d2d5fea814237923f71b36495211f20b43a1576f9a4d6da7e751a64ec6f/pyarrow-24.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:adbbedc55506cbdabb830890444fb856bfb0060c46c6f8026c6c2f2cf86ae795", size = 45741852, upload-time = "2026-04-21T10:50:04.624Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/3a/28ba9c1c1ebdbb5f1b94dfebb46f207e52e6a554b7fe4132540fde29a3a0/pyarrow-24.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:ae8a1145af31d903fa9bb166824d7abe9b4681a000b0159c9fb99c11bc11ad26", size = 48889852, upload-time = "2026-04-21T10:50:12.293Z" },
+    { url = "https://files.pythonhosted.org/packages/df/51/4a389acfd31dca009f8fb82d7f510bb4130f2b3a8e18cf00194d0687d8ac/pyarrow-24.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d7027eba1df3b2069e2e8d80f644fa0918b68c46432af3d088ddd390d063ecde", size = 49445207, upload-time = "2026-04-21T10:50:20.677Z" },
+    { url = "https://files.pythonhosted.org/packages/19/4b/0bab2b23d2ae901b1b9a03c0efd4b2d070256f8ce3fc43f6e58c167b2081/pyarrow-24.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e56a1ffe9bf7b727432b89104cc0849c21582949dd7bdcb34f17b2001a351a76", size = 51954117, upload-time = "2026-04-21T10:50:29.14Z" },
+    { url = "https://files.pythonhosted.org/packages/29/88/f4e9145da0417b3d2c12035a8492b35ff4a3dbc653e614fcfb51d9dedb38/pyarrow-24.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:38be1808cdd068605b787e6ca9119b27eb275a0234e50212c3492331680c3b1e", size = 28001155, upload-time = "2026-04-21T10:51:22.337Z" },
+    { url = "https://files.pythonhosted.org/packages/79/4f/46a49a63f43526da895b1a45bbb51d5baf8e4d77159f8528fc3e5490007f/pyarrow-24.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:418e48ce50a45a6a6c73c454677203a9c75c966cb1e92ca3370959185f197a05", size = 35250387, upload-time = "2026-04-21T10:50:35.552Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/da/d5e0cd5ef00796922404806d5f00325cdadc3441ce2c13fe7115f2df9a64/pyarrow-24.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:2f16197705a230a78270cdd4ea8a1d57e86b2fdcbc34a1f6aebc72e65c986f9a", size = 36797102, upload-time = "2026-04-21T10:50:42.417Z" },
+    { url = "https://files.pythonhosted.org/packages/34/c7/5904145b0a593a05236c882933d439b5720f0a145381179063722fbfc123/pyarrow-24.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:fb24ac194bfc5e86839d7dcd52092ee31e5fe6733fe11f5e3b06ef0812b20072", size = 45745118, upload-time = "2026-04-21T10:50:49.324Z" },
+    { url = "https://files.pythonhosted.org/packages/13/d3/cca42fe166d1c6e4d5b80e530b7949104d10e17508a90ae202dac205ce2a/pyarrow-24.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:9700ebd9a51f5895ce75ff4ac4b3c47a7d4b42bc618be8e713e5d56bacf5f931", size = 48844765, upload-time = "2026-04-21T10:50:55.579Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/49/942c3b79878ba928324d1e17c274ed84581db8c0a749b24bcf4cbdf15bd3/pyarrow-24.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d8ddd2768da81d3ee08cfea9b597f4abb4e8e1dc8ae7e204b608d23a0d3ab699", size = 49471890, upload-time = "2026-04-21T10:51:02.439Z" },
+    { url = "https://files.pythonhosted.org/packages/76/97/ff71431000a75d84135a1ace5ca4ba11726a231a8007bbb320a4c54075d5/pyarrow-24.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:61a3d7eaa97a14768b542f3d284dc6400dd2470d9f080708b13cd46b6ae18136", size = 51932250, upload-time = "2026-04-21T10:51:10.576Z" },
+    { url = "https://files.pythonhosted.org/packages/51/be/6f79d55816d5c22557cf27533543d5d70dfe692adfbee4b99f2760674f38/pyarrow-24.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c91d00057f23b8d353039520dc3a6c09d8608164c692e9f59a175a42b2ae0c19", size = 28131282, upload-time = "2026-04-21T10:51:16.815Z" },
+]
+
+[[package]]
+name = "pybind11"
+version = "3.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/f0/35145a3c3baffeef55d4b8324caa33abaa8fa56ab345ecd4b2211d09163e/pybind11-3.0.4.tar.gz", hash = "sha256:3286b59c8a774b9ee650169302dd5a4eedc30a8617905a0560dd8ee44775130c", size = 589533, upload-time = "2026-04-19T03:08:15.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/06/c3a23c9a0263b136c519f033a58d4641e73065fefc7754e9667ec206d992/pybind11-3.0.4-py3-none-any.whl", hash = "sha256:961720ee652da51d531b7b2451a6bd2bc042b0106e6d9baa48ecb7d58034ce63", size = 314166, upload-time = "2026-04-19T03:08:14.091Z" },
+]
+
 [[package]]
 name = "pydantic"
 version = "2.13.3"
@@ -1025,6 +1270,69 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" },
 ]
 
+[[package]]
+name = "rapidfuzz"
+version = "3.14.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/21/ef6157213316e85790041254259907eb722e00b03480256c0545d98acd33/rapidfuzz-3.14.5.tar.gz", hash = "sha256:ba10ac57884ce82112f7ed910b67e7fb6072d8ef2c06e30dc63c0f604a112e0e", size = 57901753, upload-time = "2026-04-07T11:16:31.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d3/e3/574435c6aafb80254c191ef40d7aca2cb2bb97a095ec9395e9fa59ac307a/rapidfuzz-3.14.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0d3378f471ef440473a396ce2f8e97ee12f89a78b495540e0a5617bbfe895638", size = 1944601, upload-time = "2026-04-07T11:14:18.771Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/1f/fbad3102a255ecc112ce9a7e779bacab7fd14398217be8868dc9082ba363/rapidfuzz-3.14.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e910eebca9fd0eba245c0555e764597e8a0cccb673a92da2dc2397050725f48", size = 1164293, upload-time = "2026-04-07T11:14:20.534Z" },
+    { url = "https://files.pythonhosted.org/packages/88/37/a3eb7ff6121ed3a5f199a8c38cc86c8e481816f879cb0e0b738b078c9a7e/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:01550fe5f60fd176aa66b7611289d46dc4aa4b1b904874c7b6d1d54e581c5ec1", size = 1371999, upload-time = "2026-04-07T11:14:22.63Z" },
+    { url = "https://files.pythonhosted.org/packages/79/72/97a9728c711c7c1b06e107d3f0623880fb4ef90e147ed13c551a1730e7cc/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48bee0b91bebfaec41e1081e351000659ab7570cc4598d617aa04d5bf827f9e6", size = 3145715, upload-time = "2026-04-07T11:14:24.508Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/54/d5caabbea233ac90c286c87c260e49d7641467e87438a18d858e41c82e91/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:7e580cb04ad849ae9b786fa21383c6b994b6e6c1444ad1cb9f22392759d72741", size = 1456304, upload-time = "2026-04-07T11:14:26.515Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/a7/2d1a81250ac8c01a0100c026018e76f0e7a097ff63e4c553e02a6938c6fb/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:09d6c9ba091854f07817055d795d604179c12a8f308ba4c7d56f3719dfea1646", size = 2389089, upload-time = "2026-04-07T11:14:28.635Z" },
+    { url = "https://files.pythonhosted.org/packages/65/0d/c47c3872203ae88e6506997c0b576ad731f5261daa25d559be09c9756658/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1e989f86113be66574113b9c7bdf4793f3f863d248e47d911b355e05ca6b6b10", size = 2493404, upload-time = "2026-04-07T11:14:30.577Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/2f/71e0a5a3130792146c8a200a2dd1e52aa16f7c1074012e17f2601eea9a90/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ebd1a18e2e47bc0b292a07e6ed9c3642f8aaa672d12253885f599b50807a4f9", size = 4251709, upload-time = "2026-04-07T11:14:32.451Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/d39874901abacef325adb5b34ae416817c8486dfb4fb87c7a9b74ec5b072/rapidfuzz-3.14.5-cp312-cp312-win32.whl", hash = "sha256:9981d38a703b86f0e315a3cd229fd1906fe1d91c989ed121fb975b3c849f89f5", size = 1710069, upload-time = "2026-04-07T11:14:34.37Z" },
+    { url = "https://files.pythonhosted.org/packages/85/0b/f65572c53de8a1c704bda707f63a447b67bdbe95d7cdc70d18885e191df5/rapidfuzz-3.14.5-cp312-cp312-win_amd64.whl", hash = "sha256:d8375e3da319593389727c3187ccaf3e0e84199accc530866b8e0f2b79af05e9", size = 1540630, upload-time = "2026-04-07T11:14:36.287Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/c3/143be3a578f989758cae516f3270d5cbb49783a7bfdf57cc27a670e00456/rapidfuzz-3.14.5-cp312-cp312-win_arm64.whl", hash = "sha256:478b59bb018a6780d73f33e38d0b3ec5e968a6c1ed42876b993dd456b7aa20e8", size = 813137, upload-time = "2026-04-07T11:14:38.289Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/252803f2010ba699618cdc048b6e1f7cc1f433c08b4a9a17579b92ab0142/rapidfuzz-3.14.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ebd8fd343bf8492a1e60bcb6dc99f90f74f65d98d8241a6b3e1fed225b76ecd6", size = 1940205, upload-time = "2026-04-07T11:14:40.319Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/59/b2afd98e41af9cd54554a4c1c423d84cdd60e6b1c0a09496f033b55f60ec/rapidfuzz-3.14.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6737b35d5af7479c5bf9710f7b17edd9d2c43128d974d25fb4ea653e42c64609", size = 1159639, upload-time = "2026-04-07T11:14:42.52Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/7aa7e62c4c516a7af322ed0c4f0774208b72d457d0cfec808bad0df12f4a/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b002c7994cc9f2bc9d9856f0fbaee6e8072c983873846c92f25cefba5b2a925f", size = 1367194, upload-time = "2026-04-07T11:14:44.25Z" },
+    { url = "https://files.pythonhosted.org/packages/90/79/2fc252a63bc91d3c3b234d0a3a6ad4ebc460037a23cdcdaf9285f986e6c9/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:17a34330cd2a538c1ce5d400b61ba358c5b72c654b928ff87b362e88f8b864c7", size = 3151805, upload-time = "2026-04-07T11:14:46.21Z" },
+    { url = "https://files.pythonhosted.org/packages/17/54/0c83508f2683ea70e2d05f8527eb07328acf7bb1e9d97a3bece5702378e7/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:95d937e74c1a7a1287dfb03b62a827be08ede10a155cf1af73bbf47f2b73ee6e", size = 1455667, upload-time = "2026-04-07T11:14:47.991Z" },
+    { url = "https://files.pythonhosted.org/packages/71/1b/070175e873177814d58850a01ebe80e20ae11e93eb4da894d563988660fa/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:46b92a9970dcc34f0096901c792644094cab49554ac3547f35e3aebbdf0a3610", size = 2388246, upload-time = "2026-04-07T11:14:50.098Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/dd/77caf7aaf9c2be050ad1f128d7c24ff0f59079aa62c5f62f9df41c0af45e/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e012177c8e8a8a0754ae0d6027d63042aa5ff036d9f40f07cb3466a6082e21b8", size = 2494333, upload-time = "2026-04-07T11:14:52.303Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/e2/dd7e1f2aa31a8fbbfc16b0610af1d770ffaf1287490f3c8c5b1c52da264f/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a2ae6f53f99c9a0eca7a0afc5b4e45fc73bc1dd4ac74c00509031d76df80ed98", size = 4258579, upload-time = "2026-04-07T11:14:54.538Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/0a/ac99e1ba347ba0e85e0bb60b74231d55fb93c0eff43f2920ccb413d0be08/rapidfuzz-3.14.5-cp313-cp313-win32.whl", hash = "sha256:4a60f0057231188e3bd30216f7b4e0f279b11fa4ec818bb6c1d9f014d1562fbc", size = 1709231, upload-time = "2026-04-07T11:14:56.524Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/cb/0e251d731b3166378644238e8f0cf9e89858c024e19f75ca9f7e3ae83fd5/rapidfuzz-3.14.5-cp313-cp313-win_amd64.whl", hash = "sha256:11bfc2ed8fbe4ab86bd516fadefab126f90e6dcadffa761739fcb304707dfd35", size = 1538519, upload-time = "2026-04-07T11:14:58.635Z" },
+    { url = "https://files.pythonhosted.org/packages/30/6f/4548132acc947db6d5346a248e44a8b3a22d608ef30e770fb578caaf2d00/rapidfuzz-3.14.5-cp313-cp313-win_arm64.whl", hash = "sha256:b486b5218808f6f4dc471b114b1054e63553db69705c97da0271f47bd706aedd", size = 812628, upload-time = "2026-04-07T11:15:00.552Z" },
+    { url = "https://files.pythonhosted.org/packages/00/60/69b177577290c5eab892c6f75fe89c3aff3f9ae80298a78d9372b1cecb9a/rapidfuzz-3.14.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:39ef8658aaf67d51667e7bdaf7096f432333377d8302ac43c70b5df8a4cf89b8", size = 1970231, upload-time = "2026-04-07T11:15:02.603Z" },
+    { url = "https://files.pythonhosted.org/packages/48/38/2fd790052659cc4e2907b63c25433f0987864b445c1aeec1a302ef5ad948/rapidfuzz-3.14.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:9ad37a0be705b544af6296da8edddc260d10a8ae5462530fc9991f66498bb1f9", size = 1194394, upload-time = "2026-04-07T11:15:04.572Z" },
+    { url = "https://files.pythonhosted.org/packages/80/f4/28430ad8472fc3536e8ebd51a864a226e979cfe924c6e3f83d111373aa74/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d45e06f60729e07d9b20c205f7e5cff90b6ef2584e852eecf46e045aea69627d", size = 1377051, upload-time = "2026-04-07T11:15:06.728Z" },
+    { url = "https://files.pythonhosted.org/packages/77/7e/9aeacabcfd1e77397968362e5b98fe14248b8307011136b17daf99752a8e/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e52da10236aa6212de71b9e170bace65b64b129c0dea7fc243d6c9ce976f5074", size = 3160565, upload-time = "2026-04-07T11:15:08.667Z" },
+    { url = "https://files.pythonhosted.org/packages/56/f4/db4dd7be0cd2f2022117ac5407d905f435d60e48baaea313a567ad27e865/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:440d30faaf682ca496170a7f0cc5453ec942e3e079f0fd802c9a7f938dfb50a3", size = 1442113, upload-time = "2026-04-07T11:15:11.138Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/99/0e9f6aa57f3e32a767216f797e56dc96b720fcecfb9d8ee907ecc82f8d66/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:56227a61fd3d17b0cd9793132431f3a3d07c8654be96794ba9f89fe0fc8b2d09", size = 2396618, upload-time = "2026-04-07T11:15:13.154Z" },
+    { url = "https://files.pythonhosted.org/packages/60/94/44a78e39ffce17cbdd3e2b53b696acc751d5d153be0f499d052b07a4d904/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:2e83cd2e25bb4edd97b689d9979d9c3acccdaaf26ceac08212ceece202febcfa", size = 2478220, upload-time = "2026-04-07T11:15:15.193Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/df/454311469a09a507e9d784a35796742bec22e4cebe75551e2da4e0e290fd/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:af3b859726cd3374287e405e14b9634563c078c5531a4f62375508addebddad1", size = 4265027, upload-time = "2026-04-07T11:15:17.28Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/01/175465a9ab3e3b70ba669058372f009d1d49c1746e2dcd56b69df188d3a5/rapidfuzz-3.14.5-cp313-cp313t-win32.whl", hash = "sha256:8ce1d850b3c0178440efde9e884d98421b5e87ff925f364d6d79e23910d7593f", size = 1766814, upload-time = "2026-04-07T11:15:19.687Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/a0/a9b84a47af06ebed94a1439eb2f02adebfb8628bcd30af1fe3e02f5ef56c/rapidfuzz-3.14.5-cp313-cp313t-win_amd64.whl", hash = "sha256:c84af70bcf34e99aee894e46a0f1ac77f17d0ef828179c387407642e2466d28a", size = 1582448, upload-time = "2026-04-07T11:15:21.98Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/f1/5937800238b3f8248e70860d79f69ba8f73e764fff47e36bc9e2f26dbcc6/rapidfuzz-3.14.5-cp313-cp313t-win_arm64.whl", hash = "sha256:aac0ad28c686a5e72b81668b906c030ee28050b244544b8af68e12fb32543895", size = 832932, upload-time = "2026-04-07T11:15:24.358Z" },
+    { url = "https://files.pythonhosted.org/packages/81/41/aa3ffb3355e62e1bf91f6599b3092e866bc88487a07c524004943c7676df/rapidfuzz-3.14.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1a31cc6d7d03e7318a0974c038959c59e19c752b81115f2e9138b3331cd64d45", size = 1943327, upload-time = "2026-04-07T11:15:26.266Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/e1/c2141f1840a41e07ad2db6f724945f8f8ff3065463899a22939152dd6e09/rapidfuzz-3.14.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0298d357e2bc59d572da4db0bc631009b6f8f6c9bc8c11e99a12b833f16b6575", size = 1161755, upload-time = "2026-04-07T11:15:28.659Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/07/66e753eeaa353161d1d331b7dd517bb349b0bacfebe8496d7b26be26f81f/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:59b3dba758661a318995655435c6ab20a04ade79fa51e75bc8dc107cac8df280", size = 1376571, upload-time = "2026-04-07T11:15:31.225Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/85/9535df0b78ba51f478c9ce7eb6d1f85535cc31fe356773b48fd9d3e563ca/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4900143d82071bdda533b00300c40b14b963ff826b3642cc463b6dd0f036585e", size = 3156468, upload-time = "2026-04-07T11:15:33.428Z" },
+    { url = "https://files.pythonhosted.org/packages/81/ee/b667eb93bba6dc4e0de658edd778e1619dc4d6aab68fa5e5c7f075152735/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:feedf219672eef83ea6be6f3bb093bba396a8560fc75be85ba225f082903df0a", size = 1458311, upload-time = "2026-04-07T11:15:35.557Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/ce/479074f5624364a48df3403c538797ef22d3ac49c19dc76c3f79fcdcc70c/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:419e4397a36e2665ec992d8d64c20ba4b2a42500c76ecadeca78a4f19cb9cc32", size = 2398228, upload-time = "2026-04-07T11:15:37.669Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/15/a8982f649150fffbdcd6f17565974501f6ab33b2795267bffbd4a7ba905b/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:97131ab2be39043054ee28d99e09efe316e6d53449b7e962dfcf3c2de8b2b246", size = 2497226, upload-time = "2026-04-07T11:15:39.857Z" },
+    { url = "https://files.pythonhosted.org/packages/19/52/5267c03ef6759831b7d4625a0c9c06e87baa2fae084b61ac9c388858317b/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:593c00dac4e30231c35bf3b4f1da8ec0998762e9e94425586a5d636fcd57f9d0", size = 4262283, upload-time = "2026-04-07T11:15:42.279Z" },
+    { url = "https://files.pythonhosted.org/packages/71/c0/2579f343a97f5254c43bb5853baccc01488357dcb64a27bcb869b7888a4a/rapidfuzz-3.14.5-cp314-cp314-win32.whl", hash = "sha256:0084b687b02b4e569b46d8d6d4ad25659528e6081cd6d067ca453a69035f07e4", size = 1744614, upload-time = "2026-04-07T11:15:44.498Z" },
+    { url = "https://files.pythonhosted.org/packages/17/eb/8edfed1e80119dc9c35b11df4bc701eea85622ad681fff0263b6961d3224/rapidfuzz-3.14.5-cp314-cp314-win_amd64.whl", hash = "sha256:5dfa89d78f22cd773054caff44827b846161a29f2dcf7e78b8f90d086621e502", size = 1588971, upload-time = "2026-04-07T11:15:46.86Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/04/5676df93c85cfa57a3045d8047318df9f3cd58c7b8a99340dd95f874795e/rapidfuzz-3.14.5-cp314-cp314-win_arm64.whl", hash = "sha256:67f3f9d2b444268ab53e47d31bab89954888d23c04c6789f2c727e51fe4b1d13", size = 834985, upload-time = "2026-04-07T11:15:49.411Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/0d/4a8988cea658fe335048ddef8c876addff1b6daa3c9ca8ad65a5a2196e69/rapidfuzz-3.14.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:77eac0526899b3c3ad1454bb2b03cdb491d67358ec8ef0c9c48bd61b632b431d", size = 1972517, upload-time = "2026-04-07T11:15:51.819Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/a3/f5cfd9965a9d9a9e32249159797c47b5d6299ea6d1629f9126b25f1c10a3/rapidfuzz-3.14.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b9c6bd754d11f6e78ac54e3d86b4b11dc1ba2f13e5fc958899574532897f5a99", size = 1196056, upload-time = "2026-04-07T11:15:54.292Z" },
+    { url = "https://files.pythonhosted.org/packages/64/07/561c2e40cfd10e6630a7b0ac5a2a813aef50d944bcd1f3d260319d659d5b/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:738c96944d076deeaff70e92b65696ab4f7ecb8081d7791c5403a3257dfaf8ff", size = 1374732, upload-time = "2026-04-07T11:15:56.584Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/39/123bb94fee40e2fb3b7c49b80827c7ef42d838e18def3fc2fef5a3cf817a/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4c1bca487a17fe4226b4ffb2d30e799d2b274d692cffa76bd0746f56235fca3", size = 3166902, upload-time = "2026-04-07T11:15:58.768Z" },
+    { url = "https://files.pythonhosted.org/packages/75/0a/45716fafc9fd2e028cf20b5ac5bc704887081cd312f84edb0e325599414b/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:af6a90a4ed2a48fa1a2d17e9d824e6c7c950bea5bad0b707c77fd55751e6bfef", size = 1452130, upload-time = "2026-04-07T11:16:01.453Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/49/4e96c413114398481c0a5b0086af32c364a18613c9a2ea578d17c4bea4ee/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bf5018938208d4597b2e679a4f8cff9fd252f1df53583130ae56281a21801b64", size = 2396308, upload-time = "2026-04-07T11:16:03.588Z" },
+    { url = "https://files.pythonhosted.org/packages/89/b7/49fea9fc6878d59bd259d01dd1972d9b86117992b1c66d9b16f0a65273c3/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c0919d1f89ddf91129906705723118ea09754171e4116f5a5dbc667c7bc9b261", size = 2488210, upload-time = "2026-04-07T11:16:05.871Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/44/a1f732b93ffacbdad077b7c801149549b2938e1bece6addb5ad85ed74df8/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:93d8da883a35116d6813432177f35e570db5b0a5e30ecb0cbd7cb39c815735df", size = 4270621, upload-time = "2026-04-07T11:16:08.483Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/ce/ff942d19fce5385054650bb71a58495ddda299d94661ccc4e6e7fa44868b/rapidfuzz-3.14.5-cp314-cp314t-win32.whl", hash = "sha256:0f23e37019ec07712d58976b1ab2b889f8649a7f7c2f626a2f34ea9139e79279", size = 1803950, upload-time = "2026-04-07T11:16:10.873Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/0f/9aafc63f9661222b819b391c187eed29fc90ad5935f9690e5ecc2d2047a4/rapidfuzz-3.14.5-cp314-cp314t-win_amd64.whl", hash = "sha256:7d5ca9c7832e6879a707296d1463685f7c243a27846227044504741640caec66", size = 1632357, upload-time = "2026-04-07T11:16:13.1Z" },
+    { url = "https://files.pythonhosted.org/packages/70/a6/51fc1b0e61e3326e1c68a61cfd0c6b3c34c843681c4b1eefbf0596f59162/rapidfuzz-3.14.5-cp314-cp314t-win_arm64.whl", hash = "sha256:3e91dcd2549b8f8d843f98ba03a17e01f3d8b72ce942adbbb6761bc58ffce813", size = 855409, upload-time = "2026-04-07T11:16:15.787Z" },
+]
+
 [[package]]
 name = "regex"
 version = "2026.4.4"
@@ -1115,7 +1423,7 @@ wheels = [
 
 [[package]]
 name = "requests"
-version = "2.33.0"
+version = "2.33.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -1123,9 +1431,9 @@ dependencies = [
     { name = "idna" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/34/64/8860370b167a9721e8956ae116825caff829224fbca0ca6e7bf8ddef8430/requests-2.33.0.tar.gz", hash = "sha256:c7ebc5e8b0f21837386ad0e1c8fe8b829fa5f544d8df3b2253bff14ef29d7652", size = 134232, upload-time = "2026-03-25T15:10:41.586Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/a4/98b9c7c6428a668bf7e42ebb7c79d576a1c3c1e3ae2d47e674b468388871/requests-2.33.1.tar.gz", hash = "sha256:18817f8c57c6263968bc123d237e3b8b08ac046f5456bd1e307ee8f4250d3517", size = 134120, upload-time = "2026-03-30T16:09:15.531Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/56/5d/c814546c2333ceea4ba42262d8c4d55763003e767fa169adc693bd524478/requests-2.33.0-py3-none-any.whl", hash = "sha256:3324635456fa185245e24865e810cecec7b4caf933d7eb133dcde67d48cee69b", size = 65017, upload-time = "2026-03-25T15:10:40.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" },
 ]
 
 [[package]]
@@ -1233,6 +1541,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/07/39/338d9219c4e87f3e708f18857ecd24d22a0c3094752393319553096b98af/scipy-1.17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:200e1050faffacc162be6a486a984a0497866ec54149a01270adc8a59b7c7d21", size = 25489165, upload-time = "2026-02-23T00:22:29.563Z" },
 ]
 
+[[package]]
+name = "setuptools"
+version = "82.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4f/db/cfac1baf10650ab4d1c111714410d2fbb77ac5a616db26775db562c8fab2/setuptools-82.0.1.tar.gz", hash = "sha256:7d872682c5d01cfde07da7bccc7b65469d3dca203318515ada1de5eda35efbf9", size = 1152316, upload-time = "2026-03-09T12:47:17.221Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/76/f789f7a86709c6b087c5a2f52f911838cad707cc613162401badc665acfe/setuptools-82.0.1-py3-none-any.whl", hash = "sha256:a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb", size = 1006223, upload-time = "2026-03-09T12:47:15.026Z" },
+]
+
 [[package]]
 name = "six"
 version = "1.17.0"
@@ -1351,11 +1668,11 @@ wheels = [
 
 [[package]]
 name = "tzdata"
-version = "2025.3"
+version = "2026.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35cb345486df41110984ea67ae69dddbc0e8a100999493/tzdata-2026.2.tar.gz", hash = "sha256:9173fde7d80d9018e02a662e168e5a2d04f87c41ea174b139fbef642eda62d10", size = 198254, upload-time = "2026-04-24T15:22:08.651Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" },
 ]
 
 [[package]]