init

Author: okaris

.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+      run: |
+        python -m build
+        twine upload dist/*

.gitignore

@@ -0,0 +1,49 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.env/
+.venv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Test coverage
+.coverage
+htmlcov/
+coverage.xml
+.pytest_cache/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Distribution
+dist/
+build/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Inference Shell Inc.
+
+This software is licensed for use only in conjunction with inference.sh services and platforms.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software to use it with inference.sh services, subject to the following conditions:
+
+1. The software may only be used in conjunction with inference.sh services and platforms.
+2. Redistribution and modification are permitted only for use with inference.sh services.
+3. This copyright notice and permission notice shall be included in all copies or
+   substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,82 @@
+# inference.sh CLI
+
+Helper package for inference.sh Python applications.
+
+## Installation
+
+```bash
+pip install infsh
+```
+
+## 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",
+    mime_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.mime_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
+```
+
+The 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

pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "inferencesh"
+version = "0.1.2"
+description = "inference.sh Python SDK"
+authors = [
+    {name = "Inference Shell Inc.", email = "hello@inference.sh"},
+]
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "pydantic>=2.0.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/inference-sh/sdk"
+"Bug Tracker" = "https://github.com/inference-sh/sdk/issues"
+
+[project.scripts]
+infsh = "infsh.__main__:cli"
+
+[tool.pytest]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+addopts = "-v"
+
+[tool.flake8]
+max-line-length = 100
+exclude = [".git", "__pycache__", "build", "dist"]

setup.py

@@ -0,0 +1,20 @@
+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",
+    ],
+    python_requires=">=3.7",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+) 

src/inferencesh/__init__.py

@@ -0,0 +1,5 @@
+"""inference.sh Python SDK package."""
+
+__version__ = "0.1.2"
+
+from .sdk import BaseApp, BaseAppInput, BaseAppOutput, File 

src/inferencesh/sdk.py

@@ -0,0 +1,74 @@
+from typing import Optional, Union
+from pydantic import BaseModel, ConfigDict
+import mimetypes
+import os
+
+class BaseAppInput(BaseModel):
+    pass
+
+class BaseAppOutput(BaseModel):
+    pass
+
+class BaseApp(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    async def setup(self):
+        pass
+
+    async def run(self, app_input: BaseAppInput) -> BaseAppOutput:
+        raise NotImplementedError("run method must be implemented")
+
+    async def unload(self):
+        pass
+
+
+class File(BaseModel):
+    """A class representing a file in the inference.sh ecosystem."""
+    path: str  # Absolute path to the file
+    mime_type: Optional[str] = None  # MIME type of the file
+    size: Optional[int] = None  # File size in bytes
+    filename: Optional[str] = None  # Original filename if available
+    
+    def __init__(self, **data):
+        super().__init__(**data)
+        if not os.path.isabs(self.path):
+            self.path = os.path.abspath(self.path)
+        self._populate_metadata()
+    
+    def _populate_metadata(self) -> None:
+        """Populate file metadata from the path if it exists."""
+        if os.path.exists(self.path):
+            if not self.mime_type:
+                self.mime_type = self._guess_mime_type()
+            if not self.size:
+                self.size = self._get_file_size()
+            if not self.filename:
+                self.filename = self._get_filename()
+    
+    @classmethod
+    def from_path(cls, path: Union[str, os.PathLike]) -> 'File':
+        """Create a File instance from a file path."""
+        return cls(path=str(path))
+    
+    def _guess_mime_type(self) -> Optional[str]:
+        """Guess the MIME type of the file."""
+        return mimetypes.guess_type(self.path)[0]
+    
+    def _get_file_size(self) -> int:
+        """Get the size of the file in bytes."""
+        return os.path.getsize(self.path)
+    
+    def _get_filename(self) -> str:
+        """Get the base filename from the path."""
+        return os.path.basename(self.path)
+    
+    def exists(self) -> bool:
+        """Check if the file exists."""
+        return os.path.exists(self.path)
+    
+    def refresh_metadata(self) -> None:
+        """Refresh all metadata from the file."""
+        self._populate_metadata()
+    
+    class Config:
+        """Pydantic config"""
+        arbitrary_types_allowed = True 

tests/test_sdk.py

@@ -0,0 +1,31 @@
+import os
+import pytest
+from inferencesh import BaseApp, BaseAppInput, BaseAppOutput, File
+
+def test_file_creation():
+    # Create a temporary file
+    with open("test.txt", "w") as f:
+        f.write("test")
+    
+    file = File(path="test.txt")
+    assert file.exists()
+    assert file.size > 0
+    assert file.mime_type is not None
+    assert file.filename == "test.txt"
+    
+    os.remove("test.txt")
+
+def test_base_app():
+    class TestInput(BaseAppInput):
+        text: str
+
+    class TestOutput(BaseAppOutput):
+        result: str
+
+    class TestApp(BaseApp):
+        async def run(self, app_input: TestInput) -> TestOutput:
+            return TestOutput(result=f"Processed: {app_input.text}")
+
+    app = TestApp()
+    with pytest.raises(NotImplementedError):
+        app.run(TestInput(text="test"))