inferencesh 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

inferencesh/utils/__init__.py

@@ -0,0 +1,6 @@
+"""Utilities package for inference.sh SDK."""
+
+from .storage import StorageDir
+from .download import download
+
+__all__ = ["StorageDir", "download"] 

inferencesh/utils/download.py

@@ -0,0 +1,59 @@
+import hashlib
+import os
+import urllib.parse
+import shutil
+from pathlib import Path
+from typing import Union
+
+from ..models.file import File
+from .storage import StorageDir
+
+
+def download(url: str, directory: Union[str, Path, StorageDir]) -> str:
+    """Download a file to the specified directory and return its path.
+    
+    Args:
+        url: The URL to download from
+        directory: The directory to save the file to. Can be a string path, 
+                  Path object, or StorageDir enum value.
+        
+    Returns:
+        str: The path to the downloaded file
+    """
+    # Convert directory to Path
+    dir_path = Path(directory)
+    dir_path.mkdir(exist_ok=True)
+    
+    # Parse URL components
+    parsed_url = urllib.parse.urlparse(url)
+    
+    # Create hash from URL path and query parameters for uniqueness
+    url_components = parsed_url.netloc + parsed_url.path
+    if parsed_url.query:
+        url_components += '?' + parsed_url.query
+    url_hash = hashlib.sha256(url_components.encode()).hexdigest()[:12]
+    
+    # Keep original filename or use a default
+    filename = os.path.basename(parsed_url.path)
+    if not filename:
+        filename = 'download'
+    
+    # Create hash directory and store file
+    hash_dir = dir_path / url_hash
+    hash_dir.mkdir(exist_ok=True)
+    
+    output_path = hash_dir / filename
+    
+    # If file exists in directory and it's not a temp directory, return it
+    if output_path.exists() and directory != StorageDir.TEMP:
+        return str(output_path)
+    
+    # Download the file
+    file = File(url)
+    if file.path:
+        shutil.copy2(file.path, output_path)
+        # Prevent the File instance from deleting its temporary file
+        file._tmp_path = None
+        return str(output_path)
+    
+    raise RuntimeError(f"Failed to download {url}") 

inferencesh/utils/storage.py

@@ -0,0 +1,16 @@
+from enum import Enum
+from pathlib import Path
+
+
+class StorageDir(str, Enum):
+    """Standard storage directories used by the SDK."""
+    DATA = "/app/data"   # Persistent storage/cache directory
+    TEMP = "/app/tmp"    # Temporary storage directory
+    CACHE = "/app/cache" # Cache directory
+
+    @property
+    def path(self) -> Path:
+        """Get the Path object for this storage directory, ensuring it exists."""
+        path = Path(self.value)
+        path.mkdir(parents=True, exist_ok=True)
+        return path 

{inferencesh-0.3.0.dist-info → inferencesh-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inferencesh
-Version: 0.3.0
+Version: 0.4.0
 Summary: inference.sh Python SDK
 Author: Inference Shell Inc.
 Author-email: "Inference Shell Inc." <hello@inference.sh>
@@ -13,9 +13,14 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: tqdm>=4.67.0
+Requires-Dist: requests>=2.31.0
 Provides-Extra: test
 Requires-Dist: pytest>=7.0.0; extra == "test"
 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

inferencesh-0.4.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+inferencesh/__init__.py,sha256=dY3l3yCkWoMtGX0gNXgxFnrprFRl6PPWjH8V7Qedx5g,772
+inferencesh/client.py,sha256=cm7E-8LxP8jyb7JnANmcBtF1ya2i7sMBW2Pq-Oh-mcM,31318
+inferencesh/models/__init__.py,sha256=FDwcdtT6c4hbRitymjmN-hZMlQa8RbKSftkZZyjtUXA,536
+inferencesh/models/base.py,sha256=4gZQRi8J7y9U6PrGD9pRIehd1MJVJAqGakPQDs2AKFM,3251
+inferencesh/models/file.py,sha256=uh1czgk0KFl_9RHTODX0PkdnI42MSU8QMJR_I4lVKI4,10556
+inferencesh/models/llm.py,sha256=GLcEkDizBbgcfc-zC719wDe44th3EGf3FpKERjIAPE8,27755
+inferencesh/utils/__init__.py,sha256=-xiD6uo2XzcrPAWFb_fUbaimmnW4KFKc-8IvBzaxNd4,148
+inferencesh/utils/download.py,sha256=DRGBudiPVa5bDS35KfR-DYeGRk7gO03WOelnisecwMo,1815
+inferencesh/utils/storage.py,sha256=E4J8emd4eFKdmdDgAqzz3TpaaDd3n0l8gYlMHuY8yIU,519
+inferencesh-0.4.0.dist-info/licenses/LICENSE,sha256=OsgqEWIh2el_QMj0y8O1A5Q5Dl-dxqqYbFE6fszuR4s,1086
+inferencesh-0.4.0.dist-info/METADATA,sha256=pHnblJABrxy5Iy81hpP7nV-J72Tp2JIUJ6D2UzVbSqo,2964
+inferencesh-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+inferencesh-0.4.0.dist-info/entry_points.txt,sha256=6IC-fyozAqW3ljsMLGCXxJ0_ui2Jb-2fLHtoH1RTnEE,45
+inferencesh-0.4.0.dist-info/top_level.txt,sha256=TSMHg3T1ThMl1HGAWmzBClwOYH1ump5neof9BfHIwaA,12
+inferencesh-0.4.0.dist-info/RECORD,,

{inferencesh-0.3.0.dist-info → inferencesh-0.4.0.dist-info}/WHEEL

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

inferencesh/sdk.py

@@ -1,363 +0,0 @@
-from typing import Optional, Union
-from pydantic import BaseModel, ConfigDict, PrivateAttr, model_validator, Field, field_validator
-import mimetypes
-import os
-import urllib.request
-import urllib.parse
-import tempfile
-from typing import Any, Dict, List
-
-import inspect
-import ast
-import textwrap
-from collections import OrderedDict
-from enum import Enum
-import shutil
-from pathlib import Path
-import hashlib
-
-
-# inspired by https://github.com/pydantic/pydantic/issues/7580
-class OrderedSchemaModel(BaseModel):
-    """A base model that ensures the JSON schema properties and required fields are in the order of field definition."""
-
-    @classmethod
-    def model_json_schema(cls, by_alias: bool = True, **kwargs: Any) -> Dict[str, Any]:
-        schema = super().model_json_schema(by_alias=by_alias, **kwargs)
-
-        field_order = cls._get_field_order()
-
-        if field_order:
-            # Order properties
-            ordered_properties = OrderedDict()
-            for field_name in field_order:
-                if field_name in schema['properties']:
-                    ordered_properties[field_name] = schema['properties'][field_name]
-
-            # Add any remaining properties that weren't in field_order
-            for field_name, field_schema in schema['properties'].items():
-                if field_name not in ordered_properties:
-                    ordered_properties[field_name] = field_schema
-
-            schema['properties'] = ordered_properties
-
-            # Order required fields
-            if 'required' in schema:
-                ordered_required = [field for field in field_order if field in schema['required']]
-                # Add any remaining required fields that weren't in field_order
-                ordered_required.extend([field for field in schema['required'] if field not in ordered_required])
-                schema['required'] = ordered_required
-
-        return schema
-
-    @classmethod
-    def _get_field_order(cls) -> List[str]:
-        """Get the order of fields as they were defined in the class."""
-        source = inspect.getsource(cls)
-
-        # Unindent the entire source code
-        source = textwrap.dedent(source)
-
-        try:
-            module = ast.parse(source)
-        except IndentationError:
-            # If we still get an IndentationError, wrap the class in a dummy module
-            source = f"class DummyModule:\n{textwrap.indent(source, '    ')}"
-            module = ast.parse(source)
-            # Adjust to look at the first class def inside DummyModule
-            # noinspection PyUnresolvedReferences
-            class_def = module.body[0].body[0]
-        else:
-            # Find the class definition
-            class_def = next(
-                node for node in module.body if isinstance(node, ast.ClassDef) and node.name == cls.__name__
-            )
-
-        # Extract field names in the order they were defined
-        field_order = []
-        for node in class_def.body:
-            if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
-                field_order.append(node.target.id)
-
-        return field_order
-    
-class BaseAppInput(OrderedSchemaModel):
-    pass
-
-class BaseAppOutput(OrderedSchemaModel):
-    pass
-
-class BaseApp(BaseModel):
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        extra='allow'
-    )
-
-    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."""
-    uri: Optional[str] = Field(default=None)  # Original location (URL or file path)
-    path: Optional[str] = None  # Resolved local file path
-    content_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
-    _tmp_path: Optional[str] = PrivateAttr(default=None)  # Internal storage for temporary file path
-    
-    def __init__(self, initializer=None, **data):
-        if initializer is not None:
-            if isinstance(initializer, str):
-                data['uri'] = initializer
-            elif isinstance(initializer, File):
-                data = initializer.model_dump()
-            else:
-                raise ValueError(f'Invalid input for File: {initializer}')
-        super().__init__(**data)
-
-    @model_validator(mode='before')
-    @classmethod
-    def convert_str_to_file(cls, values):
-        print(f"check_uri_or_path input: {values}")
-        if isinstance(values, str):  # Only accept strings
-            return {"uri": values}
-        elif isinstance(values, dict):
-            return values
-        raise ValueError(f'Invalid input for File: {values}')
-    
-    @model_validator(mode='after')
-    def validate_required_fields(self) -> 'File':
-        """Validate that either uri or path is provided."""
-        if not self.uri and not self.path:
-            raise ValueError("Either 'uri' or 'path' must be provided")
-        return self
-
-    def model_post_init(self, _: Any) -> None:
-        if self.uri and self._is_url(self.uri):
-            self._download_url()
-        elif self.uri and not os.path.isabs(self.uri):
-            self.path = os.path.abspath(self.uri)
-        elif self.uri:
-            self.path = self.uri
-        if self.path:
-            self._populate_metadata()
-        else:
-            raise ValueError("Either 'uri' or 'path' must be provided")
-    
-    def _is_url(self, path: str) -> bool:
-        """Check if the path is a URL."""
-        parsed = urllib.parse.urlparse(path)
-        return parsed.scheme in ('http', 'https')
-
-    def _download_url(self) -> None:
-        """Download the URL to a temporary file and update the path."""
-        original_url = self.uri
-        tmp_file = None
-        try:
-            # Create a temporary file with a suffix based on the URL path
-            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
-            
-            # Set up request with user agent
-            headers = {
-                'User-Agent': (
-                    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
-                    'AppleWebKit/537.36 (KHTML, like Gecko) '
-                    'Chrome/91.0.4472.124 Safari/537.36'
-                )
-            }
-            req = urllib.request.Request(original_url, headers=headers)
-            
-            # Download the file
-            print(f"Downloading URL: {original_url} to {self._tmp_path}")
-            try:
-                with urllib.request.urlopen(req) as response, open(self._tmp_path, 'wb') as out_file:
-                    out_file.write(response.read())
-                self.path = self._tmp_path
-            except (urllib.error.URLError, urllib.error.HTTPError) as e:
-                raise RuntimeError(f"Failed to download URL {original_url}: {str(e)}")
-            except IOError as e:
-                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'):
-                try:
-                    os.unlink(self._tmp_path)
-                except (OSError, IOError):
-                    pass
-            raise RuntimeError(f"Error downloading URL {original_url}: {str(e)}")
-
-    def __del__(self):
-        """Cleanup temporary file if it exists."""
-        if hasattr(self, '_tmp_path') and self._tmp_path:
-            try:
-                os.unlink(self._tmp_path)
-            except (OSError, IOError):
-                pass
-
-    def _populate_metadata(self) -> None:
-        """Populate file metadata from the path if it exists."""
-        if os.path.exists(self.path):
-            if not self.content_type:
-                self.content_type = self._guess_content_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(uri=str(path))
-    
-    def _guess_content_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."""
-        if os.path.exists(self.path):
-            self.content_type = self._guess_content_type()
-            self.size = self._get_file_size()  # Always update size
-            self.filename = self._get_filename()
-
-
-class ContextMessageRole(str, Enum):
-    USER = "user"
-    ASSISTANT = "assistant" 
-    SYSTEM = "system"
-
-class Message(BaseModel):
-    role: ContextMessageRole
-    content: str
-
-class ContextMessage(BaseModel):
-    role: ContextMessageRole = Field(
-        description="The role of the message",
-    )
-    text: str = Field(
-        description="The text content of the message"
-    )
-
-class ContextMessageWithImage(ContextMessage):
-    image: Optional[File] = Field(
-        description="The image url of the message",
-        default=None
-    )
-
-class LLMInput(BaseAppInput):
-    system_prompt: str = Field(
-        description="The system prompt to use for the model",
-        default="You are a helpful assistant that can answer questions and help with tasks.",
-        examples=[
-            "You are a helpful assistant that can answer questions and help with tasks.",
-            "You are a certified medical professional who can provide accurate health information.",
-            "You are a certified financial advisor who can give sound investment guidance.",
-            "You are a certified cybersecurity expert who can explain security best practices.",
-            "You are a certified environmental scientist who can discuss climate and sustainability.",
-        ]
-    )
-    context: list[ContextMessage] = Field(
-        description="The context to use for the model",
-        examples=[
-            [
-                {"role": "user", "content": [{"type": "text", "text": "What is the capital of France?"}]}, 
-                {"role": "assistant", "content": [{"type": "text", "text": "The capital of France is Paris."}]}
-            ],
-            [
-                {"role": "user", "content": [{"type": "text", "text": "What is the weather like today?"}]}, 
-                {"role": "assistant", "content": [{"type": "text", "text": "I apologize, but I don't have access to real-time weather information. You would need to check a weather service or app to get current weather conditions for your location."}]}
-            ],
-            [
-                {"role": "user", "content": [{"type": "text", "text": "Can you help me write a poem about spring?"}]}, 
-                {"role": "assistant", "content": [{"type": "text", "text": "Here's a short poem about spring:\n\nGreen buds awakening,\nSoft rain gently falling down,\nNew life springs anew.\n\nWarm sun breaks through clouds,\nBirds return with joyful song,\nNature's sweet rebirth."}]}
-            ],
-            [
-                {"role": "user", "content": [{"type": "text", "text": "Explain quantum computing in simple terms"}]}, 
-                {"role": "assistant", "content": [{"type": "text", "text": "Quantum computing is like having a super-powerful calculator that can solve many problems at once instead of one at a time. While regular computers use bits (0s and 1s), quantum computers use quantum bits or \"qubits\" that can be both 0 and 1 at the same time - kind of like being in two places at once! This allows them to process huge amounts of information much faster than regular computers for certain types of problems."}]}
-            ]
-        ],
-        default=[]
-    )
-    text: str = Field(
-        description="The user prompt to use for the model",
-        examples=[
-            "What is the capital of France?",
-            "What is the weather like today?",
-            "Can you help me write a poem about spring?",
-            "Explain quantum computing in simple terms"
-        ],
-    )
-
-class LLMInputWithImage(LLMInput):
-    image: Optional[File] = Field(
-        description="The image to use for the model",
-        default=None
-    )
-
-class DownloadDir(str, Enum):
-    """Standard download directories used by the SDK."""
-    DATA = "./data"   # Persistent storage/cache directory
-    TEMP = "./tmp"    # Temporary storage directory
-    CACHE = "./cache" # Cache directory
-
-def download(url: str, directory: Union[str, Path, DownloadDir]) -> str:
-    """Download a file to the specified directory and return its path.
-    
-    Args:
-        url: The URL to download from
-        directory: The directory to save the file to. Can be a string path, 
-                  Path object, or DownloadDir enum value.
-        
-    Returns:
-        str: The path to the downloaded file
-    """
-    # Convert directory to Path
-    dir_path = Path(directory)
-    dir_path.mkdir(exist_ok=True)
-    
-    # Create hash directory from URL
-    url_hash = hashlib.sha256(url.encode()).hexdigest()[:12]
-    hash_dir = dir_path / url_hash
-    hash_dir.mkdir(exist_ok=True)
-    
-    # Keep original filename
-    filename = os.path.basename(urllib.parse.urlparse(url).path)
-    if not filename:
-        filename = 'download'
-        
-    output_path = hash_dir / filename
-    
-    # If file exists in directory and it's not a temp directory, return it
-    if output_path.exists() and directory != DownloadDir.TEMP:
-        return str(output_path)
-    
-    # Download the file
-    file = File(url)
-    if file.path:
-        shutil.copy2(file.path, output_path)
-        # Prevent the File instance from deleting its temporary file
-        file._tmp_path = None
-        return str(output_path)
-    
-    raise RuntimeError(f"Failed to download {url}")

inferencesh-0.3.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-inferencesh/__init__.py,sha256=hbKkgHCh0lCdhWyHs3FHHRd8JfLeHkTd1bT4v79Fi8M,192
-inferencesh/sdk.py,sha256=Yebi85zvWYHVnnf5CARHg-eOpOPM2mZ7SafRlaJuwdA,14554
-inferencesh-0.3.0.dist-info/licenses/LICENSE,sha256=OsgqEWIh2el_QMj0y8O1A5Q5Dl-dxqqYbFE6fszuR4s,1086
-inferencesh-0.3.0.dist-info/METADATA,sha256=_06FcZ_2WJ7dS7DHhWmWDfmjR6rspTYZL7x9X0mUr5M,2728
-inferencesh-0.3.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-inferencesh-0.3.0.dist-info/entry_points.txt,sha256=6IC-fyozAqW3ljsMLGCXxJ0_ui2Jb-2fLHtoH1RTnEE,45
-inferencesh-0.3.0.dist-info/top_level.txt,sha256=TSMHg3T1ThMl1HGAWmzBClwOYH1ump5neof9BfHIwaA,12
-inferencesh-0.3.0.dist-info/RECORD,,