hidden-moves-github-projects 0.1.0__py3-none-any.whl

hidden_moves_github_projects/writes.py

@@ -0,0 +1,327 @@
+"""Two fixed mutations, guarded by trusted local Project authorization."""
+
+from collections.abc import Iterable
+from dataclasses import dataclass, replace
+from typing import Literal
+
+from . import _normalize as normalize
+from .client import ProjectsClient, _count, _text
+from .errors import CredentialError, PaginationLimitError, ProjectsError, ProtocolError
+from .models import ProjectField, SelectOption
+
+CONTENT_QUERY = """query WritableContent($id: ID!) {
+  node(id: $id) { __typename id }
+}"""
+MEMBERSHIP_QUERY = """query ProjectItemMembership($id: ID!) {
+  node(id: $id) { __typename ... on ProjectV2Item {
+    id project { id } content { __typename ... on Issue { id } ... on PullRequest { id } }
+  } }
+}"""
+SELECTION_QUERY = """query SingleSelectValue($id: ID!, $name: String!) {
+  node(id: $id) { __typename ... on ProjectV2Item {
+    id project { id } fieldValueByName(name: $name) {
+      __typename ... on ProjectV2ItemFieldSingleSelectValue {
+        optionId field { ... on ProjectV2SingleSelectField { id } }
+      }
+    }
+  } }
+}"""
+ADD_MUTATION = """mutation AddProjectItem($project: ID!, $content: ID!) {
+  addProjectV2ItemById(input: {projectId: $project, contentId: $content}) { item { id } }
+}"""
+SET_MUTATION = """mutation SetSingleSelect($project: ID!, $item: ID!, $field: ID!, $option: String!) {
+  updateProjectV2ItemFieldValue(input: {projectId: $project, itemId: $item, fieldId: $field,
+    value: {singleSelectOptionId: $option}}) { projectV2Item { id } }
+}"""
+
+
+class ProjectAuthorizationError(ProjectsError):
+    """The configured allowlist, content type or item membership denies the write."""
+
+
+class SelectionConflictError(ProjectsError):
+    """The single-select value changed before the preflight check."""
+
+
+@dataclass(frozen=True)
+class WriteReceipt:
+    operation: Literal["add_item", "set_single_select"]
+    project_id: str
+    item_id: str | None
+    content_id: str | None
+    field_id: str | None
+    option_id: str | None
+    verified: bool
+    acknowledged: bool = False
+    diagnostic: str | None = None
+
+
+@dataclass(frozen=True)
+class SingleSelectState:
+    project_id: str
+    item_id: str
+    field_id: str
+    current_option_id: str | None
+    options: list[SelectOption]
+
+
+class WriteOutcomeUnknownError(ProjectsError):
+    """A submitted mutation may have taken effect; inspect before any retry."""
+
+    def __init__(self, receipt: WriteReceipt, *, acknowledged: bool, cause_type: str):
+        self.receipt = replace(
+            receipt, acknowledged=acknowledged, diagnostic=cause_type
+        )
+        self.acknowledged = acknowledged
+        self.cause_type = cause_type
+        super().__init__(
+            "mutation outcome is unverified; inspect the Project before retrying"
+        )
+
+
+class PostWriteVerificationError(WriteOutcomeUnknownError):
+    """GitHub acknowledged the mutation but its post-write read did not verify it."""
+
+
+def _opaque(value: str, label: str) -> str:
+    value = _text(value, label)
+    if len(value) > 1024 or any(char.isspace() for char in value):
+        raise ValueError(f"{label} must be a bounded opaque ID")
+    return value
+
+
+class ProjectsWriter:
+    """Trusted configuration authorizes Projects; tool input cannot add permission."""
+
+    def __init__(
+        self,
+        reader: ProjectsClient,
+        *,
+        allowed_projects: Iterable[str],
+        max_field_pages: int = 5,
+    ):
+        if not isinstance(reader, ProjectsClient):
+            raise TypeError("reader must be an explicitly configured ProjectsClient")
+        if isinstance(allowed_projects, (str, bytes)):
+            raise ValueError("allowed_projects must be an explicit collection of IDs")
+        projects = set()
+        for index, project_id in enumerate(allowed_projects):
+            if index >= 64:
+                raise ValueError("authorize at most 64 Projects per local writer")
+            projects.add(_opaque(project_id, "project_id"))
+        if not projects:
+            raise ValueError("authorize at least one explicit Project")
+        self._reader = reader
+        self._allowed_projects = frozenset(projects)
+        self._max_field_pages = _count(max_field_pages, "max_field_pages", 100)
+
+    def __repr__(self) -> str:
+        return "ProjectsWriter()"
+
+    def _authorize(self, project_id: str) -> None:
+        _opaque(project_id, "project_id")
+        if project_id not in self._allowed_projects:
+            raise ProjectAuthorizationError(
+                "Project is outside the configured write allowlist"
+            )
+
+    def _member(self, node: dict, project_id: str, item_id: str) -> None:
+        if (
+            normalize.text(node.get("id")) != item_id
+            or normalize.text(normalize.obj(node.get("project")).get("id"))
+            != project_id
+        ):
+            raise ProjectAuthorizationError(
+                "item does not belong to the authorized Project"
+            )
+
+    def _field(self, project_id: str, name: str) -> ProjectField:
+        _text(name, "field_name")
+        found, cursor, seen = [], None, set()
+        for _ in range(self._max_field_pages):
+            page = self._reader.fields(project_id, cursor=cursor, page_size=100)
+            found.extend(field for field in page.fields if field.name == name)
+            if not page.page_info.has_next_page:
+                break
+            cursor = page.page_info.end_cursor
+            if cursor in seen:
+                raise ProtocolError("GitHub repeated a field-definition cursor")
+            seen.add(cursor)
+        else:
+            raise PaginationLimitError(
+                "field-definition budget ended before the connection"
+            )
+        if (
+            len(found) != 1
+            or found[0].graphql_type != "ProjectV2SingleSelectField"
+            or found[0].id is None
+        ):
+            raise ValueError(
+                "field_name must identify one accessible single-select field"
+            )
+        _opaque(found[0].id, "field_id")
+        return found[0]
+
+    def _selection(
+        self, project_id: str, item_id: str, field: ProjectField
+    ) -> str | None:
+        data = self._reader._execute(
+            SELECTION_QUERY, {"id": item_id, "name": field.name}
+        )
+        node = normalize.node(data, "ProjectV2Item")
+        self._member(node, project_id, item_id)
+        value = node.get("fieldValueByName")
+        if value is None:
+            return None
+        value = normalize.obj(value)
+        if (
+            value.get("__typename") != "ProjectV2ItemFieldSingleSelectValue"
+            or normalize.obj(value.get("field")).get("id") != field.id
+        ):
+            raise ProtocolError(
+                "single-select lookup returned a different field or value type"
+            )
+        return _opaque(normalize.text(value.get("optionId")), "option_id")
+
+    def inspect_single_select(
+        self, project_id: str, item_id: str, field_name: str
+    ) -> SingleSelectState:
+        """Read the authorized item value and dynamically resolved choices."""
+        self._authorize(project_id)
+        _opaque(item_id, "item_id")
+        field = self._field(project_id, field_name)
+        return SingleSelectState(
+            project_id,
+            item_id,
+            field.id,
+            self._selection(project_id, item_id, field),
+            field.options,
+        )
+
+    def _mutate(self, query: str, variables: dict, receipt: WriteReceipt) -> dict:
+        try:
+            return self._reader._execute(query, variables)
+        except CredentialError:
+            raise
+        except ProjectsError as error:
+            # Never retry automatically: transport/GraphQL errors can follow a completed effect.
+            raise WriteOutcomeUnknownError(
+                receipt, acknowledged=False, cause_type=type(error).__name__
+            ) from None
+
+    def add_item(self, project_id: str, content_id: str) -> WriteReceipt:
+        """Add one existing Issue/PR and verify returned identity and membership."""
+        self._authorize(project_id)
+        _opaque(content_id, "content_id")
+        self._reader.fields(
+            project_id, page_size=1
+        )  # also verifies Project read access/type
+        content = normalize.obj(
+            self._reader._execute(CONTENT_QUERY, {"id": content_id}).get("node")
+        )
+        if (
+            content.get("__typename") not in ("Issue", "PullRequest")
+            or content.get("id") != content_id
+        ):
+            raise ProjectAuthorizationError(
+                "content must be an accessible existing Issue or PullRequest"
+            )
+        receipt = WriteReceipt(
+            "add_item", project_id, None, content_id, None, None, False
+        )
+        data = self._mutate(
+            ADD_MUTATION, {"project": project_id, "content": content_id}, receipt
+        )
+        try:
+            item_id = _opaque(
+                normalize.text(
+                    normalize.obj(
+                        normalize.obj(data.get("addProjectV2ItemById")).get("item")
+                    ).get("id")
+                ),
+                "item_id",
+            )
+        except (ProjectsError, ValueError) as error:
+            raise WriteOutcomeUnknownError(
+                receipt, acknowledged=False, cause_type=type(error).__name__
+            ) from None
+        receipt = replace(receipt, item_id=item_id, acknowledged=True)
+        try:
+            node = normalize.node(
+                self._reader._execute(MEMBERSHIP_QUERY, {"id": item_id}),
+                "ProjectV2Item",
+            )
+            self._member(node, project_id, item_id)
+            if normalize.obj(node.get("content")).get("id") != content_id:
+                raise ProtocolError(
+                    "added item content did not match the supplied identity"
+                )
+        except (ProjectsError, ValueError) as error:
+            raise PostWriteVerificationError(
+                receipt, acknowledged=True, cause_type=type(error).__name__
+            ) from None
+        return replace(receipt, verified=True, acknowledged=True)
+
+    def set_single_select(
+        self,
+        project_id: str,
+        item_id: str,
+        field_name: str,
+        option_name: str,
+        expected_option_id: str | None,
+    ) -> WriteReceipt:
+        """Check the expected value, set a dynamically resolved option, then verify."""
+        self._authorize(project_id)
+        _opaque(item_id, "item_id")
+        _text(option_name, "option_name")
+        if expected_option_id is not None:
+            _opaque(expected_option_id, "expected_option_id")
+        field = self._field(project_id, field_name)
+        options = [option for option in field.options if option.name == option_name]
+        if len(options) != 1:
+            raise ValueError(
+                "option_name must identify one choice on the resolved field"
+            )
+        option_id = _opaque(options[0].id, "option_id")
+        if self._selection(project_id, item_id, field) != expected_option_id:
+            raise SelectionConflictError(
+                "single-select value differs from the caller's expected option"
+            )
+        receipt = WriteReceipt(
+            "set_single_select", project_id, item_id, None, field.id, option_id, False
+        )
+        data = self._mutate(
+            SET_MUTATION,
+            {
+                "project": project_id,
+                "item": item_id,
+                "field": field.id,
+                "option": option_id,
+            },
+            receipt,
+        )
+        try:
+            returned = normalize.obj(
+                normalize.obj(data.get("updateProjectV2ItemFieldValue")).get(
+                    "projectV2Item"
+                )
+            )
+            if returned.get("id") != item_id:
+                raise ProtocolError(
+                    "mutation response did not identify the requested item"
+                )
+        except (ProjectsError, ValueError) as error:
+            raise WriteOutcomeUnknownError(
+                receipt, acknowledged=False, cause_type=type(error).__name__
+            ) from None
+        receipt = replace(receipt, acknowledged=True)
+        try:
+            if self._selection(project_id, item_id, field) != option_id:
+                raise ProtocolError(
+                    "single-select post-write value did not match the requested choice"
+                )
+        except (ProjectsError, ValueError) as error:
+            raise PostWriteVerificationError(
+                receipt, acknowledged=True, cause_type=type(error).__name__
+            ) from None
+        return replace(receipt, verified=True, acknowledged=True)

hidden_moves_github_projects-0.1.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: hidden-moves-github-projects
+Version: 0.1.0
+Summary: Read and explicitly edit GitHub Projects through typed Python operations.
+Keywords: github,projects,graphql,capabilities
+Author: Ella Inng
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: backpack-store>=0.1,<0.2 ; extra == 'backpack'
+Requires-Dist: hidden-moves-mcp>=0.1,<0.2 ; extra == 'host'
+Requires-Dist: hidden-moves>=0.1,<0.2 ; extra == 'moves'
+Maintainer: Outside Labs
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/outside-labs/hidden_moves
+Project-URL: Source, https://github.com/outside-labs/hidden_moves
+Project-URL: Issues, https://github.com/outside-labs/hidden_moves/issues
+Project-URL: Documentation, https://github.com/outside-labs/hidden_moves/blob/main/packages/hidden-moves-github-projects/README.md
+Provides-Extra: backpack
+Provides-Extra: host
+Provides-Extra: moves
+Description-Content-Type: text/markdown
+
+# GitHub Projects client
+
+An experimental GraphQL client with concrete typed records and explicitly
+selected write operations. The ordinary Python library uses only the standard
+library and does not import Hidden Moves, MCP, or an API SDK. Capability integration
+is an optional extra.
+
+The PyPI distribution is `hidden-moves-github-projects` and the Python import is
+`hidden_moves_github_projects`. The optional `backpack` extra requires
+`backpack-store>=0.1,<0.2`.
+
+```sh
+python -m pip install hidden-moves-github-projects==0.1.0
+```
+
+Its release route uses `v0.1.0-github-projects`, `release.yaml`, and environment
+`pypi-github-projects`; see the
+[release guide](https://github.com/outside-labs/hidden_moves/blob/main/docs/PYPI_RELEASES.md).
+
+## Ordinary Python
+
+```python
+from hidden_moves_github_projects import ProjectsClient
+
+# The application supplies its credential resolver; construction performs no I/O.
+client = ProjectsClient(resolve_token, timeout=10)
+project = client.get("example", "organization", 2)
+fields = client.fields(project.id)
+page = client.items(project.id, page_size=20, field_page_size=50)
+```
+
+`resolve_token` is an application-owned callable returning an authorized token.
+Keep credentials outside source control and tool arguments. A successful Project
+query verifies access; repository access alone does not establish Projects access.
+Classic-token scopes and GitHub App permissions differ. See the
+[GitHub Projects API guide](https://docs.github.com/en/issues/planning-and-tracking-with-projects/automating-your-project/using-the-api-to-manage-projects).
+
+## Operations and identities
+
+- `list(owner, owner_kind, cursor=None, page_size=50)` returns a Project page.
+- `get(owner, owner_kind, number)` returns a Project record.
+- `fields(project_id, cursor=None, page_size=50)` returns a field-definition page.
+- `items(project_id, cursor=None, page_size=50, field_page_size=50)` returns an item page.
+- `item_field_values(item_id, cursor=None, page_size=50)` continues nested values.
+- `iter_item_pages(project_id, ..., max_pages=10)` explicitly iterates bounded pages.
+
+Owner kind is `user` or `organization`. Node IDs are opaque strings. Project number,
+Project node ID, item node ID, content node ID, and issue/PR number are separate
+identities. Item content distinguishes issues, PRs, drafts, redaction, and unknown
+types. Select options retain IDs/names; iteration definitions retain active and
+completed iteration metadata.
+
+## Paging and completeness
+
+Each requested connection returns `page_info.has_next_page` and `end_cursor`.
+Every page contains at most the requested 1–100 entries. A last page with an input
+cursor still represents only that page. Nested item field values have independent
+page information and `field_values_complete`; continue them with the item ID and
+their own cursor. An iterator that reaches its page budget raises
+`PaginationLimitError` instead of silently claiming to have read the board.
+
+Text, number, date, single-select, and iteration values are normalized. Unsupported
+value types remain visible as typed placeholders and diagnostics; their omitted
+payloads make `field_values_complete=False`. Unknown field/content types and null
+nodes also produce diagnostics. Issue assignees, labels, linked PRs, and repository
+connections are not queried. No unbounded nested connection is silently returned.
+
+## Transport and errors
+
+The default transport makes one HTTPS POST per explicit read, uses a finite socket
+timeout, reads at most a configured byte budget, closes the response, and refuses
+redirects carrying credentials. An explicit HTTPS endpoint supports application-
+configured enterprise API URLs. Inject a `Transport` for synthetic or custom HTTP
+behavior; it receives a `urllib.request.Request` and the timeout/byte budget and
+returns `HTTPResponse(status, body)`.
+
+HTTP failures, GraphQL errors (including HTTP 200 with partial data), malformed or
+oversized responses, unavailable resources, and iterator limits have separate error
+types. Upstream error text and resolver/transport exception messages are sanitized.
+Requests are not retried automatically. Clients do not resolve local login state
+unless the application explicitly supplies such a resolver.
+
+## Verification
+
+```sh
+PYTHONPATH=packages/hidden-moves-github-projects/src \
+  .venv/bin/python -m unittest discover -s packages/hidden-moves-github-projects/tests -p test_client.py
+```
+
+Tests use synthetic response fixtures, an injected transport, and blocked side
+effects. CI builds and installs the actual wheel across the family platform matrix.
+Live read access and capability-host interoperability are separate proofs.
+
+## Optional provider and local host
+
+Install `[moves]` for the optional provider or `[host]` for the MCP executable.
+For local development install the family packages together:
+
+```sh
+uv pip install --python .venv/bin/python . ./packages/hidden-moves-mcp \
+  ./packages/hidden-moves-openai ./packages/hidden-moves-github-projects
+hidden-moves --plugin github-projects moves show github.projects.items
+```
+
+The zero-argument `github-projects` entry-point factory never resolves credentials
+or makes a request. It advertises target-bound `github.projects.list/get/fields/items`
+with read-only, non-destructive, external annotations. Generic framework inspection
+needs no token; account invocation needs an application-bound `ProjectsClient`.
+
+```python
+from hidden_moves_github_projects import ProjectsClient
+from hidden_moves_github_projects.host import build_catalog, resolve_gh_token
+from hidden_moves_mcp import MCPAdapter
+from hidden_moves_openai import FunctionToolAdapter
+
+client = ProjectsClient(resolve_gh_token, timeout=10)
+catalog = build_catalog(client, ["github.projects.items"])
+mcp = MCPAdapter(catalog)
+functions = FunctionToolAdapter(catalog)
+```
+
+`resolve_gh_token` explicitly captures the existing `github.com` login from `gh`
+when a read executes. It neither prints the token nor changes login/scopes. A
+local MCP host can launch the installed executable:
+
+```json
+{
+  "command": "/absolute/path/to/environment/bin/hidden-moves-github-projects",
+  "args": ["--move", "github.projects.items", "--timeout", "10"]
+}
+```
+
+Only selected capabilities list or dispatch. The host supplies no arbitrary query,
+shell, or Project-editing tool. The SDK owns stdio protocol and process cleanup.
+This configured local application uses one local identity; a remote host requires
+request-scoped authorization and credentials. Sync HTTP executes inline here;
+concurrent remote hosting must provide its own offloading and resource strategy.
+
+The consumer tests use a synthetic transport and compare ordinary Python, the
+selected catalog, actual stdio MCP initialize/list/call, and offline function-tool
+dispatch. Install the local family and run:
+
+```sh
+python -m unittest discover -s packages/hidden-moves-github-projects/tests
+```
+
+Inspection, fixture tests, and offline function tools require no model API call.
+# Optional local snapshots
+
+The `backpack` extra enables an explicit Projects-to-Backpack bridge. Store dated
+normalized Project/item DTOs with a local UUID and source provenance, then reopen
+them without GitHub access. Fetch and persistence can be invoked separately; no
+snapshot read updates a board or claims to be live. See the
+[snapshot guide](../../docs/PROJECT_SNAPSHOTS.md) and run
+`python examples/projects_snapshot_demo.py` from the repository for the offline
+proof. Backpack remains an independent package with no mandatory runtime
+dependencies.
+# Optional bounded writes
+
+The separate `ProjectsWriter` and `github-projects-write` provider support adding
+an existing Issue/PR and setting a dynamically resolved single-select choice.
+The host authorizes explicit Project IDs and selects writes separately from the
+default read profile. See the [write guide](../../docs/PROJECT_WRITES.md) for
+expected-value checks, verified/unverified receipts and the remaining disposable
+fixture gate. There are no bulk, deletion or archive tools.

hidden_moves_github_projects-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+hidden_moves_github_projects/__init__.py,sha256=981WudjuNVSGl0Db7ok9AUTnUV6ABO7RdXwG6RVR9c0,940
+hidden_moves_github_projects/__main__.py,sha256=lJ-aBQgaPtD3giAFpUTx60YNQ67fj_lwL35Ue-ATB3M,136
+hidden_moves_github_projects/_normalize.py,sha256=eJ_QeFajuxdYW73eRqVYhr8f6qLryNQlnWq6ZvY1U3o,7398
+hidden_moves_github_projects/_queries.py,sha256=ynGDpWhPyE9Nmv19CsIudvvDTW40fsvYIntlQKeNjRE,2450
+hidden_moves_github_projects/client.py,sha256=-Sm1katVEVppiVGeCmPHpxe6rQ21O8ObaAfd-prcw88,8965
+hidden_moves_github_projects/errors.py,sha256=JAc4BFBj88BLXALxpTp3EdfbvrJ6X6PJ3kEEF2FBtQw,1088
+hidden_moves_github_projects/host.py,sha256=eOKmzB1ra4grnBkbtc_IGsBK7e-aHZdB59QcODOIuy4,2758
+hidden_moves_github_projects/integration.py,sha256=SmFZMZcoyJ0lmXhvSSzVceYh4YnS4AdfhghpvWS187M,2010
+hidden_moves_github_projects/models.py,sha256=i-g0UJG_kRNsx5uNDIXpUVA6DgZLTNuh1lq8XzDNtSE,2548
+hidden_moves_github_projects/snapshots.py,sha256=uy0PJz2_f76148LAELzSOd56WDrjaXREAauA8eQgfks,3697
+hidden_moves_github_projects/transport.py,sha256=bONC5j0yJTR4WfxBVLIGzfOKcZDU_wAjX2glC_vsg_o,1022
+hidden_moves_github_projects/write_host.py,sha256=5CjPt8T-CM3NN4LVLERfNJQLEnhxHkwiCUCXYkKj3B4,2208
+hidden_moves_github_projects/write_integration.py,sha256=Fk4rtBipT3FjLpPDR51KFGBWnQGGlzX4ADr1fFtn6-w,1742
+hidden_moves_github_projects/writes.py,sha256=G94xxifZY_vh0HzzvF5IhCNmpSXGisIK3NlxcxF2nQQ,12652
+hidden_moves_github_projects-0.1.0.dist-info/licenses/LICENSE,sha256=MJiaArfnOql8NJRA2TI9JIYDOoiis3Rh8xQruzBRXoU,1066
+hidden_moves_github_projects-0.1.0.dist-info/WHEEL,sha256=e4_1dyBeezi8ZjfxrZ3bnVOxFDa3ksqVqH0jTHkUZ3k,81
+hidden_moves_github_projects-0.1.0.dist-info/entry_points.txt,sha256=WNeCIjgtRJZ8sK1OesWutOoqyX8e-aAMCidKaaPOPm8,357
+hidden_moves_github_projects-0.1.0.dist-info/METADATA,sha256=5KyJPaNRbBo2hXzjslEIMtW2xu6FSIBCMc1mHducHhw,9283
+hidden_moves_github_projects-0.1.0.dist-info/RECORD,,

hidden_moves_github_projects-0.1.0.dist-info/WHEEL

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

hidden_moves_github_projects-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+hidden-moves-github-projects = hidden_moves_github_projects.host:main
+hidden-moves-github-projects-write = hidden_moves_github_projects.write_host:main
+
+[hidden_moves.moves]
+github-projects = hidden_moves_github_projects.integration:provide_moves
+github-projects-write = hidden_moves_github_projects.write_integration:provide_write_moves
+

hidden_moves_github_projects-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ella Inng
+
+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.