feedo-sdk 0.1.0__tar.gz

feedo_sdk-0.1.0/PKG-INFO

@@ -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/feedo/__init__.py

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

feedo_sdk-0.1.0/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_sdk-0.1.0/feedo/modules/__init__.py

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

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

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

@@ -0,0 +1,14 @@
+setup.py
+feedo/__init__.py
+feedo/client.py
+feedo/router.py
+feedo/modules/__init__.py
+feedo/modules/consensus.py
+feedo/modules/search.py
+feedo/modules/storage.py
+feedo_sdk.egg-info/PKG-INFO
+feedo_sdk.egg-info/SOURCES.txt
+feedo_sdk.egg-info/dependency_links.txt
+feedo_sdk.egg-info/requires.txt
+feedo_sdk.egg-info/top_level.txt
+tests/test_router.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+httpx>=0.24.0

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

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

feedo_sdk-0.1.0/setup.cfg

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

feedo_sdk-0.1.0/setup.py

@@ -0,0 +1,13 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="feedo-sdk",
+    version="0.1.0",
+    description="The official Developer SDK for Feedo Network",
+    author="Feedo Network",
+    packages=find_packages(),
+    install_requires=[
+        "httpx>=0.24.0",
+    ],
+    python_requires=">=3.8",
+)

feedo_sdk-0.1.0/tests/test_router.py

@@ -0,0 +1,47 @@
+import pytest
+import respx
+import httpx
+import asyncio
+from feedo.router import NodeRouter
+
+@pytest.mark.asyncio
+async def test_find_fastest_node_all_up():
+    router = NodeRouter(search_seeds=["http://node1", "http://node2"])
+    
+    with respx.mock:
+        # Mock node1 to respond instantly
+        route1 = respx.get("http://node1/explorer/stats").mock(return_value=httpx.Response(200, json={}))
+        
+        # Mock node2 to be slightly delayed (not natively easy in respx without custom side effects, 
+        # so we just let them both return and asyncio.wait handles whichever resolves first - since route1 is first, 
+        # or we can mock one to raise a timeout and the other to succeed)
+        
+        route2 = respx.get("http://node2/explorer/stats").mock(side_effect=httpx.TimeoutException("Timeout"))
+
+        active_node = await router.get_search_node()
+        assert active_node == "http://node1"
+
+@pytest.mark.asyncio
+async def test_fallback_when_one_down():
+    router = NodeRouter(search_seeds=["http://node1", "http://node2"])
+    
+    with respx.mock:
+        # node1 fails
+        respx.get("http://node1/explorer/stats").mock(return_value=httpx.Response(500))
+        # node2 succeeds
+        respx.get("http://node2/explorer/stats").mock(return_value=httpx.Response(200, json={}))
+
+        active_node = await router.get_search_node()
+        assert active_node == "http://node2"
+
+@pytest.mark.asyncio
+async def test_fallback_when_all_down():
+    router = NodeRouter(search_seeds=["http://node1", "http://node2"])
+    
+    with respx.mock:
+        respx.get("http://node1/explorer/stats").mock(side_effect=httpx.ConnectError("Down"))
+        respx.get("http://node2/explorer/stats").mock(side_effect=httpx.ConnectError("Down"))
+
+        active_node = await router.get_search_node()
+        # Should fallback to the first node if all fail
+        assert active_node == "http://node1"