sentienceapi 0.90.9__py3-none-any.whl → 0.90.12__py3-none-any.whl

sentience/__init__.py

@@ -70,7 +70,7 @@ from .utils import (
 )
 from .wait import wait_for
 
-__version__ = "0.90.9"
+__version__ = "0.90.12"
 
 __all__ = [
     # Core SDK

sentience/browser.py

@@ -33,6 +33,8 @@ class SentienceBrowser:
         proxy: str | None = None,
         user_data_dir: str | None = None,
         storage_state: str | Path | StorageState | dict | None = None,
+        record_video_dir: str | Path | None = None,
+        record_video_size: dict[str, int] | None = None,
     ):
         """
         Initialize Sentience browser
@@ -57,6 +59,14 @@ class SentienceBrowser:
                           - StorageState object
                           - Dictionary with 'cookies' and/or 'origins' keys
                           If provided, browser starts with pre-injected authentication.
+            record_video_dir: Optional directory path to save video recordings.
+                            If provided, browser will record video of all pages.
+                            Videos are saved as .webm files in the specified directory.
+                            If None, no video recording is performed.
+            record_video_size: Optional video resolution as dict with 'width' and 'height' keys.
+                             Examples: {"width": 1280, "height": 800} (default)
+                                      {"width": 1920, "height": 1080} (1080p)
+                             If None, defaults to 1280x800.
         """
         self.api_key = api_key
         # Only set api_url if api_key is provided, otherwise None (free tier)
@@ -80,6 +90,10 @@ class SentienceBrowser:
         self.user_data_dir = user_data_dir
         self.storage_state = storage_state
 
+        # Video recording support
+        self.record_video_dir = record_video_dir
+        self.record_video_size = record_video_size or {"width": 1280, "height": 800}
+
         self.playwright: Playwright | None = None
         self.context: BrowserContext | None = None
         self.page: Page | None = None
@@ -209,6 +223,17 @@ class SentienceBrowser:
             launch_params["ignore_https_errors"] = True
             print(f"🌐 [Sentience] Using proxy: {proxy_config.server}")
 
+        # Add video recording if configured
+        if self.record_video_dir:
+            video_dir = Path(self.record_video_dir)
+            video_dir.mkdir(parents=True, exist_ok=True)
+            launch_params["record_video_dir"] = str(video_dir)
+            launch_params["record_video_size"] = self.record_video_size
+            print(f"🎥 [Sentience] Recording video to: {video_dir}")
+            print(
+                f"   Resolution: {self.record_video_size['width']}x{self.record_video_size['height']}"
+            )
+
         # Launch persistent context (required for extensions)
         # Note: We pass headless=False to launch_persistent_context because we handle
         # headless mode via the --headless=new arg above. This is a Playwright workaround.
@@ -390,15 +415,71 @@ class SentienceBrowser:
 
         return False
 
-    def close(self) -> None:
-        """Close browser and cleanup"""
+    def close(self, output_path: str | Path | None = None) -> str | None:
+        """
+        Close browser and cleanup
+
+        Args:
+            output_path: Optional path to rename the video file to.
+                        If provided, the recorded video will be moved to this location.
+                        Useful for giving videos meaningful names instead of random hashes.
+
+        Returns:
+            Path to video file if recording was enabled, None otherwise
+            Note: Video files are saved automatically by Playwright when context closes.
+            If multiple pages exist, returns the path to the first page's video.
+        """
+        temp_video_path = None
+
+        # Get video path before closing (if recording was enabled)
+        # Note: Playwright saves videos when pages/context close, but we can get the
+        # expected path before closing. The actual file will be available after close.
+        if self.record_video_dir:
+            try:
+                # Try to get video path from the first page
+                if self.page and self.page.video:
+                    temp_video_path = self.page.video.path()
+                # If that fails, check all pages in the context
+                elif self.context:
+                    for page in self.context.pages:
+                        if page.video:
+                            temp_video_path = page.video.path()
+                            break
+            except Exception:
+                # Video path might not be available until after close
+                # In that case, we'll return None and user can check the directory
+                pass
+
+        # Close context (this triggers video file finalization)
         if self.context:
             self.context.close()
+
+        # Close playwright
         if self.playwright:
             self.playwright.stop()
+
+        # Clean up extension directory
         if self._extension_path and os.path.exists(self._extension_path):
             shutil.rmtree(self._extension_path)
 
+        # Rename/move video if output_path is specified
+        final_path = temp_video_path
+        if temp_video_path and output_path and os.path.exists(temp_video_path):
+            try:
+                output_path = str(output_path)
+                # Ensure parent directory exists
+                Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+                shutil.move(temp_video_path, output_path)
+                final_path = output_path
+            except Exception as e:
+                import warnings
+
+                warnings.warn(f"Failed to rename video file: {e}")
+                # Return original path if rename fails
+                final_path = temp_video_path
+
+        return final_path
+
     def __enter__(self):
         """Context manager entry"""
         self.start()

sentience/cloud_tracing.py

@@ -213,7 +213,10 @@ class CloudTraceSink(TraceSink):
                 if on_progress:
                     on_progress(compressed_size, compressed_size)
 
-                # Call /v1/traces/complete to report file sizes (NEW)
+                # Upload trace index file
+                self._upload_index()
+
+                # Call /v1/traces/complete to report file sizes
                 self._complete_trace()
 
                 # Delete file only on successful upload
@@ -244,6 +247,95 @@ class CloudTraceSink(TraceSink):
             # Non-fatal: log but don't crash
             print(f"⚠️  Failed to generate trace index: {e}")
 
+    def _upload_index(self) -> None:
+        """
+        Upload trace index file to cloud storage.
+
+        Called after successful trace upload to provide fast timeline rendering.
+        The index file enables O(1) step lookups without parsing the entire trace.
+        """
+        # Construct index file path (same as trace file with .index.json extension)
+        index_path = Path(str(self._path).replace(".jsonl", ".index.json"))
+
+        if not index_path.exists():
+            if self.logger:
+                self.logger.warning("Index file not found, skipping index upload")
+            return
+
+        try:
+            # Request index upload URL from API
+            if not self.api_key:
+                # No API key - skip index upload
+                if self.logger:
+                    self.logger.info("No API key provided, skipping index upload")
+                return
+
+            response = requests.post(
+                f"{self.api_url}/v1/traces/index_upload",
+                headers={"Authorization": f"Bearer {self.api_key}"},
+                json={"run_id": self.run_id},
+                timeout=10,
+            )
+
+            if response.status_code != 200:
+                if self.logger:
+                    self.logger.warning(
+                        f"Failed to get index upload URL: HTTP {response.status_code}"
+                    )
+                return
+
+            upload_data = response.json()
+            index_upload_url = upload_data.get("upload_url")
+
+            if not index_upload_url:
+                if self.logger:
+                    self.logger.warning("No upload URL in index upload response")
+                return
+
+            # Read and compress index file
+            with open(index_path, "rb") as f:
+                index_data = f.read()
+
+            compressed_index = gzip.compress(index_data)
+            index_size = len(compressed_index)
+
+            if self.logger:
+                self.logger.info(f"Index file size: {index_size / 1024:.2f} KB")
+
+            print(f"📤 [Sentience] Uploading trace index ({index_size} bytes)...")
+
+            # Upload index to cloud storage
+            index_response = requests.put(
+                index_upload_url,
+                data=compressed_index,
+                headers={
+                    "Content-Type": "application/json",
+                    "Content-Encoding": "gzip",
+                },
+                timeout=30,
+            )
+
+            if index_response.status_code == 200:
+                print("✅ [Sentience] Trace index uploaded successfully")
+
+                # Delete local index file after successful upload
+                try:
+                    os.remove(index_path)
+                except Exception:
+                    pass  # Ignore cleanup errors
+            else:
+                if self.logger:
+                    self.logger.warning(
+                        f"Index upload failed: HTTP {index_response.status_code}"
+                    )
+                print(f"⚠️  [Sentience] Index upload failed: HTTP {index_response.status_code}")
+
+        except Exception as e:
+            # Non-fatal: log but don't crash
+            if self.logger:
+                self.logger.warning(f"Error uploading trace index: {e}")
+            print(f"⚠️  [Sentience] Error uploading trace index: {e}")
+
     def _complete_trace(self) -> None:
         """
         Call /v1/traces/complete to report file sizes to gateway.

sentience/extension/release.json

@@ -67,7 +67,7 @@
       "state": "uploaded",
       "size": 78091,
       "digest": "sha256:e281f8b755b61da4b8015d6172064aa9a337c14133ceceff4ab29199ee53307e",
-      "download_count": 0,
+      "download_count": 2,
       "created_at": "2025-12-29T03:57:09Z",
       "updated_at": "2025-12-29T03:57:09Z",
       "browser_download_url": "https://github.com/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/download/v2.0.7/extension-files.tar.gz"

sentience/text_search.py

@@ -88,6 +88,47 @@ def find_text_rect(
     # Limit max_results to prevent performance issues
     max_results = min(max_results, 100)
 
+    # CRITICAL: Wait for extension injection to complete (CSP-resistant architecture)
+    # The new architecture loads injected_api.js asynchronously, so window.sentience
+    # may not be immediately available after page load
+    try:
+        browser.page.wait_for_function(
+            "typeof window.sentience !== 'undefined'",
+            timeout=5000,  # 5 second timeout
+        )
+    except Exception as e:
+        # Gather diagnostics if wait fails
+        try:
+            diag = browser.page.evaluate(
+                """() => ({
+                    sentience_defined: typeof window.sentience !== 'undefined',
+                    extension_id: document.documentElement.dataset.sentienceExtensionId || 'not set',
+                    url: window.location.href
+                })"""
+            )
+        except Exception:
+            diag = {"error": "Could not gather diagnostics"}
+
+        raise RuntimeError(
+            f"Sentience extension failed to inject window.sentience API. "
+            f"Is the extension loaded? Diagnostics: {diag}"
+        ) from e
+
+    # Verify findTextRect method exists (for older extension versions that don't have it)
+    try:
+        has_find_text_rect = browser.page.evaluate(
+            "typeof window.sentience.findTextRect !== 'undefined'"
+        )
+        if not has_find_text_rect:
+            raise RuntimeError(
+                "window.sentience.findTextRect is not available. "
+                "Please update the Sentience extension to the latest version."
+            )
+    except RuntimeError:
+        raise
+    except Exception as e:
+        raise RuntimeError(f"Failed to verify findTextRect availability: {e}") from e
+
     # Call the extension's findTextRect method
     result_dict = browser.page.evaluate(
         """

sentience/trace_indexing/__init__.py

@@ -2,16 +2,16 @@
 Trace indexing module for Sentience SDK.
 """
 
-from .indexer import build_trace_index, write_trace_index, read_step_events
 from .index_schema import (
-    TraceIndex,
-    StepIndex,
-    TraceSummary,
-    TraceFileInfo,
-    SnapshotInfo,
     ActionInfo,
+    SnapshotInfo,
     StepCounters,
+    StepIndex,
+    TraceFileInfo,
+    TraceIndex,
+    TraceSummary,
 )
+from .indexer import build_trace_index, read_step_events, write_trace_index
 
 __all__ = [
     "build_trace_index",

sentience/trace_indexing/index_schema.py

@@ -2,8 +2,8 @@
 Type definitions for trace index schema using concrete classes.
 """
 
-from dataclasses import dataclass, field, asdict
-from typing import Optional, List, Literal
+from dataclasses import asdict, dataclass, field
+from typing import List, Literal, Optional
 
 
 @dataclass
@@ -27,7 +27,7 @@ class TraceSummary:
     event_count: int
     step_count: int
     error_count: int
-    final_url: Optional[str]
+    final_url: str | None
 
     def to_dict(self) -> dict:
         return asdict(self)
@@ -37,9 +37,9 @@ class TraceSummary:
 class SnapshotInfo:
     """Snapshot metadata for index."""
 
-    snapshot_id: Optional[str] = None
-    digest: Optional[str] = None
-    url: Optional[str] = None
+    snapshot_id: str | None = None
+    digest: str | None = None
+    url: str | None = None
 
     def to_dict(self) -> dict:
         return asdict(self)
@@ -49,10 +49,10 @@ class SnapshotInfo:
 class ActionInfo:
     """Action metadata for index."""
 
-    type: Optional[str] = None
-    target_element_id: Optional[int] = None
-    args_digest: Optional[str] = None
-    success: Optional[bool] = None
+    type: str | None = None
+    target_element_id: int | None = None
+    args_digest: str | None = None
+    success: bool | None = None
 
     def to_dict(self) -> dict:
         return asdict(self)
@@ -77,14 +77,14 @@ class StepIndex:
 
     step_index: int
     step_id: str
-    goal: Optional[str]
+    goal: str | None
     status: Literal["ok", "error", "partial"]
     ts_start: str
     ts_end: str
     offset_start: int
     offset_end: int
-    url_before: Optional[str]
-    url_after: Optional[str]
+    url_before: str | None
+    url_after: str | None
     snapshot_before: SnapshotInfo
     snapshot_after: SnapshotInfo
     action: ActionInfo
@@ -104,7 +104,7 @@ class TraceIndex:
     created_at: str
     trace_file: TraceFileInfo
     summary: TraceSummary
-    steps: List[StepIndex] = field(default_factory=list)
+    steps: list[StepIndex] = field(default_factory=list)
 
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""

sentience/trace_indexing/indexer.py

@@ -10,13 +10,13 @@ from pathlib import Path
 from typing import Any, Dict, List
 
 from .index_schema import (
-    TraceIndex,
-    StepIndex,
-    TraceSummary,
-    TraceFileInfo,
-    SnapshotInfo,
     ActionInfo,
+    SnapshotInfo,
     StepCounters,
+    StepIndex,
+    TraceFileInfo,
+    TraceIndex,
+    TraceSummary,
 )
 
 
@@ -34,7 +34,7 @@ def _normalize_text(text: str | None, max_len: int = 80) -> str:
     return normalized
 
 
-def _round_bbox(bbox: Dict[str, float], precision: int = 2) -> Dict[str, int]:
+def _round_bbox(bbox: dict[str, float], precision: int = 2) -> dict[str, int]:
     """Round bbox coordinates to reduce noise (default: 2px precision)."""
     return {
         "x": round(bbox.get("x", 0) / precision) * precision,
@@ -44,7 +44,7 @@ def _round_bbox(bbox: Dict[str, float], precision: int = 2) -> Dict[str, int]:
     }
 
 
-def _compute_snapshot_digest(snapshot_data: Dict[str, Any]) -> str:
+def _compute_snapshot_digest(snapshot_data: dict[str, Any]) -> str:
     """
     Compute stable digest of snapshot for diffing.
 
@@ -62,9 +62,7 @@ def _compute_snapshot_digest(snapshot_data: Dict[str, Any]) -> str:
             "id": elem.get("id"),
             "role": elem.get("role", ""),
             "text_norm": _normalize_text(elem.get("text")),
-            "bbox": _round_bbox(
-                elem.get("bbox", {"x": 0, "y": 0, "width": 0, "height": 0})
-            ),
+            "bbox": _round_bbox(elem.get("bbox", {"x": 0, "y": 0, "width": 0, "height": 0})),
             "is_primary": elem.get("is_primary", False),
             "is_clickable": elem.get("is_clickable", False),
         }
@@ -89,7 +87,7 @@ def _compute_snapshot_digest(snapshot_data: Dict[str, Any]) -> str:
     return f"sha256:{digest}"
 
 
-def _compute_action_digest(action_data: Dict[str, Any]) -> str:
+def _compute_action_digest(action_data: dict[str, Any]) -> str:
     """
     Compute digest of action args for privacy + determinism.
 
@@ -152,8 +150,8 @@ def build_trace_index(trace_path: str) -> TraceIndex:
     error_count = 0
     final_url = None
 
-    steps_by_id: Dict[str, StepIndex] = {}
-    step_order: List[str] = []  # Track order of first appearance
+    steps_by_id: dict[str, StepIndex] = {}
+    step_order: list[str] = []  # Track order of first appearance
 
     # Stream through file, tracking byte offsets
     with open(trace_path, "rb") as f:
@@ -228,9 +226,7 @@ def build_trace_index(trace_path: str) -> TraceIndex:
                     )
                     step.url_before = step.url_before or url
 
-                step.snapshot_after = SnapshotInfo(
-                    snapshot_id=snapshot_id, digest=digest, url=url
-                )
+                step.snapshot_after = SnapshotInfo(snapshot_id=snapshot_id, digest=digest, url=url)
                 step.url_after = url
                 step.counters.snapshots += 1
                 final_url = url
@@ -311,9 +307,7 @@ def write_trace_index(trace_path: str, index_path: str | None = None) -> str:
     return index_path
 
 
-def read_step_events(
-    trace_path: str, offset_start: int, offset_end: int
-) -> List[Dict[str, Any]]:
+def read_step_events(trace_path: str, offset_start: int, offset_end: int) -> list[dict[str, Any]]:
     """
     Read events for a specific step using byte offsets from index.
 

{sentienceapi-0.90.9.dist-info → sentienceapi-0.90.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentienceapi
-Version: 0.90.9
+Version: 0.90.12
 Summary: Python SDK for Sentience AI Agent Browser Automation
 Author: Sentience Team
 License: MIT

{sentienceapi-0.90.9.dist-info → sentienceapi-0.90.12.dist-info}/RECORD

@@ -1,11 +1,11 @@
-sentience/__init__.py,sha256=5zlE1tx4AhGypFVLtRPpNTWu-GclCfjXpPhABz1WaBM,3409
+sentience/__init__.py,sha256=DETDLYDNA_A5llT6mjgcvB4FPuCELiD8ppsz3hvTEbs,3410
 sentience/actions.py,sha256=RT8AoR_CNyp6bMCYhkToWH1WB8cyB8dcFJZMhfskTeo,13239
 sentience/agent.py,sha256=rTAaQGiuZIohrJZXpCK-dZWuoAR3k_dQodjFLBkrCxY,24527
 sentience/agent_config.py,sha256=blyCUh2pjMOI6YQGLWP8mSi6GTnpzWLWem4nwYg3ngA,1489
 sentience/base_agent.py,sha256=861XkIJeig9nqdt7f2wfFKyxanGZtDhnrgsMDdXtkFM,2979
-sentience/browser.py,sha256=At0VYO3oagyaMrUcs6w2TxISztrQxSWpGpuSmVsAqwQ,17441
+sentience/browser.py,sha256=jB59HfZHHUOKTORA7gsaQlIKEZyxwivvW4VU9swyy_k,21311
 sentience/cli.py,sha256=R95DgCSJmezuymAdfL6fzUdB1HpCF3iMWcLO73KJ8eY,3851
-sentience/cloud_tracing.py,sha256=Y_20sdvOiYoavIJWh_ogZYb6H3RMRP59uM9p4u3QrGo,10128
+sentience/cloud_tracing.py,sha256=KxVIT-HQW9EaX5GWC9DEVM2cdObomD3hkPNEnTceSpc,13541
 sentience/conversational_agent.py,sha256=UUgltp-EkAbAzE6Pa_S72t7fWbdIwb3C2YppXzPx2jA,17207
 sentience/expect.py,sha256=BFSRocNJr6ZAusb6fy4OgfDNCukGfu5jto760bFN12E,2851
 sentience/formatting.py,sha256=0_UklIUd94a4W32gTorjxoXNE03qdffR-omfTA5eHF0,1828
@@ -19,7 +19,7 @@ sentience/read.py,sha256=qoSbahcNumvb0mUe-WcWrKrkKCEqya6Ac7wqXFe3SRI,3490
 sentience/recorder.py,sha256=RWzkJP6LWiFAJUfbXQS3aAnRgl7aDrWuKw3slp-gR1Y,12496
 sentience/screenshot.py,sha256=1UJjRvPxPpiL3w1_MBvO_UPMAsmt-uyRujTYA50jim0,1607
 sentience/snapshot.py,sha256=zFQa-jGh8MBPuyvZZ3kam_d8qN93UtmigCvj9m2V5Ts,9947
-sentience/text_search.py,sha256=Xu4dhU8_SYyv_MPWbChEZ8wTYvM-gzVsffxqtWBMx2s,4073
+sentience/text_search.py,sha256=UF7-Dlo69Stx_vkfcu5ss3dKCVgyWODrafJoJXU9NCw,5753
 sentience/tracer_factory.py,sha256=Fc_kb8ffJVGdy91cnxpxU2xjFZUyS2OiaI2pqtvl2lk,7643
 sentience/tracing.py,sha256=ciYSW3QXcO0BYDtjeKQLfpAysObBIKQKCAlviwU74AQ,7240
 sentience/utils.py,sha256=ryxiDVE_sUPHYmYnWYXADuyciD_ZawmsITDZNUeDVJg,8116
@@ -28,19 +28,19 @@ sentience/extension/background.js,sha256=hnK32hVtHJrLtzBeXt2beRmMzr1l0U82r8zZEXy
 sentience/extension/content.js,sha256=UIuFCDTVTkXdaiXB8LMf0OP8SB_WMrMoaav5ZBXmeIo,10442
 sentience/extension/injected_api.js,sha256=Pr5j9MGJTInPOKfKKNuaMDjOJSK3ygM-HlmWAUUS-Yg,63790
 sentience/extension/manifest.json,sha256=MfkfsS5zVxb-scqJllN8aubrRN9vsznQ3-Aw69pZ47c,897
-sentience/extension/release.json,sha256=gblo3-etdwlWMB1JIIhyXwZeVhM3voNi7982xG58D8M,6437
+sentience/extension/release.json,sha256=ikdgGGy_Jf6r_P6dKOUUaVZOQYMIRHz3ok5dVclxoT8,6437
 sentience/extension/test-content.js,sha256=RX6A42W-5pjP-avqGwrRq_GVp5yX2NqBDlDLc-SWL5g,156
 sentience/extension/pkg/sentience_core.d.ts,sha256=qrTEIR2WPkk1MmaSQzEpRyagbE9VirHowzZpbj41qeQ,1981
 sentience/extension/pkg/sentience_core.js,sha256=zldlOubec0pbNYhquwDzoQKuBF4SUVcIeXW_qLx0dVA,17904
 sentience/extension/pkg/sentience_core_bg.wasm,sha256=HtzBY8z4XgRgHHUqHQGm84EEQJirpf25wSVTXg-iJ1g,102522
 sentience/extension/pkg/sentience_core_bg.wasm.d.ts,sha256=O3c3HaUqmB6Aob6Pt0n3GEtTxM4VGeaClaA_-z2m2J4,517
 sentience/schemas/trace_v1.json,sha256=XpByPqRH1xzHmD7YeuaDE5ZaEb3L5fz762djcwXqPV8,7593
-sentience/trace_indexing/__init__.py,sha256=LuLRaq3Wjc1dZn9eXxI426oE_nahep-XadtsLMDIHSw,499
-sentience/trace_indexing/index_schema.py,sha256=hgkb2vUUQ_aqfa6DN5MR2wMjDvGtbfGmyGXNA_07IZg,2213
-sentience/trace_indexing/indexer.py,sha256=mqayI_Hl160Yb_3OBF3G-zsfZ3Stc8dNDMjebDJvAcs,10885
-sentienceapi-0.90.9.dist-info/licenses/LICENSE.md,sha256=Pl8BWUOOkFtYpgVhNwCl3YKzRvUpYid2utlJELIgr_8,3783
-sentienceapi-0.90.9.dist-info/METADATA,sha256=dIKUAlvVW104gGxMLayOAYPqQv8pD7sFDbgN64hc304,26130
-sentienceapi-0.90.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sentienceapi-0.90.9.dist-info/entry_points.txt,sha256=HdW1BvgRJm3ZAbbqrwTvDWE2KbmVz-Ue0wllW-mLmvA,49
-sentienceapi-0.90.9.dist-info/top_level.txt,sha256=A9IKao--8PsFFz5vDfBIXWHgN6oh3HkMQSiQWgUTUBQ,10
-sentienceapi-0.90.9.dist-info/RECORD,,
+sentience/trace_indexing/__init__.py,sha256=urjLuqqXCQE8pnwpYBqoMKnzZSqFJkM1SHmFve9RVE8,499
+sentience/trace_indexing/index_schema.py,sha256=Hz9igHFrHATTZOqKNiLhESjnGbDPTyRTejMGT1AKC8g,2180
+sentience/trace_indexing/indexer.py,sha256=m-p57Va0cFlCpuMWkXNSHqODpGzpESZzoOkt3OiejlM,10811
+sentienceapi-0.90.12.dist-info/licenses/LICENSE.md,sha256=Pl8BWUOOkFtYpgVhNwCl3YKzRvUpYid2utlJELIgr_8,3783
+sentienceapi-0.90.12.dist-info/METADATA,sha256=DblGVp6eXuV5WD44nR-auKp93Ig7iiXVoG-LajlznVc,26131
+sentienceapi-0.90.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sentienceapi-0.90.12.dist-info/entry_points.txt,sha256=HdW1BvgRJm3ZAbbqrwTvDWE2KbmVz-Ue0wllW-mLmvA,49
+sentienceapi-0.90.12.dist-info/top_level.txt,sha256=A9IKao--8PsFFz5vDfBIXWHgN6oh3HkMQSiQWgUTUBQ,10
+sentienceapi-0.90.12.dist-info/RECORD,,