File cache

Author: okaris

examples/run.py

@@ -5,40 +5,47 @@
 
 from inferencesh import Inference, TaskStatus
 
+
 def main() -> None:
-    api_key = "YOUR_INFERENCESH_API_KEY"
-    client = Inference(api_key=api_key)
-    
+    api_key = "1nfsh-0fd8bxd5faawt9m0cztdym4q6s"
+    client = Inference(api_key=api_key, base_url="https://api-dev.inference.sh")
+
     app = "infsh/text-templating"
 
     try:
-        result = client.run_sync(
+        task = client.run(
             {
-                "app": app,
+                "app": "infsh/lightning-wan-2-2-i2v-a14b",
                 "input": {
-                    "template": "{1} / {2}",
-                    "strings": [
-                        "god",
-                        "particle",
-                    ]
+                    "negative_prompt": "oversaturated, overexposed, static, blurry details, subtitles, stylized, artwork, painting, still image, overall gray, worst quality, low quality, JPEG artifacts, ugly, deformed, extra fingers, poorly drawn hands, poorly drawn face, malformed, disfigured, deformed limbs, fused fingers, static motionless frame, cluttered background, three legs, crowded background, walking backwards",
+                    "prompt": "test",
+                    "num_frames": 81,
+                    "num_inference_steps": 4,
+                    "fps": 16,
+                    "boundary_ratio": 0.875,
+                    "image": "https://images.dev.letz.ai/5ed74083-f9d1-4897-b8e3-c8f1596af767/fa6b9cbc-9465-4fe8-b5ba-08c7a75d4975/drawing_extreme_closeup_portrait_of_junck37342762320240205225633.jpg",
                 },
-                "worker_selection_mode": "private",
-            },
+                "infra": "private",
+                # "workers": [],
+                "variant": "fp16_480p",
+            }
         )
 
+        print(task["id"])
 
-        # Print final result
-        if result.get("status") == TaskStatus.COMPLETED:
+        # Print final task
+        if task.get("status") == TaskStatus.COMPLETED:
             print(f"\n✓ task completed successfully!")
-            print(f"result: {result.get('output', {}).get('result')}")
+            print(f"task: {task.get('output', {}).get('task')}")
         else:
-            status = result.get("status")
+            status = task.get("status")
             status_name = TaskStatus(status).name if status is not None else "UNKNOWN"
             print(f"\n✗ task did not complete. final status: {status_name}")
 
     except Exception as exc:  # noqa: BLE001
         print(f"\nerror during run_sync: {type(exc).__name__}: {exc}")
         raise  # Re-raise to see full traceback
 
+
 if __name__ == "__main__":
     main()

src/inferencesh/models/file.py

@@ -5,11 +5,45 @@
 import urllib.request
 import urllib.parse
 import tempfile
+import hashlib
+from pathlib import Path
 from tqdm import tqdm
 
 
 class File(BaseModel):
     """A class representing a file in the inference.sh ecosystem."""
+    
+    @classmethod
+    def get_cache_dir(cls) -> Path:
+        """Get the cache directory path based on environment variables or default location."""
+        if cache_dir := os.environ.get("FILE_CACHE_DIR"):
+            path = Path(cache_dir)
+        else:
+            path = Path.home() / ".cache" / "inferencesh" / "files"
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+    
+    def _get_cache_path(self, url: str) -> Path:
+        """Get the cache path for a URL using a hash-based directory structure."""
+        # 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]
+        
+        # Get filename from URL or use default
+        filename = os.path.basename(parsed_url.path)
+        if not filename:
+            filename = 'download'
+            
+        # Create hash directory in cache
+        cache_dir = self.get_cache_dir() / url_hash
+        cache_dir.mkdir(exist_ok=True)
+        
+        return cache_dir / filename
     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
@@ -74,11 +108,20 @@ def _is_url(self, path: str) -> bool:
         return parsed.scheme in ('http', 'https')
 
     def _download_url(self) -> None:
-        """Download the URL to a temporary file and update the path."""
+        """Download the URL to the cache directory and update the path."""
         original_url = self.uri
+        cache_path = self._get_cache_path(original_url)
+        
+        # If file exists in cache, use it
+        if cache_path.exists():
+            print(f"Using cached file: {cache_path}")
+            self.path = str(cache_path)
+            return
+            
+        print(f"Downloading URL: {original_url} to {cache_path}")
         tmp_file = None
         try:
-            # Create a temporary file with a suffix based on the URL path
+            # 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
@@ -133,7 +176,10 @@ def _download_url(self) -> None:
                                     # If we read the whole body at once, exit loop
                                     break
 
-                self.path = self._tmp_path
+                # Move the temporary file to the cache location
+                os.replace(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:
                 raise RuntimeError(f"Failed to download URL {original_url}: {str(e)}")
             except IOError as e:

src/inferencesh/utils/download.py

@@ -24,16 +24,24 @@ def download(url: str, directory: Union[str, Path, StorageDir]) -> str:
     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)
+    # Parse URL components
+    parsed_url = urllib.parse.urlparse(url)
 
-    # Keep original filename
-    filename = os.path.basename(urllib.parse.urlparse(url).path)
+    # 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