embed-client-dev 4.0.78__py3-none-any.whl

embed_client/config_validator_cli.py

@@ -0,0 +1,141 @@
+"""
+CLI entry point for the embed-client configuration validator.
+
+This module provides the command-line interface for validating configuration
+files using `ConfigValidator`.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from embed_client.config_validator import ConfigValidator
+
+
+def main() -> int:
+    """
+    CLI entry point for the configuration validator.
+
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
+    parser = argparse.ArgumentParser(
+        description="Validate embed-client configuration files",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Validate a single config file
+  embed-config-validator --file configs/http.json
+
+  # Validate all configs in a directory
+  embed-config-validator --dir configs
+
+  # Validate and show detailed errors
+  embed-config-validator --file configs/mtls.json --verbose
+        """,
+    )
+    parser.add_argument(
+        "--file",
+        type=str,
+        help="Path to configuration file to validate",
+    )
+    parser.add_argument(
+        "--dir",
+        type=str,
+        help="Directory containing configuration files to validate",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Show detailed error messages",
+    )
+
+    args = parser.parse_args()
+
+    if not args.file and not args.dir:
+        parser.print_help()
+        return 1
+
+    validator = ConfigValidator()
+
+    if args.file:
+        # Validate single file
+        config_path = Path(args.file)
+        if not config_path.is_absolute():
+            config_path = Path.cwd() / config_path
+
+        print(f"🔍 Validating: {config_path}")
+        is_valid, message, errors = validator.validate_config_file(config_path)
+
+        if is_valid:
+            print(f"✅ Configuration is valid: {message}")
+            return 0
+        else:
+            print(f"❌ Configuration validation failed: {message}")
+            if errors and args.verbose:
+                print("\nErrors:")
+                for error in errors:
+                    print(f"  • {error}")
+            elif errors:
+                print(f"  Found {len(errors)} error(s). Use --verbose to see details.")
+            return 1
+
+    elif args.dir:
+        # Validate directory
+        config_dir = Path(args.dir)
+        if not config_dir.is_absolute():
+            config_dir = Path.cwd() / config_dir
+
+        if not config_dir.exists():
+            print(f"❌ Directory not found: {config_dir}")
+            return 1
+
+        print(f"🔍 Validating configurations in: {config_dir}")
+        print("=" * 70)
+
+        results = validator.validate_config_directory(config_dir)
+
+        if not results:
+            print("⚠️  No configuration files found")
+            return 1
+
+        all_valid = True
+        for config_name, (is_valid, message, errors) in results.items():
+            status = "✅" if is_valid else "❌"
+            print(f"{status} {config_name:35s} - {message}")
+
+            if not is_valid:
+                all_valid = False
+                if errors and args.verbose:
+                    for error in errors:
+                        print(f"      ⚠️  {error}")
+
+        print("=" * 70)
+
+        if all_valid:
+            print(f"✅ All {len(results)} configuration files are valid!")
+            return 0
+        else:
+            failed = [
+                (name, errors)
+                for name, (valid, _, errors) in results.items()
+                if not valid
+            ]
+            print(f"❌ {len(failed)} configuration file(s) failed validation:")
+            for name, errors in failed:
+                print(f"   - {name}")
+                if args.verbose and errors:
+                    for error in errors:
+                        print(f"     • {error}")
+            return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

embed_client/constants.py

@@ -0,0 +1,52 @@
+"""
+Shared constants for embed-client package (aligned with embedding service server).
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from pathlib import Path
+from typing import Union
+
+# ---------------------------------------------------------------------------
+# Embed command (schema, default policy) — matches server embed/constants.py
+# ---------------------------------------------------------------------------
+EMBED_COMMAND_SCHEMA_DEFAULT_ERROR_POLICY = "fail_fast"
+
+# ---------------------------------------------------------------------------
+# Environment variable names for embedding service connection
+# ---------------------------------------------------------------------------
+EMBEDDING_SERVICE_BASE_URL_ENV: str = "EMBEDDING_SERVICE_BASE_URL"
+EMBEDDING_SERVICE_PORT_ENV: str = "EMBEDDING_SERVICE_PORT"
+
+# Default connection settings
+DEFAULT_BASE_URL: str = "http://localhost"
+DEFAULT_PORT: int = 8001
+
+# Default poll interval (seconds) when waiting for queued job completion
+DEFAULT_POLL_INTERVAL: float = 0.3
+
+# Max UTF-8 bytes per string item in local json_array preflight (override via
+# EMBED_CLIENT_MAX_JSON_BLOCK_BYTES).
+DEFAULT_MAX_JSON_EMBED_BLOCK_BYTES: int = 1_048_576
+
+
+def get_embed_project_root(module_file: Union[str, Path]) -> Path:
+    """
+    Return project root (parent of parent of the given module file).
+
+    Use from main or CLI: ``get_embed_project_root(__file__)``.
+    """
+    return Path(module_file).resolve().parent.parent
+
+
+__all__ = [
+    "EMBED_COMMAND_SCHEMA_DEFAULT_ERROR_POLICY",
+    "EMBEDDING_SERVICE_BASE_URL_ENV",
+    "EMBEDDING_SERVICE_PORT_ENV",
+    "DEFAULT_BASE_URL",
+    "DEFAULT_PORT",
+    "DEFAULT_POLL_INTERVAL",
+    "DEFAULT_MAX_JSON_EMBED_BLOCK_BYTES",
+    "get_embed_project_root",
+]

embed_client/demo_cli.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+Demo CLI Application for Text Vectorization
+Simple demonstration of the CLI functionality.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the project root to the path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from embed_client.cli import VectorizationCLI  # noqa: E402
+
+
+async def demo_vectorization():
+    """Demonstrate vectorization functionality."""
+    print("🚀 Embed-Client CLI Demo")
+    print("=" * 40)
+
+    # Configuration for demo
+    config = {
+        "server": {"host": "http://localhost", "port": 8001},
+        "auth": {"method": "none"},
+        "ssl": {"enabled": False},
+        "security": {"enabled": False},
+    }
+
+    cli = VectorizationCLI()
+
+    try:
+        # Connect to service
+        print("🔌 Connecting to embedding service...")
+        if not await cli.connect(config):
+            print("❌ Failed to connect to service")
+            return
+
+        # Health check
+        print("\n🏥 Checking service health...")
+        await cli.health_check()
+
+        # Get help
+        print("\n❓ Getting help from service...")
+        await cli.get_help()
+
+        # Get commands
+        print("\n📋 Getting available commands...")
+        await cli.get_commands()
+
+        # Vectorize texts
+        print("\n🔤 Vectorizing texts...")
+        texts = ["Hello world", "This is a test", "Machine learning is awesome"]
+
+        print(f"📝 Vectorizing {len(texts)} texts:")
+        for i, text in enumerate(texts):
+            print(f"  {i+1}. {text}")
+
+        await cli.vectorize_texts(texts, "json")
+
+        print("\n✅ Demo completed successfully!")
+
+    except Exception as e:
+        print(f"❌ Demo failed: {e}")
+    finally:
+        await cli.disconnect()
+
+
+async def main():
+    """Main demo function."""
+    await demo_vectorization()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

embed_client/demo_security_cli.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+Demo Security CLI Application
+Demonstrates all 8 security modes using the security CLI.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add the project root to the path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from embed_client.security_cli import (  # noqa: E402
+    SecurityCLI,
+    create_config_from_security_mode,
+)
+
+
+async def demo_security_mode(mode: str, host: str, port: int, **kwargs):
+    """Demonstrate a specific security mode."""
+    print(f"\n🔐 Demonstrating {mode} mode...")
+    print("=" * 50)
+
+    # Create configuration
+    config = create_config_from_security_mode(mode, host, port, **kwargs)
+
+    cli = SecurityCLI()
+
+    try:
+        # Connect to service
+        print(f"🔌 Connecting using {mode} mode...")
+        if not await cli.connect(config):
+            print(f"❌ Failed to connect using {mode} mode")
+            return False
+
+        # Health check
+        print("🏥 Checking service health...")
+        health_ok = await cli.health_check()
+        if not health_ok:
+            print(f"❌ Health check failed for {mode} mode")
+            return False
+
+        # Get help
+        print("❓ Getting help from service...")
+        await cli.get_help()
+
+        # Get commands
+        print("📋 Getting available commands...")
+        await cli.get_commands()
+
+        # Vectorize texts
+        texts = [
+            f"Hello from {mode} mode",
+            f"Security test for {mode}",
+            f"Vectorization using {mode}",
+        ]
+
+        print(f"🔤 Vectorizing {len(texts)} texts using {mode} mode...")
+        for i, text in enumerate(texts):
+            print(f"  {i+1}. {text}")
+
+        # Test different output formats
+        print("\n📊 Testing JSON format:")
+        await cli.vectorize_texts(texts, "json")
+
+        print("\n📊 Testing CSV format:")
+        await cli.vectorize_texts(texts, "csv")
+
+        print("\n📊 Testing vectors format:")
+        await cli.vectorize_texts(texts, "vectors")
+
+        print(f"✅ {mode} mode demonstration completed successfully!")
+        return True
+
+    except Exception as e:
+        print(f"❌ {mode} mode demonstration failed: {e}")
+        return False
+    finally:
+        await cli.disconnect()
+
+
+async def demo_all_security_modes():
+    """Demonstrate all 8 security modes."""
+    print("🚀 Security CLI Demo - All 8 Security Modes")
+    print("=" * 60)
+
+    # Demo configurations for each mode
+    demos = [
+        {
+            "mode": "http",
+            "host": "localhost",
+            "port": 10001,
+            "description": "Plain HTTP without authentication",
+        },
+        {
+            "mode": "http_token",
+            "host": "localhost",
+            "port": 10002,
+            "api_key": "admin-secret-key",
+            "description": "HTTP with API Key authentication",
+        },
+        {
+            "mode": "http_token_roles",
+            "host": "localhost",
+            "port": 10003,
+            "api_key": "admin-secret-key",
+            "description": "HTTP with API Key and role-based access control",
+        },
+        {
+            "mode": "https",
+            "host": "localhost",
+            "port": 10011,
+            "cert_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/server/embedding-service.crt",
+            "key_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/server/embedding-service.key",
+            "description": "HTTPS with server certificate verification",
+        },
+        {
+            "mode": "https_token",
+            "host": "localhost",
+            "port": 10012,
+            "api_key": "admin-secret-key",
+            "cert_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/server/embedding-service.crt",
+            "key_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/server/embedding-service.key",
+            "description": "HTTPS with server certificates + authentication",
+        },
+        {
+            "mode": "https_token_roles",
+            "host": "localhost",
+            "port": 10013,
+            "api_key": "admin-secret-key",
+            "cert_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/server/embedding-service.crt",
+            "key_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/server/embedding-service.key",
+            "description": "HTTPS with server certificates + authentication + roles",
+        },
+        {
+            "mode": "mtls",
+            "host": "localhost",
+            "port": 10021,
+            "cert_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/client/embedding-service.crt",
+            "key_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/client/embedding-service.key",
+            "ca_cert_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/ca/ca.crt",
+            "description": "Mutual TLS with client and server certificates",
+        },
+        {
+            "mode": "mtls_roles",
+            "host": "localhost",
+            "port": 10022,
+            "cert_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/client/embedding-service.crt",
+            "key_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/client/embedding-service.key",
+            "ca_cert_file": "/home/vasilyvz/projects/tools/embed/mtls_certificates/ca/ca.crt",
+            "description": "mTLS with role-based access control",
+        },
+    ]
+
+    results = {}
+
+    for demo in demos:
+        mode = demo["mode"]
+        description = demo["description"]
+
+        print(f"\n🔐 {mode.upper()} - {description}")
+        print("-" * 50)
+
+        # Extract parameters for the demo
+        demo_params = {
+            k: v
+            for k, v in demo.items()
+            if k not in ["mode", "host", "port", "description"]
+        }
+
+        success = await demo_security_mode(
+            demo["mode"], demo["host"], demo["port"], **demo_params
+        )
+
+        results[mode] = success
+
+    # Print summary
+    print("\n📊 Demo Results Summary:")
+    print("=" * 50)
+    for mode, success in results.items():
+        status = "✅ SUCCESS" if success else "❌ FAILED"
+        print(f"{mode:20} {status}")
+
+    total_demos = len(results)
+    successful_demos = sum(1 for success in results.values() if success)
+    failed_demos = total_demos - successful_demos
+
+    print("\n🎉 Demo completed!")
+    print(f"📊 Results: {successful_demos}/{total_demos} demos successful")
+    if failed_demos > 0:
+        print(f"❌ {failed_demos} demos failed")
+    else:
+        print("✅ All demos successful!")
+
+
+async def main():
+    """Main demo function."""
+    await demo_all_security_modes()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())