mixpeek 0.6.29__py3-none-any.whl → 0.7.0__py3-none-any.whl

mixpeek/client.py

@@ -1,11 +1,10 @@
 import requests
 
-from .endpoints.extract import Extract
 from .endpoints.embed import Embed
-from .endpoints.generate import Generate
-from .endpoints.connections import Connections
+from .endpoints.collections import Collections
+from .endpoints.index import Index
+from .endpoints.search import Search
 from .endpoints.tools import Tools
-from .endpoints.pipelines import Pipelines
 
 
 class Mixpeek:
@@ -16,11 +15,11 @@ class Mixpeek:
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json"
         }
-        self.extract = Extract(self.base_url, self.headers)
+        # these are remote
         self.embed = Embed(self.base_url, self.headers)
-        self.generate = Generate(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)
 
-        # we include api_key as well because the header is different for upload
-        self.connections = Connections(self.base_url, self.headers, self.api_key)
-        self.tools = Tools(self.base_url, self.headers)
-        self.pipelines = Pipelines(self.base_url, self.headers)
+        # tools is all local
+        self.tools = Tools()

mixpeek/endpoints/collections.py

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

@@ -6,45 +6,61 @@ class Embed:
         self.headers = headers
 
     def video(self, model_id: str, input: str, input_type: str):
-        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)
-        return response.json()
+        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):
-        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)
-        return response.json()
+        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):
-        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)
-        return response.json()
+        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):
-        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)
-        return response.json()
+        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
+
+class Index:
+    def __init__(self, base_url, headers):
+        self.base_url = base_url
+        self.headers = headers
+
+    def upload(self, file, collection_id, metadata=None, settings=None):
+        try:
+            url = f"{self.base_url}index/upload"
+            files = {"file": file}
+            data = {
+                "collection_id": collection_id,
+                "metadata": metadata,
+                "settings": settings
+            }
+            response = requests.post(url, files=files, data=data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def url(self, url, collection_id, metadata=None, settings=None):
+        try:
+            url = f"{self.base_url}index/url"
+            data = {
+                "url": url,
+                "collection_id": collection_id,
+                "metadata": metadata,
+                "settings": settings
+            }
+            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 youtube(self, youtube_video_id, collection_id, metadata=None, settings=None):
+        try:
+            url = f"{self.base_url}index/youtube"
+            data = {
+                "youtube_video_id": youtube_video_id,
+                "collection_id": collection_id,
+                "metadata": metadata,
+                "settings": settings
+            }
+            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/search.py

@@ -0,0 +1,60 @@
+import requests
+
+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, filters=None, page=1, page_size=10):
+        try:
+            url = f"{self.base_url}search/upload"
+            files = {"file": file}
+            data = {
+                "filters": filters or "{}",
+                "page": page,
+                "page_size": page_size
+            }
+            response = requests.post(url, files=files, data=data, headers=self.headers)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {"error": str(e)}
+
+    def url(self, url, input_type="file", filters=None, modality="text", page=1, page_size=10):
+        try:
+            url = f"{self.base_url}search/url"
+            data = {
+                "url": url,
+                "input_type": input_type,
+                "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/tools.py

@@ -1,24 +1,106 @@
-import requests
-
+import subprocess
+import tempfile
+import os
+import base64
+from urllib.parse import urlparse
+from urllib.request import urlretrieve
+from tqdm import tqdm
 
 class Tools:
-    def __init__(self, base_url, headers):
-        self.base_url = base_url
-        self.headers = headers
+    def __init__(self):
         self.video = self.Video(self)
 
     class Video:
         def __init__(self, parent):
-            self.base_url = parent.base_url
-            self.headers = parent.headers
-
-        def process(self, url: str, frame_interval: int, resolution: list, return_base64: bool):
-            endpoint = f"{self.base_url}tools/video/process"
-            data = {
-                "url": url,
-                "frame_interval": frame_interval,
-                "resolution": resolution,
-                "return_base64": return_base64
-            }
-            response = requests.post(endpoint, json=data, headers=self.headers)
-            return response.json()
+            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-0.7.0.dist-info/METADATA

@@ -0,0 +1,324 @@
+Metadata-Version: 2.1
+Name: mixpeek
+Version: 0.7.0
+Summary: Mixpeek Python SDK
+Home-page: https://github.com/mixpeek/mixpeek-python
+Author: Ethan Steininger
+Author-email: ethan@mixpeek.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests ==2.32.3
+Requires-Dist: pydantic ==2.7.3
+Requires-Dist: tqdm ==4.66.4
+Requires-Dist: urllib3 ==2.2.1
+
+# Mixpeek Python SDK
+
+This SDK provides easy access to the Mixpeek API for Python developers.
+
+## Installation
+
+```bash
+pip install mixpeek
+```
+
+## Usage
+
+First, import and initialize the Mixpeek client:
+
+```python
+from mixpeek import Mixpeek
+
+client = Mixpeek(api_key="your_api_key_here")
+```
+
+### Embed
+
+The `embed` module provides methods for embedding various types of data.
+
+#### Video Embedding
+
+```python
+response = client.embed.video(model_id="model_id", input="video_data", input_type="base64")
+```
+
+- `model_id` (str): The ID of the model to use for embedding.
+- `input` (str): The video data or URL.
+- `input_type` (str): Either "base64" or "url".
+
+#### Text Embedding
+
+```python
+response = client.embed.text(model_id="model_id", input="text_to_embed", input_type="text")
+```
+
+- `model_id` (str): The ID of the model to use for embedding.
+- `input` (str): The text to embed.
+- `input_type` (str): Should be "text".
+
+#### Image Embedding
+
+```python
+response = client.embed.image(model_id="model_id", input="image_data", input_type="base64")
+```
+
+- `model_id` (str): The ID of the model to use for embedding.
+- `input` (str): The image data or URL.
+- `input_type` (str): Either "base64" or "url".
+
+#### Audio Embedding
+
+```python
+response = client.embed.audio(model_id="model_id", input="audio_data", input_type="base64")
+```
+
+- `model_id` (str): The ID of the model to use for embedding.
+- `input` (str): The audio data or URL.
+- `input_type` (str): Either "base64" or "url".
+
+### Index
+
+The `index` module provides methods for indexing various types of content.
+
+#### Upload File
+
+```python
+with open("file.txt", "rb") as file:
+    response = client.index.upload(file=file, collection_id="collection_id", metadata={"key": "value"}, settings={"video": {"transcribe": True}})
+```
+
+- `file` (file object): The file to upload.
+- `collection_id` (str): The ID of the collection to add the file to.
+- `metadata` (dict, optional): Additional metadata for the file.
+- `settings` (dict, optional): Processing settings for the file.
+
+#### Index URL
+
+```python
+response = client.index.url(url="https://example.com", collection_id="collection_id", metadata={"key": "value"}, settings={"image": {"caption_model_id": "model_id"}})
+```
+
+- `url` (str): The URL to index.
+- `collection_id` (str): The ID of the collection to add the content to.
+- `metadata` (dict, optional): Additional metadata for the content.
+- `settings` (dict, optional): Processing settings for the content.
+
+#### Index YouTube Video
+
+```python
+response = client.index.youtube(youtube_video_id="video_id", collection_id="collection_id", metadata={"key": "value"}, settings={"video": {"transcribe": True}})
+```
+
+- `youtube_video_id` (str): The ID of the YouTube video to index.
+- `collection_id` (str): The ID of the collection to add the video to.
+- `metadata` (dict, optional): Additional metadata for the video.
+- `settings` (dict, optional): Processing settings for the video.
+
+#### Search YouTube
+
+```python
+response = client.index.youtube_search(query="search query", collection_id="collection_id", max_results=20, metadata={"key": "value"}, shorts_only=False)
+```
+
+- `query` (str): The search query for YouTube videos.
+- `collection_id` (str): The ID of the collection to add the search results to.
+- `max_results` (int, optional): Maximum number of results to return (default: 10, max: 500).
+- `metadata` (dict, optional): Additional metadata for the search results.
+- `shorts_only` (bool, optional): Whether to search for YouTube Shorts only (default: False).
+
+### Search
+
+The `search` module provides methods for searching indexed content.
+
+#### Text Search
+
+```python
+response = client.search.text(input="search query", modality="text", input_type="text", filters={"key": "value"}, group_by_file=True, page=1, page_size=10)
+```
+
+- `input` (str): The search query or input data.
+- `modality` (str): The modality of the search (e.g., "text", "image", "video", "audio").
+- `input_type` (str, optional): The type of input (default: "text").
+- `filters` (dict, optional): Additional filters for the search.
+- `group_by_file` (bool, optional): Whether to group results by file (default: True).
+- `page` (int, optional): The page number for pagination (default: 1).
+- `page_size` (int, optional): The number of results per page (default: 10).
+
+#### Upload Search
+
+```python
+with open("query_image.jpg", "rb") as file:
+    response = client.search.upload(file=file, filters={"key": "value"}, page=1, page_size=10)
+```
+
+- `file` (file object): The file to use as a search query.
+- `filters` (dict, optional): Additional filters for the search.
+- `page` (int, optional): The page number for pagination (default: 1).
+- `page_size` (int, optional): The number of results per page (default: 10).
+
+#### URL Search
+
+```python
+response = client.search.url(url="https://example.com/image.jpg", input_type="file", filters={"key": "value"}, modality="image", page=1, page_size=10)
+```
+
+- `url` (str): The URL of the file to use as a search query.
+- `input_type` (str, optional): The type of input (default: "file").
+- `filters` (dict, optional): Additional filters for the search.
+- `modality` (str, optional): The modality of the search (default: "text").
+- `page` (int, optional): The page number for pagination (default: 1).
+- `page_size` (int, optional): The number of results per page (default: 10).
+
+### Collections
+
+The `collections` module provides methods for managing collections and files.
+
+#### List Files
+
+```python
+response = client.collections.list_files(collection_id="collection_id", randomize=False, page=1, page_size=10, filters={"key": "value"}, sort_by="created_at", sort_order="desc")
+```
+
+- `collection_id` (str): The ID of the collection to list files from.
+- `randomize` (bool, optional): Whether to randomize the results (default: False).
+- `page` (int, optional): The page number for pagination (default: 1).
+- `page_size` (int, optional): The number of results per page (default: 10).
+- `filters` (dict, optional): Additional filters for the file list.
+- `sort_by` (str, optional): The field to sort by.
+- `sort_order` (str, optional): The sort order, either "asc" or "desc" (default: "asc").
+
+#### List Collections
+
+```python
+response = client.collections.list_collections()
+```
+
+#### Search Files
+
+```python
+response = client.collections.search_files(query="search query", collection_id="collection_id", page=1, page_size=10, sort_by="relevance", sort_order="desc")
+```
+
+- `query` (str): The search query for files within the collection.
+- `collection_id` (str): The ID of the collection to search in.
+- `page` (int, optional): The page number for pagination (default: 1).
+- `page_size` (int, optional): The number of results per page (default: 10).
+- `sort_by` (str, optional): The field to sort by.
+- `sort_order` (str, optional): The sort order, either "asc" or "desc" (default: "asc").
+
+#### Get File by ID
+
+```python
+response = client.collections.get_file_by_id(file_id="file_id")
+```
+
+- `file_id` (str): The ID of the file to retrieve.
+
+#### Delete File by ID
+
+```python
+response = client.collections.delete_file_by_id(file_id="file_id")
+```
+
+- `file_id` (str): The ID of the file to delete.
+
+#### Delete Collection
+
+```python
+response = client.collections.delete_collection(collection_id="collection_id")
+```
+
+- `collection_id` (str): The ID of the collection to delete.
+
+Certainly! I'll update the README to include information about the `tools` service, specifically the video processing functionality. Here's the addition to the README:
+
+### Tools
+
+The `tools` module provides utility functions for processing various types of data before embedding or indexing.
+
+#### Video Processing
+
+The `video` tool allows you to process video files or URLs into chunks for easier embedding.
+
+```python
+from mixpeek import Mixpeek
+
+mixpeek = Mixpeek('your_api_key_here')
+
+video_url = "https://example.com/video.mp4"
+
+# Process video chunks, this runs locally
+processed_chunks = mixpeek.tools.video.process(
+    video_source=video_url,
+    chunk_interval=1,
+    resolution=[720, 1280]
+)
+
+# Embed each chunk
+results = []
+for index, chunk in enumerate(processed_chunks):
+    print(f"Processing video chunk: {index}")
+
+    embedding = mixpeek.embed.video(
+        model_id="vuse-generic-v1",
+        input=chunk['base64_chunk'],
+        input_type="base64"
+    )['embedding']
+
+    result = {
+        "start_time": chunk["start_time"],
+        "end_time": chunk["end_time"],
+        "embedding": embedding
+    }
+    results.append(result)
+    print(f"  Embedding preview: {embedding[:5] + ['...'] + embedding[-5:]}")
+    print("Insert into DB here")
+
+print(f"Processed {len(results)} chunks")
+```
+
+Parameters for `mixpeek.tools.video.process`:
+
+- `video_source` (str): URL or file path of the video to process.
+- `chunk_interval` (float): Duration of each video chunk in seconds.
+- `resolution` (list): Desired resolution of the video chunks as [height, width].
+
+The `process` method returns a list of dictionaries, each containing:
+
+- `start_time` (float): Start time of the chunk in seconds.
+- `end_time` (float): End time of the chunk in seconds.
+- `base64_chunk` (str): Base64-encoded video chunk.
+
+This tool is particularly useful when you need to embed long videos, as it allows you to process the video in smaller chunks and embed each chunk separately.
+
+## Response Format
+
+All methods return a JSON response. In case of an error, the response will contain an "error" key with a description of the error.
+
+## Error Handling
+
+The SDK handles HTTP errors and returns them in the response. You should always check for the presence of an "error" key in the response before processing the results.
+
+```python
+response = client.embed.text(model_id="model_id", input="text_to_embed", input_type="text")
+if "error" in response:
+    print(f"An error occurred: {response['error']}")
+else:
+    # Process the successful response
+    print(response)
+```
+
+## Rate Limiting
+
+The Mixpeek API may have rate limits. If you encounter rate limiting errors, you should implement appropriate backoff and retry logic in your application.
+
+## Support
+
+For any issues or questions, please contact Mixpeek support or refer to the official API documentation.
+
+```
+
+```

mixpeek-0.7.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+mixpeek/__init__.py,sha256=XDdcK7wTEOEcF1cp-GeWmgPJ21Ny1R9pB0PPNrdDTMo,28
+mixpeek/client.py,sha256=JFQO-hLFe7MESdkNoweuoaGrc4Vnqtl55_JRvgDCspg,804
+mixpeek/exceptions.py,sha256=Orhdo5UFLn3fcWVJtlgkznW8Iy5ndL96h0qTY8zOlDA,235
+mixpeek/endpoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mixpeek/endpoints/collections.py,sha256=ffOBenNHG-mVpjT7kQcOfn78-wjgjdQTVyrloyeAy90,2890
+mixpeek/endpoints/embed.py,sha256=ybDqyIt0oJiwIdH1QSwuV-CPeJgd-zW0etNAcBdgZYE,2290
+mixpeek/endpoints/index.py,sha256=2WcjrRHCMqqj0ddWEkl1f5U81Ni9xKySC1_sdkrhnhM,1857
+mixpeek/endpoints/search.py,sha256=fp78miF5bSWTiQn32NMoth9mlLBsj7NfjNzS6HrEz3Q,2170
+mixpeek/endpoints/tools.py,sha256=QH3X0tYKr-W_9ApENgP7PeuLJi7Qr9W2jrrgQFH4F2A,3567
+mixpeek-0.7.0.dist-info/METADATA,sha256=kmaWlwIRerVhl4H_6cZHyvE8Kek6S4uNy5V8YDkDqhk,10754
+mixpeek-0.7.0.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+mixpeek-0.7.0.dist-info/top_level.txt,sha256=EJ8Jc4IhqyUwnUlBwKbs498Ju4O9a-IDh2kXc_lo6Vg,8
+mixpeek-0.7.0.dist-info/RECORD,,

{mixpeek-0.6.29.dist-info → mixpeek-0.7.0.dist-info}/WHEEL

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

mixpeek/endpoints/connections.py

@@ -1,71 +0,0 @@
-import requests
-import os
-
-class Connections:
-    def __init__(self, base_url, headers, api_key):
-        self.base_url = base_url
-        self.headers = headers
-        self.api_key = api_key
-        self.data = self.Data(self)
-        self.storage = self.Storage(self)
-
-    def create(self, alias: str, engine: str, details: dict):
-        url = f"{self.base_url}connections/"
-        data = {
-            "alias": alias,
-            "engine": engine,
-            "details": details
-        }
-        response = requests.post(url, json=data, headers=self.headers)
-        return response.json()
-
-    class Data:
-        def __init__(self, parent):
-            self.base_url = parent.base_url
-            self.headers = parent.headers
-        
-        # mixpeek.connections.data.insert(connection_id="123", payload={"key": "value"})
-        def insert(self, connection_id: str, payload: list):
-            pass
-
-        # mixpeek.connections.data.delete(connection_id="123", filters={"key": "value"})
-        def delete(self, connection_id: str, filters: dict):
-            pass
-
-        # mixpeek.connections.data.upsert(connection_id="123", payload={"key": "value"}, filters={"key": "value"})
-        def upsert(self, connection_id: str, payload: dict, filters: dict):
-            pass
-
-        
-    class Storage:
-        def __init__(self, parent):
-            self.base_url = parent.base_url
-            self.headers = parent.headers
-            self.api_key = parent.api_key
-
-        def upload(self, connection_id: str, file_path: str, prefix: str = None):
-            url = f"{self.base_url}connections/storage?connection_id={connection_id}"
-            if prefix:
-                url += f"&prefix={prefix}"
-
-            files=[
-                ('file',(os.path.basename(file_path),open(file_path,'rb'),'application/octet-stream'))
-            ]
-            headers = {
-                'Authorization': f'Bearer {self.api_key}'
-            }
-
-            response = requests.request("POST", url, headers=headers, files=files)
-
-            return response.json()
-
-
-        # mixpeek.connections.storage.delete(connection_id="123", file_name="example.txt")
-        def delete(self, connection_id: str, file_name: str):
-            url = f"{self.base_url}storage/{connection_id}/delete/{file_name}"
-            response = requests.delete(url, headers=self.headers)
-            return response.json()
-
-
-            
-        

mixpeek/endpoints/extract.py

@@ -1,55 +0,0 @@
-import requests
-
-class Extract:
-    def __init__(self, base_url, headers):
-        self.base_url = base_url
-        self.headers = headers
-
-    def automatic(self, input: str, input_type: str):
-        url = f"{self.base_url}extract/"
-        data = {
-            "input": input,
-            "input_type": input_type
-        }
-        response = requests.post(url, json=data, headers=self.headers)
-        return response.json()
-
-    def video(self, input: str, input_type: str):
-        url = f"{self.base_url}extract/"
-        data = {
-            "modality": "video",
-            "input": input,
-            "input_type": input_type
-        }
-        response = requests.post(url, json=data, headers=self.headers)
-        return response.json()
-    
-    def audio(self, input: str, input_type: str):
-        url = f"{self.base_url}extract/"
-        data = {
-            "modality": "audio",
-            "input": input,
-            "input_type": input_type
-        }
-        response = requests.post(url, json=data, headers=self.headers)
-        return response.json()
-
-    def image(self, input: str, input_type: str):
-        url = f"{self.base_url}extract/"
-        data = {
-            "modality": "image",
-            "input": input,
-            "input_type": input_type
-        }
-        response = requests.post(url, json=data, headers=self.headers)
-        return response.json()
-
-    def text(self, input: str, input_type: str):
-        url = f"{self.base_url}extract/"
-        data = {
-            "modality": "text",
-            "input": input,
-            "input_type": input_type
-        }
-        response = requests.post(url, json=data, headers=self.headers)
-        return response.json()

mixpeek/endpoints/generate.py

@@ -1,17 +0,0 @@
-import requests
-from pydantic import BaseModel
-
-class Generate:
-    def __init__(self, base_url, headers):
-        self.base_url = base_url
-        self.headers = headers
-
-    def text(self, model_id: str, response_format: BaseModel, context: str):
-        url = f"{self.base_url}generate/text"
-        data = {
-            "model_id": model_id,
-            "response_format": response_format.schema_json(),  # Ensure correct method to get JSON schema
-            "context": context
-        }
-        response = requests.post(url, json=data, headers=self.headers)
-        return response.json()

mixpeek/endpoints/pipelines.py

@@ -1,37 +0,0 @@
-import requests
-
-class Pipelines:
-    def __init__(self, base_url, headers):
-        self.base_url = base_url
-        self.headers = headers
-
-    # mixpeek.pipelines.enable
-    def enable(self, pipeline_id: str, enable: bool):
-        url = f"{self.base_url}pipelines/{pipeline_id}/enable"
-        data = {
-            "enable": enable
-        }
-        response = requests.patch(url, json=data, headers=self.headers)
-        return response.json()
-
-    # mixpeek.pipelines.create
-    def create(self, alias: str, code: str, destination: dict, source: dict):
-        url = f"{self.base_url}pipelines/"
-        data = {
-            "alias": alias,
-            "code": code,
-            "destination": destination,
-            "source": source
-        }
-        response = requests.post(url, json=data, headers=self.headers)
-        return response.json()
-
-    # mixpeek.pipelines.invoke
-    def invoke(self, pipeline_id: str, payload: dict, options: dict):
-        url = f"{self.base_url}pipelines/invoke/{pipeline_id}"
-        data = {
-            "payload": payload,
-            "options": options
-        }
-        response = requests.post(url, json=data, headers=self.headers)
-        return response.json()

mixpeek-0.6.29.dist-info/METADATA

@@ -1,122 +0,0 @@
-Metadata-Version: 2.1
-Name: mixpeek
-Version: 0.6.29
-Summary: Mixpeek Python SDK
-Home-page: https://github.com/mixpeek/mixpeek-python
-Author: Ethan Steininger
-Author-email: ethan@mixpeek.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: requests ==2.32.3
-Requires-Dist: pydantic ==2.7.3
-
-# Mixpeek SDK
-
-A Python SDK for the Mixpeek API.
-
-## Installation
-
-```bash
-pip install mixpeek
-```
-
-## Usage
-
-```python
-from mixpeek import Mixpeek
-from pydantic import BaseModel
-
-mixpeek = Mixpeek("YOUR_API_KEY")
-
-```
-
-### Extract
-
-```python
-extraction = mixpeek.extract.text(
-    input="s3://document.pdf",
-    input_type="url"
-)
-```
-
-### Embed
-
-```python
-embedding = mixpeek.embed.video(
-    model_id="mixpeek/vuse-generic-v1",
-    input="s3://waving_boy.mp4",
-    input_type="url"
-)
-```
-
-### Generate
-
-```python
-class ResponseFormat(BaseModel):
-    city: int
-    weather: float
-
-generated_content = mixpeek.generate.text(
-    model_id="openai/gpt-4-turbo",
-    response_format=ResponseFormat,
-    context="Please tell me the weather and make sure to respond in the provided JSON schema"
-)
-```
-
-### Connections
-
-Create connection
-
-```python
-mixpeek.connections.create(
-    alias="my-mongo-test",
-    engine="mongodb",
-    details={
-        "host": "your_host_address",
-        "database": "your_database_name",
-        "username": "your_username",
-        "password": "your_password"
-    }
-)
-```
-
-Insert data
-
-```python
-mixpeek.connections.data.insert(
-    connection_id="conn_123",
-    payload={}
-)
-```
-
-Insert data
-
-```python
-mixpeek.connections.data.delete(
-    connection_id="conn_321"
-    filters={}
-)
-```
-
-Upload file
-
-```python
-mixpeek.connections.storage.upload(
-    connection_id="conn_321",
-    file_path="/my/local/file.mp4"
-)
-```
-
-### Tools
-
-```python
-response = mixpeek.tools.video.process(
-    url="https://s3/video.mp4",
-    frame_interval=5,
-    resolution=[720, 1280],
-    return_base64=True
-)
-```

mixpeek-0.6.29.dist-info/RECORD

@@ -1,14 +0,0 @@
-mixpeek/__init__.py,sha256=XDdcK7wTEOEcF1cp-GeWmgPJ21Ny1R9pB0PPNrdDTMo,28
-mixpeek/client.py,sha256=ifN-rCXtCbitTj6coUquQjpHgd98V3EVwORzNo8tIMY,992
-mixpeek/exceptions.py,sha256=Orhdo5UFLn3fcWVJtlgkznW8Iy5ndL96h0qTY8zOlDA,235
-mixpeek/endpoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mixpeek/endpoints/connections.py,sha256=S9_328Kk3dXO4icyKPBTlAd7M83lmD4hG2fFtKjfAwQ,2430
-mixpeek/endpoints/embed.py,sha256=8ds_FinxZRW-ZQyv6LjDAX6Zoek2Cv4OYhwIgSBqwTs,1598
-mixpeek/endpoints/extract.py,sha256=PRY1ZjPPwJ3xEKNKVdWIm_WZeRNc68oJKcwVXNkv-S8,1706
-mixpeek/endpoints/generate.py,sha256=SFjVYfgeuIt4wO0I5ItnB4TEHhRkLgZOvQfWlEioye8,594
-mixpeek/endpoints/pipelines.py,sha256=X2mRsWgOx6FgWbInrAdjLQJbjXjorNqAo9mjFawLpoE,1210
-mixpeek/endpoints/tools.py,sha256=Ni9AYm2-jpDS1SLUohNLTOkXDUxLPnNLpTlhWJLfofs,791
-mixpeek-0.6.29.dist-info/METADATA,sha256=nZ9ZirutvyKfp5gg0C_fdUDAOuNbUO09k_TPLg68zaw,2083
-mixpeek-0.6.29.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-mixpeek-0.6.29.dist-info/top_level.txt,sha256=EJ8Jc4IhqyUwnUlBwKbs498Ju4O9a-IDh2kXc_lo6Vg,8
-mixpeek-0.6.29.dist-info/RECORD,,