dash-sortable-items 0.7.1__py3-none-any.whl

dash_sortable_items/HandleWrapper.py

@@ -0,0 +1,78 @@
+# AUTO GENERATED FILE - DO NOT EDIT
+
+import typing  # noqa: F401
+from typing_extensions import TypedDict, NotRequired, Literal # noqa: F401
+from dash.development.base_component import Component, _explicitize_args
+try:
+    from dash.types import NumberType  # noqa: F401
+except ImportError:
+    # Backwards compatibility for dash<=4.1.0
+    if typing.TYPE_CHECKING:
+        raise
+    NumberType = typing.Union[  # noqa: F401
+        typing.SupportsFloat, typing.SupportsInt, typing.SupportsComplex
+    ]
+
+ComponentSingleType = typing.Union[str, int, float, Component, None]
+ComponentType = typing.Union[
+    ComponentSingleType,
+    typing.Sequence[ComponentSingleType],
+]
+
+
+class HandleWrapper(Component):
+    """A HandleWrapper component.
+
+
+Keyword arguments:
+
+- id (string; optional):
+    Unique ID of the component.
+
+- child (a list of or a singular dash component, string or number; required):
+    Child component wrapped with a ref.
+
+- className (string; optional):
+    Class name of the component.
+
+- key (string | number; optional)
+
+- ref (string; optional):
+    Allows getting a ref to the component instance. Once the component
+    unmounts, React will set `ref.current` to `None` (or call the ref
+    with `None` if you passed a callback ref). @,see,,{@link
+    ,https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom
+    React Docs,}."""
+    _children_props: typing.List[str] = ['child']
+    _base_nodes = ['child', 'children']
+    _namespace = 'dash_sortable_items'
+    _type = 'HandleWrapper'
+
+
+    def __init__(
+        self,
+        child: typing.Optional[ComponentType] = None,
+        id: typing.Optional[typing.Union[str, dict]] = None,
+        className: typing.Optional[str] = None,
+        style: typing.Optional[typing.Any] = None,
+        ref: typing.Optional[typing.Union[str, typing.Any]] = None,
+        key: typing.Optional[typing.Union[str, NumberType]] = None,
+        **kwargs
+    ):
+        self._prop_names = ['id', 'child', 'className', 'key', 'ref', 'style']
+        self._valid_wildcard_attributes =            []
+        self.available_properties = ['id', 'child', 'className', 'key', 'ref', 'style']
+        self.available_wildcard_properties =            []
+        _explicit_args = kwargs.pop('_explicit_args')
+        _locals = locals()
+        _locals.update(kwargs)  # For wildcard attrs and excess named props
+        args = {k: _locals[k] for k in _explicit_args}
+
+        for k in ['child']:
+            if k not in args:
+                raise TypeError(
+                    'Required argument `' + k + '` was not specified.')
+
+        super(HandleWrapper, self).__init__(**args)
+
+setattr(HandleWrapper, "__init__", _explicitize_args(HandleWrapper.__init__))

dash_sortable_items/SortableGroup.py

@@ -0,0 +1,68 @@
+r'''
+This file defines a placeholder that users must use to create a sortable group. 
+This returns a _SortableGroup object which is the Python structure that creates the React component.
+'''
+
+# _SortableGroup and _SortableItem are used as placeholders here to avoid typing errors
+from ._SortableGroup import _SortableGroup
+from ._SortableItem  import _SortableItem
+from .SortableItem   import SortableItem
+from .types          import DashId, CSSDict, AnimationOptions
+
+class SortableGroup:
+    r'''
+    A sortable group containing SortableItem children.
+
+    :param items: List of SortableItem components that can be sorted within this group
+    :param id: Unique ID of the component.
+    :param className: Class name of the component.
+    :param style: Style to apply to the div element containing the children.
+    :param showClone: Whether a clone should be shown in the list when one of the elements is dragged or not.
+    :param dropAnimation: Specify the duration and easing of the drop animation. If None, the dragged item instantly reaches its destination.
+    '''
+
+    def __new__(
+        cls,
+        items         : list[SortableItem],
+        id            : DashId                  = None,
+        className     : str                     = '',
+        style         : CSSDict                 = {},
+        showClone     : bool                    = False,
+        dropAnimation : AnimationOptions | None = None
+    ) -> _SortableGroup:
+        
+
+        # Output list containing the new sortable items with indices set
+        new_items = []
+
+        for pos, item in enumerate(items):
+
+            handle_trick = {'handle' : item.handle} if item.handle is not None else {}
+            id_trick     = {'id' : item.id} if item.id is not None else {}
+
+            # Create the real SortableItem component by giving it its position in the list
+            # as its index
+            new_item = _SortableItem(
+                index               = pos,
+                children            = item.children,
+                className           = item.className,
+                handlePos           = item.handlePos,
+                lock                = item.lock,
+                restrict            = item.restrict,
+                styles              = item.styles,
+                styles_drag         = item.styles_drag,
+                styles_drop         = item.styles_drop,
+                transitionAnimation = item.transitionAnimation,
+                **handle_trick, **id_trick
+            )
+
+            new_items.append(new_item)
+
+        return _SortableGroup(
+            children      = new_items,
+            id            = id,
+            className     = className,
+            style         = style,
+            showClone     = showClone,
+            dropAnimation = dropAnimation
+        )

dash_sortable_items/SortableItem.py

@@ -0,0 +1,60 @@
+r'''
+This file defines a placeholder that users must use to create sortable items. When creating a SortableGroup component,
+the class below is converted into a _SortableItem which maps to the React component.
+'''
+
+import typing
+from   .types import (
+    DashId, 
+    handlePosType, 
+    restrictType, 
+    stylesType,
+    AnimationOptions
+)
+
+class SortableItem:
+    r"""
+    A sortable item used as a wrapper around any Dash component. 
+    This item must be placed within a SortableGroup to make it draggable and sortable.
+    
+    :param id: Unique ID of the component
+    :param children: Children of the component.
+    :param className: Class name of the component.
+    :param handle: Dash component used as handle to grab the row. None means the entire row is draggable.
+    :param handlePos: Position of the handle either at the start or at the end of the row.
+    :param lock: Whether to lock the item (i.e. make it not moveable) or not.
+    :param restrict: Whether to restrict items to vertical or horizontal motions only. None means there is no restriction.
+    :param styles: CSS styles to apply. This is a dictionary with keys 'div' and 'handle', each taking a dictionary with CSS properties.
+    :param styles_drag: CSS styles to apply when the item is being draggeds. This is a dictionary with keys 'div' and 'handle', each taking a dictionary with CSS properties.
+    :param styles_drop: CSS styles to apply when the item is being dropped. This is a dictionary with keys 'div' and 'handle', each taking a dictionary with CSS properties.
+    :param transitionAnimation: Dictionary with properties to style the animation when an item moves from one position to another. None disables the animation.
+    """
+
+    def __init__(
+        self,
+        id                  : DashId,
+        children            : typing.Any              = None,
+        className           : str                     = '',
+        handle              : typing.Any              = None,
+        handlePos           : handlePosType           = 'start',
+        lock                : bool                    = False,
+        restrict            : restrictType            = None,
+        styles              : stylesType              = {},
+        styles_drag         : stylesType              = {},
+        styles_drop         : stylesType              = {},
+        transitionAnimation : AnimationOptions | None = {'duration' : 250, 'easing' : 'ease'},
+    ):
+
+        self.id                  = id
+        self.children            = children
+        self.className           = className
+        self.handle              = handle
+        self.handlePos           = handlePos
+        self.lock                = lock
+        self.restrict            = restrict
+        self.styles              = styles
+        self.styles_drag         = styles_drag
+        self.styles_drop         = styles_drop
+        self.transitionAnimation = transitionAnimation
+
+        return

dash_sortable_items/_SortableGroup.py

@@ -0,0 +1,93 @@
+# AUTO GENERATED FILE - DO NOT EDIT
+
+import typing  # noqa: F401
+from typing_extensions import TypedDict, NotRequired, Literal # noqa: F401
+from dash.development.base_component import Component, _explicitize_args
+try:
+    from dash.types import NumberType  # noqa: F401
+except ImportError:
+    # Backwards compatibility for dash<=4.1.0
+    if typing.TYPE_CHECKING:
+        raise
+    NumberType = typing.Union[  # noqa: F401
+        typing.SupportsFloat, typing.SupportsInt, typing.SupportsComplex
+    ]
+
+ComponentSingleType = typing.Union[str, int, float, Component, None]
+ComponentType = typing.Union[
+    ComponentSingleType,
+    typing.Sequence[ComponentSingleType],
+]
+
+
+class _SortableGroup(Component):
+    """A _SortableGroup component.
+sortable group that allows its children to be sorted
+
+Keyword arguments:
+
+- children (list of dicts; optional):
+    Children passed as props. These should be SortableItem components.
+
+    `children` is a list of dicts with keys:
+
+    - key (string; required):
+        Key provided by Dash. This corresponds to the ID the user has
+        provided.
+
+    - type (string; required)
+
+    - props (boolean | number | string | dict | list; required)
+
+- id (string; optional):
+    Unique ID of the component.
+
+- className (string; optional):
+    Class name of the component.
+
+- dropAnimation (dict; default {duration : 250, easing: 'ease'})
+
+    `dropAnimation` is a dict with keys:
+
+    - duration (number; required)
+
+    - easing (string; required)
+
+- showClone (boolean; default False):
+    Whether a clone should be shown in the list when dragging the
+    element or not."""
+    _children_props: typing.List[str] = []
+    _base_nodes = ['children']
+    _namespace = 'dash_sortable_items'
+    _type = '_SortableGroup'
+    DropAnimation = TypedDict(
+        "DropAnimation",
+            {
+            "duration": NumberType,
+            "easing": str
+        }
+    )
+
+
+    def __init__(
+        self,
+        children: typing.Optional[ComponentType] = None,
+        showClone: typing.Optional[bool] = None,
+        dropAnimation: typing.Optional["DropAnimation"] = None,
+        id: typing.Optional[typing.Union[str, dict]] = None,
+        className: typing.Optional[str] = None,
+        style: typing.Optional[typing.Any] = None,
+        **kwargs
+    ):
+        self._prop_names = ['children', 'id', 'className', 'dropAnimation', 'showClone', 'style']
+        self._valid_wildcard_attributes =            []
+        self.available_properties = ['children', 'id', 'className', 'dropAnimation', 'showClone', 'style']
+        self.available_wildcard_properties =            []
+        _explicit_args = kwargs.pop('_explicit_args')
+        _locals = locals()
+        _locals.update(kwargs)  # For wildcard attrs and excess named props
+        args = {k: _locals[k] for k in _explicit_args if k != 'children'}
+
+        super(_SortableGroup, self).__init__(children=children, **args)
+
+setattr(_SortableGroup, "__init__", _explicitize_args(_SortableGroup.__init__))

dash_sortable_items/_SortableItem.py

@@ -0,0 +1,169 @@
+# AUTO GENERATED FILE - DO NOT EDIT
+
+import typing  # noqa: F401
+from typing_extensions import TypedDict, NotRequired, Literal # noqa: F401
+from dash.development.base_component import Component, _explicitize_args
+try:
+    from dash.types import NumberType  # noqa: F401
+except ImportError:
+    # Backwards compatibility for dash<=4.1.0
+    if typing.TYPE_CHECKING:
+        raise
+    NumberType = typing.Union[  # noqa: F401
+        typing.SupportsFloat, typing.SupportsInt, typing.SupportsComplex
+    ]
+
+ComponentSingleType = typing.Union[str, int, float, Component, None]
+ComponentType = typing.Union[
+    ComponentSingleType,
+    typing.Sequence[ComponentSingleType],
+]
+
+
+class _SortableItem(Component):
+    """A _SortableItem component.
+sortable item used in a SortableGroup component
+
+Keyword arguments:
+
+- children (string | number | boolean; optional):
+    Children of the component.
+
+- id (string; required):
+    Unique ID of the component.
+
+- className (string; optional):
+    Class name of the component.
+
+- handle (a list of or a singular dash component, string or number; optional):
+    A Dash component used as handle to grab the row. None means the
+    entire row is draggable.
+
+- handlePos (a value equal to: 'start', 'end'; default 'start'):
+    Position of the handle either at the start or at the end of the
+    row.
+
+- index (number; required):
+    Initial position of the item in the sortable list.
+
+- lock (boolean; default False):
+    Whether to lock the item (i.e. make it not moveable) or not.
+
+- restrict (a value equal to: 'vertical', 'horizontal'; optional):
+    Whether to restrict items to vertical or horizontal motions only.
+    None means there is no restriction.
+
+- styles (dict; optional):
+    CSS styles to apply.  This is a dictionary with keys 'div' and
+    'handle', each taking a dictionary with CSS properties.
+
+    `styles` is a dict with keys:
+
+    - div (boolean | number | string | dict | list; optional)
+
+    - handle (boolean | number | string | dict | list; optional)
+
+- styles_drag (dict; optional):
+    CSS styles to apply when the item is dragged.  This is a
+    dictionary with keys 'div' and 'handle', each taking a dictionary
+    with CSS properties.
+
+    `styles_drag` is a dict with keys:
+
+    - div (boolean | number | string | dict | list; optional)
+
+    - handle (boolean | number | string | dict | list; optional)
+
+- styles_drop (dict; optional):
+    CSS styles to apply when the item is dropped.  This is a
+    dictionary with keys 'div' and 'handle', each taking a dictionary
+    with CSS properties.
+
+    `styles_drop` is a dict with keys:
+
+    - div (boolean | number | string | dict | list; optional)
+
+    - handle (boolean | number | string | dict | list; optional)
+
+- transitionAnimation (dict; default {duration : 250, easing: 'ease', idle: True}):
+    Animation used when the item translates from one position to the
+    next.
+
+    `transitionAnimation` is a dict with keys:
+
+    - duration (number; optional)
+
+    - easing (string; optional)
+
+    - idle (boolean; optional)"""
+    _children_props: typing.List[str] = ['handle']
+    _base_nodes = ['handle', 'children']
+    _namespace = 'dash_sortable_items'
+    _type = '_SortableItem'
+    TransitionAnimation = TypedDict(
+        "TransitionAnimation",
+            {
+            "duration": NotRequired[NumberType],
+            "easing": NotRequired[str],
+            "idle": NotRequired[bool]
+        }
+    )
+
+    Styles = TypedDict(
+        "Styles",
+            {
+            "div": NotRequired[typing.Any],
+            "handle": NotRequired[typing.Any]
+        }
+    )
+
+    StylesDrag = TypedDict(
+        "StylesDrag",
+            {
+            "div": NotRequired[typing.Any],
+            "handle": NotRequired[typing.Any]
+        }
+    )
+
+    StylesDrop = TypedDict(
+        "StylesDrop",
+            {
+            "div": NotRequired[typing.Any],
+            "handle": NotRequired[typing.Any]
+        }
+    )
+
+
+    def __init__(
+        self,
+        children: typing.Optional[ComponentType] = None,
+        id: typing.Optional[typing.Union[str, dict]] = None,
+        index: typing.Optional[NumberType] = None,
+        restrict: typing.Optional[Literal["vertical", "horizontal"]] = None,
+        handle: typing.Optional[ComponentType] = None,
+        lock: typing.Optional[bool] = None,
+        transitionAnimation: typing.Optional["TransitionAnimation"] = None,
+        handlePos: typing.Optional[Literal["start", "end"]] = None,
+        styles: typing.Optional["Styles"] = None,
+        styles_drag: typing.Optional["StylesDrag"] = None,
+        styles_drop: typing.Optional["StylesDrop"] = None,
+        className: typing.Optional[str] = None,
+        **kwargs
+    ):
+        self._prop_names = ['children', 'id', 'className', 'handle', 'handlePos', 'index', 'lock', 'restrict', 'styles', 'styles_drag', 'styles_drop', 'transitionAnimation']
+        self._valid_wildcard_attributes =            []
+        self.available_properties = ['children', 'id', 'className', 'handle', 'handlePos', 'index', 'lock', 'restrict', 'styles', 'styles_drag', 'styles_drop', 'transitionAnimation']
+        self.available_wildcard_properties =            []
+        _explicit_args = kwargs.pop('_explicit_args')
+        _locals = locals()
+        _locals.update(kwargs)  # For wildcard attrs and excess named props
+        args = {k: _locals[k] for k in _explicit_args if k != 'children'}
+
+        for k in ['id', 'index']:
+            if k not in args:
+                raise TypeError(
+                    'Required argument `' + k + '` was not specified.')
+
+        super(_SortableItem, self).__init__(children=children, **args)
+
+setattr(_SortableItem, "__init__", _explicitize_args(_SortableItem.__init__))

dash_sortable_items/__init__.py

@@ -0,0 +1,61 @@
+from __future__ import print_function as _
+
+import os as _os
+import sys as _sys
+import json
+
+import dash as _dash
+
+# noinspection PyUnresolvedReferences
+from ._imports_ import *
+from ._imports_ import __all__
+
+if not hasattr(_dash, '__plotly_dash') and not hasattr(_dash, 'development'):
+    print('Dash was not successfully imported. '
+          'Make sure you don\'t have a file '
+          'named \n"dash.py" in your current directory.', file=_sys.stderr)
+    _sys.exit(1)
+
+_basepath = _os.path.dirname(__file__)
+_filepath = _os.path.abspath(_os.path.join(_basepath, 'package-info.json'))
+with open(_filepath) as f:
+    package = json.load(f)
+
+package_name = package['name'].replace(' ', '_').replace('-', '_')
+__version__ = package['version']
+
+_current_path = _os.path.dirname(_os.path.abspath(__file__))
+
+_this_module = _sys.modules[__name__]
+
+_js_dist = []
+
+_js_dist.extend(
+    [
+        {
+            'relative_package_path': 'dash_sortable_items.js',
+    
+            'namespace': package_name
+        },
+        {
+            'relative_package_path': 'dash_sortable_items.js.map',
+    
+            'namespace': package_name,
+            'dynamic': True
+        }
+    ]
+)
+
+_js_dist.append(dict(
+    dev_package_path="proptypes.js",
+    dev_only=True,
+    namespace="dash_sortable_items"
+))
+
+
+_css_dist = []
+
+
+for _component in __all__:
+    setattr(locals()[_component], '_js_dist', _js_dist)
+    setattr(locals()[_component], '_css_dist', _css_dist)

dash_sortable_items/_imports_.py

@@ -0,0 +1,7 @@
+from .SortableGroup  import SortableGroup
+from .SortableItem   import SortableItem
+
+__all__ = [
+    "SortableGroup",
+    "SortableItem"
+]