featrixsphere 0.2.2279__py3-none-any.whl → 0.2.3611__py3-none-any.whl

featrixsphere/__init__.py

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

featrixsphere/client.py

@@ -4547,20 +4547,20 @@ class FeatrixSphereClient:
                 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)
+                # Create temporary parquet file (faster and more efficient than CSV)
+                temp_file = tempfile.NamedTemporaryFile(mode='wb', suffix='.parquet', delete=False)
                 temp_file_path = temp_file.name
                 temp_file.close()
                 
-                # Save DataFrame to temp file
-                df.to_csv(temp_file_path, index=False)
+                # Save DataFrame to temp parquet file
+                df.to_parquet(temp_file_path, index=False, engine='pyarrow')
                 
                 if verbose:
-                    print(f"📁 Saved to temporary file: {os.path.basename(temp_file_path)}")
+                    print(f"📁 Saved to temporary parquet 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')}
+                files = {'file': (os.path.basename(temp_file_path), open(temp_file_path, 'rb'), 'application/octet-stream')}
                 
             elif input_filename:
                 # If absolute path provided, send file directly
@@ -4573,8 +4573,17 @@ class FeatrixSphereClient:
                     if verbose:
                         print(f"📤 Sending file directly from absolute path: {input_filename}")
                     
+                    # Determine MIME type based on file extension
+                    mime_type = 'application/octet-stream'  # Default fallback
+                    if input_path.suffix == '.csv':
+                        mime_type = 'text/csv'
+                    elif input_path.suffix == '.parquet':
+                        mime_type = 'application/octet-stream'
+                    elif input_path.suffix == '.gz':
+                        mime_type = 'application/gzip'
+                    
                     # Send file in multipart form
-                    files = {'file': (input_path.name, open(input_path, 'rb'), 'text/csv' if input_path.suffix == '.csv' else 'application/gzip')}
+                    files = {'file': (input_path.name, open(input_path, 'rb'), mime_type)}
                 else:
                     # Relative filename - assume it's already on the server
                     data["input_filename"] = input_filename
@@ -5007,14 +5016,44 @@ class FeatrixSphereClient:
         The system handles the hard decisions so you can focus on your problem, not 
         hyperparameter tuning.
 
+        MULTI-DATASET INPUT (NEW):
+        ---------------------------
+        You can now pass a dictionary of datasets for the `df` parameter, just like in
+        upload_df_and_create_session(). This is useful when combining multiple sources
+        for predictor training:
+        
+        ```python
+        # Train predictor on multiple datasets with labels
+        training_data = {
+            'extra_rows_from_matt': ['matt_supplement.csv', 'matt_additions.parquet'],
+            'main_training': [df1, df2, 'training.csv'],
+            'validation_samples': ['validation.csv']
+        }
+        
+        result = client.train_single_predictor(
+            session_id=session.session_id,
+            df=training_data,  # Dictionary of datasets
+            target_column='outcome',
+            target_column_type='set'
+        )
+        ```
+        
+        When using dictionary format:
+        - Each key is a dataset name (e.g., 'extra_rows_from_matt')
+        - Each value is a list of DataFrames and/or file paths
+        - A __featrix_dataset_name column is automatically added
+        - All tables are concatenated before training
+        - Works with all file types: CSV, Parquet, JSON, JSONL
+        
         Args:
             session_id: ID of session with trained embedding space
             target_column: Name of the target column to predict
             target_column_type: Type of target column ("set" or "scalar")
             file_path: Path to DIFFERENT training file (CSV or .csv.gz) to use for predictor training.
-            df: pandas DataFrame with DIFFERENT training data to use for predictor training.
-                Use file_path OR df (not both) to train predictor on different data than your 
-                embedding space! If neither provided, uses session's original data file.
+            df: pandas DataFrame OR dict of {dataset_name: [DataFrames/file paths]} with DIFFERENT 
+                training data to use for predictor training. Use file_path OR df (not both) to train 
+                predictor on different data than your 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)
             rare_label_value: For binary classification, which class is the rare/minority class for metrics (default: None)
@@ -5035,6 +5074,86 @@ class FeatrixSphereClient:
         if file_path and df is not None:
             raise ValueError("Provide either file_path or df, not both")
         
+        # Handle dictionary of datasets input (same as upload_df_and_create_session)
+        if df is not None and isinstance(df, dict):
+            if verbose:
+                print("Detected dictionary of datasets - concatenating with __featrix_dataset_name labels")
+            all_dataframes = []
+            total_rows = 0
+            
+            for dataset_name, tables in df.items():
+                if not isinstance(tables, list):
+                    raise ValueError(f"Value for dataset '{dataset_name}' must be a list of DataFrames/file paths, got {type(tables)}")
+                
+                for i, table in enumerate(tables):
+                    # Handle file path (string)
+                    if isinstance(table, str):
+                        file_path_to_load = str(table)
+                        
+                        if not os.path.exists(file_path_to_load):
+                            raise FileNotFoundError(f"File not found in dataset '{dataset_name}': {file_path_to_load}")
+                        
+                        # Determine file type and load
+                        file_ext = file_path_to_load.lower()
+                        if verbose:
+                            print(f"  - {dataset_name} loading file: {os.path.basename(file_path_to_load)}")
+                        
+                        if file_ext.endswith('.parquet'):
+                            loaded_df = pd.read_parquet(file_path_to_load)
+                        elif file_ext.endswith(('.json', '.jsonl')):
+                            try:
+                                from featrix.neural.input_data_file import featrix_wrap_read_json_file
+                                loaded_df = featrix_wrap_read_json_file(file_path_to_load)
+                                if loaded_df is None:
+                                    raise ValueError(f"Failed to parse {'JSONL' if file_ext.endswith('.jsonl') else 'JSON'} file")
+                            except ImportError:
+                                # Fallback to pandas
+                                if file_ext.endswith('.jsonl'):
+                                    import json
+                                    records = []
+                                    with open(file_path_to_load, 'r', encoding='utf-8') as f:
+                                        for line in f:
+                                            if line.strip():
+                                                records.append(json.loads(line))
+                                    loaded_df = pd.DataFrame(records)
+                                else:
+                                    loaded_df = pd.read_json(file_path_to_load)
+                        elif file_ext.endswith(('.csv', '.csv.gz')):
+                            loaded_df = pd.read_csv(file_path_to_load)
+                        else:
+                            raise ValueError(f"Unsupported file type in dataset '{dataset_name}': {file_path_to_load}. "
+                                           f"Supported: .csv, .csv.gz, .parquet, .json, .jsonl")
+                        
+                        labeled_table = loaded_df
+                        if verbose:
+                            print(f"    Loaded {len(loaded_df)} rows, {len(loaded_df.columns)} columns")
+                    
+                    # Handle DataFrame
+                    elif isinstance(table, pd.DataFrame):
+                        # Create a copy to avoid modifying the original
+                        labeled_table = table.copy()
+                        if verbose:
+                            print(f"  - {dataset_name} DataFrame {i+1}: {len(labeled_table)} rows, {len(labeled_table.columns)} columns")
+                    
+                    else:
+                        raise ValueError(f"Table {i} in dataset '{dataset_name}' must be a pandas DataFrame or file path (str), got {type(table)}")
+                    
+                    # Add the dataset name label column
+                    labeled_table['__featrix_dataset_name'] = dataset_name
+                    
+                    all_dataframes.append(labeled_table)
+                    total_rows += len(labeled_table)
+            
+            if not all_dataframes:
+                raise ValueError("No DataFrames found in the provided dictionary")
+            
+            # Concatenate all dataframes
+            if verbose:
+                print(f"Concatenating {len(all_dataframes)} tables from {len(df)} datasets ({total_rows} total rows)")
+            df = pd.concat(all_dataframes, ignore_index=True)
+            if verbose:
+                print(f"Combined DataFrame: {len(df)} rows, {len(df.columns)} columns (includes __featrix_dataset_name)")
+        
         # 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:
@@ -5055,17 +5174,17 @@ class FeatrixSphereClient:
             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)
+            # Create temporary parquet file (faster and more efficient than CSV)
+            temp_file = tempfile.NamedTemporaryFile(mode='wb', suffix='.parquet', delete=False)
             temp_file_path = temp_file.name
             temp_file.close()
             
-            # Save DataFrame to temp file
-            df.to_csv(temp_file_path, index=False)
+            # Save DataFrame to temp parquet file
+            df.to_parquet(temp_file_path, index=False, engine='pyarrow')
             file_path = temp_file_path
             
             if verbose:
-                print(f"📁 Saved to temporary file: {os.path.basename(temp_file_path)}")
+                print(f"📁 Saved to temporary parquet file: {os.path.basename(temp_file_path)}")
         
         try:
             # If a custom training file is provided (or we created one from df), use the file upload endpoint
@@ -5296,17 +5415,17 @@ class FeatrixSphereClient:
             if verbose:
                 print(f"📊 Using provided DataFrame ({len(new_data_df)} rows, {len(new_data_df.columns)} columns)")
             
-            # Create temporary CSV file
-            temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False)
+            # Create temporary parquet file (faster and more efficient than CSV)
+            temp_file = tempfile.NamedTemporaryFile(mode='wb', suffix='.parquet', delete=False)
             temp_file_path = temp_file.name
             temp_file.close()
             
-            # Save DataFrame to temp file
-            new_data_df.to_csv(temp_file_path, index=False)
+            # Save DataFrame to temp parquet file
+            new_data_df.to_parquet(temp_file_path, index=False, engine='pyarrow')
             file_to_upload = temp_file_path
             
             if verbose:
-                print(f"📁 Saved to temporary file: {os.path.basename(temp_file_path)}")
+                print(f"📁 Saved to temporary parquet file: {os.path.basename(temp_file_path)}")
         
         try:
             # Prepare file upload
@@ -5901,8 +6020,17 @@ class FeatrixSphereClient:
             print(f"📤 Uploading custom training file: {file_path.name}")
         
         # Prepare the multipart form data
+        # Determine MIME type based on file extension
+        mime_type = 'application/octet-stream'  # Default fallback
+        if file_path.suffix == '.csv':
+            mime_type = 'text/csv'
+        elif file_path.suffix == '.parquet':
+            mime_type = 'application/octet-stream'  # Parquet MIME type
+        elif file_path.suffix == '.gz':
+            mime_type = 'application/gzip'
+        
         files = {
-            'file': (file_path.name, open(file_path, 'rb'), 'text/csv' if file_path.suffix == '.csv' else 'application/gzip')
+            'file': (file_path.name, open(file_path, 'rb'), mime_type)
         }
         
         data = {

{featrixsphere-0.2.2279.dist-info → featrixsphere-0.2.3611.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featrixsphere
-Version: 0.2.2279
+Version: 0.2.3611
 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.3611.dist-info/RECORD

@@ -0,0 +1,8 @@
+featrixsphere/__init__.py,sha256=0Aq33fh4GcL9nPH57I7gam8zpatQ3Ouooy6qBE98FdE,1888
+featrixsphere/client.py,sha256=TiEZIT1Qmc983CbPljc8__e0jJRnpQ3Lf6SabwrvLlo,415649
+featrixsphere/test_client.py,sha256=4SiRbib0ms3poK0UpnUv4G0HFQSzidF3Iswo_J2cjLk,11981
+featrixsphere-0.2.3611.dist-info/METADATA,sha256=Ix0dJltPnTz5HCdFzy9fE8vLPGSttGQ56G6GhBXUwwM,16232
+featrixsphere-0.2.3611.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+featrixsphere-0.2.3611.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
+featrixsphere-0.2.3611.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
+featrixsphere-0.2.3611.dist-info/RECORD,,

featrixsphere-0.2.2279.dist-info/RECORD

@@ -1,8 +0,0 @@
-featrixsphere/__init__.py,sha256=CdXrzec_MfZTUpRyajYawHBu5iEWAe-flVrlXjiLLN8,1888
-featrixsphere/client.py,sha256=ez8ML3OMHMMO0ewzOGNgF1tg3KYygLG2NbEw33sf3AA,408591
-featrixsphere/test_client.py,sha256=4SiRbib0ms3poK0UpnUv4G0HFQSzidF3Iswo_J2cjLk,11981
-featrixsphere-0.2.2279.dist-info/METADATA,sha256=2hEITDtsSYmMLgl0RfqvcBzac4EBAH3DN4TSVf_1rPY,16232
-featrixsphere-0.2.2279.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-featrixsphere-0.2.2279.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
-featrixsphere-0.2.2279.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
-featrixsphere-0.2.2279.dist-info/RECORD,,