fraq 0.2.2__tar.gz → 0.2.3__tar.gz

{fraq-0.2.2 → fraq-0.2.3}/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [0.2.3] - 2026-03-17
+
+### Docs
+- Update docs/README.md
+- Update examples/cli-docker/README.md
+- Update examples/fastapi-docker/README.md
+- Update examples/fullstack-docker/README.md
+- Update examples/websocket-docker/README.md
+- Update project/context.md
+
+### Other
+- Update Dockerfile.cli
+- Update Dockerfile.websocket
+- Update examples/cli-docker/Dockerfile
+- Update examples/cli-docker/docker-compose.yml
+- Update examples/cli-docker/run.sh
+- Update examples/fastapi-docker/Dockerfile
+- Update examples/fastapi-docker/docker-compose.yml
+- Update examples/fastapi-docker/main.py
+- Update examples/fastapi-docker/run.py
+- Update examples/fastapi-docker/run.sh
+- ... and 21 more files
+
 ## [0.2.2] - 2026-03-17
 
 ### Docs

{fraq-0.2.2 → fraq-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fraq
-Version: 0.2.2
+Version: 0.2.3
 Summary: Fractal Query Data Library — model data as infinite, self-similar fractal structures
 Author: Softreck / Prototypowanie.pl
 Author-email: Tom Sapletta <tom@sapletta.com>

fraq-0.2.3/examples/cli-docker/run.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""
+CLI Docker — Wrapper do uruchamiania fraq CLI w Dockerze
+
+Użycie:
+    python run.py files search --ext pdf --limit 10 /data
+    python run.py nl "pokaż 10 plików"
+    python run.py --local explore --depth 5  # lokalnie, bez Docker
+"""
+
+import argparse
+import subprocess
+import sys
+import os
+
+
+def run_in_docker(args_list):
+    """Uruchom fraq CLI w Docker"""
+    cmd = ["docker-compose", "run", "--rm", "fraq-cli"] + args_list
+    
+    print(f"🐳 Docker: {' '.join(cmd)}")
+    print("")
+    
+    result = subprocess.run(cmd)
+    return result.returncode
+
+
+def run_local(args_list):
+    """Uruchom fraq CLI lokalnie"""
+    cmd = ["fraq"] + args_list
+    
+    print(f"🌀 Local: {' '.join(cmd)}")
+    print("")
+    
+    result = subprocess.run(cmd)
+    return result.returncode
+
+
+def main():
+    # Parsuj argumenty - przekaż wszystko do fraq
+    parser = argparse.ArgumentParser(
+        description="CLI Docker wrapper",
+        add_help=False
+    )
+    parser.add_argument("--local", action="store_true", help="Uruchom lokalnie (bez Docker)")
+    parser.add_argument("--docker", action="store_true", help="Wymuś Docker")
+    
+    # Znajdź --local/--docker przed przekazaniem reszty
+    args, remaining = parser.parse_known_args()
+    
+    # Jeśli nie ma argumentów, pokaż help
+    if not remaining:
+        remaining = ["--help"]
+    
+    # Uruchom
+    if args.local:
+        return run_local(remaining)
+    else:
+        return run_in_docker(remaining)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fraq-0.2.3/examples/fastapi-docker/main.py

@@ -0,0 +1,86 @@
+"""
+FastAPI + fraq Docker example
+Minimal REST API for fractal queries and file search
+"""
+
+from fastapi import FastAPI, Query
+from fastapi.responses import JSONResponse
+import os
+
+from fraq import FileSearchAdapter, FraqNode, FraqExecutor, FraqQuery
+from fraq.generators import HashGenerator
+from fraq.formats import FormatRegistry
+
+app = FastAPI(title="fraq Docker API", version="0.2.2")
+
+# Config from env
+FRAQ_DIMS = int(os.getenv("FRAQ_DIMS", "3"))
+FRAQ_SEED = int(os.getenv("FRAQ_SEED", "0"))
+
+
+@app.get("/")
+def root():
+    return {"service": "fraq-docker", "version": "0.2.2", "dims": FRAQ_DIMS}
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.get("/explore")
+def explore(
+    depth: int = Query(3, ge=1, le=20),
+    dims: int = Query(FRAQ_DIMS, ge=1, le=10),
+    format: str = Query("json"),
+):
+    """Explore fractal structure"""
+    pos = tuple(0.0 for _ in range(dims))
+    root = FraqNode(position=pos, seed=FRAQ_SEED, generator=HashGenerator())
+    node = root.zoom(steps=depth)
+    data = node.to_dict(max_depth=1)
+    return JSONResponse(content=data)
+
+
+@app.get("/files/search")
+def files_search(
+    path: str = Query("/host/home", description="Directory to search"),
+    ext: str | None = Query(None, description="File extension"),
+    limit: int = Query(10, ge=1, le=1000),
+    sort: str = Query("mtime", regex="^(name|mtime|size)$"),
+):
+    """Search files with fractal metadata"""
+    try:
+        adapter = FileSearchAdapter(base_path=path, recursive=True)
+        results = adapter.search(extension=ext, limit=limit, sort_by=sort)
+        return {"path": path, "count": len(results), "files": results}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@app.get("/files/stat/{file_path:path}")
+def files_stat(file_path: str):
+    """Get file statistics with fractal coordinates"""
+    from pathlib import Path
+    from datetime import datetime
+    
+    path = Path(file_path)
+    if not path.exists():
+        return {"error": "File not found"}
+    
+    stat = path.stat()
+    return {
+        "filename": path.name,
+        "path": str(path.absolute()),
+        "size": stat.st_size,
+        "mtime": datetime.fromtimestamp(stat.st_mtime).isoformat(),
+        "fraq": {
+            "seed": hash(str(path)) % (2**32),
+            "value": hash(str(path)) / (2**32),
+        }
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

fraq-0.2.3/examples/fastapi-docker/run.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+FastAPI Docker — Uruchomienie bez Docker (opcjonalnie)
+
+Użycie:
+    python run.py          # Uruchom serwer lokalnie (bez Docker)
+    python run.py --docker # Uruchom przez Docker
+"""
+
+import argparse
+import subprocess
+import sys
+import os
+
+
+def run_local():
+    """Uruchom serwer lokalnie (bez Docker)"""
+    print("🌀 Uruchamianie FastAPI lokalnie...")
+    try:
+        import uvicorn
+        from main import app
+        uvicorn.run(app, host="0.0.0.0", port=8000)
+    except ImportError:
+        print("❌ Brakujące zależności. Zainstaluj:")
+        print("   pip install fraq fastapi uvicorn")
+        sys.exit(1)
+
+
+def run_docker():
+    """Uruchom przez Docker"""
+    print("🐳 Uruchamianie przez Docker...")
+    subprocess.run(["docker-compose", "up", "--build", "-d"], check=True)
+    print("\n✅ Serwer działa na http://localhost:8000")
+    print("\nTestuj:")
+    print("  curl http://localhost:8000/health")
+
+
+def stop_docker():
+    """Zatrzymaj Docker"""
+    print("🛑 Zatrzymywanie Dockera...")
+    subprocess.run(["docker-compose", "down"], check=True)
+    print("✅ Zatrzymano")
+
+
+def test_api():
+    """Przetestuj API"""
+    import requests
+    import json
+    
+    base = "http://localhost:8000"
+    
+    print("🧪 Testowanie API...")
+    
+    # Health
+    try:
+        r = requests.get(f"{base}/health", timeout=5)
+        print(f"✅ Health: {r.json()}")
+    except Exception as e:
+        print(f"❌ Health failed: {e}")
+        return
+    
+    # Files search
+    try:
+        r = requests.get(f"{base}/files/search?ext=py&limit=3", timeout=10)
+        data = r.json()
+        print(f"✅ Files search: {data.get('count', 0)} files found")
+    except Exception as e:
+        print(f"❌ Files search failed: {e}")
+    
+    # Explore
+    try:
+        r = requests.get(f"{base}/explore?depth=2", timeout=10)
+        data = r.json()
+        print(f"✅ Explore: fractal depth={data.get('depth', 'N/A')}")
+    except Exception as e:
+        print(f"❌ Explore failed: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="FastAPI + fraq runner")
+    parser.add_argument("--docker", action="store_true", help="Użyj Docker")
+    parser.add_argument("--stop", action="store_true", help="Zatrzymaj Docker")
+    parser.add_argument("--test", action="store_true", help="Przetestuj API")
+    
+    args = parser.parse_args()
+    
+    if args.stop:
+        stop_docker()
+    elif args.test:
+        test_api()
+    elif args.docker:
+        run_docker()
+    else:
+        run_local()
+
+
+if __name__ == "__main__":
+    main()

fraq-0.2.3/examples/fullstack-docker/api/main.py

@@ -0,0 +1,38 @@
+"""
+Fullstack - API service
+"""
+from fastapi import FastAPI, Query
+from fastapi.responses import JSONResponse
+
+from fraq import FileSearchAdapter, FraqNode
+from fraq.generators import HashGenerator
+
+app = FastAPI(title="fraq Fullstack API")
+
+
+@app.get("/")
+def root():
+    return {"service": "api", "version": "0.2.2"}
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.get("/explore")
+def explore(depth: int = Query(3)):
+    root = FraqNode(position=(0.0, 0.0, 0.0), generator=HashGenerator())
+    node = root.zoom(steps=depth)
+    return JSONResponse(content=node.to_dict(max_depth=1))
+
+
+@app.get("/files/search")
+def files_search(
+    path: str = Query("/data"),
+    ext: str | None = Query(None),
+    limit: int = Query(10),
+):
+    adapter = FileSearchAdapter(base_path=path, recursive=True)
+    results = adapter.search(extension=ext, limit=limit, sort_by="mtime")
+    return {"count": len(results), "files": results}

fraq-0.2.3/examples/fullstack-docker/frontend/app.py

@@ -0,0 +1,60 @@
+"""
+Fullstack - Streamlit Frontend
+"""
+import streamlit as st
+import requests
+import json
+import os
+
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+WS_URL = os.getenv("WS_URL", "ws://localhost:8001")
+
+st.set_page_config(page_title="fraq UI", layout="wide")
+
+st.title("🌀 fraq — Fractal Query Data Library")
+
+# Sidebar
+st.sidebar.header("Konfiguracja")
+path = st.sidebar.text_input("Ścieżka", "/data")
+ext_filter = st.sidebar.text_input("Rozszerzenie", "py")
+limit = st.sidebar.slider("Limit", 1, 100, 10)
+
+# Tabs
+tab1, tab2, tab3 = st.tabs(["🔍 Wyszukiwanie plików", "🌐 API REST", "ℹ️ Info"])
+
+with tab1:
+    st.subheader("Wyszukiwanie plików")
+    if st.button("Szukaj"):
+        try:
+            resp = requests.get(f"{API_URL}/files/search", params={
+                "path": path, "ext": ext_filter or None, "limit": limit
+            })
+            data = resp.json()
+            if data.get("files"):
+                st.write(f"Znaleziono {data['count']} plików:")
+                for f in data["files"]:
+                    st.code(f"{f['filename']} ({f['size']} bytes)")
+            else:
+                st.warning("Brak wyników")
+        except Exception as e:
+            st.error(f"Błąd: {e}")
+
+with tab2:
+    st.subheader("Test API")
+    st.code(f"GET {API_URL}/health", language="bash")
+    try:
+        health = requests.get(f"{API_URL}/health").json()
+        st.json(health)
+    except Exception as e:
+        st.error(f"API niedostępne: {e}")
+
+with tab3:
+    st.subheader("API Endpoints")
+    st.markdown("""
+    - `GET /health` — Health check
+    - `GET /explore?depth=3` — Eksploracja fraktala
+    - `GET /files/search?ext=pdf&limit=10` — Wyszukiwanie plików
+    - `WS /ws/stream` — WebSocket streaming
+    """)
+    st.info(f"API URL: {API_URL}")
+    st.info(f"WebSocket URL: {WS_URL}")

fraq-0.2.3/examples/fullstack-docker/websocket/main.py

@@ -0,0 +1,52 @@
+"""
+Fullstack - WebSocket service
+"""
+import asyncio
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+from fraq import FileSearchAdapter, FraqNode
+from fraq.generators import HashGenerator
+
+app = FastAPI(title="fraq Fullstack WebSocket")
+
+
+@app.websocket("/ws/stream")
+async def ws_stream(websocket: WebSocket):
+    await websocket.accept()
+    try:
+        while True:
+            msg = await websocket.receive_json()
+            if msg.get("action") == "stream":
+                count = msg.get("count", 10)
+                root = FraqNode(position=(0.0, 0.0, 0.0), generator=HashGenerator())
+                cursor = root.cursor()
+                for i in range(count):
+                    cursor.advance()
+                    await websocket.send_json({"index": i, "value": cursor.current.value})
+                    await asyncio.sleep(0.1)
+    except WebSocketDisconnect:
+        pass
+
+
+@app.websocket("/ws/files")
+async def ws_files(websocket: WebSocket):
+    await websocket.accept()
+    try:
+        while True:
+            msg = await websocket.receive_json()
+            if msg.get("action") == "search":
+                path = msg.get("path", "/data")
+                ext = msg.get("ext")
+                limit = msg.get("limit", 10)
+                adapter = FileSearchAdapter(base_path=path, recursive=True)
+                for record in adapter.stream(extension=ext, count=limit):
+                    await websocket.send_json(record)
+                    await asyncio.sleep(0.01)
+                await websocket.send_json({"done": True})
+    except WebSocketDisconnect:
+        pass
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}

fraq-0.2.3/examples/websocket-docker/main.py

@@ -0,0 +1,104 @@
+"""
+WebSocket + fraq Docker example
+Real-time streaming of fractal data and file search
+"""
+
+import asyncio
+import json
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+from fraq import FileSearchAdapter, FraqNode
+from fraq.generators import HashGenerator
+
+app = FastAPI(title="fraq WebSocket Docker", version="0.2.2")
+
+
+@app.websocket("/ws/stream")
+async def ws_stream(websocket: WebSocket):
+    """Stream fractal data"""
+    await websocket.accept()
+    try:
+        while True:
+            msg = await websocket.receive_json()
+            action = msg.get("action")
+            
+            if action == "stream":
+                count = msg.get("count", 10)
+                interval = msg.get("interval", 0.1)
+                
+                # Generate fractal stream
+                root = FraqNode(position=(0.0, 0.0, 0.0), generator=HashGenerator())
+                cursor = root.cursor()
+                
+                for i in range(count):
+                    cursor.advance()
+                    await websocket.send_json({
+                        "index": i,
+                        "value": cursor.current.value,
+                        "position": cursor.current.position,
+                    })
+                    await asyncio.sleep(interval)
+                    
+            elif action == "ping":
+                await websocket.send_json({"pong": True, "timestamp": asyncio.get_event_loop().time()})
+                
+    except WebSocketDisconnect:
+        print("Client disconnected from /ws/stream")
+
+
+@app.websocket("/ws/files")
+async def ws_files(websocket: WebSocket):
+    """Stream file search results"""
+    await websocket.accept()
+    try:
+        while True:
+            msg = await websocket.receive_json()
+            action = msg.get("action")
+            
+            if action == "search":
+                path = msg.get("path", "/data")
+                ext = msg.get("ext")
+                pattern = msg.get("pattern")
+                limit = msg.get("limit", 10)
+                
+                adapter = FileSearchAdapter(base_path=path, recursive=True)
+                
+                # Stream results one by one
+                count = 0
+                for record in adapter.stream(extension=ext, pattern=pattern, count=limit):
+                    await websocket.send_json(record)
+                    count += 1
+                    await asyncio.sleep(0.01)
+                
+                await websocket.send_json({"done": True, "count": count})
+                
+            elif action == "stat":
+                from pathlib import Path
+                from datetime import datetime
+                
+                file_path = msg.get("file")
+                path = Path(file_path)
+                
+                if path.exists():
+                    stat = path.stat()
+                    await websocket.send_json({
+                        "file": str(path),
+                        "size": stat.st_size,
+                        "mtime": datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                        "fraq_seed": hash(str(path)) % (2**32),
+                    })
+                else:
+                    await websocket.send_json({"error": "File not found"})
+                    
+    except WebSocketDisconnect:
+        print("Client disconnected from /ws/files")
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "websocket": True}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001)

{fraq-0.2.2 → fraq-0.2.3}/fraq/__init__.py

@@ -44,7 +44,7 @@ from fraq.text2fraq import (
     text2filesearch,
 )
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 __all__ = [
     "FraqNode", "FraqSchema", "FraqCursor",
     "FormatRegistry",

{fraq-0.2.2 → fraq-0.2.3}/fraq.egg-info/SOURCES.txt

@@ -12,6 +12,13 @@ examples/nlp2cmd_integration.py
 examples/query_examples.py
 examples/text2fraq_examples.py
 examples/text2fraq_files.py
+examples/cli-docker/run.py
+examples/fastapi-docker/main.py
+examples/fastapi-docker/run.py
+examples/fullstack-docker/api/main.py
+examples/fullstack-docker/frontend/app.py
+examples/fullstack-docker/websocket/main.py
+examples/websocket-docker/main.py
 fraq/__init__.py
 fraq/adapters.py
 fraq/cli.py

{fraq-0.2.2 → fraq-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fraq"
-version = "0.2.2"
+version = "0.2.3"
 description = "Fractal Query Data Library — model data as infinite, self-similar fractal structures"
 readme = "README.md"
 license = "Apache-2.0"