ghostnexus 0.1.0__tar.gz

ghostnexus-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: ghostnexus
+Version: 0.1.0
+Summary: SDK Python officiel pour GhostNexus — GPU cloud décentralisé, sécurisé & RGPD
+Author-email: GhostNexus <contact@ghostnexus.net>
+License: MIT
+Project-URL: Homepage, https://ghostnexus.net
+Project-URL: Documentation, https://ghostnexus.net/docs
+Project-URL: Repository, https://github.com/ghostnexus/ghostnexus-python
+Project-URL: Bug Tracker, https://github.com/ghostnexus/ghostnexus-python/issues
+Keywords: gpu,cloud,ai,machine-learning,decentralized,compute
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: responses; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+
+# GhostNexus Python SDK
+
+**Run Python scripts on GDPR-compliant GPU cloud — billed by the second.**
+
+[![PyPI version](https://badge.fury.io/py/ghostnexus.svg)](https://pypi.org/project/ghostnexus/)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+GhostNexus is a decentralized GPU compute network. Submit your Python script, our distributed GPUs run it — securely, in the EU, billed by the second.
+
+- **RTX 4090** from $0.50/hr · **A100 80GB** from $2.20/hr · **H100** from $3.50/hr
+- GDPR-compliant · EU-hosted · AI Act 2026 ready
+- Docker sandbox isolation · Per-second billing · No minimum deposit
+
+---
+
+## Install
+
+```bash
+pip install ghostnexus
+```
+
+## Quick Start
+
+```python
+import ghostnexus
+
+client = ghostnexus.Client(api_key="gn_live_...")
+
+# Submit a script
+job = client.run("train.py")
+
+# Wait for result
+result = job.wait()
+print(result.output)
+print(f"Cost: ${result.cost_credits:.4f}")
+```
+
+Get your API key at [ghostnexus.net/dashboard](https://ghostnexus.net/dashboard) — $15 free credits with code `WELCOME15`.
+
+## Examples
+
+### Fine-tune a model
+
+```python
+import ghostnexus
+
+client = ghostnexus.Client()  # reads GHOSTNEXUS_API_KEY env var
+
+job = client.run("finetune_mistral.py", task_name="Mistral-7B LoRA fine-tune")
+result = job.wait(timeout=7200)  # 2h max
+
+print(result.output)
+# Duration: 1h 23m
+# Cost: $0.69
+```
+
+### Inline script
+
+```python
+job = client.run(
+    "import torch; print(f'CUDA: {torch.cuda.is_available()}')",
+    inline=True,
+    task_name="cuda-check"
+)
+result = job.wait(timeout=30)
+print(result.output)  # CUDA: True
+```
+
+### Check balance
+
+```python
+balance = client.balance()
+print(f"Available credits: ${balance:.2f}")
+```
+
+### Job history
+
+```python
+jobs = client.history(limit=10)
+for job in jobs:
+    print(f"{job.task_name}: {job.status} — ${job.cost_credits:.4f}")
+```
+
+## Error Handling
+
+```python
+from ghostnexus.exceptions import InsufficientCreditsError, JobFailedError
+
+try:
+    job = client.run("train.py")
+    result = job.wait()
+except InsufficientCreditsError:
+    print("Top up at https://ghostnexus.net/dashboard")
+except JobFailedError as e:
+    print(f"Job failed. Logs:\n{e.logs}")
+```
+
+## Environment Variable
+
+```bash
+export GHOSTNEXUS_API_KEY="gn_live_..."
+```
+
+```python
+# No need to pass api_key= explicitly
+client = ghostnexus.Client()
+```
+
+## Pricing
+
+| GPU | VRAM | Price | Best for |
+|-----|------|-------|----------|
+| RTX 4070 | 12 GB | $0.25/hr | Inference, small models |
+| RTX 4090 | 24 GB | $0.50/hr | Fine-tuning 7B–13B |
+| RTX A6000 | 48 GB | $0.70/hr | Fine-tuning 30B–70B |
+| A100 80GB | 80 GB | $2.20/hr | Large-scale training |
+| H100 80GB | 80 GB | $3.50/hr | LLM pre-training |
+
+Billed **per second** — no hourly rounding, no minimum.
+
+## Links
+
+- [Dashboard](https://ghostnexus.net/dashboard) — manage jobs and credits
+- [Pricing](https://ghostnexus.net/pricing) — full GPU catalog
+- [Blog](https://ghostnexus.net/blog) — tutorials and guides
+- [Contact](mailto:contact@ghostnexus.net)
+
+## License
+
+MIT

ghostnexus-0.1.0/README.md

@@ -0,0 +1,131 @@
+# GhostNexus Python SDK
+
+**Run Python scripts on GDPR-compliant GPU cloud — billed by the second.**
+
+[![PyPI version](https://badge.fury.io/py/ghostnexus.svg)](https://pypi.org/project/ghostnexus/)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+GhostNexus is a decentralized GPU compute network. Submit your Python script, our distributed GPUs run it — securely, in the EU, billed by the second.
+
+- **RTX 4090** from $0.50/hr · **A100 80GB** from $2.20/hr · **H100** from $3.50/hr
+- GDPR-compliant · EU-hosted · AI Act 2026 ready
+- Docker sandbox isolation · Per-second billing · No minimum deposit
+
+---
+
+## Install
+
+```bash
+pip install ghostnexus
+```
+
+## Quick Start
+
+```python
+import ghostnexus
+
+client = ghostnexus.Client(api_key="gn_live_...")
+
+# Submit a script
+job = client.run("train.py")
+
+# Wait for result
+result = job.wait()
+print(result.output)
+print(f"Cost: ${result.cost_credits:.4f}")
+```
+
+Get your API key at [ghostnexus.net/dashboard](https://ghostnexus.net/dashboard) — $15 free credits with code `WELCOME15`.
+
+## Examples
+
+### Fine-tune a model
+
+```python
+import ghostnexus
+
+client = ghostnexus.Client()  # reads GHOSTNEXUS_API_KEY env var
+
+job = client.run("finetune_mistral.py", task_name="Mistral-7B LoRA fine-tune")
+result = job.wait(timeout=7200)  # 2h max
+
+print(result.output)
+# Duration: 1h 23m
+# Cost: $0.69
+```
+
+### Inline script
+
+```python
+job = client.run(
+    "import torch; print(f'CUDA: {torch.cuda.is_available()}')",
+    inline=True,
+    task_name="cuda-check"
+)
+result = job.wait(timeout=30)
+print(result.output)  # CUDA: True
+```
+
+### Check balance
+
+```python
+balance = client.balance()
+print(f"Available credits: ${balance:.2f}")
+```
+
+### Job history
+
+```python
+jobs = client.history(limit=10)
+for job in jobs:
+    print(f"{job.task_name}: {job.status} — ${job.cost_credits:.4f}")
+```
+
+## Error Handling
+
+```python
+from ghostnexus.exceptions import InsufficientCreditsError, JobFailedError
+
+try:
+    job = client.run("train.py")
+    result = job.wait()
+except InsufficientCreditsError:
+    print("Top up at https://ghostnexus.net/dashboard")
+except JobFailedError as e:
+    print(f"Job failed. Logs:\n{e.logs}")
+```
+
+## Environment Variable
+
+```bash
+export GHOSTNEXUS_API_KEY="gn_live_..."
+```
+
+```python
+# No need to pass api_key= explicitly
+client = ghostnexus.Client()
+```
+
+## Pricing
+
+| GPU | VRAM | Price | Best for |
+|-----|------|-------|----------|
+| RTX 4070 | 12 GB | $0.25/hr | Inference, small models |
+| RTX 4090 | 24 GB | $0.50/hr | Fine-tuning 7B–13B |
+| RTX A6000 | 48 GB | $0.70/hr | Fine-tuning 30B–70B |
+| A100 80GB | 80 GB | $2.20/hr | Large-scale training |
+| H100 80GB | 80 GB | $3.50/hr | LLM pre-training |
+
+Billed **per second** — no hourly rounding, no minimum.
+
+## Links
+
+- [Dashboard](https://ghostnexus.net/dashboard) — manage jobs and credits
+- [Pricing](https://ghostnexus.net/pricing) — full GPU catalog
+- [Blog](https://ghostnexus.net/blog) — tutorials and guides
+- [Contact](mailto:contact@ghostnexus.net)
+
+## License
+
+MIT

ghostnexus-0.1.0/ghostnexus/__init__.py

@@ -0,0 +1,39 @@
+"""
+GhostNexus Python SDK
+~~~~~~~~~~~~~~~~~~~~~
+
+Run Python scripts on the GhostNexus decentralized GPU network.
+GDPR-compliant, EU-hosted, billed by the second.
+
+Quick start:
+    import ghostnexus
+    client = ghostnexus.Client(api_key="gn_live_...")
+    job = client.run("train.py")
+    result = job.wait()
+    print(result.output)
+
+Full documentation: https://ghostnexus.net/docs
+"""
+
+from .client import Client
+from .models import Job, JobResult, UserInfo
+from .exceptions import (
+    GhostNexusError,
+    AuthenticationError,
+    InsufficientCreditsError,
+    JobFailedError,
+    TimeoutError as GNTimeoutError,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "Client",
+    "Job",
+    "JobResult",
+    "UserInfo",
+    "GhostNexusError",
+    "AuthenticationError",
+    "InsufficientCreditsError",
+    "JobFailedError",
+    "GNTimeoutError",
+]

ghostnexus-0.1.0/ghostnexus/client.py

@@ -0,0 +1,176 @@
+"""
+GhostNexus Python SDK — Client
+"""
+import os
+import pathlib
+from typing import List, Optional
+
+import requests
+
+from .exceptions import (
+    AuthenticationError,
+    GhostNexusError,
+    InsufficientCreditsError,
+    ValidationError,
+)
+from .models import Job, JobResult, UserInfo
+
+_DEFAULT_BASE_URL = "https://ghostnexus.net"
+
+
+class Client:
+    """
+    GhostNexus API client.
+
+    Args:
+        api_key: Your GhostNexus API key (starts with gn_live_).
+                 If not provided, reads the GHOSTNEXUS_API_KEY environment variable.
+        base_url: API base URL (default: https://ghostnexus.net)
+        timeout:  HTTP timeout in seconds (default: 30)
+
+    Example:
+        >>> import ghostnexus
+        >>> client = ghostnexus.Client(api_key="gn_live_...")
+        >>> job = client.run("train.py")
+        >>> result = job.wait()
+        >>> print(result.output)
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = _DEFAULT_BASE_URL,
+        timeout: int = 30,
+    ):
+        self._api_key = api_key or os.environ.get("GHOSTNEXUS_API_KEY", "")
+        if not self._api_key:
+            raise AuthenticationError(
+                "Missing API key. Pass api_key= or set the GHOSTNEXUS_API_KEY "
+                "environment variable.\n"
+                "Get your key at https://ghostnexus.net/dashboard"
+            )
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._session = requests.Session()
+        self._session.headers.update({"x-api-key": self._api_key})
+
+    # ── Account ───────────────────────────────────────────────────────────────
+
+    def me(self) -> UserInfo:
+        """Return account information (email, credits)."""
+        data = self._get("/api/me")
+        return UserInfo.from_dict(data)
+
+    # ── Jobs ──────────────────────────────────────────────────────────────────
+
+    def run(
+        self,
+        script: str,
+        task_name: Optional[str] = None,
+        inline: bool = False,
+    ) -> Job:
+        """
+        Submit a Python script to the GhostNexus GPU network.
+
+        Args:
+            script:    Path to a .py file OR inline Python code if inline=True.
+            task_name: Job name (shown in dashboard). Defaults to the filename.
+            inline:    If True, `script` is treated as Python source code directly.
+
+        Returns:
+            Job — call .wait() to block until completion.
+
+        Raises:
+            AuthenticationError: Invalid API key.
+            InsufficientCreditsError: Not enough credits.
+            ValidationError: Script rejected by security policy.
+            GhostNexusError: Other API error.
+
+        Example:
+            >>> job = client.run("train.py")
+            >>> result = job.wait()
+
+            >>> job = client.run("import torch; print(torch.__version__)", inline=True)
+            >>> result = job.wait(timeout=60)
+        """
+        if inline:
+            script_content = script
+            name = task_name or "inline_script"
+        else:
+            path = pathlib.Path(script)
+            if not path.exists():
+                raise FileNotFoundError(f"Script not found: {script}")
+            script_content = path.read_text(encoding="utf-8")
+            name = task_name or path.name
+
+        data = self._post("/api/jobs", {
+            "script_content": script_content,
+            "task_name": name,
+        })
+        return Job.from_dict(data, client=self)
+
+    def status(self, job_id: str) -> JobResult:
+        """
+        Return the current status of a job.
+
+        Args:
+            job_id: Job identifier returned by .run().
+
+        Returns:
+            JobResult with status (pending/dispatched/success/failed), output, cost.
+        """
+        data = self._get(f"/api/jobs/{job_id}")
+        return JobResult.from_dict(data)
+
+    def history(self, limit: int = 50, offset: int = 0) -> List[JobResult]:
+        """
+        Return job history (paginated).
+
+        Args:
+            limit:  Number of results (max 500).
+            offset: Pagination offset.
+        """
+        data = self._get("/api/jobs/history", params={"limit": limit, "offset": offset})
+        return [JobResult.from_dict(j) for j in data]
+
+    # ── Credits ───────────────────────────────────────────────────────────────
+
+    def balance(self) -> float:
+        """Return available credit balance in USD."""
+        return self.me().credit_balance
+
+    # ── Internal HTTP ─────────────────────────────────────────────────────────
+
+    def _get(self, path: str, params: dict = None) -> dict:
+        resp = self._session.get(
+            f"{self._base_url}{path}",
+            params=params,
+            timeout=self._timeout,
+        )
+        return self._handle(resp)
+
+    def _post(self, path: str, payload: dict) -> dict:
+        resp = self._session.post(
+            f"{self._base_url}{path}",
+            json=payload,
+            timeout=self._timeout,
+        )
+        return self._handle(resp)
+
+    @staticmethod
+    def _handle(resp: requests.Response) -> dict:
+        if resp.status_code == 401:
+            raise AuthenticationError("Invalid or expired API key.", status_code=401)
+        if resp.status_code == 402:
+            detail = resp.json().get("detail", "Insufficient credits.")
+            raise InsufficientCreditsError(detail, status_code=402)
+        if resp.status_code == 422:
+            errors = resp.json().get("detail", [])
+            raise ValidationError(f"Script rejected: {errors}", status_code=422)
+        if not resp.ok:
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            raise GhostNexusError(detail, status_code=resp.status_code)
+        return resp.json()

ghostnexus-0.1.0/ghostnexus/exceptions.py

@@ -0,0 +1,32 @@
+"""GhostNexus SDK exceptions."""
+
+
+class GhostNexusError(Exception):
+    """Base exception for the GhostNexus SDK."""
+    def __init__(self, message: str, status_code: int = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class AuthenticationError(GhostNexusError):
+    """Invalid or expired API key."""
+
+
+class InsufficientCreditsError(GhostNexusError):
+    """Not enough credits to run the job."""
+
+
+class JobFailedError(GhostNexusError):
+    """The job failed on the provider side."""
+    def __init__(self, message: str, job_id: str = None, logs: str = None):
+        super().__init__(message)
+        self.job_id = job_id
+        self.logs = logs
+
+
+class TimeoutError(GhostNexusError):
+    """The job did not complete within the timeout."""
+
+
+class ValidationError(GhostNexusError):
+    """The script was rejected by the security policy."""

ghostnexus-0.1.0/ghostnexus/models.py

@@ -0,0 +1,103 @@
+"""GhostNexus SDK data models."""
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class UserInfo:
+    """Information about the authenticated user."""
+    email: str
+    credit_balance: float
+    api_key_prefix: str
+    is_admin: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "UserInfo":
+        return cls(
+            email=data["email"],
+            credit_balance=float(data["credit_balance"]),
+            api_key_prefix=data["api_key_prefix"],
+            is_admin=data.get("is_admin", False),
+        )
+
+
+@dataclass
+class JobResult:
+    """Result of a completed job."""
+    job_id: str
+    status: str          # success | failed
+    output: Optional[str] = None
+    duration_seconds: Optional[float] = None
+    cost_credits: Optional[float] = None
+    task_name: Optional[str] = None
+
+    @property
+    def success(self) -> bool:
+        return self.status == "success"
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "JobResult":
+        return cls(
+            job_id=data["job_id"],
+            status=data["status"],
+            output=data.get("output_logs"),
+            duration_seconds=data.get("duration_seconds"),
+            cost_credits=float(data["cost_credits"]) if data.get("cost_credits") else None,
+            task_name=data.get("task_name"),
+        )
+
+
+@dataclass
+class Job:
+    """
+    Represents a job submitted to the GhostNexus network.
+    Call .wait() to block until completion, or poll manually with client.status().
+    """
+    job_id: str
+    task_name: str
+    status: str = "pending"
+    _client: object = field(default=None, repr=False)
+
+    def wait(self, timeout: int = 600, poll_interval: int = 3) -> JobResult:
+        """
+        Wait for the job to complete (blocking).
+
+        Args:
+            timeout: Maximum wait time in seconds (default 600s = 10 min).
+            poll_interval: Polling interval in seconds.
+
+        Returns:
+            JobResult with status, output, cost.
+
+        Raises:
+            TimeoutError: If job does not complete within timeout.
+            JobFailedError: If the job failed.
+        """
+        import time
+        from .exceptions import TimeoutError, JobFailedError
+
+        start = time.time()
+        while True:
+            result = self._client.status(self.job_id)
+            if result.status in ("success", "failed"):
+                if result.status == "failed":
+                    raise JobFailedError(
+                        f"Job {self.job_id} failed",
+                        job_id=self.job_id,
+                        logs=result.output,
+                    )
+                return result
+            if time.time() - start > timeout:
+                raise TimeoutError(
+                    f"Job {self.job_id} not completed after {timeout}s"
+                )
+            time.sleep(poll_interval)
+
+    @classmethod
+    def from_dict(cls, data: dict, client=None) -> "Job":
+        return cls(
+            job_id=data["job_id"],
+            task_name=data.get("task_name", ""),
+            status=data.get("status", "pending"),
+            _client=client,
+        )

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

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: ghostnexus
+Version: 0.1.0
+Summary: SDK Python officiel pour GhostNexus — GPU cloud décentralisé, sécurisé & RGPD
+Author-email: GhostNexus <contact@ghostnexus.net>
+License: MIT
+Project-URL: Homepage, https://ghostnexus.net
+Project-URL: Documentation, https://ghostnexus.net/docs
+Project-URL: Repository, https://github.com/ghostnexus/ghostnexus-python
+Project-URL: Bug Tracker, https://github.com/ghostnexus/ghostnexus-python/issues
+Keywords: gpu,cloud,ai,machine-learning,decentralized,compute
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: responses; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+
+# GhostNexus Python SDK
+
+**Run Python scripts on GDPR-compliant GPU cloud — billed by the second.**
+
+[![PyPI version](https://badge.fury.io/py/ghostnexus.svg)](https://pypi.org/project/ghostnexus/)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+GhostNexus is a decentralized GPU compute network. Submit your Python script, our distributed GPUs run it — securely, in the EU, billed by the second.
+
+- **RTX 4090** from $0.50/hr · **A100 80GB** from $2.20/hr · **H100** from $3.50/hr
+- GDPR-compliant · EU-hosted · AI Act 2026 ready
+- Docker sandbox isolation · Per-second billing · No minimum deposit
+
+---
+
+## Install
+
+```bash
+pip install ghostnexus
+```
+
+## Quick Start
+
+```python
+import ghostnexus
+
+client = ghostnexus.Client(api_key="gn_live_...")
+
+# Submit a script
+job = client.run("train.py")
+
+# Wait for result
+result = job.wait()
+print(result.output)
+print(f"Cost: ${result.cost_credits:.4f}")
+```
+
+Get your API key at [ghostnexus.net/dashboard](https://ghostnexus.net/dashboard) — $15 free credits with code `WELCOME15`.
+
+## Examples
+
+### Fine-tune a model
+
+```python
+import ghostnexus
+
+client = ghostnexus.Client()  # reads GHOSTNEXUS_API_KEY env var
+
+job = client.run("finetune_mistral.py", task_name="Mistral-7B LoRA fine-tune")
+result = job.wait(timeout=7200)  # 2h max
+
+print(result.output)
+# Duration: 1h 23m
+# Cost: $0.69
+```
+
+### Inline script
+
+```python
+job = client.run(
+    "import torch; print(f'CUDA: {torch.cuda.is_available()}')",
+    inline=True,
+    task_name="cuda-check"
+)
+result = job.wait(timeout=30)
+print(result.output)  # CUDA: True
+```
+
+### Check balance
+
+```python
+balance = client.balance()
+print(f"Available credits: ${balance:.2f}")
+```
+
+### Job history
+
+```python
+jobs = client.history(limit=10)
+for job in jobs:
+    print(f"{job.task_name}: {job.status} — ${job.cost_credits:.4f}")
+```
+
+## Error Handling
+
+```python
+from ghostnexus.exceptions import InsufficientCreditsError, JobFailedError
+
+try:
+    job = client.run("train.py")
+    result = job.wait()
+except InsufficientCreditsError:
+    print("Top up at https://ghostnexus.net/dashboard")
+except JobFailedError as e:
+    print(f"Job failed. Logs:\n{e.logs}")
+```
+
+## Environment Variable
+
+```bash
+export GHOSTNEXUS_API_KEY="gn_live_..."
+```
+
+```python
+# No need to pass api_key= explicitly
+client = ghostnexus.Client()
+```
+
+## Pricing
+
+| GPU | VRAM | Price | Best for |
+|-----|------|-------|----------|
+| RTX 4070 | 12 GB | $0.25/hr | Inference, small models |
+| RTX 4090 | 24 GB | $0.50/hr | Fine-tuning 7B–13B |
+| RTX A6000 | 48 GB | $0.70/hr | Fine-tuning 30B–70B |
+| A100 80GB | 80 GB | $2.20/hr | Large-scale training |
+| H100 80GB | 80 GB | $3.50/hr | LLM pre-training |
+
+Billed **per second** — no hourly rounding, no minimum.
+
+## Links
+
+- [Dashboard](https://ghostnexus.net/dashboard) — manage jobs and credits
+- [Pricing](https://ghostnexus.net/pricing) — full GPU catalog
+- [Blog](https://ghostnexus.net/blog) — tutorials and guides
+- [Contact](mailto:contact@ghostnexus.net)
+
+## License
+
+MIT

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,7 @@
+requests>=2.28
+
+[dev]
+pytest
+responses
+black
+mypy

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

@@ -0,0 +1 @@
+ghostnexus

ghostnexus-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ghostnexus"
+version = "0.1.0"
+description = "SDK Python officiel pour GhostNexus — GPU cloud décentralisé, sécurisé & RGPD"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "GhostNexus", email = "contact@ghostnexus.net" }]
+keywords = ["gpu", "cloud", "ai", "machine-learning", "decentralized", "compute"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "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",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+requires-python = ">=3.9"
+dependencies = ["requests>=2.28"]
+
+[project.optional-dependencies]
+dev = ["pytest", "responses", "black", "mypy"]
+
+[project.urls]
+Homepage = "https://ghostnexus.net"
+Documentation = "https://ghostnexus.net/docs"
+Repository = "https://github.com/ghostnexus/ghostnexus-python"
+"Bug Tracker" = "https://github.com/ghostnexus/ghostnexus-python/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["ghostnexus*"]

ghostnexus-0.1.0/setup.cfg

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