feedo-sdk 0.1.0__py3-none-any.whl

feedo/__init__.py

@@ -0,0 +1,4 @@
+from .client import FeedoClient
+from .router import NodeRouter
+
+__all__ = ["FeedoClient", "NodeRouter"]

feedo/client.py

@@ -0,0 +1,13 @@
+from typing import List, Optional
+from .router import NodeRouter
+from .modules.search import SearchModule
+from .modules.consensus import ConsensusModule
+from .modules.storage import StorageModule
+
+class FeedoClient:
+    def __init__(self, search_seeds: Optional[List[str]] = None, consensus_seeds: Optional[List[str]] = None, storage_seeds: Optional[List[str]] = None):
+        self.router = NodeRouter(search_seeds, consensus_seeds, storage_seeds)
+        
+        self.search = SearchModule(self.router)
+        self.consensus = ConsensusModule(self.router)
+        self.storage = StorageModule(self.router)

feedo/modules/__init__.py

@@ -0,0 +1 @@
+# Init modules

feedo/modules/consensus.py

@@ -0,0 +1,46 @@
+import httpx
+from typing import Dict, Any, Optional
+from ..router import NodeRouter
+
+class ConsensusModule:
+    def __init__(self, router: NodeRouter):
+        self.router = router
+
+    async def _request(self, method: str, path: str, json: Optional[Dict] = None) -> Any:
+        base_url = await self.router.get_consensus_node()
+        url = f"{base_url}{path}"
+        
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.request(method, url, json=json)
+                response.raise_for_status()
+                return response.json()
+            except Exception:
+                print(f"Consensus request failed on {base_url}, finding new node...")
+                self.router.invalidate_consensus_node()
+                base_url = await self.router.get_consensus_node()
+                url = f"{base_url}{path}"
+                response = await client.request(method, url, json=json)
+                response.raise_for_status()
+                return response.json()
+
+    async def resolve_name(self, name: str):
+        return await self._request("GET", f"/resolve/{name}")
+
+    async def resolve_cid(self, cid: str):
+        return await self._request("GET", f"/resolve_cid/{cid}")
+
+    async def get_did_balance(self, did: str):
+        return await self._request("GET", f"/did/{did}/balance")
+
+    async def register_did(self, pubkey_hex: str, signature_hex: str):
+        return await self._request("POST", "/did/register", json={"pubkey_hex": pubkey_hex, "signature_hex": signature_hex})
+
+    async def register_name(self, name: str, did: str, cid: str, signature_hex: str):
+        return await self._request("POST", "/name/register", json={"name": name, "did": did, "cid": cid, "signature_hex": signature_hex})
+
+    async def update_name_cid(self, name: str, new_cid: str, signature_hex: str):
+        return await self._request("POST", "/name/update_cid", json={"name": name, "new_cid": new_cid, "signature_hex": signature_hex})
+
+    async def list_grants(self):
+        return await self._request("GET", "/grants")

feedo/modules/search.py

@@ -0,0 +1,40 @@
+import httpx
+from typing import Dict, Any, Optional
+from ..router import NodeRouter
+
+class SearchModule:
+    def __init__(self, router: NodeRouter):
+        self.router = router
+
+    async def _request(self, method: str, path: str, json: Optional[Dict] = None, params: Optional[Dict] = None) -> Any:
+        base_url = await self.router.get_search_node()
+        url = f"{base_url}{path}"
+        
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.request(method, url, json=json, params=params)
+                response.raise_for_status()
+                return response.json()
+            except Exception as e:
+                print(f"Search request failed on {base_url}, finding new node...")
+                self.router.invalidate_search_node()
+                base_url = await self.router.get_search_node()
+                url = f"{base_url}{path}"
+                response = await client.request(method, url, json=json, params=params)
+                response.raise_for_status()
+                return response.json()
+
+    async def query(self, query_text: str, limit: int = 10):
+        return await self._request("GET", "/query", params={"q": query_text, "limit": limit})
+
+    async def index_document(self, content: str, metadata: Optional[Dict] = None):
+        return await self._request("POST", "/index_document", json={"content": content, "metadata": metadata or {}})
+
+    async def deploy_proxy(self, directory_path: str, domain: str):
+        return await self._request("POST", "/proxy/publish_feedo", json={"source_dir": directory_path, "domain": domain})
+
+    async def unpin(self, cid: str):
+        return await self._request("DELETE", f"/proxy/unpin_feedo/{cid}")
+
+    async def get_stats(self):
+        return await self._request("GET", "/explorer/stats")

feedo/modules/storage.py

@@ -0,0 +1,44 @@
+import httpx
+from typing import Dict, Any, Optional
+from ..router import NodeRouter
+
+class StorageModule:
+    def __init__(self, router: NodeRouter):
+        self.router = router
+
+    async def _request(self, method: str, path: str, json: Optional[Dict] = None, data: Any = None, files: Any = None) -> Any:
+        base_url = await self.router.get_storage_node()
+        url = f"{base_url}{path}"
+        
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.request(method, url, json=json, data=data, files=files)
+                response.raise_for_status()
+                # download endpoint might not return json
+                if response.headers.get("content-type") == "application/json":
+                    return response.json()
+                return response.content
+            except Exception:
+                print(f"Storage request failed on {base_url}, finding new node...")
+                self.router.invalidate_storage_node()
+                base_url = await self.router.get_storage_node()
+                url = f"{base_url}{path}"
+                response = await client.request(method, url, json=json, data=data, files=files)
+                response.raise_for_status()
+                if response.headers.get("content-type") == "application/json":
+                    return response.json()
+                return response.content
+
+    async def upload_file(self, file_path: str, filename: str = "file"):
+        with open(file_path, "rb") as f:
+            files = {"file": (filename, f)}
+            return await self._request("POST", "/upload", files=files)
+
+    async def download_file(self, hash_id: str) -> bytes:
+        return await self._request("GET", f"/download/{hash_id}")
+
+    async def ingest_json(self, payload: Dict):
+        return await self._request("POST", "/api/v1/ingest/post", json=payload)
+
+    async def get_recent_files(self):
+        return await self._request("GET", "/api/files/recent")

feedo/router.py

@@ -0,0 +1,65 @@
+import httpx
+import asyncio
+from typing import List, Optional, Dict
+
+DEFAULT_SEEDS = {
+    "search": ["http://localhost:8000"],
+    "consensus": ["http://localhost:8080"],
+    "storage": ["http://localhost:8081"]
+}
+
+class NodeRouter:
+    def __init__(self, search_seeds: Optional[List[str]] = None, consensus_seeds: Optional[List[str]] = None, storage_seeds: Optional[List[str]] = None):
+        self.search_nodes = search_seeds or DEFAULT_SEEDS["search"]
+        self.consensus_nodes = consensus_seeds or DEFAULT_SEEDS["consensus"]
+        self.storage_nodes = storage_seeds or DEFAULT_SEEDS["storage"]
+
+        self._active_search_node = None
+        self._active_consensus_node = None
+        self._active_storage_node = None
+
+    async def _find_fastest_node(self, nodes: List[str], health_endpoint: str) -> str:
+        async def ping(node: str) -> str:
+            async with httpx.AsyncClient() as client:
+                url = f"{node}{health_endpoint}"
+                response = await client.get(url, timeout=3.0)
+                response.raise_for_status()
+                return node
+
+        tasks = [asyncio.create_task(ping(node)) for node in nodes]
+        
+        while tasks:
+            done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+            for task in done:
+                try:
+                    return task.result()
+                except Exception:
+                    pass
+            tasks = list(pending)
+            
+        print(f"Warning: All seed nodes failed. Falling back to {nodes[0]}")
+        return nodes[0]
+
+    async def get_search_node(self) -> str:
+        if not self._active_search_node:
+            self._active_search_node = await self._find_fastest_node(self.search_nodes, "/explorer/stats")
+        return self._active_search_node
+
+    async def get_consensus_node(self) -> str:
+        if not self._active_consensus_node:
+            self._active_consensus_node = await self._find_fastest_node(self.consensus_nodes, "/grants")
+        return self._active_consensus_node
+
+    async def get_storage_node(self) -> str:
+        if not self._active_storage_node:
+            self._active_storage_node = await self._find_fastest_node(self.storage_nodes, "/api/files/recent")
+        return self._active_storage_node
+
+    def invalidate_search_node(self):
+        self._active_search_node = None
+
+    def invalidate_consensus_node(self):
+        self._active_consensus_node = None
+
+    def invalidate_storage_node(self):
+        self._active_storage_node = None

feedo_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: feedo-sdk
+Version: 0.1.0
+Summary: The official Developer SDK for Feedo Network
+Author: Feedo Network
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.24.0
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

feedo_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+feedo/__init__.py,sha256=5fpQuHjJKiZjZp8WoGYbTXIthth08clKPLtro-Bl840,104
+feedo/client.py,sha256=y1O68cjdJE5ohaV5uieYvgIOgP_HhJHQt20-5uqhYAo,610
+feedo/router.py,sha256=qSrIC24ZobpBUjJSyOgB62TxvjA3jjWFlQPxrI7UTpE,2543
+feedo/modules/__init__.py,sha256=5osEvcjmclW4Wh0r8-gBp5hnY-KfklOonaDWArvLIsA,15
+feedo/modules/consensus.py,sha256=xZGgGaKD5DQnHtRIc2VXBmdYYEPr5wkZfZXmBrCQEZ0,2088
+feedo/modules/search.py,sha256=TpVeiAowtCgahQuul3nZgWYf5k_IJgzt26VnYojc39g,1834
+feedo/modules/storage.py,sha256=lnT11HAQ-eGoYxxNjT0vxH-CUSb695Rm6zZFernbQpk,1995
+feedo_sdk-0.1.0.dist-info/METADATA,sha256=WptPSj6c0gXQ04KtrZ-KxXqRpHf8v9pHy5k2XzktLDA,273
+feedo_sdk-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+feedo_sdk-0.1.0.dist-info/top_level.txt,sha256=DqxeisJ-yTDMZjgoTGrPdcHSCYHMCEX-WSk4JTJXwWU,6
+feedo_sdk-0.1.0.dist-info/RECORD,,

feedo_sdk-0.1.0.dist-info/WHEEL

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

feedo_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+feedo