solara-ui 1.41.0__py2.py3-none-any.whl → 1.43.0__py2.py3-none-any.whl

solara/__init__.py

@@ -1,6 +1,6 @@
 """Build webapps using IPywidgets"""
 
-__version__ = "1.41.0"
+__version__ = "1.43.0"
 github_url = "https://github.com/widgetti/solara"
 git_branch = "master"
 

solara/__main__.py

@@ -21,6 +21,8 @@ import solara.server.threaded
 
 from .server import telemetry
 
+print_mutex = threading.Lock()
+
 try:
     from solara_enterprise.ssg import ssg_crawl
 except ImportError:
@@ -75,13 +77,15 @@ def _check_version():
     import requests
 
     try:
-        response = requests.get("https://pypi.org/pypi/solara/json")
+        response = requests.get("https://pypi.org/pypi/solara/json", timeout=0.5)
         latest_version = response.json()["info"]["version"]
     except:  # noqa: E722
+        # in case of a firewall, or timeout, we just abort
         return
     if latest_version != solara.__version__:
-        print(f"New version of Solara available: {latest_version}. You have {solara.__version__}. Please upgrade using:")  # noqa: T201
-        print(f'\t$ pip install "solara=={latest_version}"')  # noqa: T201
+        with print_mutex:
+            print(f"New version of Solara available: {latest_version}. You have {solara.__version__}. Please upgrade using:")  # noqa: T201
+            print(f'\t$ pip install "solara=={latest_version}"')  # noqa: T201
 
 
 def find_all_packages_paths():
@@ -306,7 +310,7 @@ def run(
         print("solara: --reload is deprecated, use --auto-restart/-a instead", file=sys.stderr)  # noqa: T201
         auto_restart = reload
     if check_version:
-        _check_version()
+        threading.Thread(target=_check_version, daemon=True).run()
 
     # uvicorn calls it reload, we call it auto restart
     reload = auto_restart
@@ -341,7 +345,13 @@ def run(
         reload_excludes = restart_excludes if restart_excludes else []
         del restart_excludes
         reload_excludes = [str(solara_root / "website"), str(solara_root / "template")]
-        reload_excludes.append(app)
+        app_path = Path(app)
+        if app_path.exists():
+            # if app is not a child of the current working directory
+            # uvicorn crashes
+            if not str(app_path.resolve()).startswith(str(Path.cwd().resolve())):
+                reload_excludes.append(str(app_path.resolve()))
+        del app_path
         del solara_root
         reload = True
         # avoid sending many restarts
@@ -384,7 +394,8 @@ def run(
     if open and not qt:
         threading.Thread(target=open_browser, daemon=True).start()
 
-    rich.print(f"Solara server is starting at {url}")
+    with print_mutex:
+        rich.print(f"Solara server is starting at {url}")
 
     if log_level is not None:
         LOGGING_CONFIG["loggers"]["solara"]["level"] = log_level.upper()

solara/_stores.py

@@ -0,0 +1,189 @@
+import copy
+import dataclasses
+import inspect
+from typing import Callable, ContextManager, Generic, Optional, Union, cast
+import warnings
+from .toestand import ValueBase, KernelStore, S, _find_outside_solara_frame
+import solara.util
+
+
+class _PublicValueNotSet:
+    pass
+
+
+class _SetValueNotSet:
+    pass
+
+
+@dataclasses.dataclass
+class StoreValue(Generic[S]):
+    private: S  # the internal private value, should never be mutated
+    public: Union[S, _PublicValueNotSet]  # this is the value that is exposed in .get(), it is a deep copy of private
+    get_traceback: Optional[inspect.Traceback]
+    set_value: Union[S, _SetValueNotSet]  # the value that was set using .set(..), we deepcopy this to set private
+    set_traceback: Optional[inspect.Traceback]
+
+
+class MutateDetectorStore(ValueBase[S]):
+    def __init__(self, store: KernelStore[StoreValue[S]], equals=solara.util.equals_extra):
+        self._storage = store
+        self._enabled = True
+        super().__init__(equals=equals)
+
+    @property
+    def lock(self):
+        return self._storage.lock
+
+    def get(self) -> S:
+        self.check_mutations()
+        self._ensure_public_exists()
+        value = self._storage.get()
+        # value.public is of type Optional[S], so it's tempting to check for None here,
+        # but S could include None as a valid value, so best we can do is cast
+        public_value = cast(S, value.public)
+        return public_value
+
+    def peek(self) -> S:
+        """Return the value without automatically subscribing to listeners."""
+        self.check_mutations()
+        store_value = self._storage.peek()
+        self._ensure_public_exists()
+        public_value = cast(S, store_value.public)
+        return public_value
+
+    def set(self, value: S):
+        self.check_mutations()
+        self._ensure_public_exists()
+        private = copy.deepcopy(value)
+        self._check_equals(private, value)
+        frame = _find_outside_solara_frame()
+        if frame is not None:
+            frame_info = inspect.getframeinfo(frame)
+        else:
+            frame_info = None
+        store_value = StoreValue(private=private, public=_PublicValueNotSet(), get_traceback=None, set_value=value, set_traceback=frame_info)
+        self._storage.set(store_value)
+
+    def check_mutations(self):
+        self._storage._check_mutation()
+        if not self._enabled:
+            return
+        store_value = self._storage.peek()
+        if not isinstance(store_value.public, _PublicValueNotSet) and not self.equals(store_value.public, store_value.private):
+            tb = store_value.get_traceback
+            # TODO: make the error message as elaborate as below
+            msg = (
+                f"Reactive variable was read when it had the value of {store_value.private!r}, but was later mutated to {store_value.public!r}.\n"
+                "Mutation should not be done on the value of a reactive variable, as in production mode we would be unable to track changes.\n"
+            )
+            if tb:
+                if tb.code_context:
+                    code = tb.code_context[0]
+                else:
+                    code = "<No code context available>"
+                msg += f"The last value was read in the following code:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
+            raise ValueError(msg)
+        elif not isinstance(store_value.set_value, _SetValueNotSet) and not self.equals(store_value.set_value, store_value.private):
+            tb = store_value.set_traceback
+            msg = f"""Reactive variable was set with a value of {store_value.private!r}, but was later mutated mutated to {store_value.set_value!r}.
+
+Mutation should not be done on the value of a reactive variable, as in production mode we would be unable to track changes.
+
+Bad:
+    mylist = reactive([]]
+    some_values = [1, 2, 3]
+    mylist.value = some_values  # you give solara a reference to your list
+    some_values.append(4)  # but later mutate it (solara cannot detect this change, so a render will not be triggered)
+    # if later on a re-render happens for a different reason, you will read of the mutated list.
+
+Good (if you want the reactive variable to be updated):
+    mylist = reactive([]]
+    some_values = [1, 2, 3]
+    mylist.value = some_values
+    mylist.value = some_values + [4]
+
+Good (if you want to keep mutating your own list):
+    mylist = reactive([]]
+    some_values = [1, 2, 3]
+    mylist.value = some_values.copy()  # this gives solara a copy of the list
+    some_values.append(4)  # you are free to mutate your own list, solara will not see this
+
+"""
+            if tb:
+                if tb.code_context:
+                    code = tb.code_context[0]
+                else:
+                    code = "<No code context available>"
+                msg += "The last time the value was set was at:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
+            raise ValueError(msg)
+
+    def _ensure_public_exists(self):
+        store_value = self._storage.peek()
+        if isinstance(store_value.public, _PublicValueNotSet):
+            with self.lock:
+                if isinstance(store_value.public, _PublicValueNotSet):
+                    frame = _find_outside_solara_frame()
+                    if frame is not None:
+                        frame_info = inspect.getframeinfo(frame)
+                    else:
+                        frame_info = None
+                    store_value.public = copy.deepcopy(store_value.private)
+                    self._check_equals(store_value.public, store_value.private)
+                    store_value.get_traceback = frame_info
+
+    def _check_equals(self, a: S, b: S):
+        if not self._enabled:
+            return
+        if not self.equals(a, b):
+            frame = _find_outside_solara_frame()
+            if frame is not None:
+                frame_info = inspect.getframeinfo(frame)
+            else:
+                frame_info = None
+
+            warn = """The equals function for this reactive value returned False when comparing a deepcopy to itself.
+
+This reactive variable will not be able to detect mutations correctly, and is therefore disabled.
+
+To avoid this warning, and to ensure that mutation detection works correctly, please provide a better equals function to the reactive variable.
+A good choice for dataframes and numpy arrays might be solara.util.equals_pickle, which will also attempt to compare the pickled values of the objects.
+
+Example:
+df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
+"""
+            tb = frame_info
+            if tb:
+                if tb.code_context:
+                    code = tb.code_context[0]
+                else:
+                    code = "<No code context available>"
+                warn += "This warning was triggered from:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
+            warnings.warn(warn)
+            self._enabled = False
+
+    def subscribe(self, listener: Callable[[S], None], scope: Optional[ContextManager] = None):
+        def listener_wrapper(new: StoreValue[S], previous: StoreValue[S]):
+            self._ensure_public_exists()
+            assert not isinstance(new.public, _PublicValueNotSet)
+            assert not isinstance(previous.public, _PublicValueNotSet)
+            previous_value = previous.set_value if not isinstance(previous.set_value, _SetValueNotSet) else previous.private
+            new_value = new.set_value
+            assert not isinstance(new_value, _SetValueNotSet)
+            if not self.equals(new_value, previous_value):
+                listener(new_value)
+
+        return self._storage.subscribe_change(listener_wrapper, scope=scope)
+
+    def subscribe_change(self, listener: Callable[[S, S], None], scope: Optional[ContextManager] = None):
+        def listener_wrapper(new: StoreValue[S], previous: StoreValue[S]):
+            self._ensure_public_exists()
+            assert not isinstance(new.public, _PublicValueNotSet)
+            assert not isinstance(previous.public, _PublicValueNotSet)
+            previous_value = previous.set_value if not isinstance(previous.set_value, _SetValueNotSet) else previous.private
+            new_value = new.set_value
+            assert not isinstance(new_value, _SetValueNotSet)
+            if not self.equals(new_value, previous_value):
+                listener(new_value, previous_value)
+
+        return self._storage.subscribe_change(listener_wrapper, scope=scope)

solara/components/__init__.py

@@ -57,4 +57,21 @@ from .progress import ProgressLinear  # noqa: F401 F403
 from .component_vue import _component_vue, component_vue  # noqa: F401 F403
 import reacton.core
 
-reacton.core._default_container = Column  # noqa: F405
+try:
+    from reacton import Fragment as Fragment  # type: ignore
+except ImportError:
+    pass
+
+import logging
+from ..settings import main
+
+_container = None
+
+if main.default_container in globals():
+    _container = globals()[main.default_container]
+else:
+    logger = logging.getLogger("solara.components")
+    logger.warning(f"Default container {main.default_container} not found in solara.components. Defaulting to Column.")
+
+# TODO: When Solara 2.0 releases Column should be replaced with Fragment
+reacton.core._default_container = _container or Column  # noqa: F405

solara/components/component_vue.py

@@ -82,6 +82,29 @@ def component_vue(vue_path: str, vuetify=True) -> Callable[[Callable[P, None]],
 
     See the [Vue component example](/documentation/examples/general/vue_component) for an example of how to use this decorator.
 
+
+    ## Examples
+
+    A component that takes a `foo` argument and an `on_foo` callback that gets called when `foo` changes (from the frontend).
+
+    ```python
+    import solara
+
+    @solara.component_vue("my_foo_component.vue")
+    def MyFooComponent(foo: int, on_foo: Callable[[int], None]):
+        pass
+    ```
+
+    The following component only takes in a month argument and an event_date_clicked callback that gets called from
+    the vue template using `this.date_clicked({'extra-data': 42, 'day': this.day})`.
+    ```python
+    import solara
+
+    @solara.component_vue("my_date_component.vue")
+    def MyDateComponent(month: int, event_date_clicked: Callable):
+        pass
+    ```
+
     ## Arguments
 
      * `vue_path`: The path to the Vue template file.

solara/components/datatable.py

@@ -10,14 +10,14 @@ import solara
 import solara.hooks.dataframe
 import solara.lab
 import traitlets
-from solara.lab.hooks.dataframe import use_df_column_names
+from solara.lab.hooks.dataframe import use_df_column_names, df_row_names
 from solara.lab.utils.dataframe import df_len, df_records, df_slice
 
 from .. import CellAction, ColumnAction
 
 
 def _ensure_dict(d):
-    if dataclasses.is_dataclass(d):
+    if dataclasses.is_dataclass(d) and not isinstance(d, type):  # is_dataclass also returns True for dataclass type, rather than instance
         return dataclasses.asdict(d)
     return d
 
@@ -100,12 +100,12 @@ def DataTable(
     i2 = min(total_length, (page + 1) * items_per_page)
 
     columns = use_df_column_names(df)
-
+    rows = df_row_names(df)
     items = []
     dfs = df_slice(df, i1, i2)
     records = df_records(dfs)
     for i in range(i2 - i1):
-        item = {"__row__": i + i1}  # special key for the row number
+        item = {"__row__": format(dfs, columns, i + 1, rows[i + i1])}  # special key for the row number
         for column in columns:
             item[column] = format(dfs, column, i + i1, records[i][column])
         items.append(item)

solara/components/echarts.py

@@ -10,7 +10,7 @@ class EchartsWidget(ipyvuetify.VuetifyTemplate):
     template_file = (__file__, "echarts.vue")
 
     attributes = traitlets.Dict(default_value=None, allow_none=True).tag(sync=True)
-
+    responsive = traitlets.Bool(False).tag(sync=True)
     maps = traitlets.Any({}).tag(sync=True)
     option = traitlets.Any({}).tag(sync=True)
     on_click = traitlets.Callable(None, allow_none=True)
@@ -49,7 +49,8 @@ def FigureEcharts(
     on_mouseover: Callable[[Any], Any] = None,
     on_mouseout: Callable[[Any], Any] = None,
     maps: dict = {},
-    attributes={"style": "height: 400px"},
+    attributes={"style": "height: 400px;"},
+    responsive: bool = False,
 ):
     """Create a Echarts figure.
 
@@ -68,6 +69,7 @@ def FigureEcharts(
     * on_mouseout: Callable, a function that will be called when the user moves the mouse out of a certain component.
     * maps: dict, a dictionary of maps to be used in the figure.
     * attributes: dict, a dictionary of attributes to be passed to the container (like style, class).
+    * responsive: bool, whether the chart should resize when the container changes size.
 
 
     """
@@ -80,4 +82,5 @@ def FigureEcharts(
         on_mouseout=on_mouseout,
         on_mouseout_enabled=on_mouseout is not None,
         attributes=attributes,
+        responsive=responsive,
     )

solara/components/echarts.vue

@@ -1,7 +1,5 @@
 <template>
-  <div>
-    <div ref="echarts" class="solara-echarts" v-bind="attributes"></div>
-  </div>
+  <div ref="echarts" class="solara-echarts" v-bind="attributes"></div>
 </template>
 <script>
 module.exports = {
@@ -14,6 +12,22 @@ module.exports = {
       this.echarts = echarts;
       this.create();
     })();
+    if(this.responsive){
+      this.resizeObserver = new ResizeObserver(entries => {
+        for (let entry of entries) {
+          if (entry.target === this.$refs.echarts) {
+            this.handleContainerResize();
+          }
+        }
+      });
+      this.resizeObserver.observe(this.$refs.echarts);
+    };
+  },
+  beforeDestroy() {
+    if (this.resizeObserver) {
+      this.resizeObserver.unobserve(this.$refs.echarts);
+      this.resizeObserver.disconnect();
+    }
   },
   watch: {
     option() {
@@ -25,9 +39,7 @@ module.exports = {
   methods: {
     create() {
       this.chart = this.echarts.init(this.$refs.echarts);
-      console.log(this.maps);
       Object.keys(this.maps).forEach((mapName) => {
-        console.log(mapName);
         this.echarts.registerMap(mapName, this.maps[mapName]);
       });
 
@@ -66,6 +78,11 @@ module.exports = {
         if (this.on_mouseout_enabled) this.on_mouseout(eventData);
       });
     },
+    handleContainerResize() {
+      if (this.chart) {
+        this.chart.resize();
+      }
+    },
     import(deps) {
       return this.loadRequire().then(() => {
         if (window.jupyterVue) {

solara/components/file_drop.py

@@ -111,6 +111,26 @@ def FileDrop(
      * `lazy`: Whether to load the file contents into memory or not. If `False`,
         the file contents will be loaded into memory via the `.data` attribute of file object(s).
 
+    ## Load into Pandas
+    To load the data into a Pandas DF, set `lazy=False` and use `file['file_obj']` (be careful of memory)<br>
+    You can run this directly in your Jupyter notebook
+
+    ```python
+    import io
+    import pandas as pd
+    import solara
+
+    @solara.component
+    def Page():
+        def load_file_df(file):
+            df = pd.read_csv(file["file_obj"])
+            print("Loaded dataframe:")
+            print(df)
+
+        solara.FileDrop(label="Drop file to see dataframe!", on_file=load_file_df)
+
+    ```
+
     """
 
     return _FileDrop(label=label, on_total_progress=on_total_progress, on_file=on_file, lazy=lazy, multiple=False)

solara/components/input.py

@@ -49,6 +49,7 @@ def InputText(
     message: Optional[str] = None,
     classes: List[str] = [],
     style: Optional[Union[str, Dict[str, str]]] = None,
+    autofocus: bool = False,
 ):
     """Free form text input.
 
@@ -105,6 +106,7 @@ def InputText(
     * `message`: Message to show below the input. If `error` is a string, this will be ignored.
     * `classes`: List of CSS classes to apply to the input.
     * `style`: CSS style to apply to the input.
+    * `autofocus`: Determines if a component is to be autofocused or not (Default is False). Autofocus will occur during page load and only one component per page can have autofocus active.
     """
     reactive_value = solara.use_reactive(value, on_value)
     del value, on_value
@@ -133,6 +135,7 @@ def InputText(
         messages=messages,
         class_=classes_flat,
         style_=style_flat,
+        autofocus=autofocus,
     )
     use_change(text_field, set_value_cast, enabled=not continuous_update, update_events=update_events)
     return text_field
@@ -150,6 +153,7 @@ def InputFloat(
     clearable: bool = ...,
     classes: List[str] = ...,
     style: Optional[Union[str, Dict[str, str]]] = ...,
+    autofocus: bool = False,
 ) -> reacton.core.ValueElement[vw.TextField, Any]: ...
 
 
@@ -165,6 +169,7 @@ def InputFloat(
     clearable: bool = ...,
     classes: List[str] = ...,
     style: Optional[Union[str, Dict[str, str]]] = ...,
+    autofocus: bool = False,
 ) -> reacton.core.ValueElement[vw.TextField, Any]: ...
 
 
@@ -179,6 +184,7 @@ def InputFloat(
     clearable: bool = False,
     classes: List[str] = [],
     style: Optional[Union[str, Dict[str, str]]] = None,
+    autofocus: bool = False,
 ):
     """Numeric input (floats).
 
@@ -211,6 +217,7 @@ def InputFloat(
     * `clearable`: Whether the input can be cleared.
     * `classes`: List of CSS classes to apply to the input.
     * `style`: CSS style to apply to the input.
+    * `autofocus`: Determines if a component is to be autofocused or not (Default is False). Autofocus will occur either during page load, or when the component becomes visible (for example, dialog being opened). Only one component per page should have autofocus on each such event.
 
     """
 
@@ -237,6 +244,7 @@ def InputFloat(
         clearable=clearable,
         classes=classes,
         style=style,
+        autofocus=autofocus,
     )
 
 
@@ -252,6 +260,7 @@ def InputInt(
     clearable: bool = ...,
     classes: List[str] = ...,
     style: Optional[Union[str, Dict[str, str]]] = ...,
+    autofocus: bool = False,
 ) -> reacton.core.ValueElement[vw.TextField, Any]: ...
 
 
@@ -267,6 +276,7 @@ def InputInt(
     clearable: bool = ...,
     classes: List[str] = ...,
     style: Optional[Union[str, Dict[str, str]]] = ...,
+    autofocus: bool = False,
 ) -> reacton.core.ValueElement[vw.TextField, Any]: ...
 
 
@@ -281,6 +291,7 @@ def InputInt(
     clearable: bool = False,
     classes: List[str] = [],
     style: Optional[Union[str, Dict[str, str]]] = None,
+    autofocus: bool = False,
 ):
     """Numeric input (integers).
 
@@ -312,6 +323,7 @@ def InputInt(
     * `clearable`: Whether the input can be cleared.
     * `classes`: List of CSS classes to apply to the input.
     * `style`: CSS style to apply to the input.
+    * `autofocus`: Determines if a component is to be autofocused or not (Default is False). Autofocus will occur either during page load, or when the component becomes visible (for example, dialog being opened). Only one component per page should have autofocus on each such event.
     """
 
     def str_to_int(value: Optional[str]):
@@ -336,6 +348,7 @@ def InputInt(
         clearable=clearable,
         classes=classes,
         style=style,
+        autofocus=autofocus,
     )
 
 
@@ -360,6 +373,10 @@ def _use_input_type(
         error_message = str(e.args[0])
 
     def sync_back_input_value():
+        # Make sure we update string_value when the effect is rerun,
+        # Since the parsing & stringigying functions might have changed
+        set_string_value(stringify(reactive_value.value) if reactive_value.value is not None else None)
+
         def on_external_value_change(new_value: Optional[T]):
             new_string_value = stringify(new_value)
             try:
@@ -373,7 +390,7 @@ def _use_input_type(
 
         return reactive_value.subscribe(on_external_value_change)
 
-    solara.use_effect(sync_back_input_value, [reactive_value])
+    solara.use_effect(sync_back_input_value, [reactive_value, parse, stringify])
 
     return string_value, error_message, set_string_value
 
@@ -389,6 +406,7 @@ def _InputNumeric(
     clearable: bool = False,
     classes: List[str] = [],
     style: Optional[Union[str, Dict[str, str]]] = None,
+    autofocus: bool = False,
 ):
     """Numeric input.
 
@@ -401,6 +419,7 @@ def _InputNumeric(
     * `continuous_update`: Whether to call the `on_value` callback on every change or only when the input loses focus or the enter key is pressed.
     * `classes`: List of CSS classes to apply to the input.
     * `style`: CSS style to apply to the input.
+    * `autofocus`: Determines if a component is to be autofocused or not (Default is False). Autofocus will occur either during page load, or when the component becomes visible (for example, dialog being opened). Only one component per page should have autofocus on each such event.
     """
     style_flat = solara.util._flatten_style(style)
     classes_flat = solara.util._combine_classes(classes)
@@ -431,6 +450,7 @@ def _InputNumeric(
         error=bool(error),
         class_=classes_flat,
         style_=style_flat,
+        autofocus=autofocus,
     )
     use_change(text_field, set_value_cast, enabled=not continuous_update)
     return text_field