satgate 0.1.0__tar.gz

satgate-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,76 @@
+# 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/satgate/__init__.py

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

satgate-0.1.0/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-0.1.0/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/satgate.egg-info/PKG-INFO

@@ -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/satgate.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+setup.py
+satgate/__init__.py
+satgate/client.py
+satgate/langchain_integrations.py
+satgate.egg-info/PKG-INFO
+satgate.egg-info/SOURCES.txt
+satgate.egg-info/dependency_links.txt
+satgate.egg-info/requires.txt
+satgate.egg-info/top_level.txt
+tests/test_sdk.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,10 @@
+requests>=2.25.0
+
+[dev]
+pytest
+responses
+flask
+
+[langchain]
+langchain>=0.1.0
+pydantic>=2.0.0

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

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

satgate-0.1.0/setup.cfg

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

satgate-0.1.0/setup.py

@@ -0,0 +1,41 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="satgate",
+    version="0.1.0",
+    description="Python SDK for SatGate - Stripe for AI Agents. L402 micropayments for APIs.",
+    long_description=open("README.md").read() if __import__("os").path.exists("README.md") else "",
+    long_description_content_type="text/markdown",
+    author="SatGate Team",
+    author_email="contact@satgate.io",
+    url="https://github.com/SatGate-io/satgate",
+    project_urls={
+        "Homepage": "https://satgate.io",
+        "Documentation": "https://satgate.io/playground",
+        "Repository": "https://github.com/SatGate-io/satgate",
+    },
+    packages=find_packages(),
+    install_requires=[
+        "requests>=2.25.0",
+    ],
+    extras_require={
+        "langchain": ["langchain>=0.1.0", "pydantic>=2.0.0"],
+        "dev": ["pytest", "responses", "flask"],
+    },
+    python_requires=">=3.8",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Internet :: WWW/HTTP",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
+    keywords="l402 lightning bitcoin micropayments api ai agents langchain",
+)
+

satgate-0.1.0/tests/test_sdk.py

@@ -0,0 +1,107 @@
+import threading
+import time
+import requests
+import unittest
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from satgate.client import SatGateSession, LightningWallet
+
+# --- Mock Server ---
+
+class MockL402Handler(BaseHTTPRequestHandler):
+    protocol_version = 'HTTP/1.1'
+
+    def do_GET(self):
+        # Check for Authorization header
+        auth_header = self.headers.get("Authorization")
+        
+        if auth_header and auth_header.startswith("L402"):
+            # Validate token (Mock validation)
+            # Expected: L402 macaroon:preimage
+            token = auth_header.split(" ")[1]
+            if ":" in token:
+                macaroon, preimage = token.split(":")
+                if macaroon == "test_macaroon" and preimage == "test_preimage":
+                    self.send_response(200)
+                    self.send_header("Content-type", "application/json")
+                    self.end_headers()
+                    self.wfile.write(b'{"status": "success", "data": "premium_content"}')
+                    return
+        
+        # Default: Return 402
+        self.send_response(402)
+        self.send_header("WWW-Authenticate", 'L402 macaroon="test_macaroon", invoice="lnbc_test_invoice"')
+        self.send_header("Content-type", "text/plain")
+        self.end_headers()
+        self.wfile.write(b'Payment Required')
+
+    def log_message(self, format, *args):
+        # Silence logs
+        pass
+
+class MockServer:
+    def __init__(self):
+        self.server = HTTPServer(('localhost', 0), MockL402Handler)
+        self.port = self.server.server_port
+        self.thread = threading.Thread(target=self.server.serve_forever)
+        self.thread.daemon = True
+
+    def start(self):
+        self.thread.start()
+        # Give it a moment to start
+        time.sleep(0.1)
+
+    def stop(self):
+        self.server.shutdown()
+        self.server.server_close()
+
+# --- Mock Wallet ---
+
+class MockWallet(LightningWallet):
+    def pay_invoice(self, invoice: str) -> str:
+        if invoice == "lnbc_test_invoice":
+            return "test_preimage"
+        raise ValueError("Unknown invoice")
+
+# --- Integration Test ---
+
+class TestSatGateSDK(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.server = MockServer()
+        cls.server.start()
+        cls.base_url = f"http://localhost:{cls.server.port}"
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.server.stop()
+
+    def test_l402_flow(self):
+        # 1. Setup Wallet and Session
+        wallet = MockWallet()
+        session = SatGateSession(wallet=wallet)
+
+        # 2. Make Request
+        print(f"\nTesting request to {self.base_url}...")
+        response = session.get(self.base_url)
+
+        # 3. Verify Result
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"status": "success", "data": "premium_content"})
+        print("✅ L402 Flow Verified: 402 -> Pay -> 200")
+
+    def test_payment_failure(self):
+        # Wallet that fails
+        class BrokeWallet(LightningWallet):
+            def pay_invoice(self, invoice: str) -> str:
+                raise Exception("Insufficient funds")
+
+        session = SatGateSession(wallet=BrokeWallet())
+        
+        # Should return the original 402 response
+        response = session.get(self.base_url)
+        self.assertEqual(response.status_code, 402)
+        print("✅ Failure Handling Verified")
+
+if __name__ == "__main__":
+    unittest.main()
+