orgdatacore 2.0.0__py3-none-any.whl

orgdatacore-2.0.0.dist-info/METADATA

@@ -0,0 +1,444 @@
+Metadata-Version: 2.5
+Name: orgdatacore
+Version: 2.0.0
+Summary: Python library for organizational data management
+Project-URL: Homepage, https://github.com/openshift-eng/cyborg-data/tree/main/python
+Project-URL: Repository, https://github.com/openshift-eng/cyborg-data
+Project-URL: Changelog, https://github.com/openshift-eng/cyborg-data/blob/main/python/CHANGELOG.md
+Project-URL: Issues, https://github.com/openshift-eng/cyborg-data/issues
+Author: Continuous Release Tooling - Red Hat
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: employees,organizational-data,organizations,teams
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: orgindex-schema<0.2.0,>=0.1.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: isort>=5.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: gcs
+Requires-Dist: google-cloud-storage>=2.0.0; extra == 'gcs'
+Description-Content-Type: text/markdown
+
+# orgdatacore - Python
+
+Python port of the Go orgdatacore library for organizational data management.
+
+This library provides thread-safe access to organizational data including employees, teams, organizations, pillars, and team groups.
+
+## Installation
+
+### Using UV (Recommended)
+
+[UV](https://github.com/astral-sh/uv) is a fast Python package installer.
+
+```bash
+# Install the package
+uv pip install -e .
+
+# With GCS support (recommended for production)
+uv pip install -e ".[gcs]"
+
+# Or use uv sync for development (installs dev dependencies)
+uv sync
+
+# With GCS support
+uv sync --extra gcs
+```
+
+### Using pip
+
+```bash
+# Install from source
+pip install -e .
+
+# With GCS support (recommended for production)
+pip install -e ".[gcs]"
+
+# With development dependencies
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+### Using GCS (Recommended for Production)
+
+```python
+from orgdatacore import Service, GCSConfig
+from orgdatacore.datasources import GCSDataSourceWithSDK
+from datetime import timedelta
+
+# Configure GCS data source
+config = GCSConfig(
+    bucket="your-bucket",
+    object_path="path/to/org_data.json",
+    project_id="your-project",
+    check_interval=timedelta(minutes=5),
+)
+source = GCSDataSourceWithSDK(config)
+
+# Option 1: Constructor injection (recommended for simple cases)
+service = Service(data_source=source)
+
+# Option 2: Lazy loading (matches Go API, good for deferred loading)
+# service = Service()
+# service.load_from_data_source(source)
+
+# Query employees
+employee = service.get_employee_by_uid("jsmith")
+if employee:
+    print(f"Found: {employee.full_name}")
+```
+
+### Using a Custom DataSource (S3, Azure, etc.)
+
+The library supports pluggable data sources. Implement the `DataSource` interface for your storage backend:
+
+```python
+from orgdatacore import Service
+from orgdatacore.interface import DataSource
+from typing import BinaryIO, Callable, Optional
+from io import BytesIO
+
+class S3DataSource(DataSource):
+    """Example custom DataSource for AWS S3."""
+    
+    def __init__(self, bucket: str, key: str):
+        self.bucket = bucket
+        self.key = key
+    
+    def load(self) -> BinaryIO:
+        import boto3
+        s3 = boto3.client('s3')
+        response = s3.get_object(Bucket=self.bucket, Key=self.key)
+        return BytesIO(response['Body'].read())
+    
+    def watch(self, callback: Callable[[], Optional[Exception]]) -> Optional[Exception]:
+        # Implement watching logic (polling, S3 events, etc.)
+        return None
+    
+    def __str__(self) -> str:
+        return f"s3://{self.bucket}/{self.key}"
+
+# Use your custom data source
+service = Service()
+source = S3DataSource("my-org-bucket", "data/org_data.json")
+service.load_from_data_source(source)
+```
+
+## API Reference
+
+### Service
+
+The main class providing access to organizational data.
+
+#### Core Data Access
+
+- `get_employee_by_uid(uid: str) -> Employee | None`
+- `get_employee_by_slack_id(slack_id: str) -> Employee | None`
+- `get_employee_by_github_id(github_id: str) -> Employee | None`
+- `get_manager_for_employee(uid: str) -> Employee | None`
+- `get_team_by_name(team_name: str) -> Team | None`
+- `get_org_by_name(org_name: str) -> Org | None`
+- `get_pillar_by_name(pillar_name: str) -> Pillar | None`
+- `get_team_group_by_name(team_group_name: str) -> TeamGroup | None`
+
+#### Membership Queries
+
+- `get_teams_for_uid(uid: str) -> list[str]`
+- `get_teams_for_slack_id(slack_id: str) -> list[str]`
+- `get_team_members(team_name: str) -> list[Employee]`
+- `is_employee_in_team(uid: str, team_name: str) -> bool`
+- `is_slack_user_in_team(slack_id: str, team_name: str) -> bool`
+
+#### Organization Queries
+
+- `is_employee_in_org(uid: str, org_name: str) -> bool`
+- `is_slack_user_in_org(slack_id: str, org_name: str) -> bool`
+- `get_user_organizations(slack_user_id: str) -> list[OrgInfo]`
+
+#### Data Management
+
+- `get_version() -> DataVersion`
+- `load_from_data_source(source: DataSource) -> None`
+- `start_data_source_watcher(source: DataSource) -> None`
+
+#### Hierarchy Queries
+
+- `get_hierarchy_path(entity_name: str, entity_type: str) -> list[HierarchyPathEntry]`
+- `get_descendants_tree(entity_name: str) -> HierarchyNode | None`
+
+#### Jira Queries
+
+- `get_jira_projects() -> list[str]`
+- `get_jira_components(project: str) -> list[str]`
+- `get_teams_by_jira_project(project: str) -> list[JiraOwnerInfo]`
+- `get_teams_by_jira_component(project: str, component: str) -> list[JiraOwnerInfo]`
+- `get_jira_ownership_for_team(team_name: str) -> list[dict]`
+
+#### Component Queries
+
+- `get_component_by_name(name: str) -> Component | None`
+- `get_all_components() -> list[Component]`
+
+#### Enumeration
+
+- `get_all_employee_uids() -> list[str]`
+- `get_all_team_names() -> list[str]`
+- `get_all_org_names() -> list[str]`
+- `get_all_pillar_names() -> list[str]`
+- `get_all_team_group_names() -> list[str]`
+
+### DataSource Protocol
+
+Implement this protocol for custom storage backends (no inheritance needed):
+
+```python
+from typing import BinaryIO, Callable, Optional
+
+class MyDataSource:  # No inheritance needed!
+    def load(self) -> BinaryIO:
+        """Return a file-like object containing JSON data."""
+        ...
+    
+    def watch(self, callback: Callable[[], Optional[Exception]]) -> Optional[Exception]:
+        """Start watching for changes, call callback when data updates."""
+        ...
+    
+    def __str__(self) -> str:
+        """Return a description of this data source."""
+        ...
+```
+
+### Data Sources
+
+#### GCSDataSource / GCSDataSourceWithSDK
+
+For production use with Google Cloud Storage (requires `google-cloud-storage`):
+
+```python
+from orgdatacore import GCSConfig
+from orgdatacore.datasources import GCSDataSourceWithSDK
+from datetime import timedelta
+
+config = GCSConfig(
+    bucket="your-bucket",
+    object_path="path/to/data.json",
+    project_id="your-project",
+    check_interval=timedelta(minutes=5),
+)
+source = GCSDataSourceWithSDK(config)
+```
+
+## Async API
+
+For asyncio-based applications (FastAPI, aiohttp, etc.), use `AsyncService`:
+
+### Basic Async Usage
+
+```python
+import asyncio
+from orgdatacore import AsyncService, GCSConfig
+from orgdatacore._async import AsyncGCSDataSource
+
+async def main():
+    # Configure async GCS data source
+    config = GCSConfig(
+        bucket="your-bucket",
+        object_path="path/to/org_data.json",
+        project_id="your-project",
+    )
+    source = AsyncGCSDataSource(config)
+
+    # Create and initialize async service
+    service = AsyncService()
+    await service.load_from_data_source(source)
+
+    # Query employees (all methods are async)
+    employee = await service.get_employee_by_uid("jsmith")
+    if employee:
+        print(f"Found: {employee.full_name}")
+
+    # Check team membership
+    is_member = await service.is_employee_in_team("jsmith", "platform-team")
+
+    # Get hierarchy path
+    path = await service.get_hierarchy_path("platform-team", "team")
+    for entry in path:
+        print(f"  {entry.type}: {entry.name}")
+
+asyncio.run(main())
+```
+
+### Using with Data Watcher
+
+```python
+import asyncio
+from orgdatacore import AsyncService, GCSConfig
+from orgdatacore._async import AsyncGCSDataSource
+
+async def run_with_auto_reload():
+    config = GCSConfig(
+        bucket="your-bucket",
+        object_path="org_data.json",
+        project_id="your-project",
+    )
+    source = AsyncGCSDataSource(config)
+    service = AsyncService()
+
+    # Start watcher - loads data and monitors for changes
+    await service.start_data_source_watcher(source)
+
+    try:
+        # Service auto-reloads when data changes
+        while True:
+            teams = await service.get_all_team_names()
+            print(f"Currently tracking {len(teams)} teams")
+            await asyncio.sleep(60)
+    finally:
+        await service.stop_watcher()
+
+asyncio.run(run_with_auto_reload())
+```
+
+### AsyncService API Reference
+
+The `AsyncService` has the same methods as `Service`, but all are async:
+
+#### Core Data Access
+- `await get_employee_by_uid(uid)` → `Employee | None`
+- `await get_employee_by_email(email)` → `Employee | None`
+- `await get_employee_by_slack_id(slack_id)` → `Employee | None`
+- `await get_employee_by_github_id(github_id)` → `Employee | None`
+- `await get_manager_for_employee(uid)` → `Employee | None`
+- `await get_team_by_name(name)` → `Team | None`
+- `await get_org_by_name(name)` → `Org | None`
+- `await get_pillar_by_name(name)` → `Pillar | None`
+- `await get_team_group_by_name(name)` → `TeamGroup | None`
+- `await get_component_by_name(name)` → `Component | None`
+
+#### Membership Queries
+- `await get_teams_for_uid(uid)` → `list[str]`
+- `await get_teams_for_slack_id(slack_id)` → `list[str]`
+- `await get_team_members(team_name)` → `tuple[Employee, ...]`
+- `await get_org_members(org_name)` → `tuple[Employee, ...]`
+- `await is_employee_in_team(uid, team_name)` → `bool`
+- `await is_slack_user_in_team(slack_id, team_name)` → `bool`
+- `await is_employee_in_org(uid, org_name)` → `bool`
+- `await is_slack_user_in_org(slack_id, org_name)` → `bool`
+
+#### Hierarchy Queries
+- `await get_hierarchy_path(entity_name, entity_type)` → `list[HierarchyPathEntry]`
+- `await get_descendants_tree(entity_name)` → `HierarchyNode | None`
+- `await get_user_organizations(uid)` → `tuple[OrgInfo, ...]`
+
+#### Jira Queries
+- `await get_jira_projects()` → `list[str]`
+- `await get_jira_components(project)` → `list[str]`
+- `await get_teams_by_jira_project(project)` → `list[JiraOwnerInfo]`
+- `await get_teams_by_jira_component(project, component)` → `list[JiraOwnerInfo]`
+- `await get_jira_ownership_for_team(team_name)` → `list[dict]`
+
+#### Enumeration
+- `await get_all_employee_uids()` → `list[str]`
+- `await get_all_team_names()` → `list[str]`
+- `await get_all_org_names()` → `list[str]`
+- `await get_all_pillar_names()` → `list[str]`
+- `await get_all_team_group_names()` → `list[str]`
+- `await get_all_employees()` → `tuple[Employee, ...]`
+- `await get_all_teams()` → `tuple[Team, ...]`
+- `await get_all_orgs()` → `tuple[Org, ...]`
+- `await get_all_pillars()` → `tuple[Pillar, ...]`
+- `await get_all_team_groups()` → `tuple[TeamGroup, ...]`
+- `await get_all_components()` → `tuple[Component, ...]`
+
+#### Data Management
+- `await load_from_data_source(source)` → `None`
+- `await start_data_source_watcher(source)` → `None`
+- `await stop_watcher()` → `None`
+- `is_healthy()` → `bool` (sync)
+- `is_ready()` → `bool` (sync)
+- `get_version()` → `DataVersion` (sync)
+
+## Thread Safety
+
+The `Service` class is thread-safe. All read operations can be performed concurrently, and data reloading is atomic.
+
+The `AsyncService` class is asyncio-safe, using `asyncio.Lock` to protect data access during concurrent async operations.
+
+## Development
+
+### Using UV (Recommended)
+
+```bash
+# Set up development environment
+uv sync
+
+# Run tests
+uv run pytest
+
+# Run tests with coverage
+uv run pytest --cov=orgdatacore --cov-report=html
+
+# Type checking
+uv run mypy orgdatacore
+
+# Code formatting
+uv run black orgdatacore tests
+uv run isort orgdatacore tests
+
+# Linting
+uv run ruff check orgdatacore tests
+```
+
+### Using pip
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run tests with coverage
+pytest --cov=orgdatacore --cov-report=html
+
+# Type checking
+mypy orgdatacore
+
+# Code formatting
+black orgdatacore tests
+isort orgdatacore tests
+```
+
+## Examples
+
+Run the GCS demo with real data:
+
+```bash
+# Make sure you're logged in
+gcloud auth application-default login
+
+# Install GCS support
+pip install -e ".[gcs]"
+
+# Run the demo
+python examples/gcs_demo.py
+```
+
+## License
+
+Apache-2.0

orgdatacore-2.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+orgdatacore/__init__.py,sha256=kL05FmXMp1uIn8RvxkOxPhdGYvVCayeuAeePyDF_TcM,3469
+orgdatacore/_anonymization.py,sha256=1dgK2n7EO1Jj4ufkj38IOHyVpPyDTAYrP3cNQWlN1eA,16671
+orgdatacore/_async.py,sha256=gpYNEt1qjCd394uD4Au8LzCyBdGTBDJ2Namz1Xyi0ys,55935
+orgdatacore/_exceptions.py,sha256=j03sI3av5PXEZtWgfJFb_PIlx8JAGSF8RlojWlo_Ukw,1743
+orgdatacore/_gcs.py,sha256=IukQ_ghMrYpdYT-cy_tA6dXBXgKdusdcrk_fkwoTJKc,10610
+orgdatacore/_log.py,sha256=VN9TRttglj83dnCozUcKzzrjijT5ezYhj7RRsgy_YyM,2515
+orgdatacore/_redaction.py,sha256=7f_EUFKYEH1Zbkp7imVbot3Bo8aLXdCYNYM4k64p1XU,6707
+orgdatacore/_serialization.py,sha256=fcadan_S1db78m8xHUuFEAxSVABR2_bbZ3AzIyGdMFE,758
+orgdatacore/_service.py,sha256=7okehs8llK9kJ1-wRyzaGSxHe4JXIxOlXmMn8ScURsM,53427
+orgdatacore/_types.py,sha256=jeqWMVL72xCWpjs6uau3qQak71uD6x8BAUw9J55ANUY,6793
+orgdatacore/_version.py,sha256=Y3soZWYzN1FXxCY1fXsybM6UDKS1VpzAyUy5AXnEIZg,3792
+orgdatacore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orgdatacore/_internal/__init__.py,sha256=-agyFZJf2TLyXiZkcCSJk-ZPYM-EFPj0wNvHL7G1WdI,198
+orgdatacore/_internal/testing/__init__.py,sha256=jIYMixjP-4M4UZbTtxjBJI5ElUmdg5xQcmATYNbBP1k,445
+orgdatacore/_internal/testing/fake_gcs.py,sha256=QmzbMm3Gnc_3O6KmqqHGRQBGx9bkrgbHDnZ9s9wKWYA,5536
+orgdatacore/_internal/testing/filesource.py,sha256=nXawRG_l9_INhw0gba9ATj4jwJJUbzjNBcaTfIIFJEM,4887
+orgdatacore/_internal/testing/helpers.py,sha256=KsSYgnYcyZf7xgzMJSQYf1pyD931tJNxzX-npvRMFRg,6162
+orgdatacore-2.0.0.dist-info/METADATA,sha256=DAryDpXRUEU4CYdRhGUxhIbDoWhYt3BFqulPgyRatAk,13111
+orgdatacore-2.0.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+orgdatacore-2.0.0.dist-info/licenses/LICENSE,sha256=ZMaOn4vY3xHcEiUhtFO26tLdPeMgeP5ahb-67-3QaS0,11343
+orgdatacore-2.0.0.dist-info/RECORD,,

orgdatacore-2.0.0.dist-info/WHEEL

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

orgdatacore-2.0.0.dist-info/licenses/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 2026 Red Hat, LLC.
+
+   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.