gumlet 0.2.0__tar.gz

gumlet-0.2.0/.claude/skills/gumlet-python-sdk/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: gumlet-python-sdk
+description: "Python SDK for Gumlet API. Use when writing Python code that calls Gumlet API with the gumlet package: installing it, constructing and authenticating the client, and calling API operations."
+---
+
+# Gumlet Python SDK
+
+Generated Python client for Gumlet API, published as `gumlet`. Use the generated client instead of hand-writing HTTP requests.
+
+## Install
+
+```sh
+pip install gumlet
+```
+
+## Client setup and authentication
+
+```python
+import os
+
+from gumlet import Gumlet
+
+client = Gumlet(
+    api_key=os.environ.get("API_KEY"),
+)
+```
+
+Provide credentials using the options below. Environment variables are read automatically when the target runtime supports them:
+
+- `api_key` (env: `API_KEY`) — Credential for the API_KEY scheme.
+
+## Calling operations
+
+```python
+import os
+
+from gumlet import Gumlet
+
+client = Gumlet(
+    api_key=os.environ.get("API_KEY"),
+)
+
+video_asset = client.video_assets.create(
+    input="http://devimages.apple.com/iphone/samples/bipbop/bipbopall.m3u8",
+    collection_id="646df1c9173a4a2fcac180b4",
+    profile_id="646df1c9173a4a2fcac180b7",
+    format="ABR",
+    tag=["ball"],
+    description="some description",
+    metadata={"headermeta": "metavalue"},
+    call_to_actions=[
+        {
+            "start_time": 1,
+            "end_time": 90,
+            "text": "some test",
+            "url": "https://some-url.com",
+            "position_from_top": 11,
+            "position_from_right": 23,
+            "border_radius": "11",
+            "font_color": "#000001",
+            "background_color": "#ffffff",
+        }
+    ],
+    playlist_id="6597acd5ed6f26a9c5ca9633",
+    folder="697375fbfa2d1037283140e4",
+)
+
+print(video_asset)
+```
+
+Method names, parameter shapes, and response types are generated from the API description — do not guess them. Look up the exact call signature in [api.md](../../../api.md) before writing a call.
+
+## Error handling
+
+Non-success responses throw generated API errors. Error objects expose status, headers, response body, and request metadata where the target runtime supports it.
+
+```python
+from gumlet import APIStatusError
+
+try:
+    video_asset = client.video_assets.create(
+        input="http://devimages.apple.com/iphone/samples/bipbop/bipbopall.m3u8",
+        collection_id="646df1c9173a4a2fcac180b4",
+        profile_id="646df1c9173a4a2fcac180b7",
+        format="ABR",
+        tag=["ball"],
+        description="some description",
+        metadata={"headermeta": "metavalue"},
+        call_to_actions=[
+            {
+                "start_time": 1,
+                "end_time": 90,
+                "text": "some test",
+                "url": "https://some-url.com",
+                "position_from_top": 11,
+                "position_from_right": 23,
+                "border_radius": "11",
+                "font_color": "#000001",
+                "background_color": "#ffffff",
+            }
+        ],
+        playlist_id="6597acd5ed6f26a9c5ca9633",
+        folder="697375fbfa2d1037283140e4",
+    )
+except APIStatusError as err:
+    print(err.status_code, err.message)
+    raise
+```
+
+## Requirements
+
+- Python 3.8 or newer
+
+## Reference files
+
+- [README.md](../../../README.md) — full feature tour: client options, retries and timeouts, logging.
+- [api.md](../../../api.md) — complete catalogue of every operation with request and response types.

gumlet-0.2.0/.github/workflows/release-please.yml

@@ -0,0 +1,101 @@
+name: Release Please
+
+on:
+  # A release is cut when a human merges the platform-managed release PR into
+  # main (the PR's base, so its diff shows the full pending release).
+  # Every other push here runs release-please as well — commits written straight to
+  # this branch included — and cuts nothing, there being no release commit at the tip.
+  push:
+    branches:
+      - main
+    # The Scalar platform pushes these workflow files straight to main to keep them
+    # current between releases; that is bookkeeping, never a release. Running anyway is worse
+    # than pointless on a branch that has not been handed a .release-please-manifest.json yet —
+    # release-please fails the run outright when it cannot read one. A release commit always
+    # rewrites the manifest and the changelog, so this filter can never swallow one.
+    paths-ignore:
+      - '.github/workflows/**'
+  # Manual fallback only; nothing in the automated chain depends on dispatch.
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  # Required to update the merged release PR's autorelease labels after tagging.
+  pull-requests: write
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      # Consumed by the publish job's checkout: without this mapping the checkout ref would be
+      # empty and the publish would build the triggering branch head instead of the released
+      # tag's exact commit.
+      tag_name: ${{ steps.release.outputs.tag_name }}
+    steps:
+      - uses: googleapis/release-please-action@45996ed1f6d02564a971a2fa1b5860e934307cf7 # v5.0.0
+        id: release
+        with:
+          target-branch: main
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+          # Release PRs are opened and updated by the Scalar platform with its own
+          # credential (so their CI runs without manual approval); this workflow only
+          # cuts the tag + GitHub Release once a release PR is merged.
+          skip-github-pull-request: true
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        if: ${{ steps.release.outputs.release_created == 'true' }}
+        with:
+          fetch-depth: 0
+      # Merging the release PR into main is itself the promotion, but the
+      # version bump and changelog must also land back on scalar-next, or the next
+      # release PR would propose this release again. A real merge (never a plain
+      # commit push) so a squash- or rebase-merged release PR syncs just as well; the
+      # non-conventional message keeps the sync commit out of future changelogs. Plain
+      # (non-force) push on purpose: losing a race against a concurrent regeneration
+      # push fails loudly here, and the platform's next sync re-converges.
+      - name: Sync release back to scalar-next
+        if: ${{ steps.release.outputs.release_created == 'true' }}
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git fetch origin scalar-next
+          git checkout -B scalar-next origin/scalar-next
+          git merge --no-edit -m "Sync release ${{ steps.release.outputs.tag_name }} back to scalar-next" "${{ steps.release.outputs.sha }}"
+          git push origin scalar-next
+  publish:
+    needs: release-please
+    # `!cancelled()` keeps publishing even when the back-sync to the integration branch
+    # failed: a raced integration branch must not block the release from reaching its
+    # registry.
+    if: ${{ !cancelled() && needs.release-please.outputs.release_created == 'true' }}
+    runs-on: ubuntu-latest
+    # Job-level permissions replace the workflow's release-cutting grants with the publish
+    # floor. OIDC trusted publishing verifies this run's claims, which name this workflow
+    # file — register release-please.yml as the trusted publisher on the registry.
+    permissions:
+      contents: read
+      id-token: write
+      packages: write
+    env:
+      VERSIONING_POLICY: manual
+    steps:
+      # Publishing runs inline — a top-level job of this same run — rather than dispatching
+      # sdk-release.yml: workflow_dispatch resolves the target workflow on the repository's
+      # default branch only, so a dispatch would 404 whenever the release line is any other
+      # branch, while OIDC trusted publishing accepts this job because it stays top-level
+      # (never a reusable-workflow call). The release-please job cut the tag earlier in this
+      # run; checking it out publishes exactly the released commit, not the branch head that
+      # triggered the workflow.
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          ref: ${{ needs.release-please.outputs.tag_name }}
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.11"
+      - run: python -m pip install --upgrade build
+      - run: python -m build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
+        with:
+          skip-existing: true

gumlet-0.2.0/.github/workflows/release-title-edit.yml

@@ -0,0 +1,143 @@
+name: Release PR Version
+
+on:
+  # `edited` is not one of the default pull_request types, but it is the point of this
+  # workflow: retitling the release PR is how a maintainer picks an exact version. The
+  # other types keep the consistency check attached to the PR as it evolves.
+  pull_request:
+    types: [opened, reopened, edited, synchronize]
+
+# Read-only by default; only the job that pushes the Release-As commit widens this.
+permissions:
+  contents: read
+
+jobs:
+  version-consistency:
+    # Also the check name the release PR's footer tells maintainers to wait for.
+    name: Release PR version
+    # A release-shaped title against the release branch is the whole test here, with no clause
+    # on who opened the pull request or what branch it is rendered onto. This job only reads,
+    # and a pull request claiming to be a release is worth checking against the committed
+    # version whoever opened it. Every other pull request skips this job, which GitHub reports
+    # as neutral.
+    #
+    # Loose on purpose: the prefix, not the full semver pattern the script matches. A version
+    # typo'd into the title still reaches the script and fails there, rather than falling out
+    # of the guard and leaving no check at all — a missing check is not a failing one, and this
+    # is the check the release PR's footer tells maintainers to wait for before merging.
+    #
+    # It is also what keeps the workflow from failing silently if the platform ever opens
+    # release PRs from a different account: the bridge below stops firing, but this check still
+    # runs, the retitled version and the committed one disagree, and it turns red. The merge is
+    # blocked loudly instead of releasing the old version.
+    if: >-
+      ${{ github.event.pull_request.base.ref == 'main'
+      && startsWith(github.event.pull_request.title, 'release: ') }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          # The version committed on the PR head is what merging would actually release.
+          ref: ${{ github.event.pull_request.head.sha }}
+      # Fails while the title version and the committed version disagree — the window between
+      # a maintainer's retitle and the platform re-rendering the PR from it. Without this a
+      # merge in that window would tag a release whose own files self-report the old version,
+      # and a title release-please cannot parse would silently cut no release at all.
+      - name: Compare the title version with the committed version
+        env:
+          # The title is human input, so it is bound through the environment (never
+          # interpolated into the script) and matched against a strict semver pattern
+          # before it is read.
+          PR_TITLE: ${{ github.event.pull_request.title }}
+        run: |
+          pattern='^release: ((0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?)$'
+          if [[ ! "$PR_TITLE" =~ $pattern ]]; then
+            echo "::error::Release PR title must be \"release: X.Y.Z\" with a full semver version, got: $PR_TITLE"
+            exit 1
+          fi
+          title_version="${BASH_REMATCH[1]}"
+          manifest_version="$(jq -r '.["."]' .release-please-manifest.json)"
+          if [[ "$title_version" != "$manifest_version" ]]; then
+            echo "::error::Release PR title says $title_version but the pull request is versioned $manifest_version. Wait for the release PR to be re-rendered at $title_version before merging."
+            exit 1
+          fi
+          echo "Release PR title and committed version agree on $title_version."
+
+  apply-title-version:
+    name: Apply edited release version
+    # A human retitle of the open release PR is bridged into the canonical explicit-version
+    # mechanism (a Release-As commit on scalar-next, which the platform re-renders the
+    # release PR from). `changes.title` is only set when the title itself changed, and bot
+    # senders are ignored so the platform's own retitles cannot bounce back into another
+    # commit.
+    #
+    # Both signals are required here, unlike the read-only check above, and each covers what the
+    # other cannot. The author, because this job pushes with `contents: write` and a title is
+    # free text — anyone able to open a pull request against main could otherwise
+    # name a version and have it committed to scalar-next. `user.login` is set by GitHub when
+    # the pull request is opened and cannot be forged by whoever edits the title afterwards.
+    # The title, because those accounts open pull requests other than release PRs, and retitling
+    # one of those must not push a release.
+    #
+    # One login per platform deployment, since a repo generated by staging carries staging's
+    # app. Parenthesised because the group is ANDed with the title clause below: without the
+    # parens that `&&` would bind to the last login alone, letting the other accounts push a
+    # release off any title. Listed rather than matched on the shared `scalar-docs` stem — a
+    # prefix test would also admit any future `scalar-docs-*[bot]`, including someone else's.
+    if: >-
+      ${{ github.event.action == 'edited'
+      && github.event.changes.title != null
+      && github.event.sender.type != 'Bot'
+      && github.event.pull_request.state == 'open'
+      && github.event.pull_request.base.ref == 'main'
+      && (github.event.pull_request.user.login == 'scalar-docs[bot]'
+      || github.event.pull_request.user.login == 'scalar-docs-staging[bot]'
+      || github.event.pull_request.user.login == 'scalar-docs-development[bot]')
+      && startsWith(github.event.pull_request.title, 'release: ') }}
+    # One bridge run at a time per pull request, newest retitle wins. Two retitles in quick
+    # succession (a version typo corrected seconds later) would otherwise start two runs that
+    # both read the version committed on the PR head, both get past the no-op guard, and both
+    # push — and since each fetches scalar-next immediately before committing, the second
+    # push fast-forwards instead of failing. release-please honours the newest Release-As
+    # footer, so the release would land on whichever run happened to push last, not on the
+    # title the maintainer actually left behind.
+    concurrency:
+      group: release-title-edit-${{ github.event.pull_request.number }}
+      cancel-in-progress: true
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          # The PR head, so the version the pull request currently carries can be read before
+          # deciding whether anything needs to change.
+          ref: ${{ github.event.pull_request.head.sha }}
+      - name: Push a Release-As commit for the edited version
+        env:
+          PR_TITLE: ${{ github.event.pull_request.title }}
+        run: |
+          set -euo pipefail
+          pattern='^release: ((0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?)$'
+          if [[ ! "$PR_TITLE" =~ $pattern ]]; then
+            echo "::error::Release PR title must be \"release: X.Y.Z\" with a full semver version, got: $PR_TITLE"
+            exit 1
+          fi
+          # Only ever a validated semver from here on, so it is safe in a commit message.
+          version="${BASH_REMATCH[1]}"
+          manifest_version="$(jq -r '.["."]' .release-please-manifest.json)"
+          # The re-rendered PR is retitled to the version it now carries; stopping here keeps
+          # that from producing an endless chain of Release-As commits.
+          if [[ "$version" == "$manifest_version" ]]; then
+            echo "This release PR already carries $version; nothing to do."
+            exit 0
+          fi
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git fetch origin scalar-next
+          git checkout -B scalar-next origin/scalar-next
+          git commit --allow-empty -m "chore: release $version" -m "Release-As: $version"
+          # Plain (non-force) push: losing a race against a regeneration push fails loudly
+          # rather than discarding it, and the retitle can simply be repeated.
+          git push origin scalar-next
+          echo "Pushed Release-As: $version to scalar-next. The release PR will be re-rendered at that version."

gumlet-0.2.0/.github/workflows/sdk-ci.yml

@@ -0,0 +1,27 @@
+name: Python SDK CI
+
+on:
+  push:
+  pull_request:
+
+# Least privilege for a verification-only workflow: every job below only reads the checked-out
+# tree, so the run's GITHUB_TOKEN is narrowed to that regardless of the repository's default
+# grants. Declared at the workflow level so a job added later inherits the floor.
+permissions:
+  contents: read
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.11"
+      - run: python -m pip install --upgrade build
+      - run: python -m build
+      # Verification only, never auto-fix: the SDK is generated formatted, so a diff here means
+      # either hand-edited custom code or a regenerate that was not committed. ruff is pinned to
+      # the release that produced these bytes, since a formatter minor can change them.
+      - run: python -m pip install "ruff==0.16.1"
+      - run: ruff format --check .

gumlet-0.2.0/.github/workflows/sdk-release.yml

@@ -0,0 +1,34 @@
+name: Python SDK Release
+
+on:
+  # Manual re-publish only: the automated publish for each release runs as the `publish` job
+  # inside release-please.yml, in the same run that cuts the tag (dispatching a workflow here
+  # instead would resolve it on the repository's default branch only, which breaks releasing
+  # from any other release line). Dispatch this workflow at an existing release tag to re-run
+  # a failed or skipped publish. A dispatched run is top-level, so OIDC trusted-publisher
+  # claims name this file; register it as an additional trusted publisher only when manual
+  # re-publishes are used. Never add a workflow_call trigger here — registries reject
+  # publishes from called (reusable) workflows.
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+  packages: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    env:
+      VERSIONING_POLICY: manual
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.11"
+      - run: python -m pip install --upgrade build
+      - run: python -m build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
+        with:
+          skip-existing: true

gumlet-0.2.0/.gitignore

@@ -0,0 +1,10 @@
+# Generated by Scalar SDK Generator.
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+/dist/
+/build/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/

gumlet-0.2.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.2.0"
+}

gumlet-0.2.0/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## [0.2.0](https://github.com/gumlet/python-sdk/compare/v0.1.0...v0.2.0) (2026-09-18)
+
+
+### Features
+
+* **api:** initial SDK generation ([860d43a](https://github.com/gumlet/python-sdk/commit/860d43a0575952e5e8d658b65f4f99c332b7af59))

gumlet-0.2.0/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 Gumlet
+
+   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.