fraq 0.2.2__tar.gz → 0.2.4__tar.gz

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

@@ -2,6 +2,57 @@
 
 ## [Unreleased]
 
+## [0.2.4] - 2026-03-17
+
+### Docs
+- Update README.md
+- Update docs/README.md
+- Update examples/README.md
+- Update examples/cli-docker/README.md
+- Update examples/fastapi-docker/README.md
+- Update examples/websocket-docker/README.md
+- Update project/README.md
+- Update project/context.md
+
+### Test
+- Update tests/test_text2fraq.py
+
+### Other
+- Update examples/cli-docker/run.py
+- Update examples/cli-docker/run.sh
+- Update examples/fastapi-docker/run.sh
+- Update examples/fullstack-docker/run.py
+- Update examples/fullstack-docker/run.sh
+- Update examples/websocket-docker/run.py
+- Update examples/websocket-docker/run.sh
+- Update fraq/cli.py
+- Update fraq/text2fraq.py
+- Update project/analysis.toon
+- ... and 11 more files
+
+## [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.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fraq
-Version: 0.2.2
+Version: 0.2.4
 Summary: Fractal Query Data Library — model data as infinite, self-similar fractal structures
 Author: Softreck / Prototypowanie.pl
 Author-email: Tom Sapletta <tom@sapletta.com>
@@ -95,6 +95,7 @@ pip install -e ".[dev]"
 fraq explore --dims 3 --depth 5 --format json
 fraq stream  --dims 2 --count 20 --format csv
 fraq schema  --fields "name:str,value:float,flag:bool" --depth 2
+fraq nl "show 10 pdf files created recently" --path .
 
 # Docker
 docker compose run test          # run full test suite
@@ -123,7 +124,7 @@ q = (
 result = FraqExecutor(dims=3).execute(q)
 
 # 3. Source adapters — same query, different sources
-from fraq import FileAdapter, SQLAdapter, SensorAdapter, HybridAdapter
+from fraq import FileAdapter, SQLAdapter, SensorAdapter, HybridAdapter, FileSearchAdapter
 
 # Disk
 adapter = FileAdapter()
@@ -144,6 +145,9 @@ hybrid.add(FileAdapter(), "local_backup.json")
 hybrid.add(SensorAdapter(), "")
 merged = hybrid.load_root()
 
+# Files
+files = FileSearchAdapter(base_path=".").search(extension="py", limit=5, sort_by="mtime")
+
 # 4. Async streaming (FastAPI SSE, Kafka, NATS)
 from fraq.streaming import async_stream
 async for record in async_stream(count=1000, interval=0.1):

{fraq-0.2.2 → fraq-0.2.4}/README.md

@@ -42,6 +42,7 @@ pip install -e ".[dev]"
 fraq explore --dims 3 --depth 5 --format json
 fraq stream  --dims 2 --count 20 --format csv
 fraq schema  --fields "name:str,value:float,flag:bool" --depth 2
+fraq nl "show 10 pdf files created recently" --path .
 
 # Docker
 docker compose run test          # run full test suite
@@ -70,7 +71,7 @@ q = (
 result = FraqExecutor(dims=3).execute(q)
 
 # 3. Source adapters — same query, different sources
-from fraq import FileAdapter, SQLAdapter, SensorAdapter, HybridAdapter
+from fraq import FileAdapter, SQLAdapter, SensorAdapter, HybridAdapter, FileSearchAdapter
 
 # Disk
 adapter = FileAdapter()
@@ -91,6 +92,9 @@ hybrid.add(FileAdapter(), "local_backup.json")
 hybrid.add(SensorAdapter(), "")
 merged = hybrid.load_root()
 
+# Files
+files = FileSearchAdapter(base_path=".").search(extension="py", limit=5, sort_by="mtime")
+
 # 4. Async streaming (FastAPI SSE, Kafka, NATS)
 from fraq.streaming import async_stream
 async for record in async_stream(count=1000, interval=0.1):

fraq-0.2.4/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.4/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.4/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.4/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.4/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.4/examples/fullstack-docker/run.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+Fullstack Docker — Uruchomienie i zarządzanie stackiem
+
+Użycie:
+    python run.py           # Uruchom stack
+    python run.py --test    # Przetestuj
+    python run.py --stop    # Zatrzymaj
+    python run.py --local   # Uruchom lokalnie (bez Docker)
+"""
+
+import argparse
+import subprocess
+import sys
+import time
+
+
+def run_docker():
+    """Uruchom przez Docker Compose"""
+    print("🐳 Uruchamianie stacku...")
+    subprocess.run(["docker-compose", "up", "--build", "-d"], check=True)
+    print("\n✅ Stack działa:")
+    print("  API:       http://localhost:8000")
+    print("  WebSocket: ws://localhost:8001")
+    print("  Frontend:  http://localhost:8501")
+
+
+def stop_docker():
+    """Zatrzymaj stack"""
+    print("🛑 Zatrzymywanie...")
+    subprocess.run(["docker-compose", "down"], check=True)
+    print("✅ Zatrzymano")
+
+
+def test_stack():
+    """Przetestuj stack"""
+    import requests
+    
+    print("🧪 Testowanie...")
+    time.sleep(2)
+    
+    # Test API
+    try:
+        r = requests.get("http://localhost:8000/health", timeout=5)
+        print(f"✅ API: {r.json()}")
+    except Exception as e:
+        print(f"❌ API: {e}")
+    
+    # Test Frontend
+    try:
+        r = requests.get("http://localhost:8501", timeout=5)
+        print(f"✅ Frontend: HTTP {r.status_code}")
+    except Exception as e:
+        print(f"❌ Frontend: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fullstack Docker runner")
+    parser.add_argument("--stop", action="store_true", help="Zatrzymaj")
+    parser.add_argument("--test", action="store_true", help="Przetestuj")
+    parser.add_argument("--logs", action="store_true", help="Pokaż logi")
+    
+    args = parser.parse_args()
+    
+    if args.stop:
+        stop_docker()
+    elif args.test:
+        test_stack()
+    elif args.logs:
+        subprocess.run(["docker-compose", "logs", "-f"])
+    else:
+        run_docker()
+
+
+if __name__ == "__main__":
+    main()

fraq-0.2.4/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"}