orbitalsai 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

orbitalsai/__init__.py

@@ -3,7 +3,7 @@ OrbitalsAI Python SDK
 
 A simple and powerful Python SDK for the OrbitalsAI API.
 
-Example:
+Example (Batch Transcription):
     import orbitalsai
     
     # Synchronous usage
@@ -15,12 +15,28 @@ Example:
     async with orbitalsai.AsyncClient(api_key="your_api_key_here") as client:
         transcript = await client.transcribe("audio.mp3")
         print(transcript.text)
+
+Example (Real-time Streaming):
+    from orbitalsai.streaming import AsyncStreamingClient, PrintingEventHandlers
+    import asyncio
+    
+    async def main():
+        async with AsyncStreamingClient(api_key="your_key") as client:
+            await client.connect(PrintingEventHandlers())
+            
+            with open("audio.pcm", "rb") as f:
+                while chunk := f.read(16000):
+                    await client.send_audio(chunk)
+            
+            await client.flush()
+    
+    asyncio.run(main())
 """
 
 from .client import Client
 from .async_client import AsyncClient
 from .models import (
-    TranscriptTask, Transcript, Balance, UsageHistory, DailyUsage, User,
+    TranscriptTask, Transcript, Balance, UsageHistory, DailyUsage, User, Model,
     SUPPORTED_LANGUAGES, SUPPORTED_AUDIO_FORMATS, SUPPORTED_AUDIO_MIMETYPES
 )
 from .exceptions import (
@@ -29,7 +45,10 @@ from .exceptions import (
     TaskNotFoundError, TranscriptionError, TimeoutError, APIError
 )
 
-__version__ = "1.0.0"
+# Streaming module (imported as submodule)
+from . import streaming
+
+__version__ = "2.0.0"
 __author__ = "OrbitalsAI"
 __email__ = "support@orbitalsai.com"
 
@@ -38,6 +57,9 @@ __all__ = [
     "Client",
     "AsyncClient",
     
+    # Streaming Module
+    "streaming",
+    
     # Models
     "TranscriptTask",
     "Transcript", 
@@ -45,6 +67,7 @@ __all__ = [
     "UsageHistory",
     "DailyUsage",
     "User",
+    "Model",
     
     # Constants
     "SUPPORTED_LANGUAGES",

orbitalsai/async_client.py

@@ -11,7 +11,7 @@ from datetime import datetime, date
 
 from .models import (
     TranscriptTask, Transcript, Balance, UsageHistory, DailyUsage, 
-    User, APIKey, UsageRecord, DailyUsageRecord
+    User, APIKey, UsageRecord, DailyUsageRecord, Model
 )
 from .exceptions import (
     OrbitalsAIError, AuthenticationError, InsufficientBalanceError,
@@ -101,11 +101,33 @@ class AsyncClient:
         except aiohttp.ClientError as e:
             raise OrbitalsAIError(f"Request failed: {str(e)}")
     
+    async def get_models(self) -> List[Model]:
+        """
+        Get all available AI models with their pricing information.
+        
+        Returns:
+            List of Model objects with pricing details
+        """
+        response = await self._make_request("GET", "/models")
+        
+        models = []
+        for model_data in response:
+            models.append(Model(
+                id=model_data["id"],
+                model_name=model_data["model_name"],
+                transcription_rate_per_second=model_data["transcription_rate_per_second"],
+                transcription_rate_per_hour=model_data["transcription_rate_per_hour"],
+                is_active=model_data["is_active"]
+            ))
+        
+        return models
+    
     async def transcribe(
         self, 
         file_path: str, 
         language: str = "english", 
         generate_srt: bool = False,
+        model_name: str = "Perigee-1",
         wait: bool = True,
         timeout: int = 300,
         poll_interval: int = 5
@@ -117,6 +139,7 @@ class AsyncClient:
             file_path: Path to the audio file
             language: Language of the audio (default: "english")
             generate_srt: Whether to generate SRT subtitles (default: False)
+            model_name: AI model to use for transcription (default: "Perigee-1")
             wait: Whether to wait for completion (default: True)
             timeout: Maximum time to wait in seconds (default: 300)
             poll_interval: Seconds to wait between status checks (default: 5)
@@ -141,6 +164,7 @@ class AsyncClient:
             data.add_field('file', f, filename=file_path.split('/')[-1], content_type='audio/mpeg')
             data.add_field('language', language)
             data.add_field('generate_srt', str(generate_srt).lower())
+            data.add_field('model_name', model_name)
             
             # Upload file
             response = await self._make_request("POST", "/audio/upload", data=data)

orbitalsai/client.py

@@ -12,7 +12,7 @@ from pathlib import Path
 
 from .models import (
     TranscriptTask, Transcript, Balance, UsageHistory, DailyUsage, 
-    User, APIKey, UsageRecord, DailyUsageRecord
+    User, APIKey, UsageRecord, DailyUsageRecord, Model
 )
 from .exceptions import (
     OrbitalsAIError, AuthenticationError, InsufficientBalanceError,
@@ -89,11 +89,33 @@ class Client:
         except requests.exceptions.RequestException as e:
             raise OrbitalsAIError(f"Request failed: {str(e)}")
     
+    def get_models(self) -> List[Model]:
+        """
+        Get all available AI models with their pricing information.
+        
+        Returns:
+            List of Model objects with pricing details
+        """
+        response = self._make_request("GET", "/models")
+        
+        models = []
+        for model_data in response:
+            models.append(Model(
+                id=model_data["id"],
+                model_name=model_data["model_name"],
+                transcription_rate_per_second=model_data["transcription_rate_per_second"],
+                transcription_rate_per_hour=model_data["transcription_rate_per_hour"],
+                is_active=model_data["is_active"]
+            ))
+        
+        return models
+    
     def transcribe(
         self, 
         file_path: str, 
         language: str = "english", 
         generate_srt: bool = False,
+        model_name: str = "Perigee-1",
         wait: bool = True,
         timeout: int = 300,
         poll_interval: int = 5
@@ -105,6 +127,7 @@ class Client:
             file_path: Path to the audio file
             language: Language of the audio (default: "english")
             generate_srt: Whether to generate SRT subtitles (default: False)
+            model_name: AI model to use for transcription (default: "Perigee-1")
             wait: Whether to wait for completion (default: True)
             timeout: Maximum time to wait in seconds (default: 300)
             poll_interval: Seconds to wait between status checks (default: 5)
@@ -128,7 +151,8 @@ class Client:
             files = {"file": (Path(file_path).name, f, "audio/mpeg")}
             data = {
                 "language": language,
-                "generate_srt": str(generate_srt).lower()
+                "generate_srt": str(generate_srt).lower(),
+                "model_name": model_name
             }
             
             # Upload file
@@ -249,54 +273,6 @@ class Client:
             last_updated=datetime.fromisoformat(response["last_updated"].replace('Z', '+00:00'))
         )
     
-    def get_usage_history(
-        self, 
-        start_date: Optional[datetime] = None, 
-        end_date: Optional[datetime] = None,
-        page: int = 1,
-        page_size: int = 50
-    ) -> UsageHistory:
-        """
-        Get usage history for the current user.
-        
-        Args:
-            start_date: Start date for the history (default: 30 days ago)
-            end_date: End date for the history (default: now)
-            page: Page number (default: 1)
-            page_size: Number of records per page (default: 50)
-            
-        Returns:
-            UsageHistory object with usage records
-        """
-        params = {"page": page, "page_size": page_size}
-        if start_date:
-            params["start_date"] = start_date.isoformat()
-        if end_date:
-            params["end_date"] = end_date.isoformat()
-        
-        response = self._make_request("GET", "/billing/usage-history", params=params)
-        
-        records = []
-        for record_data in response["records"]:
-            records.append(UsageRecord(
-                id=record_data["id"],
-                service_type=record_data["service_type"],
-                usage_amount=record_data["total_audio_usage"],
-                cost=record_data["cost"],
-                timestamp=datetime.fromisoformat(record_data["timestamp"].replace('Z', '+00:00')),
-                api_key_id=record_data.get("api_key_id")
-            ))
-        
-        return UsageHistory(
-            records=records,
-            total_records=response["total_records"],
-            total_pages=response["total_pages"],
-            current_page=response["current_page"],
-            start_date=datetime.fromisoformat(response["start_date"].replace('Z', '+00:00')),
-            end_date=datetime.fromisoformat(response["end_date"].replace('Z', '+00:00')),
-            period_summary=response["period_summary"]
-        )
-    
     def get_daily_usage(
         self, 
         start_date: Optional[date] = None, 

orbitalsai/models.py

@@ -114,6 +114,16 @@ class APIKey:
     last_used: Optional[datetime] = None
 
 
+@dataclass
+class Model:
+    """Represents an AI model with pricing information."""
+    id: int
+    model_name: str
+    transcription_rate_per_second: float
+    transcription_rate_per_hour: float
+    is_active: bool
+
+
 # Supported languages and file formats
 SUPPORTED_LANGUAGES = [
     "english", "hausa", "igbo", "yoruba", "swahili", "pidgin", "kinyarwanda"

orbitalsai/streaming/__init__.py

@@ -0,0 +1,117 @@
+"""
+OrbitalsAI Streaming Module
+
+Real-time streaming transcription via WebSocket.
+
+Example (Async - Recommended):
+    import asyncio
+    from orbitalsai.streaming import AsyncStreamingClient, PrintingEventHandlers
+    
+    async def main():
+        async with AsyncStreamingClient(api_key="your_key") as client:
+            await client.connect(PrintingEventHandlers())
+            
+            # Stream audio file
+            with open("audio.pcm", "rb") as f:
+                while chunk := f.read(16000):
+                    await client.send_audio(chunk)
+            
+            await client.flush()
+    
+    asyncio.run(main())
+
+Example (Sync):
+    import time
+    from orbitalsai.streaming import StreamingClient, StreamingEventHandlers
+    
+    class MyHandlers(StreamingEventHandlers):
+        def on_transcript_final(self, transcript, metadata):
+            print(f"Final: {transcript}")
+            print(f"Cost: ${metadata['cost']:.4f}")
+    
+    with StreamingClient(api_key="your_key") as client:
+        client.connect(MyHandlers())
+        
+        with open("audio.pcm", "rb") as f:
+            while chunk := f.read(16000):
+                client.send_audio(chunk)
+                time.sleep(0.5)  # Real-time pacing
+        
+        client.flush()
+"""
+
+from .config import (
+    StreamingConfig,
+    STREAMING_SUPPORTED_LANGUAGES,
+    DEFAULT_SAMPLE_RATE,
+    DEFAULT_CHUNK_SIZE,
+)
+from .events import (
+    StreamingEventHandlers,
+    PrintingEventHandlers,
+    CallbackEventHandlers,
+)
+from .exceptions import (
+    StreamingError,
+    ConnectionError,
+    AuthenticationError,
+    AudioFormatError,
+    InsufficientCreditsError,
+    ReconnectionFailedError,
+    ServiceUnavailableError,
+    ServerBusyError,
+    SessionClosedError,
+    ProtocolError,
+)
+from .async_client import AsyncStreamingClient
+from .client import StreamingClient, StreamingTranscriptAccumulator
+from .audio import (
+    AudioBuffer,
+    AudioConverter,
+    AudioFormat,
+    PCM16_MONO,
+    AudioSource,
+    FileAudioSource,
+    RawPCMFileSource,
+    MicrophoneSource,
+)
+
+__all__ = [
+    # Clients
+    "AsyncStreamingClient",
+    "StreamingClient",
+    
+    # Configuration
+    "StreamingConfig",
+    "STREAMING_SUPPORTED_LANGUAGES",
+    "DEFAULT_SAMPLE_RATE",
+    "DEFAULT_CHUNK_SIZE",
+    
+    # Event Handlers
+    "StreamingEventHandlers",
+    "PrintingEventHandlers",
+    "CallbackEventHandlers",
+    "StreamingTranscriptAccumulator",
+    
+    # Exceptions
+    "StreamingError",
+    "ConnectionError",
+    "AuthenticationError",
+    "AudioFormatError",
+    "InsufficientCreditsError",
+    "ReconnectionFailedError",
+    "ServiceUnavailableError",
+    "ServerBusyError",
+    "SessionClosedError",
+    "ProtocolError",
+    
+    # Audio Utilities
+    "AudioBuffer",
+    "AudioConverter",
+    "AudioFormat",
+    "PCM16_MONO",
+    "AudioSource",
+    "FileAudioSource",
+    "RawPCMFileSource",
+    "MicrophoneSource",
+]