mitosheet 0.2.54__py2.py3-none-any.whl → 0.2.55__py2.py3-none-any.whl

mitosheet/dataframe_display_formatters.py

@@ -2,82 +2,49 @@
 # Distributed under the terms of the GNU Affero General Public License v3.0 License.
 
 """
-    This code is responsible for making mitosheet the default dataframe display when Jupyter 
-    is rendering a dataframe to the output cell. 
+This code is responsible for making mitosheet the default dataframe display when Jupyter
+is rendering a dataframe to the output cell.
 
-    This approach works by overriding the default HTML and plain text formatters for pandas DataFrames in IPython.
-    When a DataFrame is displayed, the custom formatter functions are called, which in turn call mitosheet.sheet()
-    to render the DataFrame using mitosheet. 
-    
-    In order for the custom renderers to work, the mitosheet package must first be imported in the user's kernel. 
-    To do so, when the Mito extension is activated, we register a kernel status listener that imports the mitosheet package
-    whenever the kernel changes.
+The new approach add a new custom mimetype to hook a custom viewer. This allows to keep
+the default view if the user prefers it.
 
-    This approach still fails the race condition caused when the user clicks "Restart Kernel and run all cells". 
-    When doing so, the `import mitosheet` does not get executed until after all of the code cells have been executed. 
-    Which means that the mitosheet package is not imported when rendering any dataframes in the notebook. In
-    this case, we just default to the pandas dataframe renderer. That is okay.
+_____
 
-    _____
+Previous approaches:
 
-    Previous approaches: 
-    
-    Before landing on this approach, we tried to create a custom dataframe mime renderer. Using the mime renderer
-    did not work because: 
+This approach works by overriding the default HTML and plain text formatters for pandas DataFrames in IPython.
+When a DataFrame is displayed, the custom formatter functions are called, which in turn call mitosheet.sheet()
+to render the DataFrame using mitosheet.
 
-    In order to create the mitosheet, we need to execute the mitosheet.sheet() function. To do so, we 
-    had to send a new kernel message from the mimerender with the code mitosheet.sheet(df). However, becasue
-    the kernel message queue might have had additional messages already queued that edited the df, by the time
-    the mitosheet was rendered, it might have displayed a dataframe that reflected future code cell edits instead of the
-    current state of the dataframe at the time the code cell with the hanging df was executed. This is not what we want. 
+In order for the custom renderers to work, the mitosheet package must first be imported in the user's kernel.
+To do so, when the Mito extension is activated, we register a kernel status listener that imports the mitosheet package
+whenever the kernel changes.
 
-    For a more thorough explanation of attempted solutions, see the comment here: https://github.com/mito-ds/mito/pull/1330#issuecomment-2386428760
-    """
-
-def set_dataframe_display_formatters() -> None:
+This approach still fails the race condition caused when the user clicks "Restart Kernel and run all cells".
+When doing so, the `import mitosheet` does not get executed until after all of the code cells have been executed.
+Which means that the mitosheet package is not imported when rendering any dataframes in the notebook. In
+this case, we just default to the pandas dataframe renderer. That is okay.
 
-    try: 
-        # Since Mito is used in Streamlit which is not a iPython enviornment, 
-        # we just wrap this entire thing in a try, except statement 
+Before landing on this approach, we tried to create a custom dataframe mime renderer. Using the mime renderer
+did not work because:
 
-        from IPython import get_ipython
-        import pandas as pd
-        import mitosheet
+In order to create the mitosheet, we need to execute the mitosheet.sheet() function. To do so, we
+had to send a new kernel message from the mimerender with the code mitosheet.sheet(df). However, becasue
+the kernel message queue might have had additional messages already queued that edited the df, by the time
+the mitosheet was rendered, it might have displayed a dataframe that reflected future code cell edits instead of the
+current state of the dataframe at the time the code cell with the hanging df was executed. This is not what we want.
 
-        ip = get_ipython() # type: ignore
-        if not ip: # Exit if not in an IPython environment
-            return
+For a more thorough explanation of attempted solutions, see the comment here: https://github.com/mito-ds/mito/pull/1330#issuecomment-2386428760
+"""
 
-        # Custom HTML formatter for DataFrames using Mitosheet
-        def mitosheet_display_formatter(obj, include=None, exclude=None):
-            if isinstance(obj, pd.DataFrame):
-                # Render the DataFrame using Mitosheet
-                return mitosheet.sheet(obj, input_cell_execution_count=ip.execution_count)
-            # Returning None tells Jupyter that this formatter (the text/html one) didn’t produce any output for the given object.
-            # This causes Jupyter to “fall back” to lower-priority formatters (like text/plain).
-            return None
+from .formatter import register_ipython_formatter
 
-        # Custom plain text formatter to suppress plain text for DataFrames
-        def mitosheet_plain_formatter(obj, p, cycle):
-            # TODO: I'm not 100% confident that this is correct, but if I don't overwrite the plain text formatter
-            # for dataframes, then I end up getting the mitosheet followed by a printed version of the dataframe.
-            if isinstance(obj, pd.DataFrame):
-                # Returning None here tells Jupyter not to render anything in the text/plain format 
-                # for DataFrames. In this case, Jupyter has already rendered the text/html output, 
-                # so returning None for text/plain means “suppress this output,” 
-                # preventing Jupyter from rendering the plain text fallback.
-                return None
-            # For other objects, use the default plain text formatter
-            return p.text(obj)
 
-        ip = get_ipython() # type: ignore
-        
-        html_formatter = ip.display_formatter.formatters['text/html']
-        plain_formatter = ip.display_formatter.formatters['text/plain']
+def set_dataframe_display_formatters() -> None:
+    """
+    Deprecated
 
-        # Register the custom formatters
-        html_formatter.for_type(pd.DataFrame, mitosheet_display_formatter)
-        plain_formatter.for_type(pd.DataFrame, mitosheet_plain_formatter)
-    
-    except:
-        pass
+    The registration of a custom formatter is now done automatically by the
+    mitosheet plugin.
+    """
+    register_ipython_formatter()

mitosheet/formatter/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from .viewer import (
+    register_ipython_formatter,
+)
+
+__all__ = [
+    "register_ipython_formatter",
+]

mitosheet/formatter/viewer.py

@@ -0,0 +1,148 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from typing import Dict, Optional
+
+import pandas as pd
+
+
+def _is_describe_output(df: pd.DataFrame) -> bool:
+    """
+    Detect if DataFrame is the result of a describe() call.
+
+    describe() DataFrames have specific characteristics:
+    - Index contains statistical measures (count, mean, std, min, max)
+    """
+    if df.empty or len(df.index) < 5:
+        return False
+
+    # Check if index contains typical describe() statistical measures
+    expected_stats = {"count", "mean", "std", "min", "max"}
+    index_values = set(str(idx).strip() for idx in df.index)
+
+    # If the expected stats are in the index, likely describe() output
+    matches = expected_stats.intersection(index_values)
+    return len(matches) == 5
+
+
+def register_ipython_formatter() -> None:
+    """
+    Register custom formatter with IPython display system.
+    """
+    try:
+        from IPython.core.getipython import get_ipython
+
+        ip = get_ipython() # type: ignore
+        if ip is None:
+            return
+
+        # Register formatter for pandas DataFrames with application/x.mito+json mimetype
+        if getattr(ip, "display_formatter", None) is not None:
+            formatter = getattr(ip.display_formatter, "formatters", None)
+            if formatter is not None:
+                # Try to register with existing mimetype formatter
+                if "application/x.mito+json" not in formatter:
+                    # Create a new formatter for the custom mimetype
+                    from IPython.core.formatters import BaseFormatter
+
+                    class MitoJSONFormatter(BaseFormatter):
+                        def __call__(self, obj):
+                            if isinstance(obj, pd.DataFrame):
+                                # Skip custom formatter for describe() output
+                                if _is_describe_output(obj):
+                                    return None
+                                return format_dataframe_mimetype(obj)
+                            else:
+                                return None
+
+                    formatter["application/x.mito+json"] = MitoJSONFormatter()
+
+    except ImportError:
+        # IPython not available
+        pass
+    except Exception as e:
+        # Log error but don't fail
+        print(f"Warning: Could not register mito viewer formatter: {e}")
+
+
+def format_dataframe_mimetype(obj: pd.DataFrame) -> Optional[Dict]:
+    """
+    Format a pandas DataFrame as a mimetype object for JupyterLab rendering.
+
+    Args:
+        obj: pandas DataFrame to display
+
+    Returns:
+        Dictionary with mimetype and data for JupyterLab renderer, or None if should skip formatting
+    """
+    # Skip custom formatter for describe() output
+    if _is_describe_output(obj):
+        return None
+
+    # Get pandas display options
+    max_rows = pd.get_option("display.max_rows")
+
+    # Prepare data
+    total_rows = len(obj)
+    has_multi_columns = isinstance(obj.columns, pd.MultiIndex)
+    column_levels = obj.columns.nlevels if has_multi_columns else 1
+    columns = list(obj.columns)
+
+    # Get index information - handle MultiIndex
+    index_name = obj.index.name if obj.index.name is not None else "index"
+    index_dtype = str(obj.index.dtype)
+
+    # Check if we have a MultiIndex
+    has_multi_index = isinstance(obj.index, pd.MultiIndex)
+    if has_multi_index:
+        index_levels = obj.index.nlevels
+        index_names = [
+            name if name is not None else f"level_{i}"
+            for i, name in enumerate(obj.index.names)
+        ]
+    else:
+        index_levels = 1
+        index_names = [index_name]
+
+    # Limit rows if necessary
+    if max_rows is not None and total_rows > max_rows:
+        display_df = obj.head(max_rows)
+    else:
+        display_df = obj
+
+    # Convert DataFrame to JSON-serializable format using pandas.to_json
+    try:
+        json_data = display_df.reset_index().to_json(orient="values", date_format="iso")
+    except Exception:
+        return None
+
+    # Prepare column metadata - include index as first column(s)
+    column_metadata = []
+
+    # Add index column(s) first
+    for i, name in enumerate(index_names):
+        column_metadata.append(
+            {
+                "name": [str(name)],
+                "dtype": f"level_{i + 1}" if has_multi_index else index_dtype,
+            }
+        )
+
+    # Add regular columns
+    for col in columns:
+        dtype = str(obj[col].dtype)
+        column_metadata.append(
+            {"name": list(col) if has_multi_columns else [str(col)], "dtype": dtype}
+        )
+
+    # Prepare the data payload
+    payload = {
+        "columns": column_metadata,
+        "data": json_data,
+        "totalRows": total_rows,
+        "indexLevels": index_levels if has_multi_index else 1,
+        "columnLevels": column_levels,
+    }
+
+    # Return mimetype data for JupyterLab
+    return payload

mitosheet/labextension/package.json

@@ -9,9 +9,11 @@
   "jupyterlab": {
     "outputDir": "mitosheet/labextension",
     "extension": "lib/plugin",
+    "mimeExtension": "lib/viewer/renderer",
     "_build": {
-      "load": "static/remoteEntry.ad0d7beec7bf313e216f.js",
-      "extension": "./extension"
+      "load": "static/remoteEntry.b3dffe9fd1efc1d162d4.js",
+      "extension": "./extension",
+      "mimeExtension": "./mimeExtension"
     }
   },
   "name": "mitosheet",
@@ -21,16 +23,18 @@
     "email": "aaron@sagacollab.com"
   },
   "bugs": {
-    "url": "https://github.com/mito-ds/monorepo/issues"
+    "url": "https://github.com/mito-ds/mito/issues"
   },
   "repository": {
-    "url": "https://github.com/mito-ds/monorepo",
+    "url": "https://github.com/mito-ds/mito",
     "type": "git"
   },
-  "version": "0.2.54",
+  "version": "0.2.55",
   "dependencies": {
     "@jupyterlab/application": "^4.0.0",
     "@jupyterlab/notebook": "^4.2.4",
+    "@jupyterlab/rendermime-interfaces": "^3.0.0",
+    "@jupyterlab/ui-components": "^4.0.0",
     "@types/fscreen": "^1.0.1",
     "@types/react-dom": "^18.3.0",
     "fscreen": "^1.1.0",
@@ -70,7 +74,10 @@
     "lint": "eslint src/ --ext .ts,.tsx --fix",
     "prepack": "jlpm run build:all",
     "build:docs:update_frontend": "python docs/make_function_docs.py update_frontend",
-    "build:docs:generate_markdown": "python docs/make_function_docs.py generate_markdown"
+    "build:docs:generate_markdown": "python docs/make_function_docs.py generate_markdown",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   },
   "keywords": [
     "jupyter",
@@ -82,7 +89,12 @@
   ],
   "devDependencies": {
     "@jupyterlab/builder": "^4.0.0",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
     "@types/expect.js": "^0.3.29",
+    "@types/jest": "^30.0.0",
     "@types/node": "^18.19.43",
     "@types/react": "^18.3.3",
     "@typescript-eslint/eslint-plugin": "^4.8.1",
@@ -96,15 +108,19 @@
     "expect.js": "^0.3.1",
     "file-loader": "^6.2.0",
     "fs-extra": "^10.0.0",
+    "identity-obj-proxy": "^3.0.0",
+    "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
     "mkdirp": "^1.0.4",
     "mocha": "^9.1.2",
     "npm-run-all": "^4.1.5",
     "prettier": "^2.1.1",
     "rimraf": "^3.0.2",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.5.4"
   },
   "main": "lib/index.js",
-  "homepage": "https://trymito.io",
+  "homepage": "https://github.com/mito-ds/mito",
   "types": "./lib/index.d.ts",
   "description": "The Mito Spreadsheet",
   "resolutions": {