titangpt 0.1.5__tar.gz

titangpt-0.1.5/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: titangpt
+Version: 0.1.5
+Summary: Official Python client for TitanGPT API
+Home-page: https://github.com/TitanGPT/titangpt
+Author: TitanGPT
+Author-email: info@titangpt.ru
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: aiohttp>=3.8.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# TitanGPT.ru Python Client
+
+Official Python client for TitanGPT.ru API - OpenAI compatible interface.

titangpt-0.1.5/README.md

@@ -0,0 +1,3 @@
+# TitanGPT.ru Python Client
+
+Official Python client for TitanGPT.ru API - OpenAI compatible interface.

titangpt-0.1.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

titangpt-0.1.5/setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+from pathlib import Path
+
+long_description = Path("README.md").read_text(encoding="utf-8")
+
+setup(
+    name="titangpt",
+    version="0.1.5",
+    author="TitanGPT",
+    author_email="info@titangpt.ru",
+    description="Official Python client for TitanGPT API",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/TitanGPT/titangpt",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",  
+    ],
+    python_requires=">=3.7",
+    install_requires=[
+        "requests>=2.28.0",
+        "aiohttp>=3.8.0",
+    ],
+    include_package_data=True,
+)

titangpt-0.1.5/tests/test_async_client.py

@@ -0,0 +1,373 @@
+"""
+Asynchronous client tests for TitanGPT.
+
+This module contains comprehensive tests for the asynchronous client functionality,
+including connection handling, request/response processing, error handling, and
+concurrent operations.
+"""
+
+import asyncio
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+from typing import Any, Dict, List
+
+# Import async client and related components
+# Adjust imports based on your actual project structure
+try:
+    from titangpt.async_client import AsyncClient
+    from titangpt.exceptions import (
+        TitanGPTException,
+        ConnectionError as TitanConnectionError,
+        TimeoutError as TitanTimeoutError,
+        AuthenticationError,
+    )
+except ImportError:
+    # Fallback for testing structure
+    AsyncClient = None
+
+
+@pytest.mark.asyncio
+class TestAsyncClientInitialization:
+    """Tests for AsyncClient initialization and configuration."""
+
+    @pytest.mark.asyncio
+    async def test_client_initialization(self):
+        """Test basic client initialization."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        client = AsyncClient(api_key="test_key")
+        assert client is not None
+        await client.close()
+
+    @pytest.mark.asyncio
+    async def test_client_with_custom_config(self):
+        """Test client initialization with custom configuration."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        config = {
+            "timeout": 30,
+            "max_retries": 3,
+            "base_url": "https://api.example.com",
+        }
+        client = AsyncClient(api_key="test_key", **config)
+        assert client is not None
+        await client.close()
+
+    @pytest.mark.asyncio
+    async def test_client_missing_api_key(self):
+        """Test client initialization without API key."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        with pytest.raises((ValueError, TypeError)):
+            AsyncClient()
+
+
+@pytest.mark.asyncio
+class TestAsyncClientRequests:
+    """Tests for async client request handling."""
+
+    @pytest.fixture
+    async def client(self):
+        """Provide an async client instance."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        client = AsyncClient(api_key="test_key")
+        yield client
+        await client.close()
+
+    @pytest.mark.asyncio
+    async def test_simple_request(self, client):
+        """Test making a simple asynchronous request."""
+        with patch.object(client, '_send_request', new_callable=AsyncMock) as mock_send:
+            mock_send.return_value = {"status": "success", "data": "test_response"}
+            
+            # Assuming a method like query() exists
+            if hasattr(client, 'query'):
+                result = await client.query("test prompt")
+                assert result is not None
+                mock_send.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_request_with_parameters(self, client):
+        """Test request with multiple parameters."""
+        with patch.object(client, '_send_request', new_callable=AsyncMock) as mock_send:
+            mock_send.return_value = {"status": "success", "data": "response"}
+            
+            params = {
+                "temperature": 0.7,
+                "max_tokens": 100,
+                "top_p": 0.9,
+            }
+            
+            if hasattr(client, 'query'):
+                result = await client.query("prompt", **params)
+                assert result is not None
+
+    @pytest.mark.asyncio
+    async def test_concurrent_requests(self, client):
+        """Test handling multiple concurrent requests."""
+        with patch.object(client, '_send_request', new_callable=AsyncMock) as mock_send:
+            mock_send.return_value = {"status": "success", "data": "response"}
+            
+            if hasattr(client, 'query'):
+                tasks = [
+                    client.query(f"prompt {i}") 
+                    for i in range(5)
+                ]
+                results = await asyncio.gather(*tasks)
+                assert len(results) == 5
+                assert mock_send.call_count == 5
+
+
+@pytest.mark.asyncio
+class TestAsyncClientErrorHandling:
+    """Tests for error handling in async client."""
+
+    @pytest.fixture
+    async def client(self):
+        """Provide an async client instance."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        client = AsyncClient(api_key="test_key")
+        yield client
+        await client.close()
+
+    @pytest.mark.asyncio
+    async def test_connection_error_handling(self, client):
+        """Test handling of connection errors."""
+        with patch.object(client, '_send_request', new_callable=AsyncMock) as mock_send:
+            mock_send.side_effect = TitanConnectionError("Connection failed")
+            
+            if hasattr(client, 'query'):
+                with pytest.raises((TitanConnectionError, Exception)):
+                    await client.query("test prompt")
+
+    @pytest.mark.asyncio
+    async def test_timeout_handling(self, client):
+        """Test handling of timeout errors."""
+        with patch.object(client, '_send_request', new_callable=AsyncMock) as mock_send:
+            mock_send.side_effect = TitanTimeoutError("Request timeout")
+            
+            if hasattr(client, 'query'):
+                with pytest.raises((TitanTimeoutError, Exception, asyncio.TimeoutError)):
+                    await client.query("test prompt")
+
+    @pytest.mark.asyncio
+    async def test_authentication_error(self, client):
+        """Test handling of authentication errors."""
+        with patch.object(client, '_send_request', new_callable=AsyncMock) as mock_send:
+            mock_send.side_effect = AuthenticationError("Invalid API key")
+            
+            if hasattr(client, 'query'):
+                with pytest.raises((AuthenticationError, Exception)):
+                    await client.query("test prompt")
+
+    @pytest.mark.asyncio
+    async def test_rate_limit_error(self, client):
+        """Test handling of rate limit errors."""
+        with patch.object(client, '_send_request', new_callable=AsyncMock) as mock_send:
+            mock_send.side_effect = TitanGPTException("Rate limit exceeded")
+            
+            if hasattr(client, 'query'):
+                with pytest.raises((TitanGPTException, Exception)):
+                    await client.query("test prompt")
+
+    @pytest.mark.asyncio
+    async def test_retry_on_failure(self, client):
+        """Test retry mechanism on transient failures."""
+        with patch.object(client, '_send_request', new_callable=AsyncMock) as mock_send:
+            # First call fails, second succeeds
+            mock_send.side_effect = [
+                TitanTimeoutError("Timeout"),
+                {"status": "success", "data": "response"}
+            ]
+            
+            if hasattr(client, 'query') and hasattr(client, '_retry'):
+                # This assumes the client has retry logic
+                try:
+                    result = await client.query("test prompt")
+                    assert result is not None
+                except Exception:
+                    pass  # Expected if retry not implemented
+
+
+@pytest.mark.asyncio
+class TestAsyncClientContextManager:
+    """Tests for async context manager functionality."""
+
+    @pytest.mark.asyncio
+    async def test_context_manager_usage(self):
+        """Test using client as async context manager."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        async with AsyncClient(api_key="test_key") as client:
+            assert client is not None
+
+    @pytest.mark.asyncio
+    async def test_context_manager_cleanup(self):
+        """Test that cleanup happens when exiting context."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        with patch('titangpt.async_client.AsyncClient.close', new_callable=AsyncMock) as mock_close:
+            try:
+                async with AsyncClient(api_key="test_key") as client:
+                    assert client is not None
+            except Exception:
+                pass  # May fail if __aenter__/__aexit__ not implemented
+            
+            # close() should be called on exit
+
+
+@pytest.mark.asyncio
+class TestAsyncClientStreaming:
+    """Tests for streaming responses in async client."""
+
+    @pytest.fixture
+    async def client(self):
+        """Provide an async client instance."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        client = AsyncClient(api_key="test_key")
+        yield client
+        await client.close()
+
+    @pytest.mark.asyncio
+    async def test_stream_response(self, client):
+        """Test streaming response handling."""
+        if not hasattr(client, 'stream'):
+            pytest.skip("Streaming not implemented")
+        
+        async def mock_stream():
+            for chunk in ["Hello", " ", "World"]:
+                yield chunk
+
+        with patch.object(client, 'stream', new_callable=AsyncMock) as mock_stream_method:
+            mock_stream_method.return_value = mock_stream()
+            
+            chunks = []
+            async for chunk in await mock_stream_method("test prompt"):
+                chunks.append(chunk)
+            
+            assert len(chunks) > 0
+
+    @pytest.mark.asyncio
+    async def test_stream_with_error(self, client):
+        """Test error handling in streaming."""
+        if not hasattr(client, 'stream'):
+            pytest.skip("Streaming not implemented")
+        
+        async def mock_stream_with_error():
+            yield "chunk1"
+            raise TitanGPTException("Stream error")
+
+        with patch.object(client, 'stream', new_callable=AsyncMock) as mock_stream_method:
+            mock_stream_method.return_value = mock_stream_with_error()
+            
+            with pytest.raises(TitanGPTException):
+                async for chunk in await mock_stream_method("test prompt"):
+                    pass
+
+
+@pytest.mark.asyncio
+class TestAsyncClientResourceManagement:
+    """Tests for resource management in async client."""
+
+    @pytest.mark.asyncio
+    async def test_connection_pool_management(self):
+        """Test that connection pools are properly managed."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        client = AsyncClient(api_key="test_key")
+        
+        # Verify client has necessary session management
+        assert hasattr(client, 'close') or hasattr(client, '__aexit__')
+        
+        await client.close()
+
+    @pytest.mark.asyncio
+    async def test_multiple_client_instances(self):
+        """Test creating multiple independent client instances."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        clients = [AsyncClient(api_key=f"key_{i}") for i in range(3)]
+        
+        assert len(clients) == 3
+        
+        for client in clients:
+            await client.close()
+
+    @pytest.mark.asyncio
+    async def test_client_reusability(self):
+        """Test that a single client can handle multiple requests."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        client = AsyncClient(api_key="test_key")
+        
+        with patch.object(client, '_send_request', new_callable=AsyncMock) as mock_send:
+            mock_send.return_value = {"status": "success"}
+            
+            if hasattr(client, 'query'):
+                for i in range(5):
+                    try:
+                        await client.query(f"prompt {i}")
+                    except Exception:
+                        pass
+        
+        await client.close()
+
+
+@pytest.mark.asyncio
+class TestAsyncClientConfiguration:
+    """Tests for client configuration and customization."""
+
+    @pytest.mark.asyncio
+    async def test_custom_timeout(self):
+        """Test setting custom timeout."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        client = AsyncClient(api_key="test_key", timeout=60)
+        await client.close()
+
+    @pytest.mark.asyncio
+    async def test_custom_headers(self):
+        """Test setting custom headers."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        headers = {"X-Custom-Header": "value"}
+        client = AsyncClient(api_key="test_key", headers=headers)
+        await client.close()
+
+    @pytest.mark.asyncio
+    async def test_proxy_configuration(self):
+        """Test proxy configuration."""
+        if AsyncClient is None:
+            pytest.skip("AsyncClient not available")
+        
+        client = AsyncClient(api_key="test_key", proxy="http://proxy.example.com:8080")
+        await client.close()
+
+
+# Async fixture for pytest-asyncio
+@pytest.fixture
+def event_loop():
+    """Create an event loop for async tests."""
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])