inferencesh 0.4.1__tar.gz → 0.4.2__tar.gz

{inferencesh-0.4.1/src/inferencesh.egg-info → inferencesh-0.4.2}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.4
 Name: inferencesh
-Version: 0.4.1
+Version: 0.4.2
 Summary: inference.sh Python SDK
-Author: Inference Shell Inc.
 Author-email: "Inference Shell Inc." <hello@inference.sh>
 Project-URL: Homepage, https://github.com/inference-sh/sdk
 Project-URL: Bug Tracker, https://github.com/inference-sh/sdk/issues
@@ -21,9 +20,7 @@ Requires-Dist: pytest-cov>=4.0.0; extra == "test"
 Provides-Extra: async
 Requires-Dist: aiohttp>=3.9.0; python_version >= "3.8" and extra == "async"
 Requires-Dist: aiofiles>=23.2.1; python_version >= "3.8" and extra == "async"
-Dynamic: author
 Dynamic: license-file
-Dynamic: requires-python
 
 # inference.sh sdk
 
@@ -38,47 +35,91 @@ pip install infsh
 ## client usage
 
 ```python
-from infsh import Inference, TaskStatus
+from inferencesh import Inference, TaskStatus
 
-# create client
+# Create client
 client = Inference(api_key="your-api-key")
 
-# simple usage - wait for result
-result = client.run({
-    "app": "your-app",
-    "input": {"key": "value"},
-    "variant": "default"
-})
-print(f"output: {result['output']}")
-
-# get task info without waiting
-task = client.run(params, wait=False)
-print(f"task id: {task['id']}")
-
-# stream updates (recommended)
-for update in client.run(params, stream=True):
-    status = update.get("status")
-    print(f"status: {TaskStatus(status).name}")
+# Simple synchronous usage
+try:
+    task = client.run({
+        "app": "your-app",
+        "input": {"key": "value"},
+        "infra": "cloud",
+        "variant": "default"
+    })
     
-    if status == TaskStatus.COMPLETED:
-        print(f"output: {update.get('output')}")
-        break
-    elif status == TaskStatus.FAILED:
-        print(f"error: {update.get('error')}")
-        break
-
-# async support
+    print(f"Task ID: {task.get('id')}")
+
+    if task.get("status") == TaskStatus.COMPLETED:
+        print("✓ Task completed successfully!")
+        print(f"Output: {task.get('output')}")
+    else:
+        status = task.get("status")
+        status_name = TaskStatus(status).name if status is not None else "UNKNOWN"
+        print(f"✗ Task did not complete. Final status: {status_name}")
+
+except Exception as exc:
+    print(f"Error: {type(exc).__name__}: {exc}")
+    raise  # Re-raise to see full traceback
+
+# Streaming updates (recommended)
+try:
+    for update in client.run(
+        {
+            "app": "your-app",
+            "input": {"key": "value"},
+            "infra": "cloud",
+            "variant": "default"
+        },
+        stream=True  # Enable streaming updates
+    ):
+        status = update.get("status")
+        status_name = TaskStatus(status).name if status is not None else "UNKNOWN"
+        print(f"Status: {status_name}")
+        
+        if status == TaskStatus.COMPLETED:
+            print("✓ Task completed!")
+            print(f"Output: {update.get('output')}")
+            break
+        elif status == TaskStatus.FAILED:
+            print(f"✗ Task failed: {update.get('error')}")
+            break
+        elif status == TaskStatus.CANCELLED:
+            print("✗ Task was cancelled")
+            break
+
+except Exception as exc:
+    print(f"Error: {type(exc).__name__}: {exc}")
+    raise  # Re-raise to see full traceback
+
+# Async support
 async def run_async():
-    from infsh import AsyncInference
+    from inferencesh import AsyncInference
     
     client = AsyncInference(api_key="your-api-key")
     
-    # simple usage
-    result = await client.run(params)
+    # Simple usage
+    result = await client.run({
+        "app": "your-app",
+        "input": {"key": "value"},
+        "infra": "cloud",
+        "variant": "default"
+    })
     
-    # stream updates
-    async for update in await client.run(params, stream=True):
-        print(f"status: {TaskStatus(update['status']).name}")
+    # Stream updates
+    async for update in await client.run(
+        {
+            "app": "your-app",
+            "input": {"key": "value"},
+            "infra": "cloud",
+            "variant": "default"
+        },
+        stream=True
+    ):
+        status = update.get("status")
+        status_name = TaskStatus(status).name if status is not None else "UNKNOWN"
+        print(f"Status: {status_name}")
 ```
 
 ## file handling

inferencesh-0.4.2/README.md

@@ -0,0 +1,172 @@
+# inference.sh sdk
+
+helper package for inference.sh python applications.
+
+## installation
+
+```bash
+pip install infsh
+```
+
+## client usage
+
+```python
+from inferencesh import Inference, TaskStatus
+
+# Create client
+client = Inference(api_key="your-api-key")
+
+# Simple synchronous usage
+try:
+    task = client.run({
+        "app": "your-app",
+        "input": {"key": "value"},
+        "infra": "cloud",
+        "variant": "default"
+    })
+    
+    print(f"Task ID: {task.get('id')}")
+
+    if task.get("status") == TaskStatus.COMPLETED:
+        print("✓ Task completed successfully!")
+        print(f"Output: {task.get('output')}")
+    else:
+        status = task.get("status")
+        status_name = TaskStatus(status).name if status is not None else "UNKNOWN"
+        print(f"✗ Task did not complete. Final status: {status_name}")
+
+except Exception as exc:
+    print(f"Error: {type(exc).__name__}: {exc}")
+    raise  # Re-raise to see full traceback
+
+# Streaming updates (recommended)
+try:
+    for update in client.run(
+        {
+            "app": "your-app",
+            "input": {"key": "value"},
+            "infra": "cloud",
+            "variant": "default"
+        },
+        stream=True  # Enable streaming updates
+    ):
+        status = update.get("status")
+        status_name = TaskStatus(status).name if status is not None else "UNKNOWN"
+        print(f"Status: {status_name}")
+        
+        if status == TaskStatus.COMPLETED:
+            print("✓ Task completed!")
+            print(f"Output: {update.get('output')}")
+            break
+        elif status == TaskStatus.FAILED:
+            print(f"✗ Task failed: {update.get('error')}")
+            break
+        elif status == TaskStatus.CANCELLED:
+            print("✗ Task was cancelled")
+            break
+
+except Exception as exc:
+    print(f"Error: {type(exc).__name__}: {exc}")
+    raise  # Re-raise to see full traceback
+
+# Async support
+async def run_async():
+    from inferencesh import AsyncInference
+    
+    client = AsyncInference(api_key="your-api-key")
+    
+    # Simple usage
+    result = await client.run({
+        "app": "your-app",
+        "input": {"key": "value"},
+        "infra": "cloud",
+        "variant": "default"
+    })
+    
+    # Stream updates
+    async for update in await client.run(
+        {
+            "app": "your-app",
+            "input": {"key": "value"},
+            "infra": "cloud",
+            "variant": "default"
+        },
+        stream=True
+    ):
+        status = update.get("status")
+        status_name = TaskStatus(status).name if status is not None else "UNKNOWN"
+        print(f"Status: {status_name}")
+```
+
+## file handling
+
+the `File` class provides a standardized way to handle files in the inference.sh ecosystem:
+
+```python
+from infsh import File
+
+# Basic file creation
+file = File(path="/path/to/file.png")
+
+# File with explicit metadata
+file = File(
+    path="/path/to/file.png",
+    content_type="image/png",
+    filename="custom_name.png",
+    size=1024  # in bytes
+)
+
+# Create from path (automatically populates metadata)
+file = File.from_path("/path/to/file.png")
+
+# Check if file exists
+exists = file.exists()
+
+# Access file metadata
+print(file.content_type)  # automatically detected if not specified
+print(file.size)       # file size in bytes
+print(file.filename)   # basename of the file
+
+# Refresh metadata (useful if file has changed)
+file.refresh_metadata()
+```
+
+the `File` class automatically handles:
+- mime type detection
+- file size calculation
+- filename extraction from path
+- file existence checking
+
+## creating an app
+
+to create an inference app, inherit from `BaseApp` and define your input/output types:
+
+```python
+from infsh import BaseApp, BaseAppInput, BaseAppOutput, File
+
+class AppInput(BaseAppInput):
+    image: str  # URL or file path to image
+    mask: str   # URL or file path to mask
+
+class AppOutput(BaseAppOutput):
+    image: File
+
+class MyApp(BaseApp):
+    async def setup(self):
+        # Initialize your model here
+        pass
+
+    async def run(self, app_input: AppInput) -> AppOutput:
+        # Process input and return output
+        result_path = "/tmp/result.png"
+        return AppOutput(image=File(path=result_path))
+
+    async def unload(self):
+        # Clean up resources
+        pass
+```
+
+app lifecycle has three main methods:
+- `setup()`: called when the app starts, use it to initialize models
+- `run()`: called for each inference request
+- `unload()`: called when shutting down, use it to free resources

{inferencesh-0.4.1 → inferencesh-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inferencesh"
-version = "0.4.1"
+version = "0.4.2"
 description = "inference.sh Python SDK"
 authors = [
     {name = "Inference Shell Inc.", email = "hello@inference.sh"},

{inferencesh-0.4.1 → inferencesh-0.4.2}/src/inferencesh/models/file.py

@@ -4,7 +4,6 @@ import mimetypes
 import os
 import urllib.request
 import urllib.parse
-import tempfile
 import hashlib
 from pathlib import Path
 from tqdm import tqdm
@@ -119,12 +118,10 @@ class File(BaseModel):
             return
             
         print(f"Downloading URL: {original_url} to {cache_path}")
-        tmp_file = None
         try:
-            # Download to temporary file first to avoid partial downloads in cache
-            suffix = os.path.splitext(urllib.parse.urlparse(original_url).path)[1]
-            tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
-            self._tmp_path = tmp_file.name
+            # Download to a temporary filename in the final directory
+            tmp_path = str(cache_path) + '.tmp'
+            self._tmp_path = tmp_path
             
             # Set up request with user agent
             headers = {
@@ -176,8 +173,8 @@ class File(BaseModel):
                                     # If we read the whole body at once, exit loop
                                     break
                             
-                # Move the temporary file to the cache location
-                os.replace(self._tmp_path, cache_path)
+                # Rename the temporary file to the final name
+                os.rename(self._tmp_path, cache_path)
                 self._tmp_path = None  # Prevent deletion in __del__
                 self.path = str(cache_path)
             except (urllib.error.URLError, urllib.error.HTTPError) as e:
@@ -186,7 +183,7 @@ class File(BaseModel):
                 raise RuntimeError(f"Failed to write downloaded file to {self._tmp_path}: {str(e)}")
         except Exception as e:
             # Clean up temp file if something went wrong
-            if tmp_file is not None and hasattr(self, '_tmp_path'):
+            if hasattr(self, '_tmp_path') and self._tmp_path:
                 try:
                     os.unlink(self._tmp_path)
                 except (OSError, IOError):

{inferencesh-0.4.1 → inferencesh-0.4.2/src/inferencesh.egg-info}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.4
 Name: inferencesh
-Version: 0.4.1
+Version: 0.4.2
 Summary: inference.sh Python SDK
-Author: Inference Shell Inc.
 Author-email: "Inference Shell Inc." <hello@inference.sh>
 Project-URL: Homepage, https://github.com/inference-sh/sdk
 Project-URL: Bug Tracker, https://github.com/inference-sh/sdk/issues
@@ -21,9 +20,7 @@ Requires-Dist: pytest-cov>=4.0.0; extra == "test"
 Provides-Extra: async
 Requires-Dist: aiohttp>=3.9.0; python_version >= "3.8" and extra == "async"
 Requires-Dist: aiofiles>=23.2.1; python_version >= "3.8" and extra == "async"
-Dynamic: author
 Dynamic: license-file
-Dynamic: requires-python
 
 # inference.sh sdk
 
@@ -38,47 +35,91 @@ pip install infsh
 ## client usage
 
 ```python
-from infsh import Inference, TaskStatus
+from inferencesh import Inference, TaskStatus
 
-# create client
+# Create client
 client = Inference(api_key="your-api-key")
 
-# simple usage - wait for result
-result = client.run({
-    "app": "your-app",
-    "input": {"key": "value"},
-    "variant": "default"
-})
-print(f"output: {result['output']}")
-
-# get task info without waiting
-task = client.run(params, wait=False)
-print(f"task id: {task['id']}")
-
-# stream updates (recommended)
-for update in client.run(params, stream=True):
-    status = update.get("status")
-    print(f"status: {TaskStatus(status).name}")
+# Simple synchronous usage
+try:
+    task = client.run({
+        "app": "your-app",
+        "input": {"key": "value"},
+        "infra": "cloud",
+        "variant": "default"
+    })
     
-    if status == TaskStatus.COMPLETED:
-        print(f"output: {update.get('output')}")
-        break
-    elif status == TaskStatus.FAILED:
-        print(f"error: {update.get('error')}")
-        break
-
-# async support
+    print(f"Task ID: {task.get('id')}")
+
+    if task.get("status") == TaskStatus.COMPLETED:
+        print("✓ Task completed successfully!")
+        print(f"Output: {task.get('output')}")
+    else:
+        status = task.get("status")
+        status_name = TaskStatus(status).name if status is not None else "UNKNOWN"
+        print(f"✗ Task did not complete. Final status: {status_name}")
+
+except Exception as exc:
+    print(f"Error: {type(exc).__name__}: {exc}")
+    raise  # Re-raise to see full traceback
+
+# Streaming updates (recommended)
+try:
+    for update in client.run(
+        {
+            "app": "your-app",
+            "input": {"key": "value"},
+            "infra": "cloud",
+            "variant": "default"
+        },
+        stream=True  # Enable streaming updates
+    ):
+        status = update.get("status")
+        status_name = TaskStatus(status).name if status is not None else "UNKNOWN"
+        print(f"Status: {status_name}")
+        
+        if status == TaskStatus.COMPLETED:
+            print("✓ Task completed!")
+            print(f"Output: {update.get('output')}")
+            break
+        elif status == TaskStatus.FAILED:
+            print(f"✗ Task failed: {update.get('error')}")
+            break
+        elif status == TaskStatus.CANCELLED:
+            print("✗ Task was cancelled")
+            break
+
+except Exception as exc:
+    print(f"Error: {type(exc).__name__}: {exc}")
+    raise  # Re-raise to see full traceback
+
+# Async support
 async def run_async():
-    from infsh import AsyncInference
+    from inferencesh import AsyncInference
     
     client = AsyncInference(api_key="your-api-key")
     
-    # simple usage
-    result = await client.run(params)
+    # Simple usage
+    result = await client.run({
+        "app": "your-app",
+        "input": {"key": "value"},
+        "infra": "cloud",
+        "variant": "default"
+    })
     
-    # stream updates
-    async for update in await client.run(params, stream=True):
-        print(f"status: {TaskStatus(update['status']).name}")
+    # Stream updates
+    async for update in await client.run(
+        {
+            "app": "your-app",
+            "input": {"key": "value"},
+            "infra": "cloud",
+            "variant": "default"
+        },
+        stream=True
+    ):
+        status = update.get("status")
+        status_name = TaskStatus(status).name if status is not None else "UNKNOWN"
+        print(f"Status: {status_name}")
 ```
 
 ## file handling

{inferencesh-0.4.1 → inferencesh-0.4.2}/src/inferencesh.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE
 README.md
 pyproject.toml
-setup.py
 src/inferencesh/__init__.py
 src/inferencesh/client.py
 src/inferencesh.egg-info/PKG-INFO

inferencesh-0.4.1/README.md

@@ -1,128 +0,0 @@
-# inference.sh sdk
-
-helper package for inference.sh python applications.
-
-## installation
-
-```bash
-pip install infsh
-```
-
-## client usage
-
-```python
-from infsh import Inference, TaskStatus
-
-# create client
-client = Inference(api_key="your-api-key")
-
-# simple usage - wait for result
-result = client.run({
-    "app": "your-app",
-    "input": {"key": "value"},
-    "variant": "default"
-})
-print(f"output: {result['output']}")
-
-# get task info without waiting
-task = client.run(params, wait=False)
-print(f"task id: {task['id']}")
-
-# stream updates (recommended)
-for update in client.run(params, stream=True):
-    status = update.get("status")
-    print(f"status: {TaskStatus(status).name}")
-    
-    if status == TaskStatus.COMPLETED:
-        print(f"output: {update.get('output')}")
-        break
-    elif status == TaskStatus.FAILED:
-        print(f"error: {update.get('error')}")
-        break
-
-# async support
-async def run_async():
-    from infsh import AsyncInference
-    
-    client = AsyncInference(api_key="your-api-key")
-    
-    # simple usage
-    result = await client.run(params)
-    
-    # stream updates
-    async for update in await client.run(params, stream=True):
-        print(f"status: {TaskStatus(update['status']).name}")
-```
-
-## file handling
-
-the `File` class provides a standardized way to handle files in the inference.sh ecosystem:
-
-```python
-from infsh import File
-
-# Basic file creation
-file = File(path="/path/to/file.png")
-
-# File with explicit metadata
-file = File(
-    path="/path/to/file.png",
-    content_type="image/png",
-    filename="custom_name.png",
-    size=1024  # in bytes
-)
-
-# Create from path (automatically populates metadata)
-file = File.from_path("/path/to/file.png")
-
-# Check if file exists
-exists = file.exists()
-
-# Access file metadata
-print(file.content_type)  # automatically detected if not specified
-print(file.size)       # file size in bytes
-print(file.filename)   # basename of the file
-
-# Refresh metadata (useful if file has changed)
-file.refresh_metadata()
-```
-
-the `File` class automatically handles:
-- mime type detection
-- file size calculation
-- filename extraction from path
-- file existence checking
-
-## creating an app
-
-to create an inference app, inherit from `BaseApp` and define your input/output types:
-
-```python
-from infsh import BaseApp, BaseAppInput, BaseAppOutput, File
-
-class AppInput(BaseAppInput):
-    image: str  # URL or file path to image
-    mask: str   # URL or file path to mask
-
-class AppOutput(BaseAppOutput):
-    image: File
-
-class MyApp(BaseApp):
-    async def setup(self):
-        # Initialize your model here
-        pass
-
-    async def run(self, app_input: AppInput) -> AppOutput:
-        # Process input and return output
-        result_path = "/tmp/result.png"
-        return AppOutput(image=File(path=result_path))
-
-    async def unload(self):
-        # Clean up resources
-        pass
-```
-
-app lifecycle has three main methods:
-- `setup()`: called when the app starts, use it to initialize models
-- `run()`: called for each inference request
-- `unload()`: called when shutting down, use it to free resources

inferencesh-0.4.1/setup.py

@@ -1,22 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="inferencesh",
-    version="0.1.2",
-    description="inference.sh Python SDK",
-    author="Inference Shell Inc.",
-    author_email="hello@inference.sh",
-    packages=find_packages(where="src"),
-    package_dir={"": "src"},
-    install_requires=[
-        "pydantic>=2.0.0",
-        "tqdm>=4.67.0",
-        "requests>=2.31.0",
-    ],
-    python_requires=">=3.7",
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ],
-)