sniptide 0.1.0__tar.gz

sniptide-0.1.0/LICENSE

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

sniptide-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: sniptide
+Version: 0.1.0
+Summary: Official Sniptide API client
+License-Expression: MIT
+Project-URL: Homepage, https://sniptide.com
+Project-URL: Repository, https://github.com/Dino-Kupinic/sniptide
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Sniptide Python SDK
+
+Install the published package:
+
+```sh
+python -m pip install sniptide
+```
+
+```python
+from sniptide import SniptideClient, SniptideError
+client = SniptideClient("snpt_...")
+page = client.list_pastes(limit=20)
+if page["nextCursor"]:
+    next_page = client.list_pastes(cursor=page["nextCursor"])
+created = client.create_paste({"title": "Example", "files": [{"name": "hello.py", "content": "print('hello')"}]})
+```
+
+Methods `me`, `usage`, `read_paste`, `create_paste`, `update_paste`, `update_settings`, `trash_paste`, `list_collections`, `create_collection`, and `collection_pastes` return API JSON dictionaries. Create methods accept an optional `idempotency_key`; current main ignores these keys; support requires a server version with idempotency enabled. `SniptideError` exposes `status`, `code`, and `retry_after`. Requests are not automatically retried. Set `base_url` for a self-hosted instance; HTTPS is required except on loopback. Redirects are rejected.
+
+Environment group reads and writes return variable values, which can contain secrets. Handle responses accordingly. Listing groups returns counts, not values.
+
+The response limit defaults to 64 MiB. Set `max_response_bytes` to a positive integer for a different limit.
+
+## License
+
+This package is licensed under the [MIT License](LICENSE).

sniptide-0.1.0/README.md

@@ -0,0 +1,26 @@
+# Sniptide Python SDK
+
+Install the published package:
+
+```sh
+python -m pip install sniptide
+```
+
+```python
+from sniptide import SniptideClient, SniptideError
+client = SniptideClient("snpt_...")
+page = client.list_pastes(limit=20)
+if page["nextCursor"]:
+    next_page = client.list_pastes(cursor=page["nextCursor"])
+created = client.create_paste({"title": "Example", "files": [{"name": "hello.py", "content": "print('hello')"}]})
+```
+
+Methods `me`, `usage`, `read_paste`, `create_paste`, `update_paste`, `update_settings`, `trash_paste`, `list_collections`, `create_collection`, and `collection_pastes` return API JSON dictionaries. Create methods accept an optional `idempotency_key`; current main ignores these keys; support requires a server version with idempotency enabled. `SniptideError` exposes `status`, `code`, and `retry_after`. Requests are not automatically retried. Set `base_url` for a self-hosted instance; HTTPS is required except on loopback. Redirects are rejected.
+
+Environment group reads and writes return variable values, which can contain secrets. Handle responses accordingly. Listing groups returns counts, not values.
+
+The response limit defaults to 64 MiB. Set `max_response_bytes` to a positive integer for a different limit.
+
+## License
+
+This package is licensed under the [MIT License](LICENSE).

sniptide-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sniptide"
+version = "0.1.0"
+description = "Official Sniptide API client"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+
+[project.urls]
+Homepage = "https://sniptide.com"
+Repository = "https://github.com/Dino-Kupinic/sniptide"

sniptide-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sniptide-0.1.0/sniptide/__init__.py

@@ -0,0 +1,90 @@
+"""A small client for the Sniptide token API."""
+import json
+from http.client import IncompleteRead
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode, urlsplit, urlunsplit
+from urllib.request import HTTPRedirectHandler, Request, build_opener
+
+_MAX_RESPONSE = 64 * 1024 * 1024
+
+class SniptideError(Exception):
+    def __init__(self, message, status=None, code=None, retry_after=None):
+        super().__init__(message)
+        self.status, self.code, self.retry_after = status, code, retry_after
+
+class _NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+def _segment(value):
+    if not value or value in (".", ".."):
+        raise ValueError("Invalid identifier")
+    return quote(value, safe="")
+
+class SniptideClient:
+    def __init__(self, token, base_url="https://app.sniptide.com", timeout=30, max_response_bytes=_MAX_RESPONSE):
+        url = urlsplit(base_url)
+        if (url.scheme != "https" and not (url.scheme == "http" and url.hostname in ("localhost", "127.0.0.1", "::1"))) or not url.hostname or url.username or url.password or url.query or url.fragment:
+            raise ValueError("Base URL must use HTTPS (or HTTP on loopback) and have no credentials, query or fragment")
+        if not token or "\r" in token or "\n" in token:
+            raise ValueError("A valid token is required")
+        if isinstance(max_response_bytes, bool) or not isinstance(max_response_bytes, int) or max_response_bytes <= 0:
+            raise ValueError("max_response_bytes must be a positive integer")
+        self._max_response_bytes = max_response_bytes
+        self._base_url = urlunsplit((url.scheme, url.netloc, url.path.rstrip("/"), "", ""))
+        self._token, self._timeout = token, timeout
+        self._opener = build_opener(_NoRedirect())
+
+    def _request(self, path, method="GET", body=None, idempotency_key=None):
+        headers = {"Authorization": "Bearer " + self._token, "Accept": "application/json"}
+        data = None
+        if body is not None:
+            data = json.dumps(body).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+        if idempotency_key is not None:
+            headers["Idempotency-Key"] = idempotency_key
+        request = Request(self._base_url + "/api/v1/" + path, data=data, headers=headers, method=method)
+        try:
+            response = self._opener.open(request, timeout=self._timeout)
+        except HTTPError as error:
+            response = error
+        except (URLError, OSError) as error:
+            raise SniptideError("Cannot reach Sniptide", code="network_error") from error
+        with response:
+            status = response.status
+            retry_after = response.headers.get("Retry-After")
+            if 300 <= status < 400:
+                raise SniptideError("Sniptide redirected the request", status, "redirect", retry_after)
+            try:
+                raw = response.read(self._max_response_bytes + 1)
+                if len(raw) > self._max_response_bytes:
+                    raise ValueError("Response too large")
+                value = json.loads(raw)
+                if not isinstance(value, dict):
+                    raise ValueError("Expected an object")
+            except (OSError, IncompleteRead) as error:
+                raise SniptideError("Cannot reach Sniptide", code="network_error") from error
+            except (ValueError, UnicodeError) as error:
+                raise SniptideError("Sniptide returned an invalid or oversized response", status, "invalid_response", retry_after) from error
+            if status >= 400:
+                raise SniptideError(value.get("message", f"HTTP {status}"), status, value.get("code"), retry_after)
+            return value
+
+    def me(self): return self._request("me")
+    def usage(self): return self._request("usage")
+    def list_pastes(self, **options):
+        query = urlencode({key: value for key, value in options.items() if value is not None}, doseq=True)
+        return self._request("pastes" + ("?" + query if query else ""))
+    def read_paste(self, identifier): return self._request("pastes/" + _segment(identifier))
+    def create_paste(self, capture, idempotency_key=None): return self._request("pastes", "POST", capture, idempotency_key)
+    def update_paste(self, identifier, capture): return self._request("pastes/" + _segment(identifier), "PUT", capture)
+    def update_settings(self, identifier, settings): return self._request("pastes/" + _segment(identifier), "PATCH", settings)
+    def trash_paste(self, identifier): return self._request("pastes/" + _segment(identifier), "DELETE")
+    def list_env_groups(self): return self._request("env")
+    def read_env_group(self, group): return self._request("env/" + _segment(group))
+    def write_env_group(self, group, variables): return self._request("env/" + _segment(group), "PUT", {"variables": variables})
+    def delete_env_group(self, group): return self._request("env/" + _segment(group), "DELETE")
+    def list_collections(self): return self._request("collections")
+    def create_collection(self, name, idempotency_key=None): return self._request("collections", "POST", {"name": name}, idempotency_key)
+    def collection_pastes(self, slug, cursor=None):
+        return self._request("collections/" + _segment(slug) + "/pastes" + ("?" + urlencode({"cursor": cursor}) if cursor is not None else ""))

sniptide-0.1.0/sniptide.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: sniptide
+Version: 0.1.0
+Summary: Official Sniptide API client
+License-Expression: MIT
+Project-URL: Homepage, https://sniptide.com
+Project-URL: Repository, https://github.com/Dino-Kupinic/sniptide
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Sniptide Python SDK
+
+Install the published package:
+
+```sh
+python -m pip install sniptide
+```
+
+```python
+from sniptide import SniptideClient, SniptideError
+client = SniptideClient("snpt_...")
+page = client.list_pastes(limit=20)
+if page["nextCursor"]:
+    next_page = client.list_pastes(cursor=page["nextCursor"])
+created = client.create_paste({"title": "Example", "files": [{"name": "hello.py", "content": "print('hello')"}]})
+```
+
+Methods `me`, `usage`, `read_paste`, `create_paste`, `update_paste`, `update_settings`, `trash_paste`, `list_collections`, `create_collection`, and `collection_pastes` return API JSON dictionaries. Create methods accept an optional `idempotency_key`; current main ignores these keys; support requires a server version with idempotency enabled. `SniptideError` exposes `status`, `code`, and `retry_after`. Requests are not automatically retried. Set `base_url` for a self-hosted instance; HTTPS is required except on loopback. Redirects are rejected.
+
+Environment group reads and writes return variable values, which can contain secrets. Handle responses accordingly. Listing groups returns counts, not values.
+
+The response limit defaults to 64 MiB. Set `max_response_bytes` to a positive integer for a different limit.
+
+## License
+
+This package is licensed under the [MIT License](LICENSE).

sniptide-0.1.0/sniptide.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+sniptide/__init__.py
+sniptide.egg-info/PKG-INFO
+sniptide.egg-info/SOURCES.txt
+sniptide.egg-info/dependency_links.txt
+sniptide.egg-info/top_level.txt
+tests/test_client.py

sniptide-0.1.0/sniptide.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sniptide-0.1.0/sniptide.egg-info/top_level.txt

@@ -0,0 +1 @@
+sniptide

sniptide-0.1.0/tests/test_client.py

@@ -0,0 +1,61 @@
+import json
+import unittest
+from sniptide import SniptideClient, SniptideError
+
+class ContractTest(unittest.TestCase):
+    def test_all_methods(self):
+        from unittest.mock import MagicMock
+        client = SniptideClient("token")
+        response = MagicMock()
+        response.__enter__.return_value = response
+        response.status = 200
+        response.headers = {}
+        client._opener = MagicMock()
+        client._opener.open.return_value = response
+        capture = {"title": "a", "files": [{"name": "a", "content": "b"}]}
+        variables = [{"name": "SECRET", "value": "value"}]
+        cases = [
+            (lambda: client.me(), "GET", "me", None, {"user": {"id": "1"}, "scopes": []}, None),
+            (lambda: client.usage(), "GET", "usage", None, {"storageBytes": 0, "apiRequests": []}, None),
+            (lambda: client.list_pastes(limit=1), "GET", "pastes?limit=1", None, {"pastes": [], "nextCursor": None}, None),
+            (lambda: client.read_paste("a/b"), "GET", "pastes/a%2Fb", None, {"paste": {"id": "1"}}, None),
+            (lambda: client.create_paste(capture, "key"), "POST", "pastes", capture, {"paste": {"id": "1"}}, "key"),
+            (lambda: client.update_paste("a", capture), "PUT", "pastes/a", capture, {"paste": {"id": "1"}}, None),
+            (lambda: client.update_settings("a", {"visibility": "private"}), "PATCH", "pastes/a", {"visibility": "private"}, {"paste": {}, "settings": {}}, None),
+            (lambda: client.trash_paste("a"), "DELETE", "pastes/a", None, {"trashed": {"id": "1", "slug": "a"}}, None),
+            (lambda: client.list_collections(), "GET", "collections", None, {"collections": []}, None),
+            (lambda: client.create_collection("a", "key"), "POST", "collections", {"name": "a"}, {"collection": {"slug": "a", "name": "a", "pasteCount": 0}}, "key"),
+            (lambda: client.collection_pastes("a", "next +"), "GET", "collections/a/pastes?cursor=next+%2B", None, {"pastes": [], "nextCursor": None}, None),
+            (lambda: client.list_env_groups(), "GET", "env", None, {"groups": [{"slug": "a", "variables": 1, "createdAt": "now", "updatedAt": "now"}]}, None),
+            (lambda: client.read_env_group("a"), "GET", "env/a", None, {"group": {"slug": "a", "updatedAt": "now", "variables": variables}}, None),
+            (lambda: client.write_env_group("a", variables), "PUT", "env/a", {"variables": variables}, {"group": {"slug": "a", "updatedAt": "now", "variables": variables}}, None),
+            (lambda: client.delete_env_group("a"), "DELETE", "env/a", None, {"ok": True}, None),
+        ]
+        for call, method, path, body, envelope, key in cases:
+            with self.subTest(path=path, method=method):
+                response.read.return_value = json.dumps(envelope).encode()
+                self.assertEqual(call(), envelope)
+                req = client._opener.open.call_args.args[0]
+                self.assertEqual(req.get_header("Authorization"), "Bearer token")
+                self.assertEqual((req.full_url, req.method, json.loads(req.data) if req.data else None, req.get_header("Idempotency-key")), ("https://app.sniptide.com/api/v1/" + path, method, body, key))
+
+    def test_read_errors_and_limits(self):
+        from http.client import IncompleteRead
+        from unittest.mock import MagicMock
+        client = SniptideClient("token", max_response_bytes=5)
+        response = MagicMock()
+        response.__enter__.return_value = response
+        response.status = 200
+        response.headers = {}
+        client._opener = MagicMock()
+        client._opener.open.return_value = response
+        for error in (TimeoutError(), OSError(), IncompleteRead(b"a")):
+            response.read.side_effect = error
+            with self.assertRaises(SniptideError) as caught: client.me()
+            self.assertEqual(caught.exception.code, "network_error")
+        response.read.side_effect = None
+        response.read.return_value = b'{"a":1}'
+        with self.assertRaises(SniptideError) as caught: client.me()
+        self.assertEqual(caught.exception.code, "invalid_response")
+        for value in (0, -1, True, 1.5):
+            with self.assertRaises(ValueError): SniptideClient("token", max_response_bytes=value)