verda-watermark 0.1.0__tar.gz

verda_watermark-0.1.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: verda-watermark
+Version: 0.1.0
+Summary: Python SDK for the Verda Enterprise Watermarking API
+Author-email: Verda AI <support@verda.ai>
+License: MIT
+Project-URL: Homepage, https://verda.ai
+Project-URL: Documentation, https://enterprise.verda.ai/api-docs
+Project-URL: Repository, https://github.com/VerdaAI/sdk-python
+Keywords: watermark,watermarking,content-protection,verda,ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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 :: Multimedia
+Classifier: Topic :: Security
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+
+# Verda Python SDK
+
+Python SDK for the [Verda Enterprise Watermarking API](https://enterprise.verda.ai/api-docs).
+
+Embed imperceptible watermarks into images, videos, and audio. Decode watermarks to trace content back to its source.
+
+## Install
+
+```bash
+pip install verda
+```
+
+## Quick Start
+
+```python
+from verda import VerdaClient
+
+client = VerdaClient(api_key="vk_...")
+
+# Encode a watermark into a local file
+result = client.encode("photo.jpg")
+print(result.watermark_id)   # 40-bit watermark identifier
+print(result.download_url)   # Download the watermarked file
+
+# Encode from a URL
+result = client.encode(url="https://cdn.example.com/video.mp4")
+
+# Decode / verify a watermark
+result = client.decode("suspect.jpg")
+print(result.match)          # True if watermark found
+print(result.watermark_id)   # Original watermark ID
+
+# Check credits
+credits = client.credits()
+print(f"${credits.balance_dollars:.2f} remaining")
+```
+
+## Configuration
+
+```python
+client = VerdaClient(
+    api_key="vk_...",                                    # or set VERDA_API_KEY env var
+    base_url="https://api.verda.ai/api/v2/enterprise",   # default
+    poll_interval=5,                                      # seconds between job polls
+    poll_timeout=300,                                     # max seconds to wait for a job
+)
+```
+
+## Async Jobs
+
+By default, `encode()` and `decode()` wait for the job to complete. For long-running jobs (video), you can use `wait=False`:
+
+```python
+# Start encode without waiting
+job_id = client.encode("long_video.mp4", wait=False)
+
+# Check status later
+job = client.get_job(job_id)
+print(job.status)  # QUEUED, PROCESSING, COMPLETED, or FAILED
+
+# Or poll manually
+import time
+while True:
+    job = client.get_job(job_id)
+    if job.status in ("COMPLETED", "FAILED"):
+        break
+    time.sleep(10)
+```
+
+## Supported Formats
+
+| Type | Formats |
+|------|---------|
+| Image | jpg, png, webp, bmp, gif, tiff, heic |
+| Video | mp4, mov, avi, mkv, webm |
+| Audio | mp3, wav, flac, aac, ogg, m4a |
+
+## Pricing
+
+| Operation | Price | Free Tier |
+|-----------|-------|-----------|
+| Image encode | $0.005/file | 100/month |
+| Audio encode | $0.01/minute | 10 min/month |
+| Video encode | $0.10/minute | 10 min/month |
+| Image decode | $0.001/file | 1,000/month |
+| Audio decode | $0.001/minute | 1,000/month |
+| Video decode | $0.001/minute | 1,000/month |
+
+## License
+
+MIT

verda_watermark-0.1.0/README.md

@@ -0,0 +1,91 @@
+# Verda Python SDK
+
+Python SDK for the [Verda Enterprise Watermarking API](https://enterprise.verda.ai/api-docs).
+
+Embed imperceptible watermarks into images, videos, and audio. Decode watermarks to trace content back to its source.
+
+## Install
+
+```bash
+pip install verda
+```
+
+## Quick Start
+
+```python
+from verda import VerdaClient
+
+client = VerdaClient(api_key="vk_...")
+
+# Encode a watermark into a local file
+result = client.encode("photo.jpg")
+print(result.watermark_id)   # 40-bit watermark identifier
+print(result.download_url)   # Download the watermarked file
+
+# Encode from a URL
+result = client.encode(url="https://cdn.example.com/video.mp4")
+
+# Decode / verify a watermark
+result = client.decode("suspect.jpg")
+print(result.match)          # True if watermark found
+print(result.watermark_id)   # Original watermark ID
+
+# Check credits
+credits = client.credits()
+print(f"${credits.balance_dollars:.2f} remaining")
+```
+
+## Configuration
+
+```python
+client = VerdaClient(
+    api_key="vk_...",                                    # or set VERDA_API_KEY env var
+    base_url="https://api.verda.ai/api/v2/enterprise",   # default
+    poll_interval=5,                                      # seconds between job polls
+    poll_timeout=300,                                     # max seconds to wait for a job
+)
+```
+
+## Async Jobs
+
+By default, `encode()` and `decode()` wait for the job to complete. For long-running jobs (video), you can use `wait=False`:
+
+```python
+# Start encode without waiting
+job_id = client.encode("long_video.mp4", wait=False)
+
+# Check status later
+job = client.get_job(job_id)
+print(job.status)  # QUEUED, PROCESSING, COMPLETED, or FAILED
+
+# Or poll manually
+import time
+while True:
+    job = client.get_job(job_id)
+    if job.status in ("COMPLETED", "FAILED"):
+        break
+    time.sleep(10)
+```
+
+## Supported Formats
+
+| Type | Formats |
+|------|---------|
+| Image | jpg, png, webp, bmp, gif, tiff, heic |
+| Video | mp4, mov, avi, mkv, webm |
+| Audio | mp3, wav, flac, aac, ogg, m4a |
+
+## Pricing
+
+| Operation | Price | Free Tier |
+|-----------|-------|-----------|
+| Image encode | $0.005/file | 100/month |
+| Audio encode | $0.01/minute | 10 min/month |
+| Video encode | $0.10/minute | 10 min/month |
+| Image decode | $0.001/file | 1,000/month |
+| Audio decode | $0.001/minute | 1,000/month |
+| Video decode | $0.001/minute | 1,000/month |
+
+## License
+
+MIT

verda_watermark-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "verda-watermark"
+version = "0.1.0"
+description = "Python SDK for the Verda Enterprise Watermarking API"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [{name = "Verda AI", email = "support@verda.ai"}]
+keywords = ["watermark", "watermarking", "content-protection", "verda", "ai"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia",
+    "Topic :: Security",
+]
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.urls]
+Homepage = "https://verda.ai"
+Documentation = "https://enterprise.verda.ai/api-docs"
+Repository = "https://github.com/VerdaAI/sdk-python"
+
+[tool.setuptools.packages.find]
+include = ["verda*"]

verda_watermark-0.1.0/setup.cfg

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

verda_watermark-0.1.0/verda/__init__.py

@@ -0,0 +1,5 @@
+from verda.client import VerdaClient
+from verda.models import EncodeResult, DecodeResult, Job, CreditBalance
+
+__version__ = "0.1.0"
+__all__ = ["VerdaClient", "EncodeResult", "DecodeResult", "Job", "CreditBalance"]

verda_watermark-0.1.0/verda/client.py

@@ -0,0 +1,278 @@
+import os
+import time
+import mimetypes
+from pathlib import Path
+from typing import Optional, Union
+
+import requests
+
+from verda.models import EncodeResult, DecodeResult, Job, CreditBalance
+
+DEFAULT_BASE_URL = "https://api.verda.ai/api/v2/enterprise"
+DEFAULT_TIMEOUT = 30
+DEFAULT_POLL_INTERVAL = 5
+DEFAULT_POLL_TIMEOUT = 300  # 5 minutes
+
+
+class VerdaError(Exception):
+    def __init__(self, message: str, status_code: int = 0, error_code: str = ""):
+        self.message = message
+        self.status_code = status_code
+        self.error_code = error_code
+        super().__init__(message)
+
+
+class InsufficientCreditsError(VerdaError):
+    pass
+
+
+class VerdaClient:
+    """Verda Enterprise API client for watermarking media.
+
+    Usage:
+        client = VerdaClient(api_key="vk_...")
+
+        # Encode a local file (uploads + encodes + waits for result)
+        result = client.encode("photo.jpg")
+        print(result.watermark_id)
+        print(result.download_url)
+
+        # Encode from a URL
+        result = client.encode(url="https://cdn.example.com/image.png")
+
+        # Decode / verify
+        result = client.decode("suspect.jpg")
+        print(result.match)
+        print(result.watermark_id)
+
+        # Check credits
+        credits = client.credits()
+        print(f"${credits.balance_dollars:.4f} remaining")
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: int = DEFAULT_TIMEOUT,
+        poll_interval: int = DEFAULT_POLL_INTERVAL,
+        poll_timeout: int = DEFAULT_POLL_TIMEOUT,
+    ):
+        self.api_key = api_key or os.environ.get("VERDA_API_KEY", "")
+        if not self.api_key:
+            raise VerdaError("API key required. Pass api_key= or set VERDA_API_KEY env var.")
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.poll_interval = poll_interval
+        self.poll_timeout = poll_timeout
+        self._session = requests.Session()
+        self._session.headers.update({
+            "X-API-Key": self.api_key,
+            "User-Agent": "verda-python/0.1.0",
+        })
+
+    def _request(self, method: str, path: str, **kwargs) -> dict:
+        kwargs.setdefault("timeout", self.timeout)
+        resp = self._session.request(method, f"{self.base_url}{path}", **kwargs)
+
+        if resp.status_code == 402:
+            raise InsufficientCreditsError("Insufficient credits", status_code=402)
+
+        if resp.status_code >= 400:
+            body = {}
+            try:
+                body = resp.json()
+            except Exception:
+                pass
+            msg = body.get("message", body.get("error", f"HTTP {resp.status_code}"))
+            raise VerdaError(msg, status_code=resp.status_code, error_code=body.get("error_code", ""))
+
+        data = resp.json()
+        return data.get("data", data)
+
+    def _get(self, path: str, **kwargs) -> dict:
+        return self._request("GET", path, **kwargs)
+
+    def _post(self, path: str, **kwargs) -> dict:
+        return self._request("POST", path, **kwargs)
+
+    def _delete(self, path: str, **kwargs) -> dict:
+        return self._request("DELETE", path, **kwargs)
+
+    # --- Upload ---
+
+    def _upload_file(self, file_path: str) -> tuple[str, str]:
+        """Upload a local file to Verda S3 and return (content_id, file_format)."""
+        p = Path(file_path)
+        if not p.exists():
+            raise VerdaError(f"File not found: {file_path}")
+
+        file_format = p.suffix.lstrip(".").lower()
+        content_type = _guess_content_type(file_format)
+
+        resp = self._get("/watermark/upload-url", params={
+            "filename": p.name,
+            "content_type": content_type,
+            "file_format": file_format,
+        })
+
+        upload_url = resp.get("upload_url", resp.get("uploadUrl", ""))
+        content_id = resp.get("content_id", resp.get("contentId", ""))
+
+        if not upload_url or not content_id:
+            raise VerdaError("Failed to get upload URL")
+
+        mime_type = mimetypes.guess_type(file_path)[0] or "application/octet-stream"
+        with open(file_path, "rb") as f:
+            put_resp = requests.put(upload_url, data=f, headers={"Content-Type": mime_type}, timeout=120)
+            if put_resp.status_code >= 400:
+                raise VerdaError(f"Upload failed: HTTP {put_resp.status_code}")
+
+        return content_id, file_format
+
+    # --- Jobs ---
+
+    def get_job(self, job_id: str) -> Job:
+        """Get the status of a watermark job."""
+        resp = self._get(f"/watermark/jobs/{job_id}")
+        job_data = resp.get("job", resp)
+        return Job.from_dict(job_data)
+
+    def _wait_for_job(self, job_id: str) -> Job:
+        """Poll a job until it completes or fails."""
+        deadline = time.time() + self.poll_timeout
+        while time.time() < deadline:
+            job = self.get_job(job_id)
+            if job.status in ("COMPLETED", "FAILED"):
+                return job
+            time.sleep(self.poll_interval)
+        raise VerdaError(f"Job {job_id} timed out after {self.poll_timeout}s")
+
+    # --- Encode ---
+
+    def encode(
+        self,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        content_type: Optional[str] = None,
+        file_format: Optional[str] = None,
+        wait: bool = True,
+    ) -> Union[EncodeResult, str]:
+        """Encode a watermark into media.
+
+        Args:
+            file: Path to a local file to watermark.
+            url: Public URL of media to watermark.
+            content_type: "image", "video", or "audio". Auto-detected from file extension if not provided.
+            file_format: File extension (e.g. "jpg", "mp4"). Auto-detected if not provided.
+            wait: If True (default), poll until the job completes and return the result.
+                  If False, return the job_id immediately.
+
+        Returns:
+            EncodeResult if wait=True, job_id string if wait=False.
+        """
+        body = {}
+
+        if file:
+            content_id, fmt = self._upload_file(file)
+            body["content_id"] = content_id
+            body["file_format"] = file_format or fmt
+            body["content_type"] = content_type or _guess_content_type(fmt)
+        elif url:
+            body["media_url"] = url
+            if file_format:
+                body["file_format"] = file_format
+            else:
+                body["file_format"] = _format_from_url(url)
+            body["content_type"] = content_type or _guess_content_type(body["file_format"])
+        else:
+            raise VerdaError("Provide either file= or url=")
+
+        resp = self._post("/watermark/encode", json=body)
+        job_id = resp.get("job_id", resp.get("jobId", ""))
+
+        if not wait:
+            return job_id
+
+        job = self._wait_for_job(job_id)
+        if job.status == "FAILED":
+            raise VerdaError(f"Encode failed: {job.error_message}", error_code="ENCODE_FAILED")
+
+        return EncodeResult.from_job(job.__dict__)
+
+    # --- Decode ---
+
+    def decode(
+        self,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        content_type: Optional[str] = None,
+        file_format: Optional[str] = None,
+        wait: bool = True,
+    ) -> Union[DecodeResult, str]:
+        """Decode / verify a watermark from media.
+
+        Args:
+            file: Path to a local file to check.
+            url: Public URL of media to check.
+            content_type: "image", "video", or "audio". Auto-detected if not provided.
+            file_format: File extension. Auto-detected if not provided.
+            wait: If True (default), poll until the job completes. If False, return job_id.
+
+        Returns:
+            DecodeResult if wait=True, job_id string if wait=False.
+        """
+        body = {}
+
+        if file:
+            content_id, fmt = self._upload_file(file)
+            body["content_id"] = content_id
+            body["file_format"] = file_format or fmt
+            body["content_type"] = content_type or _guess_content_type(fmt)
+        elif url:
+            body["media_url"] = url
+            if file_format:
+                body["file_format"] = file_format
+            else:
+                body["file_format"] = _format_from_url(url)
+            body["content_type"] = content_type or _guess_content_type(body["file_format"])
+        else:
+            raise VerdaError("Provide either file= or url=")
+
+        resp = self._post("/watermark/decode", json=body)
+        job_id = resp.get("job_id", resp.get("jobId", ""))
+
+        if not wait:
+            return job_id
+
+        job = self._wait_for_job(job_id)
+        if job.status == "FAILED":
+            raise VerdaError(f"Decode failed: {job.error_message}", error_code="DECODE_FAILED")
+
+        return DecodeResult.from_job(job.__dict__)
+
+    # --- Credits ---
+
+    def credits(self) -> CreditBalance:
+        """Check your credit balance."""
+        resp = self._get("/credits")
+        credit_data = resp.get("credits", resp)
+        return CreditBalance.from_dict(credit_data)
+
+
+def _guess_content_type(file_format: str) -> str:
+    fmt = file_format.lower().strip(".")
+    if fmt in ("jpg", "jpeg", "png", "webp", "bmp", "gif", "tiff", "heic"):
+        return "image"
+    elif fmt in ("mp4", "mov", "avi", "mkv", "webm", "ts", "m4v"):
+        return "video"
+    elif fmt in ("mp3", "wav", "flac", "aac", "ogg", "m4a", "wma"):
+        return "audio"
+    return "image"
+
+
+def _format_from_url(url: str) -> str:
+    path = url.split("?")[0].split("#")[0]
+    if "." in path:
+        return path.rsplit(".", 1)[-1].lower()
+    return "jpg"

verda_watermark-0.1.0/verda/models.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class EncodeResult:
+    job_id: str
+    watermark_id: str
+    download_url: str
+    status: str
+
+    @classmethod
+    def from_job(cls, job: dict) -> "EncodeResult":
+        return cls(
+            job_id=job.get("job_id", ""),
+            watermark_id=job.get("watermark_id", ""),
+            download_url=job.get("download_url", ""),
+            status=job.get("status", ""),
+        )
+
+
+@dataclass
+class DecodeResult:
+    job_id: str
+    match: bool
+    watermark_id: Optional[str]
+    confidence: float
+    status: str
+
+    @classmethod
+    def from_job(cls, job: dict) -> "DecodeResult":
+        return cls(
+            job_id=job.get("job_id", ""),
+            match=job.get("match", False),
+            watermark_id=job.get("watermark_id") or None,
+            confidence=job.get("confidence", 0.0),
+            status=job.get("status", ""),
+        )
+
+
+@dataclass
+class Job:
+    job_id: str
+    job_type: str
+    status: str
+    watermark_id: Optional[str]
+    download_url: Optional[str]
+    match: bool
+    confidence: float
+    error_message: Optional[str]
+    created_at: int
+    completed_at: Optional[int]
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Job":
+        status_map = {0: "UNSPECIFIED", 1: "QUEUED", 2: "PROCESSING", 3: "COMPLETED", 4: "FAILED"}
+        raw_status = d.get("status", 0)
+        status = status_map.get(raw_status, str(raw_status)) if isinstance(raw_status, int) else raw_status
+        return cls(
+            job_id=d.get("job_id", ""),
+            job_type=d.get("job_type", ""),
+            status=status,
+            watermark_id=d.get("watermark_id") or None,
+            download_url=d.get("download_url") or None,
+            match=d.get("match", False),
+            confidence=d.get("confidence", 0.0),
+            error_message=d.get("error_message") or None,
+            created_at=d.get("created_at", 0),
+            completed_at=d.get("completed_at") or None,
+        )
+
+
+@dataclass
+class CreditBalance:
+    balance_microdollars: int
+    balance_dollars: float
+    free_tier_reset_at: int
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "CreditBalance":
+        micros = d.get("balance_microdollars", d.get("balanceMicrodollars", 0))
+        return cls(
+            balance_microdollars=micros,
+            balance_dollars=micros / 1_000_000,
+            free_tier_reset_at=d.get("free_tier_reset_at", d.get("freeTierResetAt", 0)),
+        )

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

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: verda-watermark
+Version: 0.1.0
+Summary: Python SDK for the Verda Enterprise Watermarking API
+Author-email: Verda AI <support@verda.ai>
+License: MIT
+Project-URL: Homepage, https://verda.ai
+Project-URL: Documentation, https://enterprise.verda.ai/api-docs
+Project-URL: Repository, https://github.com/VerdaAI/sdk-python
+Keywords: watermark,watermarking,content-protection,verda,ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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 :: Multimedia
+Classifier: Topic :: Security
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+
+# Verda Python SDK
+
+Python SDK for the [Verda Enterprise Watermarking API](https://enterprise.verda.ai/api-docs).
+
+Embed imperceptible watermarks into images, videos, and audio. Decode watermarks to trace content back to its source.
+
+## Install
+
+```bash
+pip install verda
+```
+
+## Quick Start
+
+```python
+from verda import VerdaClient
+
+client = VerdaClient(api_key="vk_...")
+
+# Encode a watermark into a local file
+result = client.encode("photo.jpg")
+print(result.watermark_id)   # 40-bit watermark identifier
+print(result.download_url)   # Download the watermarked file
+
+# Encode from a URL
+result = client.encode(url="https://cdn.example.com/video.mp4")
+
+# Decode / verify a watermark
+result = client.decode("suspect.jpg")
+print(result.match)          # True if watermark found
+print(result.watermark_id)   # Original watermark ID
+
+# Check credits
+credits = client.credits()
+print(f"${credits.balance_dollars:.2f} remaining")
+```
+
+## Configuration
+
+```python
+client = VerdaClient(
+    api_key="vk_...",                                    # or set VERDA_API_KEY env var
+    base_url="https://api.verda.ai/api/v2/enterprise",   # default
+    poll_interval=5,                                      # seconds between job polls
+    poll_timeout=300,                                     # max seconds to wait for a job
+)
+```
+
+## Async Jobs
+
+By default, `encode()` and `decode()` wait for the job to complete. For long-running jobs (video), you can use `wait=False`:
+
+```python
+# Start encode without waiting
+job_id = client.encode("long_video.mp4", wait=False)
+
+# Check status later
+job = client.get_job(job_id)
+print(job.status)  # QUEUED, PROCESSING, COMPLETED, or FAILED
+
+# Or poll manually
+import time
+while True:
+    job = client.get_job(job_id)
+    if job.status in ("COMPLETED", "FAILED"):
+        break
+    time.sleep(10)
+```
+
+## Supported Formats
+
+| Type | Formats |
+|------|---------|
+| Image | jpg, png, webp, bmp, gif, tiff, heic |
+| Video | mp4, mov, avi, mkv, webm |
+| Audio | mp3, wav, flac, aac, ogg, m4a |
+
+## Pricing
+
+| Operation | Price | Free Tier |
+|-----------|-------|-----------|
+| Image encode | $0.005/file | 100/month |
+| Audio encode | $0.01/minute | 10 min/month |
+| Video encode | $0.10/minute | 10 min/month |
+| Image decode | $0.001/file | 1,000/month |
+| Audio decode | $0.001/minute | 1,000/month |
+| Video decode | $0.001/minute | 1,000/month |
+
+## License
+
+MIT

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

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+verda/__init__.py
+verda/client.py
+verda/models.py
+verda_watermark.egg-info/PKG-INFO
+verda_watermark.egg-info/SOURCES.txt
+verda_watermark.egg-info/dependency_links.txt
+verda_watermark.egg-info/requires.txt
+verda_watermark.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

verda_watermark-0.1.0/verda_watermark.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28.0

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

@@ -0,0 +1 @@
+verda