fastpix-python 0.1.0__py3-none-any.whl

fastpix/__init__.py

@@ -0,0 +1,4 @@
+from fastpix.client.client import Client
+from fastpix.async_client.client import Client as AsyncClient
+
+__all__ = ['Client', 'AsyncClient']

fastpix/async_client/__init__.py

@@ -0,0 +1,3 @@
+from fastpix.async_client.client import Client as AsyncClient
+
+__all__ = ['AsyncClient']

fastpix/async_client/api.py

@@ -0,0 +1,33 @@
+import aiohttp
+from fastpix.utilis.exceptions import APIError
+from fastpix.utilis.constants import BASE_URL
+
+
+async def make_request(method, endpoint, headers=None, data=None, params=None):
+    url = f"{BASE_URL}{endpoint}"
+    headers = headers or {}
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.request(
+                method=method,
+                url=url,
+                headers=headers,
+                json=data,
+                params=params,
+            ) as response:
+                try:
+                    response_data = await response.json()
+                except aiohttp.ContentTypeError:
+                    response_data = await response.text()
+
+                if response.ok:
+                    return response_data
+                else:
+                    raise APIError(
+                        message=f"Request failed with status {response.status}",
+                        status_code=response.status,
+                        details=response_data
+                    )
+    except aiohttp.ClientError as e:
+        raise APIError(f"Request failed: {str(e)}")

fastpix/async_client/client.py

@@ -0,0 +1,52 @@
+import base64
+from fastpix.utilis.exceptions import APIError
+from fastpix.async_client.media import MediaResource
+from fastpix.async_client.playback_ids import PlaybackIDs
+from fastpix.async_client.live_streams import Livestream
+
+
+class Client:
+    def __init__(self, username=None, password=None, api_key=None):
+        """
+        Initialize the client with flexible authentication.
+        
+        Args:
+            username (str, optional): Username for authentication
+            password (str, optional): Password for authentication
+            api_key (str, optional): Pre-generated base64 encoded API key
+        """
+
+        # Validate and prepare API key
+        if api_key:
+            self.api_key = api_key
+        elif username and password:
+            # Encode credentials to base64
+            credentials = f"{username}:{password}"
+            self.api_key = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')
+        else:
+            raise ValueError("Must provide either username and password or a pre-generated API key")
+        
+        # Prepare headers
+        self.headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "Authorization": f"Basic {self.api_key}",
+        }
+        
+        # Initialize resources
+        self.media = MediaResource(self)
+        self.playback_ids = PlaybackIDs(self)
+        self.livestreams = Livestream(self)
+
+    async def _validate_credentials(self):
+        """
+        Validate credentials by attempting to fetch media.
+        Raises an APIError if authentication fails.
+        """
+        try:
+            # Attempt to fetch media to verify credentials (async)
+            response = await self.media.get_all()
+            return response
+
+        except APIError as e:
+            raise APIError(f"Authentication failed: {str(e)}") from e

fastpix/async_client/live_streams.py

@@ -0,0 +1,147 @@
+from fastpix.utilis.exceptions import APIError
+from fastpix.async_client.api import make_request
+from fastpix.utilis.utilis import validate_uuid, validate_request_body
+
+
+class Livestream:
+    def __init__(self, client):
+        self.client = client
+    
+    async def create(self, data):
+        """Create a live stream."""
+
+        validate_request_body(data)  # validating request body is valid json or not
+
+        try:
+            return await make_request(
+                method="POST", 
+                endpoint="/live/streams", 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    async def list(self, params):
+        """Retrieve all live streams."""
+        try:
+            return await make_request(
+                method="GET", 
+                endpoint="/live/streams", 
+                headers=self.client.headers,
+                params=params
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    async def get(self, stream_id):
+        """Retrieve a specific live stream by ID."""
+        
+        validate_uuid(stream_id)  # validating stream_id
+        
+        try:
+            return await make_request(
+                method="GET", 
+                endpoint=f"/live/streams/{stream_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    async def update(self, stream_id, data):
+        """Update a specific live stream."""
+        if not stream_id:
+            raise ValueError("Stream ID must be provided.")
+        
+        try:
+            return await make_request(
+                method="PATCH", 
+                endpoint=f"/live/streams/{stream_id}", 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    async def delete(self, stream_id):
+        """Delete a specific live stream."""
+        
+        validate_uuid(stream_id)  # validating stream_id
+        
+        try:
+            return await make_request(
+                method="DELETE", 
+                endpoint=f"/live/streams/{stream_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    async def create_simulcast(self, stream_id, data):
+        """Create a simulcast for a live stream."""
+        
+        validate_uuid(stream_id)  # validating stream_id 
+        validate_request_body(data)  # validating request body as valid json body or not
+        
+        try:
+            return await make_request(
+                method="POST", 
+                endpoint=f"/live/streams/{stream_id}/simulcast", 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    async def get_simulcast(self, stream_id, simulcast_id):
+        """Retrieve a specific simulcast."""
+         
+        if simulcast_id is None:
+            raise ValueError("Simulcast ID must be provided.")
+
+        validate_uuid(stream_id)  # validating stream_id 
+        
+        try:
+            return await make_request(
+                method="GET", 
+                endpoint=f"/live/streams/{stream_id}/simulcast/{simulcast_id}",
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    async def update_simulcast(self, stream_id, simulcast_id, data):
+        """Update a specific simulcast."""
+
+        if simulcast_id is None:
+            raise ValueError("Simulcast ID must be provided.")
+        
+        validate_uuid(stream_id)  # validating stream_id 
+        validate_request_body(data)  # validating request body as valid json body or not
+        
+        try:
+            return await make_request(
+                method="PUT", 
+                endpoint=f"/live/streams/{stream_id}/simulcast/{simulcast_id}", 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    async def delete_simulcast(self, stream_id, simulcast_id):
+        """Delete a specific simulcast."""
+
+        if simulcast_id is None:
+            raise ValueError("Simulcast ID must be provided.")
+        
+        validate_uuid(stream_id)  # validating stream_id
+        
+        try:
+            return await make_request(
+                method="DELETE", 
+                endpoint=f"/live/streams/{stream_id}/simulcast/{simulcast_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()

fastpix/async_client/media.py

@@ -0,0 +1,121 @@
+from fastpix.utilis.exceptions import APIError
+from fastpix.async_client.api import make_request
+from fastpix.utilis.utilis import validate_uuid, validate_request_body
+
+
+class MediaResource:
+    def __init__(self, client):
+        self.client = client
+    
+    async def get_all_media(self, params):
+        """Fetch all medias."""
+        try:
+            return await make_request(
+                method="GET", 
+                endpoint="/on-demand", 
+                headers=self.client.headers,
+                params=params
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    async def get_by_mediaId(self, media_id):
+        """Fetch media by its ID."""
+        
+        validate_uuid(media_id)  # validating media id
+        
+        try:
+            return await make_request(
+                method="GET", 
+                endpoint=f"/on-demand/{media_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    async def update(self, media_id, data):
+        """Update media by its ID."""
+        
+        validate_uuid(media_id)  # validating media id 
+        validate_request_body(data)  # validating request body is valid json or not
+        
+        try:
+            return await make_request(
+                method="PATCH", 
+                endpoint=f"/on-demand/{media_id}", 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    async def delete(self, media_id):
+        """Delete media by its ID."""
+        
+        validate_uuid(media_id)  # validating media id
+        
+        try:
+            return await make_request(
+                method="DELETE", 
+                endpoint=f"/on-demand/{media_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    async def create_pull_video(self, data):
+        """Create an on-demand request by calling the /on-demand endpoint."""
+        endpoint = "/on-demand"
+
+        validate_request_body(data) # validating body
+        
+        if "accessPolicy" not in data:
+            data["accessPolicy"] = "public"
+        
+        try:
+            response = await make_request(
+                method="POST", 
+                endpoint=endpoint, 
+                headers=self.client.headers, 
+                data=data
+            )
+            return response
+        except APIError as e:
+            return e.to_dict()
+
+    async def get_presigned_url(self, data):
+        """Create an on-demand presigned URL request by calling the /on-demand/uploads endpoint."""
+        endpoint = "/on-demand/uploads"
+
+        validate_request_body(data) # validating body
+        
+        if "corsOrigin" not in data:
+            data["corsOrigin"] = "*"
+        
+        try:
+            response = await make_request(
+                method="POST", 
+                endpoint=endpoint, 
+                headers=self.client.headers, 
+                data=data
+            )
+            return response
+        except APIError as e:
+            return e.to_dict()
+    
+    async def get_media_info(self, media_id):
+        """Retrieve media input info by media ID."""
+        endpoint = f"/on-demand/{media_id}/input-info"
+        
+        validate_uuid(media_id)  # validating media id
+        
+        try:
+            response = await make_request(
+                method="GET", 
+                endpoint=endpoint, 
+                headers=self.client.headers
+            )
+            return response
+        except APIError as e:
+            return e.to_dict()
+            

fastpix/async_client/playback_ids.py

@@ -0,0 +1,79 @@
+from fastpix.utilis.exceptions import APIError
+from fastpix.async_client.api import make_request
+from fastpix.utilis.utilis import validate_uuid, validate_request_body
+
+
+class PlaybackIDs:
+    def __init__(self, client):
+        self.client = client
+
+    def _get_endpoint(self, media_type, media_id):
+        """Helper method to get the correct endpoint based on media type."""
+        if media_type == "livestream":
+            return f"/live/streams/{media_id}/playback-ids"
+        elif media_type == "video_on_demand":
+            return f"/on-demand/{media_id}/playback-ids"
+        else:
+            raise ValueError("Invalid media type. Must be 'livestream' or 'video_on_demand'.")
+
+    async def create(self, media_type, media_id, data):
+        """Create a playback ID for a media resource (livestream or video on demand)."""
+        
+        # Validate media_id
+        validate_uuid(media_id)  # Ensure valid UUID format
+        
+        # Validate request body (data)
+        validate_request_body(data)  # Ensure the request body is valid JSON
+        
+        try:
+            # Get the correct endpoint based on media type
+            endpoint = self._get_endpoint(media_type, media_id)
+
+            return await make_request(
+                method="POST", 
+                endpoint=endpoint, 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    async def delete(self, media_type, media_id, playback_ids):
+        """Delete a specific playback ID for a media resource (livestream or video on demand)."""
+        
+        # Validate media_id
+        validate_uuid(media_id)  # Ensure valid UUID format
+        
+        try:
+            # Get the correct endpoint based on media type
+            endpoint = self._get_endpoint(media_type, media_id)
+
+            return await make_request(
+                method="DELETE", 
+                endpoint=endpoint, 
+                headers=self.client.headers,
+                params={'playbackId': playback_ids}
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    async def get(self, media_type, media_id, playback_id):
+        """Retrieve a specific playback ID for a media resource (livestream or video on demand)."""
+        
+        # Validate media_id
+        validate_uuid(media_id)  # Ensure valid UUID format
+
+        if media_type == "video_on_demand":
+            return {"error": "The 'get' method is not available for video_on_demand."}
+    
+        try:
+            # Get the correct endpoint based on media type
+            endpoint = self._get_endpoint(media_type, media_id) + f"/{playback_id}"
+
+            return await make_request(
+                method="GET", 
+                endpoint=endpoint,
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()

fastpix/client/__init__.py

@@ -0,0 +1,3 @@
+from fastpix.client.client import Client
+
+__all__ = ['Client']

fastpix/client/api.py

@@ -0,0 +1,28 @@
+import requests
+from fastpix.utilis.exceptions import APIError
+from fastpix.utilis.constants import BASE_URL
+
+
+def make_request(method, endpoint, headers=None, data=None, params=None):
+    url = f"{BASE_URL}{endpoint}"
+    headers = headers or {}
+
+    try:
+        response = requests.request(
+            method=method,
+            url=url,
+            headers=headers,
+            json=data,
+            params=params
+        )
+
+        if response.ok:
+            return response.json()
+        else:
+            raise APIError(
+                message=f"Request failed with status {response.status_code}",
+                status_code=response.status_code,
+                details=response.json() if response.headers.get("content-type") == "application/json" else response.text
+            )
+    except requests.RequestException as e:
+        raise APIError(f"Request failed: {str(e)}")

fastpix/client/client.py

@@ -0,0 +1,57 @@
+import base64
+from fastpix.utilis.exceptions import APIError
+from fastpix.client.media import MediaResource
+from fastpix.client.playback_ids import PlaybackIDs
+from fastpix.client.live_streams import Livestream
+
+
+class Client:
+    def __init__(self, username=None, password=None, api_key=None):
+        """
+        Initialize the client with flexible authentication.
+        
+        Args:
+            username (str, optional): Username for authentication
+            password (str, optional): Password for authentication
+            api_key (str, optional): Pre-generated base64 encoded API key
+        """
+
+        # Validate and prepare API key
+        if api_key:
+            self.api_key = api_key
+        elif username and password:
+
+            # Encode credentials to base64
+            credentials = f"{username}:{password}"
+            self.api_key = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')
+        else:
+            raise ValueError("Must provide either username and password or a pre-generated API key")
+        
+        # Prepare headers
+        self.headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "Authorization": f"Basic {self.api_key}",
+        }
+        
+        # Initialize resources
+        self.media = MediaResource(self)
+        self.playback_ids = PlaybackIDs(self)
+        self.livestreams = Livestream(self)
+
+        # Validate credentials
+        self._validate_credentials()
+
+    def _validate_credentials(self):
+        """
+        Validate credentials by attempting to fetch media.
+        Raises an APIError if authentication fails.
+        """
+        try:
+            # Attempt to fetch media to verify credentials
+            response = self.media.get_all_media()
+            return response
+
+        except APIError as e:
+            raise APIError(f"Authentication failed: {str(e)}") from e
+            

fastpix/client/live_streams.py

@@ -0,0 +1,150 @@
+from fastpix.utilis.exceptions import APIError
+from fastpix.client.api import make_request
+from fastpix.utilis.utilis import validate_uuid, validate_request_body
+
+
+class Livestream:
+    def __init__(self, client):
+        self.client = client
+    
+    def create(self, data):
+        """Create a live stream."""
+
+        validate_request_body(data)  # validating request body is valid json or not
+
+        try:
+            return make_request(
+                method="POST", 
+                endpoint="/live/streams", 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    def list(self, params=None):
+        """Retrieve all live streams."""
+
+        try:
+            return make_request(
+                method="GET", 
+                endpoint="/live/streams", 
+                headers=self.client.headers,
+                params=params
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    def get(self, stream_id):
+        """Retrieve a specific live stream by ID."""
+
+        validate_uuid(stream_id)  # validating stream_id
+        
+        try:
+            return make_request(
+                method="GET", 
+                endpoint=f"/live/streams/{stream_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    def update(self, stream_id, data):
+        """Update a specific live stream."""
+        
+        validate_uuid(stream_id) # validating stream_id
+        validate_request_body(data)  # validating request body is valid json or not
+        
+        try:
+            return make_request(
+                method="PATCH", 
+                endpoint=f"/live/streams/{stream_id}", 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    def delete(self, stream_id):
+        """Delete a specific live stream."""
+        
+        validate_uuid(stream_id)  # validating stream_id
+        
+        try:
+            return make_request(
+                method="DELETE", 
+                endpoint=f"/live/streams/{stream_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    def create_simulcast(self, stream_id, data):
+        """Create a simulcast for a live stream."""
+        
+        validate_uuid(stream_id) # validating stream_id 
+        validate_request_body(data) # validating request body as valid json body or not
+        
+        try:
+            return make_request(
+                method="POST", 
+                endpoint=f"/live/streams/{stream_id}/simulcast", 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    def get_simulcast(self, stream_id, simulcast_id):
+        """Retrieve a specific simulcast."""
+
+        if simulcast_id is None:
+            raise ValueError("Simulcast ID must be provided.")
+
+        validate_uuid(stream_id)  # validating stream_id 
+
+        try:
+            return make_request(
+                method="GET", 
+                endpoint=f"/live/streams/{stream_id}/simulcast/{simulcast_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    def update_simulcast(self, stream_id, simulcast_id, data):
+        """Update a specific simulcast."""
+        
+        if simulcast_id is None:
+            raise ValueError("Simulcast ID must be provided.")
+
+        validate_uuid(stream_id)  # validating stream_id 
+        validate_request_body(data)  # validating request body as valid json body or not
+        
+        try:
+            return make_request(
+                method="PUT", 
+                endpoint=f"/live/streams/{stream_id}/simulcast/{simulcast_id}", 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    def delete_simulcast(self, stream_id, simulcast_id):
+        """Delete a specific simulcast."""
+        
+        if simulcast_id is None:
+            raise ValueError("Simulcast ID must be provided.")
+
+        validate_uuid(stream_id)  # validating stream_id
+        
+        try:
+            return make_request(
+                method="DELETE", 
+                endpoint=f"/live/streams/{stream_id}/simulcast/{simulcast_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+            

fastpix/client/media.py

@@ -0,0 +1,110 @@
+from fastpix.utilis.exceptions import APIError
+from fastpix.client.api import make_request
+from fastpix.utilis.utilis import validate_uuid, validate_request_body
+
+
+class MediaResource:
+    def __init__(self, client):
+        self.client = client
+    
+    def get_all_media(self, params):
+        """Fetch all medias."""
+        try:
+            return make_request(
+                method="GET", 
+                endpoint="/on-demand", 
+                headers=self.client.headers,
+                params=params
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    def get_by_mediaId(self, media_id):
+        """Fetch media by its ID."""
+        validate_uuid(media_id)  # Validate media ID
+        try:
+            return make_request(
+                method="GET", 
+                endpoint=f"/on-demand/{media_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    def update(self, media_id, data):
+        """Update media by its ID."""
+        validate_uuid(media_id)  # Validate media ID
+        validate_request_body(data)  # Validate request body
+
+        try:
+            return make_request(
+                method="PATCH", 
+                endpoint=f"/on-demand/{media_id}", 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    def delete(self, media_id):
+        """Delete media by its ID."""
+        validate_uuid(media_id)  # Validate media ID
+
+        try:
+            return make_request(
+                method="DELETE", 
+                endpoint=f"/on-demand/{media_id}", 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    def create_pull_video(self, data):
+        """Create an on-demand request by calling the /on-demand endpoint."""
+        endpoint = "/on-demand"
+        validate_request_body(data)  # Validate body
+
+        if "accessPolicy" not in data:
+            data["accessPolicy"] = "public"
+
+        try:
+            return make_request(
+                method="POST", 
+                endpoint=endpoint, 
+                headers=self.client.headers, 
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    def get_presigned_url(self, data):
+        """Create an on-demand presigned URL request by calling the /on-demand/uploads endpoint."""
+        endpoint = "/on-demand/uploads"
+        validate_request_body(data)  # Validate body
+
+        if "corsOrigin" not in data:
+            data["corsOrigin"] = "*"
+
+        try:
+            return make_request(
+                method="POST", 
+                endpoint=endpoint, 
+                headers=self.client.headers, 
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    def get_media_info(self, media_id):
+        """Retrieve media input info by media ID."""
+        validate_uuid(media_id)  # Validate media ID
+
+        try:
+            endpoint = f"/on-demand/{media_id}/input-info"
+            return make_request(
+                method="GET", 
+                endpoint=endpoint, 
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()

fastpix/client/playback_ids.py

@@ -0,0 +1,80 @@
+from fastpix.utilis.exceptions import APIError
+from fastpix.client.api import make_request
+from fastpix.utilis.utilis import validate_uuid, validate_request_body
+
+
+class PlaybackIDs:
+    def __init__(self, client):
+        self.client = client
+    
+    def _get_endpoint(self, media_type, media_id):
+        """Helper method to get the correct endpoint based on media type."""
+        if media_type == "livestream":
+            return f"/live/streams/{media_id}/playback-ids"
+        elif media_type == "video_on_demand":
+            return f"/on-demand/{media_id}/playback-ids"
+        else:
+            raise ValueError("Invalid media type. Must be 'livestream' or 'video_on_demand'.")
+
+    def create(self, media_type, media_id, data):
+        """Create a playback ID for a media resource (livestream or video on demand)."""
+        
+        # Validate media_id
+        validate_uuid(media_id)  # Ensure valid UUID format
+        
+        # Validate request body (data)
+        validate_request_body(data)  # Ensure the request body is valid JSON
+        
+        try:
+            # Get the correct endpoint based on media type
+            endpoint = self._get_endpoint(media_type, media_id)
+
+            return make_request(
+                method="POST", 
+                endpoint=endpoint, 
+                headers=self.client.headers,
+                data=data
+            )
+        except APIError as e:
+            return e.to_dict()
+    
+    def delete(self, media_type, media_id, playback_ids):
+        """Delete a specific playback ID for a media resource (livestream or video on demand)."""
+        
+        # Validate media_id
+        validate_uuid(media_id)  # Ensure valid UUID format
+        
+        try:
+            # Get the correct endpoint based on media type
+            endpoint = self._get_endpoint(media_type, media_id)
+
+            return make_request(
+                method="DELETE", 
+                endpoint=endpoint, 
+                headers=self.client.headers,
+                params={'playbackId': playback_ids}
+            )
+        except APIError as e:
+            return e.to_dict()
+
+    def get(self, media_type, media_id, playback_id):
+        """Retrieve a specific playback ID for a media resource (livestream or video on demand)."""
+        
+        # Validate media_id
+        validate_uuid(media_id)  # Ensure valid UUID format
+
+        if media_type == "video_on_demand":
+            return {"error": "The 'get' method is not available for video_on_demand."}
+    
+        try:
+            # Get the correct endpoint based on media type
+            endpoint = self._get_endpoint(media_type, media_id) + f"/{playback_id}"
+
+            return make_request(
+                method="GET", 
+                endpoint=endpoint,
+                headers=self.client.headers
+            )
+        except APIError as e:
+            return e.to_dict()
+    

fastpix/utilis/__init__.py

@@ -0,0 +1,4 @@
+from .constants import BASE_URL, validate_uuid, validate_request_body
+from .exceptions import APIError
+
+__all__ = ['constants', 'exceptions']

fastpix/utilis/constants.py

@@ -0,0 +1 @@
+BASE_URL = "https://v1.fastpix.io"

fastpix/utilis/exceptions.py

@@ -0,0 +1,14 @@
+class APIError(Exception):
+    """Custom exception for API-related errors."""
+    def __init__(self, message, status_code=None, details=None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.details = details
+        
+    def to_dict(self):
+        return {
+            "error": self.message,
+            "status_code": self.status_code,
+            "details": self.details,
+        }

fastpix/utilis/utilis.py

@@ -0,0 +1,17 @@
+import uuid
+import json
+
+
+def validate_uuid(id_str):
+    try:
+        uuid.UUID(str(id_str))
+    except ValueError:
+        raise ValueError(f"Invalid UUID format: {id_str}")
+
+
+def validate_request_body(data):
+    try:
+        json.dumps(data)
+    except (TypeError, ValueError):
+        raise ValueError("Invalid JSON data in request body")
+

fastpix_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: fastpix-python
+Version: 0.1.0
+Summary: FastPix SDK with both sync and async support
+Home-page: https://github.com/fastpix-io/fastpix-python-server-sdk
+Author: FastPix
+Author-email: dev@fastpix.io
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: async
+Requires-Dist: aiohttp>=3.8.0; extra == "async"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

fastpix_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+fastpix/__init__.py,sha256=loB8C7K059okqu9xAO32Jr9_wBF8kzZXIVjWWp_v9x8,140
+fastpix/async_client/__init__.py,sha256=0brJ1RCLOd7cNl6cjtr96AqftUd66Owp2W1fkfo4Rbo,89
+fastpix/async_client/api.py,sha256=jmALp5zny5FaqUm7RDmVXF9T0iFnNyCKtJpEQ0cxtiA,1144
+fastpix/async_client/client.py,sha256=UggrQiehFSNBvF3dH0evq0DacVsvEooxRaAx-Wpr88g,1878
+fastpix/async_client/live_streams.py,sha256=sx9_xtiR1FD6MGg_F3aq8NwjXHOwuVD1eBvp4NjGBvk,4765
+fastpix/async_client/media.py,sha256=l4CMp61eEvX0v67jrcurZ2CAysvJQZbr4VRQDNOowtc,3704
+fastpix/async_client/playback_ids.py,sha256=1pKQ9VNuOUzADZQiAlJPftRkdB3gS97srwz7QUB4WJY,2924
+fastpix/client/__init__.py,sha256=3C-Vhg1RULZzdjI0kCnfNj_LzwOHSHO-di--gSA-gTQ,63
+fastpix/client/api.py,sha256=WUN0Z7crvw7V3E5_0XzrTXfmLb4mFoDogj1ADoru4sk,890
+fastpix/client/client.py,sha256=GiFPu3jq0cXrUw1iqmwvJRIXaZKC_HtgMlklsYXNUyY,1928
+fastpix/client/live_streams.py,sha256=p_3r4PzipnTEYmd6KlZUi4kHSwiOkOvvJxT2QAVEav4,4706
+fastpix/client/media.py,sha256=-VdOb5fm18G-f11DGnZD7dTjaBY9BeI2c1jebrUh8tE,3369
+fastpix/client/playback_ids.py,sha256=2duK4WAjOIhL-nOBKHt1PpFbPSclUsMh5Upta1lWIcQ,2890
+fastpix/utilis/__init__.py,sha256=-9bDUz5FeRXp-ZyeMJEap0q5EXvhIr-ljadB24_5yUo,142
+fastpix/utilis/constants.py,sha256=s4jcq1qk7N5-t4wcZE4aIutzsIoHx8pattbg4NBIAnw,35
+fastpix/utilis/exceptions.py,sha256=fctNkUrSg2VkukwVdTGa1j8v2VMcUM4rPna76VHIe3o,454
+fastpix/utilis/utilis.py,sha256=3JIwmN-fuDc8JQ1jpzPLom-vQI3aXEuch0V9LactpxU,343
+fastpix_python-0.1.0.dist-info/licenses/LICENSE,sha256=F9rynAolz0RQr0fiAQO0TSptdJq_Q-KPx0sguGiLdAI,1063
+fastpix_python-0.1.0.dist-info/METADATA,sha256=_2990kEoq7jVBiEkt2fp0QqmP3SiqxA-XWMi8k9_dQY,896
+fastpix_python-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fastpix_python-0.1.0.dist-info/top_level.txt,sha256=SADFSkxaYaU-AHZY56jucIDG-iqlTMU3y3EL2FksnDM,8
+fastpix_python-0.1.0.dist-info/RECORD,,

fastpix_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fastpix_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 FastPix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastpix_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastpix