mixpeek 0.11.0__py3-none-any.whl → 0.11.1__py3-none-any.whl

mixpeek/__init__.py

@@ -1,93 +1 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from . import types
-from ._types import NOT_GIVEN, NoneType, NotGiven, Transport, ProxiesTypes
-from ._utils import file_from_path
-from ._client import (
-    Client,
-    Stream,
-    Timeout,
-    Transport,
-    MixpeekSDK,
-    AsyncClient,
-    AsyncStream,
-    RequestOptions,
-    AsyncMixpeekSDK,
-)
-from ._models import BaseModel
-from ._version import __title__, __version__
-from ._response import APIResponse as APIResponse, AsyncAPIResponse as AsyncAPIResponse
-from ._constants import DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES, DEFAULT_CONNECTION_LIMITS
-from ._exceptions import (
-    APIError,
-    ConflictError,
-    NotFoundError,
-    APIStatusError,
-    RateLimitError,
-    APITimeoutError,
-    BadRequestError,
-    MixpeekSDKError,
-    APIConnectionError,
-    AuthenticationError,
-    InternalServerError,
-    PermissionDeniedError,
-    UnprocessableEntityError,
-    APIResponseValidationError,
-)
-from ._base_client import DefaultHttpxClient, DefaultAsyncHttpxClient
-from ._utils._logs import setup_logging as _setup_logging
-
-__all__ = [
-    "types",
-    "__version__",
-    "__title__",
-    "NoneType",
-    "Transport",
-    "ProxiesTypes",
-    "NotGiven",
-    "NOT_GIVEN",
-    "MixpeekSDKError",
-    "APIError",
-    "APIStatusError",
-    "APITimeoutError",
-    "APIConnectionError",
-    "APIResponseValidationError",
-    "BadRequestError",
-    "AuthenticationError",
-    "PermissionDeniedError",
-    "NotFoundError",
-    "ConflictError",
-    "UnprocessableEntityError",
-    "RateLimitError",
-    "InternalServerError",
-    "Timeout",
-    "RequestOptions",
-    "Client",
-    "AsyncClient",
-    "Stream",
-    "AsyncStream",
-    "MixpeekSDK",
-    "AsyncMixpeekSDK",
-    "file_from_path",
-    "BaseModel",
-    "DEFAULT_TIMEOUT",
-    "DEFAULT_MAX_RETRIES",
-    "DEFAULT_CONNECTION_LIMITS",
-    "DefaultHttpxClient",
-    "DefaultAsyncHttpxClient",
-]
-
-_setup_logging()
-
-# Update the __module__ attribute for exported symbols so that
-# error messages point to this module instead of the module
-# it was originally defined in, e.g.
-# mixpeek._exceptions.NotFoundError -> mixpeek.NotFoundError
-__locals = locals()
-for __name in __all__:
-    if not __name.startswith("__"):
-        try:
-            __locals[__name].__module__ = "mixpeek"
-        except (TypeError, AttributeError):
-            # Some of our exported symbols are builtins which we can't set attributes for.
-            pass
+from .client import Mixpeek

mixpeek/client.py

@@ -0,0 +1,27 @@
+import requests
+
+from .endpoints.embed import Embed
+from .endpoints.collections import Collections
+from .endpoints.index import Index
+from .endpoints.search import Search
+from .endpoints.tools import Tools
+from .endpoints.register import Register
+
+
+class Mixpeek:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.base_url = "https://api.mixpeek.com/"
+        self.headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        # these are remote
+        self.embed = Embed(self.base_url, self.headers)
+        self.collections = Collections(self.base_url, self.headers)
+        self.index = Index(self.base_url, self.headers)
+        self.search = Search(self.base_url, self.headers)
+        self.register = Register(self.base_url, self.headers)
+
+        # tools is all local
+        self.tools = Tools()

mixpeek/endpoints/collections.py

@@ -0,0 +1,86 @@
+import requests
+
+class Collections:
+    def __init__(self, base_url, headers):
+        self.base_url = base_url
+        self.headers = headers
+
+    def list_files(self, collection_id, randomize=False, page=1, page_size=10, filters=None, sort_by=None, sort_order="asc"):
+        try:
+            url = f"{self.base_url}collections/"
+            data = {
+                "collection_id": collection_id,
+                "randomize": randomize,
+                "page": page,
+                "page_size": page_size,
+                "filters": filters,
+                "sort_by": sort_by,
+                "sort_order": sort_order
+            }
+            response = requests.post(url, json=data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def list_collections(self):
+        try:
+            url = f"{self.base_url}collections/"
+            response = requests.get(url, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def search_files(self, query, collection_id, page=1, page_size=10, sort_by=None, sort_order="asc"):
+        try:
+            url = f"{self.base_url}collections/search"
+            data = {
+                "query": query,
+                "collection_id": collection_id,
+                "page": page,
+                "page_size": page_size,
+                "sort_by": sort_by,
+                "sort_order": sort_order
+            }
+            response = requests.post(url, json=data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def get_file_by_id(self, file_id):
+        try:
+            url = f"{self.base_url}collections/file/{file_id}"
+            response = requests.get(url, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def get_full_file(self, file_id):
+        try:
+            url = f"{self.base_url}collections/file/{file_id}/full"
+            response = requests.get(url, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def delete_file_by_id(self, file_id):
+        try:
+            url = f"{self.base_url}collections/file/{file_id}"
+            response = requests.delete(url, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def delete_collection(self, collection_id):
+        try:
+            url = f"{self.base_url}collections/{collection_id}"
+            response = requests.delete(url, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}

mixpeek/endpoints/embed.py

@@ -0,0 +1,66 @@
+import requests
+#test
+class Embed:
+    def __init__(self, base_url, headers):
+        self.base_url = base_url
+        self.headers = headers
+
+    def video(self, model_id: str, input: str, input_type: str):
+        try:
+            url = f"{self.base_url}embed/"
+            data = {
+                "modality": "video",
+                "model_id": model_id,
+                "input": input,
+                "input_type": input_type
+            }
+            response = requests.post(url, json=data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def text(self, model_id: str, input: str, input_type: str):
+        try:
+            url = f"{self.base_url}embed/"
+            data = {
+                "modality": "text",
+                "model_id": model_id,
+                "input": input,
+                "input_type": input_type
+            }
+            response = requests.post(url, json=data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def image(self, model_id: str, input: str, input_type: str):
+        try:
+            url = f"{self.base_url}embed/"
+            data = {
+                "modality": "image",
+                "model_id": model_id,
+                "input": input,
+                "input_type": input_type
+            }
+            response = requests.post(url, json=data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def audio(self, model_id: str, input: str, input_type: str):
+        try:
+            url = f"{self.base_url}embed/"
+            data = {
+                "modality": "audio",
+                "model_id": model_id,
+                "input": input,
+                "input_type": input_type
+            }
+            response = requests.post(url, json=data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}

mixpeek/endpoints/index.py

@@ -0,0 +1,51 @@
+import requests
+from .tasks import Task
+
+class Index:
+    def __init__(self, base_url, headers):
+        self.base_url = base_url
+        self.headers = headers
+
+    def _prepare_data(self, base_data, metadata=None, video_settings=None, image_settings=None):
+        if metadata is not None:
+            base_data["metadata"] = metadata
+        if video_settings is not None:
+            base_data["video_settings"] = video_settings
+        if image_settings is not None:
+            base_data["image_settings"] = image_settings
+        return base_data
+
+    def url(self, target_url, collection_id, metadata=None, video_settings=None, image_settings=None):
+        try:
+            endpoint = f"{self.base_url}index/url"
+            data = self._prepare_data({"url": target_url, "collection_id": collection_id}, metadata, video_settings, image_settings)
+
+            response = requests.post(endpoint, json=data, headers=self.headers)
+            response.raise_for_status()
+            task_id = response.json().get("task_id")
+            if task_id:
+                return Task(self.base_url, self.headers, task_id)
+            else:
+                return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+        
+    def upload(self, file_path, collection_id, metadata=None, settings=None):
+        try:
+            endpoint = f"{self.base_url}index/upload"
+            data = self._prepare_data({"collection_id": collection_id}, metadata, settings)
+            
+            with open(file_path, 'rb') as file:
+                files = [('file', (file.name, file, 'application/octet-stream'))]
+                response = requests.post(endpoint, headers=self.headers, data=data, files=files)
+            
+            response.raise_for_status()
+            task_id = response.json().get("task_id")
+            if task_id:
+                return Task(self.base_url, self.headers, task_id)
+            else:
+                return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+        except IOError as e:
+            return {"error": f"File error: {str(e)}"}

mixpeek/endpoints/register.py

@@ -0,0 +1,34 @@
+import requests
+from .tasks import Task
+
+class Register:
+    def __init__(self, base_url, headers):
+        self.base_url = base_url
+        self.headers = headers
+
+    def _prepare_data(self, base_data, metadata=None, settings=None):
+        if metadata is not None:
+            base_data["metadata"] = metadata
+        if settings is not None:
+            base_data["settings"] = settings
+        return base_data
+
+    def faces(self, file_path, collection_id, metadata=None, settings=None):
+        try:
+            endpoint = f"{self.base_url}register/faces"
+            data = self._prepare_data({"collection_id": collection_id}, metadata, settings)
+            
+            with open(file_path, 'rb') as file:
+                files = [('file', (file.name, file, 'application/octet-stream'))]
+                response = requests.post(endpoint, headers=self.headers, data=data, files=files)
+            
+            response.raise_for_status()
+            task_id = response.json().get("task_id")
+            if task_id:
+                return Task(self.base_url, self.headers, task_id)
+            else:
+                return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+        except IOError as e:
+            return {"error": f"File error: {str(e)}"}

mixpeek/endpoints/search.py

@@ -0,0 +1,67 @@
+import requests
+import os
+import json
+
+class Search:
+    def __init__(self, base_url, headers):
+        self.base_url = base_url
+        self.headers = headers
+
+    def text(self, input, modality, input_type="text", filters=None, group_by_file=True, page=1, page_size=10):
+        try:
+            url = f"{self.base_url}search/text"
+            data = {
+                "input": input,
+                "modality": modality,
+                "input_type": input_type,
+                "filters": filters or {},
+                "group_by_file": group_by_file,
+                "pagination": {
+                    "page": page,
+                    "page_size": page_size
+                }
+            }
+            response = requests.post(url, json=data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    # def upload(self, file_path, filters=None, page=1, page_size=10):
+    #     try:
+    #         url = f"{self.base_url}search/upload"
+            
+    #         filename = os.path.basename(file_path)
+    #         files = {
+    #             'file': (filename, open(file_path, 'rb'), 'application/octet-stream')
+    #         }
+            
+    #         payload = {
+    #             'filters': json.dumps(filters or {}),
+    #             'page': str(page),
+    #             'page_size': str(page_size)
+    #         }
+            
+    #         response = requests.post(url, headers=self.headers, data=payload, files=files)
+    #         response.raise_for_status()
+    #         return response.json()
+    #     except requests.RequestException as e:
+    #         return {"error": str(e)}
+
+    def url(self, target_url, filters=None, modality="text", page=1, page_size=10):
+        try:
+            url = f"{self.base_url}search/url"
+            data = {
+                "url": target_url,
+                "filters": filters or {},
+                "modality": modality,
+                "pagination": {
+                    "page": page,
+                    "page_size": page_size
+                }
+            }
+            response = requests.post(url, json=data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}

mixpeek/endpoints/tasks.py

@@ -0,0 +1,26 @@
+import requests
+import time
+
+class Task:
+    def __init__(self, base_url, headers, task_id):
+        self.base_url = base_url
+        self.headers = headers
+        self.task_id = task_id
+
+    def get_task_status(self, task_id):
+        try:
+            endpoint = f"{self.base_url}tasks/{task_id}"
+            response = requests.get(endpoint, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def wait_for_done(self, sleep_interval=2, callback=None):
+        while True:
+            status = self.get_task_status(self.task_id)
+            if callback:
+                callback(status)
+            if status.get("status") == "DONE":
+                return status
+            time.sleep(sleep_interval)

mixpeek/endpoints/tools.py

@@ -0,0 +1,138 @@
+import subprocess
+import tempfile
+import os
+import base64
+from urllib.parse import urlparse
+from urllib.request import urlretrieve
+from tqdm import tqdm
+from PIL import Image
+import io
+
+class Tools:
+    def __init__(self):
+        self.video = self.Video(self)
+        self.image = self.Image(self)
+
+    class Image:
+        def __init__(self, parent):
+            pass
+
+        def process(self, image_source: str):
+            # Download image if it's a URL
+            if urlparse(image_source).scheme in ('http', 'https'):
+                with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+                    urlretrieve(image_source, temp_file.name)
+                    image_source = temp_file.name
+
+            # Open and process the image
+            with Image.open(image_source) as img:
+                # Convert image to RGB mode if it's not already
+                if img.mode != 'RGB':
+                    img = img.convert('RGB')
+
+                # Convert image to base64
+                buffered = io.BytesIO()
+                img.save(buffered, format="JPEG")
+                base64_string = base64.b64encode(buffered.getvalue()).decode('utf-8')
+
+            # Remove temporary file if it was created
+            if urlparse(image_source).scheme in ('http', 'https'):
+                os.unlink(image_source)
+
+            return base64_string
+
+    class Video:
+        def __init__(self, parent):
+            pass
+
+        def process(self, video_source: str, chunk_interval: float, resolution: list):
+            chunker = VideoChunker(video_source, chunk_interval, resolution)
+            
+            for chunk in chunker:
+                data = {
+                    "base64_chunk": chunk["base64"],
+                    "start_time": chunk["start_time"],
+                    "end_time": chunk["end_time"]
+                }
+                yield data
+
+
+class VideoChunker:
+    def __init__(self, video_source, chunk_interval, target_resolution):
+        self.video_source = video_source
+        self.chunk_interval = chunk_interval
+        self.target_resolution = f"{target_resolution[0]}x{target_resolution[1]}"
+        self.temp_dir = tempfile.mkdtemp()
+        self.total_duration = None
+        self.current_time = 0
+
+    def __del__(self):
+        self.cleanup()
+
+    def cleanup(self):
+        for file in os.listdir(self.temp_dir):
+            os.remove(os.path.join(self.temp_dir, file))
+        os.rmdir(self.temp_dir)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.total_duration is None:
+            self._initialize_video()
+
+        chunk = self._process_chunk()
+        if chunk is None:
+            raise StopIteration
+        return chunk
+
+    def _initialize_video(self):
+        if urlparse(self.video_source).scheme in ('http', 'https'):
+            print("Downloading video...")
+            temp_file = os.path.join(self.temp_dir, 'temp_video')
+            urlretrieve(self.video_source, temp_file)
+            self.video_source = temp_file
+
+        # Get video duration
+        result = subprocess.run(['ffprobe', '-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', self.video_source], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        self.total_duration = float(result.stdout)
+        
+        print(f"Total video duration: {self.total_duration:.2f} seconds")
+        self.progress_bar = tqdm(total=100, desc="Processing video", unit="%")
+
+    def _process_chunk(self):
+        if self.current_time >= self.total_duration:
+            return None
+
+        start_time = self.current_time
+        end_time = min(start_time + self.chunk_interval, self.total_duration)
+
+        # Generate chunk using FFmpeg
+        temp_output = os.path.join(self.temp_dir, f"chunk_{self.current_time}.mp4")
+        subprocess.run([
+            'ffmpeg', '-y', '-i', self.video_source,
+            '-ss', str(start_time), '-to', str(end_time),
+            '-vf', f'scale={self.target_resolution}',
+            '-c:v', 'libx264', '-preset', 'ultrafast',
+            temp_output
+        ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+        # Convert to base64
+        with open(temp_output, 'rb') as f:
+            base64_string = base64.b64encode(f.read()).decode('utf-8')
+
+        # Remove temporary file
+        os.remove(temp_output)
+
+        # Update progress
+        progress = (end_time / self.total_duration) * 100
+        self.progress_bar.n = int(progress)
+        self.progress_bar.refresh()
+
+        self.current_time = end_time
+
+        return {
+            "base64": base64_string,
+            "start_time": start_time,
+            "end_time": end_time
+        }

mixpeek/exceptions.py

@@ -0,0 +1,13 @@
+class MixpeekException(Exception):
+    pass
+
+class AuthenticationError(MixpeekException):
+    pass
+
+class BadRequestError(MixpeekException):
+    pass
+
+class NotFoundError(MixpeekException):
+    pass
+
+# Define more exceptions as needed