yaml-test-params 0.1.0__py3-none-any.whl

yaml_test_params/__init__.py

@@ -0,0 +1,29 @@
+from .args_loader import load_parametrize_args
+from .models import (
+    BaseTestCase,
+    BaseTestConfig,
+    BaseTestConfigCollection,
+    ListConfig,
+    ParametrizeInteger,
+    ParametrizeIntegerConfigModels,
+    ParametrizeString,
+    ParametrizeStringConfigModels,
+    RangeConfig,
+    ValueConfig,
+)
+from .parametrize_args import ParametrizeArgs
+
+__all__ = [
+    "BaseTestCase",
+    "BaseTestConfig",
+    "BaseTestConfigCollection",
+    "ListConfig",
+    "ParametrizeArgs",
+    "ParametrizeInteger",
+    "ParametrizeIntegerConfigModels",
+    "ParametrizeString",
+    "ParametrizeStringConfigModels",
+    "RangeConfig",
+    "ValueConfig",
+    "load_parametrize_args",
+]

yaml_test_params/args_loader.py

@@ -0,0 +1,29 @@
+import pathlib
+from typing import Type, TypeVar, Union
+
+import yaml
+
+from .models import BaseTestConfigCollection
+from .parametrize_args import ParametrizeArgs
+
+
+TestConfigCollection = TypeVar(
+    "TestConfigCollection",
+    bound=BaseTestConfigCollection,
+)
+
+
+def load_parametrize_args(
+    path_to_configs: Union[pathlib.Path, str],
+    config_collection_model: Type[TestConfigCollection],
+    collection_name: str,
+) -> ParametrizeArgs:
+    with open(path_to_configs, "r", encoding="utf-8") as f:
+        yaml_config = yaml.safe_load(f)  # type: ignore[attr-defined]
+        test_configs = config_collection_model.model_validate(yaml_config)
+
+    for cfg in test_configs.collection:
+        if cfg.name == collection_name:
+            return cfg.generate_parametrize_args()
+
+    raise ValueError(f"No test configuration found for collection name: {collection_name}")

yaml_test_params/models.py

@@ -0,0 +1,209 @@
+from abc import ABC, abstractmethod
+from itertools import product
+from typing import Union, List, get_args, get_origin
+
+from pydantic import BaseModel, Field
+
+from .parametrize_args import ParametrizeArgs
+
+
+class ValueConfig(BaseModel):
+    """Configuration for parameters with a simple value"""
+
+    value: Union[int, str] = Field(..., alias="value")
+
+    model_config = {"populate_by_name": True}
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+
+class ListConfig(BaseModel):
+    """Configuration for parameters with a list of values"""
+
+    values: list[Union[int, str]] = Field(..., alias="values")
+
+    model_config = {"populate_by_name": True}
+
+    def __str__(self) -> str:
+        return str(self.values)
+
+
+class RangeConfig(BaseModel):
+    """Configuration for parameters with a range (from/to/step)"""
+
+    from_: int = Field(..., alias="from")
+    to: int
+    step: int = Field(..., gt=0)
+
+    model_config = {"populate_by_name": True}
+
+    def __str__(self) -> str:
+        return f"From {self.from_} To {self.to} Step {self.step}"
+
+
+ParametrizeIntegerConfigModels = Union[RangeConfig, ListConfig, ValueConfig]
+ParametrizeStringConfigModels = Union[ListConfig, ValueConfig]
+ParametrizeInteger = Union[int, ParametrizeIntegerConfigModels]
+ParametrizeString = Union[str, ParametrizeStringConfigModels]
+
+
+class BaseTestCase(BaseModel, ABC):
+    test_name: str
+
+    @property
+    @abstractmethod
+    def arg_id(self) -> str:
+        return self.test_name
+
+
+class BaseTestConfig(BaseModel):
+    name: str
+    test_cases: list[BaseTestCase]
+
+    @staticmethod
+    def _generate_range_values(range_config: RangeConfig) -> list[int]:
+        """
+        Generate a list of values from a RangeConfig.
+
+        Args:
+            range_config: RangeConfig object with from_, to, and step
+
+        Returns:
+            List of integer values in the range
+        """
+        return list(range(range_config.from_, range_config.to + 1, range_config.step))
+
+    @staticmethod
+    def _format_range_values(values: tuple) -> str:
+        """
+        Format range values into a string for test naming.
+
+        Args:
+            values: Tuple of values
+
+        Returns:
+            Formatted string representation
+        """
+        return "_".join(str(v) for v in values)
+
+    @property
+    def test_case_type(self) -> BaseTestCase:
+        raw_type = self.__annotations__["test_cases"]
+        origin = get_origin(raw_type)
+
+        if origin is None or origin not in (list, List):
+            raise TypeError(f"Field 'test_cases' has to be List[…] , not {origin!r}")
+
+        (inner_type,) = get_args(raw_type)
+        return inner_type
+
+    def _expand_range_configs(self, test_case: BaseTestCase) -> list[BaseTestCase]:
+        """
+        Expand a test case with RangeConfig and ListConfig values into multiple test cases.
+
+        Args:
+            test_case: Single BaseTestCase with potential RangeConfig or ListConfig values
+
+        Returns:
+            List of expanded BaseTestCase objects
+        """
+        # Check if any of the parameters use ValueConfig, ListConfig or RangeConfig
+        params_with_configs = []
+
+        fields = getattr(type(test_case), "model_fields")
+
+        for key in fields.keys():
+            value = getattr(test_case, key)
+            if isinstance(value, (ValueConfig, ListConfig, RangeConfig)):
+                params_with_configs.append((key, value))
+
+        # If no value configs, return the original test case
+        if not params_with_configs:
+            return [test_case]
+
+        # Get all possible values for each parameter
+        param_values = []
+        param_names = []
+
+        for param_name, config in params_with_configs:
+            values: list[int] | list[int | str]
+            if isinstance(config, ValueConfig):
+                values = [config.value]
+            elif isinstance(config, ListConfig):
+                values = config.values
+            elif isinstance(config, RangeConfig):
+                values = self._generate_range_values(config)
+            else:
+                raise ValueError("Unsupported configuration type.")
+            param_values.append(values)
+            param_names.append(param_name)
+
+        # Generate all combinations
+        combinations = list(product(*param_values))
+
+        # Create new test cases for each combination
+        expanded_cases = []
+        for combo in combinations:
+            # Create a copy of the original test case
+            new_test_case = test_case.model_copy(deep=True)
+
+            # Update the parameters with specific values
+            for i, param_name in enumerate(param_names):
+                setattr(new_test_case, param_name, ValueConfig(value=combo[i]))
+
+            # Update test name to reflect the specific values
+            new_test_case.test_name = f"{test_case.test_name}__{self._format_range_values(combo)}"
+
+            expanded_cases.append(new_test_case)
+
+        return expanded_cases
+
+    def generate_parametrize_args(self) -> ParametrizeArgs:
+        """
+        Generate parametrize args (test_cases) based on the BaseTestCase model,
+        handling value configs appropriately.
+
+        Returns:
+            MetafuncParametrizeArgs object
+        """
+
+        parametrize_args = ParametrizeArgs()
+        parametrize_args.init_arg_names(self.test_case_type)
+
+        for test_case in self.test_cases:
+            # Handle RangeConfig values by expanding them into individual test cases
+            expanded_test_cases = self._expand_range_configs(test_case)
+
+            for expanded_case in expanded_test_cases:
+                # Create a tuple of parameters for this test case
+                arg_values = []
+
+                for key in parametrize_args.keys:
+                    attr = getattr(expanded_case, key)
+                    if isinstance(attr, ValueConfig):
+                        arg_values.append(attr.value)
+                    else:
+                        arg_values.append(attr)
+
+                parametrize_args.add_params(arg_id=expanded_case.arg_id, arg_values=tuple(arg_values))
+
+        return parametrize_args
+
+
+class BaseTestConfigCollection(BaseModel):
+    collection: list[BaseTestConfig]
+
+
+__all__ = [
+    "ValueConfig",
+    "ListConfig",
+    "RangeConfig",
+    "ParametrizeIntegerConfigModels",
+    "ParametrizeStringConfigModels",
+    "ParametrizeInteger",
+    "ParametrizeString",
+    "BaseTestCase",
+    "BaseTestConfig",
+    "BaseTestConfigCollection",
+]

yaml_test_params/parametrize_args.py

@@ -0,0 +1,52 @@
+from dataclasses import asdict, dataclass, field
+from typing import Type, Union
+
+from pydantic import BaseModel
+
+
+ERROR_INIT_ARGS_MSG = "Argument names are not initialized"
+
+
+def _filter_private(items: list) -> dict:
+    return {k: v for k, v in items if not k.startswith("_")}
+
+
+@dataclass
+class ParametrizeArgs:
+    argnames: Union[str, None] = None
+    argvalues: list[tuple] = field(default_factory=list)
+    ids: list[str] = field(default_factory=list)
+    _model_cls: Union[Type[BaseModel], BaseModel] = None
+    _arg_keys: Union[tuple, None] = None
+
+    def init_arg_names(self, model_cls: BaseModel) -> None:
+        if self.argnames is None:
+            model_cls = model_cls if isinstance(model_cls, type) else type(model_cls)
+            if hasattr(model_cls, "model_fields"):
+                self._model_cls = model_cls
+                fields = getattr(model_cls, "model_fields")
+                self._arg_keys = tuple(fields.keys())
+                self.argnames = ", ".join(fields.keys())
+            else:
+                raise ValueError("No pydantic fields found for model")
+        else:
+            raise ValueError("Argname already set")
+
+    def add_params(self, arg_id: str, arg_values: tuple) -> None:
+        self.ids.append(arg_id)
+        self.argvalues.append(arg_values)
+
+    @property
+    def keys(self) -> tuple:
+        if self._arg_keys is None:
+            raise ValueError(ERROR_INIT_ARGS_MSG)
+        return self._arg_keys
+
+    @property
+    def keys_set(self) -> set:
+        if self._arg_keys is None:
+            raise ValueError(ERROR_INIT_ARGS_MSG)
+        return set(self._arg_keys)
+
+    def to_dict(self) -> dict:
+        return asdict(self, dict_factory=_filter_private)

yaml_test_params/py.typed

@@ -0,0 +1 @@
+

yaml_test_params-0.1.0.dist-info/METADATA

@@ -0,0 +1,454 @@
+Metadata-Version: 2.4
+Name: yaml-test-params
+Version: 0.1.0
+Summary: Generate pytest and unittest parameters from YAML configuration files.
+Project-URL: Homepage, https://github.com/fomenko-ai/yaml-test-params
+Project-URL: Repository, https://github.com/fomenko-ai/yaml-test-params
+Project-URL: Issues, https://github.com/fomenko-ai/yaml-test-params/issues
+Author-email: Aleksei Fomenko <fomenko_ai@proton.me>
+License: MIT
+License-File: LICENSE.txt
+Keywords: parametrize,pydantic,pytest,testing,unittest,yaml
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.4.2; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# yaml-test-params
+
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/yaml-test-params)](https://pypi.org/project/yaml-test-params/)
+[![PyPI - License](https://img.shields.io/pypi/l/yaml-test-params)](LICENSE.txt)
+
+A Python library for dynamic test parameter generation from YAML configuration files. This library enables flexible, data-driven test scenarios by combining Pydantic models with pytest's parametrize functionality or Python's built-in unittest library.
+
+## Features
+
+- **Configuration-driven tests**: Define test parameters in YAML files instead of hardcoding them
+- **Pydantic validation**: Type-safe configuration models with automatic validation
+- **Automatic test expansion**: Range configurations are automatically expanded into individual test cases
+- **Seamless pytest integration**: Works with pytest's native parametrize mechanism
+- **unittest support**: Generated parameter sets can be iterated in standard `unittest.TestCase` tests
+- **Flexible parameter types**: Support for simple values, lists, and ranges
+- **Custom test case data**: `test_cases` can include any YAML data types accepted by your Pydantic models
+
+## Installation
+
+```bash
+uv add yaml-test-params
+```
+
+**Dependencies:**
+
+- Python >= 3.9
+- pydantic >= 2.0
+- pyyaml >= 6.0.2
+
+For local development and examples, install the development extra:
+
+```bash
+uv sync --extra dev
+```
+
+## How It Works
+
+The project supports dynamic parameter generation for tests from configuration files, enabling flexible test scenarios.
+
+### Workflow
+
+1. **Base Pydantic models** define the structure of test cases and the YAML configuration file structure.
+2. **YAML configuration** defines test parameters and scenarios.
+3. **Test runner integration** uses the generated arguments either through a `pytest_generate_tests` hook or directly inside `unittest.TestCase`.
+
+## Quick Start
+
+### Step 1: Define Your Models
+
+Create Pydantic models that represent your test case structure:
+
+```python
+from yaml_test_params.models import (
+    BaseTestCase,
+    BaseTestConfig,
+    BaseTestConfigCollection,
+    ParametrizeInteger,
+    ParametrizeString,
+)
+
+
+class ExampleTestCase(BaseTestCase):
+    test_name: str
+    integer: ParametrizeInteger
+    string: ParametrizeString
+
+    @property
+    def arg_id(self) -> str:
+        return self.test_name
+
+
+class ExampleTestConfig(BaseTestConfig):
+    test_cases: list[ExampleTestCase]
+
+
+class ExampleTestConfigCollection(BaseTestConfigCollection):
+    collection: list[ExampleTestConfig]
+```
+
+### Step 2: Create YAML Configuration
+
+Define your test parameters in a YAML file:
+
+```yaml
+collection:
+  - name: examples
+    test_cases:
+      - test_name: int_1,2,3__str_a
+        integer:
+          values: [1, 2, 3]
+        string: a
+
+      - test_name: int_42__str_a,b,c
+        integer: 42
+        string:
+          values: [a, b, c]
+
+      - test_name: int_1_10_1__str_a
+        integer:
+          from: 1
+          to: 10
+          step: 1
+        string: a
+
+      - test_name: int_1_10_2__str_a,b,c
+        integer:
+          from: 1
+          to: 10
+          step: 2
+        string:
+          values: [a, b, c]
+```
+
+### Step 3: Use Generated Parameters in Tests
+
+You can use the generated parameters with either pytest or unittest.
+
+#### Option A: Configure pytest Hook
+
+Add the hook to your `conftest.py`:
+
+```python
+import pytest
+
+from yaml_test_params.args_loader import load_parametrize_args
+from ..models import ExampleTestConfigCollection
+
+
+def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
+    test_cls = getattr(metafunc, "cls", None)
+    if test_cls is None:
+        return
+
+    full_cls_name = f"{test_cls.__module__}.{test_cls.__qualname__}"
+
+    if (
+        full_cls_name == "examples.pytest_tests.test_examples.TestParametrizeExamples"
+        and metafunc.function.__name__ == "test_values"
+    ):
+        parametrize_args = load_parametrize_args(
+            path_to_configs="examples/collection.yaml",
+            config_collection_model=ExampleTestConfigCollection,
+            collection_name="examples",
+        )
+        needed_args = parametrize_args.keys_set
+        if needed_args.issubset(set(metafunc.fixturenames)):
+            metafunc.parametrize(**parametrize_args.to_dict())
+```
+
+Then write tests that accept the parameters defined in your configuration:
+
+```python
+class TestParametrizeExamples:
+    """Test class demonstrating pytest parametrize with integer and string variables."""
+
+    def test_values(self, test_name: str, integer: int, string: str):
+        """Test that integer and string parameters are correctly passed."""
+        print(f"\n==============\n")
+        print(f"Test name: {test_name}")
+        print(f"integer: {integer}\nstring: {string}")
+```
+
+Run the pytest example:
+
+```bash
+uv run pytest -s examples/pytest_tests
+```
+
+#### Option B: Use unittest
+
+Load the generated arguments once and iterate over them in a `unittest.TestCase`:
+
+```python
+import unittest
+
+from yaml_test_params.args_loader import load_parametrize_args
+from ..models import ExampleTestConfigCollection
+
+
+parametrize_args = load_parametrize_args(
+    path_to_configs="examples/collection.yaml",
+    config_collection_model=ExampleTestConfigCollection,
+    collection_name="examples",
+)
+
+
+class TestParametrizeExamples(unittest.TestCase):
+    """Test class demonstrating unittest with generated YAML parameters."""
+
+    cases = parametrize_args.argvalues
+
+    def test_values(self):
+        """Test that integer and string parameters are correctly passed."""
+        for test_name, integer, string in self.cases:
+            with self.subTest(test_name=test_name, integer=integer, string=string):
+                print(f"\n==============\n")
+                print(f"Test name: {test_name}")
+                print(f"integer: {integer}\nstring: {string}")
+```
+
+Run the unittest example:
+
+```bash
+uv run python -m unittest examples.unittest_tests.test_examples
+```
+
+See the full examples in [`examples/pytest_tests`](examples/pytest_tests/) and [`examples/unittest_tests`](examples/unittest_tests/).
+
+## Configuration Types
+
+The library supports three types of parameter configurations:
+
+`test_cases` may also contain any additional fields and data types that can be
+represented in YAML and validated by your Pydantic models, such as booleans,
+lists, dictionaries, nested models, dates, or enums. These fields are passed to
+generated test arguments according to the model definition.
+
+The built-in parametrization config models currently expand only `int` and
+`str` values through `ParametrizeInteger` and `ParametrizeString`.
+
+```python
+class ExampleTestCase(BaseTestCase):
+    integer: ParametrizeInteger
+    string: ParametrizeString
+    list_of_types: list[int, str, float]
+```
+
+```yaml
+test_cases:
+  - test_name: int_1_10_2__str_a,b,c__42_abc_0.07
+    integer:
+        from: 1
+        to: 10
+        step: 2
+    string:
+        values: [a, b, c]
+    list_of_types: [42, abc, 0.07]
+```
+
+### Simple Value
+
+A single value for a parameter:
+
+```yaml
+integer: 42
+string: "hello"
+```
+
+### List of Values
+
+Multiple discrete values:
+
+```yaml
+integer:
+  values: [1, 2, 3]
+string:
+  values: [a, b, c]
+```
+
+### Range
+
+A range of values with start, end, and step:
+
+```yaml
+integer:
+  from: 1
+  to: 10
+  step: 2
+```
+
+This generates values: `[1, 3, 5, 7, 9]`.
+
+`step` must be a positive integer.
+
+## Available Models
+
+### ValueConfig
+
+Configuration for parameters with a simple value:
+
+```python
+class ValueConfig(BaseModel):
+    value: int | str
+```
+
+### ListConfig
+
+Configuration for parameters with a list of values:
+
+```python
+class ListConfig(BaseModel):
+    values: list[int | str]
+```
+
+### RangeConfig
+
+Configuration for parameters with a range:
+
+```python
+class RangeConfig(BaseModel):
+    from_: int
+    to: int
+    step: int
+```
+
+### Type Aliases
+
+```python
+ParametrizeIntegerConfigModels = RangeConfig | ListConfig | ValueConfig
+ParametrizeStringConfigModels = ListConfig | ValueConfig
+ParametrizeInteger = int | ParametrizeIntegerConfigModels
+ParametrizeString = str | ParametrizeStringConfigModels
+```
+
+### Base Classes
+
+```python
+class BaseTestCase(BaseModel, ABC):
+    test_name: str
+
+class BaseTestConfig(BaseModel):
+    name: str
+    test_cases: list[BaseTestCase]
+
+class BaseTestConfigCollection(BaseModel):
+    collection: list[BaseTestConfig]
+```
+
+## API Reference
+
+### `load_parametrize_args()`
+
+Loads and parses a YAML configuration file and returns parametrize arguments.
+
+```python
+def load_parametrize_args(
+    path_to_configs: Union[pathlib.Path, str],
+    config_collection_model: Type[TestConfigCollection],
+    collection_name: str,
+) -> ParametrizeArgs:
+```
+
+**Parameters:**
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `path_to_configs` | `pathlib.Path \| str` | Path to the YAML configuration file |
+| `config_collection_model` | `Type[TestConfigCollection]` | Pydantic model class for parsing the configuration |
+| `collection_name` | `str` | Name of the test collection to use from the configuration |
+
+**Returns:** `ParametrizeArgs` object containing parametrize arguments
+
+**Raises:** `ValueError` if no configuration is found for the given collection name
+
+### `ParametrizeArgs`
+
+Dataclass holding generated test parameters for pytest and unittest integrations:
+
+```python
+@dataclass
+class ParametrizeArgs:
+    argnames: str | None = None
+    argvalues: list[tuple] = field(default_factory=list)
+    ids: list[str] = field(default_factory=list)
+```
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `init_arg_names(model_cls)` | Initialize argument names from a Pydantic model |
+| `add_params(arg_id, arg_values)` | Add a parameterized test case |
+| `to_dict()` | Convert to dictionary for `metafunc.parametrize()` |
+| `keys` | Property returning the tuple of argument keys |
+| `keys_set` | Property returning the set of argument keys |
+
+## Exported Symbols
+
+```python
+__all__ = [
+    "BaseTestCase",
+    "BaseTestConfig",
+    "BaseTestConfigCollection",
+    "ListConfig",
+    "ParametrizeArgs",
+    "ParametrizeInteger",
+    "ParametrizeIntegerConfigModels",
+    "ParametrizeString",
+    "ParametrizeStringConfigModels",
+    "RangeConfig",
+    "ValueConfig",
+    "load_parametrize_args",
+]
+```
+
+## Project Structure
+
+```
+yaml-test-params/
+├── examples/
+│   ├── collection.yaml
+│   ├── models.py
+│   ├── pytest_tests/
+│   │   ├── conftest.py
+│   │   └── test_examples.py
+│   └── unittest_tests/
+│       └── test_examples.py
+├── tests/
+│   ├── test_args_loader.py
+│   ├── test_models.py
+│   └── test_parametrize_args.py
+├── yaml_test_params/
+│   ├── __init__.py
+│   ├── args_loader.py          # YAML configuration loader
+│   ├── models.py               # Pydantic model definitions
+│   └── parametrize_args.py     # Parametrize arguments dataclass
+├── CONTRIBUTING.md
+├── LICENSE.txt
+├── pyproject.toml
+└── README.md
+```
+
+## License
+
+MIT

yaml_test_params-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+yaml_test_params/__init__.py,sha256=JDcCzCarO5AuGL2jXYda9WuCndJSq7zNZtsg899SLHQ,676
+yaml_test_params/args_loader.py,sha256=G14mFL9OWMxMPMcjsgt2laEMAGatSF84-VLchkrwWZA,871
+yaml_test_params/models.py,sha256=aoDPyzZ7FaoGZMppUs4b8JqD6YJXuzut5-MgeRmUqd4,6476
+yaml_test_params/parametrize_args.py,sha256=HtbghZsa8tXkrZsp9oA87hnLGoBc1wdmTYd1Neyp64c,1714
+yaml_test_params/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+yaml_test_params-0.1.0.dist-info/METADATA,sha256=K6aLCk32dDFq3EZzm195QJ6sooNq5ZKjsMUIOLKuBYs,12248
+yaml_test_params-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+yaml_test_params-0.1.0.dist-info/licenses/LICENSE.txt,sha256=F-35ycqPcYW243OjxMHCggr_AHQgZLX2zvtZgobVEvo,1072
+yaml_test_params-0.1.0.dist-info/RECORD,,

yaml_test_params-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

yaml_test_params-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aleksei Fomenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.