schemathesis 3.28.0__tar.gz → 3.29.0__tar.gz

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/build.yml

@@ -26,7 +26,7 @@ jobs:
     name: Generic pre-commit checks
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
         with:
           fetch-depth: 1
 
@@ -41,7 +41,7 @@ jobs:
     name: Documentation
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
         with:
           fetch-depth: 1
       - uses: ammaraskar/sphinx-action@master
@@ -66,7 +66,7 @@ jobs:
     name: Tests (Python ${{ matrix.python }} on ${{ matrix.os }} ${{ matrix.tox_env }})
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
         with:
           fetch-depth: 1
 
@@ -83,6 +83,6 @@ jobs:
         run: python -m tox
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4.3.1
+        uses: codecov/codecov-action@v4.4.1
         with:
           token: ${{ secrets.CODECOV_TOKEN }}

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/codeql-analysis.yml

@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4.1.4
+        uses: actions/checkout@v4.1.6
         with:
           # We must fetch at least the immediate parents so that if this is
           # a pull request then we can checkout the head.
@@ -38,7 +38,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.25.3
+        uses: github/codeql-action/init@v3.25.6
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -49,7 +49,7 @@ jobs:
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v3.25.3
+        uses: github/codeql-action/autobuild@v3.25.6
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -63,4 +63,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.25.3
+        uses: github/codeql-action/analyze@v3.25.6

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/codspeed.yml

@@ -11,7 +11,7 @@ jobs:
   benchmarks:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
       - uses: actions/setup-python@v5
         with:
           # Python 3.12 for flamegraph support

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/commit.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Check out code
-        uses: actions/checkout@v4.1.4
+        uses: actions/checkout@v4.1.6
         with:
           fetch-depth: 0
       - name: Run commitsar

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/example-build.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-22.04
 
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
 
       - name: Start containers
         run: docker compose up -d --build

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/master_update.yml

@@ -20,7 +20,7 @@ jobs:
             tag: "latest-bookworm"
 
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/release.yml

@@ -19,7 +19,7 @@ jobs:
             tag-suffix: "-bookworm"
 
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
 
       - name: Docker meta
         id: meta
@@ -68,7 +68,7 @@ jobs:
     name: Build and publish package to pypi.org
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
         with:
           fetch-depth: 1
 

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/test-corpus.yml

@@ -15,7 +15,7 @@ jobs:
     name: Corpus tests
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
         with:
           fetch-depth: 1
           submodules: true

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/test-hypothesis.yml

@@ -11,7 +11,7 @@ jobs:
     name: Hypothesis tests with CI profile
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
         with:
           fetch-depth: 1
 

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/update-corpus.yml

@@ -10,7 +10,7 @@ jobs:
     name: Update test corpus
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
         with:
           fetch-depth: 1
           submodules: true

{schemathesis-3.28.0 → schemathesis-3.29.0}/.github/workflows/update-pre-commit.yml

@@ -10,7 +10,7 @@ jobs:
     name: Update pre-commit
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4.1.4
+      - uses: actions/checkout@v4.1.6
         with:
           fetch-depth: 1
           submodules: true

{schemathesis-3.28.0 → schemathesis-3.29.0}/.pre-commit-config.yaml

@@ -38,12 +38,12 @@ repos:
         additional_dependencies: [types-click, types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.3
+    rev: v0.4.5
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.3
+    rev: v0.4.5
     hooks:
       - id: ruff
 

{schemathesis-3.28.0 → schemathesis-3.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.28.0
+Version: 3.29.0
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html
@@ -50,7 +50,7 @@ Requires-Dist: tomli<3.0,>=2.0.1
 Requires-Dist: werkzeug<4,>=0.16.0
 Requires-Dist: yarl<2.0,>=1.5
 Provides-Extra: bench
-Requires-Dist: pytest-codspeed==2.2.0; extra == 'bench'
+Requires-Dist: pytest-codspeed==2.2.1; extra == 'bench'
 Provides-Extra: cov
 Requires-Dist: coverage-enable-subprocess; extra == 'cov'
 Requires-Dist: coverage[toml]>=5.3; extra == 'cov'
@@ -342,6 +342,10 @@ Schemathesis is used by a number of project and companies, including direct usag
 
 ### Articles
 
+- [Implementing Schemathesis at PayLead](https://medium.com/paylead/implementing-schemathesis-at-paylead-a469a5d43626) by **Jérémy Pelletier** at **PayLead**
+  - **Description**: In-depth walkthrough including custom hooks, stateful testing and CI/CD integration.
+  - **Date**: 29 May 2024
+
 - [Auto-Generating & Validating OpenAPI Docs in Rust: A Streamlined Approach with Utoipa and Schemathesis](https://identeco.de/en/blog/generating_and_validating_openapi_docs_in_rust/) by **identeco**
   - **Description**: Demonstrates OpenAPI doc generation with Utoipa and validating it with Schemathesis.
   - **Date**: 01 Jun 2023

{schemathesis-3.28.0 → schemathesis-3.29.0}/README.md

@@ -264,6 +264,10 @@ Schemathesis is used by a number of project and companies, including direct usag
 
 ### Articles
 
+- [Implementing Schemathesis at PayLead](https://medium.com/paylead/implementing-schemathesis-at-paylead-a469a5d43626) by **Jérémy Pelletier** at **PayLead**
+  - **Description**: In-depth walkthrough including custom hooks, stateful testing and CI/CD integration.
+  - **Date**: 29 May 2024
+
 - [Auto-Generating & Validating OpenAPI Docs in Rust: A Streamlined Approach with Utoipa and Schemathesis](https://identeco.de/en/blog/generating_and_validating_openapi_docs_in_rust/) by **identeco**
   - **Description**: Demonstrates OpenAPI doc generation with Utoipa and validating it with Schemathesis.
   - **Date**: 01 Jun 2023

schemathesis-3.29.0/benches/references.py

@@ -0,0 +1,49 @@
+import pytest
+
+import schemathesis
+from schemathesis.specs.openapi.references import resolve_pointer
+
+RECURSIVE_SCHEMA = {
+    "openapi": "3.0.0",
+    "info": {"title": "Example API", "description": "An API to test Schemathesis", "version": "1.0.0"},
+    "components": {
+        "schemas": {
+            "Node": {
+                "type": "object",
+                "required": ["child"],
+                "properties": {"child": {"$ref": "#/components/schemas/Node"}},
+            }
+        }
+    },
+    "paths": {
+        "/foo": {
+            "post": {
+                "summary": "Test",
+                "description": "",
+                "requestBody": {
+                    "required": True,
+                    "content": {"application/json": {"schema": {"$ref": "#/components/schemas/Node"}}},
+                },
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "content": {},
+                    }
+                },
+            }
+        }
+    },
+}
+
+
+@pytest.mark.benchmark
+def test_inlining_during_resolution():
+    schema = schemathesis.from_dict(RECURSIVE_SCHEMA)
+    schema.resolver.resolve_all(
+        RECURSIVE_SCHEMA["paths"]["/foo"]["post"]["requestBody"]["content"]["application/json"]["schema"]
+    )
+
+
+@pytest.mark.benchmark
+def test_resolve_pointer():
+    resolve_pointer(RECURSIVE_SCHEMA, "/paths/~1foo/post/requestBody/content/application~1json/schema")

schemathesis-3.29.0/benches/schema.py

@@ -0,0 +1,224 @@
+import pathlib
+import sys
+
+import hypothesis
+import pytest
+from hypothesis import HealthCheck, Phase, Verbosity
+
+import schemathesis
+from schemathesis.runner import from_schema
+
+CURRENT_DIR = pathlib.Path(__file__).parent.absolute()
+sys.path.append(str(CURRENT_DIR.parent))
+CATALOG_DIR = CURRENT_DIR / "data"
+
+from corpus.tools import read_corpus_file, load_from_corpus  # noqa: E402
+
+CORPUS_OPENAPI_30 = read_corpus_file("openapi-3.0")
+CORPUS_SWAGGER_20 = read_corpus_file("swagger-2.0")
+# Small size (~2k lines in YAML)
+BBCI = load_from_corpus("bbci.co.uk/1.0.json", CORPUS_OPENAPI_30)
+BBCI_SCHEMA = schemathesis.from_dict(BBCI)
+BBCI_OPERATIONS = list(BBCI_SCHEMA.get_all_operations())
+# Medium size (~8k lines in YAML)
+VMWARE = load_from_corpus("vmware.local/vrni/1.0.0.json", CORPUS_OPENAPI_30)
+VMWARE_SCHEMA = schemathesis.from_dict(VMWARE)
+VMWARE_OPERATIONS = list(VMWARE_SCHEMA.get_all_operations())
+# Large size (~92k lines in YAML)
+STRIPE = load_from_corpus("stripe.com/2022-11-15.json", CORPUS_OPENAPI_30)
+STRIPE_SCHEMA = schemathesis.from_dict(STRIPE)
+# Medium GraphQL schema (~6k lines)
+UNIVERSE = load_from_corpus("universe.json", "graphql")
+UNIVERSE_SCHEMA = schemathesis.graphql.from_dict(UNIVERSE)
+
+APPVEYOR = load_from_corpus("appveyor.com/1.0.0.json", CORPUS_SWAGGER_20)
+EVETECH = load_from_corpus("evetech.net/0.8.6.json", CORPUS_SWAGGER_20)
+OSISOFT = load_from_corpus("osisoft.com/1.11.1.5383.json", CORPUS_SWAGGER_20)
+ML_WEBSERVICES = load_from_corpus("azure.com/machinelearning-webservices/2017-01-01.json", CORPUS_SWAGGER_20)
+AZURE_NETWORK = load_from_corpus("azure.com/network/2016-03-30.json", CORPUS_SWAGGER_20)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "raw_schema, loader",
+    [
+        (BBCI, schemathesis.from_dict),
+        (VMWARE, schemathesis.from_dict),
+        (UNIVERSE, schemathesis.graphql.from_dict),
+        (APPVEYOR, schemathesis.from_dict),
+        (EVETECH, schemathesis.from_dict),
+        (OSISOFT, schemathesis.from_dict),
+        (ML_WEBSERVICES, schemathesis.from_dict),
+        (AZURE_NETWORK, schemathesis.from_dict),
+    ],
+    ids=("bbci", "vmware", "universe", "appveyor", "evetech", "osisoft", "ml_webservices", "azure_network"),
+)
+def test_iter_operations(raw_schema, loader):
+    schema = loader(raw_schema)
+
+    for _ in schema.get_all_operations():
+        pass
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "raw_schema, loader",
+    [
+        (BBCI, schemathesis.from_dict),
+        (VMWARE, schemathesis.from_dict),
+        (STRIPE, schemathesis.from_dict),
+        (UNIVERSE, schemathesis.graphql.from_dict),
+        (APPVEYOR, schemathesis.from_dict),
+        (EVETECH, schemathesis.from_dict),
+        (OSISOFT, schemathesis.from_dict),
+        (ML_WEBSERVICES, schemathesis.from_dict),
+        (AZURE_NETWORK, schemathesis.from_dict),
+    ],
+    ids=("bbci", "vmware", "stripe", "universe", "appveyor", "evetech", "osisoft", "ml_webservices", "azure_network"),
+)
+def test_length(raw_schema, loader):
+    schema = loader(raw_schema)
+    _ = len(schema)
+
+
+# Schemas with pre-populated cache
+BBCI_OPERATION_ID = "Get_Categories_"
+BBCI_OPERATION_KEY = ("/categories", "get")
+BBCI_SCHEMA_WITH_OPERATIONS_CACHE = schemathesis.from_dict(BBCI)
+BBCI_SCHEMA_WITH_OPERATIONS_CACHE.get_operation_by_id(BBCI_OPERATION_ID)
+VMWARE_OPERATION_ID = "listProblemEvents"
+VMWARE_OPERATION_KEY = ("/entities/problems", "get")
+VMWARE_SCHEMA_WITH_OPERATIONS_CACHE = schemathesis.from_dict(VMWARE)
+VMWARE_SCHEMA_WITH_OPERATIONS_CACHE.get_operation_by_id(VMWARE_OPERATION_ID)
+UNIVERSE_OPERATION_KEY = ("Query", "manageTickets")
+UNIVERSE_SCHEMA_WITH_OPERATIONS_CACHE = schemathesis.graphql.from_dict(UNIVERSE)
+UNIVERSE_SCHEMA_WITH_OPERATIONS_CACHE[UNIVERSE_OPERATION_KEY[0]][UNIVERSE_OPERATION_KEY[1]]
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "raw_schema, key, loader",
+    [
+        (BBCI, BBCI_OPERATION_KEY, schemathesis.from_dict),
+        (VMWARE, VMWARE_OPERATION_KEY, schemathesis.from_dict),
+        (UNIVERSE, UNIVERSE_OPERATION_KEY, schemathesis.graphql.from_dict),
+    ],
+    ids=("bbci", "vmware", "universe"),
+)
+def test_get_operation_single(raw_schema, key, loader):
+    schema = loader(raw_schema)
+    current = schema
+    for segment in key:
+        current = current[segment]
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "schema, key",
+    [
+        (BBCI_SCHEMA_WITH_OPERATIONS_CACHE, BBCI_OPERATION_KEY),
+        (VMWARE_SCHEMA_WITH_OPERATIONS_CACHE, VMWARE_OPERATION_KEY),
+        (UNIVERSE_SCHEMA_WITH_OPERATIONS_CACHE, UNIVERSE_OPERATION_KEY),
+    ],
+    ids=("bbci", "vmware", "universe"),
+)
+def test_get_operation_repeatedly(schema, key):
+    current = schema
+    for segment in key:
+        current = current[segment]
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "raw_schema, key",
+    [(BBCI, BBCI_OPERATION_ID), (VMWARE, VMWARE_OPERATION_ID)],
+    ids=("bbci", "vmware"),
+)
+def test_get_operation_by_id_single(raw_schema, key):
+    schema = schemathesis.from_dict(raw_schema)
+    _ = schema.get_operation_by_id(key)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "schema, key",
+    [
+        (BBCI_SCHEMA_WITH_OPERATIONS_CACHE, BBCI_OPERATION_ID),
+        (VMWARE_SCHEMA_WITH_OPERATIONS_CACHE, VMWARE_OPERATION_ID),
+    ],
+    ids=("bbci", "vmware"),
+)
+def test_get_operation_by_id_repeatedly(schema, key):
+    _ = schema.get_operation_by_id(key)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "raw_schema, key",
+    [
+        (BBCI, "#/paths/~1categories/get"),
+        (VMWARE, "#/paths/~1entities~1problems/get"),
+    ],
+    ids=("bbci", "vmware"),
+)
+def test_get_operation_by_reference_single(raw_schema, key):
+    schema = schemathesis.from_dict(raw_schema)
+    _ = schema.get_operation_by_reference(key)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "schema, key",
+    [
+        (BBCI_SCHEMA_WITH_OPERATIONS_CACHE, "#/paths/~1categories/get"),
+        (VMWARE_SCHEMA_WITH_OPERATIONS_CACHE, "#/paths/~1entities~1problems/get"),
+    ],
+    ids=("bbci", "vmware"),
+)
+def test_get_operation_by_reference_repeatedly(schema, key):
+    _ = schema.get_operation_by_reference(key)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize("operations", [BBCI_OPERATIONS, VMWARE_OPERATIONS], ids=("bbci", "vmware"))
+def test_as_json_schema(operations):
+    for operation in operations:
+        for parameter in operation.ok().iter_parameters():
+            _ = parameter.as_json_schema(operation)
+
+
+@pytest.mark.benchmark
+def test_events():
+    runner = from_schema(
+        BBCI_SCHEMA,
+        checks=(),
+        count_operations=False,
+        count_links=False,
+        hypothesis_settings=hypothesis.settings(
+            deadline=None,
+            database=None,
+            max_examples=1,
+            derandomize=True,
+            suppress_health_check=list(HealthCheck),
+            phases=[Phase.explicit, Phase.generate],
+            verbosity=Verbosity.quiet,
+        ),
+    )
+    for _ in runner.execute():
+        pass
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize("raw_schema", [BBCI, VMWARE, STRIPE], ids=("bbci", "vmware", "stripe"))
+def test_rewritten_components(raw_schema):
+    schema = schemathesis.from_dict(raw_schema)
+
+    _ = schema.rewritten_components
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize("raw_schema", [BBCI, VMWARE, STRIPE], ids=("bbci", "vmware", "stripe"))
+def test_links_count(raw_schema):
+    schema = schemathesis.from_dict(raw_schema)
+
+    _ = schema.links_count

schemathesis-3.29.0/corpus/tools.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import io
+import os
+import pathlib
+import re
+import tarfile
+from typing import Any, Dict, Generator
+
+import yaml
+
+try:
+    from yaml import CSafeLoader as SafeLoader
+except ImportError:
+    from yaml import SafeLoader  # type: ignore
+
+try:
+    import orjson
+    from orjson import loads as json_loads
+
+    def json_dumps(obj: Any) -> bytes:
+        return orjson.dumps(obj)
+
+except ImportError:
+    import json
+    from json import loads as json_loads
+
+    def json_dumps(obj: Any) -> bytes:
+        return json.dumps(obj, separators=(",", ":")).encode("utf-8")
+
+
+CURRENT_DIR = pathlib.Path(__file__).parent.absolute()
+CATALOG_DIR = CURRENT_DIR / "../test-corpus/openapi-directory/APIs/"
+DATA_DIR = CURRENT_DIR / "data"
+
+Loader = type("YAMLLoader", (SafeLoader,), {})
+Loader.yaml_implicit_resolvers = {  # type: ignore[attr-defined]
+    key: [(tag, regexp) for tag, regexp in mapping if tag != "tag:yaml.org,2002:timestamp"]
+    for key, mapping in Loader.yaml_implicit_resolvers.copy().items()  # type: ignore[attr-defined]
+}
+
+Loader.add_implicit_resolver(  # type: ignore
+    "tag:yaml.org,2002:float",
+    re.compile(
+        r"""^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+]?[0-9]+)?
+                    |[-+]?(?:[0-9][0-9_]*)(?:[eE][-+]?[0-9]+)
+                    |\.[0-9_]+(?:[eE][-+]?[0-9]+)?
+                    |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
+                    |[-+]?\.(?:inf|Inf|INF)
+                    |\.(?:nan|NaN|NAN))$""",
+        re.X,
+    ),
+    list("-+0123456789."),
+)
+
+
+def construct_mapping(self: SafeLoader, node: yaml.Node, deep: bool = False) -> dict[str, Any]:
+    if isinstance(node, yaml.MappingNode):
+        self.flatten_mapping(node)  # type: ignore
+    mapping = {}
+    for key_node, value_node in node.value:
+        if key_node.tag != "tag:yaml.org,2002:str":
+            key = key_node.value
+        else:
+            key = self.construct_object(key_node, deep)  # type: ignore
+        mapping[key] = self.construct_object(value_node, deep)  # type: ignore
+    return mapping
+
+
+Loader.construct_mapping = construct_mapping  # type: ignore
+
+
+def create_tar_gz(schemas: Dict[str, Dict[str, Any]], output_dir: pathlib.Path) -> None:
+    """Create compressed API schemas corpus."""
+    os.makedirs(output_dir, exist_ok=True)
+
+    for version, version_schemas in schemas.items():
+        if version.startswith("2."):
+            output_path = output_dir / f"swagger-{version}.tar.gz"
+        else:
+            output_path = output_dir / f"openapi-{version}.tar.gz"
+
+        with tarfile.open(output_path, "w:gz") as tar_gz:
+            for schema_name, schema in version_schemas.items():
+                json_path = f"{schema_name}.json"
+                json_data = json_dumps(schema)
+                info = tarfile.TarInfo(name=json_path)
+                info.size = len(json_data)
+                tar_gz.addfile(info, io.BytesIO(json_data))
+
+
+def parse_schemas(directory: pathlib.Path) -> Dict[str, Dict[str, Any]]:
+    schemas: Dict[str, Dict[str, Any]] = {}
+
+    for root, _, files in os.walk(directory):
+        for file in files:
+            if file.endswith("swagger.yaml") or file.endswith("openapi.yaml"):
+                file_path = os.path.join(root, file)
+                try:
+                    with open(file_path, "r") as fd:
+                        schema = yaml.load(fd, Loader)
+                    version = get_schema_version(schema)
+                    schema_name = (
+                        os.path.relpath(file_path, directory)
+                        .replace(os.sep, "/")
+                        .replace("/swagger.yaml", "")
+                        .replace("/openapi.yaml", "")
+                    )
+                    if version not in schemas:
+                        schemas[version] = {}
+                    schemas[version][schema_name] = schema
+                except (yaml.YAMLError, KeyError):
+                    print(f"Error parsing {file_path}")
+
+    return schemas
+
+
+def get_schema_version(schema: Dict[str, Any]) -> str:
+    """Extract the schema version from the parsed schema."""
+    if "openapi" in schema:
+        return schema["openapi"][:3]
+    elif "swagger" in schema:
+        return schema["swagger"]
+    else:
+        raise ValueError("Invalid schema format")
+
+
+def load_from_corpus(file_name: str, corpus: tarfile.TarFile | str) -> dict[str, Any]:
+    if isinstance(corpus, str):
+        corpus = read_corpus_file(corpus)
+    extracted = corpus.extractfile(file_name)
+    if extracted is not None:
+        return json_loads(extracted.read())
+    raise FileNotFoundError(file_name)
+
+
+def read_corpus_file(name: str) -> tarfile.TarFile:
+    return tarfile.open(DATA_DIR / f"{name}.tar.gz", "r:gz")
+
+
+def iter_corpus_file(name: str) -> Generator[tuple[str, dict[str, Any]], None, None]:
+    """Iterate over the corpus file."""
+    with read_corpus_file(name) as tar:
+        for member in tar.getmembers():
+            extracted = tar.extractfile(member)
+            if extracted is not None:
+                yield member.name, json_loads(extracted.read())
+
+
+def iter_all_corpus_files() -> Generator[tuple[str, str, dict[str, Any]], None, None]:
+    """Iterate over all corpus files."""
+    for corpus_name in os.listdir(DATA_DIR):
+        if corpus_name.endswith(".tar.gz"):
+            for file_name, schema in iter_corpus_file(corpus_name):
+                yield corpus_name, file_name, schema
+
+
+if __name__ == "__main__":
+    schemas = parse_schemas(CATALOG_DIR)
+    create_tar_gz(schemas, DATA_DIR)