nicegui 1.2.1__tar.gz → 1.2.2__tar.gz

{nicegui-1.2.1 → nicegui-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nicegui
-Version: 1.2.1
+Version: 1.2.2
 Summary: Web User Interface with Buttons, Dialogs, Markdown, 3D Scences and Plots
 Home-page: https://github.com/zauberzeug/nicegui
 License: MIT
@@ -111,10 +111,10 @@ Note: NiceGUI will automatically reload the page when you modify the code.
 
 ## Documentation and Examples
 
-The API reference is hosted at [https://nicegui.io/reference](https://nicegui.io/reference) and provides plenty of live examples.
+The documentation is hosted at [https://nicegui.io/documentation](https://nicegui.io/documentation) and provides plenty of live demos.
 The whole content of [https://nicegui.io](https://nicegui.io) is [implemented with NiceGUI itself](https://github.com/zauberzeug/nicegui/blob/main/main.py).
 
-You may also have a look at [our in-depth demonstrations](https://github.com/zauberzeug/nicegui/tree/main/examples) of what you can do with NiceGUI.
+You may also have a look at our [in-depth examples](https://github.com/zauberzeug/nicegui/tree/main/examples) of what you can do with NiceGUI.
 
 ## Why?
 

{nicegui-1.2.1 → nicegui-1.2.2}/README.md

@@ -75,10 +75,10 @@ Note: NiceGUI will automatically reload the page when you modify the code.
 
 ## Documentation and Examples
 
-The API reference is hosted at [https://nicegui.io/reference](https://nicegui.io/reference) and provides plenty of live examples.
+The documentation is hosted at [https://nicegui.io/documentation](https://nicegui.io/documentation) and provides plenty of live demos.
 The whole content of [https://nicegui.io](https://nicegui.io) is [implemented with NiceGUI itself](https://github.com/zauberzeug/nicegui/blob/main/main.py).
 
-You may also have a look at [our in-depth demonstrations](https://github.com/zauberzeug/nicegui/tree/main/examples) of what you can do with NiceGUI.
+You may also have a look at our [in-depth examples](https://github.com/zauberzeug/nicegui/tree/main/examples) of what you can do with NiceGUI.
 
 ## Why?
 

{nicegui-1.2.1 → nicegui-1.2.2}/nicegui/element.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import re
-from abc import ABC
 from copy import deepcopy
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
 
@@ -20,12 +19,13 @@ if TYPE_CHECKING:
 PROPS_PATTERN = re.compile(r'([\w\-]+)(?:=(?:("[^"\\]*(?:\\.[^"\\]*)*")|([\w\-.%:\/]+)))?(?:$|\s)')
 
 
-class Element(ABC, Visibility):
+class Element(Visibility):
 
     def __init__(self, tag: str, *, _client: Optional[Client] = None) -> None:
         """Generic Element
 
-        This class is also the base class for all other elements.
+        This class is the base class for all other UI elements.
+        But you can use it to create elements with arbitrary HTML tags.
 
         :param tag: HTML tag of the element
         :param _client: client for this element (for internal use only)
@@ -167,10 +167,6 @@ class Element(ABC, Visibility):
 
         Removing or replacing styles can be helpful if the predefined style is not desired.
 
-        .. codeblock:: python
-
-            ui.button('Click me').style('color: #6E93D6; font-size: 200%', remove='font-weight; background-color')
-
         :param add: semicolon-separated list of styles to add to the element
         :param remove: semicolon-separated list of styles to remove from the element
         :param replace: semicolon-separated list of styles to use instead of existing ones
@@ -203,10 +199,6 @@ class Element(ABC, Visibility):
         This allows modifying the look of the element or its layout using `Quasar <https://quasar.dev/>`_ props.
         Since props are simply applied as HTML attributes, they can be used with any HTML element.
 
-        .. codeblock:: python
-
-            ui.button('Open menu').props('outline icon=menu')
-
         Boolean properties are assumed ``True`` if no value is specified.
 
         :param add: whitespace-delimited list of either boolean values or key=value pair to add

{nicegui-1.2.1 → nicegui-1.2.2}/nicegui/elements/color_input.py

@@ -26,5 +26,11 @@ class ColorInput(ValueElement):
 
         with self.add_slot('append'):
             self.picker = ColorPicker(on_pick=lambda e: self.set_value(e.color))
-            self.button = ui.button(on_click=self.picker.open) \
+            self.button = ui.button(on_click=self.open_picker) \
                 .props('icon=colorize flat round', remove='color').classes('cursor-pointer')
+
+    def open_picker(self) -> None:
+        """Open the color picker"""
+        if self.value:
+            self.picker.set_color(self.value)
+        self.picker.open()

{nicegui-1.2.1 → nicegui-1.2.2}/nicegui/elements/color_picker.py

@@ -18,4 +18,11 @@ class ColorPicker(Menu):
         with self:
             def handle_change(msg: Dict):
                 handle_event(on_pick, ColorPickEventArguments(sender=self, client=self.client, color=msg['args']))
-            Element('q-color').on('change', handle_change)
+            self.q_color = Element('q-color').on('change', handle_change)
+
+    def set_color(self, color: str) -> None:
+        """Set the color of the picker
+
+        :param color: the color to set
+        """
+        self.q_color.props(f'model-value="{color}"')

nicegui-1.2.2/nicegui/elements/interactive_image.js

@@ -0,0 +1,65 @@
+export default {
+  template: `
+    <div style="position:relative">
+      <img :src="src" style="width:100%; height:100%;" v-on="onEvents" draggable="false" />
+      <svg v-if="cross" style="position:absolute;top:0;left:0;pointer-events:none" :viewBox="viewBox">
+        <g :style="{ display: cssDisplay }">
+          <line :x1="x" y1="0" :x2="x" y2="100%" stroke="black" />
+          <line x1="0" :y1="y" x2="100%" :y2="y" stroke="black" />
+        </g>
+        <g v-html="content"></g>
+      </svg>
+    </div>
+  `,
+  data() {
+    return {
+      viewBox: "0 0 0 0",
+      x: 100,
+      y: 100,
+      cssDisplay: "none",
+    };
+  },
+  methods: {
+    updateCrossHair(e) {
+      this.x = (e.offsetX * e.target.naturalWidth) / e.target.clientWidth;
+      this.y = (e.offsetY * e.target.naturalHeight) / e.target.clientHeight;
+    },
+    onImageLoaded(e) {
+      this.viewBox = `0 0 ${e.target.naturalWidth} ${e.target.naturalHeight}`;
+    },
+    onMouseEvent(type, e) {
+      this.$emit("mouse", {
+        mouse_event_type: type,
+        image_x: (e.offsetX * e.target.naturalWidth) / e.target.clientWidth,
+        image_y: (e.offsetY * e.target.naturalHeight) / e.target.clientHeight,
+        button: e.button,
+        buttons: e.buttons,
+        altKey: e.altKey,
+        ctrlKey: e.ctrlKey,
+        metaKey: e.metaKey,
+        shiftKey: e.shiftKey,
+      });
+    },
+  },
+  computed: {
+    onEvents() {
+      const allEvents = {};
+      for (const type of this.events) {
+        allEvents[type] = (event) => this.onMouseEvent(type, event);
+      }
+      if (this.cross) {
+        allEvents["mouseenter"] = () => (this.cssDisplay = "block");
+        allEvents["mouseleave"] = () => (this.cssDisplay = "none");
+        allEvents["mousemove"] = (event) => this.updateCrossHair(event);
+        allEvents["load"] = (event) => this.onImageLoaded(event);
+      }
+      return allEvents;
+    },
+  },
+  props: {
+    src: String,
+    content: String,
+    events: Array,
+    cross: Boolean,
+  },
+};

{nicegui-1.2.1 → nicegui-1.2.2}/nicegui/elements/interactive_image.py

@@ -52,7 +52,3 @@ class InteractiveImage(SourceElement, ContentElement):
             )
             return handle_event(on_mouse, arguments)
         self.on('mouse', handle_mouse)
-
-    def on_source_change(self, source: str) -> None:
-        super().on_source_change(source)
-        self.run_method('set_source', source)

{nicegui-1.2.1 → nicegui-1.2.2}/nicegui/elements/markdown.js

@@ -1,6 +1,7 @@
 export default {
   template: `<div></div>`,
   mounted() {
+    this.ensure_codehilite_css();
     this.update(this.$el.innerHTML);
   },
   methods: {
@@ -11,6 +12,18 @@ export default {
         mermaid.render(`mermaid_${this.$el.id}_${i}`, code, (svg) => (pre.innerHTML = svg));
       });
     },
+    ensure_codehilite_css() {
+      if (!document.querySelector(`style[data-codehilite-css]`)) {
+        const style = document.createElement("style");
+        style.setAttribute("data-codehilite-css", "");
+        style.innerHTML = this.codehilite_css;
+        console.log(style);
+        document.head.appendChild(style);
+      }
+    },
+  },
+  props: {
+    codehilite_css: String,
   },
 };
 

{nicegui-1.2.1 → nicegui-1.2.2}/nicegui/elements/markdown.py

@@ -4,6 +4,7 @@ from functools import lru_cache
 from typing import List
 
 import markdown2
+from pygments.formatters import HtmlFormatter
 
 from ..dependencies import register_component
 from .mixins.content_element import ContentElement
@@ -23,6 +24,7 @@ class Markdown(ContentElement):
         """
         self.extras = extras
         super().__init__(tag='markdown', content=content)
+        self._props['codehilite_css'] = HtmlFormatter(nobackground=True).get_style_defs('.codehilite')
 
     def on_content_change(self, content: str) -> None:
         html = prepare_content(content, extras=' '.join(self.extras))
@@ -33,7 +35,7 @@ class Markdown(ContentElement):
 
 @lru_cache(maxsize=int(os.environ.get('MARKDOWN_CONTENT_CACHE_SIZE', '1000')))
 def prepare_content(content: str, extras: str) -> str:
-    html = markdown2.markdown(content, extras=extras.split())
+    html = markdown2.markdown(remove_indentation(content), extras=extras.split())
     return apply_tailwind(html)  # we need explicit Markdown styling because tailwind CSS removes all default styles
 
 
@@ -52,3 +54,14 @@ def apply_tailwind(html: str) -> str:
     }
     pattern = re.compile('|'.join(rep.keys()))
     return pattern.sub(lambda m: rep[re.escape(m.group(0))], html)
+
+
+def remove_indentation(text: str) -> str:
+    """Remove indentation from a multi-line string based on the indentation of the first non-empty line."""
+    lines = text.splitlines()
+    while lines and not lines[0].strip():
+        lines.pop(0)
+    if not lines:
+        return ''
+    indentation = len(lines[0]) - len(lines[0].lstrip())
+    return '\n'.join(line[indentation:] for line in lines)

nicegui-1.2.2/nicegui/elements/mixins/content_element.py

@@ -0,0 +1,80 @@
+from typing import Any, Callable
+
+from typing_extensions import Self
+
+from ...binding import BindableProperty, bind, bind_from, bind_to
+from ...element import Element
+
+
+class ContentElement(Element):
+    CONTENT_PROP = 'innerHTML'
+    content = BindableProperty(on_change=lambda sender, content: sender.on_content_change(content))
+
+    def __init__(self, *, content: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.content = content
+        self.on_content_change(content)
+
+    def bind_content_to(self,
+                        target_object: Any,
+                        target_name: str = 'content',
+                        forward: Callable = lambda x: x) -> Self:
+        """Bind the content of this element to the target object's target_name property.
+
+        The binding works one way only, from this element to the target.
+
+        :param target_object: The object to bind to.
+        :param target_name: The name of the property to bind to.
+        :param forward: A function to apply to the value before applying it to the target.
+        """
+        bind_to(self, 'content', target_object, target_name, forward)
+        return self
+
+    def bind_content_from(self,
+                          target_object: Any,
+                          target_name: str = 'content',
+                          backward: Callable = lambda x: x) -> Self:
+        """Bind the content of this element from the target object's target_name property.
+
+        The binding works one way only, from the target to this element.
+
+        :param target_object: The object to bind from.
+        :param target_name: The name of the property to bind from.
+        :param backward: A function to apply to the value before applying it to this element.
+        """
+        bind_from(self, 'content', target_object, target_name, backward)
+        return self
+
+    def bind_content(self,
+                     target_object: Any,
+                     target_name: str = 'content', *,
+                     forward: Callable = lambda x: x,
+                     backward: Callable = lambda x: x) -> Self:
+        """Bind the content of this element to the target object's target_name property.
+
+        The binding works both ways, from this element to the target and from the target to this element.
+
+        :param target_object: The object to bind to.
+        :param target_name: The name of the property to bind to.
+        :param forward: A function to apply to the value before applying it to the target.
+        :param backward: A function to apply to the value before applying it to this element.
+        """
+        bind(self, 'content', target_object, target_name, forward=forward, backward=backward)
+        return self
+
+    def set_content(self, content: str) -> None:
+        """Set the content of this element.
+
+        :param content: The new content.
+        """
+        self.content = content
+
+    def on_content_change(self, content: str) -> None:
+        """Called when the content of this element changes.
+
+        :param content: The new content.
+        """
+        if self.CONTENT_PROP == 'innerHTML' and '</script>' in content:
+            raise ValueError('HTML elements must not contain <script> tags. Use ui.add_body_html() instead.')
+        self._props[self.CONTENT_PROP] = content
+        self.update()

nicegui-1.2.2/nicegui/elements/mixins/filter_element.py

@@ -0,0 +1,78 @@
+from typing import Any, Callable, Optional
+
+from typing_extensions import Self
+
+from ...binding import BindableProperty, bind, bind_from, bind_to
+from ...element import Element
+
+
+class FilterElement(Element):
+    FILTER_PROP = 'filter'
+    filter = BindableProperty(on_change=lambda sender, filter: sender.on_filter_change(filter))
+
+    def __init__(self, *, filter: Optional[str] = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.filter = filter
+        self._props[self.FILTER_PROP] = filter
+
+    def bind_filter_to(self,
+                       target_object: Any,
+                       target_name: str = 'filter',
+                       forward: Callable = lambda x: x) -> Self:
+        """Bind the filter of this element to the target object's target_name property.
+
+        The binding works one way only, from this element to the target.
+
+        :param target_object: The object to bind to.
+        :param target_name: The name of the property to bind to.
+        :param forward: A function to apply to the value before applying it to the target.
+        """
+        bind_to(self, 'filter', target_object, target_name, forward)
+        return self
+
+    def bind_filter_from(self,
+                         target_object: Any,
+                         target_name: str = 'filter',
+                         backward: Callable = lambda x: x) -> Self:
+        """Bind the filter of this element from the target object's target_name property.
+
+        The binding works one way only, from the target to this element.
+
+        :param target_object: The object to bind from.
+        :param target_name: The name of the property to bind from.
+        :param backward: A function to apply to the value before applying it to this element.
+        """
+        bind_from(self, 'filter', target_object, target_name, backward)
+        return self
+
+    def bind_filter(self,
+                    target_object: Any,
+                    target_name: str = 'filter', *,
+                    forward: Callable = lambda x: x,
+                    backward: Callable = lambda x: x) -> Self:
+        """Bind the filter of this element to the target object's target_name property.
+
+        The binding works both ways, from this element to the target and from the target to this element.
+
+        :param target_object: The object to bind to.
+        :param target_name: The name of the property to bind to.
+        :param forward: A function to apply to the value before applying it to the target.
+        :param backward: A function to apply to the value before applying it to this element.
+        """
+        bind(self, 'filter', target_object, target_name, forward=forward, backward=backward)
+        return self
+
+    def set_filter(self, filter: str) -> None:
+        """Set the filter of this element.
+
+        :param filter: The new filter.
+        """
+        self.filter = filter
+
+    def on_filter_change(self, filter: str) -> None:
+        """Called when the filter of this element changes.
+
+        :param filter: The new filter.
+        """
+        self._props[self.FILTER_PROP] = filter
+        self.update()

nicegui-1.2.2/nicegui/elements/mixins/source_element.py

@@ -0,0 +1,77 @@
+from typing import Any, Callable
+
+from typing_extensions import Self
+
+from ...binding import BindableProperty, bind, bind_from, bind_to
+from ...element import Element
+
+
+class SourceElement(Element):
+    source = BindableProperty(on_change=lambda sender, source: sender.on_source_change(source))
+
+    def __init__(self, *, source: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.source = source
+        self._props['src'] = source
+
+    def bind_source_to(self,
+                       target_object: Any,
+                       target_name: str = 'source',
+                       forward: Callable = lambda x: x) -> Self:
+        """Bind the source of this element to the target object's target_name property.
+
+        The binding works one way only, from this element to the target.
+
+        :param target_object: The object to bind to.
+        :param target_name: The name of the property to bind to.
+        :param forward: A function to apply to the value before applying it to the target.
+        """
+        bind_to(self, 'source', target_object, target_name, forward)
+        return self
+
+    def bind_source_from(self,
+                         target_object: Any,
+                         target_name: str = 'source',
+                         backward: Callable = lambda x: x) -> Self:
+        """Bind the source of this element from the target object's target_name property.
+
+        The binding works one way only, from the target to this element.
+
+        :param target_object: The object to bind from.
+        :param target_name: The name of the property to bind from.
+        :param backward: A function to apply to the value before applying it to this element.
+        """
+        bind_from(self, 'source', target_object, target_name, backward)
+        return self
+
+    def bind_source(self,
+                    target_object: Any,
+                    target_name: str = 'source', *,
+                    forward: Callable = lambda x: x,
+                    backward: Callable = lambda x: x) -> Self:
+        """Bind the source of this element to the target object's target_name property.
+
+        The binding works both ways, from this element to the target and from the target to this element.
+
+        :param target_object: The object to bind to.
+        :param target_name: The name of the property to bind to.
+        :param forward: A function to apply to the value before applying it to the target.
+        :param backward: A function to apply to the value before applying it to this element.
+        """
+        bind(self, 'source', target_object, target_name, forward=forward, backward=backward)
+        return self
+
+    def set_source(self, source: str) -> None:
+        """Set the source of this element.
+
+        :param source: The new source.
+        """
+        self.source = source
+
+    def on_source_change(self, source: str) -> None:
+        """Called when the source of this element changes.
+
+        :param source: The new source.
+        """
+        self._props['src'] = source
+        self.update()

nicegui-1.2.2/nicegui/elements/mixins/text_element.py

@@ -0,0 +1,80 @@
+from typing import Any, Callable
+
+from typing_extensions import Self
+
+from ...binding import BindableProperty, bind, bind_from, bind_to
+from ...element import Element
+
+
+class TextElement(Element):
+    text = BindableProperty(on_change=lambda sender, text: sender.on_text_change(text))
+
+    def __init__(self, *, text: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.text = text
+        self._text_to_model_text(text)
+
+    def bind_text_to(self,
+                     target_object: Any,
+                     target_name: str = 'text',
+                     forward: Callable = lambda x: x) -> Self:
+        """Bind the text of this element to the target object's target_name property.
+
+        The binding works one way only, from this element to the target.
+
+        :param target_object: The object to bind to.
+        :param target_name: The name of the property to bind to.
+        :param forward: A function to apply to the value before applying it to the target.
+        """
+        bind_to(self, 'text', target_object, target_name, forward)
+        return self
+
+    def bind_text_from(self,
+                       target_object: Any,
+                       target_name: str = 'text',
+                       backward: Callable = lambda x: x) -> Self:
+        """Bind the text of this element from the target object's target_name property.
+
+        The binding works one way only, from the target to this element.
+
+        :param target_object: The object to bind from.
+        :param target_name: The name of the property to bind from.
+        :param backward: A function to apply to the value before applying it to this element.
+        """
+        bind_from(self, 'text', target_object, target_name, backward)
+        return self
+
+    def bind_text(self,
+                  target_object: Any,
+                  target_name: str = 'text', *,
+                  forward: Callable = lambda x: x,
+                  backward: Callable = lambda x: x) -> Self:
+        """Bind the text of this element to the target object's target_name property.
+
+        The binding works both ways, from this element to the target and from the target to this element.
+
+        :param target_object: The object to bind to.
+        :param target_name: The name of the property to bind to.
+        :param forward: A function to apply to the value before applying it to the target.
+        :param backward: A function to apply to the value before applying it to this element.
+        """
+        bind(self, 'text', target_object, target_name, forward=forward, backward=backward)
+        return self
+
+    def set_text(self, text: str) -> None:
+        """Set the text of this element.
+
+        :param text: The new text.
+        """
+        self.text = text
+
+    def on_text_change(self, text: str) -> None:
+        """Called when the text of this element changes.
+
+        :param text: The new text.
+        """
+        self._text_to_model_text(text)
+        self.update()
+
+    def _text_to_model_text(self, text: str) -> None:
+        self._text = text

nicegui-1.2.2/nicegui/elements/mixins/value_element.py

@@ -0,0 +1,102 @@
+from typing import Any, Callable, Dict, Optional
+
+from typing_extensions import Self
+
+from ...binding import BindableProperty, bind, bind_from, bind_to
+from ...element import Element
+from ...events import ValueChangeEventArguments, handle_event
+
+
+class ValueElement(Element):
+    VALUE_PROP = 'model-value'
+    EVENT_ARGS = ['value']
+    LOOPBACK = True
+    value = BindableProperty(on_change=lambda sender, value: sender.on_value_change(value))
+
+    def __init__(self, *, value: Any, on_value_change: Optional[Callable], throttle: float = 0, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.set_value(value)
+        self._props[self.VALUE_PROP] = self._value_to_model_value(value)
+        self._props['loopback'] = self.LOOPBACK
+        self._send_update_on_value_change = True
+        self.change_handler = on_value_change
+
+        def handle_change(msg: Dict) -> None:
+            self._send_update_on_value_change = self.LOOPBACK
+            self.set_value(self._msg_to_value(msg))
+            self._send_update_on_value_change = True
+        self.on(f'update:{self.VALUE_PROP}', handle_change, self.EVENT_ARGS, throttle=throttle)
+
+    def bind_value_to(self,
+                      target_object: Any,
+                      target_name: str = 'value',
+                      forward: Callable = lambda x: x) -> Self:
+        """Bind the value of this element to the target object's target_name property.
+
+        The binding works one way only, from this element to the target.
+
+        :param target_object: The object to bind to.
+        :param target_name: The name of the property to bind to.
+        :param forward: A function to apply to the value before applying it to the target.
+        """
+        bind_to(self, 'value', target_object, target_name, forward)
+        return self
+
+    def bind_value_from(self,
+                        target_object: Any,
+                        target_name: str = 'value',
+                        backward: Callable = lambda x: x) -> Self:
+        """Bind the value of this element from the target object's target_name property.
+
+        The binding works one way only, from the target to this element.
+
+        :param target_object: The object to bind from.
+        :param target_name: The name of the property to bind from.
+        :param backward: A function to apply to the value before applying it to this element.
+        """
+        bind_from(self, 'value', target_object, target_name, backward)
+        return self
+
+    def bind_value(self,
+                   target_object: Any,
+                   target_name: str = 'value', *,
+                   forward: Callable = lambda x: x,
+                   backward: Callable = lambda x: x) -> Self:
+        """Bind the value of this element to the target object's target_name property.
+
+        The binding works both ways, from this element to the target and from the target to this element.
+
+        :param target_object: The object to bind to.
+        :param target_name: The name of the property to bind to.
+        :param forward: A function to apply to the value before applying it to the target.
+        :param backward: A function to apply to the value before applying it to this element.
+        """
+        bind(self, 'value', target_object, target_name, forward=forward, backward=backward)
+        return self
+
+    def set_value(self, value: Any) -> None:
+        """Set the value of this element.
+
+        :param value: The value to set.
+        """
+        self.value = value
+
+    def on_value_change(self, value: Any) -> None:
+        """Called when the value of this element changes.
+
+        :param value: The new value.
+        """
+        self._props[self.VALUE_PROP] = self._value_to_model_value(value)
+        if self._send_update_on_value_change:
+            self.update()
+        args = ValueChangeEventArguments(sender=self, client=self.client, value=self._value_to_event_value(value))
+        handle_event(self.change_handler, args)
+
+    def _msg_to_value(self, msg: Dict) -> Any:
+        return msg['args']
+
+    def _value_to_model_value(self, value: Any) -> Any:
+        return value
+
+    def _value_to_event_value(self, value: Any) -> Any:
+        return value