getsnap 1.4.0__tar.gz

getsnap-1.4.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: getsnap
+Version: 1.4.0
+Summary: Official Python SDK for getSnap.dev - Screenshot & PDF API
+Author-email: "getSnap.dev" <support@getsnap.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://getsnap.dev
+Project-URL: Documentation, https://getsnap.dev/docs/
+Keywords: screenshot,api,pdf,webpage,capture,getsnap
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# getsnap
+
+Official Python SDK for [getSnap.dev](https://getsnap.dev) — Screenshot & PDF API.
+
+Zero dependencies. Uses only Python's standard library (`urllib`).
+
+## Installation
+
+```bash
+pip install getsnap
+```
+
+## Quick Start
+
+```python
+from getsnap import GetSnap
+
+snap = GetSnap("sk_live_YOUR_KEY")
+
+# Take a screenshot
+result = snap.screenshot(url="https://github.com", format="png")
+print(result["url"])  # CDN URL to your screenshot
+```
+
+## Features
+
+- Zero external dependencies (uses `urllib`)
+- Python 3.8+
+- Screenshot capture (URL or HTML)
+- Binary response (raw image bytes)
+- Batch capture (up to 100 URLs)
+- Usage tracking
+- All API parameters supported: `lazy_load`, `wait_for_selector`, `hide_selectors`, `remove_selectors`, `extract_text`, `extract_html`, `click_selector`, `scroll_to_selector`, and more
+
+## API
+
+### `GetSnap(api_key, base_url=None)`
+
+Create a client instance.
+
+- `api_key` — Your getSnap.dev key (starts with `sk_live_` or `sk_test_`)
+- `base_url` — Custom base URL (default: `https://api.getsnap.dev`)
+
+### `snap.screenshot(**kwargs)`
+
+Take a screenshot. Returns a dict with `url`, `cached`, `request_id`, and optionally `extracted_text`/`extracted_html`.
+
+```python
+result = snap.screenshot(
+    url="https://example.com",
+    format="png",
+    full_page=True,
+    remove_popups=True,
+    lazy_load=True,
+    extract_text=True,
+)
+print(result["url"])
+print(result["extracted_text"])
+```
+
+### `snap.screenshot_binary(**kwargs)`
+
+Get raw image/PDF bytes.
+
+```python
+data = snap.screenshot_binary(url="https://example.com", format="webp", quality=90)
+with open("screenshot.webp", "wb") as f:
+    f.write(data)
+```
+
+### `snap.batch(urls, **kwargs)`
+
+Capture multiple URLs in one request.
+
+```python
+result = snap.batch(
+    urls=["https://github.com", "https://stripe.com", "https://vercel.com"],
+    format="png",
+    remove_popups=True,
+)
+
+print(f"{result['succeeded']}/{result['count']} captured")
+for r in result["results"]:
+    print(f"{r['source_url']} -> {r['url']}")
+```
+
+### `snap.usage()`
+
+Check current usage and quota.
+
+```python
+usage = snap.usage()
+print(f"{usage['used']}/{usage['limit']} ({usage['plan']})")
+```
+
+### `snap.status(request_id)`
+
+Check status of an async (webhook) request.
+
+```python
+status = snap.status("req_abc123")
+```
+
+## Error Handling
+
+```python
+from getsnap import GetSnap, GetSnapError
+
+snap = GetSnap("sk_live_YOUR_KEY")
+
+try:
+    snap.screenshot(url="https://example.com", format="png")
+except GetSnapError as e:
+    print(e.status, e.error, str(e))
+    # 402, "quota_exceeded", "Monthly limit reached..."
+```
+
+## License
+
+MIT

getsnap-1.4.0/README.md

@@ -0,0 +1,120 @@
+# getsnap
+
+Official Python SDK for [getSnap.dev](https://getsnap.dev) — Screenshot & PDF API.
+
+Zero dependencies. Uses only Python's standard library (`urllib`).
+
+## Installation
+
+```bash
+pip install getsnap
+```
+
+## Quick Start
+
+```python
+from getsnap import GetSnap
+
+snap = GetSnap("sk_live_YOUR_KEY")
+
+# Take a screenshot
+result = snap.screenshot(url="https://github.com", format="png")
+print(result["url"])  # CDN URL to your screenshot
+```
+
+## Features
+
+- Zero external dependencies (uses `urllib`)
+- Python 3.8+
+- Screenshot capture (URL or HTML)
+- Binary response (raw image bytes)
+- Batch capture (up to 100 URLs)
+- Usage tracking
+- All API parameters supported: `lazy_load`, `wait_for_selector`, `hide_selectors`, `remove_selectors`, `extract_text`, `extract_html`, `click_selector`, `scroll_to_selector`, and more
+
+## API
+
+### `GetSnap(api_key, base_url=None)`
+
+Create a client instance.
+
+- `api_key` — Your getSnap.dev key (starts with `sk_live_` or `sk_test_`)
+- `base_url` — Custom base URL (default: `https://api.getsnap.dev`)
+
+### `snap.screenshot(**kwargs)`
+
+Take a screenshot. Returns a dict with `url`, `cached`, `request_id`, and optionally `extracted_text`/`extracted_html`.
+
+```python
+result = snap.screenshot(
+    url="https://example.com",
+    format="png",
+    full_page=True,
+    remove_popups=True,
+    lazy_load=True,
+    extract_text=True,
+)
+print(result["url"])
+print(result["extracted_text"])
+```
+
+### `snap.screenshot_binary(**kwargs)`
+
+Get raw image/PDF bytes.
+
+```python
+data = snap.screenshot_binary(url="https://example.com", format="webp", quality=90)
+with open("screenshot.webp", "wb") as f:
+    f.write(data)
+```
+
+### `snap.batch(urls, **kwargs)`
+
+Capture multiple URLs in one request.
+
+```python
+result = snap.batch(
+    urls=["https://github.com", "https://stripe.com", "https://vercel.com"],
+    format="png",
+    remove_popups=True,
+)
+
+print(f"{result['succeeded']}/{result['count']} captured")
+for r in result["results"]:
+    print(f"{r['source_url']} -> {r['url']}")
+```
+
+### `snap.usage()`
+
+Check current usage and quota.
+
+```python
+usage = snap.usage()
+print(f"{usage['used']}/{usage['limit']} ({usage['plan']})")
+```
+
+### `snap.status(request_id)`
+
+Check status of an async (webhook) request.
+
+```python
+status = snap.status("req_abc123")
+```
+
+## Error Handling
+
+```python
+from getsnap import GetSnap, GetSnapError
+
+snap = GetSnap("sk_live_YOUR_KEY")
+
+try:
+    snap.screenshot(url="https://example.com", format="png")
+except GetSnapError as e:
+    print(e.status, e.error, str(e))
+    # 402, "quota_exceeded", "Monthly limit reached..."
+```
+
+## License
+
+MIT

getsnap-1.4.0/getsnap.egg-info/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: getsnap
+Version: 1.4.0
+Summary: Official Python SDK for getSnap.dev - Screenshot & PDF API
+Author-email: "getSnap.dev" <support@getsnap.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://getsnap.dev
+Project-URL: Documentation, https://getsnap.dev/docs/
+Keywords: screenshot,api,pdf,webpage,capture,getsnap
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# getsnap
+
+Official Python SDK for [getSnap.dev](https://getsnap.dev) — Screenshot & PDF API.
+
+Zero dependencies. Uses only Python's standard library (`urllib`).
+
+## Installation
+
+```bash
+pip install getsnap
+```
+
+## Quick Start
+
+```python
+from getsnap import GetSnap
+
+snap = GetSnap("sk_live_YOUR_KEY")
+
+# Take a screenshot
+result = snap.screenshot(url="https://github.com", format="png")
+print(result["url"])  # CDN URL to your screenshot
+```
+
+## Features
+
+- Zero external dependencies (uses `urllib`)
+- Python 3.8+
+- Screenshot capture (URL or HTML)
+- Binary response (raw image bytes)
+- Batch capture (up to 100 URLs)
+- Usage tracking
+- All API parameters supported: `lazy_load`, `wait_for_selector`, `hide_selectors`, `remove_selectors`, `extract_text`, `extract_html`, `click_selector`, `scroll_to_selector`, and more
+
+## API
+
+### `GetSnap(api_key, base_url=None)`
+
+Create a client instance.
+
+- `api_key` — Your getSnap.dev key (starts with `sk_live_` or `sk_test_`)
+- `base_url` — Custom base URL (default: `https://api.getsnap.dev`)
+
+### `snap.screenshot(**kwargs)`
+
+Take a screenshot. Returns a dict with `url`, `cached`, `request_id`, and optionally `extracted_text`/`extracted_html`.
+
+```python
+result = snap.screenshot(
+    url="https://example.com",
+    format="png",
+    full_page=True,
+    remove_popups=True,
+    lazy_load=True,
+    extract_text=True,
+)
+print(result["url"])
+print(result["extracted_text"])
+```
+
+### `snap.screenshot_binary(**kwargs)`
+
+Get raw image/PDF bytes.
+
+```python
+data = snap.screenshot_binary(url="https://example.com", format="webp", quality=90)
+with open("screenshot.webp", "wb") as f:
+    f.write(data)
+```
+
+### `snap.batch(urls, **kwargs)`
+
+Capture multiple URLs in one request.
+
+```python
+result = snap.batch(
+    urls=["https://github.com", "https://stripe.com", "https://vercel.com"],
+    format="png",
+    remove_popups=True,
+)
+
+print(f"{result['succeeded']}/{result['count']} captured")
+for r in result["results"]:
+    print(f"{r['source_url']} -> {r['url']}")
+```
+
+### `snap.usage()`
+
+Check current usage and quota.
+
+```python
+usage = snap.usage()
+print(f"{usage['used']}/{usage['limit']} ({usage['plan']})")
+```
+
+### `snap.status(request_id)`
+
+Check status of an async (webhook) request.
+
+```python
+status = snap.status("req_abc123")
+```
+
+## Error Handling
+
+```python
+from getsnap import GetSnap, GetSnapError
+
+snap = GetSnap("sk_live_YOUR_KEY")
+
+try:
+    snap.screenshot(url="https://example.com", format="png")
+except GetSnapError as e:
+    print(e.status, e.error, str(e))
+    # 402, "quota_exceeded", "Monthly limit reached..."
+```
+
+## License
+
+MIT

getsnap-1.4.0/getsnap.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+README.md
+getsnap.py
+pyproject.toml
+getsnap.egg-info/PKG-INFO
+getsnap.egg-info/SOURCES.txt
+getsnap.egg-info/dependency_links.txt
+getsnap.egg-info/top_level.txt

getsnap-1.4.0/getsnap.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

getsnap-1.4.0/getsnap.egg-info/top_level.txt

@@ -0,0 +1 @@
+getsnap

getsnap-1.4.0/getsnap.py

@@ -0,0 +1,328 @@
+"""
+getsnap - Official Python SDK for the getSnap.dev Screenshot & PDF API
+https://getsnap.dev
+"""
+
+import json
+from typing import Any, Optional
+from urllib import request as urllib_request
+from urllib.error import HTTPError
+
+
+class GetSnapError(Exception):
+    """Error from the getSnap.dev service."""
+
+    def __init__(self, status: int, error: str, message: str, details: Optional[dict] = None):
+        super().__init__(message)
+        self.status = status
+        self.error = error
+        self.details = details
+
+
+class GetSnap:
+    """Client for the getSnap.dev Screenshot & PDF API."""
+
+    def __init__(self, api_key: str, base_url: str = "https://api.getsnap.dev"):
+        self.api_key = api_key
+        self.base_url = base_url
+
+    def screenshot(self, **kwargs) -> dict:
+        """
+        Take a screenshot of a URL or HTML content.
+
+        Common options:
+            url: URL to capture
+            html: HTML content to render
+            format: png | jpg | jpeg | webp | avif | pdf
+            viewport_width: 320-3840
+            viewport_height: 200-2160
+            full_page: bool
+            full_page_max_height: hard cap in pixels (0 = unlimited)
+            full_page_slices: split tall pages for AI vision workflows
+            full_page_slice_height: max height per slice (200-16000)
+            full_page_slice_overlap_height: pixel overlap between slices
+            device: desktop | mobile | tablet
+            delay: extra ms after page load (0-10000)
+            css: string of CSS to inject
+            js: string of JavaScript to execute
+            dark_mode: bool
+            reduced_motion: emulate prefers-reduced-motion:reduce
+            media_type: "screen" | "print" emulation
+            quality: 1-100 for lossy formats
+            remove_popups: heuristic banner/popup killer
+            click_accept: best-effort cookie-consent Accept clicker
+            press_escape: send Escape key after load
+            block_ads: bool
+            block_images / block_fonts / block_scripts / block_frames: bool
+            block_urls: list of URL substrings / wildcards to block
+            bypass_csp: disable page CSP (needed for some inject scenarios)
+            selector: CSS selector to capture only that element
+            fail_if_selector_missing: 500 if selector isn't found
+            clip: dict {"x", "y", "width", "height"} - capture region
+            device_scale_factor: 0.5-3
+            headers: dict of custom HTTP headers
+            cookies: list of cookie dicts
+            locale: browser locale (e.g. "de-DE")
+            timezone: browser timezone (e.g. "Europe/Berlin")
+            user_agent: custom UA string
+            wait_for_selector: wait for CSS selector
+            wait_for_network_idle: bool
+            lazy_load: auto-scroll to trigger lazy content
+            hide_selectors / remove_selectors: lists of CSS selectors
+            omit_background: transparent PNG
+            extract_text: return page innerText
+            extract_html: return page outerHTML
+            extract_metadata: return {title, favicon, open_graph,
+                fonts, http_status, http_status_text, http_headers}
+            click_selector: click element before capture
+            scroll_to_selector: scroll to element before capture
+            response_type: "url" (default) or "binary"
+            attachment_name: sets Content-Disposition on binary
+                responses / user S3 filename
+            webhook_url: async webhook URL
+            s3_upload: dict with your own S3 credentials
+
+        PDF-specific:
+            pdf_page_size: A0-A6, Letter, Legal, Tabloid, Ledger
+            pdf_orientation: portrait | landscape
+            pdf_margin_top / _right / _bottom / _left: CSS unit strings
+            pdf_background: print CSS backgrounds
+            pdf_scale: 0.1-2.0
+            pdf_show_header / pdf_header: Chromium templated HTML
+            pdf_show_footer / pdf_footer: Chromium templated HTML
+            pdf_page_range: e.g. "1-5,8,11-13"
+            pdf_title / pdf_subject / pdf_author / pdf_keywords /
+                pdf_creator: document metadata
+
+        Returns:
+            Dict with url, cached, request_id, response_time_ms,
+            and optional extracted_text / extracted_html /
+            extracted_metadata / slices / s3_key / s3_bucket.
+        """
+        return self._request("POST", "/v1/screenshot", kwargs)
+
+    def screenshot_binary(self, **kwargs) -> bytes:
+        """Take a screenshot and return raw binary image data."""
+        kwargs["response_type"] = "binary"
+        return self._request_binary("POST", "/v1/screenshot", kwargs)
+
+    def batch(self, urls: list, **kwargs) -> dict:
+        """
+        Capture screenshots of multiple URLs.
+
+        Args:
+            urls: List of URLs to capture (1-100)
+            **kwargs: Same options as screenshot() except url/html/selector
+
+        Returns:
+            Dict with batch_id, count, succeeded, failed, results
+        """
+        kwargs["urls"] = urls
+        return self._request("POST", "/v1/batch", kwargs)
+
+    def usage(self) -> dict:
+        """Check current usage and quota."""
+        return self._request("GET", "/v1/usage")
+
+    def status(self, request_id: str) -> dict:
+        """Check status of an async webhook request."""
+        return self._request("GET", f"/v1/screenshot/{request_id}")
+
+    # ------------------------------------------------------------------
+    # Scheduled captures (Phase 10)
+    #
+    # Example:
+    #     gs = GetSnap("sk_live_...")
+    #     s = gs.create_schedule(
+    #         name="morning traffic dashboard",
+    #         cron="0 9 * * MON-FRI",
+    #         timezone="Europe/Berlin",
+    #         options={"url": "https://dash.example.com", "full_page": True},
+    #         webhook_url="https://my-app.com/webhooks/getsnap",
+    #         webhook_secret="a-strong-shared-secret",
+    #     )
+    #     gs.run_schedule_now(s["id"])
+    #     history = gs.list_schedule_runs(s["id"])
+    # ------------------------------------------------------------------
+    def create_schedule(
+        self,
+        name: str,
+        cron: str,
+        options: dict,
+        timezone: str = "UTC",
+        webhook_url: Optional[str] = None,
+        webhook_secret: Optional[str] = None,
+        is_active: bool = True,
+    ) -> dict:
+        """
+        Create a cron-driven scheduled capture.
+
+        Args:
+            name: Human-friendly name.
+            cron: Standard 5- or 6-field UNIX cron expression.
+            timezone: IANA timezone (default 'UTC').
+            options: ScreenshotOptions dict (url or html required).
+            webhook_url: Optional URL to POST each result to.
+            webhook_secret: If set, deliveries include
+                X-Webhook-Signature: sha256=hex(hmac(secret, ts + "." + body))
+                and X-Webhook-Timestamp headers.
+            is_active: Start immediately if True (default), paused otherwise.
+        """
+        body: dict = {
+            "name": name,
+            "cron": cron,
+            "timezone": timezone,
+            "options": options,
+            "is_active": is_active,
+        }
+        if webhook_url is not None:
+            body["webhook_url"] = webhook_url
+        if webhook_secret is not None:
+            body["webhook_secret"] = webhook_secret
+        return self._request("POST", "/v1/schedules", body)
+
+    def list_schedules(self) -> dict:
+        """List all your scheduled captures."""
+        return self._request("GET", "/v1/schedules")
+
+    def get_schedule(self, schedule_id: str) -> dict:
+        """Fetch one scheduled capture."""
+        return self._request("GET", f"/v1/schedules/{schedule_id}")
+
+    def update_schedule(self, schedule_id: str, **fields) -> dict:
+        """
+        Update fields on a schedule.
+
+        Accepted kwargs: name, cron, timezone, options,
+        webhook_url, webhook_secret, is_active.
+        Pass empty strings to clear webhook_url / webhook_secret.
+        """
+        return self._request("PATCH", f"/v1/schedules/{schedule_id}", fields)
+
+    def delete_schedule(self, schedule_id: str) -> dict:
+        """Delete a schedule (also removes it from the queue)."""
+        return self._request("DELETE", f"/v1/schedules/{schedule_id}")
+
+    def run_schedule_now(self, schedule_id: str) -> dict:
+        """Fire a scheduled capture immediately (ad-hoc, does not touch the cron)."""
+        return self._request("POST", f"/v1/schedules/{schedule_id}/run")
+
+    def list_schedule_runs(self, schedule_id: str) -> dict:
+        """Recent execution history (latest 100 runs) for a schedule."""
+        return self._request("GET", f"/v1/schedules/{schedule_id}/runs")
+
+    # ------------------------------------------------------------------
+    # Scrolling video (Phase 11)
+    #
+    # Example:
+    #     result = gs.video(
+    #         url="https://en.wikipedia.org/wiki/Screenshot",
+    #         format="mp4",
+    #         duration_ms=5000,
+    #         fps=15,
+    #         viewport_width=800,
+    #         viewport_height=500,
+    #     )
+    #     print(result["url"], result["frame_count"], result["bytes"])
+    #
+    # Costs 1 credit per second of video (rounded up, min 1). Sync mode
+    # returns the CDN URL; pass webhook_url for async delivery.
+    # ------------------------------------------------------------------
+    def video(self, **kwargs) -> dict:
+        """
+        Capture a scrolling video (MP4 or GIF) of a URL.
+
+        Common kwargs:
+            url:                required, must be a valid HTTP/HTTPS URL
+            format:             "mp4" (default) or "gif"
+            viewport_width:     320-1920 (default 1280)
+            viewport_height:    200-1080 (default 720)
+            device:             desktop | mobile | tablet
+            device_scale_factor: 0.5-2 (default 1)
+            fps:                10-30 (default 15)
+            duration_ms:        2000-30000 (default 5000)
+            delay:              extra ms after page load (0-10000)
+            quality:            1-100 (MP4 CRF / GIF palette)
+            remove_popups:      bool (default True)
+            block_ads:          bool (default True)
+            dark_mode:          bool
+            css / js:           string injections
+            headers:            dict of HTTP headers
+            cookies:            list of cookie dicts
+            locale, timezone, user_agent, wait_for_selector,
+            wait_for_network_idle: same semantics as screenshot()
+            response_type:      "url" (default) or "binary"
+            attachment_name:    filename hint on binary / S3
+            webhook_url:        async webhook delivery URL
+            s3_upload:          dict with your own S3 credentials
+
+        Returns dict with url, request_id, format, duration_ms,
+        frame_count, fps, bytes, credits_charged, response_time_ms.
+        In binary mode returns raw bytes (use video_binary()).
+        In webhook mode returns 202 status envelope with credits_reserved.
+        """
+        return self._request("POST", "/v1/video", kwargs)
+
+    def video_binary(self, **kwargs) -> bytes:
+        """Capture a scrolling video and return the raw MP4/GIF bytes."""
+        kwargs["response_type"] = "binary"
+        return self._request_binary("POST", "/v1/video", kwargs)
+
+    def _request(self, method: str, path: str, body: Optional[dict] = None) -> dict:
+        url = f"{self.base_url}{path}"
+        data = json.dumps(body).encode("utf-8") if body else None
+
+        req = urllib_request.Request(url, data=data, method=method)
+        req.add_header("Content-Type", "application/json")
+        req.add_header("x-api-key", self.api_key)
+
+        try:
+            with urllib_request.urlopen(req) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except HTTPError as e:
+            try:
+                error_body = json.loads(e.read().decode("utf-8"))
+                raise GetSnapError(
+                    status=e.code,
+                    error=error_body.get("error", "unknown"),
+                    message=error_body.get("message", str(e)),
+                    details=error_body.get("details"),
+                ) from e
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                raise GetSnapError(
+                    status=e.code,
+                    error="http_error",
+                    message=str(e),
+                ) from e
+
+    def _request_binary(self, method: str, path: str, body: Optional[dict] = None) -> bytes:
+        url = f"{self.base_url}{path}"
+        data = json.dumps(body).encode("utf-8") if body else None
+
+        req = urllib_request.Request(url, data=data, method=method)
+        req.add_header("Content-Type", "application/json")
+        req.add_header("x-api-key", self.api_key)
+
+        try:
+            with urllib_request.urlopen(req) as resp:
+                return resp.read()
+        except HTTPError as e:
+            try:
+                error_body = json.loads(e.read().decode("utf-8"))
+                raise GetSnapError(
+                    status=e.code,
+                    error=error_body.get("error", "unknown"),
+                    message=error_body.get("message", str(e)),
+                    details=error_body.get("details"),
+                ) from e
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                raise GetSnapError(
+                    status=e.code,
+                    error="http_error",
+                    message=str(e),
+                ) from e
+
+
+# Backwards-compat aliases (in case anything imported the old names locally)
+SnapAPI = GetSnap
+SnapAPIError = GetSnapError

getsnap-1.4.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "getsnap"
+version = "1.4.0"
+description = "Official Python SDK for getSnap.dev - Screenshot & PDF API"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [{ name = "getSnap.dev", email = "support@getsnap.dev" }]
+keywords = ["screenshot", "api", "pdf", "webpage", "capture", "getsnap"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+]
+
+[project.urls]
+Homepage = "https://getsnap.dev"
+Documentation = "https://getsnap.dev/docs/"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+py-modules = ["getsnap"]

getsnap-1.4.0/setup.cfg

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