satgate 0.1.0__py3-none-any.whl

satgate/__init__.py

@@ -0,0 +1,4 @@
+from .client import SatGateSession, LightningWallet
+
+__all__ = ["SatGateSession", "LightningWallet"]
+

satgate/client.py

@@ -0,0 +1,99 @@
+import requests
+import re
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, Any
+
+# --- 1. Wallet Interface (Plug & Play) ---
+
+class LightningWallet(ABC):
+    """Abstract Base Class for any Lightning Wallet"""
+    
+    @abstractmethod
+    def pay_invoice(self, invoice: str) -> str:
+        """Pays the invoice and returns the preimage (hex string)"""
+        pass
+
+# --- 2. The Intelligent Session ---
+
+class SatGateSession(requests.Session):
+    def __init__(self, wallet: LightningWallet):
+        super().__init__()
+        self.wallet = wallet
+
+    def request(self, method: str, url: str, *args, **kwargs) -> requests.Response:
+        # 1. Attempt the request normally
+        try:
+            response = super().request(method, url, *args, **kwargs)
+        except requests.exceptions.RequestException as e:
+            # If we can't even connect, re-raise
+            raise e
+
+        # 2. Intercept 402 Errors
+        if response.status_code == 402:
+            return self._handle_payment_flow(response, method, url, *args, **kwargs)
+        
+        return response
+
+    def _handle_payment_flow(self, response: requests.Response, method: str, url: str, *args, **kwargs) -> requests.Response:
+        """The magic loop: Parse -> Pay -> Retry"""
+        
+        # A. Parse the L402 Header
+        auth_header = response.headers.get("WWW-Authenticate")
+        if not auth_header:
+            # Some servers might not send WWW-Authenticate or send it differently
+            # Try to see if it's in the body or standard L402
+            print("⚠️ 402 received but no WWW-Authenticate header found.")
+            return response
+
+        # Check for L402 or LSAT
+        if "L402" not in auth_header and "LSAT" not in auth_header:
+             print("⚠️ 402 received but header does not contain L402/LSAT scheme.")
+             return response
+
+        # Extract Invoice and Macaroon (Regex to handle standard L402 format)
+        # Example: L402 macaroon="...", invoice="lnbc..."
+        # Using non-greedy match for values in quotes
+        macaroon_match = re.search(r'macaroon="([^"]+)"', auth_header)
+        invoice_match = re.search(r'invoice="([^"]+)"', auth_header)
+
+        if not macaroon_match or not invoice_match:
+            print("❌ Invalid L402 header format: could not find macaroon or invoice.")
+            return response
+
+        macaroon = macaroon_match.group(1)
+        invoice = invoice_match.group(1)
+
+        print(f"⚡ 402 Detected. Price: Unknown (check invoice).")
+        print(f"   Invoice: {invoice[:20]}...{invoice[-10:]}")
+
+        # B. Pay the Invoice (User's Wallet Implementation)
+        try:
+            preimage = self.wallet.pay_invoice(invoice)
+            if not preimage:
+                 raise ValueError("Wallet returned empty preimage")
+            print(f"✅ Payment Confirmed. Preimage: {preimage[:10]}...")
+        except Exception as e:
+            print(f"❌ Payment Failed: {e}")
+            return response
+
+        # C. Retry with Authorization
+        # Format: Authorization: L402 <macaroon>:<preimage>
+        # Note: Some implementations might use LSAT, but L402 is the standard.
+        # We'll use L402 as the prefix.
+        l402_token = f"L402 {macaroon}:{preimage}"
+        
+        # Merge headers if they exist, or create new dict
+        # We need to be careful not to modify the original kwargs['headers'] in place 
+        # if it's reused elsewhere, though usually fine here.
+        req_headers = kwargs.get("headers", {})
+        if req_headers is None:
+            req_headers = {}
+        
+        # Copy to avoid side effects
+        req_headers = req_headers.copy()
+        req_headers["Authorization"] = l402_token
+        kwargs["headers"] = req_headers
+
+        print("🔄 Retrying request with L402 Token...")
+        return super().request(method, url, *args, **kwargs)
+

satgate/langchain_integrations.py

@@ -0,0 +1,46 @@
+from typing import Optional, Type, Any
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from .client import SatGateSession, LightningWallet
+
+class SatGateToolInput(BaseModel):
+    endpoint: str = Field(description="The full URL of the premium API endpoint to fetch data from.")
+
+class SatGateTool(BaseTool):
+    name: str = "satgate_api_browser"
+    description: str = (
+        "Useful for fetching data from paid/premium APIs that require Lightning Network payments. "
+        "Use this tool when you need to access high-value data, reports, or analytics "
+        "that are behind a paywall. The tool handles payment automatically."
+    )
+    args_schema: Type[BaseModel] = SatGateToolInput
+    
+    # We exclude session from Pydantic fields since it's not a model field
+    # but an internal component. However, LangChain tools often want fields to be Pydantic compatible.
+    # We'll mark it as PrivateAttr or just exclude it from init if possible, 
+    # but BaseTool inherits from BaseModel.
+    # The standard way is to treat it as a private attribute or configured via init.
+    
+    _session: SatGateSession
+
+    def __init__(self, wallet: LightningWallet, **kwargs):
+        super().__init__(**kwargs)
+        self._session = SatGateSession(wallet=wallet)
+
+    def _run(self, endpoint: str) -> str:
+        """Synchronous execution"""
+        try:
+            response = self._session.get(endpoint)
+            # Raise error for 4xx/5xx if not handled (though 402 is handled inside)
+            response.raise_for_status()
+            return response.text
+        except Exception as e:
+            return f"Error fetching data: {str(e)}"
+
+    async def _arun(self, endpoint: str) -> str:
+        """Async support (Critical for high-performance agents)"""
+        # For MVP, we can just wrap the sync call or use aiohttp later
+        # Since SatGateSession is sync (requests), we just call _run.
+        return self._run(endpoint)
+

satgate-0.1.0.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: satgate
+Version: 0.1.0
+Summary: Python SDK for SatGate - Stripe for AI Agents. L402 micropayments for APIs.
+Home-page: https://github.com/SatGate-io/satgate
+Author: SatGate Team
+Author-email: contact@satgate.io
+Project-URL: Homepage, https://satgate.io
+Project-URL: Documentation, https://satgate.io/playground
+Project-URL: Repository, https://github.com/SatGate-io/satgate
+Keywords: l402 lightning bitcoin micropayments api ai agents langchain
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+Requires-Dist: pydantic>=2.0.0; extra == "langchain"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: responses; extra == "dev"
+Requires-Dist: flask; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SatGate Python SDK
+
+**Stripe for AI Agents** — L402 micropayments for APIs.
+
+[![PyPI version](https://badge.fury.io/py/satgate.svg)](https://pypi.org/project/satgate/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install satgate
+```
+
+For LangChain integration:
+
+```bash
+pip install satgate[langchain]
+```
+
+## Quick Start
+
+```python
+from satgate import SatGateSession, LightningWallet
+
+# Implement your wallet (or use a library like lndgrpc, pyln-client)
+class MyWallet(LightningWallet):
+    def pay_invoice(self, invoice: str) -> str:
+        # Pay the invoice and return the preimage
+        return your_lightning_node.pay(invoice)
+
+# Create a session that auto-pays 402 responses
+session = SatGateSession(wallet=MyWallet())
+
+# Use like requests - payments happen automatically!
+response = session.get("https://api.example.com/premium/data")
+print(response.json())
+```
+
+## LangChain Integration
+
+```python
+from satgate import SatGateTool
+
+# Create a tool your AI agent can use
+tool = SatGateTool(wallet=MyWallet())
+
+# Add to your LangChain agent
+agent = initialize_agent(
+    tools=[tool],
+    llm=ChatOpenAI(),
+    agent=AgentType.OPENAI_FUNCTIONS
+)
+
+# The agent can now access paid APIs automatically!
+agent.run("Fetch premium market data from https://api.example.com/insights")
+```
+
+## How It Works
+
+1. Your code makes a request to a paid API
+2. The API returns `402 Payment Required` with a Lightning invoice
+3. SatGate automatically pays the invoice via your wallet
+4. The request is retried with the L402 token
+5. You get your data ✨
+
+## Links
+
+- 🌐 Website: [satgate.io](https://satgate.io)
+- 📖 Playground: [satgate.io/playground](https://satgate.io/playground)
+- 💻 GitHub: [github.com/SatGate-io/satgate](https://github.com/SatGate-io/satgate)
+- 📧 Contact: contact@satgate.io
+
+## License
+
+MIT License - © 2025 SatGate. Patent Pending.
+

satgate-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+satgate/__init__.py,sha256=KxzSzbD50GKEao2piywGDIiMQKCcS2FRvnVFf5p_TtA,102
+satgate/client.py,sha256=RgsAmdPIBTHM6uLy8GdskZtzhL5hQxIzaAAlcJtzZng,3898
+satgate/langchain_integrations.py,sha256=gugk-CfOnMFfIHvYNkl8dCZ3ulJG6dlP4_TNrssjUEE,1971
+satgate-0.1.0.dist-info/METADATA,sha256=BkIWHaDJ2q2hKogAVXNp-VqAl0AqwBFqhOHeqPGmxMo,3608
+satgate-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+satgate-0.1.0.dist-info/top_level.txt,sha256=7snZYk1LjcrpxhXVSGoAKTJBkisPVJq4YpGTpQtL_k8,8
+satgate-0.1.0.dist-info/RECORD,,

satgate-0.1.0.dist-info/WHEEL

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

satgate-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+satgate