novence 0.2.0__py3-none-any.whl

novence/__init__.py

@@ -0,0 +1,509 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+import json
+import os
+import time
+import urllib.parse
+import urllib.request
+import urllib.error
+from pathlib import Path
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "MIME_BY_EXT",
+    "Novence",
+    "bootstrap_account",
+    "verify_email",
+    "resend_verification",
+    "reissue_api_key",
+]
+
+#: Public control plane.
+DEFAULT_BASE_URL = "https://api.novence.ai"
+
+#: Extensions the platform accepts, mirroring MIME_BY_EXT in @novence/sdk.
+#: upload_dir skips anything not listed here.
+MIME_BY_EXT = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".map": "application/json",
+    ".json": "application/json",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".txt": "text/plain; charset=utf-8",
+    ".xml": "application/xml",
+    ".webmanifest": "application/manifest+json",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+}
+
+
+def _resolve_base_url(explicit: Optional[str] = None) -> str:
+    """Resolve the control plane URL.
+
+    Order: explicit argument, then the NOVENCE_BASE_URL environment variable,
+    then the public API. Read at call time rather than import time, so setting
+    the variable after import still takes effect.
+    """
+    raw = explicit or os.environ.get("NOVENCE_BASE_URL") or DEFAULT_BASE_URL
+    return raw.rstrip("/")
+
+
+def _post_json(url: str, body: dict) -> dict:
+    """POST JSON and translate HTTP errors into RuntimeError with the API's message."""
+    req = urllib.request.Request(
+        url,
+        data=json.dumps(body).encode("utf-8"),
+        method="POST",
+        headers={"Content-Type": "application/json"},
+    )
+    try:
+        with urllib.request.urlopen(req) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        raise RuntimeError(_error_message(exc)) from exc
+
+
+def _error_message(exc: urllib.error.HTTPError) -> str:
+    payload = exc.read().decode("utf-8")
+    try:
+        return json.loads(payload).get("error", payload)
+    except Exception:
+        return payload or f"HTTP {exc.code}"
+
+
+@dataclass
+class Novence:
+    """Client for the Novence control plane.
+
+    ``base_url`` defaults to https://api.novence.ai. Pass it explicitly, or set
+    NOVENCE_BASE_URL, to target a different control plane (e.g. a local API).
+    """
+
+    api_key: str
+    base_url: str = field(default_factory=_resolve_base_url)
+
+    def __post_init__(self) -> None:
+        # Normalise whatever the caller passed, including a trailing slash, and
+        # fall back to the environment when given an empty value.
+        self.base_url = _resolve_base_url(self.base_url)
+
+    def _request(self, method: str, path: str, body: Optional[dict] = None) -> Any:
+        url = self.base_url + path
+        data = None if body is None else json.dumps(body).encode("utf-8")
+        req = urllib.request.Request(
+            url,
+            data=data,
+            method=method,
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            },
+        )
+        try:
+            with urllib.request.urlopen(req) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            raise RuntimeError(_error_message(exc)) from exc
+
+    def create_project(self, name: str, description: Optional[str] = None) -> dict:
+        body: dict[str, Any] = {"name": name}
+        if description:
+            body["description"] = description
+        return self._request("POST", "/v1/projects", body)
+
+    def list_projects(self) -> dict:
+        return self._request("GET", "/v1/projects")
+
+    def get_project(self, project_id: str) -> dict:
+        return self._request("GET", f"/v1/projects/{project_id}")
+
+    def update_project(
+        self,
+        project_id: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        check_thresholds: Optional[dict] = None,
+        analytics_enabled: Optional[bool] = None,
+    ) -> dict:
+        body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        if description is not None:
+            body["description"] = description
+        if check_thresholds is not None:
+            body["checkThresholds"] = check_thresholds
+        if analytics_enabled is not None:
+            body["analyticsEnabled"] = analytics_enabled
+        return self._request("PATCH", f"/v1/projects/{project_id}", body)
+
+    def project_usage(self, project_id: str) -> dict:
+        """Storage, deploys, check minutes, bandwidth for one project.
+
+        Prefer usage["storage_bytes"] over the rounded storage_gb.
+        """
+        return self._request("GET", f"/v1/projects/{project_id}/usage")
+
+    def project_analytics(
+        self, project_id: str, from_: Optional[str] = None, to: Optional[str] = None
+    ) -> dict:
+        """Cookieless traffic. Off by default — enable with
+        update_project(analytics_enabled=True)."""
+        query = urllib.parse.urlencode(
+            {k: v for k, v in (("from", from_), ("to", to)) if v}
+        )
+        suffix = f"?{query}" if query else ""
+        return self._request("GET", f"/v1/projects/{project_id}/analytics{suffix}")
+
+    def get_upload_url(self, project_id: str, path: str, content_type: str) -> dict:
+        return self._request(
+            "POST",
+            f"/v1/projects/{project_id}/uploads",
+            {"path": path, "contentType": content_type},
+        )
+
+    def confirm_upload(self, project_id: str, path: str, content_type: str) -> dict:
+        return self._request(
+            "POST",
+            f"/v1/projects/{project_id}/uploads/confirm",
+            {"path": path, "contentType": content_type},
+        )
+
+    def get_upload_urls_batch(self, project_id: str, files: list) -> dict:
+        """Presign many uploads at once. Each entry: {"path", "contentType"}."""
+        return self._request(
+            "POST", f"/v1/projects/{project_id}/uploads/batch", {"files": files}
+        )
+
+    def confirm_batch(self, project_id: str, files: list) -> dict:
+        """Confirm many uploads. Check the "errors" list — retry only those paths."""
+        return self._request(
+            "POST", f"/v1/projects/{project_id}/uploads/confirm-batch", {"files": files}
+        )
+
+    def upload_bytes(
+        self, project_id: str, path: str, content_type: Optional[str], content: bytes
+    ) -> dict:
+        resolved = content_type or MIME_BY_EXT.get(
+            Path(path).suffix.lower(), "application/octet-stream"
+        )
+        upload = self.get_upload_url(project_id, path, resolved)
+        req = urllib.request.Request(
+            upload["uploadUrl"],
+            data=content,
+            method="PUT",
+            headers={"Content-Type": resolved},
+        )
+        try:
+            with urllib.request.urlopen(req):
+                pass
+        except urllib.error.HTTPError as exc:
+            raise RuntimeError(f"Upload failed for {path}: HTTP {exc.code}") from exc
+        return self.confirm_upload(project_id, path, resolved)
+
+    def upload_file(
+        self, project_id: str, local_path: str, site_path: Optional[str] = None
+    ) -> dict:
+        """Upload one file from disk. site_path defaults to /<filename>."""
+        data = Path(local_path).read_bytes()
+        target = site_path or "/" + Path(local_path).name
+        return self.upload_bytes(project_id, target, None, data)
+
+    def upload_dir(self, project_id: str, directory: str) -> dict:
+        """Upload a directory tree.
+
+        Mirrors uploadDir in @novence/sdk: dotfiles and dot-directories are
+        skipped, and so is any extension not in MIME_BY_EXT (the platform would
+        reject it). Returns {"uploaded": [site paths], "skipped": [local paths]}.
+        """
+        root = Path(directory)
+        if not root.is_dir():
+            raise RuntimeError(f"Not a directory: {directory}")
+
+        uploaded: list[str] = []
+        skipped: list[str] = []
+        for full in sorted(root.rglob("*")):
+            if not full.is_file():
+                continue
+            rel_parts = full.relative_to(root).parts
+            if any(part.startswith(".") for part in rel_parts):
+                continue
+            if full.suffix.lower() not in MIME_BY_EXT:
+                skipped.append(str(full))
+                continue
+            site_path = "/" + "/".join(rel_parts)
+            self.upload_bytes(project_id, site_path, None, full.read_bytes())
+            uploaded.append(site_path)
+        return {"uploaded": uploaded, "skipped": skipped}
+
+    def deploy(self, project_id: str, force: bool = False) -> dict:
+        """Queue a deployment.
+
+        Deploys are asynchronous: this returns as soon as the deployment is
+        created, usually with status ``queued``. Use :meth:`wait_for_deployment`
+        (or poll :meth:`latest_deployment`) to find out whether it went live.
+        """
+        return self._request(
+            "POST", f"/v1/projects/{project_id}/deployments", {"force": force}
+        )
+
+    def latest_deployment(self, project_id: str) -> dict:
+        """Current state of the most recent deployment."""
+        return self._request("GET", f"/v1/projects/{project_id}/deployments/latest")
+
+    def wait_for_deployment(
+        self, project_id: str, timeout: float = 300.0, interval: float = 2.0
+    ) -> dict:
+        """Poll until the deployment is live, and return it.
+
+        Raises RuntimeError if the deploy fails or ``timeout`` seconds elapse.
+        Note that ``checks_results["passed"]`` is None when checks were skipped
+        (unverified accounts) — that is not a pass.
+        """
+        deadline = time.monotonic() + timeout
+        seen = False
+        while time.monotonic() < deadline:
+            try:
+                deployment = self.latest_deployment(project_id).get("deployment", {})
+            except RuntimeError as exc:
+                # A deployment created moments ago may not be readable yet, so a
+                # not-found is "not yet" rather than fatal. The timeout still
+                # bounds the wait.
+                if "not found" not in str(exc).lower():
+                    raise
+                time.sleep(interval)
+                continue
+            seen = True
+            status = deployment.get("status")
+            if status == "live":
+                return deployment
+            if status == "failed":
+                raise RuntimeError(deployment.get("errorMessage") or "Deploy failed")
+            time.sleep(interval)
+
+        if not seen:
+            raise RuntimeError(
+                f"No deployment found for project {project_id} after {timeout:.0f}s "
+                "— did you call deploy()?"
+            )
+        raise RuntimeError(f"Deploy did not go live within {timeout:.0f}s")
+
+    def configure_domain(
+        self,
+        project_id: str,
+        hostname: str,
+        primary: Optional[str] = None,
+        redirect: Optional[bool] = None,
+    ) -> dict:
+        """Attach a custom domain. Returns DNS records to create.
+
+        primary is "www" or "apex" (default www).
+        """
+        body: dict[str, Any] = {"hostname": hostname}
+        if primary is not None:
+            body["primary"] = primary
+        if redirect is not None:
+            body["redirect"] = redirect
+        return self._request("POST", f"/v1/projects/{project_id}/domains", body)
+
+    def domain_status(self, project_id: str) -> dict:
+        return self._request("GET", f"/v1/projects/{project_id}/domains")
+
+    def create_form(
+        self,
+        project_id: str,
+        name: str,
+        fields: Optional[list] = None,
+        slug: Optional[str] = None,
+        notify_email: Optional[str] = None,
+    ) -> dict:
+        body: dict[str, Any] = {"name": name, "fields": fields or []}
+        if slug:
+            body["slug"] = slug
+        if notify_email is not None:
+            body["notifyEmail"] = notify_email
+        return self._request("POST", f"/v1/projects/{project_id}/forms", body)
+
+    def list_forms(self, project_id: str) -> dict:
+        return self._request("GET", f"/v1/projects/{project_id}/forms")
+
+    def get_form(self, project_id: str, form_id: str) -> dict:
+        return self._request("GET", f"/v1/projects/{project_id}/forms/{form_id}")
+
+    def update_form(
+        self,
+        project_id: str,
+        form_id: str,
+        name: Optional[str] = None,
+        slug: Optional[str] = None,
+        fields: Optional[list] = None,
+        notify_email: Optional[str] = None,
+        honeypot_field: Optional[str] = None,
+        status: Optional[str] = None,
+    ) -> dict:
+        body: dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        if slug is not None:
+            body["slug"] = slug
+        if fields is not None:
+            body["fields"] = fields
+        if notify_email is not None:
+            body["notifyEmail"] = notify_email
+        if honeypot_field is not None:
+            body["honeypotField"] = honeypot_field
+        if status is not None:
+            body["status"] = status
+        return self._request(
+            "PATCH", f"/v1/projects/{project_id}/forms/{form_id}", body
+        )
+
+    def delete_form(self, project_id: str, form_id: str) -> dict:
+        """Soft-delete a form."""
+        return self._request("DELETE", f"/v1/projects/{project_id}/forms/{form_id}")
+
+    def list_form_submissions(
+        self, project_id: str, form_id: str, limit: int = 50, offset: int = 0
+    ) -> dict:
+        return self._request(
+            "GET",
+            f"/v1/projects/{project_id}/forms/{form_id}/submissions?limit={limit}&offset={offset}",
+        )
+
+    def delete_form_submission(
+        self, project_id: str, form_id: str, submission_id: str
+    ) -> dict:
+        return self._request(
+            "DELETE",
+            f"/v1/projects/{project_id}/forms/{form_id}/submissions/{submission_id}",
+        )
+
+    def quotas(self) -> dict:
+        """Plan caps and current usage."""
+        return self._request("GET", "/v1/billing/quotas")
+
+    def checkout(
+        self,
+        plan: str = "pro",
+        success_url: Optional[str] = None,
+        cancel_url: Optional[str] = None,
+    ) -> dict:
+        """Stripe Checkout session for a human with a card."""
+        body: dict[str, Any] = {"plan": plan}
+        if success_url:
+            body["successUrl"] = success_url
+        if cancel_url:
+            body["cancelUrl"] = cancel_url
+        return self._request("POST", "/v1/billing/checkout", body)
+
+    def billing_portal(self, return_url: Optional[str] = None) -> dict:
+        """Stripe Customer Portal link."""
+        body: dict[str, Any] = {}
+        if return_url:
+            body["returnUrl"] = return_url
+        return self._request("POST", "/v1/billing/portal", body)
+
+    def mpp_upgrade(self, plan: str = "pro") -> dict:
+        """Agent subscription via MPP/SPT.
+
+        Unlike the other methods this does not raise on a non-2xx: the 402 with
+        a WWW-Authenticate challenge is the expected path for agents. Returns
+        {"status", "wwwAuthenticate", "data"}.
+        """
+        req = urllib.request.Request(
+            self.base_url + "/v1/billing/mpp",
+            data=json.dumps({"plan": plan}).encode("utf-8"),
+            method="POST",
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            },
+        )
+        try:
+            with urllib.request.urlopen(req) as resp:
+                status, headers, payload = resp.status, resp.headers, resp.read()
+        except urllib.error.HTTPError as exc:
+            status, headers, payload = exc.code, exc.headers, exc.read()
+        try:
+            data = json.loads(payload.decode("utf-8"))
+        except Exception:
+            data = {}
+        return {
+            "status": status,
+            "wwwAuthenticate": headers.get("WWW-Authenticate"),
+            "data": data,
+        }
+
+    def get_account(self) -> dict:
+        """Plan, verification, quotas, and projects across the account."""
+        return self._request("GET", "/v1/account")
+
+    def account_console_kit(self) -> dict:
+        """Local HTML console kit. Serve on 127.0.0.1 — never inject an nv_ key."""
+        return self._request("GET", "/v1/account/console-kit")
+
+    def create_session(self) -> dict:
+        """Mint a short-lived mgmt_ token for a browser console.
+
+        Call this with an ``nv_`` key. Never put the ``nv_`` key itself in HTML —
+        inject only the returned mgmt_ token.
+        """
+        return self._request("POST", "/v1/account/sessions", {})
+
+    def revoke_session(self) -> dict:
+        """Revoke the mgmt_ session this client is authenticated with.
+
+        Requires a client constructed with a ``mgmt_`` token — calling it with an
+        ``nv_`` API key raises "Only management sessions can be revoked via this
+        endpoint". To end a console session:
+
+            session = Novence(api_key=key).create_session()
+            Novence(api_key=session["token"]).revoke_session()
+        """
+        return self._request("DELETE", "/v1/account/sessions/current")
+
+    def revoke_api_key(self, api_key_id: str) -> dict:
+        return self._request("DELETE", f"/v1/api-keys/{api_key_id}")
+
+
+def bootstrap_account(email: str, base_url: Optional[str] = None) -> dict:
+    return _post_json(_resolve_base_url(base_url) + "/v1/bootstrap", {"email": email})
+
+
+def verify_email(email: str, code: str, base_url: Optional[str] = None) -> dict:
+    return _post_json(
+        _resolve_base_url(base_url) + "/v1/auth/verify-email",
+        {"email": email, "code": code},
+    )
+
+
+def resend_verification(email: str, base_url: Optional[str] = None) -> dict:
+    """Re-send the email OTP. Returns {"sent": true} even if already verified."""
+    return _post_json(
+        _resolve_base_url(base_url) + "/v1/auth/resend-verification", {"email": email}
+    )
+
+
+def reissue_api_key(email: str, code: str, base_url: Optional[str] = None) -> dict:
+    """Recover a lost key with an OTP.
+
+    This also verifies the email — do not spend a second OTP on verify_email.
+    """
+    return _post_json(
+        _resolve_base_url(base_url) + "/v1/auth/reissue-key",
+        {"email": email, "code": code},
+    )

novence-0.2.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: novence
+Version: 0.2.0
+Summary: Official Python SDK for Novence — static site hosting for AI agents
+License-Expression: MIT
+Project-URL: Homepage, https://novence.ai
+Project-URL: Documentation, https://novence.ai/docs
+Project-URL: Issues, https://novence.ai/support
+Keywords: novence,static-site-hosting,deploy,hosting,edge,ai-agents
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: Site Management
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# novence (Python)
+
+Python SDK for [Novence](https://novence.ai) — static site hosting built for AI agents.
+
+> Not published to PyPI yet. Use it from the repo for now.
+
+Requires Python 3.10+. No third-party dependencies — standard library only.
+
+## Quick start
+
+```python
+from novence import Novence, bootstrap_account, verify_email
+
+boot = bootstrap_account("you@example.com")     # emails a 6-digit OTP
+verify_email("you@example.com", "123456")
+
+client = Novence(api_key=boot["apiKey"])
+project = client.create_project("launch")
+pid = project["project"]["id"]
+
+client.upload_bytes(pid, "index.html", "text/html; charset=utf-8", b"<h1>hi</h1>")
+client.deploy(pid)
+
+deployment = client.wait_for_deployment(pid)     # polls until live or failed
+print(deployment["liveUrl"])
+```
+
+## Configuration
+
+`base_url` defaults to `https://api.novence.ai`. Override per client, or set
+`NOVENCE_BASE_URL` to point everything at a different control plane:
+
+```python
+client = Novence(api_key=key, base_url="http://127.0.0.1:8080")
+```
+
+The variable is read at call time, so setting it after import still works.
+
+## Deploys are asynchronous
+
+`deploy()` returns as soon as the deployment is queued. Use
+`wait_for_deployment(project_id, timeout=300, interval=2)` to block until it is
+live, or poll `latest_deployment(project_id)` yourself.
+
+`checks_results["passed"]` is `None` when checks were **skipped** (unverified
+accounts). That is not a pass.
+
+## API
+
+| Area | Methods |
+| --- | --- |
+| Projects | `create_project` `list_projects` `get_project` `update_project` `project_usage` `project_analytics` |
+| Uploads | `upload_dir` `upload_file` `upload_bytes` `get_upload_url` `get_upload_urls_batch` `confirm_upload` `confirm_batch` |
+| Deploys | `deploy` `latest_deployment` `wait_for_deployment` |
+| Domains | `configure_domain` `domain_status` |
+| Forms | `create_form` `list_forms` `get_form` `update_form` `delete_form` `list_form_submissions` `delete_form_submission` |
+| Billing | `quotas` `checkout` `billing_portal` `mpp_upgrade` |
+| Account | `get_account` `account_console_kit` `create_session` `revoke_session` `revoke_api_key` |
+
+Module-level: `bootstrap_account` `verify_email` `resend_verification` `reissue_api_key`.
+
+`reissue_api_key` issues a new key and revokes the old one — rebuild your client
+with the returned key.
+
+## Uploading a directory
+
+```python
+result = client.upload_dir(pid, "./dist")
+result["uploaded"]   # site paths that went up
+result["skipped"]    # local files whose extension the platform does not accept
+```
+
+Dotfiles and dot-directories (`.git`, `.env`) are skipped, matching the
+TypeScript SDK.
+
+## Errors
+
+Every API error raises `RuntimeError` carrying the API's message — including
+rate limits and quota rejections.
+
+## Security
+
+`nv_` keys are server-side credentials. Read them from the environment; never
+commit one or put one in client-side code.
+
+## License
+
+MIT

novence-0.2.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+novence/__init__.py,sha256=E1LxbXgT4PcLagMtXVPCB7GSYQAKzvrYVRVH3glzdSM,18834
+novence-0.2.0.dist-info/licenses/LICENSE,sha256=abe2-16akQ6tE777rsJ7SQ3QB7Ya2A4c0yuVwgHTg0k,1064
+novence-0.2.0.dist-info/METADATA,sha256=haIGsLcvqGB10INiBvAY5rA3g-SLN_Vo2S28l74Cp8A,3879
+novence-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+novence-0.2.0.dist-info/top_level.txt,sha256=6DYz264fYi7FPoRN-Qeypglpap69OAXjuytYtaiaHoo,8
+novence-0.2.0.dist-info/RECORD,,

novence-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

novence-0.2.0.dist-info/licenses/LICENSE

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

novence-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+novence