edsl 0.1.62__py3-none-any.whl → 1.0.0__py3-none-any.whl

edsl/__init__.py

@@ -150,3 +150,69 @@ BaseException.install_exception_hook()
 
 # Log the total number of items in __all__ for debugging
 logger.debug(f"EDSL initialization complete with {len(__all__)} items in __all__")
+
+
+def check_for_updates(silent: bool = False) -> dict:
+    """
+    Check if there's a newer version of EDSL available.
+
+    Args:
+        silent: If True, don't print any messages to console
+
+    Returns:
+        dict with version info if update is available, None otherwise
+    """
+    from edsl.coop import Coop
+
+    coop = Coop()
+    return coop.check_for_updates(silent=silent)
+
+
+# Add check_for_updates to exports
+__all__.append("check_for_updates")
+
+
+# Perform version check on import (non-blocking)
+def _check_version_on_import():
+    """Check for updates on package import in a non-blocking way."""
+    import threading
+    import os
+
+    # Check if version check is disabled
+    if os.getenv("EDSL_DISABLE_VERSION_CHECK", "").lower() in ["1", "true", "yes"]:
+        return
+
+    # Check if we've already checked recently (within 24 hours)
+    cache_file = os.path.join(os.path.expanduser("~"), ".edsl_version_check")
+    try:
+        if os.path.exists(cache_file):
+            with open(cache_file, "r") as f:
+                last_check = float(f.read().strip())
+                if time.time() - last_check < 86400:  # 24 hours
+                    return
+    except Exception:
+        pass
+
+    def check_in_background():
+        try:
+            # Update cache file
+            with open(cache_file, "w") as f:
+                f.write(str(time.time()))
+
+            # Perform the check
+            from edsl.coop import Coop
+
+            coop = Coop()
+            coop.check_for_updates(silent=False)
+        except Exception:
+            # Silently fail
+            pass
+
+    check_in_background()
+    # # Run in a separate thread to avoid blocking imports
+    # thread = threading.Thread(target=check_in_background, daemon=True)
+    # thread.start()
+
+
+# Run version check on import
+_check_version_on_import()

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.62"
+__version__ = "1.0.0"

edsl/base/base_class.py

@@ -516,6 +516,51 @@ class PersistenceMixin:
         c = Coop()
         return c.search(cls, query)
 
+    def clipboard(self):
+        """Copy this object's representation to the system clipboard.
+
+        This method first checks if the object has a custom clipboard_data() method.
+        If it does, it uses that method's output. Otherwise, it serializes the object 
+        to a dictionary (without version info) and copies it to the system clipboard as JSON text.
+
+        Returns:
+            None, but prints a confirmation message
+        """
+        import subprocess
+        import json
+        import platform
+
+        # Check if the object has a custom clipboard_data method
+        if hasattr(self, 'clipboard_data') and callable(getattr(self, 'clipboard_data')):
+            clipboard_text = self.clipboard_data()
+        else:
+            # Default behavior: use to_dict and convert to JSON
+            obj_dict = self.to_dict(add_edsl_version=False)
+            clipboard_text = json.dumps(obj_dict, indent=2)
+
+        # Determine the clipboard command based on the operating system
+        system = platform.system()
+        
+        try:
+            if system == "Darwin":  # macOS
+                process = subprocess.Popen(['pbcopy'], stdin=subprocess.PIPE)
+                process.communicate(clipboard_text.encode('utf-8'))
+            elif system == "Linux":
+                process = subprocess.Popen(['xclip', '-selection', 'clipboard'], stdin=subprocess.PIPE)
+                process.communicate(clipboard_text.encode('utf-8'))
+            elif system == "Windows":
+                process = subprocess.Popen(['clip'], stdin=subprocess.PIPE, shell=True)
+                process.communicate(clipboard_text.encode('utf-8'))
+            else:
+                print(f"Clipboard not supported on {system}")
+                return
+            
+            print("Object data copied to clipboard")
+        except FileNotFoundError:
+            print("Clipboard command not found. Please install pbcopy (macOS), xclip (Linux), or use Windows.")
+        except Exception as e:
+            print(f"Failed to copy to clipboard: {e}")
+
     def store(self, d: dict, key_name: Optional[str] = None):
         if key_name is None:
             index = len(d)

edsl/cli.py

@@ -26,91 +26,113 @@ app.add_typer(plugins_app, name="plugins")
 validation_app = typer.Typer(help="Manage EDSL validation failures")
 app.add_typer(validation_app, name="validation")
 
+
 @validation_app.command("logs")
 def list_validation_logs(
     count: int = typer.Option(10, "--count", "-n", help="Number of logs to show"),
-    question_type: Optional[str] = typer.Option(None, "--type", "-t", help="Filter by question type"),
-    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file path"),
+    question_type: Optional[str] = typer.Option(
+        None, "--type", "-t", help="Filter by question type"
+    ),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
 ):
     """List validation failure logs."""
     from .questions.validation_logger import get_validation_failure_logs
-    
+
     logs = get_validation_failure_logs(n=count)
-    
+
     # Filter by question type if provided
     if question_type:
         logs = [log for log in logs if log.get("question_type") == question_type]
-    
+
     if output:
         with open(output, "w") as f:
             json.dump(logs, f, indent=2)
         console.print(f"[green]Logs written to {output}[/green]")
     else:
         console.print_json(json.dumps(logs, indent=2))
-        
+
+
 @validation_app.command("clear")
 def clear_validation_logs():
     """Clear validation failure logs."""
     from .questions.validation_logger import clear_validation_logs
-    
+
     clear_validation_logs()
     console.print("[green]Validation logs cleared.[/green]")
-        
+
+
 @validation_app.command("stats")
 def validation_stats(
-    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file path"),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
 ):
     """Show validation failure statistics."""
     from .questions.validation_analysis import get_validation_failure_stats
-    
+
     stats = get_validation_failure_stats()
-    
+
     if output:
         with open(output, "w") as f:
             json.dump(stats, f, indent=2)
         console.print(f"[green]Stats written to {output}[/green]")
     else:
         console.print_json(json.dumps(stats, indent=2))
-        
+
+
 @validation_app.command("suggest")
 def suggest_improvements(
-    question_type: Optional[str] = typer.Option(None, "--type", "-t", help="Filter by question type"),
-    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file path"),
+    question_type: Optional[str] = typer.Option(
+        None, "--type", "-t", help="Filter by question type"
+    ),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
 ):
     """Suggest improvements for fix methods."""
     from .questions.validation_analysis import suggest_fix_improvements
-    
+
     suggestions = suggest_fix_improvements(question_type=question_type)
-    
+
     if output:
         with open(output, "w") as f:
             json.dump(suggestions, f, indent=2)
         console.print(f"[green]Suggestions written to {output}[/green]")
     else:
         console.print_json(json.dumps(suggestions, indent=2))
-        
+
+
 @validation_app.command("report")
 def generate_report(
-    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file path"),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
 ):
     """Generate a comprehensive validation report."""
     from .questions.validation_analysis import export_improvements_report
-    
+
     report_path = export_improvements_report(output_path=output)
     console.print(f"[green]Report generated at: {report_path}[/green]")
-    
+
+
 @validation_app.command("html-report")
 def generate_html_report(
-    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file path"),
-    open_browser: bool = typer.Option(True, "--open/--no-open", help="Open the report in a browser"),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+    open_browser: bool = typer.Option(
+        True, "--open/--no-open", help="Open the report in a browser"
+    ),
 ):
     """Generate an HTML validation report and optionally open it in a browser."""
     from .questions.validation_html_report import generate_html_report
     import webbrowser
-    
+
     report_path = generate_html_report(output_path=output)
     console.print(f"[green]HTML report generated at: {report_path}[/green]")
-    
+
     if open_browser:
         try:
             webbrowser.open(f"file://{report_path}")
@@ -119,15 +141,17 @@ def generate_html_report(
             console.print(f"[yellow]Could not open browser: {e}[/yellow]")
             console.print(f"[yellow]Report is available at: {report_path}[/yellow]")
 
+
 @app.callback()
 def callback():
     """
     Expected Parrot EDSL Command Line Interface.
-    
+
     A toolkit for creating, managing, and running surveys with language models.
     """
     pass
 
+
 @app.command()
 def version():
     """Show the EDSL version."""
@@ -135,8 +159,50 @@ def version():
         version = metadata.version("edsl")
         console.print(f"[bold cyan]EDSL version:[/bold cyan] {version}")
     except metadata.PackageNotFoundError:
-        console.print("[yellow]EDSL package not installed or version not available.[/yellow]")
+        console.print(
+            "[yellow]EDSL package not installed or version not available.[/yellow]"
+        )
+
+
+@app.command()
+def check_updates():
+    """Check for available EDSL updates."""
+    try:
+        from edsl import check_for_updates
+
+        console.print("[cyan]Checking for updates...[/cyan]")
+        update_info = check_for_updates(silent=True)
+
+        if update_info:
+            console.print("\n[bold yellow]📦 Update Available![/bold yellow]")
+            console.print(
+                f"[cyan]Current version:[/cyan] {update_info['current_version']}"
+            )
+            console.print(
+                f"[green]Latest version:[/green] {update_info['latest_version']}"
+            )
+            if update_info.get("update_info"):
+                console.print(f"[cyan]Update info:[/cyan] {update_info['update_info']}")
+            console.print(f"\n[bold]To update:[/bold] {update_info['update_command']}")
+        else:
+            console.print(
+                "[green]✓ You are running the latest version of EDSL![/green]"
+            )
+    except Exception as e:
+        console.print(f"[red]Error checking for updates: {str(e)}[/red]")
+
 
 def main():
     """Main entry point for the EDSL CLI."""
-    app()
+    # Check for updates on startup if environment variable is set
+    import os
+
+    if os.getenv("EDSL_CHECK_UPDATES_ON_STARTUP", "").lower() in ["1", "true", "yes"]:
+        try:
+            from edsl import check_for_updates
+
+            check_for_updates(silent=False)
+        except Exception:
+            pass  # Silently fail if update check fails
+
+    app()

edsl/config/config_class.py

@@ -111,6 +111,10 @@ CONFIG_MAP = {
         "default": "10",  # Change to a very low threshold (10 bytes) to test SQLite offloading
         "info": "This config var determines the memory threshold in bytes before Results' SQLList offloads data to SQLite.",
     },
+    "EDSL_USE_SQLITE_FOR_SCENARIO_LIST": {
+        "default": "False",
+        "info": "This config var determines whether to use SQLite for ScenarioList instances.",
+    },
 }
 
 

edsl/coop/coop.py

@@ -273,6 +273,118 @@ class Coop(CoopFunctionsMixin):
 
         return user_stable_version < server_stable_version
 
+    def check_for_updates(self, silent: bool = False) -> Optional[dict]:
+        """
+        Check if there's a newer version of EDSL available.
+
+        Args:
+            silent: If True, don't print any messages to console
+
+        Returns:
+            dict with version info if update is available, None otherwise
+        """
+        try:
+            # Use the new /version/updates endpoint
+            response = self._send_server_request(
+                uri="version/updates", method="GET", timeout=5
+            )
+
+            data = response.json()
+
+            # Extract version information from the response
+            current_version = data.get("current")  # Latest version in use
+            guid_message = data.get("guid_message", "")  # Message about updates
+            force_update = (
+                "force update" in guid_message.lower() if guid_message else False
+            )
+            # Check if update is needed
+            if current_version and self._user_version_is_outdated(
+                user_version_str=self._edsl_version,
+                server_version_str=current_version,
+            ):
+                update_data = {
+                    "current_version": self._edsl_version,
+                    "latest_version": current_version,
+                    "guid_message": guid_message,
+                    "force_update": force_update,
+                    "update_command": "pip install --upgrade edsl",
+                }
+
+                if not silent:
+                    print("\n" + "=" * 60)
+                    print("📦 EDSL Update Available!")
+                    print(f"Your version: {self._edsl_version}")
+                    print(f"Latest version: {current_version}")
+
+                    # Display the guid message if present
+                    if guid_message:
+                        print(f"\n{guid_message}")
+
+                    # Prompt user for update
+                    prompt_message = "\nDo you want to update now? [Y/n] "
+                    if force_update:
+                        prompt_message = "\n⚠️  FORCE UPDATE REQUIRED - Do you want to update now? [Y/n] "
+
+                    print(prompt_message, end="")
+
+                    try:
+                        user_input = input().strip().lower()
+                        if user_input in ["", "y", "yes"]:
+                            # Actually run the update
+                            print("\nUpdating EDSL...")
+                            import subprocess
+                            import sys
+
+                            try:
+                                # Run pip install --upgrade edsl
+                                result = subprocess.run(
+                                    [
+                                        sys.executable,
+                                        "-m",
+                                        "pip",
+                                        "install",
+                                        "--upgrade",
+                                        "edsl",
+                                    ],
+                                    capture_output=True,
+                                    text=True,
+                                )
+
+                                if result.returncode == 0:
+                                    print(
+                                        "✅ Update successful! Please restart your application."
+                                    )
+                                else:
+                                    print(f"❌ Update failed: {result.stderr}")
+                                    print(
+                                        "You can try updating manually with: pip install --upgrade edsl"
+                                    )
+                            except Exception as e:
+                                print(f"❌ Update failed: {str(e)}")
+                                print(
+                                    "You can try updating manually with: pip install --upgrade edsl"
+                                )
+                        else:
+                            print(
+                                "\nUpdate skipped. You can update later with: pip install --upgrade edsl"
+                            )
+
+                        print("=" * 60 + "\n")
+
+                    except (EOFError, KeyboardInterrupt):
+                        print(
+                            "\nUpdate skipped. You can update later with: pip install --upgrade edsl"
+                        )
+                        print("=" * 60 + "\n")
+
+                return update_data
+
+        except Exception:
+            # Silently fail if we can't check for updates
+            pass
+
+        return None
+
     def _resolve_server_response(
         self, response: requests.Response, check_api_key: bool = True
     ) -> None:
@@ -280,18 +392,35 @@ class Coop(CoopFunctionsMixin):
         Check the response from the server and raise errors as appropriate.
         """
         # Get EDSL version from header
-        # breakpoint()
-        # Commented out as currently unused
-        # server_edsl_version = response.headers.get("X-EDSL-Version")
-
-        # if server_edsl_version:
-        #     if self._user_version_is_outdated(
-        #         user_version_str=self._edsl_version,
-        #         server_version_str=server_edsl_version,
-        #     ):
-        #         print(
-        #             "Please upgrade your EDSL version to access our latest features. Open your terminal and run `pip install --upgrade edsl`"
-        #         )
+        server_edsl_version = response.headers.get("X-EDSL-Version")
+
+        if server_edsl_version:
+            if self._user_version_is_outdated(
+                user_version_str=self._edsl_version,
+                server_version_str=server_edsl_version,
+            ):
+                # Get additional info from server if available
+                update_info = response.headers.get("X-EDSL-Update-Info", "")
+
+                print("\n" + "=" * 60)
+                print("📦 EDSL Update Available!")
+                print(f"Your version: {self._edsl_version}")
+                print(f"Latest version: {server_edsl_version}")
+                if update_info:
+                    print(f"Update info: {update_info}")
+                print(
+                    "\nYour version is out of date - can we update to latest version? [Y/n]"
+                )
+
+                try:
+                    user_input = input().strip().lower()
+                    if user_input in ["", "y", "yes"]:
+                        print("To update, run: pip install --upgrade edsl")
+                        print("=" * 60 + "\n")
+                except (EOFError, KeyboardInterrupt):
+                    # Handle non-interactive environments
+                    print("To update, run: pip install --upgrade edsl")
+                    print("=" * 60 + "\n")
         if response.status_code >= 400:
             try:
                 message = str(response.json().get("detail"))
@@ -1562,7 +1691,6 @@ class Coop(CoopFunctionsMixin):
 
         # The job has been offloaded to GCS
         if include_json_string and json_string == "offloaded":
-
             # Attempt to fetch JSON string from GCS
             response = self._send_server_request(
                 uri="api/v0/remote-inference/pull",

edsl/dataset/dataset.py

@@ -1017,6 +1017,53 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
         # Save the document
         doc.save(output_file)
 
+    def unique(self) -> "Dataset":
+        """
+        Remove duplicate rows from the dataset.
+        
+        Returns:
+            A new Dataset with duplicate rows removed.
+            
+        Examples:
+            >>> d = Dataset([{'a': [1, 2, 3, 1]}, {'b': [4, 5, 6, 4]}])
+            >>> d.unique().data
+            [{'a': [1, 2, 3]}, {'b': [4, 5, 6]}]
+            
+            >>> d = Dataset([{'x': ['a', 'b', 'a']}, {'y': [1, 2, 1]}])
+            >>> d.unique().data
+            [{'x': ['a', 'b']}, {'y': [1, 2]}]
+            
+            >>> # Dataset with a single column
+            >>> Dataset([{'value': [1, 2, 3, 2, 1, 3]}]).unique().data
+            [{'value': [1, 2, 3]}]
+        """
+        # Convert data to tuples for each row to make them hashable
+        rows = []
+        for i in range(len(self)):
+            row = tuple(entry[list(entry.keys())[0]][i] for entry in self.data)
+            rows.append(row)
+        
+        # Keep track of unique rows and their indices
+        unique_rows = []
+        indices = []
+        
+        # Use a set to track seen rows
+        seen = set()
+        for i, row in enumerate(rows):
+            if row not in seen:
+                seen.add(row)
+                unique_rows.append(row)
+                indices.append(i)
+        
+        # Create a new dataset with only the unique rows
+        new_data = []
+        for entry in self.data:
+            key, values = list(entry.items())[0]
+            new_values = [values[i] for i in indices]
+            new_data.append({key: new_values})
+            
+        return Dataset(new_data)
+
     def expand(self, field: str, number_field: bool = False) -> "Dataset":
         """
         Expand a field containing lists into multiple rows.
@@ -1086,47 +1133,6 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
         
         return Dataset(new_data)
 
-    def unique(self) -> "Dataset":
-        """Return a new dataset with only unique observations.
-        
-        Examples:
-            >>> d = Dataset([{'a': [1, 2, 2, 3]}, {'b': [4, 5, 5, 6]}])
-            >>> d.unique().data
-            [{'a': [1, 2, 3]}, {'b': [4, 5, 6]}]
-            
-            >>> d = Dataset([{'x': ['a', 'a', 'b']}, {'y': [1, 1, 2]}])
-            >>> d.unique().data
-            [{'x': ['a', 'b']}, {'y': [1, 2]}]
-        """
-        # Get all column names and values
-        headers, data = self._tabular()
-        
-        # Create a list of unique rows
-        unique_rows = []
-        seen = set()
-        
-        for row in data:
-            # Convert the row to a hashable representation for comparison
-            # We need to handle potential unhashable types
-            try:
-                row_key = tuple(map(lambda x: str(x) if isinstance(x, (list, dict)) else x, row))
-                if row_key not in seen:
-                    seen.add(row_key)
-                    unique_rows.append(row)
-            except:
-                # Fallback for complex objects: compare based on string representation
-                row_str = str(row)
-                if row_str not in seen:
-                    seen.add(row_str)
-                    unique_rows.append(row)
-        
-        # Create a new dataset with unique combinations
-        new_data = []
-        for i, header in enumerate(headers):
-            values = [row[i] for row in unique_rows]
-            new_data.append({header: values})
-        
-        return Dataset(new_data)
 
 
 if __name__ == "__main__":