streamlit-nightly 1.38.1.dev20240905__py2.py3-none-any.whl → 1.38.1.dev20240907__py2.py3-none-any.whl

streamlit/commands/page_config.py

@@ -21,7 +21,12 @@ from typing import TYPE_CHECKING, Final, Literal, Mapping, Union, cast
 from typing_extensions import TypeAlias
 
 from streamlit.elements import image
-from streamlit.errors import StreamlitAPIException
+from streamlit.errors import (
+    StreamlitInvalidMenuItemKeyError,
+    StreamlitInvalidPageLayoutError,
+    StreamlitInvalidSidebarStateError,
+    StreamlitInvalidURLError,
+)
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg as ForwardProto
 from streamlit.proto.PageConfig_pb2 import PageConfig as PageConfigProto
 from streamlit.runtime.metrics_util import gather_metrics
@@ -227,9 +232,8 @@ def set_page_config(
     elif layout == "wide":
         pb_layout = PageConfigProto.WIDE
     else:
-        raise StreamlitAPIException(
-            f'`layout` must be "centered" or "wide" (got "{layout}")'
-        )
+        raise StreamlitInvalidPageLayoutError(layout=layout)
+
     msg.page_config_changed.layout = pb_layout
 
     pb_sidebar_state: PageConfigProto.SidebarState.ValueType
@@ -240,10 +244,8 @@ def set_page_config(
     elif initial_sidebar_state == "collapsed":
         pb_sidebar_state = PageConfigProto.COLLAPSED
     else:
-        raise StreamlitAPIException(
-            "`initial_sidebar_state` must be "
-            '"auto" or "expanded" or "collapsed" '
-            f'(got "{initial_sidebar_state}")'
+        raise StreamlitInvalidSidebarStateError(
+            initial_sidebar_state=initial_sidebar_state
         )
 
     msg.page_config_changed.initial_sidebar_state = pb_sidebar_state
@@ -287,15 +289,11 @@ def set_menu_items_proto(lowercase_menu_items, menu_items_proto) -> None:
 def validate_menu_items(menu_items: MenuItems) -> None:
     for k, v in menu_items.items():
         if not valid_menu_item_key(k):
-            raise StreamlitAPIException(
-                "We only accept the keys: "
-                '"Get help", "Report a bug", and "About" '
-                f'("{k}" is not a valid key.)'
-            )
+            raise StreamlitInvalidMenuItemKeyError(key=k)
         if v is not None and (
             not is_url(v, ("http", "https", "mailto")) and k != ABOUT_KEY
         ):
-            raise StreamlitAPIException(f'"{v}" is a not a valid URL!')
+            raise StreamlitInvalidURLError(url=v)
 
 
 def valid_menu_item_key(key: str) -> TypeGuard[MenuKey]:

streamlit/elements/layouts.py

@@ -20,7 +20,12 @@ from typing_extensions import TypeAlias
 
 from streamlit.delta_generator_singletons import get_dg_singleton_instance
 from streamlit.elements.lib.utils import Key, compute_and_register_element_id, to_key
-from streamlit.errors import StreamlitAPIException
+from streamlit.errors import (
+    StreamlitAPIException,
+    StreamlitInvalidColumnGapError,
+    StreamlitInvalidColumnSpecError,
+    StreamlitInvalidVerticalAlignmentError,
+)
 from streamlit.proto.Block_pb2 import Block as BlockProto
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.string_util import validate_icon_or_emoji
@@ -294,12 +299,7 @@ class LayoutsMixin:
             weights = (1,) * weights
 
         if len(weights) == 0 or any(weight <= 0 for weight in weights):
-            raise StreamlitAPIException(
-                "The input argument to st.columns must be either a "
-                "positive integer or a list of positive numeric weights. "
-                "See [documentation](https://docs.streamlit.io/develop/api-reference/layout/st.columns) "
-                "for more information."
-            )
+            raise StreamlitInvalidColumnSpecError()
 
         vertical_alignment_mapping: dict[
             str, BlockProto.Column.VerticalAlignment.ValueType
@@ -310,9 +310,8 @@ class LayoutsMixin:
         }
 
         if vertical_alignment not in vertical_alignment_mapping:
-            raise StreamlitAPIException(
-                'The `vertical_alignment` argument to st.columns must be "top", "center", or "bottom". \n'
-                f"The argument passed was {vertical_alignment}."
+            raise StreamlitInvalidVerticalAlignmentError(
+                vertical_alignment=vertical_alignment
             )
 
         def column_gap(gap):
@@ -323,10 +322,7 @@ class LayoutsMixin:
                 if gap_size in valid_sizes:
                     return gap_size
 
-            raise StreamlitAPIException(
-                'The gap argument to st.columns must be "small", "medium", or "large". \n'
-                f"The argument passed was {gap}."
-            )
+            raise StreamlitInvalidColumnGapError(gap=gap)
 
         gap_size = column_gap(gap)
 

streamlit/elements/lib/policies.py

@@ -18,7 +18,12 @@ from typing import TYPE_CHECKING, Any, Final, Sequence
 
 from streamlit import config, errors, logger, runtime
 from streamlit.elements.form_utils import is_in_form
-from streamlit.errors import StreamlitAPIException, StreamlitAPIWarning
+from streamlit.errors import (
+    StreamlitAPIWarning,
+    StreamlitFragmentWidgetsNotAllowedOutsideError,
+    StreamlitInvalidFormCallbackError,
+    StreamlitValueAssignmentNotAllowedError,
+)
 from streamlit.runtime.scriptrunner_utils.script_run_context import (
     get_script_run_ctx,
     in_cached_function,
@@ -38,15 +43,12 @@ def check_callback_rules(dg: DeltaGenerator, on_change: WidgetCallback | None) -
 
     Raises
     ------
-    StreamlitAPIException:
+    StreamlitInvalidFormCallbackError:
         Raised when the described rule is violated.
     """
 
     if runtime.exists() and is_in_form(dg) and on_change is not None:
-        raise StreamlitAPIException(
-            "With forms, callbacks can only be defined on the `st.form_submit_button`."
-            " Defining callbacks on other widgets inside a form is not allowed."
-        )
+        raise StreamlitInvalidFormCallbackError()
 
 
 _shown_default_value_warning: bool = False
@@ -76,10 +78,7 @@ def check_session_state_rules(
         return
 
     if not writes_allowed:
-        raise StreamlitAPIException(
-            f"Values for the widget with key '{key}' cannot be set using"
-            " `st.session_state`."
-        )
+        raise StreamlitValueAssignmentNotAllowedError(key=key)
 
     if (
         default_value is not None
@@ -155,13 +154,13 @@ def check_fragment_path_policy(dg: DeltaGenerator):
     # the elements delta path cannot be smaller than the fragment's delta path if it is
     # inside of the fragment
     if len(current_cursor_delta_path) < len(current_fragment_delta_path):
-        raise StreamlitAPIException(_fragment_writes_widget_to_outside_error)
+        raise StreamlitFragmentWidgetsNotAllowedOutsideError()
 
     # all path indices of the fragment-path must occur in the inner-elements delta path,
     # otherwise it is outside of the fragment container
     for index, path_index in enumerate(current_fragment_delta_path):
         if current_cursor_delta_path[index] != path_index:
-            raise StreamlitAPIException(_fragment_writes_widget_to_outside_error)
+            raise StreamlitFragmentWidgetsNotAllowedOutsideError()
 
 
 def check_widget_policies(

streamlit/elements/widgets/button.py

@@ -34,7 +34,11 @@ from streamlit import runtime
 from streamlit.elements.form_utils import current_form_id, is_in_form
 from streamlit.elements.lib.policies import check_widget_policies
 from streamlit.elements.lib.utils import Key, compute_and_register_element_id, to_key
-from streamlit.errors import StreamlitAPIException
+from streamlit.errors import (
+    StreamlitAPIException,
+    StreamlitMissingPageLabelError,
+    StreamlitPageNotFoundError,
+)
 from streamlit.file_util import get_main_script_directory, normalize_path_join
 from streamlit.navigation.page import StreamlitPage
 from streamlit.proto.Button_pb2 import Button as ButtonProto
@@ -776,9 +780,7 @@ class ButtonMixin:
             # Handle external links:
             if is_url(page):
                 if label is None or label == "":
-                    raise StreamlitAPIException(
-                        "The label param is required for external links used with st.page_link - please provide a label."
-                    )
+                    raise StreamlitMissingPageLabelError()
                 else:
                     page_link_proto.page = page
                     page_link_proto.external = True
@@ -808,11 +810,16 @@ class ButtonMixin:
                     break
 
             if page_link_proto.page_script_hash == "":
-                raise StreamlitAPIException(
-                    f"Could not find page: `{page}`. Must be the file path relative to "
-                    "the main script, from the directory: "
-                    f"`{os.path.basename(main_script_directory)}`. Only the main app "
-                    "file and files in the `pages/` directory are supported."
+                is_mpa_v2 = (
+                    ctx is not None
+                    and ctx.pages_manager is not None
+                    and ctx.pages_manager.mpa_version == 2
+                )
+
+                raise StreamlitPageNotFoundError(
+                    is_mpa_v2=is_mpa_v2,
+                    page=page,
+                    main_script_directory=main_script_directory,
                 )
 
         return self.dg._enqueue("page_link", page_link_proto)

streamlit/elements/widgets/multiselect.py

@@ -37,7 +37,9 @@ from streamlit.elements.lib.utils import (
     maybe_coerce_enum_sequence,
     to_key,
 )
-from streamlit.errors import StreamlitAPIException
+from streamlit.errors import (
+    StreamlitSelectionCountExceedsMaxError,
+)
 from streamlit.proto.MultiSelect_pb2 import MultiSelect as MultiSelectProto
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.scriptrunner import ScriptRunContext, get_script_run_ctx
@@ -80,18 +82,6 @@ class MultiSelectSerde(Generic[T]):
         return [self.options[i] for i in current_value]
 
 
-def _get_over_max_options_message(current_selections: int, max_selections: int):
-    curr_selections_noun = "option" if current_selections == 1 else "options"
-    max_selections_noun = "option" if max_selections == 1 else "options"
-    return f"""
-Multiselect has {current_selections} {curr_selections_noun} selected but `max_selections`
-is set to {max_selections}. This happened because you either gave too many options to `default`
-or you manipulated the widget's state through `st.session_state`. Note that
-the latter can happen before the line indicated in the traceback.
-Please select at most {max_selections} {max_selections_noun}.
-"""
-
-
 def _get_default_count(default: Sequence[Any] | Any | None) -> int:
     if default is None:
         return 0
@@ -108,8 +98,8 @@ def _check_max_selections(
 
     default_count = _get_default_count(selections)
     if default_count > max_selections:
-        raise StreamlitAPIException(
-            _get_over_max_options_message(default_count, max_selections)
+        raise StreamlitSelectionCountExceedsMaxError(
+            current_selections_count=default_count, max_selections_count=max_selections
         )
 
 

streamlit/elements/widgets/number_input.py

@@ -33,7 +33,13 @@ from streamlit.elements.lib.utils import (
     get_label_visibility_proto_value,
     to_key,
 )
-from streamlit.errors import StreamlitAPIException
+from streamlit.errors import (
+    StreamlitInvalidNumberFormatError,
+    StreamlitJSNumberBoundsError,
+    StreamlitMixedNumericTypesError,
+    StreamlitValueAboveMaxError,
+    StreamlitValueBelowMinError,
+)
 from streamlit.js_number import JSNumber, JSNumberBoundsException
 from streamlit.proto.NumberInput_pb2 import NumberInput as NumberInputProto
 from streamlit.runtime.metrics_util import gather_metrics
@@ -369,23 +375,17 @@ class NumberInputMixin:
         # Ensure that all arguments are of the same type.
         number_input_args = [min_value, max_value, value, step]
 
-        int_args = all(
+        all_int_args = all(
             isinstance(a, (numbers.Integral, type(None), str))
             for a in number_input_args
         )
 
-        float_args = all(
+        all_float_args = all(
             isinstance(a, (float, type(None), str)) for a in number_input_args
         )
 
-        if not int_args and not float_args:
-            raise StreamlitAPIException(
-                "All numerical arguments must be of the same type."
-                f"\n`value` has {type(value).__name__} type."
-                f"\n`min_value` has {type(min_value).__name__} type."
-                f"\n`max_value` has {type(max_value).__name__} type."
-                f"\n`step` has {type(step).__name__} type."
-            )
+        if not all_int_args and not all_float_args:
+            raise StreamlitMixedNumericTypesError(value=value, min_value=min_value, max_value=max_value, step=step)
 
         session_state = get_session_state().filtered_state
         if key is not None and key in session_state and session_state[key] is None:
@@ -394,9 +394,9 @@ class NumberInputMixin:
         if value == "min":
             if min_value is not None:
                 value = min_value
-            elif int_args and float_args:
+            elif all_int_args and all_float_args:
                 value = 0.0  # if no values are provided, defaults to float
-            elif int_args:
+            elif all_int_args:
                 value = 0
             else:
                 value = 0.0
@@ -405,7 +405,7 @@ class NumberInputMixin:
         float_value = isinstance(value, float)
 
         if value is None:
-            if int_args and not float_args:
+            if all_int_args and not all_float_args:
                 # Select int type if all relevant args are ints:
                 int_value = True
             else:
@@ -437,22 +437,18 @@ class NumberInputMixin:
         try:
             float(format % 2)
         except (TypeError, ValueError):
-            raise StreamlitAPIException(
-                "Format string for st.number_input contains invalid characters: %s"
-                % format
-            )
+            raise StreamlitInvalidNumberFormatError(format)
+
 
         # Ensure that the value matches arguments' types.
-        all_ints = int_value and int_args
+        all_ints = int_value and all_int_args
 
         if min_value is not None and value is not None and min_value > value:
-            raise StreamlitAPIException(
-                f"The default `value` {value} must be greater than or equal to the `min_value` {min_value}"
-            )
+            raise StreamlitValueBelowMinError(value=value, min_value=min_value)
+
+
         if max_value is not None and value is not None and max_value < value:
-            raise StreamlitAPIException(
-                f"The default `value` {value} must be less than or equal to the `max_value` {max_value}"
-            )
+            raise StreamlitValueAboveMaxError(value=value, max_value=max_value)
 
         # Bounds checks. JSNumber produces human-readable exceptions that
         # we simply re-package as StreamlitAPIExceptions.
@@ -476,7 +472,7 @@ class NumberInputMixin:
                 if value is not None:
                     JSNumber.validate_float_bounds(value, "`value`")
         except JSNumberBoundsException as e:
-            raise StreamlitAPIException(str(e))
+            raise StreamlitJSNumberBoundsError(str(e))
 
         data_type = NumberInputProto.INT if all_ints else NumberInputProto.FLOAT
 

streamlit/errors.py

@@ -14,6 +14,9 @@
 
 from __future__ import annotations
 
+import os
+from typing import Any, Literal
+
 from streamlit import util
 
 
@@ -154,7 +157,276 @@ class StreamlitModuleNotFoundError(StreamlitAPIWarning):
 
     def __init__(self, module_name, *args):
         message = (
-            f'This Streamlit command requires module "{module_name}" to be '
-            "installed."
+            f'This Streamlit command requires module "{module_name}" '
+            "to be installed."
         )
         super().__init__(message, *args)
+
+
+class LocalizableStreamlitException(StreamlitAPIException):
+    def __init__(self, message: str, **kwargs):
+        super().__init__((message).format(**kwargs))
+        self._exec_kwargs = kwargs
+
+    @property
+    def exec_kwargs(self) -> dict[str, Any]:
+        return self._exec_kwargs
+
+
+# st.set_page_config
+class StreamlitSetPageConfigMustBeFirstCommandError(LocalizableStreamlitException):
+    """Exception raised when the set_page_config command is not the first executed streamlit command."""
+
+    def __init__(self):
+        super().__init__(
+            "`set_page_config()` can only be called once per app page, "
+            "and must be called as the first Streamlit command in your script.\n\n"
+            "For more information refer to the [docs]"
+            "(https://docs.streamlit.io/develop/api-reference/configuration/st.set_page_config)."
+        )
+
+
+class StreamlitInvalidPageLayoutError(LocalizableStreamlitException):
+    """Exception raised when an invalid value is specified for layout."""
+
+    def __init__(self, layout: str):
+        super().__init__(
+            '`layout` must be `"centered"` or `"wide"` (got `"{layout}"`)',
+            layout=layout,
+        )
+
+
+class StreamlitInvalidSidebarStateError(LocalizableStreamlitException):
+    """Exception raised when an invalid value is specified for `initial_sidebar_state`."""
+
+    def __init__(self, initial_sidebar_state: str):
+        super().__init__(
+            '`initial_sidebar_state` must be `"auto"` or `"expanded"` or `"collapsed"` (got `"{initial_sidebar_state}"`)',
+            initial_sidebar_state=initial_sidebar_state,
+        )
+
+
+class StreamlitInvalidMenuItemKeyError(LocalizableStreamlitException):
+    """Exception raised when an invalid key is specified."""
+
+    def __init__(self, key: str):
+        super().__init__(
+            'We only accept the keys: `"Get help"`, `"Report a bug"`, and `"About"` (`"{key}"` is not a valid key.)',
+            key=key,
+        )
+
+
+class StreamlitInvalidURLError(LocalizableStreamlitException):
+    """Exception raised when an invalid URL is specified for any of the menu items except for “About”."""
+
+    def __init__(self, url: str):
+        super().__init__(
+            '"{url}" is a not a valid URL. '
+            'You must use a fully qualified domain beginning with "http://", "https://", or "mailto:".',
+            url=url,
+        )
+
+
+# st.columns
+class StreamlitInvalidColumnSpecError(LocalizableStreamlitException):
+    """Exception raised when no weights are specified, or a negative weight is specified."""
+
+    def __init__(self):
+        super().__init__(
+            "The `spec` argument to `st.columns` must be either a "
+            "positive integer (number of columns) or a list of positive numbers (width ratios of the columns). "
+            "See [documentation](https://docs.streamlit.io/develop/api-reference/layout/st.columns) "
+            "for more information."
+        )
+
+
+class StreamlitInvalidVerticalAlignmentError(LocalizableStreamlitException):
+    """Exception raised when an invalid value is specified for vertical_alignment."""
+
+    def __init__(self, vertical_alignment: str):
+        super().__init__(
+            'The `vertical_alignment` argument to `st.columns` must be `"top"`, `"center"`, or `"bottom"`. \n'
+            "The argument passed was {vertical_alignment}.",
+            vertical_alignment=vertical_alignment,
+        )
+
+
+class StreamlitInvalidColumnGapError(LocalizableStreamlitException):
+    """Exception raised when an invalid value is specified for gap."""
+
+    def __init__(self, gap: str):
+        super().__init__(
+            'The `gap` argument to `st.columns` must be `"small"`, `"medium"`, or `"large"`. \n'
+            "The argument passed was {gap}.",
+            gap=gap,
+        )
+
+
+# st.multiselect
+class StreamlitSelectionCountExceedsMaxError(LocalizableStreamlitException):
+    """Exception raised when there are more default selections specified than the max allowable selections."""
+
+    def __init__(self, current_selections_count: int, max_selections_count: int):
+        super().__init__(
+            "Multiselect has {current_selections_count} {current_selections_noun} "
+            "selected but `max_selections` is set to {max_selections_count}. "
+            "This happened because you either gave too many options to `default` "
+            "or you manipulated the widget's state through `st.session_state`. "
+            "Note that the latter can happen before the line indicated in the traceback. "
+            "Please select at most {max_selections_count} {options_noun}.",
+            current_selections_count=current_selections_count,
+            current_selections_noun="option"
+            if current_selections_count == 1
+            else "options",
+            max_selections_count=max_selections_count,
+            options_noun="option" if max_selections_count == 1 else "options",
+        )
+
+
+# st.number_input
+class StreamlitMixedNumericTypesError(LocalizableStreamlitException):
+    """Exception raised mixing floats and ints in st.number_input."""
+
+    def __init__(
+        self,
+        value: int | float | Literal["min"] | None,
+        min_value: int | float | None,
+        max_value: int | float | None,
+        step: int | float | None,
+    ):
+        value_type = None
+        min_value_type = None
+        max_value_type = None
+        step_type = None
+
+        error_message = "All numerical arguments must be of the same type."
+
+        if value:
+            value_type = type(value).__name__
+            error_message += "\n`value` has {value_type} type."
+
+        if min_value:
+            min_value_type = type(min_value).__name__
+            error_message += "\n`min_value` has {min_value_type} type."
+
+        if max_value:
+            max_value_type = type(max_value).__name__
+            error_message += "\n`max_value` has {max_value_type} type."
+
+        if step:
+            step_type = type(step).__name__
+            error_message += "\n`step` has {step_type} type."
+
+        super().__init__(
+            error_message,
+            value_type=value_type,
+            min_value_type=min_value_type,
+            max_value_type=max_value_type,
+            step_type=step_type,
+        )
+
+
+class StreamlitValueBelowMinError(LocalizableStreamlitException):
+    """Exception raised when the `min_value` is greater than the `value`."""
+
+    def __init__(self, value: int | float, min_value: int | float):
+        super().__init__(
+            "The `value` {value} is less than the `min_value` {min_value}.",
+            value=value,
+            min_value=min_value,
+        )
+
+
+class StreamlitValueAboveMaxError(LocalizableStreamlitException):
+    """Exception raised when the `max_value` is less than the `value`."""
+
+    def __init__(self, value: int | float, max_value: int | float):
+        super().__init__(
+            "The `value` {value} is greater than than the `max_value` {max_value}.",
+            value=value,
+            max_value=max_value,
+        )
+
+
+class StreamlitJSNumberBoundsError(LocalizableStreamlitException):
+    """Exception raised when a number exceeds the Javascript limits."""
+
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class StreamlitInvalidNumberFormatError(LocalizableStreamlitException):
+    """Exception raised when the format string for `st.number_input` contains
+    invalid characters.
+    """
+
+    def __init__(self, format: str):
+        super().__init__(
+            "Format string for `st.number_input` contains invalid characters: {format}",
+            format=format,
+        )
+
+
+# st.page_link
+class StreamlitMissingPageLabelError(LocalizableStreamlitException):
+    """Exception raised when a page_link is created without a label."""
+
+    def __init__(self):
+        super().__init__(
+            "The `label` param is required for external links used with `st.page_link` - please provide a `label`."
+        )
+
+
+class StreamlitPageNotFoundError(LocalizableStreamlitException):
+    """Exception raised the linked page can not be found."""
+
+    def __init__(self, page: str, main_script_directory: str, is_mpa_v2: bool):
+        directory = os.path.basename(main_script_directory)
+
+        message = (
+            "Could not find page: `{page}`. You must provide a file path "
+            "relative to the entrypoint file (from the directory `{directory}`). "
+            "Only the entrypoint file and files in the `pages/` directory are supported."
+        )
+
+        if is_mpa_v2:
+            message = (
+                "Could not find page: `{page}`. You must provide a `StreamlitPage` "
+                "object or file path relative to the entrypoint file. Only pages "
+                "previously defined by `st.Page` and passed to `st.navigation` are "
+                "allowed."
+            )
+
+        super().__init__(
+            message,
+            page=page,
+            directory=directory,
+        )
+
+
+# policies
+class StreamlitFragmentWidgetsNotAllowedOutsideError(LocalizableStreamlitException):
+    """Exception raised when the fragment attempts to write to an element outside of its container."""
+
+    def __init__(self):
+        super().__init__("Fragments cannot write widgets to outside containers.")
+
+
+class StreamlitInvalidFormCallbackError(LocalizableStreamlitException):
+    """Exception raised a `on_change` callback is set on any element in a form except for the `st.form_submit_button`."""
+
+    def __init__(self):
+        super().__init__(
+            "Within a form, callbacks can only be defined on `st.form_submit_button`. "
+            "Defining callbacks on other widgets inside a form is not allowed."
+        )
+
+
+class StreamlitValueAssignmentNotAllowedError(LocalizableStreamlitException):
+    """Exception raised when trying to set values where writes are not allowed."""
+
+    def __init__(self, key: str):
+        super().__init__(
+            "Values for the widget with `key` '{key}' cannot be set using `st.session_state`.",
+            key=key,
+        )

streamlit/runtime/pages_manager.py

@@ -269,6 +269,10 @@ class PagesManager:
     def intended_page_script_hash(self) -> PageHash | None:
         return self._intended_page_script_hash
 
+    @property
+    def mpa_version(self) -> int:
+        return 2 if isinstance(self.pages_strategy, PagesStrategyV2) else 1
+
     def get_main_page(self) -> PageInfo:
         return {
             "script_path": self._main_script_path,