streamlit-octostar-utils 0.4.2.dev11__tar.gz → 0.4.2.dev13__tar.gz

{streamlit_octostar_utils-0.4.2.dev11 → streamlit_octostar_utils-0.4.2.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-octostar-utils
-Version: 0.4.2.dev11
+Version: 0.4.2.dev13
 Summary: 
 License: MIT
 License-File: LICENSE

{streamlit_octostar_utils-0.4.2.dev11 → streamlit_octostar_utils-0.4.2.dev13}/pyproject.toml

@@ -5,7 +5,7 @@ include = '\.pyi?$'
 
 [tool.poetry]
 name = "streamlit-octostar-utils"
-version = "0.4.2-dev.11"
+version = "0.4.2-dev.13"
 description = ""
 license = "MIT"
 authors = ["Octostar"]

{streamlit_octostar_utils-0.4.2.dev11 → streamlit_octostar_utils-0.4.2.dev13}/streamlit_octostar_utils/api_crafter/contents.py

@@ -18,7 +18,6 @@ from abc import ABC, abstractmethod
 from typing import Optional, Dict, Any, List
 from enum import Enum
 import base64
-import httpx
 import logging
 from io import BytesIO, SEEK_SET, SEEK_CUR, SEEK_END
 
@@ -710,20 +709,18 @@ class TemporaryAttachmentContents(Contents):
     """
     Contents implementation for Octostar temporary blob storage.
     
-    All I/O goes through presigned S3 URLs:
-    - Reads use get_temporary_blob_url() for presigned download URLs
-    - Writes use request_temporary_blob_url() for presigned upload URLs
+    Uses the SDK's ``read_temporary_blob`` / ``write_temporary_blob`` /
+    ``delete_temporary_blob`` functions which handle presigned URLs internally.
+    
+    - Reads use ``read_temporary_blob.sync()`` with ``byte_range`` for efficient
+      partial reads and ``headers_only=True`` for HEAD metadata.
+    - Writes are buffered locally and uploaded on ``flush()`` via
+      ``write_temporary_blob.sync()``.
     
     Temporary blobs are keyed by filename (not workspace/entity), and are not
     associated with any workspace entity. Use WorkspaceAttachmentContents for that.
-    
-    Presigned URL Handling:
-    - Download URLs are cached and refreshed automatically on 403 (expired).
     """
     
-    DEFAULT_URL_TIMEOUT = 120
-    MAX_RETRIES = 3
-    
     def __init__(
         self,
         entity_type: Optional[str] = None,
@@ -741,150 +738,70 @@ class TemporaryAttachmentContents(Contents):
         self._modified = False
         self._position = 0
         self._size: Optional[int] = None
-        self._download_url: Optional[str] = None
-        self._http_client: Optional[httpx.Client] = None
-    
-    # ==================== Presigned URL management ====================
-    
-    def _ensure_http_client(self):
-        """Ensure the shared httpx.Client is initialized."""
-        if not self._http_client:
-            self._http_client = httpx.Client(timeout=self.DEFAULT_URL_TIMEOUT)
-    
-    def _ensure_download_url(self):
-        """Ensure a download URL is cached, fetching one if needed."""
-        if not self._download_url:
-            self._download_url = self._refresh_download_url()
     
-    def _refresh_download_url(self) -> str:
-        from octostar.utils.workspace import get_temporary_blob_url
-        
-        return get_temporary_blob_url.sync(
-            filename=self._filename,
-            client=self._client
-        )
-    
-    def _get_upload_info(self) -> Dict[str, Any]:
-        from octostar.utils.workspace import request_temporary_blob_url
-        
-        return request_temporary_blob_url.sync(
-            filename=self._filename,
-            client=self._client
-        )
-    
-    # ==================== Remote operations ====================
+    # ==================== Remote operations via SDK ====================
     
     def _fetch_size(self) -> int:
-        """Fetch remote content size via HEAD request with presigned URL."""
+        """Fetch the remote content size via a HEAD request."""
         if self._size is not None:
             return self._size
         
-        self._ensure_download_url()
-        self._ensure_http_client()
-        
-        assert self._http_client is not None
-        assert self._download_url is not None
-        
-        for attempt in range(self.MAX_RETRIES):
-            response = self._http_client.head(self._download_url)
-            if response.status_code == 200:
-                self._size = int(response.headers.get('content-length', 0))
-                return self._size
-            elif response.status_code == 403:
-                _logger.debug(
-                    "Presigned URL expired while fetching size, refreshing... (attempt %d/%d)",
-                    attempt + 1, self.MAX_RETRIES,
-                )
-                self._download_url = self._refresh_download_url()
-                continue
-            else:
-                response.raise_for_status()
-
-        raise ConnectionError(
-            f"Failed to fetch file size after {self.MAX_RETRIES} attempts (URL kept expiring)"
-        )
+        try:
+            from octostar.utils.workspace import read_temporary_blob
+            
+            headers = read_temporary_blob.sync(
+                filename=self._filename,
+                headers_only=True,
+                client=self._client,
+            )
+            self._size = int(headers.get('content-length', 0))
+        except Exception:
+            self._size = 0
+        return self._size
     
     def _read_range(self, start: int, end: int) -> bytes:
-        """Read a specific byte range via presigned URL with Range header."""
-        self._ensure_download_url()
-        self._ensure_http_client()
-        assert self._http_client is not None
-        assert self._download_url is not None
-        
-        headers = {"Range": f"bytes={start}-{end}"}
+        """Read a specific byte range from the remote blob."""
+        from octostar.utils.workspace import read_temporary_blob
         
-        for attempt in range(self.MAX_RETRIES):
-            response = self._http_client.get(self._download_url, headers=headers)
-            
-            if response.status_code == 206:
-                return response.content
-            elif response.status_code == 416:
-                return b""
-            elif response.status_code == 403:
-                _logger.debug(
-                    "Presigned URL expired at byte %d, refreshing... (attempt %d/%d)",
-                    start, attempt + 1, self.MAX_RETRIES,
-                )
-                self._download_url = self._refresh_download_url()
-                continue
-            else:
-                response.raise_for_status()
-                return response.content
-                
-        raise ConnectionError(
-            f"Failed to read range {start}-{end} after {self.MAX_RETRIES} attempts (URL kept expiring)"
+        data = read_temporary_blob.sync(
+            filename=self._filename,
+            decode=False,
+            byte_range=(start, end),
+            client=self._client,
         )
+        return data if isinstance(data, bytes) else data.encode()
     
     def _load_full(self):
-        """Load the entire remote content into memory buffer via presigned URL."""
+        """Load the entire remote blob into the in-memory buffer."""
         if self._fully_loaded:
             return
         
-        self._ensure_download_url()
-        self._ensure_http_client()
-        assert self._http_client is not None
-        assert self._download_url is not None
-        
-        for attempt in range(self.MAX_RETRIES):
-            response = self._http_client.get(self._download_url)
-            if response.status_code == 200:
-                data = response.content
-                self._buffer = BytesIO(data)
-                self._fully_loaded = True
-                self._size = len(data)
-                self._buffer.seek(self._position, SEEK_SET)
-                return
-            elif response.status_code == 403:
-                _logger.debug(
-                    "Presigned URL expired during full load, refreshing... (attempt %d/%d)",
-                    attempt + 1, self.MAX_RETRIES,
-                )
-                self._download_url = self._refresh_download_url()
-                continue
-            else:
-                response.raise_for_status()
+        try:
+            from octostar.utils.workspace import read_temporary_blob
+            
+            data = read_temporary_blob.sync(
+                filename=self._filename,
+                decode=False,
+                client=self._client,
+            )
+        except Exception:
+            # Blob may not exist yet — start with empty buffer
+            data = b""
         
-        raise ConnectionError(
-            f"Failed to load full content after {self.MAX_RETRIES} attempts (URL kept expiring)"
-        )
+        self._buffer = BytesIO(data)
+        self._fully_loaded = True
+        self._size = len(data)
+        self._buffer.seek(self._position, SEEK_SET)
     
     def _upload_data(self, data: bytes):
-        """Upload data to temporary storage via presigned POST URL."""
-        upload_info = self._get_upload_info()
-        upload_url = upload_info["url"]
-        upload_fields = upload_info.get("fields", {})
-        
-        self._ensure_http_client()
-        assert self._http_client is not None
-        file_obj = BytesIO(data)
+        """Upload data via the SDK write_temporary_blob."""
+        from octostar.utils.workspace import write_temporary_blob
         
-        response = self._http_client.post(
-            upload_url,
-            data=upload_fields,
-            files={"file": file_obj},
+        write_temporary_blob.sync(
+            filename=self._filename,
+            file=data,
+            client=self._client,
         )
-        if response.status_code not in (200, 204):
-            response.raise_for_status()
     
     # ==================== FileIO Interface ====================
     
@@ -952,7 +869,7 @@ class TemporaryAttachmentContents(Contents):
         return self._position
     
     def flush(self):
-        """Upload buffer to temporary storage via presigned URL, then invalidate cache."""
+        """Upload buffer to temporary storage, then invalidate cache."""
         if self._buffer:
             self._buffer.flush()
         
@@ -972,7 +889,6 @@ class TemporaryAttachmentContents(Contents):
         self._fully_loaded = False
         self._position = 0
         self._size = None
-        self._download_url = None
     
     def close(self):
         if not self._closed:
@@ -980,9 +896,6 @@ class TemporaryAttachmentContents(Contents):
                 self.flush()
             if self._buffer:
                 self._buffer.close()
-            if self._http_client:
-                self._http_client.close()
-                self._http_client = None
             super().close()
     
     def truncate(self, size: Optional[int] = None) -> int:

{streamlit_octostar_utils-0.4.2.dev11 → streamlit_octostar_utils-0.4.2.dev13}/streamlit_octostar_utils/api_crafter/nifi.py

@@ -524,9 +524,11 @@ class NifiContextManager(object):
         fetch_relationships_entities = {}
         fetch_concept_relationships = {}
         for entity in entities:
-            if entity.sync_params.get(NifiContextManager.SyncFlag.FETCH_RELATIONSHIPS):
+            rels_to_fetch = (
+                entity.sync_params.get(NifiContextManager.SyncFlag.FETCH_RELATIONSHIPS) or {}
+            ).get("relationships") or []
+            if rels_to_fetch:
                 concept_name = entity.record["entity_type"]
-                rels_to_fetch = entity.sync_params.get(NifiContextManager.SyncFlag.FETCH_RELATIONSHIPS, [])
                 for rel in rels_to_fetch:
                     if rel not in fetch_relationships_entities:
                         fetch_relationships_entities[rel] = []