dash-week-range-picker 0.0.1__tar.gz

dash_week_range_picker-0.0.1/MANIFEST.in

@@ -0,0 +1,11 @@
+include dash_week_range_picker/dash_week_range_picker.min.js
+include dash_week_range_picker/dash_week_range_picker.min.js.map
+include dash_week_range_picker/async-*.js
+include dash_week_range_picker/async-*.js.map
+include dash_week_range_picker/*-shared.js
+include dash_week_range_picker/*-shared.js.map
+include dash_week_range_picker/metadata.json
+include dash_week_range_picker/package-info.json
+include README.md
+include LICENSE
+include package.json

dash_week_range_picker-0.0.1/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: dash_week_range_picker
+Version: 0.0.1
+Summary: Mantine-based ISO-week range picker for Dash
+Author: Ihor Lazariev <121246456+ihor-lazariev@users.noreply.github.com>
+License: MIT
+Classifier: Framework :: Dash
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
+
+# Dash Week Range Picker
+
+Dash Week Range Picker is a Dash component library.
+
+Mantine-based ISO-week range picker for Dash
+
+Get started with:
+1. Install Dash and its dependencies: https://dash.plotly.com/installation
+2. Run `python usage.py`
+3. Visit http://localhost:8050 in your web browser
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md)
+
+### Install dependencies
+
+If you have selected install_dependencies during the prompt, you can skip this part.
+
+1. Install npm packages
+    ```
+    $ npm install
+    ```
+2. Create a virtual env and activate.
+    ```
+    $ virtualenv venv
+    $ . venv/bin/activate
+    ```
+    _Note: venv\Scripts\activate for windows_
+
+3. Install python packages required to build components.
+    ```
+    $ pip install -r requirements.txt
+    ```
+4. Install the python packages for testing (optional)
+    ```
+    $ pip install -r tests/requirements.txt
+    ```
+
+### Write your component code in `src/lib/components/DashWeekRangePicker.react.js`.
+
+- The demo app is in `src/demo` and you will import your example component code into your demo app.
+- Test your code in a Python environment:
+    1. Build your code
+        ```
+        $ npm run build
+        ```
+    2. Run and modify the `usage.py` sample dash app:
+        ```
+        $ python usage.py
+        ```
+- Write tests for your component.
+    - A sample test is available in `tests/test_usage.py`, it will load `usage.py` and you can then automate interactions with selenium.
+    - Run the tests with `$ pytest tests`.
+    - The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g. https://github.com/plotly/dash-core-components)
+- Add custom styles to your component by putting your custom CSS files into your distribution folder (`dash_week_range_picker`).
+    - Make sure that they are referenced in `MANIFEST.in` so that they get properly included when you're ready to publish your component.
+    - Make sure the stylesheets are added to the `_css_dist` dict in `dash_week_range_picker/__init__.py` so dash will serve them automatically when the component suite is requested.
+- [Review your code](./review_checklist.md)
+
+### Create a production build and publish:
+
+1. Build your code:
+    ```
+    $ npm run build
+    ```
+2. Create a Python distribution
+    ```
+    $ python setup.py sdist bdist_wheel
+    ```
+    This will create source and wheel distribution in the generated the `dist/` folder.
+    See [PyPA](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project)
+    for more information.
+
+3. Test your tarball by copying it into a new environment and installing it locally:
+    ```
+    $ pip install dash_week_range_picker-0.0.1.tar.gz
+    ```
+
+4. If it works, then you can publish the component to NPM and PyPI:
+    1. Publish on PyPI
+        ```
+        $ twine upload dist/*
+        ```
+    2. Cleanup the dist folder (optional)
+        ```
+        $ rm -rf dist
+        ```
+    3. Publish on NPM (Optional if chosen False in `publish_on_npm`)
+        ```
+        $ npm publish
+        ```
+        _Publishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can set `serve_locally` to `False` and you may see faster load times._
+
+5. Share your component with the community! https://community.plotly.com/c/dash
+    1. Publish this repository to GitHub
+    2. Tag your GitHub repository with the plotly-dash tag so that it appears here: https://github.com/topics/plotly-dash
+    3. Create a post in the Dash community forum: https://community.plotly.com/c/dash

dash_week_range_picker-0.0.1/README.md

@@ -0,0 +1,98 @@
+# Dash Week Range Picker
+
+Dash Week Range Picker is a Dash component library.
+
+Mantine-based ISO-week range picker for Dash
+
+Get started with:
+1. Install Dash and its dependencies: https://dash.plotly.com/installation
+2. Run `python usage.py`
+3. Visit http://localhost:8050 in your web browser
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md)
+
+### Install dependencies
+
+If you have selected install_dependencies during the prompt, you can skip this part.
+
+1. Install npm packages
+    ```
+    $ npm install
+    ```
+2. Create a virtual env and activate.
+    ```
+    $ virtualenv venv
+    $ . venv/bin/activate
+    ```
+    _Note: venv\Scripts\activate for windows_
+
+3. Install python packages required to build components.
+    ```
+    $ pip install -r requirements.txt
+    ```
+4. Install the python packages for testing (optional)
+    ```
+    $ pip install -r tests/requirements.txt
+    ```
+
+### Write your component code in `src/lib/components/DashWeekRangePicker.react.js`.
+
+- The demo app is in `src/demo` and you will import your example component code into your demo app.
+- Test your code in a Python environment:
+    1. Build your code
+        ```
+        $ npm run build
+        ```
+    2. Run and modify the `usage.py` sample dash app:
+        ```
+        $ python usage.py
+        ```
+- Write tests for your component.
+    - A sample test is available in `tests/test_usage.py`, it will load `usage.py` and you can then automate interactions with selenium.
+    - Run the tests with `$ pytest tests`.
+    - The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g. https://github.com/plotly/dash-core-components)
+- Add custom styles to your component by putting your custom CSS files into your distribution folder (`dash_week_range_picker`).
+    - Make sure that they are referenced in `MANIFEST.in` so that they get properly included when you're ready to publish your component.
+    - Make sure the stylesheets are added to the `_css_dist` dict in `dash_week_range_picker/__init__.py` so dash will serve them automatically when the component suite is requested.
+- [Review your code](./review_checklist.md)
+
+### Create a production build and publish:
+
+1. Build your code:
+    ```
+    $ npm run build
+    ```
+2. Create a Python distribution
+    ```
+    $ python setup.py sdist bdist_wheel
+    ```
+    This will create source and wheel distribution in the generated the `dist/` folder.
+    See [PyPA](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project)
+    for more information.
+
+3. Test your tarball by copying it into a new environment and installing it locally:
+    ```
+    $ pip install dash_week_range_picker-0.0.1.tar.gz
+    ```
+
+4. If it works, then you can publish the component to NPM and PyPI:
+    1. Publish on PyPI
+        ```
+        $ twine upload dist/*
+        ```
+    2. Cleanup the dist folder (optional)
+        ```
+        $ rm -rf dist
+        ```
+    3. Publish on NPM (Optional if chosen False in `publish_on_npm`)
+        ```
+        $ npm publish
+        ```
+        _Publishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can set `serve_locally` to `False` and you may see faster load times._
+
+5. Share your component with the community! https://community.plotly.com/c/dash
+    1. Publish this repository to GitHub
+    2. Tag your GitHub repository with the plotly-dash tag so that it appears here: https://github.com/topics/plotly-dash
+    3. Create a post in the Dash community forum: https://community.plotly.com/c/dash

dash_week_range_picker-0.0.1/dash_week_range_picker/WeekRangePickerInput.py

@@ -0,0 +1,193 @@
+# 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 WeekRangePickerInput(Component):
+    """A WeekRangePickerInput component.
+WeekRangePickerInput - an ISO-week-granularity range picker (Mantine `Calendar` + `PickerInputBase`
+composed by hand, the same public building blocks Mantine's own `YearPickerInput`/`MonthPickerInput`
+are built from). Clicking any day selects/commits its whole ISO week (Monday-Sunday), instead of the
+arbitrary single day a normal date-range picker would give you.
+
+`value` is always `[startISO, endISO]` where both bounds already fall on a Monday/Sunday
+respectively, or `[startISO, null]` while a range is mid-selection (exactly one week picked so far),
+or `[null, null]` when empty - the same shape a Dash range DatePickerInput already emits, so it drops
+into any callback written against `utils.dates.unpack_range`/`range_pending` unchanged.
+
+Keyword arguments:
+
+- id (string | dict; optional):
+    The ID used to identify this component in Dash callbacks. Works as
+    a normal Dash id, including pattern-matching (dict) ids.
+
+- className (string; optional):
+    CSS class for the outer wrapper div.
+
+- clearable (boolean; default True):
+    Shows a clear button (resets value to `[None, None]`) once a range
+    is selected.
+
+- closeOnChange (boolean; default False):
+    Closes the calendar popover as soon as a range is completed (or a
+    preset is clicked).
+
+- firstDayOfWeek (number; default 1):
+    0-6, where 1 = Monday. Do not change this - the
+    click-to-select-week snapping logic always snaps to the
+    Monday/Sunday of the ISO week regardless of this prop, so changing
+    it would only desync the visual grid from that logic, not the
+    weeks it actually selects.
+
+- forceColorScheme (a value equal to: 'light', 'dark'; default undefined):
+    Forces a specific color scheme (\"light\" | \"dark\") on this
+    component's own `MantineProvider`, independent of the host app's
+    own scheme.
+
+- highlightToday (boolean; default True):
+    Highlights today's date in the calendar.
+
+- loading_state (dict; optional):
+    Object that holds the loading state object coming from
+    dash-renderer.
+
+    `loading_state` is a dict with keys:
+
+    - is_loading (boolean; optional):
+        Determines if the component is loading or not.
+
+    - prop_name (string; optional):
+        Holds which property is loading.
+
+    - component_name (string; optional):
+        Holds the name of the component that is loading.
+
+- maxDate (string; optional):
+    Latest selectable date, ISO `YYYY-MM-DD`.
+
+- minDate (string; optional):
+    Earliest selectable date, ISO `YYYY-MM-DD`. Does not need to be
+    week-aligned itself; days before it are disabled in the calendar
+    the normal Mantine way.
+
+- persisted_props (list of a value equal to: 'value's; default ['value']):
+    Properties whose user interactions will persist after refreshing
+    the component or the page.
+
+- persistence (boolean | string | number; default False):
+    Used to allow user interactions in this component to be persisted
+    when the component - or the page - is refreshed. If `persisted` is
+    truthy and `persistence_type` is `session`, the value is persisted
+    for the duration of the browser session.
+
+- persistence_type (a value equal to: 'local', 'session', 'memory'; default 'local'):
+    Where persisted user changes will be stored: `memory` (only kept
+    in memory, reset on page refresh), `local` (window.localStorage,
+    data is kept after the browser quit), or `session`
+    (window.sessionStorage, data is cleared once the browser quit).
+
+- placeholder (string; default 'Select Period'):
+    Text shown in the input when no range is selected.
+
+- presets (list of dicts; optional):
+    Quick-pick shortcuts shown to the left of the calendar, each
+    `value` already a week-aligned `[startISO, endISO]` pair, e.g.
+    `{\"label\": \"Last 12 Weeks\", \"value\": [\"2026-03-16\",
+    \"2026-06-07\"]}`.
+
+    `presets` is a list of dicts with keys:
+
+    - label (string; optional)
+
+    - value (list of strings; optional)
+
+- theme (dict; optional):
+    Mantine theme override, merged into this component's own isolated
+    `MantineProvider` (this component ships its own private copy of
+    `@mantine/core`, so it does not automatically inherit a host app's
+    `MantineProvider` theme - pass the same theme dict the host app
+    uses here instead).
+
+- value (list of strings; default [None, None]):
+    `[startISO, endISO]`, both ISO `YYYY-MM-DD` and already
+    week-aligned (Monday/Sunday), e.g. `[\"2026-06-01\",
+    \"2026-06-07\"]`. `[startISO, None]` while a range is
+    mid-selection (one week picked so far). `[None, None]` (or unset)
+    when empty.
+
+- withWeekNumbers (boolean; default True):
+    Shows the ISO week-number column next to the calendar grid."""
+    _children_props: typing.List[str] = []
+    _base_nodes = ['children']
+    _namespace = 'dash_week_range_picker'
+    _type = 'WeekRangePickerInput'
+    Presets = TypedDict(
+        "Presets",
+            {
+            "label": NotRequired[str],
+            "value": NotRequired[typing.Sequence[str]]
+        }
+    )
+
+    LoadingState = TypedDict(
+        "LoadingState",
+            {
+            "is_loading": NotRequired[bool],
+            "prop_name": NotRequired[str],
+            "component_name": NotRequired[str]
+        }
+    )
+
+
+    def __init__(
+        self,
+        id: typing.Optional[typing.Union[str, dict]] = None,
+        value: typing.Optional[typing.Sequence[str]] = None,
+        minDate: typing.Optional[str] = None,
+        maxDate: typing.Optional[str] = None,
+        presets: typing.Optional[typing.Sequence["Presets"]] = None,
+        placeholder: typing.Optional[str] = None,
+        clearable: typing.Optional[bool] = None,
+        closeOnChange: typing.Optional[bool] = None,
+        withWeekNumbers: typing.Optional[bool] = None,
+        highlightToday: typing.Optional[bool] = None,
+        firstDayOfWeek: typing.Optional[NumberType] = None,
+        theme: typing.Optional[dict] = None,
+        forceColorScheme: typing.Optional[Literal["light", "dark"]] = None,
+        className: typing.Optional[str] = None,
+        style: typing.Optional[typing.Any] = None,
+        loading_state: typing.Optional["LoadingState"] = None,
+        persistence: typing.Optional[typing.Union[bool, str, NumberType]] = None,
+        persisted_props: typing.Optional[typing.Sequence[Literal["value"]]] = None,
+        persistence_type: typing.Optional[Literal["local", "session", "memory"]] = None,
+        **kwargs
+    ):
+        self._prop_names = ['id', 'className', 'clearable', 'closeOnChange', 'firstDayOfWeek', 'forceColorScheme', 'highlightToday', 'loading_state', 'maxDate', 'minDate', 'persisted_props', 'persistence', 'persistence_type', 'placeholder', 'presets', 'style', 'theme', 'value', 'withWeekNumbers']
+        self._valid_wildcard_attributes =            []
+        self.available_properties = ['id', 'className', 'clearable', 'closeOnChange', 'firstDayOfWeek', 'forceColorScheme', 'highlightToday', 'loading_state', 'maxDate', 'minDate', 'persisted_props', 'persistence', 'persistence_type', 'placeholder', 'presets', 'style', 'theme', 'value', 'withWeekNumbers']
+        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}
+
+        super(WeekRangePickerInput, self).__init__(**args)
+
+setattr(WeekRangePickerInput, "__init__", _explicitize_args(WeekRangePickerInput.__init__))

dash_week_range_picker-0.0.1/dash_week_range_picker/__init__.py

@@ -0,0 +1,87 @@
+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__]
+
+async_resources = []
+
+_js_dist = []
+
+_js_dist.extend(
+    [
+        {
+            "relative_package_path": "async-{}.js".format(async_resource),
+            "external_url": (
+                "https://unpkg.com/{0}@{2}"
+                "/{1}/async-{3}.js"
+            ).format(package_name, __name__, __version__, async_resource),
+            "namespace": package_name,
+            "async": True,
+        }
+        for async_resource in async_resources
+    ]
+)
+
+# TODO: Figure out if unpkg link works
+_js_dist.extend(
+    [
+        {
+            "relative_package_path": "async-{}.js.map".format(async_resource),
+            "external_url": (
+                "https://unpkg.com/{0}@{2}"
+                "/{1}/async-{3}.js.map"
+            ).format(package_name, __name__, __version__, async_resource),
+            "namespace": package_name,
+            "dynamic": True,
+        }
+        for async_resource in async_resources
+    ]
+)
+
+_js_dist.extend(
+    [
+        {
+            'relative_package_path': 'dash_week_range_picker.min.js',
+    
+            'namespace': package_name
+        },
+        {
+            'relative_package_path': 'dash_week_range_picker.min.js.map',
+    
+            'namespace': package_name,
+            'dynamic': True
+        }
+    ]
+)
+
+_css_dist = []
+
+
+for _component in __all__:
+    setattr(locals()[_component], '_js_dist', _js_dist)
+    setattr(locals()[_component], '_css_dist', _css_dist)

dash_week_range_picker-0.0.1/dash_week_range_picker/_imports_.py

@@ -0,0 +1,5 @@
+from .WeekRangePickerInput import WeekRangePickerInput
+
+__all__ = [
+    "WeekRangePickerInput"
+]