authix-python-sdk 1.0.0__py3-none-any.whl

authix/__init__.py

@@ -0,0 +1,23 @@
+"""
+Authix Python SDK
+Official Python SDK for the Authix authentication service
+"""
+
+__version__ = "1.0.0"
+__author__ = "Authix Team"
+__email__ = "support@authix.com"
+
+from .api import AuthixAPI
+from .client import APIClient
+from .handlers import AuthHandler, AppsHandler, LicensesHandler, UsersHandler, SecurityHandler, WebhooksHandler
+
+__all__ = [
+    "AuthixAPI",
+    "APIClient", 
+    "AuthHandler",
+    "AppsHandler",
+    "LicensesHandler", 
+    "UsersHandler",
+    "SecurityHandler",
+    "WebhooksHandler",
+]

authix/api.py

@@ -0,0 +1,81 @@
+"""
+Authix API - Main API interface
+Official Python SDK for the Authix authentication service
+"""
+
+import os
+import asyncio
+from typing import Optional
+
+from .client import APIClient
+from .handlers import AuthHandler, AppsHandler, LicensesHandler, UsersHandler, SecurityHandler, WebhooksHandler
+
+
+class AuthixAPI:
+    """
+    Main Authix API client that provides access to all Authix services.
+    
+    Example:
+        import asyncio
+        from authix import AuthixAPI
+
+        async def main():
+            # Initialize with your API key
+            api = AuthixAPI(api_key="your_api_key_here")
+            
+            # Register a new user
+            result = await api.auth.register(
+                username="testuser",
+                password="SecurePass123!",
+                license_key="AX-XXXX-XXXX-XXXX",
+                hwid="device_hash_here",
+                app_id="your_app_id",
+                app_name="Your App Name"
+            )
+            print("Registration result:", result)
+            
+            # Login user
+            login_result = await api.auth.login(
+                username="testuser",
+                password="SecurePass123!",
+                hwid="device_hash_here",
+                app_id="your_app_id",
+                app_name="Your App Name"
+            )
+            print("Login result:", login_result)
+
+        asyncio.run(main())
+    """
+    
+    def __init__(self, 
+                 api_key: Optional[str] = None,
+                 server_url: Optional[str] = None,
+                 timeout: int = 30):
+        """
+        Initialize Authix API client
+        
+        Args:
+            api_key: Your Authix API key (can be set via AUTHIX_API_KEY env var)
+            server_url: Authix server URL (can be set via AUTHIX_SERVER env var)
+            timeout: Request timeout in seconds
+        """
+        # Get configuration from parameters or environment
+        self.api_key = api_key or os.getenv("AUTHIX_API_KEY")
+        self.server_url = server_url or os.getenv("AUTHIX_SERVER", "https://getauthix.online")
+        
+        if not self.api_key:
+            raise RuntimeError("API key is required. Set it via parameter or AUTHIX_API_KEY environment variable")
+        
+        # Initialize the HTTP client
+        self.client = APIClient(server_url=self.server_url, api_key=self.api_key, timeout=timeout)
+        
+        # Initialize handlers
+        self.auth = AuthHandler(self.client)
+        self.apps = AppsHandler(self.client)
+        self.licenses = LicensesHandler(self.client)
+        self.users = UsersHandler(self.client)
+        self.security = SecurityHandler(self.client)
+        self.webhooks = WebhooksHandler(self.client)
+    
+    def __repr__(self):
+        return f"AuthixAPI(server_url='{self.server_url}', api_key='...{self.api_key[-8:]}')"

authix/cli.py

@@ -0,0 +1,252 @@
+"""
+Authix CLI
+Command-line interface for Authix operations
+"""
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+from typing import Dict, Any
+
+from .api import AuthixAPI
+from . import __version__
+
+
+def load_config() -> Dict[str, str]:
+    """Load configuration from environment variables"""
+    config = {
+        'api_key': os.getenv('AUTHIX_API_KEY'),
+        'server_url': os.getenv('AUTHIX_SERVER', 'https://getauthix.online')
+    }
+    
+    if not config['api_key']:
+        print("Error: AUTHIX_API_KEY must be set")
+        sys.exit(1)
+    
+    return config
+
+
+async def register_command(args):
+    """Register a new user"""
+    config = load_config()
+    api = AuthixAPI(**config)
+    
+    try:
+        result = await api.auth.register(
+            username=args.username,
+            password=args.password,
+            license_key=args.license_key,
+            hwid=args.hwid,
+            app_id=args.app_id,
+            app_name=args.app_name
+        )
+        print(json.dumps(result, indent=2))
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    finally:
+        await api.client.close()
+
+
+async def login_command(args):
+    """Login user"""
+    config = load_config()
+    api = AuthixAPI(**config)
+    
+    try:
+        result = await api.auth.login(
+            username=args.username,
+            password=args.password,
+            hwid=args.hwid,
+            app_id=args.app_id,
+            app_name=args.app_name
+        )
+        print(json.dumps(result, indent=2))
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    finally:
+        await api.client.close()
+
+
+async def apps_command(args):
+    """List applications"""
+    config = load_config()
+    api = AuthixAPI(**config)
+    
+    try:
+        apps = await api.apps.get_apps()
+        print(json.dumps(apps, indent=2))
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    finally:
+        await api.client.close()
+
+
+async def create_app_command(args):
+    """Create new application"""
+    config = load_config()
+    api = AuthixAPI(**config)
+    
+    try:
+        data = {'name': args.name}
+        if args.description:
+            data['description'] = args.description
+        
+        app = await api.apps.create_app(**data)
+        print(json.dumps(app, indent=2))
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    finally:
+        await api.client.close()
+
+
+async def create_license_command(args):
+    """Create license"""
+    config = load_config()
+    api = AuthixAPI(**config)
+    
+    try:
+        license_data = await api.licenses.create_license(
+            app_id=args.app_id,
+            days=args.days,
+            max_hwids=args.max_hwids
+        )
+        print(json.dumps(license_data, indent=2))
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    finally:
+        await api.client.close()
+
+
+async def ban_hwid_command(args):
+    """Ban HWID"""
+    config = load_config()
+    api = AuthixAPI(**config)
+    
+    try:
+        result = await api.security.ban_hwid(args.app_id, args.hwid)
+        print(json.dumps(result, indent=2))
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    finally:
+        await api.client.close()
+
+
+async def create_webhook_command(args):
+    """Create webhook"""
+    config = load_config()
+    api = AuthixAPI(**config)
+    
+    try:
+        webhook = await api.webhooks.create_webhook(
+            app_id=args.app_id,
+            url=args.url,
+            events=args.events,
+            secret=args.secret
+        )
+        print(json.dumps(webhook, indent=2))
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    finally:
+        await api.client.close()
+
+
+async def health_command(args):
+    """Check server health"""
+    config = load_config()
+    api = AuthixAPI(**config)
+    
+    try:
+        # Try to get apps as a health check
+        await api.apps.get_apps()
+        print("✅ Authix server is online and accessible")
+    except Exception as e:
+        print(f"❌ Server health check failed: {e}")
+        sys.exit(1)
+    finally:
+        await api.client.close()
+
+
+def main():
+    """Main CLI entry point"""
+    parser = argparse.ArgumentParser(
+        description='Authix CLI - Command-line interface for Authix',
+        prog='authix-cli'
+    )
+    parser.add_argument('--version', action='version', version=f'Authix CLI {__version__}')
+    
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    
+    # Auth commands
+    register_parser = subparsers.add_parser('register', help='Register a new user')
+    register_parser.add_argument('username', help='Username')
+    register_parser.add_argument('password', help='Password')
+    register_parser.add_argument('license_key', help='License key')
+    register_parser.add_argument('hwid', help='Hardware ID')
+    register_parser.add_argument('app_id', help='Application ID')
+    register_parser.add_argument('app_name', help='Application name')
+    register_parser.set_defaults(func=register_command)
+    
+    login_parser = subparsers.add_parser('login', help='Login user')
+    login_parser.add_argument('username', help='Username')
+    login_parser.add_argument('password', help='Password')
+    login_parser.add_argument('hwid', help='Hardware ID')
+    login_parser.add_argument('app_id', help='Application ID')
+    login_parser.add_argument('app_name', help='Application name')
+    login_parser.set_defaults(func=login_command)
+    
+    # App commands
+    apps_parser = subparsers.add_parser('apps', help='List all applications')
+    apps_parser.set_defaults(func=apps_command)
+    
+    create_app_parser = subparsers.add_parser('create-app', help='Create a new application')
+    create_app_parser.add_argument('name', help='Application name')
+    create_app_parser.add_argument('--description', help='Application description')
+    create_app_parser.set_defaults(func=create_app_command)
+    
+    # License commands
+    license_parser = subparsers.add_parser('create-license', help='Create a new license')
+    license_parser.add_argument('app_id', help='Application ID')
+    license_parser.add_argument('--days', type=int, default=30, help='License validity in days')
+    license_parser.add_argument('--max-hwids', type=int, default=3, help='Maximum allowed hardware IDs')
+    license_parser.set_defaults(func=create_license_command)
+    
+    # Security commands
+    ban_hwid_parser = subparsers.add_parser('ban-hwid', help='Ban hardware ID')
+    ban_hwid_parser.add_argument('app_id', help='Application ID')
+    ban_hwid_parser.add_argument('hwid', help='Hardware ID to ban')
+    ban_hwid_parser.set_defaults(func=ban_hwid_command)
+    
+    # Webhook commands
+    webhook_parser = subparsers.add_parser('create-webhook', help='Create webhook')
+    webhook_parser.add_argument('app_id', help='Application ID')
+    webhook_parser.add_argument('url', help='Webhook URL')
+    webhook_parser.add_argument('--events', nargs='+', required=True, help='Events to subscribe to')
+    webhook_parser.add_argument('--secret', help='Webhook secret')
+    webhook_parser.set_defaults(func=create_webhook_command)
+    
+    # Health check
+    health_parser = subparsers.add_parser('health', help='Check server health')
+    health_parser.set_defaults(func=health_command)
+    
+    # Parse arguments
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+    
+    # Execute command
+    asyncio.run(args.func(args))
+
+
+if __name__ == '__main__':
+    main()

authix/client.py

@@ -0,0 +1,110 @@
+"""
+Authix HTTP Client
+HTTP client for making requests to Authix API
+"""
+
+import json
+import asyncio
+import aiohttp
+from typing import Dict, Any, Optional
+
+
+class APIClient:
+    """
+    HTTP client for Authix API requests
+    
+    This class handles all HTTP communication with the Authix server.
+    """
+    
+    def __init__(self, server_url: str, api_key: str, timeout: int = 30):
+        """
+        Initialize API client
+        
+        Args:
+            server_url: Base URL of Authix server
+            api_key: API key for authentication
+            timeout: Request timeout in seconds
+        """
+        self.server_url = server_url.rstrip('/')
+        self.api_key = api_key
+        self.timeout = aiohttp.ClientTimeout(total=timeout)
+        self._session = None
+    
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """Get or create aiohttp session"""
+        if self._session is None or self._session.closed:
+            headers = {
+                'Authorization': f'Bearer {self.api_key}',
+                'Content-Type': 'application/json',
+                'User-Agent': f'Authix-Python-SDK/1.0.0'
+            }
+            self._session = aiohttp.ClientSession(
+                headers=headers,
+                timeout=self.timeout
+            )
+        return self._session
+    
+    async def request(self, method: str, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Make HTTP request to Authix API
+        
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE)
+            endpoint: API endpoint
+            data: Request data for POST/PUT requests
+            
+        Returns:
+            Response data as dictionary
+            
+        Raises:
+            RuntimeError: If API request fails
+        """
+        url = f"{self.server_url}/api/v1{endpoint}"
+        session = await self._get_session()
+        
+        try:
+            async with session.request(method, url, json=data) as response:
+                response_data = await response.json()
+                
+                if response.status >= 400:
+                    error_msg = response_data.get('error', f'HTTP {response.status}')
+                    raise RuntimeError(error_msg)
+                
+                return response_data
+                
+        except aiohttp.ClientError as e:
+            raise RuntimeError(f"Network error: {str(e)}")
+        except json.JSONDecodeError:
+            raise RuntimeError("Invalid JSON response from server")
+    
+    async def get(self, endpoint: str) -> Dict[str, Any]:
+        """Make GET request"""
+        return await self.request('GET', endpoint)
+    
+    async def post(self, endpoint: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Make POST request"""
+        return await self.request('POST', endpoint, data)
+    
+    async def put(self, endpoint: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Make PUT request"""
+        return await self.request('PUT', endpoint, data)
+    
+    async def delete(self, endpoint: str) -> Dict[str, Any]:
+        """Make DELETE request"""
+        return await self.request('DELETE', endpoint)
+    
+    async def close(self):
+        """Close the HTTP session"""
+        if self._session and not self._session.closed:
+            await self._session.close()
+    
+    def __del__(self):
+        """Cleanup when client is destroyed"""
+        if self._session and not self._session.closed:
+            # Schedule closing for the next event loop iteration
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    loop.create_task(self.close())
+            except RuntimeError:
+                pass

authix/decorators.py

@@ -0,0 +1,109 @@
+"""
+SecureAuth Decorators
+Authentication and authorization decorators for Flask
+"""
+
+from flask import g, request, redirect, url_for, abort, jsonify
+from functools import wraps
+from typing import Callable, Any
+
+
+def require_auth(f: Callable) -> Callable:
+    """Decorator to require authentication"""
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if not hasattr(g, 'current_user') or not g.current_user:
+            if request.path.startswith('/api/'):
+                return jsonify({'success': False, 'error': 'Authentication required'}), 401
+            else:
+                return redirect(url_for('login'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+
+def require_role(*required_roles: str) -> Callable:
+    """Decorator to require specific role(s)"""
+    def decorator(f: Callable) -> Callable:
+        @wraps(f)
+        def decorated_function(*args, **kwargs):
+            if not hasattr(g, 'current_user') or not g.current_user:
+                if request.path.startswith('/api/'):
+                    return jsonify({'success': False, 'error': 'Authentication required'}), 401
+                else:
+                    return redirect(url_for('login'))
+            
+            user_role = g.current_user.get('role')
+            if user_role not in required_roles:
+                if request.path.startswith('/api/'):
+                    return jsonify({'success': False, 'error': 'Insufficient permissions'}), 403
+                else:
+                    abort(403)
+            
+            return f(*args, **kwargs)
+        return decorated_function
+    return decorator
+
+
+def require_verification(f: Callable) -> Callable:
+    """Decorator to require user verification"""
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if not hasattr(g, 'current_user') or not g.current_user:
+            if request.path.startswith('/api/'):
+                return jsonify({'success': False, 'error': 'Authentication required'}), 401
+            else:
+                return redirect(url_for('login'))
+        
+        if not g.current_user.get('is_verified', False):
+            if request.path.startswith('/api/'):
+                return jsonify({'success': False, 'error': 'Account not verified'}), 403
+            else:
+                abort(403)
+        
+        return f(*args, **kwargs)
+    return decorated_function
+
+
+def require_permission(permission: str) -> Callable:
+    """Decorator to require specific permission"""
+    def decorator(f: Callable) -> Callable:
+        @wraps(f)
+        def decorated_function(*args, **kwargs):
+            if not hasattr(g, 'current_user') or not g.current_user:
+                if request.path.startswith('/api/'):
+                    return jsonify({'success': False, 'error': 'Authentication required'}), 401
+                else:
+                    return redirect(url_for('login'))
+            
+            # Check permission (this would need to be implemented in the API)
+            # For now, check if user is admin
+            user_role = g.current_user.get('role')
+            if user_role != 'admin':
+                if request.path.startswith('/api/'):
+                    return jsonify({'success': False, 'error': 'Insufficient permissions'}), 403
+                else:
+                    abort(403)
+            
+            return f(*args, **kwargs)
+        return decorated_function
+    return decorator
+
+
+def optional_auth(f: Callable) -> Callable:
+    """Decorator that makes authentication optional"""
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        # User may or may not be authenticated
+        return f(*args, **kwargs)
+    return decorated_function
+
+
+def rate_limit(limit: int, window: int = 60) -> Callable:
+    """Decorator for rate limiting"""
+    def decorator(f: Callable) -> Callable:
+        @wraps(f)
+        def decorated_function(*args, **kwargs):
+            # This is a placeholder - implement actual rate limiting
+            return f(*args, **kwargs)
+        return decorated_function
+    return decorator

authix/exceptions.py

@@ -0,0 +1,42 @@
+"""
+SecureAuth Exceptions
+Custom exceptions for SecureAuth SDK
+"""
+
+
+class SecureAuthError(Exception):
+    """Base exception for SecureAuth errors"""
+    pass
+
+
+class SecureAuthException(SecureAuthError):
+    """Exception for SecureAuth API errors"""
+    def __init__(self, message: str, status_code: int = None, response_data: dict = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_data = response_data or {}
+
+
+class AuthenticationError(SecureAuthError):
+    """Exception for authentication failures"""
+    pass
+
+
+class AuthorizationError(SecureAuthError):
+    """Exception for authorization failures"""
+    pass
+
+
+class ConfigurationError(SecureAuthError):
+    """Exception for configuration errors"""
+    pass
+
+
+class NetworkError(SecureAuthError):
+    """Exception for network-related errors"""
+    pass
+
+
+class ValidationError(SecureAuthError):
+    """Exception for validation errors"""
+    pass