Merge pull request 'documentation' (#1) from documentation into dev

Reviewed-on: #1

.gitignore

@@ -0,0 +1,14 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+main.py
+# Virtual environments
+.venv
+.idea
+
+# etc files
+*.txt

.python-version

@@ -0,0 +1 @@
+3.13

LICENSE

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

README.md

@@ -0,0 +1,262 @@
+# oxipy
+
+`oxipy` is a Python client for the [Oxidized](https://github.com/ytti/oxidized) API.
+It fetches device configurations from Oxidized and parses them into structured
+Pydantic models using bundled TTP templates.
+
+Oxidized remains responsible for collecting and storing configuration backups.
+`oxipy` focuses on consuming those backups from Python code and exposing common
+configuration sections such as system data, interfaces, and VLANs.
+
+## Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [API Reference](#api-reference)
+  - [OxiAPI](#oxiapi)
+  - [NodeView](#nodeview)
+  - [NodeConfig](#nodeconfig)
+  - [ModelView](#modelview)
+- [Supported Devices](#supported-devices)
+- [Additional Documentation](#additional-documentation)
+
+## Installation
+
+The package is distributed from the source repository. It is not published to
+PyPI yet.
+
+**Requirements:** Python 3.10+
+
+### From GitHub Source
+
+Install directly from the repository:
+
+```bash
+pip install git+https://github.com/sttarsky/oxipy.git
+```
+
+Install a specific tag or branch:
+
+```bash
+pip install git+https://github.com/sttarsky/oxipy.git@v0.1.0
+pip install git+https://github.com/sttarsky/oxipy.git@dev
+```
+
+For local development:
+
+```bash
+git clone https://github.com/sttarsky/oxipy
+cd oxipy
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from oxi import OxiAPI
+
+api = OxiAPI(url="https://oxi.example.com", verify=False)
+
+node = api.node("Router_HOME")
+
+print(node.ip)
+print(node.model)
+print(node.full_name)
+
+print(node.config.system.model)
+print(node.config.interfaces.dump_json())
+print(node.config.vlans.dump_json())
+```
+
+Example output:
+
+```text
+192.168.1.1
+keenetic
+router/HQ
+Sprinter (KN-3710)
+[
+  {"interface": "Bridge1", "ip_address": "192.168.1.1", "mask": 24, "description": "Guest network"},
+  {"interface": "Bridge0", "ip_address": "172.16.1.1", "mask": 24, "description": "Home network"}
+]
+[
+  {"vlan_id": 1, "description": "Home VLAN"},
+  {"vlan_id": 2, "description": "Ethernet uplink"},
+  {"vlan_id": 3, "description": "Home network"}
+]
+```
+
+## API Reference
+
+### OxiAPI
+
+`OxiAPI` is the entry point. It manages the HTTP session and provides access to
+Oxidized nodes.
+
+```python
+OxiAPI(
+    url: str,
+    username: str | None = None,
+    password: str | None = None,
+    verify: bool = True,
+)
+```
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `url` | `str` | Base URL of the Oxidized API, for example `https://oxi.example.com`. |
+| `username` | `str | None` | Optional username for HTTP basic authentication. |
+| `password` | `str | None` | Optional password for HTTP basic authentication. |
+| `verify` | `bool` | Whether to verify TLS certificates. Defaults to `True`. |
+
+Example:
+
+```python
+# Without authentication
+api = OxiAPI(url="https://oxi.example.com")
+
+# With HTTP basic authentication
+api = OxiAPI(
+    url="https://oxi.example.com",
+    username="admin",
+    password="secret",
+)
+
+# As a context manager. The HTTP session is closed automatically.
+with OxiAPI(url="https://oxi.example.com") as api:
+    node = api.node("HQ")
+    print(node.ip)
+```
+
+#### `api.node(name)`
+
+Returns a `NodeView` for the requested Oxidized node.
+
+```python
+node = api.node("HQ")
+```
+
+### NodeView
+
+`NodeView` represents one network device. It contains metadata returned by
+Oxidized and lazy access to the fetched configuration.
+
+| Property | Type | Description |
+| --- | --- | --- |
+| `ip` | `str` | Node IP address. |
+| `full_name` | `str` | Full node name in Oxidized. |
+| `group` | `str` | Oxidized group the node belongs to. |
+| `model` | `str` | Device model key used to select a parser. |
+| `config` | `NodeConfig` | Device configuration, fetched and parsed on first access. |
+
+Example:
+
+```python
+node = api.node("HQ")
+
+print(node.ip)
+print(node.group)
+print(node.model)
+```
+
+### NodeConfig
+
+`NodeConfig` fetches and parses a device configuration. The parser is selected
+from the device registry by the node `model` value returned by Oxidized.
+
+Configuration sections are exposed through properties that return `ModelView`
+objects.
+
+| Property | Returns | Description |
+| --- | --- | --- |
+| `system` | `ModelView[System]` | System information. |
+| `interfaces` | `ModelView[list[Interfaces]]` | Parsed interface list. |
+| `vlans` | `ModelView[list[Vlans]]` | Parsed VLAN list, if the template provides VLAN data. |
+| `text` | `str` | Raw configuration text fetched from Oxidized. |
+
+Example:
+
+```python
+cfg = node.config
+
+print(cfg.system.model)
+print(cfg.system.serial_number)
+print(cfg.system.version)
+
+for iface in cfg.interfaces:
+    print(iface.name, iface.ip_address, iface.mask)
+
+first_iface = cfg.interfaces[0]
+print(first_iface.name)
+print(len(cfg.interfaces))
+
+print(cfg.interfaces.dump_json())
+print(cfg.vlans.dump_json())
+print(cfg.system.dump_json())
+
+print(cfg.text)
+```
+
+`NodeConfig` also provides `dump()` and `dump_json()` methods for the whole
+parsed device object.
+
+### ModelView
+
+`ModelView` wraps either a single Pydantic model or a list of Pydantic models.
+It provides serialization, iteration for list sections, and transparent access
+to model attributes.
+
+| Method / operation | Applies to | Description |
+| --- | --- | --- |
+| `.dump()` | single model and list | Returns a Python `dict` or `list` using aliases. |
+| `.dump_json()` | single model and list | Returns a JSON string using aliases. |
+| `.<attr>` | single model and list | Proxies attribute access to the wrapped model. |
+| `iter(view)` | list only | Iterates over wrapped models. |
+| `len(view)` | list only | Returns the number of wrapped models. |
+| `view[i]` | list only | Returns an item or slice. |
+
+`__iter__`, `__len__`, and `__getitem__` are available only for list-backed
+sections such as `interfaces` and `vlans`. Calling them on `system` raises
+`TypeError`.
+
+Examples:
+
+```python
+system = node.config.system
+print(system.dump_json())
+print(system.model)
+print(system.serial_number)
+
+interfaces = node.config.interfaces
+
+for iface in interfaces:
+    print(iface.name, iface.ip_address)
+
+print(len(interfaces))
+print(interfaces[0])
+print(interfaces[:3])
+print(interfaces.dump())
+```
+
+## Supported Devices
+
+Registry keys are compared with the Oxidized node `model` value
+case-insensitively.
+
+| Device | Registry keys |
+| --- | --- |
+| Keenetic | `ndms`, `keenetic`, `keeneticos` |
+| MikroTik | `routeros`, `ros`, `mikrotik` |
+| Qtech | `qtech` |
+| Huawei | `huawei`, `vrp` |
+| Eltex | `eltex` |
+| H3C | `h3c` |
+| Quasar | `qos`, `quasar` |
+
+You can add support for another device family by creating a new device model
+and TTP template. See [Extending Device Models](docs/extending-models.md).
+
+## Additional Documentation
+
+- [Writing TTP Templates](docs/templates.md)
+- [Extending Device Models](docs/extending-models.md)

docs/extending-models.md

@@ -0,0 +1,326 @@
+# Extending Device Models
+
+`oxipy` parses an Oxidized configuration in two stages. A TTP template first
+extracts raw dictionaries from the text, then a device model normalizes those
+dictionaries before Pydantic validates them against the public contract.
+
+Device models extend `BaseDevice`. Override `system()`, `interfaces()`, or
+`vlans()` when the raw TTP result needs vendor-specific cleanup.
+
+## Contents
+
+- [Data Flow](#data-flow)
+- [Registering a Device](#registering-a-device)
+- [Method Overrides](#method-overrides)
+  - [interfaces()](#interfaces)
+  - [vlans()](#vlans)
+  - [system()](#system)
+- [Complete Example](#complete-example)
+- [Expected Contract](#expected-contract)
+
+## Data Flow
+
+```text
+configuration text
+        |
+        v
+   TTP template (.ttp)
+        |
+        v
+   self.raw: dict
+        |
+        +--> system()     -> dict
+        +--> interfaces() -> list[dict]
+        +--> vlans()      -> list[dict]
+        |
+        v
+   Pydantic validation
+        |
+        v
+   Device(system, interfaces, vlans)
+```
+
+The extension methods are intentionally small. The base implementation returns
+data directly from `self.raw`:
+
+```python
+def interfaces(self) -> list[dict]:
+    return self.raw.get("interfaces", [])
+
+def vlans(self) -> list[dict]:
+    return self.raw.get("vlans", [])
+
+def system(self) -> dict:
+    return self.raw.get("system", None)
+```
+
+## Registering a Device
+
+To add support for a new vendor:
+
+1. Create a Python file in `oxi/interfaces/models/`, for example `cisco.py`.
+2. Create a template in `oxi/interfaces/models/templates/`, for example
+   `cisco.ttp`.
+3. Subclass `BaseDevice` and register it with `@register_parser`.
+
+```python
+from oxi.interfaces import register_parser
+from oxi.interfaces.base import BaseDevice
+
+
+@register_parser(["ios", "cisco", "cisco_ios"])
+class CiscoIOS(BaseDevice):
+    template = "cisco.ttp"
+```
+
+`@register_parser` accepts a string or a list of strings. These values are the
+registry keys used to match the Oxidized node `model` field. Matching is
+case-insensitive.
+
+Model modules are imported automatically through `pkgutil` when
+`oxi.interfaces` is loaded, so you do not need to import your model class
+manually.
+
+## Method Overrides
+
+### interfaces()
+
+Override `interfaces()` when you need to:
+
+- Convert dotted decimal netmasks to prefix lengths.
+- Decode escaped descriptions.
+- Rename keys that do not match the contract.
+- Filter service-only interfaces.
+
+Example: convert a netmask to a prefix length.
+
+```python
+from ipaddress import ip_interface
+from oxi.interfaces import register_parser
+from oxi.interfaces.base import BaseDevice
+
+
+@register_parser(["myvendor"])
+class MyVendor(BaseDevice):
+    template = "myvendor.ttp"
+
+    def interfaces(self) -> list[dict]:
+        result = []
+        for item in self.raw.get("interfaces", []):
+            if item.get("ip_address") and item.get("netmask"):
+                iface = ip_interface(f"{item['ip_address']}/{item['netmask']}")
+                item["mask"] = iface.network.prefixlen
+                item.pop("netmask", None)
+            result.append(item)
+        return result
+```
+
+Example: filter management interfaces.
+
+```python
+def interfaces(self) -> list[dict]:
+    return [
+        item for item in self.raw.get("interfaces", [])
+        if not item.get("interface", "").startswith("Mgmt")
+    ]
+```
+
+Example: decode escaped UTF-8 descriptions.
+
+```python
+def _decode_utf(self, text: str) -> str:
+    if "\\x" in text:
+        return (
+            text.strip('"')
+            .encode("utf-8")
+            .decode("unicode_escape")
+            .encode("latin1")
+            .decode("utf-8")
+        )
+    return text
+
+
+def interfaces(self) -> list[dict]:
+    interfaces = self.raw.get("interfaces", [])
+    for item in interfaces:
+        if item.get("description"):
+            item["description"] = self._decode_utf(item["description"])
+    return interfaces
+```
+
+### vlans()
+
+Override `vlans()` to normalize VLAN IDs, expand compressed ranges, decode
+names, or merge details from multiple template groups.
+
+Example: add a generated VLAN name.
+
+```python
+def vlans(self) -> list[dict]:
+    result = []
+    for item in self.raw.get("vlans", []):
+        item["description"] = f"VLAN_{item.get('vlan_id', '?')}"
+        result.append(item)
+    return result
+```
+
+Example: merge data from another raw group.
+
+```python
+def vlans(self) -> list[dict]:
+    vlans = {item["vlan_id"]: item for item in self.raw.get("vlans", [])}
+    for extra in self.raw.get("vlan_details", []):
+        vlan_id = extra.get("vlan_id")
+        if vlan_id in vlans:
+            vlans[vlan_id].update(extra)
+    return list(vlans.values())
+```
+
+Example: expand a comma-separated VLAN range.
+
+```python
+def _expand_vlan_range(value: str) -> list[str]:
+    result = []
+    for part in value.split(","):
+        if "-" not in part:
+            result.append(part.strip())
+            continue
+        start, end = (int(item) for item in part.split("-", 1))
+        result.extend(str(vlan_id) for vlan_id in range(start, end + 1))
+    return result
+```
+
+### system()
+
+Override `system()` when the system section needs computed fields or data from
+another raw group.
+
+Example: assemble a serial number from two fields.
+
+```python
+def system(self) -> dict:
+    raw_system = self.raw.get("system", {})
+    part1 = raw_system.get("serial_part1", "")
+    part2 = raw_system.get("serial_part2", "")
+    raw_system["serial_number"] = f"{part1}-{part2}"
+    return raw_system
+```
+
+Example: normalize a version string.
+
+```python
+def system(self) -> dict:
+    raw_system = self.raw.get("system", {})
+    version = raw_system.get("version", "")
+    raw_system["version"] = version.split()[0] if version else version
+    return raw_system
+```
+
+## Complete Example
+
+Assume a Cisco IOS-like device where:
+
+- IP address and netmask are separated by a space.
+- Interface descriptions can contain several words.
+- System fields are present in separate lines.
+
+Template: `oxi/interfaces/models/templates/cisco.ttp`
+
+```xml
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": "",
+    "version": ""
+}
+</vars>
+
+<group name="system" default="default_system">
+Cisco IOS Software, {{ ignore }} Version {{ version }},{{ ignore('.*') }}
+Model Number         : {{ model }}
+System serial number : {{ serial_number }}
+</group>
+
+<group name="interfaces">
+interface {{ interface | _start_ }}
+ description {{ description | ORPHRASE }}
+ ip address {{ ip_address }} {{ netmask }}
+</group>
+
+<group name="vlans">
+vlan {{ vlan_id | _start_ }}
+ name {{ name | ORPHRASE }}
+</group>
+```
+
+Device model: `oxi/interfaces/models/cisco.py`
+
+```python
+from ipaddress import ip_interface
+from oxi.interfaces import register_parser
+from oxi.interfaces.base import BaseDevice
+
+
+@register_parser(["ios", "cisco", "cisco_ios"])
+class CiscoIOS(BaseDevice):
+    template = "cisco.ttp"
+
+    def interfaces(self) -> list[dict]:
+        result = []
+        for item in self.raw.get("interfaces", []):
+            if item.get("ip_address") and item.get("netmask"):
+                iface = ip_interface(f"{item['ip_address']}/{item['netmask']}")
+                item["mask"] = iface.network.prefixlen
+                item.pop("netmask", None)
+            if item.get("interface", "").startswith("Mgmt"):
+                continue
+            result.append(item)
+        return result
+
+    def system(self) -> dict:
+        raw_system = self.raw.get("system", {})
+        if raw_system.get("model"):
+            raw_system["model"] = raw_system["model"].strip()
+        return raw_system
+```
+
+## Expected Contract
+
+Methods must return structures accepted by `oxi.interfaces.contract`.
+
+### `system() -> dict`
+
+```python
+{
+    "model": "RB951Ui-2nD",
+    "serial_number": "B88C0B31117B",
+    "version": "7.12.1",
+}
+```
+
+### `interfaces() -> list[dict]`
+
+```python
+[
+    {
+        "interface": "ether1",
+        "ip_address": "192.168.1.1",
+        "mask": 24,
+        "description": "LAN",
+    },
+]
+```
+
+### `vlans() -> list[dict]`
+
+```python
+[
+    {
+        "vlan_id": 10,
+        "description": "MGMT",
+    },
+]
+```
+
+The Pydantic models use `populate_by_name=True` for aliased models, so both
+field names and aliases are accepted where aliases exist.

docs/templates.md

@@ -0,0 +1,299 @@
+# Writing TTP Templates
+
+`oxipy` uses [TTP (Template Text Parser)](https://ttp.readthedocs.io/) to turn
+network device configurations fetched from Oxidized into structured data.
+Templates are stored in `oxi/interfaces/models/templates/`.
+
+## Contents
+
+- [Template Structure](#template-structure)
+- [Required Groups](#required-groups)
+- [The system Group](#the-system-group)
+- [The interfaces Group](#the-interfaces-group)
+- [The vlans Group](#the-vlans-group)
+- [Useful TTP Features](#useful-ttp-features)
+- [Default Variables](#default-variables)
+- [Full Example](#full-example)
+- [Validation](#validation)
+
+## Template Structure
+
+Each template is a `.ttp` file with a small set of conventional blocks:
+
+```xml
+<doc>
+    Optional template documentation.
+</doc>
+
+<vars>
+    <!-- Default values for groups. -->
+</vars>
+
+<group name="system">
+    <!-- Rules for system information. -->
+</group>
+
+<group name="interfaces">
+    <!-- Rules for interfaces. -->
+</group>
+
+<group name="vlans">
+    <!-- Optional rules for VLANs. -->
+</group>
+```
+
+Use `oxi/interfaces/models/templates/_template.ttp` as the starting point for a
+new parser.
+
+## Required Groups
+
+The framework requires two groups in every template:
+
+| Group | Required | Description |
+| --- | --- | --- |
+| `system` | Yes | Device system information. |
+| `interfaces` | Yes | Interface configuration. |
+| `vlans` | No | VLAN configuration. |
+
+If a required group is missing from the template or from the TTP result,
+`BaseDevice` raises `ValueError`.
+
+If a template declares an optional `vlans` group, `oxipy` expects TTP to return
+that group. Omit the group completely for devices where VLAN parsing is not
+implemented.
+
+## The system Group
+
+The `system` group must return one dictionary with these fields:
+
+| Field | Type | Required | Description |
+| --- | --- | --- | --- |
+| `model` | `str` | Yes | Device model. |
+| `serial_number` | `str` | Yes | Device serial number. |
+| `version` | `str` | Yes | Firmware, software, or build version chosen by the parser. |
+
+Example for MikroTik:
+
+```text
+# version: 7.12.1 (stable)
+# model = RB951Ui-2nD
+# serial number = B88C0B31117B
+```
+
+```xml
+<group name="system">
+# version: {{ version }}{{ ignore('.*') }}
+# model = {{ model }}
+# serial number = {{ serial_number }}
+</group>
+```
+
+Example for Keenetic:
+
+```text
+! release: 4.1.7.1-1
+! model: Keenetic Extra
+! hw_version: F02B4E7A1C90
+```
+
+```xml
+<group name="system">
+! release: {{ version }}
+! model: {{ model | ORPHRASE }}
+! hw_version: {{ serial_number }}
+</group>
+```
+
+## The interfaces Group
+
+The `interfaces` group must return a list of dictionaries. Each dictionary
+describes one interface.
+
+The `Interfaces` contract expects these fields:
+
+| Contract field | TTP name / alias | Type | Required |
+| --- | --- | --- | --- |
+| `name` | `interface` | `str` | Yes |
+| `ip_address` | `ip_address` | `IPv4Address | None` | No |
+| `mask` | `mask` | `int | None` | No |
+| `description` | `description` | `str | None` | No |
+
+The Pydantic field `name` has the alias `interface`, so templates should usually
+emit `interface`. You can also emit `name` because the models allow population
+by field name, or you can normalize keys in the device class by overriding
+`interfaces()`.
+
+Example for MikroTik:
+
+```text
+/ip address
+add address=192.168.1.1/24 interface=ether1 network=192.168.1.0
+add address=10.0.0.1/30 comment="WAN link" interface=ether2 network=10.0.0.0
+```
+
+```xml
+<group name="interfaces">
+/ip address
+add address={{ ip_address | _start_ }}/{{ mask }} interface={{ interface }} network={{ network }}
+add address={{ ip_address | _start_ }}/{{ mask }} comment={{ description | ORPHRASE | strip('"') }} interface={{ interface }} network={{ network }}
+</group>
+```
+
+Example for CLI-style devices:
+
+```text
+interface Vlanif120
+ description SSH
+ ip address 10.26.196.254 255.255.255.0
+```
+
+```xml
+<group name="interfaces">
+interface {{ interface | _start_ }}
+ description {{ description | ORPHRASE }}
+ ip address {{ ip_address }} {{ mask | to_cidr }}
+</group>
+```
+
+Use TTP's `to_cidr` formatter when the device uses dotted decimal masks.
+
+## The vlans Group
+
+The `vlans` group is optional. If it is declared, it must return a list of VLAN
+dictionaries.
+
+The `Vlans` contract expects these fields:
+
+| Contract field | Alias | Type | Required |
+| --- | --- | --- | --- |
+| `vlan_id` | none | `int` | Yes |
+| `name` | `description` | `str | None` | No |
+
+`name` has the alias `description`, so either key is accepted. Existing parsers
+use both forms depending on the vendor format.
+
+Example:
+
+```text
+vlan 10
+ name MGMT
+```
+
+```xml
+<group name="vlans">
+vlan {{ vlan_id | _start_ }}
+ name {{ name | ORPHRASE }}
+</group>
+```
+
+For compressed vendor syntax such as `vlan batch 101 to 103 110`, parse the raw
+range in the template and normalize it in the device class when needed.
+
+## Useful TTP Features
+
+### Line markers
+
+| Marker | Description |
+| --- | --- |
+| `_start_` | Starts a new group match from the current line. |
+| `_end_` | Ends the current group match. |
+
+```xml
+interface {{ interface | _start_ }}
+```
+
+### Variable modifiers
+
+| Modifier | Description |
+| --- | --- |
+| `ORPHRASE` | Captures a word or phrase to the end of the line. |
+| `exclude("pattern")` | Skips the match when the captured value contains the pattern. |
+| `strip('"')` | Removes a character from both ends of the captured value. |
+| `replace("old","new")` | Replaces text inside the captured value. |
+| `re("pattern")` | Accepts the value only if it matches the regex. |
+| `ignore` | Captures and discards the value. |
+| `ignore('.*')` | Discards the rest of the line. |
+| `to_cidr` | Converts a dotted decimal netmask to a prefix length. |
+| `unrange("-", ",")` | Expands ranges such as `10-12` using a comma separator. |
+| `split(",")` | Splits a captured string into a list. |
+
+### Template comments
+
+Lines beginning with `##` are TTP comments:
+
+```xml
+## disabled no comment
+add address={{ ip_address | _start_ }}/{{ mask }} interface={{ interface }}
+```
+
+## Default Variables
+
+The `<vars>` block can define default values for a group through the group's
+`default` attribute:
+
+```xml
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": "",
+    "version": ""
+}
+</vars>
+
+<group name="system" default="default_system">
+# version: {{ version }}
+# model = {{ model }}
+# serial number = {{ serial_number }}
+</group>
+```
+
+If the group does not match anything, TTP returns the default dictionary.
+
+## Full Example
+
+This simplified Cisco IOS-style example shows the expected shape of a complete
+template:
+
+```xml
+<doc>
+Cisco IOS running-config parser.
+</doc>
+
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": "",
+    "version": ""
+}
+</vars>
+
+<group name="system" default="default_system">
+Cisco IOS Software, {{ ignore }} Version {{ version }},{{ ignore('.*') }}
+Model Number         : {{ model }}
+System serial number : {{ serial_number }}
+</group>
+
+<group name="interfaces">
+interface {{ interface | _start_ }}
+ description {{ description | ORPHRASE }}
+ ip address {{ ip_address }} {{ mask | to_cidr }}
+</group>
+
+<group name="vlans">
+vlan {{ vlan_id | _start_ }}
+ name {{ name | ORPHRASE }}
+</group>
+```
+
+## Validation
+
+`BaseDevice` performs two validation passes:
+
+1. Template structure validation checks that the template declares the required
+   `system` and `interfaces` groups.
+2. Parse result validation checks that TTP actually returned the required groups
+   for the given configuration.
+
+After that, parsed data is validated by Pydantic models from
+`oxi.interfaces.contract`. Invalid structures raise the original Pydantic
+validation error.

oxi/__init__.py

@@ -0,0 +1,6 @@
+from .core import OxiAPI
+
+
+__all__ = [
+    "OxiAPI",
+]

oxi/adapter.py

@@ -0,0 +1,21 @@
+from typing import Optional
+from requests.adapters import HTTPAdapter
+from urllib3.util import Retry
+
+
+class OxiAdapter(HTTPAdapter):
+    def __init__(
+        self,
+        timeout: Optional[int] = None,
+        max_retries: int = 3,
+        *args,
+        **kwargs,
+    ):
+        self.timeout = timeout
+        retry = Retry(total=max_retries, backoff_factor=0.3)
+        super().__init__(*args, max_retries=retry, **kwargs)
+
+    def send(self, request, **kwargs):
+        if kwargs.get("timeout") is None:
+            kwargs["timeout"] = self.timeout
+        return super().send(request, **kwargs)

oxi/conf.py

@@ -0,0 +1,94 @@
+from functools import cached_property
+import json
+from typing import TYPE_CHECKING, Generic, Iterator, TypeVar
+
+from pydantic import BaseModel
+
+from .interfaces import BaseDevice, device_registry
+
+if TYPE_CHECKING:
+    from requests import Session
+
+TModel = TypeVar("TModel", bound=BaseModel)
+
+
+class ModelView(Generic[TModel]):
+    def __init__(self, model: TModel | list[TModel]):
+        self._model = model
+
+    def dump_json(self) -> str:
+        if isinstance(self._model, list):
+            return json.dumps(
+                [item.model_dump(by_alias=True) for item in self._model],
+                ensure_ascii=False,
+            )
+        return self._model.model_dump_json(by_alias=True)
+
+    def dump(self) -> dict | list:
+        if isinstance(self._model, list):
+            return [item.model_dump(by_alias=True) for item in self._model]
+        return self._model.model_dump(by_alias=True)
+
+    def __iter__(self) -> Iterator[TModel]:
+        if isinstance(self._model, list):
+            return iter(self._model)
+        raise TypeError("This view wraps a single model, not a list")
+
+    def __len__(self) -> int:
+        if isinstance(self._model, list):
+            return len(self._model)
+        raise TypeError("This view wraps a single model, not a list")
+
+    def __getitem__(self, item):
+        if isinstance(self._model, list):
+            return self._model[item]
+        raise TypeError("This view wraps a single model, not a list")
+
+    def __getattr__(self, item):
+        return getattr(self._model, item)
+
+    def __repr__(self) -> str:
+        return repr(self._model)
+
+
+class NodeConfig:
+    def __init__(self, session: "Session", full_name: str, model: str, base_url: str):
+        self._session = session
+        self._full_name = full_name
+        self._model = model.lower()
+        self._url = f"{base_url}/node/fetch/{full_name}"
+        self._device: type[BaseDevice] = device_registry.get(self._model.lower())
+        if self._device is None:
+            raise ValueError(f"Device model '{self._model}' not found in registry")
+        self._parsed_data = self._device(self.text, name=self._full_name).parse()
+
+    @cached_property
+    def _response(self):
+        response = self._session.get(self._url)
+        response.raise_for_status()
+        return response
+
+    @property
+    def text(self):
+        return self._response.text
+
+    def dump_json(self):
+        return self._parsed_data.model_dump_json(by_alias=True)
+
+    def dump(self):
+        return self._parsed_data.model_dump(by_alias=True)
+
+    def __str__(self):
+        return self.text
+
+    @property
+    def vlans(self):
+        return ModelView(self._parsed_data.vlans)
+
+    @property
+    def interfaces(self):
+        return ModelView(self._parsed_data.interfaces)
+
+    @property
+    def system(self):
+        return ModelView(self._parsed_data.system)

oxi/core.py

@@ -0,0 +1,51 @@
+from typing import Optional
+from requests import HTTPError, Session
+
+from oxi.adapter import OxiAdapter
+from oxi.exception import OxiAPIError
+from .node import Node
+
+
+class OxiAPI:
+    def __init__(
+        self,
+        url: str,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        verify: bool = True,
+    ):
+        self.base_url = url.rstrip("/")
+        self._session = self.__create_session(username, password, verify)
+        self.node = Node(self._session, self.base_url)
+
+    def __create_session(
+        self,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        verify: bool = True,
+    ) -> Session:
+        session = Session()
+        adapter = OxiAdapter(timeout=10, max_retries=3)
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        session.verify = verify
+        if username and password:
+            session.auth = (username, password)
+        return session
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def close(self):
+        return self._session.close()
+
+    def reload(self):
+        try:
+            reload_response = self._session.get(f"{self.base_url}/reload")
+            reload_response.raise_for_status()
+        except HTTPError as e:
+            raise OxiAPIError.from_http_error(e, context="Reload Oxidized") from e
+        return reload_response.status_code

oxi/exception.py

@@ -0,0 +1,65 @@
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from requests import HTTPError
+
+_STATUS_MESSAGES: dict[int, str] = {
+    401: "Unauthorized",
+    403: "Forbidden",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+}
+
+
+def _looks_like_node_not_found_html(e: "HTTPError") -> bool:
+    resp = getattr(e, "response", None)
+    if resp is None:
+        return False
+    try:
+        content_type = (resp.headers or {}).get("Content-Type", "")
+    except Exception:
+        content_type = ""
+    if "text/html" not in (content_type or "").lower():
+        return False
+    try:
+        body = (resp.text or "")[:20_000]
+    except Exception:
+        return False
+    return (
+        "Oxidized::NodeNotFound" in body
+        or "NodeNotFound" in body
+        or "<title>Oxidized::NodeNotFound" in body
+    )
+
+
+class OxiAPIError(Exception):
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.message = message
+
+    def __str__(self):
+        if self.status_code is not None:
+            return f"OxiAPIError: {self.args[0]} (HTTP {self.status_code})"
+        return f"OxiAPIError: {self.args[0]}"
+
+    @classmethod
+    def from_http_error(cls, e: "HTTPError", context: str = "") -> "OxiAPIError":
+        resp = getattr(e, "response", None)
+        status = resp.status_code if resp is not None else None
+
+        if status == 500 and _looks_like_node_not_found_html(e):
+            status = 404
+
+        if status == 404:
+            message = f"{context} not found" if context else "Not found"
+        else:
+            base = (
+                (_STATUS_MESSAGES.get(status) if status is not None else None)
+                or (resp.reason if resp is not None else None)
+                or (f"HTTP {status}" if status is not None else "Request failed")
+            )
+            message = f"{context}: {base}" if context else base
+        return cls(message, status)

oxi/interfaces/__init__.py

@@ -0,0 +1,26 @@
+from typing import Callable, Type
+
+from .base import BaseDevice
+
+device_registry = {}
+
+
+def register_parser(
+    name: list[str] | str,
+) -> Callable[[Type[BaseDevice]], Type[BaseDevice]]:
+    def wrapper(cls):
+        name_list = []
+        if isinstance(name, str):
+            name_list.append(name)
+        else:
+            name_list.extend(name)
+        for item in name_list:
+            device_registry[item.lower()] = cls
+        return cls
+
+    return wrapper
+
+
+from . import models  # noqa: E402, F401
+
+__all__ = ["register_parser", "device_registry", "BaseDevice"]

oxi/interfaces/base.py

@@ -0,0 +1,143 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from ttp import ttp
+from oxi.exception import OxiAPIError
+from oxi.interfaces.contract import Device
+import xml.etree.ElementTree as ET
+from oxi.interfaces.contract import Interfaces, System, Vlans
+
+
+class BaseDevice(ABC):
+    _REQUIRED_SECTIONS: frozenset[str] = frozenset({"system", "interfaces"})
+    _OPTIONAL_SECTIONS: frozenset[str] = frozenset({"vlans"})
+
+    def __init__(self, config: str, name: str | None = None):
+        self.config: str = config
+        self.name = name
+
+        self._loaded_template = self._load_template()
+        self._declared_sections = None
+        self._validate_template_groups()
+        self.raw: dict = self._run_ttp()
+
+    @property
+    @abstractmethod
+    def template(self) -> str:
+        """
+        Name of the TTP template file used by this device parser.
+        """
+
+    def vlans(self) -> list[dict]:
+        """
+        Parse VLAN configuration from self.raw['vlans'].
+
+        Expected structure:
+            [{"vlan_id": 10, "description": "MGMT"}, {"vlan_id": 15, "name": "SSH"}, ...]
+
+        Returns:
+            list[Vlans]: VLANs from the vlans section, or an empty list
+                when the section is absent.
+
+        Raises:
+            ValueError: if raw data cannot be validated by the contract.
+        """
+        return self.raw.get("vlans", [])
+
+    def interfaces(self) -> list[dict]:
+        """
+        Parse Interface configuration from self.raw['interfaces'].
+
+        Expected raw structure:
+            [{"interface": "GEthernet1/0/1", "ip_address": "192.168.1.1", "mask": "24", "description": "IPBB interface"}]
+
+        Raises:
+            ValueError: if raw data cannot be validated by the contract.
+        """
+        return self.raw.get("interfaces", [])
+
+    def system(self) -> dict:
+        """
+        Parse System configuration from self.raw['system'].
+
+        Expected raw structure:
+            {"model":"RB951Ui-2nD", serial_number: "B88C0B31117B", "version": "7.12.1"}
+
+        Raises:
+            ValueError: if raw data cannot be validated by the contract.
+        """
+        return self.raw.get("system", None)
+
+    def _validate_contract(self) -> dict:
+        if self.raw is None:
+            msg = (
+                f"Node {self.name} not found"
+                if self.name
+                else "Node not found"
+            )
+            raise OxiAPIError(msg, status_code=404)
+        system_data = self.system()
+        interfaces_data = self.interfaces() or []
+        result = {
+            "system": System(**system_data),
+            "interfaces": [Interfaces(**item) for item in interfaces_data],
+            "vlans": [],
+        }
+
+        if "vlans" in self._declared_sections:
+            if "vlans" not in self.raw:
+                raise ValueError(
+                    f"{self.__class__.__name__}: template '{self.template}' declares optional group "
+                    f"'vlans', but TTP did not return it."
+                )
+            vlans_data = self.vlans() or []
+            result["vlans"] = [Vlans(**item) for item in vlans_data]
+        return result
+
+    def _load_template(self):
+        """Load the device TTP template from models/templates."""
+        path = Path(__file__).parent / "models" / "templates" / self.template
+        if not path.exists():
+            raise FileNotFoundError(f"Template {self.template} not found")
+        return path.read_text(encoding="utf-8")
+
+    def _validate_template_groups(self) -> None:
+        """Validate that the template declares all required groups."""
+        try:
+            root = ET.fromstring(self._loaded_template)
+        except ET.ParseError:
+            root = ET.fromstring(f"<template>{self._loaded_template}</template>")
+
+        declared = {g.get("name") for g in root.iter("group") if g.get("name")}
+        self._declared_sections = declared
+
+        missing_required = self._REQUIRED_SECTIONS - declared
+        if missing_required:
+            raise ValueError(
+                f"{self.__class__.__name__}: template '{self.template}' "
+                f"missing required groups: {sorted(missing_required)}. "
+                f"Declared groups: {sorted(declared)}"
+            )
+
+    def _run_ttp(self) -> dict:
+        """Run the node-not-found check and then parse the config with TTP."""
+        pattern = """node not {{found}}"""
+        parser = ttp(data=self.config, template=pattern)
+        parser.parse()
+        res = parser.result()
+        if res[0][0]:
+            # raise OxiAPIError(f"Node {self.name} not found", status_code=404)
+            return None
+        p = ttp(data=self.config, template=self._loaded_template)
+        p.parse()
+        raw: dict = p.result()[0][0]
+        missing = self._REQUIRED_SECTIONS - raw.keys()
+        if missing:
+            raise ValueError(
+                f"{self.__class__.__name__}: TTP template '{self.template}' "
+                f"did not produce required groups: {sorted(missing)}. "
+                f"Return only: {(raw.keys())}"
+            )
+        return raw
+
+    def parse(self) -> Device:
+        return Device(**self._validate_contract())

oxi/interfaces/contract.py

@@ -0,0 +1,42 @@
+from ipaddress import IPv4Address
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Base(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class System(BaseModel):
+    """
+    Required
+    """
+
+    model: str
+    serial_number: str
+    version: str
+
+
+class Interfaces(Base):
+    """
+    Required
+    """
+
+    name: str = Field(alias="interface")
+    ip_address: IPv4Address | None = None
+    mask: int | None = None
+    description: str | None = None
+
+
+class Vlans(Base):
+    """
+    Optional
+    """
+
+    vlan_id: int
+    name: str | None = Field(default=None, alias="description")
+
+
+class Device(BaseModel):
+    system: System
+    interfaces: list[Interfaces]
+    vlans: list[Vlans] = []

oxi/interfaces/models/__init__.py

@@ -0,0 +1,7 @@
+import importlib
+import pkgutil
+
+package = __package__
+
+for loader, module_name, is_pkg in pkgutil.iter_modules(__path__):
+    importlib.import_module(f"{package}.{module_name}")

oxi/interfaces/models/eltex.py

@@ -0,0 +1,68 @@
+from oxi.interfaces import register_parser
+from oxi.interfaces.base import BaseDevice
+
+
+def _expand_vlan_range(value: str | list[str]) -> list[str]:
+    if isinstance(value, list):
+        value = ",".join(str(item) for item in value)
+
+    result: list[str] = []
+    for part in value.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if "-" not in part:
+            result.append(part)
+            continue
+        start_s, end_s = part.split("-", 1)
+        try:
+            start, end = int(start_s), int(end_s)
+        except ValueError:
+            result.append(part)
+            continue
+        if start > end:
+            start, end = end, start
+        result.extend(str(vlan_id) for vlan_id in range(start, end + 1))
+    return result
+
+
+@register_parser("eltex")
+class Eltex(BaseDevice):
+    template = "eltex.ttp"
+
+    def system(self) -> dict:
+        system = self.raw["system"]
+        serial_num = self.raw["serial"]
+        if serial_num:
+            if len(serial_num) > 1:
+                serial_num = serial_num[0]
+            system["serial_number"] = serial_num.get("serial_number")
+        return system
+
+    def vlans(self) -> list[dict]:
+        vlans_ttp = self.raw.get("vlans", [])
+        vlans: list[dict] = []
+        named_vlan: set[str] = set()
+        for item in vlans_ttp:
+            vlan_id = item.get("vlan_id")
+            if vlan_id:
+                named_vlan.add(str(vlan_id))
+                vlans.append(item)
+                continue
+
+            ids = item.get("vlan_ids", "")
+            tail = item.get("vlan_tail")
+            if tail:
+                ids = [*ids, tail] if isinstance(ids, list) else f"{ids},{tail}"
+            for vid in _expand_vlan_range(ids):
+                if vid in named_vlan:
+                    continue
+                vlans.append({"vlan_id": vid})
+        return vlans
+
+
+if __name__ == "__main__":
+    with open("./test_not_found.txt") as file:
+        data = file.read()
+    eltex = Eltex(data)
+    print(eltex.parse())

oxi/interfaces/models/h3c.py

@@ -0,0 +1,24 @@
+from oxi.interfaces import BaseDevice, register_parser
+
+
+@register_parser("h3c")
+class H3C(BaseDevice):
+    template = "h3c.ttp"
+
+    def vlans(self) -> list[dict]:
+        vlan_list = self.raw.get("vlans", [])
+        vlans: list[dict] = []
+        for item in vlan_list:
+            vlan_ids = item.get("vlans_id")
+            if not vlan_ids:
+                vlans.append(item)
+                continue
+            vlans.extend({"vlan_id": vlan_id} for vlan_id in vlan_ids)
+        return vlans
+
+
+if __name__ == "__main__":
+    with open("./test5.txt") as file:
+        data = file.read()
+    h3c = H3C(data)
+    print(h3c.parse())

oxi/interfaces/models/huawei.py

@@ -0,0 +1,18 @@
+from oxi.interfaces import register_parser
+from oxi.interfaces.base import BaseDevice
+
+
+@register_parser(["vrp", "huawei"])
+class Huawei(BaseDevice):
+    template = "huawei.ttp"
+
+    def vlans(self) -> list[dict]:
+        vlan_ids = self.raw.get("vlans", {}).get("vlan_ids", [])
+        return [{"vlan_id": vlan} for vlan in vlan_ids]
+
+
+if __name__ == "__main__":
+    with open("./test4.txt") as file:
+        data = file.read()
+    huawei = Huawei(data)
+    print(huawei.parse())

oxi/interfaces/models/keenetic.py

@@ -0,0 +1,49 @@
+from ipaddress import ip_interface
+from oxi.interfaces import register_parser
+from oxi.interfaces.base import BaseDevice
+
+
+@register_parser(["NDMS", "keenetic", "KeeneticOS"])
+class Keenetic(BaseDevice):
+    template = "keenetic.ttp"
+
+    def _decode_utf(self, text: str):
+        if "\\x" in text:
+            desc = text.strip('"')
+            decoded = (
+                desc.encode("utf-8")
+                .decode("unicode_escape")
+                .encode("latin1")
+                .decode("utf-8")
+            )
+            return decoded
+        return text
+
+    def interfaces(self):
+        interfaces: list[dict] = self.raw["interfaces"]
+        for item in interfaces:
+            if item.get("ip_address") and item.get("netmask"):
+                ipaddress = ip_interface(
+                    f"{item.get('ip_address')}/{item.get('netmask')}"
+                )
+                item["mask"] = ipaddress.network.prefixlen
+                item.pop("netmask", "Key not found")
+            if item.get("description"):
+                decoded = self._decode_utf(item.get("description", ""))
+                item["description"] = decoded
+        return interfaces
+
+    def vlans(self):
+        vlans = self.raw["vlans"]
+        for item in vlans:
+            if item.get("description"):
+                decoded = self._decode_utf(item.get("description", ""))
+                item["description"] = decoded
+        return vlans
+
+
+if __name__ == "__main__":
+    with open("./test2.txt") as file:
+        data = file.read()
+    mikr = Keenetic(data)
+    print(mikr.parse().model_dump_json())

oxi/interfaces/models/mikrotik.py

@@ -0,0 +1,16 @@
+import os
+from oxi.interfaces import register_parser
+from oxi.interfaces.base import BaseDevice
+
+
+@register_parser(["routeros", "ros", "mikrotik"])
+class Mikrotik(BaseDevice):
+    template = "mikrotik.ttp"
+
+
+if __name__ == "__main__":
+    print(os.path.abspath(os.curdir))
+    with open("./test.txt") as file:
+        data = file.read()
+    mikr = Mikrotik(data)
+    print(mikr.parse().json())

oxi/interfaces/models/qtech.py

@@ -0,0 +1,68 @@
+from oxi.interfaces import register_parser
+from oxi.interfaces.base import BaseDevice
+
+
+def _expand_vlan_range(value: str | list[str]) -> list[str]:
+    """Expand values like '1,7,14-15' into individual VLAN IDs."""
+    if isinstance(value, list):
+        value = ",".join(str(item) for item in value)
+
+    result: list[str] = []
+    if not value:
+        return result
+    for part in value.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if "-" in part:
+            start_s, end_s = part.split("-", 1)
+            try:
+                start, end = int(start_s), int(end_s)
+            except ValueError:
+                result.append(part)
+                continue
+            if start > end:
+                start, end = end, start
+            result.extend(str(i) for i in range(start, end + 1))
+        else:
+            result.append(part)
+    return result
+
+
+@register_parser(["QTECH"])
+class Qtech(BaseDevice):
+    template = "qtech.ttp"
+
+    def vlans(self) -> list[dict]:
+        vlans_ttp = self.raw.get("vlans", [])
+        vlans: list[dict] = []
+        named_vlan: set[str] = set()
+        for item in vlans_ttp:
+            vlan_id = item.get("vlan_id")
+            if vlan_id and "," not in vlan_id and "-" not in vlan_id:
+                named_vlan.add(vlan_id)
+                vlans.append(item)
+                continue
+
+            ids = item.get("vlan_ids") or vlan_id or ""
+            tail = item.get("vlan_tail")
+            if tail:
+                ids = [*ids, tail] if isinstance(ids, list) else f"{ids},{tail}"
+            for vid in _expand_vlan_range(ids):
+                if vid in named_vlan:
+                    continue
+                vlans.append({"vlan_id": vid})
+        return vlans
+
+
+if __name__ == "__main__":
+    with open("./test3.txt") as file:
+        data = file.read()
+    qtech = Qtech(data)
+    qt = qtech.parse()
+    print(qt)
+    with open("./test3-1.txt") as file:
+        data = file.read()
+    qtech = Qtech(data)
+    qt = qtech.parse()
+    print(qt)

oxi/interfaces/models/quasar.py

@@ -0,0 +1,37 @@
+from oxi.interfaces import BaseDevice, register_parser
+
+
+@register_parser(["quasar", "qos"])
+class Quasar(BaseDevice):
+    template = "quasar.ttp"
+
+    def interfaces(self) -> list[dict]:
+        ether_interface: dict = self.raw.get("interfaces", {})
+        interfaces: list[dict] = []
+        bulk_interfaces: dict = self.raw.get("bulkinterfaces", {})
+        for key, value in bulk_interfaces.items():
+            interfaces.append(
+                {
+                    "interface": key,
+                    "description": value.get("description"),
+                    "ip_address": value.get("ip_address"),
+                    "mask": value.get("mask"),
+                }
+            )
+        if ether_interface:
+            interfaces.append(ether_interface)
+        return interfaces
+
+
+if __name__ == "__main__":
+    with open("./test7.txt") as file:
+        data = file.read()
+    quasar = Quasar(data)
+    qt = quasar.parse()
+    print(qt)
+    print()
+    with open("./test8.txt") as file:
+        data = file.read()
+    quasar = Quasar(data)
+    qt = quasar.parse()
+    print(qt)

oxi/interfaces/models/templates/_template.ttp

@@ -0,0 +1,37 @@
+<doc>
+Base template for a new device parser. Copy this file, rename it to
+&lt;vendor&gt;.ttp, and fill the groups for the target configuration format.
+
+Required groups: system, interfaces.
+Optional group: vlans. Add it only when VLAN parsing is implemented.
+
+system must return one dictionary with: model, serial_number, version.
+interfaces must return a list of dictionaries with: interface, ip_address,
+mask, description. Use a prefix length for mask; convert dotted decimal masks
+with `to_cidr` or in the device class.
+vlans must return dictionaries with vlan_id and optional name/description.
+
+Useful TTP modifiers: ORPHRASE, _start_, strip(), replace(), exclude(),
+ignore, ignore('.*'), to_cidr, unrange(), split().
+
+See docs/templates.md for details.
+</doc>
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": "",
+    "version": ""
+}
+</vars>
+
+<group name="system" default="default_system">
+    ...
+</group>
+
+<group name="interfaces">
+    ...
+</group>
+
+<group name="vlans">
+    ...
+</group>

oxi/interfaces/models/templates/eltex.ttp

@@ -0,0 +1,37 @@
+<doc>
+Eltex configuration parser.
+
+The system group reads software version data and the serial group extracts
+serial numbers from the unit table. The interfaces group parses interface IP
+settings. The vlans group supports named VLAN interfaces and compressed VLAN
+lists.
+</doc>
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": "",
+    "version": ""
+}
+</vars>
+
+<group name="system" default="default_system">
+Active-image: {{ ignore }} {{ _start_ }}
+! Version: {{ version }}
+</group>
+<group name="serial" method="table">
+! Unit MAC address Hardware version Serial number
+!  {{ unit | exclude("-") }} {{ mac_address }} {{ hardware_version }} {{ serial_number }}
+</group>
+
+<group name="interfaces">
+interface {{ interface | ORPHRASE }}
+ ip address {{ ip_address }} {{ mask | to_cidr }}
+</group>
+
+<group name="vlans">
+interface vlan {{ vlan_id | _start_ }}
+ name {{ name  }}
+
+vlan {{ _db_ | _start_ }}
+ vlan {{ vlan_ids | joinmatches(',') | unrange("-", ",") | split(",")}}
+</group>

oxi/interfaces/models/templates/h3c.ttp

@@ -0,0 +1,34 @@
+<doc>
+H3C configuration parser.
+
+The system group reads boot image version and board model data. The interfaces
+group parses interface IP settings. The vlans groups parse both named VLANs and
+range-style VLAN declarations.
+</doc>
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": "",
+    "version": ""
+}
+</vars>
+
+<group name="system" default="default_system">
+# Boot image version: {{ version }}, Release {{ release }}
+# {{ mpu }} Slot {{ slot }}:
+# BOARD TYPE: {{ model }}
+</group>
+
+<group name="interfaces">
+interface {{ interface }}
+ ip address {{ ip_address }} {{ mask | to_cidr }}
+</group>
+
+<group name="vlans">
+vlan {{ vlan_id }}
+ name {{ name }}
+ description {{ description }}
+</group>
+<group name="vlans">
+vlan {{ vlans_id | ORPHRASE | contains(" to ") | unrange(" to ", ",") | split(",") }}
+</group>

oxi/interfaces/models/templates/huawei.ttp

@@ -0,0 +1,28 @@
+<doc>
+Huawei VRP configuration parser.
+
+The system group reads VRP version and slot ESN data. The interfaces group
+parses interface blocks and converts dotted decimal masks to prefix lengths.
+The vlans group parses `vlan batch` declarations and emits VLAN IDs.
+</doc>
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": "",
+    "version": ""
+}
+</vars>
+
+<group name="system" default="default_system">
+# VRP (R) software, Version {{ version }} {{ _line_ }}
+# ESN of slot {{ slot_number }}: {{ serial_number }}
+</group>
+
+<group name="interfaces">
+interface {{ interface }}
+ description {{ description }}
+ ip address {{ ip_address }} {{ mask | to_cidr }}
+</group>
+<group name="vlans">
+vlan batch {{ vlan_ids | ORPHRASE | unrange(" to ", " ") | split(" ")}}
+</group>

oxi/interfaces/models/templates/keenetic.ttp

@@ -0,0 +1,29 @@
+<doc>
+</doc>
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": ""
+}
+default_interfaces = {}
+</vars>
+
+<group name="system" default="default_system">
+! release: {{ version }}
+! model: {{ model | ORPHRASE }}
+! hw_version: {{ serial_number }}
+</group>
+
+<group name="interfaces">
+interface {{ name | _start_ | exclude("Vlan") }}
+    rename {{ rename }}
+    description {{ description | ORPHRASE | strip('"') }}
+    ip address {{ ip_address }} {{ netmask }}
+    {{ shutdown | re("up") | replace("up","False") | strip('"') }}
+    {{ shutdown | re("down") | replace("down","True") | strip('"') }}
+</group>
+
+<group name="vlans">
+interface {{ ignore }}/Vlan{{ vlan_id }}
+    description {{ description | ORPHRASE | strip('"') }}
+</group>

oxi/interfaces/models/templates/mikrotik.ttp

@@ -0,0 +1,47 @@
+<doc>
+    some templates
+</doc>
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": ""
+}
+default_interfaces = {
+    "disabled": "False"
+}
+default_vlans = {
+    "disabled": "False",
+    "mtu": None
+    }
+</vars>
+
+<group name="system" default="default_system">
+# version: {{ version }}{{ ignore('.*') }}
+# model = {{ model }}
+# serial number = {{ serial_number }}
+</group>
+
+<group name="interfaces" default="default_interfaces">
+/ip address
+## not disabled and no comment
+add address={{ ip_address | _start_ }}/{{ mask }} interface={{ name }} network={{ network }}
+## not disabled and comment with/without quotes
+add address={{ ip_address | _start_ }}/{{ mask }} comment={{ description | ORPHRASE | exclude("disabled=") | strip('"')}} interface={{ name }} network={{ network }}
+## disabled no comment
+add address={{ ip_address | _start_ }}/{{ mask }} disabled={{ disabled | replace("yes","True") | strip('"')}} interface={{ name }} network={{ network }}
+## disabled with comment with/without quotes
+add address={{ ip_address | _start_ }}/{{ mask }} comment={{ description | ORPHRASE | exclude("disabled=") | strip('"') }} disabled={{ disabled }} interface={{ name }} network={{ network }}
+</group>
+
+<group name="vlans">
+/interface vlan
+## not disabled and no comment
+add interface={{ interface | _start_ }} name={{ name | ORPHRASE | strip('"') }} vlan-id={{ vlan_id }}
+## not disabled and comment with/without quotes
+add comment={{ comment | _start_ | ORPHRASE | exclude("disabled=") | strip('"')}} interface={{ interface }} name={{ name | ORPHRASE | strip('"') }} vlan-id={{ vlan_id }}
+## disabled with comment with/without quotes
+add comment={{ comment | _start_ | ORPHRASE | exclude("disabled=") | strip('"')}} disabled={{ disabled | replace("yes","True") | strip('"') }} interface={{ interface }} name={{ name | ORPHRASE | strip('"') }} vlan-id={{ vlan_id }}
+## disabled no comment
+add interface={{ interface | _start_ }} name={{ name | ORPHRASE | strip('"') }} vlan-id={{ vlan_id }} disabled={{ disabled | replace("yes","True") | strip('"') }}
+</group>
+

oxi/interfaces/models/templates/qtech.ttp

@@ -0,0 +1,41 @@
+<doc>
+Qtech switch configuration parser.
+
+The system group reads the model, serial number, and build number. For Qtech,
+system.version intentionally stores the build number from lines like
+`Version 2.2.0C Build 96279`.
+
+The interfaces group parses CLI interface blocks and converts dotted decimal
+masks to prefix lengths. The vlans group supports named VLANs, comma-separated
+VLAN lists, ranges, and continuation lines.
+</doc>
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": "",
+    "version": ""
+}
+</vars>
+
+<group name="system" default="default_system">
+! {{ model | ORPHRASE | _start_ }} Series Software, Version {{ ignore }} Build {{ version | strip(",") }}{{ ignore('.*') }}
+! Serial num:{{ serial_number | strip(",") }}{{ ignore('.*') }}
+
+! System description : {{ description | PHRASE | _start_ }}({{ model }}) By {{ vendor }}
+! System description : {{ description | PHRASE | _start_ }}({{ model }})
+! System software version : {{ description | PHRASE }}, Release({{ version }})
+! System serial number : {{ serial_number }}
+</group>
+
+<group name="interfaces">
+interface {{ interface | ORPHRASE }}
+ description {{ description | ORPHRASE }}
+ ip address {{ ip_address }} {{ mask | to_cidr }}
+</group>
+
+<group name="vlans">
+vlan {{ vlan_ids | contains(",", "-") | unrange("-", ",") }}
+,{{ vlan_tail | unrange("-", ",") }}
+vlan {{ vlan_id | _start_ }}
+ name {{ name | ORPHRASE }}
+</group>

oxi/interfaces/models/templates/quasar.ttp

@@ -0,0 +1,35 @@
+<doc>
+Quasar configuration parser.
+
+The system group supports Assembly-based and Engine-based firmware blocks. The
+interfaces group parses the management Ethernet address, while bulkinterfaces
+collects per-port descriptions that the Python model merges into interface
+records.
+</doc>
+<vars>
+default_system = {
+    "model": "",
+    "serial_number": "",
+    "version": ""
+}
+</vars>
+
+<group name="system" default="default_system">
+# Component Version {{ _start_ }}
+# Assembly {{ version }}
+# Product Name {{ model | ORPHRASE }}
+# Product Serial Number {{ serial_number }}
+
+# Subsystem Version {{ _start_ }}
+# Engine {{ version }}
+# Product Name {{ model | ORPHRASE }}
+# Product Serial Number {{ serial_number }}
+</group>
+
+<group name="interfaces">
+{{ ignore("\\s*") }}config {{ interface }} ipv4 address {{ ip_address }}/{{ mask }} gateway {{ gateway }} {{ ignore }}
+</group>
+
+<group name="bulkinterfaces.{{ interface }}">
+{{ ignore("\\s*") }}config interface {{ interface | _start_ }} description {{ description | ORPHRASE | strip('"')}}
+</group>

oxi/node.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING
+
+from requests import HTTPError
+
+from oxi.exception import OxiAPIError
+
+from .view import NodeView
+
+
+if TYPE_CHECKING:
+    from requests import Session
+
+
+class Node:
+    def __init__(self, session: "Session", base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    def __call__(self, name: str) -> NodeView:
+        try:
+            url = f"{self._base_url}/node/show/{name}"
+            if not url.endswith(".json"):
+                url += ".json"
+            response = self._session.get(url)
+            response.raise_for_status()
+        except HTTPError as e:
+            raise OxiAPIError.from_http_error(e, context=f"Node {name}") from e
+        return NodeView(
+            session=self._session, base_url=self._base_url, data=response.json()
+        )

oxi/view.py

@@ -0,0 +1,60 @@
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+from .conf import NodeConfig
+
+
+if TYPE_CHECKING:
+    from requests import Session
+
+
+class NodeView:
+    def __init__(self, session: "Session", base_url: str, data: dict):
+        self._session = session
+        self._base_url = base_url
+        self._data = data
+
+    def _updater(self) -> int:
+        response = self._session.get(f"{self._base_url}/node/next/{self.full_name}")
+        response.raise_for_status()
+        return response.status_code
+
+    @property
+    def name(self) -> str:
+        return self._data.get("name")
+
+    @property
+    def ip(self) -> str:
+        return self._data.get("ip")
+
+    @property
+    def full_name(self) -> str:
+        return self._data.get("full_name")
+
+    @property
+    def group(self) -> str:
+        return self._data.get("group")
+
+    @property
+    def model(self) -> str:
+        return self._data.get("model")
+
+    @property
+    def last_status(self) -> str:
+        last = self._data.get("last") or {}
+        return last.get("status")
+
+    @property
+    def last_check(self) -> str:
+        last = self._data.get("last") or {}
+        return last.get("start")
+
+    def refresh(self) -> str:
+        result = self._updater()
+        if result != 200:
+            raise ValueError(f"Failed to refresh node {self.full_name}")
+        return "OK"
+
+    @cached_property
+    def config(self) -> NodeConfig:
+        return NodeConfig(self._session, self.full_name, self.model, self._base_url)

pyproject.toml

@@ -1,16 +1,34 @@
 [build-system]
-requires = ["setuptools>=61"]
+requires = ["setuptools>=77"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "oxipy"
 version = "0.1.0"
-description = "Oxi API client"
+description = "Python client for Oxidized API with TTP-based config parsing"
 readme = "README.md"
-requires-python = ">=3.13"
-dependencies = [
-    "requests>=2.32.5",
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
 ]
+dependencies = [
+    "pydantic>=2.12.5",
+    "requests>=2.32.5",
+    "ttp>=0.10.0",
+]
+
+[project.urls]
+Repository = "https://github.com/sttarsky/oxipy"
+
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["oxi*"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+"oxi" = ["**/*.ttp"]

uv.lock

@@ -0,0 +1,323 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1f/b8/6d51fc1d52cbd52cd4ccedd5b5b2f0f6a11bbf6765c782298b0f3e808541/charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d", size = 209709, upload-time = "2025-10-14T04:40:11.385Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/af/1f9d7f7faafe2ddfb6f72a2e07a548a629c61ad510fe60f9630309908fef/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8", size = 148814, upload-time = "2025-10-14T04:40:13.135Z" },
+    { url = "https://files.pythonhosted.org/packages/79/3d/f2e3ac2bbc056ca0c204298ea4e3d9db9b4afe437812638759db2c976b5f/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad", size = 144467, upload-time = "2025-10-14T04:40:14.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/85/1bf997003815e60d57de7bd972c57dc6950446a3e4ccac43bc3070721856/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8", size = 162280, upload-time = "2025-10-14T04:40:16.14Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/8e/6aa1952f56b192f54921c436b87f2aaf7c7a7c3d0d1a765547d64fd83c13/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d", size = 159454, upload-time = "2025-10-14T04:40:17.567Z" },
+    { url = "https://files.pythonhosted.org/packages/36/3b/60cbd1f8e93aa25d1c669c649b7a655b0b5fb4c571858910ea9332678558/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313", size = 153609, upload-time = "2025-10-14T04:40:19.08Z" },
+    { url = "https://files.pythonhosted.org/packages/64/91/6a13396948b8fd3c4b4fd5bc74d045f5637d78c9675585e8e9fbe5636554/charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e", size = 151849, upload-time = "2025-10-14T04:40:20.607Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/7a/59482e28b9981d105691e968c544cc0df3b7d6133152fb3dcdc8f135da7a/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93", size = 151586, upload-time = "2025-10-14T04:40:21.719Z" },
+    { url = "https://files.pythonhosted.org/packages/92/59/f64ef6a1c4bdd2baf892b04cd78792ed8684fbc48d4c2afe467d96b4df57/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0", size = 145290, upload-time = "2025-10-14T04:40:23.069Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/63/3bf9f279ddfa641ffa1962b0db6a57a9c294361cc2f5fcac997049a00e9c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84", size = 163663, upload-time = "2025-10-14T04:40:24.17Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/09/c9e38fc8fa9e0849b172b581fd9803bdf6e694041127933934184e19f8c3/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e", size = 151964, upload-time = "2025-10-14T04:40:25.368Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d1/d28b747e512d0da79d8b6a1ac18b7ab2ecfd81b2944c4c710e166d8dd09c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db", size = 161064, upload-time = "2025-10-14T04:40:26.806Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/9a/31d62b611d901c3b9e5500c36aab0ff5eb442043fb3a1c254200d3d397d9/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6", size = 155015, upload-time = "2025-10-14T04:40:28.284Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/107e008fa2bff0c8b9319584174418e5e5285fef32f79d8ee6a430d0039c/charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f", size = 99792, upload-time = "2025-10-14T04:40:29.613Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/66/e396e8a408843337d7315bab30dbf106c38966f1819f123257f5520f8a96/charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d", size = 107198, upload-time = "2025-10-14T04:40:30.644Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/58/01b4f815bf0312704c267f2ccb6e5d42bcc7752340cd487bc9f8c3710597/charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69", size = 100262, upload-time = "2025-10-14T04:40:32.108Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" },
+    { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" },
+    { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" },
+    { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" },
+    { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" },
+    { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" },
+    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" },
+    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" },
+    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" },
+    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "oxipy"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "pydantic" },
+    { name = "requests" },
+    { name = "ttp" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "pydantic", specifier = ">=2.12.5" },
+    { name = "requests", specifier = ">=2.32.5" },
+    { name = "ttp", specifier = ">=0.10.0" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/90/32c9941e728d564b411d574d8ee0cf09b12ec978cb22b294995bae5549a5/pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146", size = 2107298, upload-time = "2025-11-04T13:39:04.116Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/a8/61c96a77fe28993d9a6fb0f4127e05430a267b235a124545d79fea46dd65/pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2", size = 1901475, upload-time = "2025-11-04T13:39:06.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/b6/338abf60225acc18cdc08b4faef592d0310923d19a87fba1faf05af5346e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97", size = 1918815, upload-time = "2025-11-04T13:39:10.41Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/1c/2ed0433e682983d8e8cba9c8d8ef274d4791ec6a6f24c58935b90e780e0a/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9", size = 2065567, upload-time = "2025-11-04T13:39:12.244Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/24/cf84974ee7d6eae06b9e63289b7b8f6549d416b5c199ca2d7ce13bbcf619/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52", size = 2230442, upload-time = "2025-11-04T13:39:13.962Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/21/4e287865504b3edc0136c89c9c09431be326168b1eb7841911cbc877a995/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941", size = 2350956, upload-time = "2025-11-04T13:39:15.889Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/76/7727ef2ffa4b62fcab916686a68a0426b9b790139720e1934e8ba797e238/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a", size = 2068253, upload-time = "2025-11-04T13:39:17.403Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/8c/a4abfc79604bcb4c748e18975c44f94f756f08fb04218d5cb87eb0d3a63e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c", size = 2177050, upload-time = "2025-11-04T13:39:19.351Z" },
+    { url = "https://files.pythonhosted.org/packages/67/b1/de2e9a9a79b480f9cb0b6e8b6ba4c50b18d4e89852426364c66aa82bb7b3/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2", size = 2147178, upload-time = "2025-11-04T13:39:21Z" },
+    { url = "https://files.pythonhosted.org/packages/16/c1/dfb33f837a47b20417500efaa0378adc6635b3c79e8369ff7a03c494b4ac/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556", size = 2341833, upload-time = "2025-11-04T13:39:22.606Z" },
+    { url = "https://files.pythonhosted.org/packages/47/36/00f398642a0f4b815a9a558c4f1dca1b4020a7d49562807d7bc9ff279a6c/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49", size = 2321156, upload-time = "2025-11-04T13:39:25.843Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/70/cad3acd89fde2010807354d978725ae111ddf6d0ea46d1ea1775b5c1bd0c/pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba", size = 1989378, upload-time = "2025-11-04T13:39:27.92Z" },
+    { url = "https://files.pythonhosted.org/packages/76/92/d338652464c6c367e5608e4488201702cd1cbb0f33f7b6a85a60fe5f3720/pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9", size = 2013622, upload-time = "2025-11-04T13:39:29.848Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351, upload-time = "2025-11-04T13:43:02.058Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363, upload-time = "2025-11-04T13:43:05.159Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615, upload-time = "2025-11-04T13:43:08.116Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0a/99a53d06dd0348b2008f2f30884b34719c323f16c3be4e6cc1203b74a91d/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2", size = 2175369, upload-time = "2025-11-04T13:43:12.49Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/94/30ca3b73c6d485b9bb0bc66e611cff4a7138ff9736b7e66bcf0852151636/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093", size = 2144218, upload-time = "2025-11-04T13:43:15.431Z" },
+    { url = "https://files.pythonhosted.org/packages/87/57/31b4f8e12680b739a91f472b5671294236b82586889ef764b5fbc6669238/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a", size = 2329951, upload-time = "2025-11-04T13:43:18.062Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/73/3c2c8edef77b8f7310e6fb012dbc4b8551386ed575b9eb6fb2506e28a7eb/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963", size = 2318428, upload-time = "2025-11-04T13:43:20.679Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009, upload-time = "2025-11-04T13:43:23.286Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+]
+
+[[package]]
+name = "ttp"
+version = "0.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/83/e6/9169d35574be82df2a0cdd2546f4f83d0d30964cf0043fc9784df855b024/ttp-0.10.0.tar.gz", hash = "sha256:40f1ca61ee1431f5b1ab5326fb55f852a04749e9574792d45455b62c5e7ac97b", size = 64665, upload-time = "2025-11-02T08:47:50.329Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/c3/60abb45bd8eb973997f133eb76949523478d35dfc551a0dbd8906b6a8075/ttp-0.10.0-py3-none-any.whl", hash = "sha256:9985e0ca414e85d41493a6291a924624b9a08c48c78d2d01477cc60ba2a347c1", size = 84287, upload-time = "2025-11-02T08:47:48.656Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]