embed-client 3.1.0.1__py3-none-any.whl → 3.1.0.3__py3-none-any.whl

embed_client/__init__.py

@@ -1 +1,21 @@
- 
+"""
+embed-client: Async client for Embedding Service API with comprehensive authentication, SSL/TLS, and mTLS support
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from .async_client import EmbeddingServiceAsyncClient
+from .config import ClientConfig
+from .auth import AuthManager
+from .ssl_manager import ClientSSLManager
+from .client_factory import ClientFactory
+
+__version__ = "3.1.0.2"
+__all__ = [
+    "EmbeddingServiceAsyncClient",
+    "ClientConfig", 
+    "AuthManager",
+    "ClientSSLManager",
+    "ClientFactory"
+]

embed_client/__main__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+"""
+Main entry point for embed-client CLI.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import sys
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(asyncio.run(main()))

embed_client/cli.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+CLI Application for Text Vectorization
+Command-line interface for embedding text using embed-client.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+from embed_client.async_client import EmbeddingServiceAsyncClient
+from embed_client.client_factory import ClientFactory
+
+
+class VectorizationCLI:
+    """CLI application for text vectorization."""
+    
+    def __init__(self):
+        self.client = None
+        
+    async def connect(self, config: Dict[str, Any]):
+        """Connect to embedding service."""
+        try:
+            self.client = EmbeddingServiceAsyncClient(config_dict=config)
+            await self.client.__aenter__()
+            return True
+        except Exception as e:
+            print(f"❌ Failed to connect: {e}")
+            return False
+    
+    async def disconnect(self):
+        """Disconnect from embedding service."""
+        if self.client:
+            await self.client.close()
+    
+    async def health_check(self) -> bool:
+        """Check service health."""
+        try:
+            result = await self.client.health()
+            print(f"✅ Service health: {result.get('status', 'unknown')}")
+            return True
+        except Exception as e:
+            print(f"❌ Health check failed: {e}")
+            return False
+    
+    async def vectorize_texts(self, texts: List[str], output_format: str = "json") -> Optional[List[List[float]]]:
+        """Vectorize texts."""
+        try:
+            params = {"texts": texts}
+            result = await self.client.cmd("embed", params=params)
+            
+            # Extract embeddings from result
+            embeddings = self._extract_embeddings(result)
+            
+            if output_format == "json":
+                print(json.dumps(embeddings, indent=2))
+            elif output_format == "csv":
+                self._print_csv(embeddings)
+            elif output_format == "vectors":
+                self._print_vectors(embeddings)
+            
+            return embeddings
+            
+        except Exception as e:
+            print(f"❌ Vectorization failed: {e}")
+            return None
+    
+    def _extract_embeddings(self, result: Dict[str, Any]) -> List[List[float]]:
+        """Extract embeddings from API response."""
+        # Handle different response formats
+        if "embeddings" in result:
+            return result["embeddings"]
+        
+        if "result" in result:
+            res = result["result"]
+            
+            if isinstance(res, list):
+                return res
+            
+            if isinstance(res, dict):
+                if "embeddings" in res:
+                    return res["embeddings"]
+                
+                if "data" in res and isinstance(res["data"], list):
+                    embeddings = []
+                    for item in res["data"]:
+                        if isinstance(item, dict) and "embedding" in item:
+                            embeddings.append(item["embedding"])
+                        else:
+                            embeddings.append(item)
+                    return embeddings
+        
+        raise ValueError(f"Cannot extract embeddings from response: {result}")
+    
+    def _print_csv(self, embeddings: List[List[float]]):
+        """Print embeddings in CSV format."""
+        for i, embedding in enumerate(embeddings):
+            print(f"text_{i}," + ",".join(map(str, embedding)))
+    
+    def _print_vectors(self, embeddings: List[List[float]]):
+        """Print embeddings as vectors."""
+        for i, embedding in enumerate(embeddings):
+            print(f"Text {i}: [{', '.join(map(str, embedding))}]")
+    
+    async def get_help(self, command: Optional[str] = None):
+        """Get help information."""
+        try:
+            if command:
+                result = await self.client.cmd("help", params={"command": command})
+            else:
+                result = await self.client.cmd("help")
+            
+            print(json.dumps(result, indent=2))
+            
+        except Exception as e:
+            print(f"❌ Help request failed: {e}")
+    
+    async def get_commands(self):
+        """Get available commands."""
+        try:
+            result = await self.client.get_commands()
+            print(json.dumps(result, indent=2))
+            
+        except Exception as e:
+            print(f"❌ Commands request failed: {e}")
+
+
+def create_config_from_args(args) -> Dict[str, Any]:
+    """Create configuration from command line arguments."""
+    config = {
+        "server": {
+            "host": args.host,
+            "port": args.port
+        },
+        "auth": {"method": "none"},
+        "ssl": {"enabled": False},
+        "security": {"enabled": False}
+    }
+    
+    # Add authentication if specified
+    if args.api_key:
+        config["auth"]["method"] = "api_key"
+        config["security"] = {
+            "enabled": True,
+            "tokens": {"user": args.api_key}
+        }
+    
+    # Add SSL if specified
+    if args.ssl:
+        config["ssl"]["enabled"] = True
+        if args.cert_file:
+            config["ssl"]["cert_file"] = args.cert_file
+        if args.key_file:
+            config["ssl"]["key_file"] = args.key_file
+        if args.ca_cert_file:
+            config["ssl"]["ca_cert_file"] = args.ca_cert_file
+    
+    return config
+
+
+async def main():
+    """Main CLI function."""
+    parser = argparse.ArgumentParser(
+        description="CLI Application for Text Vectorization",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Vectorize text from command line
+  python -m embed_client.cli vectorize "hello world" "test text"
+  
+  # Vectorize text from file
+  python -m embed_client.cli vectorize --file texts.txt
+  
+  # Use HTTPS with authentication
+  python -m embed_client.cli vectorize "hello world" --host https://localhost --port 8443 --api-key your-key
+  
+  # Use mTLS
+  python -m embed_client.cli vectorize "hello world" --ssl --cert-file client.crt --key-file client.key
+  
+  # Get help from service
+  python -m embed_client.cli help
+  
+  # Check service health
+  python -m embed_client.cli health
+        """
+    )
+    
+    # Connection options
+    parser.add_argument("--host", default="http://localhost", help="Server host (default: http://localhost)")
+    parser.add_argument("--port", type=int, default=8001, help="Server port (default: 8001)")
+    parser.add_argument("--api-key", help="API key for authentication")
+    parser.add_argument("--ssl", action="store_true", help="Enable SSL/TLS")
+    parser.add_argument("--cert-file", help="Client certificate file")
+    parser.add_argument("--key-file", help="Client private key file")
+    parser.add_argument("--ca-cert-file", help="CA certificate file")
+    
+    # Output options
+    parser.add_argument("--format", choices=["json", "csv", "vectors"], default="json", help="Output format")
+    parser.add_argument("--output", "-o", help="Output file (default: stdout)")
+    
+    # Commands
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    
+    # Vectorize command
+    vectorize_parser = subparsers.add_parser("vectorize", help="Vectorize text")
+    vectorize_parser.add_argument("texts", nargs="*", help="Texts to vectorize")
+    vectorize_parser.add_argument("--file", "-f", help="File containing texts (one per line)")
+    
+    # Health command
+    health_parser = subparsers.add_parser("health", help="Check service health")
+    
+    # Help command
+    help_parser = subparsers.add_parser("help", help="Get help from service")
+    help_parser.add_argument("--command", help="Specific command to get help for")
+    
+    # Commands command
+    commands_parser = subparsers.add_parser("commands", help="Get available commands")
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        return 1
+    
+    # Create configuration
+    config = create_config_from_args(args)
+    
+    # Create CLI instance
+    cli = VectorizationCLI()
+    
+    try:
+        # Connect to service
+        if not await cli.connect(config):
+            return 1
+        
+        # Execute command
+        if args.command == "vectorize":
+            texts = args.texts
+            if args.file:
+                with open(args.file, 'r') as f:
+                    texts.extend(line.strip() for line in f if line.strip())
+            
+            if not texts:
+                print("❌ No texts provided")
+                return 1
+            
+            await cli.vectorize_texts(texts, args.format)
+            
+        elif args.command == "health":
+            await cli.health_check()
+            
+        elif args.command == "help":
+            await cli.get_help(args.command)
+            
+        elif args.command == "commands":
+            await cli.get_commands()
+        
+        return 0
+        
+    except KeyboardInterrupt:
+        print("\n🛑 Interrupted by user")
+        return 1
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return 1
+    finally:
+        await cli.disconnect()
+
+
+if __name__ == "__main__":
+    sys.exit(asyncio.run(main()))

embed_client/demo_cli.py

@@ -0,0 +1,82 @@
+#!/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
+
+
+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,202 @@
+#!/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 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(f"🏥 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(f"❓ Getting help from service...")
+        await cli.get_help()
+        
+        # Get commands
+        print(f"📋 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(f"\n📊 Testing JSON format:")
+        await cli.vectorize_texts(texts, "json")
+        
+        print(f"\n📊 Testing CSV format:")
+        await cli.vectorize_texts(texts, "csv")
+        
+        print(f"\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/embed-client/mtls_certificates/server/embedding-service.crt",
+            "key_file": "/home/vasilyvz/projects/embed-client/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/embed-client/mtls_certificates/server/embedding-service.crt",
+            "key_file": "/home/vasilyvz/projects/embed-client/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/embed-client/mtls_certificates/server/embedding-service.crt",
+            "key_file": "/home/vasilyvz/projects/embed-client/mtls_certificates/server/embedding-service.key",
+            "description": "HTTPS with server certificates + authentication + roles"
+        },
+        {
+            "mode": "mtls",
+            "host": "localhost",
+            "port": 10021,
+            "cert_file": "/home/vasilyvz/projects/embed-client/mtls_certificates/client/embedding-service.crt",
+            "key_file": "/home/vasilyvz/projects/embed-client/mtls_certificates/client/embedding-service.key",
+            "ca_cert_file": "/home/vasilyvz/projects/embed-client/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/embed-client/mtls_certificates/client/embedding-service.crt",
+            "key_file": "/home/vasilyvz/projects/embed-client/mtls_certificates/client/embedding-service.key",
+            "ca_cert_file": "/home/vasilyvz/projects/embed-client/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(f"\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())

embed_client/security_cli.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""
+Security CLI Application for Text Vectorization
+Command-line interface supporting all 8 security modes.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+from embed_client.async_client import EmbeddingServiceAsyncClient
+from embed_client.client_factory import ClientFactory
+
+
+class SecurityCLI:
+    """CLI application supporting all 8 security modes."""
+    
+    def __init__(self):
+        self.client = None
+        
+    async def connect(self, config: Dict[str, Any]):
+        """Connect to embedding service."""
+        try:
+            # Создаем клиент, но не входим в контекст пока
+            self.client = EmbeddingServiceAsyncClient(config_dict=config)
+            return True
+        except Exception as e:
+            print(f"❌ Failed to connect: {e}")
+            return False
+    
+    async def disconnect(self):
+        """Disconnect from embedding service."""
+        if self.client:
+            await self.client.close()
+    
+    async def health_check(self) -> bool:
+        """Check service health."""
+        try:
+            async with self.client as client:
+                result = await client.health()
+                print(f"✅ Service health: {result.get('status', 'unknown')}")
+                return True
+        except Exception as e:
+            print(f"❌ Health check failed: {e}")
+            return False
+    
+    async def vectorize_texts(self, texts: List[str], output_format: str = "json") -> Optional[List[List[float]]]:
+        """Vectorize texts."""
+        try:
+            params = {"texts": texts}
+            result = await self.client.cmd("embed", params=params)
+            
+            # Extract embeddings from result
+            embeddings = self._extract_embeddings(result)
+            
+            if output_format == "json":
+                print(json.dumps(embeddings, indent=2))
+            elif output_format == "csv":
+                self._print_csv(embeddings)
+            elif output_format == "vectors":
+                self._print_vectors(embeddings)
+            
+            return embeddings
+            
+        except Exception as e:
+            print(f"❌ Vectorization failed: {e}")
+            return None
+    
+    def _extract_embeddings(self, result: Dict[str, Any]) -> List[List[float]]:
+        """Extract embeddings from API response."""
+        # Handle different response formats
+        if "embeddings" in result:
+            return result["embeddings"]
+        
+        if "result" in result:
+            res = result["result"]
+            
+            if isinstance(res, list):
+                return res
+            
+            if isinstance(res, dict):
+                if "embeddings" in res:
+                    return res["embeddings"]
+                
+                if "data" in res and isinstance(res["data"], list):
+                    embeddings = []
+                    for item in res["data"]:
+                        if isinstance(item, dict) and "embedding" in item:
+                            embeddings.append(item["embedding"])
+                        else:
+                            embeddings.append(item)
+                    return embeddings
+        
+        raise ValueError(f"Cannot extract embeddings from response: {result}")
+    
+    def _print_csv(self, embeddings: List[List[float]]):
+        """Print embeddings in CSV format."""
+        for i, embedding in enumerate(embeddings):
+            print(f"text_{i}," + ",".join(map(str, embedding)))
+    
+    def _print_vectors(self, embeddings: List[List[float]]):
+        """Print embeddings as vectors."""
+        for i, embedding in enumerate(embeddings):
+            print(f"Text {i}: [{', '.join(map(str, embedding))}]")
+    
+    async def get_help(self, command: Optional[str] = None):
+        """Get help information."""
+        try:
+            if command:
+                result = await self.client.cmd("help", params={"command": command})
+            else:
+                result = await self.client.cmd("help")
+            
+            print(json.dumps(result, indent=2))
+            
+        except Exception as e:
+            print(f"❌ Help request failed: {e}")
+    
+    async def get_commands(self):
+        """Get available commands."""
+        try:
+            result = await self.client.get_commands()
+            print(json.dumps(result, indent=2))
+            
+        except Exception as e:
+            print(f"❌ Commands request failed: {e}")
+
+
+def create_config_from_security_mode(security_mode: str, host: str, port: int, **kwargs) -> Dict[str, Any]:
+    """Create configuration based on security mode."""
+    
+    # Base configuration
+    config = {
+        "server": {"host": host, "port": port},
+        "auth": {"method": "none"},
+        "ssl": {"enabled": False},
+        "security": {"enabled": False}
+    }
+    
+    if security_mode == "http":
+        # HTTP - plain HTTP without authentication
+        config["server"]["host"] = f"http://{host.split('://')[-1]}"
+        
+    elif security_mode == "http_token":
+        # HTTP + Token - HTTP with API Key authentication
+        config["server"]["host"] = f"http://{host.split('://')[-1]}"
+        config["auth"]["method"] = "api_key"
+        config["security"] = {
+            "enabled": True,
+            "tokens": {"user": kwargs.get("api_key", "admin-secret-key")}
+        }
+        
+    elif security_mode == "http_token_roles":
+        # HTTP + Token + Roles - HTTP with API Key and role-based access control
+        config["server"]["host"] = f"http://{host.split('://')[-1]}"
+        config["auth"]["method"] = "api_key"
+        config["security"] = {
+            "enabled": True,
+            "tokens": {"user": kwargs.get("api_key", "admin-secret-key")},
+            "roles": {
+                "admin": ["read", "write", "delete", "admin"],
+                "user": ["read", "write"],
+                "readonly": ["read"]
+            }
+        }
+        
+    elif security_mode == "https":
+        # HTTPS - HTTPS with server certificate verification
+        config["server"]["host"] = f"https://{host.split('://')[-1]}"
+        config["ssl"] = {
+            "enabled": True,
+            "verify": False,  # Отключаем проверку для самоподписанных сертификатов
+            "cert_file": kwargs.get("cert_file"),
+            "key_file": kwargs.get("key_file"),
+            "ca_cert_file": kwargs.get("ca_cert_file")
+        }
+        
+    elif security_mode == "https_token":
+        # HTTPS + Token - HTTPS with server certificates + authentication
+        config["server"]["host"] = f"https://{host.split('://')[-1]}"
+        config["auth"]["method"] = "api_key"
+        config["ssl"] = {
+            "enabled": True,
+            "cert_file": kwargs.get("cert_file"),
+            "key_file": kwargs.get("key_file")
+        }
+        config["security"] = {
+            "enabled": True,
+            "tokens": {"user": kwargs.get("api_key", "admin-secret-key")}
+        }
+        
+    elif security_mode == "https_token_roles":
+        # HTTPS + Token + Roles - HTTPS with server certificates + authentication + roles
+        config["server"]["host"] = f"https://{host.split('://')[-1]}"
+        config["auth"]["method"] = "api_key"
+        config["ssl"] = {
+            "enabled": True,
+            "cert_file": kwargs.get("cert_file"),
+            "key_file": kwargs.get("key_file")
+        }
+        config["security"] = {
+            "enabled": True,
+            "tokens": {"user": kwargs.get("api_key", "admin-secret-key")},
+            "roles": {
+                "admin": ["read", "write", "delete", "admin"],
+                "user": ["read", "write"],
+                "readonly": ["read"]
+            }
+        }
+        
+    elif security_mode == "mtls":
+        # mTLS - mutual TLS with client and server certificates
+        config["server"]["host"] = f"https://{host.split('://')[-1]}"
+        config["auth"]["method"] = "certificate"
+        config["ssl"] = {
+            "enabled": True,
+            "cert_file": kwargs.get("cert_file"),
+            "key_file": kwargs.get("key_file"),
+            "ca_cert_file": kwargs.get("ca_cert_file")
+        }
+        
+    elif security_mode == "mtls_roles":
+        # mTLS + Roles - mTLS with role-based access control
+        config["server"]["host"] = f"https://{host.split('://')[-1]}"
+        config["auth"]["method"] = "certificate"
+        config["ssl"] = {
+            "enabled": True,
+            "cert_file": kwargs.get("cert_file"),
+            "key_file": kwargs.get("key_file"),
+            "ca_cert_file": kwargs.get("ca_cert_file")
+        }
+        config["security"] = {
+            "enabled": True,
+            "roles": {
+                "admin": ["read", "write", "delete", "admin"],
+                "user": ["read", "write"],
+                "readonly": ["read"]
+            }
+        }
+    
+    return config
+
+
+async def main():
+    """Main CLI function."""
+    parser = argparse.ArgumentParser(
+        description="Security CLI Application for Text Vectorization",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Security Modes:
+  http              - Plain HTTP without authentication
+  http_token        - HTTP with API Key authentication
+  http_token_roles  - HTTP with API Key and role-based access control
+  https             - HTTPS with server certificate verification
+  https_token       - HTTPS with server certificates + authentication
+  https_token_roles - HTTPS with server certificates + authentication + roles
+  mtls              - Mutual TLS with client and server certificates
+  mtls_roles        - mTLS with role-based access control
+
+Examples:
+  # HTTP without authentication
+  python -m embed_client.security_cli vectorize --mode http "hello world"
+  
+  # HTTP with token authentication
+  python -m embed_client.security_cli vectorize --mode http_token --api-key your-key "hello world"
+  
+  # HTTPS with server certificates
+  python -m embed_client.security_cli vectorize --mode https --cert-file server.crt --key-file server.key "hello world"
+  
+  # mTLS with client certificates
+  python -m embed_client.security_cli vectorize --mode mtls --cert-file client.crt --key-file client.key --ca-cert-file ca.crt "hello world"
+  
+  # mTLS with roles
+  python -m embed_client.security_cli vectorize --mode mtls_roles --cert-file client.crt --key-file client.key --ca-cert-file ca.crt "hello world"
+        """
+    )
+    
+    # Security mode selection
+    parser.add_argument(
+        "--mode", 
+        choices=[
+            "http", "http_token", "http_token_roles",
+            "https", "https_token", "https_token_roles", 
+            "mtls", "mtls_roles"
+        ],
+        required=True,
+        help="Security mode to use"
+    )
+    
+    # Connection options
+    parser.add_argument("--host", default="localhost", help="Server host (default: localhost)")
+    parser.add_argument("--port", type=int, default=8001, help="Server port (default: 8001)")
+    
+    # Authentication options
+    parser.add_argument("--api-key", help="API key for authentication (required for token modes)")
+    
+    # SSL/TLS options
+    parser.add_argument("--cert-file", help="Certificate file (required for HTTPS/mTLS modes)")
+    parser.add_argument("--key-file", help="Private key file (required for HTTPS/mTLS modes)")
+    parser.add_argument("--ca-cert-file", help="CA certificate file (required for mTLS modes)")
+    
+    # Output options
+    parser.add_argument("--format", choices=["json", "csv", "vectors"], default="json", help="Output format")
+    parser.add_argument("--output", "-o", help="Output file (default: stdout)")
+    
+    # Commands
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    
+    # Vectorize command
+    vectorize_parser = subparsers.add_parser("vectorize", help="Vectorize text")
+    vectorize_parser.add_argument("texts", nargs="*", help="Texts to vectorize")
+    vectorize_parser.add_argument("--file", "-f", help="File containing texts (one per line)")
+    
+    # Health command
+    health_parser = subparsers.add_parser("health", help="Check service health")
+    
+    # Help command
+    help_parser = subparsers.add_parser("help", help="Get help from service")
+    help_parser.add_argument("--command", help="Specific command to get help for")
+    
+    # Commands command
+    commands_parser = subparsers.add_parser("commands", help="Get available commands")
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        return 1
+    
+    # Validate required arguments based on security mode
+    if "token" in args.mode and not args.api_key:
+        print("❌ API key required for token-based authentication modes")
+        return 1
+    
+    if "https" in args.mode or "mtls" in args.mode:
+        if not args.cert_file or not args.key_file:
+            print("❌ Certificate and key files required for HTTPS/mTLS modes")
+            return 1
+    
+    if "mtls" in args.mode and not args.ca_cert_file:
+        print("❌ CA certificate file required for mTLS modes")
+        return 1
+    
+    # Create configuration
+    config = create_config_from_security_mode(
+        args.mode,
+        args.host,
+        args.port,
+        api_key=args.api_key,
+        cert_file=args.cert_file,
+        key_file=args.key_file,
+        ca_cert_file=args.ca_cert_file
+    )
+    
+    # Create CLI instance
+    cli = SecurityCLI()
+    
+    try:
+        # Connect to service
+        print(f"🔌 Connecting using {args.mode} mode...")
+        if not await cli.connect(config):
+            return 1
+        
+        # Execute command
+        if args.command == "vectorize":
+            texts = args.texts
+            if args.file:
+                with open(args.file, 'r') as f:
+                    texts.extend(line.strip() for line in f if line.strip())
+            
+            if not texts:
+                print("❌ No texts provided")
+                return 1
+            
+            print(f"🔤 Vectorizing {len(texts)} texts using {args.mode} mode...")
+            await cli.vectorize_texts(texts, args.format)
+            
+        elif args.command == "health":
+            print(f"🏥 Checking service health using {args.mode} mode...")
+            await cli.health_check()
+            
+        elif args.command == "help":
+            print(f"❓ Getting help using {args.mode} mode...")
+            await cli.get_help(args.command)
+            
+        elif args.command == "commands":
+            print(f"📋 Getting commands using {args.mode} mode...")
+            await cli.get_commands()
+        
+        return 0
+        
+    except KeyboardInterrupt:
+        print("\n🛑 Interrupted by user")
+        return 1
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return 1
+    finally:
+        await cli.disconnect()
+
+
+if __name__ == "__main__":
+    sys.exit(asyncio.run(main()))

{embed_client-3.1.0.1.dist-info → embed_client-3.1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: embed-client
-Version: 3.1.0.1
+Version: 3.1.0.3
 Summary: Async client for Embedding Service API with comprehensive authentication, SSL/TLS, and mTLS support
 Author-email: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
 License-Expression: MIT
@@ -29,6 +29,7 @@ Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: PyJWT>=2.0.0
 Requires-Dist: cryptography>=3.0.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: mcp-security-framework>=1.2.3
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-asyncio; extra == "test"

{embed_client-3.1.0.1.dist-info → embed_client-3.1.0.3.dist-info}/RECORD

@@ -1,17 +1,22 @@
-embed_client/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
+embed_client/__init__.py,sha256=12iI-f075Gmv8IyQ9L7-SH8eNND4qpF6Fjqz1-P4d1Y,535
+embed_client/__main__.py,sha256=oURC6FcGQxbMzz07-RxZUILIPjjIhMMWyPWEPnfbU4s,235
 embed_client/async_client.py,sha256=Zf08g-i_2ylDj4tt9E1TO9swi-zcozFDr4mJdlfiGSI,40222
 embed_client/auth.py,sha256=MMk5XqFIY5htf3Bx0JA_8mJaAiLslpLUIVUaiO84XBw,18310
 embed_client/auth_examples.py,sha256=QX_QWaaeyBAqvSs9uOP1ZVdAe72gJ91e8AP1e7R-yzQ,7361
+embed_client/cli.py,sha256=xu8sM1UhnduJFt8Oe-LLxuaCWo6x-ZsYBmZNzP1Fax0,9266
 embed_client/client_factory.py,sha256=-W2nvzMuyyQNu3_nNmALKHT9uL0Z9nMYTxyQ4bgVOFQ,14279
 embed_client/client_factory_examples.py,sha256=7A2JWkyGEJeOB7p84ijklh8rTyeRUeg2lCIPTfAtahc,11823
 embed_client/config.py,sha256=CzVmduJjuN82uiaxDyMyXJLS2tNOOlDBGwcO76SWjXg,19922
 embed_client/config_examples.py,sha256=9aEF8X4h9nbfSV_CORZLrlWM5KEwuwqW6AcQDPguQ7g,6175
+embed_client/demo_cli.py,sha256=20MEcpyNLCYIoqSvR1jTROuop3LAQzMdlT-EYGqq2RQ,2052
+embed_client/demo_security_cli.py,sha256=gwuKzI5R4SzkkMPtkmwIYupHFDec6-yGcgGPYcPBCGI,6932
 embed_client/example_async_usage.py,sha256=dndf79MIqZaHvWzbtKrZVwU7G4a5yNL1JPMnMBEdLBg,29803
 embed_client/example_async_usage_ru.py,sha256=3HeP5YoyGd49dRlxNC-2TAh_GbwSW4jJmoLXMpMIfFs,29899
+embed_client/security_cli.py,sha256=YV_IgT7btVSTMOHPrCnKNCU5NAINfQ5z_eWJSMX0A5I,15114
 embed_client/ssl_examples.py,sha256=22lTGhK2bqGJ44uUCpc7v2egY4AP3_ar8RMaTb4KBwU,9346
 embed_client/ssl_manager.py,sha256=Ts6-hKxUUNHdW3yldnoykaDblxWtGbIwKdnzPw__30U,17247
-embed_client-3.1.0.1.dist-info/licenses/LICENSE,sha256=6KdtUcTwmTRbJrAmYjVn7e6S-V42ubeDJ-AiVEzZ510,1075
-embed_client-3.1.0.1.dist-info/METADATA,sha256=mvhUNvCDzryNQh68sFeSyGx9ZG9gyypnkPWrNYqxth4,8633
-embed_client-3.1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-embed_client-3.1.0.1.dist-info/top_level.txt,sha256=uG00A4d9o9DFrhiN7goObpeig72Pniby0E7UpDRgyXY,13
-embed_client-3.1.0.1.dist-info/RECORD,,
+embed_client-3.1.0.3.dist-info/licenses/LICENSE,sha256=6KdtUcTwmTRbJrAmYjVn7e6S-V42ubeDJ-AiVEzZ510,1075
+embed_client-3.1.0.3.dist-info/METADATA,sha256=15-eyREORjE5HLHyoTcQcs3JYHHEZkIk8veXaXGxE14,8678
+embed_client-3.1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+embed_client-3.1.0.3.dist-info/top_level.txt,sha256=uG00A4d9o9DFrhiN7goObpeig72Pniby0E7UpDRgyXY,13
+embed_client-3.1.0.3.dist-info/RECORD,,