synapsai-python 0.1.0__py3-none-any.whl

synapsai/types/__init__.py

@@ -0,0 +1,144 @@
+# Copyright 2026 SynapsAI Technologies Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Type definitions for SynapsAI client library
+"""
+
+from .completion import *
+from .images import *
+from .videos import *
+from .embeddings import *
+from .audio import *
+from .classifications import *
+from .question_answering import *
+from .common import *
+from .models import *
+from .feature_extraction import *
+from .fill_mask import *
+from .rerank import *
+
+__all__ = [
+    # Models types
+    "Model",
+    "Models",
+    
+    # Chat types
+    "ChatCompletionRequest",
+    "ChatCompletionResponse",
+    "ChatCompletionChunk",
+    "ChatMessage",
+    "ChatRole",
+    "ReasoningEffort",
+    "ChatCompletionChoice",
+    "CompletionChoice",
+    "Delta",
+    "FunctionCall",
+    "Tool",
+    "ToolCall",
+    "ChatCompletionMessageToolCall",
+    "ChatCompletionMessageToolCallFunction",
+    "DeltaFunctionCall",
+    "DeltaToolCall",
+    "ChoiceDeltaToolCall",
+    "ChatCompletionNamedToolChoice",
+    "ToolChoice",
+    "ChoiceDelta",
+    
+    # Image types
+    "ImageGenerateRequest",
+    "ImageGenerateResponse",
+    "ImageEditRequest",
+    "ImageEditResponse",
+    "ImageAnalysisRequest",
+    "ImageAnalysisResponse",
+    "Image",
+    "ImageSource",
+    
+    # Video types
+    "Video",
+    "VideoCreateError",
+    "VideoCreateRequest",
+    "VideoDeleteResponse",
+    "VideoInputReference",
+    "VideoStatus",
+    
+    # Embedding types
+    "EmbeddingRequest",
+    "EmbeddingResponse",
+    "Embedding",
+    "SimilarityResponse",
+    "SimilarityResult",
+    
+    # Audio types
+    "AudioSpeechRequest",
+    "AudioSpeechResponse",
+    "AudioTranscriptionRequest",
+    "AudioTranscriptionResponse",
+    "AudioTranslationRequest",
+    "AudioTranslationResponse",
+    "AudioTranscriptionChunk",
+    "AudioTranslationChunk",
+    "AudioFormat",
+    "Transcription",
+    "Usage",
+
+    # Classification types
+    "AudioClassificationRequest",
+    "AudioClassificationResponse",
+    "ImageClassificationRequest",
+    "ImageClassificationResponse",
+    "TextClassificationRequest",
+    "TextClassificationResponse",
+    "TokenClassificationRequest",
+    "TokenClassificationResponse",
+    "VideoClassificationRequest",
+    "VideoClassificationResponse",
+    "ZeroShotAudioClassificationRequest",
+    "ZeroShotAudioClassificationResponse",
+    "ZeroShotClassificationRequest",
+    "ZeroShotClassificationResponse",
+    "ZeroShotImageClassificationRequest",
+    "ZeroShotImageClassificationResponse",
+    "ZeroShotObjectDetectionRequest",
+    "ZeroShotObjectDetectionResponse",
+    
+    # Question Answering types
+    "DocumentQuestionAnsweringRequest",
+    "DocumentQuestionAnsweringResponse",
+    "QuestionAnsweringRequest",
+    "QuestionAnsweringResponse",
+    "TableQuestionAnsweringRequest",
+    "TableQuestionAnsweringResponse",
+    "VisualQuestionAnsweringRequest",
+    "VisualQuestionAnsweringResponse",
+
+    # Feature extraction types
+    "FeatureExtractionRequest",
+    "FeatureExtractionResponse",
+
+    # Fill mask types
+    "FillMaskRequest",
+    "FillMaskResponse",
+
+    # Text ranking types
+    "RerankRequest",
+    "RerankResult",
+    "RerankResponse",
+    
+    # Common types
+    "APIResponse",
+    "Error",
+    "ErrorResponse",
+] 

synapsai/types/audio.py

@@ -0,0 +1,177 @@
+# Copyright 2026 SynapsAI Technologies Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Audio speech and transcription type definitions
+"""
+
+from typing import Optional, List, Literal, Union
+from pydantic import BaseModel, Field
+from enum import Enum
+
+from .common import APIResponse, Usage
+
+
+class AudioFormat(str, Enum):
+    """Audio format options"""
+    MP3 = "mp3"
+    OPUS = "opus"
+    AAC = "aac"
+    FLAC = "flac"
+    WAV = "wav"
+    PCM = "pcm"
+
+
+class AudioSpeechRequest(BaseModel):
+    """Audio speech request"""
+    model: str
+    input: str = Field(max_length=4096)
+    response_format: Optional[AudioFormat] = AudioFormat.MP3
+    speed: Optional[float] = Field(default=1.0, ge=0.25, le=4.0)
+    stream: Optional[bool] = False
+
+
+class AudioSpeechResponse(BaseModel):
+    """Audio speech response"""
+    content: bytes = Field(description="Audio content as bytes")
+    content_type: str = Field(description="MIME type of the audio")
+
+
+class TimestampGranularity(str, Enum):
+    """Timestamp granularity options"""
+    WORD = "word"
+    SEGMENT = "segment"
+    CHAR = "char"
+
+
+class Word(BaseModel):
+    """Word-level timestamp"""
+    word: str
+    start: float
+    end: float
+
+
+class Segment(BaseModel):
+    """Segment-level transcript"""
+    id: int
+    start: float
+    end: float
+    text: str
+    temperature: float
+
+
+class Char(BaseModel):
+    """Character-level timestamp"""
+    char: str
+    start: float
+    end: float
+
+
+class AudioTranscriptionRequest(BaseModel):
+    """Audio transcription request"""
+    model: str
+    file: str = Field(description="Audio file to transcribe (base64 encoded or file path)")
+    language: Optional[str] = Field(default=None, description="ISO-639-1 language code")
+    prompt: Optional[str] = Field(default=None, max_length=244)
+    response_format: Literal["json", "text", "str", "verbose_json", "vtt"] = "json"
+    temperature: Optional[float] = Field(default=0.0, ge=0.0, le=1.0)
+    seed: Optional[int] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    n: Optional[int] = None
+    frequency_penalty: Optional[float] = None
+    presence_penalty: Optional[float] = None
+    max_completion_tokens: Optional[int] = None
+    to_language: Optional[str] = None
+    repetition_penalty: Optional[float] = None
+    timestamp_granularities: Optional[List[TimestampGranularity]] = Field(
+        default=[TimestampGranularity.SEGMENT]
+    )
+    stream: Optional[bool] = False
+
+
+class Transcription(BaseModel):
+    """Transcription object"""
+    text: str
+
+
+class AudioTranscriptionResponse(APIResponse):
+    """Audio transcription response"""
+    object: Literal["transcription"] = "transcription"
+    text: str
+    language: Optional[str] = None
+    duration: Optional[float] = None
+    words: Optional[List[Word]] = None
+    segments: Optional[List[Segment]] = None
+    chars: Optional[List[Char]] = None
+    usage: Optional[dict] = None
+
+
+class AudioTranslationRequest(BaseModel):
+    """Audio translation request"""
+    model: str
+    file: str = Field(description="Audio file to translate (base64 encoded or file path)")
+    language: Optional[str] = Field(default=None, description="ISO-639-1 language code")
+    prompt: Optional[str] = Field(default=None, max_length=244)
+    response_format: Literal["json", "text", "str", "verbose_json", "vtt"] = "json"
+    temperature: Optional[float] = Field(default=0.0, ge=0.0, le=1.0)
+    seed: Optional[int] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    n: Optional[int] = None
+    frequency_penalty: Optional[float] = None
+    presence_penalty: Optional[float] = None
+    max_completion_tokens: Optional[int] = None
+    to_language: Optional[str] = None
+    repetition_penalty: Optional[float] = None
+    stream: Optional[bool] = False
+
+
+class AudioTranslationResponse(APIResponse):
+    """Audio translation response"""
+    object: Literal["translation"] = "translation"
+    text: str
+    language: Optional[str] = None
+    duration: Optional[float] = None
+    segments: Optional[List[Segment]] = None
+    usage: Optional[dict] = None
+
+
+class Delta(BaseModel):
+    """Delta object for streaming responses"""
+    content: Optional[str] = None
+
+class ChatCompletionChoice(BaseModel):
+    """Choice object"""
+    delta: Optional[Delta] = None
+    logprobs: Optional[dict | list[dict]] = None
+
+class ChatCompletionResponse(APIResponse):
+    """Chat completion response"""
+    model: str
+    object: Literal["chat.completion"] = "chat.completion"
+    choices: List[ChatCompletionChoice]
+    system_fingerprint: Optional[str] = None
+    usage: Optional[Usage] = None
+
+class AudioTranscriptionChunk(APIResponse):
+    """Chat completion chunk for streaming"""
+    model: str
+    object: Literal["transcription.chunk"] = "transcription.chunk"
+    choices: List[ChatCompletionChoice]
+    usage: Optional[Usage] = None
+
+class AudioTranslationChunk(AudioTranscriptionChunk):
+    """Streaming translation chunk"""
+    object: Literal["translation.chunk"] = "translation.chunk"

synapsai/types/classifications.py

@@ -0,0 +1,228 @@
+# Copyright 2026 SynapsAI Technologies Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Classification type definitions
+"""
+
+from typing import Optional, Dict, Any, Union, List, Literal
+from pydantic import BaseModel, Field, ConfigDict
+from enum import Enum
+from numpy import ndarray
+from PIL.Image import Image as PilImage
+
+from .common import APIResponse, Usage
+
+
+class AudioClassificationData(BaseModel):
+    """Data model for audio classification result"""
+    label: str = Field(..., description="The label predicted for the audio")
+    score: float = Field(..., description="The probability/score for the label")
+
+
+class AudioClassificationRequest(BaseModel):
+    """Request model for audio classification"""
+    model: str
+    inputs: Union[ndarray, bytes, Dict[str, Any]] = Field(..., description="The audio data to classify. Can be raw waveform, bytes from an audio file, or a dict with sampling rate and raw audio.")
+    top_k: Optional[int] = Field(default=None, description="The number of top labels that will be returned by the pipeline.")
+    function_to_apply: Optional[Literal['sigmoid','softmax','none']] = Field(default=None, description="The function to apply to the model outputs to retrieve scores. Valid: 'sigmoid', 'softmax', 'none'.")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class AudioClassificationResponse(APIResponse):
+    """Audio classification response"""
+    object: Literal["list"] = "list"
+    data: List[AudioClassificationData]
+    usage: Optional[Usage] = None
+
+
+class ImageClassificationData(BaseModel):
+    """Data model for image classification result"""
+    label: str = Field(..., description="The label identified by the model")
+    score: float = Field(..., description="The score attributed by the model for that label")
+
+
+class ImageClassificationRequest(BaseModel):
+    """Request model for image classification"""
+    model: str
+    inputs: Union[str, List[str], PilImage, List[PilImage]] = Field(..., description="The image or list of images to classify. Can be a URL, base64, file path or PIL Image.")
+    function_to_apply: Optional[Literal['sigmoid','softmax','none']] = Field(default='default', description="The function to apply to the model outputs in order to retrieve the scores.")
+    top_k: Optional[int] = Field(default=5, description="The number of top labels that will be returned by the pipeline.")
+    timeout: Optional[float] = Field(default=None, description="Maximum time in seconds to wait for fetching images from the web. If None, no timeout is set.")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+class ImageClassificationResponse(APIResponse):
+    """Image classification response"""
+    object: Literal["list"] = "list"
+    data: List[ImageClassificationData]
+    usage: Optional[Usage] = None
+
+
+class TextClassificationData(BaseModel):
+    """Data model for text classification result"""
+    label: str = Field(..., description="The label predicted")
+    score: float = Field(..., description="The corresponding probability")
+
+
+class TextClassificationRequest(BaseModel):
+    """Request model for text classification"""
+    model: str
+    inputs: Union[str, List[str], Dict[str, Any], List[Dict[str, Any]]] = Field(..., description="One or several texts to classify. To use text pairs, send a dict with {'text', 'text_pair'} or a list of such dicts.")
+    top_k: Optional[int] = Field(default=1, description="How many results to return.")
+    function_to_apply: Optional[Literal['sigmoid','softmax','none']] = Field(default='default', description="The function to apply to the model outputs in order to retrieve the scores.")
+
+
+class TextClassificationResponse(APIResponse):
+    """Text classification response"""
+    object: Literal["list"] = "list"
+    data: List[TextClassificationData]
+    usage: Optional[Usage] = None
+
+
+class TokenClassificationData(BaseModel):
+    """Data model for token classification result"""
+    word: str = Field(..., description="The token/word")
+    score: float = Field(..., description="The score for this token")
+    entity: str = Field(..., description="The entity label for the token")
+    index: int = Field(..., description="Token index")
+    start: int = Field(..., description="Start char offset in the original text")
+    end: int = Field(..., description="End char offset in the original text")
+
+
+class TokenClassificationRequest(BaseModel):
+    """Request model for token classification"""
+    model: str
+    inputs: Union[str, List[str]] = Field(..., description="One or several texts (or one list of texts) for token classification.")
+
+
+class TokenClassificationResponse(APIResponse):
+    """Token classification response"""
+    object: Literal["list"] = "list"
+    data: List[TokenClassificationData] | list
+    usage: Optional[Usage] = None
+
+
+class VideoClassificationData(BaseModel):
+    """Data model for video classification result"""
+    label: str = Field(..., description="The label identified by the model")
+    score: float = Field(..., description="The score attributed by the model for that label")
+
+
+class VideoClassificationRequest(BaseModel):
+    """Request model for video classification"""
+    model: str
+    inputs: Union[str, List[str]] = Field(..., description="A http link to a video or a local path to a video. Accepts single video or a batch.")
+    top_k: Optional[int] = Field(default=5, description="The number of top labels that will be returned by the pipeline.")
+    num_frames: Optional[int] = Field(default=16, description="The number of frames sampled from the video to run the classification on.")
+    frame_sampling_rate: Optional[int] = Field(default=1, description="The sampling rate used to select frames from the video.")
+    function_to_apply: Optional[Literal['sigmoid','softmax','none']] = Field(default='softmax', description="The function to apply to the model output. Valid: 'softmax', 'sigmoid', 'none'.")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+class VideoClassificationResponse(APIResponse):
+    """Video classification response"""
+    object: Literal["list"] = "list"
+    data: List[VideoClassificationData]
+    usage: Optional[Usage] = None
+
+
+
+# ================================
+# Zero-Shot Classifications
+# ================================
+
+class ZeroShotAudioClassificationData(BaseModel):
+    """Data model for zero-shot audio classification result"""
+    label: str = Field(..., description="The label predicted for the audio")
+    score: float = Field(..., description="The corresponding probability")
+
+
+class ZeroShotAudioClassificationRequest(BaseModel):
+    """Request model for zero-shot audio classification"""
+    model: str
+    audios: Union[ndarray, List[ndarray]] = Field(..., description="An audio loaded in numpy. Accepts a single array or a list of arrays.")
+    candidate_labels: List[str] = Field(..., description="The candidate labels for this audio.")
+    hypothesis_template: Optional[str] = Field(default="This is a sound of {}", description="Template used with candidate labels.")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class ZeroShotAudioClassificationResponse(APIResponse):
+    """Zero-shot audio classification response"""
+    object: Literal["list"] = "list"
+    data: List[ZeroShotAudioClassificationData]
+    usage: Optional[Usage] = None
+
+
+class ZeroShotClassificationData(BaseModel):
+    """Data model for zero-shot text classification result"""
+    sequence: str = Field(..., description="The input sequence")
+    labels: List[str] = Field(..., description="Candidate labels")
+    scores: List[float] = Field(..., description="Scores aligned with labels")
+
+
+class ZeroShotClassificationRequest(BaseModel):
+    """Request model for zero-shot text classification"""
+    model: str
+    sequences: Union[str, List[str]] = Field(..., description="The sequence(s) to classify")
+    candidate_labels: Union[str, List[str]] = Field(..., description="Possible class labels")
+    hypothesis_template: Optional[str] = Field(default="This example is {}.", description="Template used with candidate labels")
+    multi_label: Optional[bool] = Field(default=False, description="Whether multiple labels can be true")
+
+
+class ZeroShotClassificationResponse(APIResponse):
+    """Zero-shot text classification response"""
+    object: Literal["list"] = "list"
+    data: List[ZeroShotClassificationData]
+    usage: Optional[Usage] = None
+
+
+class ZeroShotImageClassificationData(BaseModel):
+    """Data model for zero-shot image classification result"""
+    label: str = Field(..., description="The label identified by the model")
+    score: float = Field(..., description="The corresponding probability")
+
+
+class ZeroShotImageClassificationRequest(BaseModel):
+    """Request model for zero-shot image classification"""
+    model: str
+    image: Union[str, List[str], PilImage, List[PilImage]] = Field(..., description="An image or list of images to classify")
+    candidate_labels: List[str] = Field(..., description="The candidate labels for this image")
+    hypothesis_template: Optional[str] = Field(default="This is a photo of {}", description="Template used with candidate labels")
+    timeout: Optional[float] = Field(default=None, description="Timeout for fetching images from the web")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class ZeroShotImageClassificationResponse(APIResponse):
+    """Zero-shot image classification response"""
+    object: Literal["list"] = "list"
+    data: List[ZeroShotImageClassificationData]
+    usage: Optional[Usage] = None
+
+
+class ZeroShotObjectDetectionData(BaseModel):
+    """Data model for zero-shot object detection result"""
+    bbox: Dict[str, int] = Field(..., description="Bounding box in corners format")
+
+
+class ZeroShotObjectDetectionRequest(BaseModel):
+    """Request model for zero-shot object detection"""
+    model: str
+    box: Any = Field(..., description="Tensor or list containing the coordinates in corners format")
+
+
+class ZeroShotObjectDetectionResponse(APIResponse):
+    """Zero-shot object detection response"""
+    object: Literal["list"] = "list"
+    data: List[ZeroShotObjectDetectionData]
+    usage: Optional[Usage] = None
+

synapsai/types/common.py

@@ -0,0 +1,56 @@
+# Copyright 2026 SynapsAI Technologies Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Common type definitions used across SynapsAI API
+"""
+
+from typing import Optional, Dict, Any, Union, List
+from pydantic import BaseModel, Field
+from enum import Enum
+
+
+class APIResponse(BaseModel):
+    """Base response model for all API responses"""
+    object: str
+    created: Optional[int] = None
+    id: Optional[str] = None
+
+
+class Error(BaseModel):
+    """Error object"""
+    message: str
+    type: Optional[str] = None
+    param: Optional[str] = None
+    code: Optional[str] = None
+
+
+class ErrorResponse(BaseModel):
+    """Error response model"""
+    error: Error
+
+
+class FinishReason(str, Enum):
+    """Reason why the generation finished"""
+    STOP = "stop"
+    LENGTH = "length"
+    FUNCTION_CALL = "function_call"
+    TOOL_CALLS = "tool_calls"
+    CONTENT_FILTER = "content_filter" 
+
+class Usage(BaseModel):
+    """Token usage information"""
+    prompt_tokens: int
+    completion_tokens: Optional[int] = None
+    total_tokens: int