featrixsphere 0.2.1002__py3-none-any.whl → 0.2.1314__py3-none-any.whl

featrixsphere/__init__.py

@@ -38,7 +38,7 @@ Example:
     ...                                labels=['Experiment A', 'Experiment B'])
 """
 
-__version__ = "0.2.1002"
+__version__ = "0.2.1314"
 __author__ = "Featrix"
 __email__ = "support@featrix.com"
 __license__ = "MIT"

featrixsphere/client.py

@@ -633,13 +633,97 @@ class FeatrixSphereClient:
             _client=self
         )
     
-    def get_model_card(self, session_id: str, max_retries: int = None) -> Dict[str, Any]:
+    def update_user_metadata(self, session_id: str, metadata: Dict[str, Any], write_mode: str = "merge") -> Dict[str, Any]:
+        """
+        Update user metadata for a session.
+        
+        Args:
+            session_id: The session ID to update metadata for
+            metadata: Dictionary of metadata to update (max 32KB total)
+            write_mode: How to update metadata:
+                - "merge" (default): Merge new metadata with existing (existing keys are updated, new keys are added)
+                - "overwrite": Replace all user_metadata with the new dictionary
+        
+        Returns:
+            Dictionary containing the updated session information
+            
+        Raises:
+            requests.exceptions.HTTPError: If the request fails
+            ValueError: If write_mode is not "merge" or "overwrite"
+            
+        Example:
+            >>> # Merge new metadata with existing
+            >>> client.update_user_metadata(
+            ...     session_id="abc123",
+            ...     metadata={"new_key": "value", "existing_key": "updated_value"},
+            ...     write_mode="merge"
+            ... )
+            
+            >>> # Replace all metadata
+            >>> client.update_user_metadata(
+            ...     session_id="abc123",
+            ...     metadata={"only_key": "only_value"},
+            ...     write_mode="overwrite"
+            ... )
+        """
+        if write_mode not in ["merge", "overwrite"]:
+            raise ValueError(f"write_mode must be 'merge' or 'overwrite', got '{write_mode}'")
+        
+        request_data = {
+            "user_metadata": metadata,
+            "write_mode": write_mode
+        }
+        
+        response_data = self._post_json(f"/session/{session_id}/update_user_metadata", request_data)
+        return response_data
+    
+    def is_foundation_model_ready(self, session_id: str, max_retries: int = None) -> Tuple[bool, str]:
+        """
+        Check if a foundation model session is ready to use (training completed).
+        
+        Args:
+            session_id: The session ID to check
+            max_retries: Maximum number of retries (defaults to client default)
+            
+        Returns:
+            Tuple of (is_ready: bool, status_message: str)
+            - is_ready: True if session is done and model card is available
+            - status_message: Human-readable status message
+            
+        Example:
+            >>> is_ready, message = client.is_foundation_model_ready("session_123")
+            >>> if not is_ready:
+            ...     print(f"Foundation model not ready: {message}")
+        """
+        try:
+            session_status = self.get_session_status(session_id, max_retries=max_retries)
+            
+            if session_status.status in ["done", "DONE"]:
+                # Check if model card exists
+                try:
+                    self.get_model_card(session_id, max_retries=max_retries, check_status_first=False)
+                    return True, "Foundation model is ready"
+                except (requests.exceptions.HTTPError, FileNotFoundError):
+                    return False, "Session is done but model card is not available yet"
+            else:
+                return False, f"Session is still {session_status.status}. Training may still be in progress."
+                
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 404:
+                return False, f"Session {session_id} not found"
+            return False, f"Error checking session status: {e}"
+        except Exception as e:
+            return False, f"Error checking foundation model: {e}"
+    
+    def get_model_card(self, session_id: str, max_retries: int = None, check_status_first: bool = True) -> Dict[str, Any]:
         """
         Get the model card JSON for a given session.
         
         Args:
             session_id: The session ID to get the model card for
             max_retries: Maximum number of retries (defaults to client default)
+            check_status_first: If True, check session status before fetching model card.
+                               Provides better error messages if session is still training.
             
         Returns:
             Dictionary containing the model card JSON data
@@ -647,12 +731,31 @@ class FeatrixSphereClient:
         Raises:
             requests.exceptions.HTTPError: If the request fails
             FileNotFoundError: If the model card doesn't exist (404)
+            ValueError: If session is not ready and check_status_first is True
             
         Example:
             >>> client = FeatrixSphereClient()
             >>> model_card = client.get_model_card("session_123")
             >>> print(model_card["model_details"]["name"])
         """
+        # Check session status first to provide better error messages
+        if check_status_first:
+            try:
+                session_status = self.get_session_status(session_id, max_retries=max_retries)
+                if session_status.status not in ["done", "DONE"]:
+                    raise ValueError(
+                        f"Session {session_id} is not ready (status: {session_status.status}). "
+                        f"Model card is only available after training completes. "
+                        f"Use wait_for_session_completion() to wait for training to finish."
+                    )
+            except requests.exceptions.HTTPError as e:
+                # If we can't get status, continue and let the model_card request fail
+                # This handles cases where the session doesn't exist
+                if e.response.status_code == 404:
+                    raise FileNotFoundError(f"Session {session_id} not found") from e
+                # For other HTTP errors, continue to try model_card request
+                pass
+        
         response = self._make_request(
             "GET",
             f"/session/{session_id}/model_card",
@@ -660,6 +763,77 @@ class FeatrixSphereClient:
         )
         return response.json()
     
+    def publish_session(self, session_id: str) -> Dict[str, Any]:
+        """
+        Publish a session by moving it to /sphere/published/<sessionId>.
+        Moves both the session file and output directory.
+        
+        Args:
+            session_id: Session ID to publish
+            
+        Returns:
+            Response with published_path, output_path, and status
+            
+        Example:
+            ```python
+            result = client.publish_session("abc123")
+            print(f"Published to: {result['published_path']}")
+            ```
+        """
+        response_data = self._post_json(f"/compute/session/{session_id}/publish", {})
+        return response_data
+
+    def deprecate_session(self, session_id: str, warning_message: str, expiration_date: str) -> Dict[str, Any]:
+        """
+        Deprecate a published session with a warning message and expiration date.
+        The session remains available until the expiration date.
+        
+        Args:
+            session_id: Session ID to deprecate
+            warning_message: Warning message to display about deprecation
+            expiration_date: ISO format date string when session will be removed (e.g., "2025-12-31T23:59:59Z")
+            
+        Returns:
+            Response with deprecation status
+            
+        Example:
+            ```python
+            from datetime import datetime, timedelta
+            
+            expiration = (datetime.now() + timedelta(days=90)).isoformat() + "Z"
+            result = client.deprecate_session(
+                session_id="abc123",
+                warning_message="This session will be removed on 2025-12-31",
+                expiration_date=expiration
+            )
+            ```
+        """
+        data = {
+            "warning_message": warning_message,
+            "expiration_date": expiration_date
+        }
+        response_data = self._post_json(f"/compute/session/{session_id}/deprecate", data)
+        return response_data
+
+    def unpublish_session(self, session_id: str) -> Dict[str, Any]:
+        """
+        Unpublish a session by moving it back from /sphere/published/<sessionId>.
+        
+        Args:
+            session_id: Session ID to unpublish
+            
+        Returns:
+            Response with unpublish status
+            
+        Example:
+            ```python
+            result = client.unpublish_session("abc123")
+            print(f"Status: {result['status']}")
+            ```
+        """
+        response_data = self._post_json(f"/compute/session/{session_id}/unpublish", {})
+        return response_data
+
     def get_sessions_for_org(self, name_prefix: str, max_retries: int = None) -> Dict[str, Any]:
         """
         Get all sessions matching a name prefix across all compute nodes.
@@ -703,8 +877,8 @@ class FeatrixSphereClient:
             >>> print(f"Model card recreated: {model_card['model_info']['name']}")
         """
         response = self._make_request(
-            "POST",
-            f"/session/{session_id}/model_card",
+            "GET",
+            f"/compute/session/{session_id}/model_card",
             max_retries=max_retries
         )
         return response.json()
@@ -1424,16 +1598,141 @@ class FeatrixSphereClient:
             job_queue_positions={}
         )
 
+    def fine_tune_embedding_space(
+        self,
+        name: str,
+        parent_session_id: str = None,
+        parent_embedding_space_path: str = None,
+        s3_training_dataset: str = None,
+        s3_validation_dataset: str = None,
+        webhooks: Dict[str, str] = None
+    ) -> SessionInfo:
+        """
+        Fine-tune an existing embedding space on new data.
+        
+        This method takes a pre-trained embedding space (the "parent") and fine-tunes it
+        on a new dataset with the same columns. The number of training epochs is automatically
+        calculated based on the dataset size ratio to ensure optimal training.
+        
+        **How Epoch Calculation Works:**
+        - The system calculates F = len(new_dataset) / len(old_dataset)
+        - New epochs = original_epochs / F
+        - If new dataset is smaller (F < 1), more epochs are used (to see data enough times)
+        - If new dataset is larger (F > 1), fewer epochs are used (less repetition needed)
+        
+        **Example:**
+        - Original: 1000 rows, trained for 100 epochs
+        - New: 500 rows → F = 0.5 → 100/0.5 = 200 epochs
+        - New: 2000 rows → F = 2.0 → 100/2.0 = 50 epochs
+        
+        This ensures the model sees the new data an appropriate number of times relative
+        to how much it saw the original data.
+        
+        Args:
+            name: Name for the fine-tuned embedding space
+            parent_session_id: Session ID of the parent embedding space (optional)
+            parent_embedding_space_path: Direct path to parent embedding space pickle file (optional)
+            s3_training_dataset: S3 URL for new training dataset (must start with 's3://')
+            s3_validation_dataset: S3 URL for new validation dataset (must start with 's3://')
+            webhooks: Optional dict with webhook configuration keys (webhook_callback_secret, s3_backup_url, model_id_update_url)
+            
+        Returns:
+            SessionInfo for the newly created fine-tuning session
+            
+        Raises:
+            ValueError: If S3 URLs are invalid or neither parent identifier is provided
+            
+        Example:
+            ```python
+            # Fine-tune an existing embedding space on new data
+            client = FeatrixSphereClient("https://sphere-api.featrix.com")
+            
+            # Option 1: Use parent session ID
+            fine_tuned = client.fine_tune_embedding_space(
+                name="customer_behavior_v2",
+                parent_session_id="abc123-20240101-120000",
+                s3_training_dataset="s3://my-bucket/new_training_data.csv",
+                s3_validation_dataset="s3://my-bucket/new_validation_data.csv"
+            )
+            
+            # Option 2: Use direct path to parent embedding space
+            fine_tuned = client.fine_tune_embedding_space(
+                name="customer_behavior_v2",
+                parent_embedding_space_path="/path/to/parent/embedded_space.pickle",
+                s3_training_dataset="s3://my-bucket/new_training_data.csv",
+                s3_validation_dataset="s3://my-bucket/new_validation_data.csv"
+            )
+            
+            # Wait for fine-tuning to complete
+            client.wait_for_session_completion(fine_tuned.session_id)
+            
+            # Use the fine-tuned model for predictions
+            result = client.predict(fine_tuned.session_id, {"feature1": "value1"})
+            ```
+        """
+        # Validate S3 URLs
+        if s3_training_dataset and not s3_training_dataset.startswith('s3://'):
+            raise ValueError("s3_training_dataset must be a valid S3 URL (s3://...)")
+        if s3_validation_dataset and not s3_validation_dataset.startswith('s3://'):
+            raise ValueError("s3_validation_dataset must be a valid S3 URL (s3://...)")
+        
+        # Validate that we have either parent_session_id or parent_embedding_space_path
+        if not parent_session_id and not parent_embedding_space_path:
+            raise ValueError("Either parent_session_id or parent_embedding_space_path must be provided")
+        
+        print(f"Fine-tuning embedding space '{name}'...")
+        if parent_session_id:
+            print(f"  Parent session: {parent_session_id}")
+        if parent_embedding_space_path:
+            print(f"  Parent embedding space: {parent_embedding_space_path}")
+        print(f"  New training data: {s3_training_dataset}")
+        print(f"  New validation data: {s3_validation_dataset}")
+        
+        data = {
+            "name": name,
+            "s3_file_data_set_training": s3_training_dataset,
+            "s3_file_data_set_validation": s3_validation_dataset
+        }
+        
+        if parent_session_id:
+            data["parent_session_id"] = parent_session_id
+        if parent_embedding_space_path:
+            data["parent_embedding_space_path"] = parent_embedding_space_path
+        
+        if webhooks:
+            data['webhooks'] = webhooks
+        
+        response_data = self._post_json("/compute/fine-tune-embedding-space", data)
+        
+        session_id = response_data.get('session_id')
+        fine_tune_info = response_data.get('fine_tune_info', {})
+        
+        print(f"Fine-tuning session created: {session_id}")
+        if fine_tune_info:
+            print(f"  Original dataset: {fine_tune_info.get('original_train_size', 'N/A')} rows")
+            print(f"  New dataset: {fine_tune_info.get('new_total_size', 'N/A')} rows")
+            print(f"  Dataset ratio (F): {fine_tune_info.get('F', 'N/A'):.4f}")
+            print(f"  Original epochs: {fine_tune_info.get('original_epochs', 'N/A')}")
+            print(f"  Calculated epochs: {fine_tune_info.get('calculated_epochs', 'N/A')}")
+        
+        return SessionInfo(
+            session_id=session_id,
+            session_type=response_data.get('session_type', 'embedding_space_finetune'),
+            status=response_data.get('status', 'ready'),
+            jobs={},
+            job_queue_positions={}
+        )
+
     # =========================================================================
     # File Upload
     # =========================================================================
     
     def upload_file_and_create_session(self, file_path: Path, session_name_prefix: str = None, name: str = None, webhooks: Dict[str, str] = None) -> SessionInfo:
         """
-        Upload a CSV file and create a new session.
+        Upload a CSV, Parquet, JSON, or JSONL file and create a new session.
         
         Args:
-            file_path: Path to the CSV file to upload
+            file_path: Path to the CSV, Parquet, JSON, or JSONL file to upload
             session_name_prefix: Optional prefix for the session ID. Session will be named <prefix>-<full-uuid>
             name: Optional name for the embedding space/model (for identification and metadata)
             webhooks: Optional dict with webhook configuration keys (webhook_callback_secret, s3_backup_url, model_id_update_url)
@@ -1491,12 +1790,13 @@ class FeatrixSphereClient:
                                     string_list_delimiter: str = "|",
                                     important_columns_for_visualization: List[str] = None,
                                     metadata: Dict[str, Any] = None,
+                                    user_metadata: Dict[str, Any] = None,  # User metadata for ES/SP identification (max 32KB)
                                     session_name_prefix: str = None,
                                     name: str = None,
                                     webhooks: Dict[str, str] = None,
                                     epochs: int = None) -> SessionInfo:
         """
-        Upload a pandas DataFrame or CSV file and create a new session.
+        Upload a pandas DataFrame, CSV file, Parquet file, JSON file, or JSONL file and create a new session.
         
         Special Column: __featrix_train_predictor
         ------------------------------------------
@@ -1504,7 +1804,7 @@ class FeatrixSphereClient:
         which rows are used for single predictor training.
         
         How it works:
-        - Add a boolean column "__featrix_train_predictor" to your DataFrame/CSV before upload
+        - Add a boolean column "__featrix_train_predictor" to your DataFrame/CSV/Parquet/JSON/JSONL before upload
         - Set it to True for rows you want to use for predictor training
         - Set it to False (or any other value) for rows to exclude from predictor training
         - Embedding space training uses ALL rows (ignores this column)
@@ -1538,7 +1838,7 @@ class FeatrixSphereClient:
         Args:
             df: pandas DataFrame to upload (optional if file_path is provided)
             filename: Name to give the uploaded file (default: "data.csv")
-            file_path: Path to CSV file to upload (optional if df is provided)
+            file_path: Path to CSV, Parquet, JSON, or JSONL file to upload (optional if df is provided)
             column_overrides: Dict mapping column names to types ("scalar", "set", "free_string", "free_string_list")
             column_types: Alias for column_overrides (for backward compatibility)
             string_list_delimiter: Delimiter for free_string_list columns (default: "|")
@@ -1579,21 +1879,90 @@ class FeatrixSphereClient:
             if not os.path.exists(file_path):
                 raise FileNotFoundError(f"File not found: {file_path}")
             
-            # Check if it's a CSV file
-            if not file_path.lower().endswith(('.csv', '.csv.gz')):
-                raise ValueError("File must be a CSV file (with .csv or .csv.gz extension)")
+            # Check if it's a supported file type
+            file_ext = file_path.lower()
+            if not file_ext.endswith(('.csv', '.csv.gz', '.parquet', '.json', '.jsonl')):
+                raise ValueError("File must be a CSV, Parquet, JSON, or JSONL file (with .csv, .csv.gz, .parquet, .json, or .jsonl extension)")
             
             print(f"Uploading file: {file_path}")
             
             # Read the file content
             if file_path.endswith('.gz'):
-                # Already gzipped
+                # Already gzipped CSV
                 with gzip.open(file_path, 'rb') as f:
                     file_content = f.read()
                 upload_filename = os.path.basename(file_path)
                 content_type = 'application/gzip'
+            elif file_path.lower().endswith(('.json', '.jsonl')):
+                # JSON/JSONL file - read as DataFrame, convert to CSV, then compress
+                print(f"Reading {'JSONL' if file_path.lower().endswith('.jsonl') else 'JSON'} file...")
+                try:
+                    from featrix.neural.input_data_file import featrix_wrap_read_json_file
+                    json_df = featrix_wrap_read_json_file(file_path)
+                    if json_df is None:
+                        raise ValueError(f"Failed to parse {'JSONL' if file_path.lower().endswith('.jsonl') else 'JSON'} file")
+                except ImportError:
+                    # Fallback to pandas if featrix wrapper not available
+                    if file_path.lower().endswith('.jsonl'):
+                        # JSONL: one JSON object per line
+                        import json
+                        records = []
+                        with open(file_path, 'r', encoding='utf-8') as f:
+                            for line in f:
+                                if line.strip():
+                                    records.append(json.loads(line))
+                        json_df = pd.DataFrame(records)
+                    else:
+                        # Regular JSON
+                        json_df = pd.read_json(file_path)
+                
+                # Clean NaN values before CSV conversion
+                cleaned_df = json_df.where(pd.notna(json_df), None)
+                
+                # Convert to CSV and compress
+                csv_buffer = io.StringIO()
+                cleaned_df.to_csv(csv_buffer, index=False)
+                csv_data = csv_buffer.getvalue().encode('utf-8')
+                
+                print(f"Compressing {'JSONL' if file_path.lower().endswith('.jsonl') else 'JSON'} (converted to CSV)...")
+                compressed_buffer = io.BytesIO()
+                with gzip.GzipFile(fileobj=compressed_buffer, mode='wb') as gz:
+                    gz.write(csv_data)
+                file_content = compressed_buffer.getvalue()
+                upload_filename = os.path.basename(file_path).replace('.jsonl', '.csv.gz').replace('.json', '.csv.gz')
+                content_type = 'application/gzip'
+                
+                original_size = len(csv_data)
+                compressed_size = len(file_content)
+                compression_ratio = (1 - compressed_size / original_size) * 100
+                print(f"Converted {'JSONL' if file_path.lower().endswith('.jsonl') else 'JSON'} to CSV and compressed from {original_size:,} to {compressed_size:,} bytes ({compression_ratio:.1f}% reduction)")
+            elif file_path.lower().endswith('.parquet'):
+                # Parquet file - read as DataFrame, convert to CSV, then compress
+                print("Reading Parquet file...")
+                parquet_df = pd.read_parquet(file_path)
+                
+                # Clean NaN values before CSV conversion
+                cleaned_df = parquet_df.where(pd.notna(parquet_df), None)
+                
+                # Convert to CSV and compress
+                csv_buffer = io.StringIO()
+                cleaned_df.to_csv(csv_buffer, index=False)
+                csv_data = csv_buffer.getvalue().encode('utf-8')
+                
+                print("Compressing Parquet (converted to CSV)...")
+                compressed_buffer = io.BytesIO()
+                with gzip.GzipFile(fileobj=compressed_buffer, mode='wb') as gz:
+                    gz.write(csv_data)
+                file_content = compressed_buffer.getvalue()
+                upload_filename = os.path.basename(file_path).replace('.parquet', '.csv.gz')
+                content_type = 'application/gzip'
+                
+                original_size = len(csv_data)
+                compressed_size = len(file_content)
+                compression_ratio = (1 - compressed_size / original_size) * 100
+                print(f"Converted Parquet to CSV and compressed from {original_size:,} to {compressed_size:,} bytes ({compression_ratio:.1f}% reduction)")
             else:
-                # Read CSV and compress it
+                # Regular CSV file - read and compress it
                 with open(file_path, 'rb') as f:
                     csv_content = f.read()
                 
@@ -1663,6 +2032,10 @@ class FeatrixSphereClient:
             import json
             data['metadata'] = json.dumps(metadata)
             print(f"Session metadata: {metadata}")
+        if user_metadata:
+            import json
+            data['user_metadata'] = json.dumps(user_metadata)
+            print(f"User metadata: {user_metadata}")
         if session_name_prefix:
             data['session_name_prefix'] = session_name_prefix
             print(f"Session name prefix: {session_name_prefix}")
@@ -3239,6 +3612,24 @@ class FeatrixSphereClient:
         response_data = self._delete_json(f"/session/{session_id}/predictor", params=params, max_retries=max_retries)
         return response_data
 
+    def mark_for_deletion(self, session_id: str, max_retries: int = None) -> Dict[str, Any]:
+        """
+        Mark a session for deletion. The session will be deleted by the garbage collection process.
+        
+        Args:
+            session_id: Session ID to mark for deletion
+            max_retries: Number of retries for errors (default: uses client default)
+            
+        Returns:
+            Dictionary with confirmation that the session was marked for deletion
+            
+        Example:
+            result = client.mark_for_deletion("session_123")
+            print(result)  # {"status": "marked", "session_id": "session_123"}
+        """
+        response_data = self._post_json(f"/compute/session/{session_id}/mark_for_deletion", max_retries=max_retries)
+        return response_data
+
 
     def _create_interactive_training_movie(self, training_metrics, epoch_projections, session_id,
                                           show_embedding_evolution, show_loss_evolution):
@@ -3720,12 +4111,12 @@ class FeatrixSphereClient:
 
     def train_on_foundational_model(self, foundation_model_id: str, target_column: str, target_column_type: str,
                                     input_filename: str = None,
+                                    df = None,
                                     name: str = None,
                                     session_name_prefix: str = None,
-                                    epochs: int = 0, batch_size: int = 0, learning_rate: float = 0.001,
-                                    positive_label: str = None,
+                                    epochs: int = 0, 
+                                    rare_label_value: str = None,
                                     class_imbalance: dict = None,
-                                    optimize_for: str = "balanced",
                                     poll_interval: int = 30, max_poll_time: int = 3600,
                                     verbose: bool = True,
                                     webhooks: Dict[str, str] = None) -> SessionInfo:
@@ -3741,14 +4132,13 @@ class FeatrixSphereClient:
             target_column: Name of the target column to predict
             target_column_type: Type of target column ("set" or "scalar")
             input_filename: Optional input data file (uses foundation model's data if not provided)
+            df: Optional pandas DataFrame with training data (uses foundation model's data if not provided).
+                Use input_filename OR df (not both) to train predictor on different data than the foundation model.
             name: Optional name for the new session
             session_name_prefix: Optional prefix for session ID. Session will be named <prefix>-<uuid>
             epochs: Number of training epochs (default: 0; automatic)
-            batch_size: Training batch size (default: 0; automatic)
-            learning_rate: Learning rate for training (default: 0.001)
-            positive_label: For binary classification, which class is "positive" for metrics (default: None)
+            rare_label_value: For binary classification, which class is the rare/minority class for metrics (default: None)
             class_imbalance: Expected class ratios/counts from real world for sampled data (default: None)
-            optimize_for: Optimization target - "balanced" (F1 score), "precision", or "recall" (default: "balanced")
             poll_interval: Seconds between status checks when job is already running (default: 30)
             max_poll_time: Maximum time to poll in seconds (default: 3600 = 1 hour)
             verbose: Whether to print status updates during polling (default: True)
@@ -3760,44 +4150,125 @@ class FeatrixSphereClient:
         print(f"Training predictor on foundation model {foundation_model_id}...")
         print(f"  Target: {target_column} ({target_column_type})")
         
-        data = {
-            "foundation_model_id": foundation_model_id,
-            "target_column": target_column,
-            "target_column_type": target_column_type,
-            "epochs": epochs,
-            "batch_size": batch_size,
-            "learning_rate": learning_rate,
-            "optimize_for": optimize_for,
-        }
-        
-        if input_filename:
-            # Clean up input_filename: extract just the filename if it's an absolute path
-            # The file should be uploaded first or already exist on the server
-            from pathlib import Path
-            input_path = Path(input_filename)
-            if input_path.is_absolute():
-                # Extract just the filename - client should upload file first
-                cleaned_filename = input_path.name
-                print(f"⚠️  Note: Extracted filename '{cleaned_filename}' from absolute path '{input_filename}'")
-                print(f"   Make sure the file has been uploaded to the server first")
-                data["input_filename"] = cleaned_filename
-            else:
-                data["input_filename"] = input_filename
-        if name:
-            data["name"] = name
-        if session_name_prefix:
-            data["session_name_prefix"] = session_name_prefix
-        if positive_label:
-            data["positive_label"] = positive_label
-        if class_imbalance:
-            data["class_imbalance"] = class_imbalance
-        if webhooks:
-            data["webhooks"] = webhooks
-        
-        response_data = self._post_json("/compute/train_on_foundational_model", data)
+        # Get the compute cluster from the foundation model session
+        # This ensures we upload files to the same node where the foundation model lives
+        foundation_session = self.get_session_status(foundation_model_id)
+        foundation_compute_cluster = self.get_last_server_metadata()
+        foundation_compute_cluster = foundation_compute_cluster.get('compute_cluster') if foundation_compute_cluster else None
+        
+        # Temporarily set compute cluster for file uploads if we found one
+        original_compute_cluster = self.compute_cluster
+        original_headers = self.session.headers.copy()
+        if foundation_compute_cluster:
+            self.set_compute_cluster(foundation_compute_cluster)
+            if verbose:
+                print(f"  Using compute cluster: {foundation_compute_cluster}")
         
-        new_session_id = response_data.get('session_id')
-        print(f"✅ Predictor training session created: {new_session_id}")
+        try:
+            # Validate that only one data source is provided
+            if input_filename and df is not None:
+                raise ValueError("Provide either input_filename or df, not both")
+            
+            # Prepare multipart form data (like train_single_predictor_with_file does)
+            files = None
+            data = {
+                "foundation_model_id": foundation_model_id,
+                "target_column": target_column,
+                "target_column_type": target_column_type,
+                "epochs": str(epochs),
+            }
+            
+            # Handle file upload - send file directly in multipart form
+            if df is not None:
+                import pandas as pd
+                import tempfile
+                import os
+                
+                if not isinstance(df, pd.DataFrame):
+                    raise ValueError("df must be a pandas DataFrame")
+                
+                if verbose:
+                    print(f"📊 Using provided DataFrame ({len(df)} rows, {len(df.columns)} columns)")
+                
+                # Create temporary CSV file
+                temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False)
+                temp_file_path = temp_file.name
+                temp_file.close()
+                
+                # Save DataFrame to temp file
+                df.to_csv(temp_file_path, index=False)
+                
+                if verbose:
+                    print(f"📁 Saved to temporary file: {os.path.basename(temp_file_path)}")
+                    print(f"📤 Uploading file directly with training request...")
+                
+                # Send file in multipart form
+                files = {'file': (os.path.basename(temp_file_path), open(temp_file_path, 'rb'), 'text/csv')}
+                
+            elif input_filename:
+                # If absolute path provided, send file directly
+                from pathlib import Path
+                input_path = Path(input_filename)
+                if input_path.is_absolute():
+                    if not input_path.exists():
+                        raise FileNotFoundError(f"Input file not found: {input_filename}")
+                    
+                    if verbose:
+                        print(f"📤 Sending file directly from absolute path: {input_filename}")
+                    
+                    # Send file in multipart form
+                    files = {'file': (input_path.name, open(input_path, 'rb'), 'text/csv' if input_path.suffix == '.csv' else 'application/gzip')}
+                else:
+                    # Relative filename - assume it's already on the server
+                    data["input_filename"] = input_filename
+            
+            if name:
+                data["name"] = name
+            if session_name_prefix:
+                data["session_name_prefix"] = session_name_prefix
+            if rare_label_value:
+                data["rare_label_value"] = rare_label_value
+            if class_imbalance:
+                import json
+                data["class_imbalance"] = json.dumps(class_imbalance)
+            if webhooks:
+                import json
+                data["webhooks"] = json.dumps(webhooks)
+            
+            # Send request with file if provided
+            try:
+                if files:
+                    response = self._make_request("POST", "/compute/train_on_foundational_model", files=files, data=data)
+                else:
+                    response = self._make_request("POST", "/compute/train_on_foundational_model", json=data)
+                response_data = response.json()
+            finally:
+                # Close file handles
+                if files and 'file' in files:
+                    files['file'][1].close()
+                    # Clean up temp file if we created one
+                    if df is not None and temp_file_path:
+                        try:
+                            os.unlink(temp_file_path)
+                        except Exception:
+                            pass
+            
+            new_session_id = response_data.get('session_id')
+            print(f"✅ Predictor training session created: {new_session_id}")
+            
+            # Restore original compute cluster setting
+            if original_compute_cluster != self.compute_cluster:
+                if original_compute_cluster:
+                    self.set_compute_cluster(original_compute_cluster)
+                else:
+                    self.session.headers = original_headers
+        finally:
+            # Ensure we restore headers even if there's an error
+            if original_compute_cluster != self.compute_cluster:
+                if original_compute_cluster:
+                    self.set_compute_cluster(original_compute_cluster)
+                else:
+                    self.session.headers = original_headers
         
         if verbose:
             print(f"⏳ Waiting for training to complete...")
@@ -3821,9 +4292,10 @@ class FeatrixSphereClient:
                               df = None,
                               epochs: int = 0,
                               validation_ignore_columns: List[str] = None,
-                              positive_label: str = None,
+                              rare_label_value: str = None,
                               class_imbalance: dict = None,
-                              optimize_for: str = "balanced",
+                              cost_false_positive: float = None,
+                              cost_false_negative: float = None,
                               poll_interval: int = 30, max_poll_time: int = 3600,
                               verbose: bool = True,
                               webhooks: Dict[str, str] = None) -> Dict[str, Any]:
@@ -4001,24 +4473,6 @@ class FeatrixSphereClient:
         This happens automatically - no configuration needed. The system invests a few seconds
         in analysis to deliver significantly better models.
         
-        Understanding optimize_for:
-        ---------------------------
-        The optimize_for parameter controls which loss function and training strategy is used,
-        optimizing for different aspects of model performance:
-        
-        - "balanced" (default): Optimizes for F1 score (harmonic mean of precision and recall).
-          Uses FocalLoss with class weights. Best for general-purpose classification where you
-          want balanced performance across all classes.
-          
-        - "precision": Optimizes for precision (minimizing false positives). Uses FocalLoss with
-          class weights, which focuses training on hard-to-classify examples. Best when false
-          positives are costly (e.g., fraud detection where flagging legitimate transactions
-          as fraud is expensive).
-          
-        - "recall": Optimizes for recall (minimizing false negatives). Uses CrossEntropyLoss
-          with class weights that strongly boost the minority class. Best when false negatives
-          are costly (e.g., medical diagnosis where missing a disease is dangerous).
-        
         Understanding class_imbalance:
         ------------------------------
         For imbalanced datasets where your training data doesn't reflect real-world class
@@ -4036,14 +4490,14 @@ class FeatrixSphereClient:
         
         If not provided, class weights are computed from your training data distribution.
         
-        Understanding positive_label:
+        Understanding rare_label_value:
         -----------------------------
-        For binary classification, positive_label specifies which class is considered the
-        "positive" class for computing metrics like precision, recall, and ROC-AUC.
+        For binary classification, rare_label_value specifies which class is the rare/minority
+        class for computing metrics like precision, recall, and ROC-AUC.
         
         Example: For a credit risk model predicting "good" vs "bad" loans:
         
-            positive_label="bad"  # We want to detect bad loans
+            rare_label_value="bad"  # "bad" is the rare class we want to detect
         
         This affects how metrics are reported:
         - Precision = True Positives / (True Positives + False Positives)
@@ -4124,7 +4578,7 @@ class FeatrixSphereClient:
             session_id=session.session_id,
             target_column='approved',
             target_column_type='set',
-            positive_label='yes'
+            rare_label_value='yes'
         )
         ```
         
@@ -4139,8 +4593,7 @@ class FeatrixSphereClient:
             target_column='approved',
             target_column_type='set',
             class_imbalance={'approved': 0.97, 'rejected': 0.03},
-            optimize_for='recall',  # Don't miss rejections
-            positive_label='rejected'
+            rare_label_value='rejected'
         )
         
         # System will:
@@ -4159,8 +4612,7 @@ class FeatrixSphereClient:
             session_id=session.session_id,
             target_column='is_fraud',
             target_column_type='set',
-            positive_label='fraud',
-            optimize_for='precision',  # Minimize false alarms
+            rare_label_value='fraud',
             class_imbalance={'legitimate': 0.999, 'fraud': 0.001}
         )
         ```
@@ -4174,8 +4626,7 @@ class FeatrixSphereClient:
             session_id=session.session_id,
             target_column='has_disease',
             target_column_type='set',
-            positive_label='positive',
-            optimize_for='recall'  # Don't miss any cases
+            rare_label_value='positive'
         )
         ```
         
@@ -4189,7 +4640,7 @@ class FeatrixSphereClient:
             target_column='churn',
             target_column_type='set',
             validation_ignore_columns=['customer_id', 'signup_date'],
-            positive_label='churned'
+            rare_label_value='churned'
         )
         ```
         
@@ -4215,9 +4666,8 @@ class FeatrixSphereClient:
                 embedding space! If neither provided, uses session's original data file.
             epochs: Number of training epochs (default: 0; automatic)
             validation_ignore_columns: List of column names to exclude from validation queries (default: None)
-            positive_label: For binary classification, which class is "positive" for metrics (default: None)
+            rare_label_value: For binary classification, which class is the rare/minority class for metrics (default: None)
             class_imbalance: Expected class ratios/counts from real world for sampled data (default: None)
-            optimize_for: Optimization target - "balanced" (F1 score), "precision", or "recall" (default: "balanced")
             poll_interval: Seconds between status checks when job is already running (default: 30)
             max_poll_time: Maximum time to poll in seconds (default: 3600 = 1 hour)
             verbose: Whether to print status updates during polling (default: True)
@@ -4234,6 +4684,17 @@ class FeatrixSphereClient:
         if file_path and df is not None:
             raise ValueError("Provide either file_path or df, not both")
         
+        # Validate cost parameters
+        if cost_false_positive is not None or cost_false_negative is not None:
+            if cost_false_positive is None or cost_false_negative is None:
+                raise ValueError("Both cost_false_positive and cost_false_negative must be specified together")
+            if target_column_type != "set":
+                raise ValueError("cost_false_positive and cost_false_negative are only valid for target_column_type='set' (classification), not 'scalar' (regression)")
+            if cost_false_positive <= 0 or cost_false_negative <= 0:
+                raise ValueError("cost_false_positive and cost_false_negative must be positive numbers")
+            if verbose:
+                print(f"💰 Cost-based optimization enabled: FP cost={cost_false_positive}, FN cost={cost_false_negative}")
+        
         # If DataFrame provided, save to temp file and use file_path logic
         temp_file = None
         if df is not None:
@@ -4264,9 +4725,10 @@ class FeatrixSphereClient:
                     target_column=target_column,
                     target_column_type=target_column_type,
                     epochs=epochs,
-                    positive_label=positive_label,
+                    rare_label_value=rare_label_value,
                     class_imbalance=class_imbalance,
-                    optimize_for=optimize_for,
+                    cost_false_positive=cost_false_positive,
+                    cost_false_negative=cost_false_negative,
                     verbose=verbose,
                     webhooks=webhooks
                 )
@@ -4277,10 +4739,12 @@ class FeatrixSphereClient:
                 "target_column_type": target_column_type,
                 "epochs": epochs,
                 "validation_ignore_columns": validation_ignore_columns or [],
-                "positive_label": positive_label,
-                "class_imbalance": class_imbalance,
-                "optimize_for": optimize_for
+                "rare_label_value": rare_label_value,
+                "class_imbalance": class_imbalance
             }
+            if cost_false_positive is not None and cost_false_negative is not None:
+                data["cost_false_positive"] = cost_false_positive
+                data["cost_false_negative"] = cost_false_negative
             if webhooks:
                 data['webhooks'] = webhooks
             
@@ -4577,9 +5041,8 @@ class FeatrixSphereClient:
 
     def train_predictor_more(self, session_id: str, epochs: int = 50,
                             predictor_id: str = None, target_column: str = None,
-                            batch_size: int = 0, learning_rate: float = None,
                             poll_interval: int = 30, max_poll_time: int = 3600,
-                            verbose: bool = True) -> Dict[str, Any]:
+                            verbose: bool = True, webhooks: Dict[str, str] = None) -> Dict[str, Any]:
         """
         Continue training an existing single predictor for more epochs.
         Loads the existing predictor and resumes training from where it left off.
@@ -4589,11 +5052,10 @@ class FeatrixSphereClient:
             epochs: Additional epochs to train (required)
             predictor_id: Predictor ID to continue training (optional, highest priority)
             target_column: Target column name to find predictor (optional, alternative to predictor_id)
-            batch_size: Batch size for continuation (0 = use existing from predictor)
-            learning_rate: Learning rate for continuation (None = use existing from predictor)
             poll_interval: Seconds between status checks (default: 30)
             max_poll_time: Maximum time to poll in seconds (default: 3600 = 1 hour)
             verbose: Whether to print status updates (default: True)
+            webhooks: Optional dict with webhook configuration keys (webhook_callback_secret, s3_backup_url, model_id_update_url)
             
         Returns:
             Response with continuation start confirmation or completion status
@@ -4616,15 +5078,14 @@ class FeatrixSphereClient:
         
         data = {
             "epochs": epochs,
-            "batch_size": batch_size,
         }
         
         if predictor_id:
             data["predictor_id"] = predictor_id
         if target_column:
             data["target_column"] = target_column
-        if learning_rate is not None:
-            data["learning_rate"] = learning_rate
+        if webhooks:
+            data["webhooks"] = webhooks
         
         if verbose:
             print(f"🔄 Continuing training for predictor on session {session_id}")
@@ -4714,6 +5175,139 @@ class FeatrixSphereClient:
                 print(f"❌ Error starting predictor continuation: {e}")
             raise
 
+    def foundation_model_train_more(self, session_id: str, es_id: str = None, data_passes: int = None,
+                                   epochs: int = None, poll_interval: int = 30, max_poll_time: int = 3600,
+                                   verbose: bool = True, webhooks: Dict[str, str] = None) -> Dict[str, Any]:
+        """
+        Continue training an existing foundation model (embedding space) for more epochs.
+        Loads the existing embedding space and resumes training from where it left off.
+        
+        Args:
+            session_id: Session ID containing the trained foundation model
+            es_id: Embedding space ID (optional, uses session's ES if not provided)
+            data_passes: Additional epochs to train (preferred, default: 50)
+            epochs: Additional epochs to train (deprecated, use data_passes instead, for compatibility)
+            poll_interval: Seconds between status checks (default: 30)
+            max_poll_time: Maximum time to poll in seconds (default: 3600 = 1 hour)
+            verbose: Whether to print status updates (default: True)
+            webhooks: Optional dict with webhook configuration keys (webhook_callback_secret, s3_backup_url, model_id_update_url)
+            
+        Returns:
+            Response with continuation start confirmation or completion status
+            
+        Example:
+            ```python
+            # Continue training for 50 more epochs
+            result = client.foundation_model_train_more(
+                session_id="abc123",
+                data_passes=50
+            )
+            ```
+        """
+        # Support both data_passes and epochs for compatibility
+        if data_passes is None and epochs is None:
+            data_passes = 50  # Default
+        elif data_passes is None:
+            data_passes = epochs  # Use epochs if data_passes not provided
+        # If both provided, data_passes takes precedence
+        
+        if data_passes <= 0:
+            raise ValueError("data_passes (or epochs) must be > 0 (specify additional epochs to train)")
+        
+        data = {
+            "data_passes": data_passes,
+        }
+        
+        if es_id:
+            data["es_id"] = es_id
+        if webhooks:
+            data["webhooks"] = webhooks
+        
+        if verbose:
+            print(f"🔄 Continuing training for foundation model on session {session_id}")
+            print(f"   Additional epochs: {data_passes}")
+            if es_id:
+                print(f"   ES ID: {es_id}")
+        
+        try:
+            response_data = self._post_json(f"/compute/session/{session_id}/train_foundation_model_more", data)
+            
+            if verbose:
+                print(f"✅ Foundation model continuation started: {response_data.get('message')}")
+            
+            # Poll for completion if requested
+            if poll_interval > 0 and max_poll_time > 0:
+                import time
+                start_time = time.time()
+                last_status = ""
+                
+                while time.time() - start_time < max_poll_time:
+                    try:
+                        session_info = self.get_session_status(session_id)
+                        jobs = session_info.jobs if hasattr(session_info, 'jobs') else {}
+                        
+                        # Find continuation jobs
+                        es_jobs = {j_id: j for j_id, j in jobs.items() 
+                                 if j.get('type') == 'train_es'}
+                        
+                        if not es_jobs:
+                            if verbose:
+                                print("✅ No continuation jobs found - training may have completed")
+                            break
+                        
+                        # Check job statuses
+                        running_jobs = [j_id for j_id, j in es_jobs.items() if j.get('status') == 'running']
+                        completed_jobs = [j_id for j_id, j in es_jobs.items() if j.get('status') == 'done']
+                        failed_jobs = [j_id for j_id, j in es_jobs.items() if j.get('status') == 'failed']
+                        
+                        current_status = f"Running: {len(running_jobs)}, Done: {len(completed_jobs)}, Failed: {len(failed_jobs)}"
+                        if current_status != last_status and verbose:
+                            print(f"📊 Status: {current_status}")
+                            last_status = current_status
+                        
+                        if not running_jobs and (completed_jobs or failed_jobs):
+                            if completed_jobs:
+                                if verbose:
+                                    print(f"✅ Foundation model continuation completed successfully!")
+                                return {
+                                    "message": "Foundation model continuation completed successfully",
+                                    "session_id": session_id,
+                                    "status": "completed",
+                                    "additional_epochs": data_passes
+                                }
+                            else:
+                                if verbose:
+                                    print(f"❌ Foundation model continuation failed")
+                                return {
+                                    "message": "Foundation model continuation failed",
+                                    "session_id": session_id,
+                                    "status": "failed",
+                                    "failed_jobs": failed_jobs
+                                }
+                        
+                        time.sleep(poll_interval)
+                    except Exception as poll_error:
+                        if verbose:
+                            print(f"⚠️ Error during polling: {poll_error}")
+                        time.sleep(poll_interval)
+                
+                # Timeout
+                if verbose:
+                    print(f"⏱️ Polling timeout reached ({max_poll_time}s)")
+                return {
+                    "message": "Polling timeout",
+                    "session_id": session_id,
+                    "status": "timeout",
+                    "additional_epochs": data_passes
+                }
+            
+            return response_data
+            
+        except Exception as e:
+            if verbose:
+                print(f"❌ Error starting foundation model continuation: {e}")
+            raise
+
     def _train_single_predictor_with_file(
         self,
         session_id: str,
@@ -4721,10 +5315,11 @@ class FeatrixSphereClient:
         target_column: str,
         target_column_type: str,
         epochs: int,
-        positive_label: str,
+        rare_label_value: str,
         class_imbalance: dict,
-        optimize_for: str,
-        verbose: bool,
+        cost_false_positive: float = None,
+        cost_false_negative: float = None,
+        verbose: bool = True,
         webhooks: Dict[str, str] = None
     ) -> Dict[str, Any]:
         """
@@ -4749,16 +5344,19 @@ class FeatrixSphereClient:
         data = {
             'target_column': target_column,
             'target_column_type': target_column_type,
-            'epochs': str(epochs),
-            'optimize_for': optimize_for,
+            'epochs': str(epochs)
         }
         
-        if positive_label:
-            data['positive_label'] = positive_label
+        if rare_label_value:
+            data['rare_label_value'] = rare_label_value
         
         if class_imbalance:
             data['class_imbalance'] = json.dumps(class_imbalance)
         
+        if cost_false_positive is not None and cost_false_negative is not None:
+            data['cost_false_positive'] = str(cost_false_positive)
+            data['cost_false_negative'] = str(cost_false_negative)
+        
         if webhooks:
             data['webhooks'] = json.dumps(webhooks)
         
@@ -5785,7 +6383,24 @@ class FeatrixSphereClient:
         if not file_path.exists():
             raise FileNotFoundError(f"File not found: {file_path}")
         
-        df = pd.read_csv(file_path)
+        # Support CSV, Parquet, JSON, and JSONL files
+        file_path_str = str(file_path).lower()
+        if file_path_str.endswith('.parquet'):
+            df = pd.read_parquet(file_path)
+        elif file_path_str.endswith('.jsonl'):
+            # JSONL: one JSON object per line
+            import json
+            records = []
+            with open(file_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    if line.strip():
+                        records.append(json.loads(line))
+            df = pd.DataFrame(records)
+        elif file_path_str.endswith('.json'):
+            # Regular JSON
+            df = pd.read_json(file_path)
+        else:
+            df = pd.read_csv(file_path)
         
         # Convert to JSON Tables format and clean NaNs
         table_data = JSONTablesEncoder.from_dataframe(df)
@@ -5939,11 +6554,11 @@ class FeatrixSphereClient:
     def run_csv_predictions(self, session_id: str, csv_file: str, target_column: str = None,
                            sample_size: int = None, remove_target: bool = True) -> Dict[str, Any]:
         """
-        Run predictions on a CSV file with automatic accuracy calculation.
+        Run predictions on a CSV, Parquet, JSON, or JSONL file with automatic accuracy calculation.
         
         Args:
             session_id: ID of session with trained predictor
-            csv_file: Path to CSV file
+            csv_file: Path to CSV, Parquet, JSON, or JSONL file
             target_column: Name of target column (for accuracy calculation)
             sample_size: Number of records to test (None = all records)
             remove_target: Whether to remove target column from prediction input
@@ -5953,8 +6568,24 @@ class FeatrixSphereClient:
         """
         import pandas as pd
         
-        # Load CSV
-        df = pd.read_csv(csv_file)
+        # Load CSV, Parquet, JSON, or JSONL
+        csv_file_lower = csv_file.lower()
+        if csv_file_lower.endswith('.parquet'):
+            df = pd.read_parquet(csv_file)
+        elif csv_file_lower.endswith('.jsonl'):
+            # JSONL: one JSON object per line
+            import json
+            records = []
+            with open(csv_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    if line.strip():
+                        records.append(json.loads(line))
+            df = pd.DataFrame(records)
+        elif csv_file_lower.endswith('.json'):
+            # Regular JSON
+            df = pd.read_json(csv_file)
+        else:
+            df = pd.read_csv(csv_file)
         
         # Handle target column
         actual_values = None

{featrixsphere-0.2.1002.dist-info → featrixsphere-0.2.1314.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featrixsphere
-Version: 0.2.1002
+Version: 0.2.1314
 Summary: Transform any CSV into a production-ready ML model in minutes, not months.
 Home-page: https://github.com/Featrix/sphere
 Author: Featrix

featrixsphere-0.2.1314.dist-info/RECORD

@@ -0,0 +1,9 @@
+featrixsphere/__init__.py,sha256=S0XWndX6ycMk8j03X_Dt_GpMuCMG2k0uwzoVJ6EbbnA,1888
+featrixsphere/cli.py,sha256=AW9O3vCvCNJ2UxVGN66eRmeN7XLSiHJlvK6JLZ9UJXc,13358
+featrixsphere/client.py,sha256=c1axFTTB6Hvdu2cWngN0VnkBdU0W0neTDKwzIU-IFXc,380183
+featrixsphere/test_client.py,sha256=4SiRbib0ms3poK0UpnUv4G0HFQSzidF3Iswo_J2cjLk,11981
+featrixsphere-0.2.1314.dist-info/METADATA,sha256=gu4_0nXC3gk8GfKB-lDbgrZPhdvTQCRcUEIlIMtWy-I,16232
+featrixsphere-0.2.1314.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+featrixsphere-0.2.1314.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
+featrixsphere-0.2.1314.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
+featrixsphere-0.2.1314.dist-info/RECORD,,

featrixsphere-0.2.1002.dist-info/RECORD

@@ -1,9 +0,0 @@
-featrixsphere/__init__.py,sha256=sevQkmuBmlhyq__FJhZi9d_8ts-PgzPLNDhTX--NoXM,1888
-featrixsphere/cli.py,sha256=AW9O3vCvCNJ2UxVGN66eRmeN7XLSiHJlvK6JLZ9UJXc,13358
-featrixsphere/client.py,sha256=rIq2kawfaffmq20-T1RBsbwibQJg0XRu3z5NVc1vgCw,349355
-featrixsphere/test_client.py,sha256=4SiRbib0ms3poK0UpnUv4G0HFQSzidF3Iswo_J2cjLk,11981
-featrixsphere-0.2.1002.dist-info/METADATA,sha256=M1heARJnCtK_p9bVNUZYhHL-RyWRNmYFiUwVMk0PBk8,16232
-featrixsphere-0.2.1002.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-featrixsphere-0.2.1002.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
-featrixsphere-0.2.1002.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
-featrixsphere-0.2.1002.dist-info/RECORD,,