mixpeek 0.11.2__py3-none-any.whl → 0.13__py3-none-any.whl

mixpeek/endpoints/collections.py

@@ -1,86 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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, query, model_id=None, filters=None, page=1, page_size=10):
-        try:
-            url = f"{self.base_url}search/text"
-            data = {
-                "query": query,
-                "model_id": model_id,
-                "filters": filters or {},
-                "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 url(self, target_url, model_id=None, filters=None, page=1, page_size=10):
-        try:
-            url = f"{self.base_url}search/url"
-            data = {
-                "url": target_url,
-                "model_id": model_id,
-                "filters": filters or {},
-                "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

@@ -1,26 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

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