df

scripts/remote_storage_server.py

@@ -16,7 +16,7 @@ server and uses it as a remote storage backend through the RemoteStorageBackend.
    $ python remote_storage_server.py --storage-path /path/to/storage --port 5000
    $ python remote_storage_server.py --storage-path /path/to/storage --api-key mysecretkey
 5. Server prints connection info automatically (IP, port, API key)
-   
+
 ### On PC:
 1. Install requests: pip install requests
 2. Add to config.conf:
@@ -58,10 +58,7 @@ from SYS.logger import log
 # CONFIGURATION
 # ============================================================================
 
-logging.basicConfig(
-    level=logging.INFO,
-    format='[%(asctime)s] %(levelname)s: %(message)s'
-)
+logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(levelname)s: %(message)s")
 logger = logging.getLogger(__name__)
 
 STORAGE_PATH: Optional[Path] = None
@@ -71,6 +68,7 @@ API_KEY: Optional[str] = None  # API key for authentication (None = no auth requ
 try:
     from flask import Flask, request, jsonify
     from flask_cors import CORS
+
     HAS_FLASK = True
 except ImportError:
     HAS_FLASK = False
@@ -79,9 +77,11 @@ except ImportError:
 # UTILITY FUNCTIONS
 # ============================================================================
 
+
 def get_local_ip() -> Optional[str]:
     """Get the local IP address that would be used for external connections."""
     import socket
+
     try:
         # Create a socket to determine which interface would be used
         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -92,397 +92,427 @@ def get_local_ip() -> Optional[str]:
     except Exception:
         return None
 
+
 # ============================================================================
 # FLASK APP FACTORY
 # ============================================================================
 
+
 def create_app():
     """Create and configure Flask app with all routes."""
     if not HAS_FLASK:
         raise ImportError("Flask not installed. Install with: pip install flask flask-cors")
-    
+
     from flask import Flask, request, jsonify
     from flask_cors import CORS
-    
+
     app = Flask(__name__)
     CORS(app)
-    
+
     # ========================================================================
     # HELPER DECORATORS
     # ========================================================================
-    
+
     def require_auth():
         """Decorator to check API key authentication if configured."""
+
         def decorator(f):
             @wraps(f)
             def decorated_function(*args, **kwargs):
                 if API_KEY:
                     # Get API key from header or query parameter
-                    provided_key = request.headers.get('X-API-Key') or request.args.get('api_key')
+                    provided_key = request.headers.get("X-API-Key") or request.args.get("api_key")
                     if not provided_key or provided_key != API_KEY:
                         return jsonify({"error": "Unauthorized. Invalid or missing API key."}), 401
                 return f(*args, **kwargs)
+
             return decorated_function
+
         return decorator
-    
+
     def require_storage():
         """Decorator to ensure storage path is configured."""
+
         def decorator(f):
             @wraps(f)
             def decorated_function(*args, **kwargs):
                 if not STORAGE_PATH:
                     return jsonify({"error": "Storage path not configured"}), 500
                 return f(*args, **kwargs)
+
             return decorated_function
+
         return decorator
-    
+
     # ========================================================================
     # HEALTH CHECK
     # ========================================================================
-    
-    @app.route('/health', methods=['GET'])
+
+    @app.route("/health", methods=["GET"])
     @require_auth()
     def health():
         """Check server health and storage availability."""
         status = {
             "status": "ok",
             "storage_configured": STORAGE_PATH is not None,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
-        
+
         if STORAGE_PATH:
             status["storage_path"] = str(STORAGE_PATH)
             status["storage_exists"] = STORAGE_PATH.exists()
             try:
                 from API.folder import API_folder_store
+
                 with API_folder_store(STORAGE_PATH) as db:
                     status["database_accessible"] = True
             except Exception as e:
                 status["database_accessible"] = False
                 status["database_error"] = str(e)
-        
+
         return jsonify(status), 200
-    
+
     # ========================================================================
     # FILE OPERATIONS
     # ========================================================================
-    
-    @app.route('/files/search', methods=['GET'])
+
+    @app.route("/files/search", methods=["GET"])
     @require_auth()
     @require_storage()
     def search_files():
         """Search for files by name or tag."""
         from API.folder import LocalLibrarySearchOptimizer
-        
-        query = request.args.get('q', '')
-        limit = request.args.get('limit', 100, type=int)
-        
+
+        query = request.args.get("q", "")
+        limit = request.args.get("limit", 100, type=int)
+
         if not query:
             return jsonify({"error": "Search query required"}), 400
-        
+
         try:
             with LocalLibrarySearchOptimizer(STORAGE_PATH) as db:
                 results = db.search_by_name(query, limit)
                 tag_results = db.search_by_tag(query, limit)
-                all_results = {r['hash']: r for r in (results + tag_results)}
-                
-                return jsonify({
-                    "query": query,
-                    "count": len(all_results),
-                    "files": list(all_results.values())
-                }), 200
+                all_results = {r["hash"]: r for r in (results + tag_results)}
+
+                return (
+                    jsonify(
+                        {
+                            "query": query,
+                            "count": len(all_results),
+                            "files": list(all_results.values()),
+                        }
+                    ),
+                    200,
+                )
         except Exception as e:
             logger.error(f"Search error: {e}", exc_info=True)
             return jsonify({"error": f"Search failed: {str(e)}"}), 500
-    
-    @app.route('/files/<file_hash>', methods=['GET'])
+
+    @app.route("/files/<file_hash>", methods=["GET"])
     @require_auth()
     @require_storage()
     def get_file_metadata(file_hash: str):
         """Get metadata for a specific file by hash."""
         from API.folder import API_folder_store
-        
+
         try:
             with API_folder_store(STORAGE_PATH) as db:
                 file_path = db.search_hash(file_hash)
-                
+
                 if not file_path or not file_path.exists():
                     return jsonify({"error": "File not found"}), 404
-                
+
                 metadata = db.get_metadata(file_path)
                 tags = db.get_tags(file_path)
-                
-                return jsonify({
-                    "hash": file_hash,
-                    "path": str(file_path),
-                    "size": file_path.stat().st_size,
-                    "metadata": metadata,
-                    "tag": tags
-                }), 200
+
+                return (
+                    jsonify(
+                        {
+                            "hash": file_hash,
+                            "path": str(file_path),
+                            "size": file_path.stat().st_size,
+                            "metadata": metadata,
+                            "tag": tags,
+                        }
+                    ),
+                    200,
+                )
         except Exception as e:
             logger.error(f"Get metadata error: {e}", exc_info=True)
             return jsonify({"error": f"Failed to get metadata: {str(e)}"}), 500
-    
-    @app.route('/files/index', methods=['POST'])
+
+    @app.route("/files/index", methods=["POST"])
     @require_auth()
     @require_storage()
     def index_file():
         """Index a new file in the storage."""
         from API.folder import API_folder_store
         from SYS.utils import sha256_file
-        
+
         data = request.get_json() or {}
-        file_path_str = data.get('path')
-        tags = data.get('tag', [])
-        url = data.get('url', [])
-        
+        file_path_str = data.get("path")
+        tags = data.get("tag", [])
+        url = data.get("url", [])
+
         if not file_path_str:
             return jsonify({"error": "File path required"}), 400
-        
+
         try:
             file_path = Path(file_path_str)
-            
+
             if not file_path.exists():
                 return jsonify({"error": "File does not exist"}), 404
-            
+
             with API_folder_store(STORAGE_PATH) as db:
                 db.get_or_create_file_entry(file_path)
-                
+
                 if tags:
                     db.add_tags(file_path, tags)
-                
+
                 if url:
                     db.add_url(file_path, url)
-                
+
                 file_hash = sha256_file(file_path)
-                
-                return jsonify({
-                    "hash": file_hash,
-                    "path": str(file_path),
-                    "tags_added": len(tags),
-                    "url_added": len(url)
-                }), 201
+
+                return (
+                    jsonify(
+                        {
+                            "hash": file_hash,
+                            "path": str(file_path),
+                            "tags_added": len(tags),
+                            "url_added": len(url),
+                        }
+                    ),
+                    201,
+                )
         except Exception as e:
             logger.error(f"Index error: {e}", exc_info=True)
             return jsonify({"error": f"Indexing failed: {str(e)}"}), 500
-    
+
     # ========================================================================
     # TAG OPERATIONS
     # ========================================================================
-    
-    @app.route('/tags/<file_hash>', methods=['GET'])
+
+    @app.route("/tags/<file_hash>", methods=["GET"])
     @require_auth()
     @require_storage()
     def get_tags(file_hash: str):
         """Get tags for a file."""
         from API.folder import API_folder_store
-        
+
         try:
             with API_folder_store(STORAGE_PATH) as db:
                 file_path = db.search_hash(file_hash)
                 if not file_path:
                     return jsonify({"error": "File not found"}), 404
-                
+
                 tags = db.get_tags(file_path)
                 return jsonify({"hash": file_hash, "tag": tags}), 200
         except Exception as e:
             logger.error(f"Get tags error: {e}", exc_info=True)
             return jsonify({"error": f"Failed: {str(e)}"}), 500
-    
-    @app.route('/tags/<file_hash>', methods=['POST'])
+
+    @app.route("/tags/<file_hash>", methods=["POST"])
     @require_auth()
     @require_storage()
     def add_tags(file_hash: str):
         """Add tags to a file."""
         from API.folder import API_folder_store
-        
+
         data = request.get_json() or {}
-        tags = data.get('tag', [])
-        mode = data.get('mode', 'add')
-        
+        tags = data.get("tag", [])
+        mode = data.get("mode", "add")
+
         if not tags:
             return jsonify({"error": "Tag required"}), 400
-        
+
         try:
             with API_folder_store(STORAGE_PATH) as db:
                 file_path = db.search_hash(file_hash)
                 if not file_path:
                     return jsonify({"error": "File not found"}), 404
-                
-                if mode == 'replace':
+
+                if mode == "replace":
                     db.remove_tags(file_path, db.get_tags(file_path))
-                
+
                 db.add_tags(file_path, tags)
                 return jsonify({"hash": file_hash, "tag_added": len(tags), "mode": mode}), 200
         except Exception as e:
             logger.error(f"Add tags error: {e}", exc_info=True)
             return jsonify({"error": f"Failed: {str(e)}"}), 500
-    
-    @app.route('/tags/<file_hash>', methods=['DELETE'])
+
+    @app.route("/tags/<file_hash>", methods=["DELETE"])
     @require_auth()
     @require_storage()
     def remove_tags(file_hash: str):
         """Remove tags from a file."""
         from API.folder import API_folder_store
-        
-        tags_str = request.args.get('tag', '')
-        
+
+        tags_str = request.args.get("tag", "")
+
         try:
             with API_folder_store(STORAGE_PATH) as db:
                 file_path = db.search_hash(file_hash)
                 if not file_path:
                     return jsonify({"error": "File not found"}), 404
-                
+
                 if tags_str:
-                    tags_to_remove = [t.strip() for t in tags_str.split(',')]
+                    tags_to_remove = [t.strip() for t in tags_str.split(",")]
                 else:
                     tags_to_remove = db.get_tags(file_path)
-                
+
                 db.remove_tags(file_path, tags_to_remove)
                 return jsonify({"hash": file_hash, "tags_removed": len(tags_to_remove)}), 200
         except Exception as e:
             logger.error(f"Remove tags error: {e}", exc_info=True)
             return jsonify({"error": f"Failed: {str(e)}"}), 500
-    
+
     # ========================================================================
     # RELATIONSHIP OPERATIONS
     # ========================================================================
-    
-    @app.route('/relationships/<file_hash>', methods=['GET'])
+
+    @app.route("/relationships/<file_hash>", methods=["GET"])
     @require_auth()
     @require_storage()
     def get_relationships(file_hash: str):
         """Get relationships for a file."""
         from API.folder import API_folder_store
-        
+
         try:
             with API_folder_store(STORAGE_PATH) as db:
                 file_path = db.search_hash(file_hash)
                 if not file_path:
                     return jsonify({"error": "File not found"}), 404
-                
+
                 metadata = db.get_metadata(file_path)
-                relationships = metadata.get('relationships', {}) if metadata else {}
+                relationships = metadata.get("relationships", {}) if metadata else {}
                 return jsonify({"hash": file_hash, "relationships": relationships}), 200
         except Exception as e:
             logger.error(f"Get relationships error: {e}", exc_info=True)
             return jsonify({"error": f"Failed: {str(e)}"}), 500
-    
-    @app.route('/relationships', methods=['POST'])
+
+    @app.route("/relationships", methods=["POST"])
     @require_auth()
     @require_storage()
     def set_relationship():
         """Set a relationship between two files."""
         from API.folder import API_folder_store
-        
+
         data = request.get_json() or {}
-        from_hash = data.get('from_hash')
-        to_hash = data.get('to_hash')
-        rel_type = data.get('type', 'alt')
-        
+        from_hash = data.get("from_hash")
+        to_hash = data.get("to_hash")
+        rel_type = data.get("type", "alt")
+
         if not from_hash or not to_hash:
             return jsonify({"error": "from_hash and to_hash required"}), 400
-        
+
         try:
             with API_folder_store(STORAGE_PATH) as db:
                 from_path = db.search_hash(from_hash)
                 to_path = db.search_hash(to_hash)
-                
+
                 if not from_path or not to_path:
                     return jsonify({"error": "File not found"}), 404
-                
+
                 db.set_relationship(from_path, to_path, rel_type)
                 return jsonify({"from_hash": from_hash, "to_hash": to_hash, "type": rel_type}), 200
         except Exception as e:
             logger.error(f"Set relationship error: {e}", exc_info=True)
             return jsonify({"error": f"Failed: {str(e)}"}), 500
-    
+
     # ========================================================================
     # URL OPERATIONS
     # ========================================================================
-    
-    @app.route('/url/<file_hash>', methods=['GET'])
+
+    @app.route("/url/<file_hash>", methods=["GET"])
     @require_auth()
     @require_storage()
     def get_url(file_hash: str):
         """Get known url for a file."""
         from API.folder import API_folder_store
-        
+
         try:
             with API_folder_store(STORAGE_PATH) as db:
                 file_path = db.search_hash(file_hash)
                 if not file_path:
                     return jsonify({"error": "File not found"}), 404
-                
+
                 metadata = db.get_metadata(file_path)
-                url = metadata.get('url', []) if metadata else []
+                url = metadata.get("url", []) if metadata else []
                 return jsonify({"hash": file_hash, "url": url}), 200
         except Exception as e:
             logger.error(f"Get url error: {e}", exc_info=True)
             return jsonify({"error": f"Failed: {str(e)}"}), 500
-    
-    @app.route('/url/<file_hash>', methods=['POST'])
+
+    @app.route("/url/<file_hash>", methods=["POST"])
     @require_auth()
     @require_storage()
     def add_url(file_hash: str):
         """Add url to a file."""
         from API.folder import API_folder_store
-        
+
         data = request.get_json() or {}
-        url = data.get('url', [])
-        
+        url = data.get("url", [])
+
         if not url:
             return jsonify({"error": "url required"}), 400
-        
+
         try:
             with API_folder_store(STORAGE_PATH) as db:
                 file_path = db.search_hash(file_hash)
                 if not file_path:
                     return jsonify({"error": "File not found"}), 404
-                
+
                 db.add_url(file_path, url)
                 return jsonify({"hash": file_hash, "url_added": len(url)}), 200
         except Exception as e:
             logger.error(f"Add url error: {e}", exc_info=True)
             return jsonify({"error": f"Failed: {str(e)}"}), 500
-    
+
     return app
 
+
 # ============================================================================
 # MAIN
 # ============================================================================
 
+
 def main():
     if not HAS_FLASK:
         print("ERROR: Flask and flask-cors required")
         print("Install with: pip install flask flask-cors")
         sys.exit(1)
-    
+
     parser = argparse.ArgumentParser(
-        description='Remote Storage Server for Medios-Macina',
-        epilog='Example: python remote_storage_server.py --storage-path /storage/media --port 5000 --api-key mysecretkey'
+        description="Remote Storage Server for Medios-Macina",
+        epilog="Example: python remote_storage_server.py --storage-path /storage/media --port 5000 --api-key mysecretkey",
     )
-    parser.add_argument('--storage-path', type=str, required=True, help='Path to storage directory')
-    parser.add_argument('--host', type=str, default='0.0.0.0', help='Server host (default: 0.0.0.0)')
-    parser.add_argument('--port', type=int, default=5000, help='Server port (default: 5000)')
-    parser.add_argument('--api-key', type=str, default=None, help='API key for authentication (optional)')
-    parser.add_argument('--debug', action='store_true', help='Enable debug mode')
-    
+    parser.add_argument("--storage-path", type=str, required=True, help="Path to storage directory")
+    parser.add_argument(
+        "--host", type=str, default="0.0.0.0", help="Server host (default: 0.0.0.0)"
+    )
+    parser.add_argument("--port", type=int, default=5000, help="Server port (default: 5000)")
+    parser.add_argument(
+        "--api-key", type=str, default=None, help="API key for authentication (optional)"
+    )
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
+
     args = parser.parse_args()
-    
+
     global STORAGE_PATH, API_KEY
     STORAGE_PATH = Path(args.storage_path).resolve()
     API_KEY = args.api_key
-    
+
     if not STORAGE_PATH.exists():
         print(f"ERROR: Storage path does not exist: {STORAGE_PATH}")
         sys.exit(1)
-    
+
     # Get local IP address
     local_ip = get_local_ip()
     if not local_ip:
         local_ip = "127.0.0.1"
-    
+
     print(f"\n{'='*70}")
     print(f"Remote Storage Server - Medios-Macina")
     print(f"{'='*70}")
@@ -490,27 +520,31 @@ def main():
     print(f"Local IP:        {local_ip}")
     print(f"Server URL:      http://{local_ip}:{args.port}")
     print(f"Health URL:      http://{local_ip}:{args.port}/health")
-    print(f"API Key:         {'Enabled - ' + ('***' + args.api_key[-4:]) if args.api_key else 'Disabled (no auth)'}")
+    print(
+        f"API Key:         {'Enabled - ' + ('***' + args.api_key[-4:]) if args.api_key else 'Disabled (no auth)'}"
+    )
     print(f"Debug Mode:      {args.debug}")
     print("\n📋 Config for config.conf:")
     print("[store=remote]")
-    print("name=\"phone\"")
-    print(f"url=\"http://{local_ip}:{args.port}\"")
+    print('name="phone"')
+    print(f'url="http://{local_ip}:{args.port}"')
     if args.api_key:
-        print(f"api_key=\"{args.api_key}\"")
+        print(f'api_key="{args.api_key}"')
     print("timeout=30")
     print(f"\n{'='*70}\n")
-    
+
     try:
         from API.folder import API_folder_store
+
         with API_folder_store(STORAGE_PATH) as db:
             logger.info("Database initialized successfully")
     except Exception as e:
         logger.error(f"Failed to initialize database: {e}")
         sys.exit(1)
-    
+
     app = create_app()
     app.run(host=args.host, port=args.port, debug=args.debug, use_reloader=False)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()