paykit-sdk 0.1.0__py3-none-any.whl

commands/__init__.py

@@ -0,0 +1,9 @@
+"""
+Commands package
+"""
+
+from paykit.commands.init import init_command
+from paykit.commands.set import set_command
+from paykit.commands.add import add_command
+
+__all__ = ["init_command", "set_command", "add_command"]

commands/add.py

@@ -0,0 +1,138 @@
+"""
+Add command — adds payment providers from CDN into the project.
+
+  paykit add              → interactive: lists available providers, prompts
+  paykit add payme        → latest version
+  paykit add payme@1.0.0  → specific version
+  paykit add payme click  → multiple at once
+"""
+
+import click
+
+from paykit.core.config import Config
+from paykit.core.fetcher import ProviderFetcher
+from paykit.utils.parsers import parse_provider_string
+
+
+def _pick_from_list(items: list, label: str) -> str:
+    """Simple numbered prompt when user doesn't specify."""
+    click.echo(f"\nAvailable {label}:")
+    for i, item in enumerate(items, 1):
+        click.echo(f"  {i}. {item}")
+    while True:
+        raw = click.prompt(f"Pick {label} (number or name)", default=items[0])
+        if raw in items:
+            return raw
+        try:
+            idx = int(raw) - 1
+            if 0 <= idx < len(items):
+                return items[idx]
+        except ValueError:
+            pass
+        click.echo("  Invalid choice, try again.")
+
+
+@click.command()
+@click.argument("providers", nargs=-1, required=False)
+def add_command(providers: tuple):
+    """
+    Add payment provider(s) to the project.
+
+    \b
+    Examples:
+        paykit add                  # interactive — shows available providers
+        paykit add payme            # latest version
+        paykit add payme@1.0.0      # specific version
+        paykit add payme click      # multiple
+    """
+    config = Config()
+
+    if not config.config_exists():
+        click.echo("Error: paykit.json not found. Run 'paykit init' first.", err=True)
+        return
+
+    try:
+        config.load_config()
+    except Exception as e:
+        click.echo(f"Error loading config: {e}", err=True)
+        return
+
+    framework = config.get_framework()
+    cdn_url = config.get_cdn_url()
+    fetcher = ProviderFetcher(cdn_url, config.library_dir)
+
+    # ── No providers specified → interactive discovery ────────────────────────
+    if not providers:
+        try:
+            available = fetcher.fetch_available_providers(framework)
+        except Exception as e:
+            click.echo(f"Error fetching available providers: {e}", err=True)
+            return
+
+        if not available:
+            click.echo(f"No providers available for framework: {framework}")
+            return
+
+        chosen = _pick_from_list(available, "provider")
+        providers = (chosen,)
+
+    # ── Process each provider spec ────────────────────────────────────────────
+    added = []
+    failed = []
+
+    click.echo(f"\nFramework: {framework}\n")
+
+    for spec in providers:
+        provider_name, version = parse_provider_string(spec)
+
+        # If version not pinned, resolve to "latest" — but show available versions
+        if version == "latest":
+            try:
+                versions = fetcher.fetch_available_versions(framework, provider_name)
+                # Use latest (first entry per CDN convention) without prompting,
+                # unless it's interactive mode (single provider, no @version)
+                if len(providers) == 1 and len(versions) > 1:
+                    version = _pick_from_list(versions, "version")
+                else:
+                    version = versions[0] if versions else "latest"
+            except Exception:
+                version = "latest"  # fall back to literal "latest"
+
+        try:
+            click.echo(f"Adding {provider_name}@{version}...")
+
+            if config.is_provider_installed(provider_name):
+                click.echo(f"  Removing existing installation...")
+                config.remove_provider_installation(provider_name)
+
+            click.echo(f"  Fetching from CDN...")
+            fetcher.install_provider(
+                framework=framework,
+                provider_name=provider_name,
+                version=version,
+                force=True,
+            )
+
+            if fetcher.verify_installation(provider_name):
+                config.add_provider(provider_name, version)
+                added.append(f"{provider_name}@{version}")
+                click.echo(f"  ✓ {provider_name}@{version} added\n")
+            else:
+                failed.append(spec)
+                click.echo(f"  ✗ Verification failed\n", err=True)
+
+        except Exception as e:
+            failed.append(spec)
+            click.echo(f"  ✗ Failed: {e}\n", err=True)
+            if config.is_provider_installed(provider_name):
+                config.remove_provider_installation(provider_name)
+
+    # ── Summary ───────────────────────────────────────────────────────────────
+    click.echo("─" * 40)
+    if added:
+        for p in added:
+            click.echo(f"  ✓ {p}")
+    if failed:
+        for p in failed:
+            click.echo(f"  ✗ {p} (failed)")
+    click.echo("─" * 40)

commands/init.py

@@ -0,0 +1,121 @@
+"""
+Init command implementation
+
+Initializes PayKit configuration and synchronizes providers with library.
+"""
+
+import click
+from pathlib import Path
+
+from paykit.core.config import Config
+from paykit.core.fetcher import ProviderFetcher
+
+
+@click.command()
+@click.option(
+    "--framework",
+    default="django",
+    help="Framework to use (default: django)"
+)
+@click.option(
+    "--reload",
+    is_flag=True,
+    help="Force reload all providers from CDN"
+)
+def init_command(framework: str, reload: bool):
+    """
+    Initialize PayKit configuration
+
+    Creates paykit.json in the current directory and synchronizes
+    providers with the library installation.
+    """
+    config = Config()
+
+    # Initialize or load configuration
+    if config.config_exists():
+        click.echo("Found existing paykit.json")
+        try:
+            config.load_config()
+        except Exception as e:
+            click.echo(f"Error loading config: {e}", err=True)
+            return
+    else:
+        click.echo("Initializing new paykit.json...")
+        config.initialize(framework=framework)
+        click.echo(f"✓ Created paykit.json with framework: {framework}")
+
+    # Get configuration details
+    cdn_url = config.get_cdn_url()
+    current_framework = config.get_framework()
+    providers = config.get_providers()
+
+    if not providers:
+        click.echo("No providers configured")
+        return
+
+    click.echo(f"\nSynchronizing {len(providers)} provider(s)...")
+
+    # Initialize fetcher
+    fetcher = ProviderFetcher(cdn_url, config.library_dir)
+
+    # Track success/failure
+    installed = []
+    failed = []
+
+    # Process each provider
+    for provider_name, version in providers.items():
+        try:
+            # Check if provider needs installation/reload
+            needs_install = reload or not config.is_provider_installed(provider_name)
+
+            if needs_install:
+                if reload and config.is_provider_installed(provider_name):
+                    click.echo(f"  Removing {provider_name} for reload...")
+                    config.remove_provider_installation(provider_name)
+
+                click.echo(f"  Fetching {provider_name} @ {version}...")
+                fetcher.install_provider(
+                    framework=current_framework,
+                    provider_name=provider_name,
+                    version=version,
+                    force=reload
+                )
+
+                # Verify installation
+                if fetcher.verify_installation(provider_name):
+                    installed.append(provider_name)
+                    click.echo(f"  ✓ Installed {provider_name}")
+                else:
+                    failed.append(provider_name)
+                    click.echo(f"  ✗ Installation verification failed for {provider_name}", err=True)
+            else:
+                click.echo(f"  ✓ {provider_name} already installed")
+                installed.append(provider_name)
+
+        except Exception as e:
+            failed.append(provider_name)
+            click.echo(f"  ✗ Failed to install {provider_name}: {e}", err=True)
+
+    # Remove obsolete providers (installed but not in config)
+    installed_providers = config.get_installed_providers()
+    configured_providers = set(providers.keys())
+    obsolete = installed_providers - configured_providers
+
+    if obsolete:
+        click.echo(f"\nRemoving {len(obsolete)} obsolete provider(s)...")
+        for provider_name in obsolete:
+            try:
+                config.remove_provider_installation(provider_name)
+                click.echo(f"  ✓ Removed {provider_name}")
+            except Exception as e:
+                click.echo(f"  ✗ Failed to remove {provider_name}: {e}", err=True)
+
+    # Summary
+    click.echo(f"\n{'=' * 50}")
+    click.echo(f"Framework: {current_framework}")
+    click.echo(f"Successfully installed: {len(installed)}")
+    if failed:
+        click.echo(f"Failed: {len(failed)}")
+    if obsolete:
+        click.echo(f"Removed obsolete: {len(obsolete)}")
+    click.echo(f"{'=' * 50}")

commands/set.py

@@ -0,0 +1,47 @@
+"""
+Set command implementation
+
+Sets the framework in PayKit configuration.
+"""
+
+import click
+
+from paykit.core.config import Config
+
+
+@click.command()
+@click.argument("framework")
+def set_command(framework: str):
+    """
+    Set the framework in PayKit configuration
+
+    Args:
+        framework: Framework name to set (e.g., django, flask)
+    """
+    config = Config()
+
+    # Check if config exists
+    if not config.config_exists():
+        click.echo("Error: paykit.json not found. Run 'paykit init' first.", err=True)
+        return
+
+    try:
+        # Load existing config
+        config.load_config()
+
+        # Get current framework
+        old_framework = config.get_framework()
+
+        # Set new framework
+        config.set_framework(framework)
+
+        if old_framework == framework:
+            click.echo(f"Framework is already set to: {framework}")
+        else:
+            click.echo(f"✓ Framework changed: {old_framework} → {framework}")
+            click.echo("\nNote: You may need to run 'paykit init --reload' to update providers for the new framework.")
+
+    except FileNotFoundError:
+        click.echo("Error: paykit.json not found. Run 'paykit init' first.", err=True)
+    except Exception as e:
+        click.echo(f"Error setting framework: {e}", err=True)

core/__init__.py

@@ -0,0 +1,11 @@
+"""
+Core functionality
+"""
+
+from paykit.core.config import Config, config
+from paykit.core.fetcher import ProviderFetcher
+
+# from paykit.core.loader import ProviderLoader
+
+# __all__ = ["Config", "ProviderFetcher", "ProviderLoader"]
+__all__ = ["Config", "ProviderFetcher"]

core/config.py

@@ -0,0 +1,183 @@
+"""
+Core configuration management for PayKit.
+
+Changes over original:
+- Atomic config saves (write temp → rename, no corrupt paykit.json on crash)
+- get_cdn_url() normalises scheme so fetcher always gets a valid URL
+- Multi-merchant: providers block supports per-provider config dict
+  { "payme": { "version": "latest", "config": { "PAYME_KEY": "..." } } }
+  as well as the original flat string form { "payme": "latest" }
+"""
+
+import json
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Dict, Optional, Set
+
+
+class Config:
+    """Manages PayKit configuration and provider state."""
+
+    CONFIG_FILENAME = "paykit.json"
+    DEFAULT_CDN_URL = "http://cdn.paykit.qzz.io"
+
+    def __init__(self, project_dir: Optional[Path] = None):
+        self.project_dir = project_dir or Path.cwd()
+        self.config_path = self.project_dir / self.CONFIG_FILENAME
+        self.library_dir = self._get_library_dir()
+        self.providers_dir = self.library_dir / "providers"
+        self._config_data: Optional[Dict] = None
+
+    @staticmethod
+    def _get_library_dir() -> Path:
+        import paykit
+
+        return Path(paykit.__file__).parent
+
+    # ── Load / save ──────────────────────────────────────────────────────────
+
+    def load_config(self) -> Dict:
+        if not self.config_path.exists():
+            raise FileNotFoundError(f"paykit.json not found: {self.config_path}")
+        with open(self.config_path, "r", encoding="utf-8") as fh:
+            self._config_data = json.load(fh)
+        return self._config_data
+
+    def save_config(self, config: Optional[Dict] = None) -> None:
+        """Atomic save: write to .tmp then rename — crash-safe."""
+        data = config or self._config_data
+        if data is None:
+            raise ValueError("No configuration data to save")
+        tmp = self.config_path.with_suffix(".tmp")
+        with open(tmp, "w", encoding="utf-8") as fh:
+            json.dump(data, fh, indent=2, ensure_ascii=False)
+        # os.replace is atomic on POSIX; near-atomic on Windows
+        os.replace(tmp, self.config_path)
+        self._config_data = data
+
+    def initialize(
+        self, framework: str = "django", cdn_url: Optional[str] = None
+    ) -> Dict:
+        config = {
+            "framework": framework,
+            "providers": {},
+        }
+        self.save_config(config)
+        return config
+
+    # ── Getters ──────────────────────────────────────────────────────────────
+
+    def _data(self) -> Dict:
+        return self._config_data or self.load_config()
+
+    def get_framework(self) -> str:
+        return self._data().get("framework", "django")
+
+    def set_framework(self, framework: str) -> None:
+        cfg = self._data()
+        cfg["framework"] = framework
+        self.save_config(cfg)
+
+    def get_provider_defaults(self, provider_name: str) -> Dict[str, Any]:
+        return self._data().get("defaults", {}).get(provider_name, {})
+
+    def get_cdn_url(self) -> str:
+        url = self._data().get("cdn_url", self.DEFAULT_CDN_URL).rstrip("/")
+        if not url.startswith(("http://", "https://")):
+            url = "https://" + url
+        return url
+
+    # ── Provider config (multi-merchant aware) ───────────────────────────────
+
+    def get_providers(self) -> Dict[str, str]:
+        """
+        Returns {provider_name: version} — same shape as before.
+        Works whether the stored value is a plain version string or a dict.
+        """
+        raw: Dict[str, Any] = self._data().get("providers", {})
+        out: Dict[str, str] = {}
+        for name, val in raw.items():
+            if isinstance(val, dict):
+                out[name] = val.get("version", "latest")
+            else:
+                out[name] = str(val)
+        return out
+
+    def get_provider_config(self, provider_name: str) -> Dict[str, Any]:
+        """
+        Returns per-provider runtime config dict if present, else {}.
+        This is where multi-merchant keys live, e.g.:
+          { "PAYME_KEY": "...", "CLICK_SECRET_KEY": "..." }
+        """
+        raw: Dict[str, Any] = self._data().get("providers", {})
+        val = raw.get(provider_name, {})
+        if isinstance(val, dict):
+            return val.get("config", {})
+        return {}
+
+    def add_provider(
+        self, provider_name: str, version: str, config: Optional[Dict] = None
+    ) -> None:
+        """
+        Add or update a provider.
+        If config is given the entry is stored as a dict, otherwise as a plain version string.
+        """
+        cfg = self._data()
+        cfg.setdefault("providers", {})
+        if config:
+            existing = cfg["providers"].get(provider_name)
+            if isinstance(existing, dict):
+                existing["version"] = version
+                existing["config"] = config
+            else:
+                cfg["providers"][provider_name] = {"version": version, "config": config}
+        else:
+            cfg["providers"][provider_name] = version
+        self.save_config(cfg)
+
+    def remove_provider(self, provider_name: str) -> None:
+        cfg = self._data()
+        cfg.get("providers", {}).pop(provider_name, None)
+        self.save_config(cfg)
+
+    # ── Installation state ───────────────────────────────────────────────────
+
+    def get_installed_providers(self) -> Set[str]:
+        if not self.providers_dir.exists():
+            return set()
+        return {
+            p.name
+            for p in self.providers_dir.iterdir()
+            if p.is_dir() and not p.name.startswith("_")
+        }
+
+    def is_provider_installed(self, provider_name: str) -> bool:
+        return (self.providers_dir / provider_name).is_dir()
+
+    def remove_provider_installation(self, provider_name: str) -> None:
+        path = self.providers_dir / provider_name
+        if path.exists():
+            shutil.rmtree(path)
+
+    # ── Misc ─────────────────────────────────────────────────────────────────
+
+    def get_python_version(self) -> str:
+        import sys
+
+        return f"{sys.version_info.major}.{sys.version_info.minor}"
+
+    def validate_config(self) -> bool:
+        cfg = self._data()
+        for field in ("cdn_url", "framework", "providers"):
+            if field not in cfg:
+                raise ValueError(f"Missing required field: {field}")
+        if not isinstance(cfg["providers"], dict):
+            raise ValueError("'providers' must be a dict")
+        return True
+
+    def config_exists(self) -> bool:
+        return self.config_path.exists()
+
+
+config = Config()

core/fetcher.py

@@ -0,0 +1,140 @@
+"""
+Provider fetcher — downloads and installs providers from CDN.
+"""
+
+import json
+import os
+import shutil
+import tarfile
+import time
+import zipfile
+from pathlib import Path
+from typing import Dict, List
+
+import requests
+
+
+class ProviderFetcher:
+    def __init__(self, cdn_url: str, library_dir: Path):
+        raw = cdn_url.rstrip("/")
+        if not raw.startswith(("http://", "https://")):
+            raw = "https://" + raw
+        self.cdn_url = raw
+        self.library_dir = library_dir
+        self.providers_dir = library_dir / "providers"
+        self.providers_dir.mkdir(parents=True, exist_ok=True)
+
+    # ── CDN discovery ─────────────────────────────────────────────────────────
+
+    def fetch_available_providers(self, framework: str) -> List[str]:
+        """GET /providers/{framework}/available → list of provider names."""
+        url = f"{self.cdn_url}/providers/{framework}/available"
+        resp = requests.get(url, timeout=15)
+        resp.raise_for_status()
+        data = resp.json()
+        if not isinstance(data, list):
+            raise ValueError(f"Expected list from {url}, got {type(data)}")
+        return data
+
+    def fetch_available_versions(self, framework: str, provider_name: str) -> List[str]:
+        """GET /providers/{framework}/{provider}/available → list of versions."""
+        url = f"{self.cdn_url}/providers/{framework}/{provider_name}/available"
+        resp = requests.get(url, timeout=15)
+        resp.raise_for_status()
+        data = resp.json()
+        if not isinstance(data, list):
+            raise ValueError(f"Expected list from {url}, got {type(data)}")
+        return data
+
+    def fetch_metadata(self, framework: str, provider_name: str, version: str) -> Dict:
+        """GET /providers/{framework}/{provider}/{version} → metadata dict with download_url."""
+        url = f"{self.cdn_url}/providers/{framework}/{provider_name}/{version}"
+        resp = requests.get(url, timeout=15)
+        resp.raise_for_status()
+        return resp.json()
+
+    # ── Install ───────────────────────────────────────────────────────────────
+
+    def install_provider(
+        self,
+        framework: str,
+        provider_name: str,
+        version: str,
+        force: bool = False,
+    ) -> Path:
+        provider_dir = self.providers_dir / provider_name
+
+        if provider_dir.exists() and not force:
+            return provider_dir
+
+        metadata = self.fetch_metadata(framework, provider_name, version)
+        download_url = metadata.get("download_url", "").strip()
+        if not download_url:
+            raise ValueError(
+                f"CDN returned no download_url for {provider_name}@{version}"
+            )
+        if not download_url.startswith(("http://", "https://")):
+            download_url = "https://" + download_url
+
+        resp = requests.get(download_url, timeout=60, stream=True)
+        resp.raise_for_status()
+
+        # Unique temp paths — safe against concurrent paykit runs
+        uid = f"{os.getpid()}_{int(time.time() * 1000)}"
+        is_tar = ".tar" in download_url or download_url.endswith(".tgz")
+        suffix = ".tar.gz" if is_tar else ".zip"
+        tmp_archive = self.providers_dir / f"_{provider_name}_{uid}{suffix}"
+        tmp_dir = self.providers_dir / f"_{provider_name}_{uid}_extract"
+
+        try:
+            with open(tmp_archive, "wb") as fh:
+                for chunk in resp.iter_content(chunk_size=8192):
+                    fh.write(chunk)
+
+            tmp_dir.mkdir(parents=True, exist_ok=True)
+
+            if is_tar:
+                with tarfile.open(tmp_archive, "r:gz") as tf:
+                    tf.extractall(tmp_dir)
+            else:
+                with zipfile.ZipFile(tmp_archive, "r") as zf:
+                    zf.extractall(tmp_dir)
+
+            # The archive may wrap everything in a single top-level dir — unwrap it
+            extracted = list(tmp_dir.iterdir())
+            if len(extracted) == 1 and extracted[0].is_dir():
+                actual_dir = extracted[0]
+            else:
+                actual_dir = tmp_dir
+
+            if provider_dir.exists():
+                shutil.rmtree(provider_dir)
+            actual_dir.rename(provider_dir)
+
+        except Exception:
+            if tmp_dir.exists():
+                shutil.rmtree(tmp_dir, ignore_errors=True)
+            raise
+        finally:
+            if tmp_archive.exists():
+                tmp_archive.unlink()
+            if tmp_dir.exists():
+                shutil.rmtree(tmp_dir, ignore_errors=True)
+
+        return provider_dir
+
+    def verify_installation(self, provider_name: str) -> bool:
+        provider_dir = self.providers_dir / provider_name
+        if not provider_dir.is_dir():
+            return False
+        if not (provider_dir / "__init__.py").exists():
+            return False
+        manifest = provider_dir / "manifest.json"
+        if not manifest.exists():
+            return False
+        try:
+            with open(manifest) as fh:
+                json.load(fh)
+        except (json.JSONDecodeError, OSError):
+            return False
+        return True

paykit_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: paykit-sdk
+Version: 0.1.0
+Summary: Payment provider integration toolkit
+Home-page: https://github.com/abrorbekuz/paykit
+Author: Abror Qodirov
+Author-email: splayerme@gmail.com
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: requests>=2.25.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# PayKit
+
+Payment provider integration toolkit for Django and other web frameworks.
+
+## Installation
+
+```bash
+pip install paykit-sdk
+```
+
+## Quick Start
+
+Initialize PayKit in your project directory. If `paykit.json` already exists, it will sync automatically.
+
+```bash
+paykit init
+```
+
+## CLI Reference
+
+### Set Framework
+
+PayKit auto-detects your framework. Only run this if detection fails or you want to override it.
+
+```bash
+paykit set django
+paykit set flask
+```
+
+### Add a Provider
+
+```bash
+paykit add payme              # latest version
+paykit add payme@latest       # explicitly latest
+paykit add payme@1            # major version
+paykit add payme@1.0.0        # exact version
+```
+
+### Re-sync Config
+
+After editing `paykit.json`, re-run init to apply changes:
+
+```bash
+paykit init
+```
+
+## Configuration
+
+`paykit.json` is auto-generated on `paykit init`. Edit it as needed, then re-run `paykit init`.
+
+```json
+{
+  "framework": "django",
+  "providers": {
+    "payme": "latest"
+  },
+  "defaults": {
+    "payme": {
+      "language": "uz",
+      "request_link": "https://test.paycom.uz",
+      "callback_link": "https://your-domain.com/payme_endpoint/"
+    }
+  }
+}
+```
+
+| Field | Description | Options |
+|---|---|---|
+| `language` | Payment page language shown to user | `uz`, `ru`, `en` |
+| `request_link` | Payme checkout URL | Use test URL during development, production URL when live |
+| `callback_link` | Redirect URL after payment completes | Must be a publicly accessible URL |
+
+## Supported
+
+| Category | Supported |
+|---|---|
+| Languages | Python |
+| Frameworks | Django |
+| Providers | Payme |
+
+---
+
+For Django-specific integration (views, webhook handlers, payment link generation), see [Usage](/paykit/usage).

paykit_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+commands/__init__.py,sha256=F2fUYkoQRW_hPmh3sp-yVw-DoLDJp0gEv0YkUF6_Nbw,218
+commands/add.py,sha256=bBpZOjQm-hx9cU-OI7uHpPIJOVh_e48IilIFruJC1YQ,5075
+commands/init.py,sha256=p7gaByUAB94K-k_XNLevnpZjbEQ53wGUHXwiCy8qwTU,4040
+commands/set.py,sha256=FH-2fKcAWyjCXggl8fnXxe5eeqPwBw03EF590osJRzA,1289
+core/__init__.py,sha256=GbGHxjfkRCVx-UNLkvS3D-ZVbNvA0zfjd1oHu7bq3Rg,272
+core/config.py,sha256=_YS7Dno46zldYnL4NDO8ViGSbGLrQq18lCcaJD0nqYE,7038
+core/fetcher.py,sha256=p-Bo8j4C6byd_Iu50SDdknqzPY8XCpx3TIWqzgi9Ahc,5338
+paykit_sdk-0.1.0.dist-info/METADATA,sha256=n9SYif45VRPV1sx6mQJFsNYf4YHlXLdGUVBEYAzRGjg,2232
+paykit_sdk-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+paykit_sdk-0.1.0.dist-info/entry_points.txt,sha256=2JjKUfW2ImxDua108on5hg31apZMeTUKw7i2GNMZsOU,42
+paykit_sdk-0.1.0.dist-info/top_level.txt,sha256=Z_mfyM_t0Id8-bdJwN5KANmvkNmNot6ubFnG7U5Cbpo,14
+paykit_sdk-0.1.0.dist-info/RECORD,,

paykit_sdk-0.1.0.dist-info/WHEEL

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

paykit_sdk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+paykit = paykit.cli:cli

paykit_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+commands
+core