pyglove 0.4.5.dev202410170809__py3-none-any.whl → 0.4.5.dev202410190807__py3-none-any.whl

pyglove/core/views/base.py

@@ -133,7 +133,7 @@ import inspect
 import io
 import os
 import types
-from typing import Any, Callable, ContextManager, Dict, Iterator, Optional, Sequence, Set, Type, Union
+from typing import Any, Callable, Dict, Iterator, Optional, Sequence, Set, Type, Union
 
 from pyglove.core import io as pg_io
 from pyglove.core import object_utils
@@ -151,6 +151,12 @@ NodeFilter = Callable[
 ]
 
 
+_VIEW_ARGS_PRESET_NAME = 'pyglove_view_args'
+_VIEW_REGISTRY = {}
+_TLS_KEY_OPERAND_STACK_BY_METHOD = '__view_operand_stack__'
+_TLS_KEY_VIEW_OPTIONS = '__view_options__'
+
+
 class Content(object_utils.Formattable, metaclass=abc.ABCMeta):
   """Content: A type of media to be displayed in a view.
 
@@ -436,14 +442,39 @@ def view(
   if isinstance(value, Content):
     return value
 
-  view_object = View.create(view_id)
-  with View.preset_args(**kwargs):
+  with view_options(**kwargs) as options:
+    view_object = View.create(view_id)
     return view_object.render(
         value, name=name, root_path=root_path or object_utils.KeyPath(),
-        **kwargs
+        **options
     )
 
 
+@contextlib.contextmanager
+def view_options(**kwargs) -> Iterator[Dict[str, Any]]:
+  """Context manager to inject rendering args to view.
+
+  Example:
+
+    with pg.view_options(enable_summary_tooltip=False):
+      MyObject().to_html()
+
+  Args:
+    **kwargs: Keyword arguments for View.render method.
+
+  Yields:
+    The merged keyword arguments.
+  """
+  parent_options = object_utils.thread_local_peek(_TLS_KEY_VIEW_OPTIONS, {})
+  # Deep merge the two dict.
+  options = object_utils.merge([parent_options, kwargs])
+  object_utils.thread_local_push(_TLS_KEY_VIEW_OPTIONS, options)
+  try:
+    yield options
+  finally:
+    object_utils.thread_local_pop(_TLS_KEY_VIEW_OPTIONS)
+
+
 class View(metaclass=abc.ABCMeta):
   """Base class for views.
 
@@ -457,60 +488,6 @@ class View(metaclass=abc.ABCMeta):
   # argument of `pg.view()`. Must be set for non-abstract subclasses.
   VIEW_ID = None
 
-  class PresetArgValue(pg_typing.PresetArgValue):
-    """Argument marker for View and Extension methods to use preset values.
-
-    Methods defined in a ``View`` or ``Extension`` class can be parameterized by
-    keyword arguments from the ``pg.view()`` function. These arguments, referred
-    to as preset arguments, allow the View or Extension method to consume
-    parameters passed during object rendering. For instance, when rendering a
-    user-defined object ``MyObject()`` with a keyword argument
-    ``hide_default=True``, the View or Extension method may use this argument to
-    customize the rendering behavior.
-
-    Since there can be multiple layers of calls between ``View`` and
-    ``Extension`` methods, it is easy to lose track of arguments passed from
-    ``pg.view()``. To simplify this process, users can employ the
-    ``PresetArgValue`` marker to annotate specific arguments. This ensures that
-    View or Extension methods can access preset arguments from the parent call
-    to ``pg.view()``, even when those arguments are not explicitly passed around
-    in subsequent method calls.
-
-    Example usage:
-
-    .. code-block:: python
-
-      class MyView(pg.View):
-        VIEW_TYPE = 'my_view'
-
-        class Extension(pg.View.Extension):
-          def _myview_render(
-              self,
-              *,
-              view,
-              hide_default_value=pg.View.PresetArgValue(default=False),
-              **kwargs
-            ):
-            return view.render(value, **kwargs)
-
-        @pg.View.extension_method('_myview_render')
-        def render(self, value, *, **kwargs):
-          return ...
-
-    In the above example, the ``hide_default_value`` argument is annotated with
-    ``pg.View.PresetArgValue``. This allows it to consume the
-    ``hide_default=True`` keyword argument from the parent call to
-    ``pg.view()``, or fallback to the default value ``False`` if the argument is
-    not provided.
-    """
-
-  @classmethod
-  def preset_args(cls, **kwargs) -> ContextManager[Dict[str, Any]]:
-    """Context manager to provide preset argument values for a specific view."""
-    return pg_typing.preset_args(
-        kwargs, preset_name=_VIEW_ARGS_PRESET_NAME, inherit_preset=True
-    )
-
   class Extension:
     """Extension for the View class.
 
@@ -563,31 +540,6 @@ class View(metaclass=abc.ABCMeta):
     methods to provide custom view rendering for the object.
     """
 
-    def __init_subclass__(cls):
-      # Enable preset args for all methods. As a result, function args
-      # with `View.PresetArgValue` will be able to consume the keyword args
-      # from the call to `pg.view`.
-      supported_preset_args = {}
-      for name, method in cls.__dict__.items():
-        if inspect.isfunction(method):
-          used_preset_args = View.PresetArgValue.inspect(method)
-          if used_preset_args:
-            supported_preset_args.update(used_preset_args)
-            setattr(
-                cls, name,
-                pg_typing.enable_preset_args(
-                    include_all_preset_kwargs=True,
-                    preset_name=_VIEW_ARGS_PRESET_NAME,
-                )(method)
-            )
-      setattr(cls, '_SUPPORTED_PRESET_ARGS', supported_preset_args)
-      super().__init_subclass__()
-
-    @classmethod
-    def supported_preset_args(cls) -> Dict[str, Any]:
-      """Returns supported preset args for this view."""
-      return getattr(cls, '_SUPPORTED_PRESET_ARGS', {})
-
     @classmethod
     @functools.cache
     def supported_view_classes(cls) -> Set[Type['View']]:
@@ -674,6 +626,7 @@ class View(metaclass=abc.ABCMeta):
             sig.args[i].name: arg
             for i, arg in enumerate(args) if i != extension_arg_index
         })
+        kwargs.pop('value', None)
         return kwargs
 
       # We use the original function signature to generate the view method.
@@ -682,14 +635,13 @@ class View(metaclass=abc.ABCMeta):
         # This allows a View method to consume the preset kwargs from the
         # parent call to `pg.view`, yet also customizes the preset kwargs
         # to the calls to other View/Extension methods within this context.
-        with cls.preset_args(**kwargs):
-          return self._maybe_dispatch(   # pylint: disable=protected-access
-              *args, **kwargs,
-              extension=get_extension(args, kwargs),
-              view_method=func,
-              extension_method_name=method_name,
-              arg_map_fn=map_args
-          )
+        return self._maybe_dispatch(   # pylint: disable=protected-access
+            *args, **kwargs,
+            extension=get_extension(args, kwargs),
+            view_method=func,
+            extension_method_name=method_name,
+            arg_map_fn=map_args
+        )
       return _generated_view_fn
     return decorator
 
@@ -709,62 +661,8 @@ class View(metaclass=abc.ABCMeta):
       )
 
     _VIEW_REGISTRY[cls.VIEW_ID] = cls
-
-    # Enable preset args for all view methods. As a result, function args
-    # with `pg.views.View.PresetArgValue` will be able to consume the keyword
-    # args from the parent call to `pg.view`.
-    supported_preset_args = {}
-    for name, method in cls.__dict__.items():
-      if inspect.isfunction(method):
-        used_preset_args = cls.PresetArgValue.inspect(method)
-        if used_preset_args:
-          setattr(
-              cls, name,
-              pg_typing.enable_preset_args(
-                  include_all_preset_kwargs=True,
-                  preset_name=_VIEW_ARGS_PRESET_NAME,
-              )(method)
-          )
-          supported_preset_args.update(used_preset_args)
-
-    setattr(cls, '_SUPPORTED_PRESET_ARGS', supported_preset_args)
     super().__init_subclass__()
 
-  @classmethod
-  def supported_preset_args(
-      cls,
-      view_id: Optional[str] = None,
-      include_all_extensions: bool = True
-  ) -> Dict[Type[Any], Dict[str, Any]]:
-    """Returns all supported preset args for this view.
-
-    Args:
-      view_id: The view ID to get the supported preset args for. If not
-        provided, the default view ID for this class will be used.
-      include_all_extensions: Whether to include the supported preset args from
-        all extensions of this view. If False, only the supported preset args
-        from the base extension class will be included.
-
-    Returns:
-      A dictionary mapping view classes to their supported preset args.
-    """
-    view_id = view_id or cls.VIEW_ID
-    if view_id is None:
-      raise ValueError(
-          'No `VIEW_ID` is set for this View class. Please set `VIEW_ID` '
-          'or provide a `view_id` to `supported_preset_args`.'
-      )
-    supported = {cls: getattr(cls, '_SUPPORTED_PRESET_ARGS', {})}
-    extension_classes = [cls.Extension]
-    if include_all_extensions:
-      extension_classes.extend(cls.Extension.__subclasses__())
-
-    for cls in extension_classes:
-      supported_preset_args = cls.supported_preset_args()
-      if supported_preset_args:
-        supported[cls] = supported_preset_args
-    return supported
-
   @classmethod
   def dir(cls) -> Dict[str, Type['View']]:
     """Returns all registered View classes with their view IDs."""
@@ -872,8 +770,9 @@ class View(metaclass=abc.ABCMeta):
         return view_method(self, *args, **kwargs)
 
       # Call the extension's method.
+      mapped = arg_map_fn(args, kwargs)
       return getattr(extension, extension_method_name)(
-          view=self, **arg_map_fn(args, kwargs)
+          view=self, **mapped
       )
 
   @contextlib.contextmanager
@@ -901,8 +800,3 @@ class View(metaclass=abc.ABCMeta):
           object_utils.thread_local_del(_TLS_KEY_OPERAND_STACK_BY_METHOD)
       else:
         rendering_stack[view_method] = callsite_value
-
-
-_VIEW_ARGS_PRESET_NAME = 'view_args'
-_VIEW_REGISTRY = {}
-_TLS_KEY_OPERAND_STACK_BY_METHOD = '__view_operand_stack__'

pyglove/core/views/base_test.py

@@ -287,8 +287,8 @@ class TestView(View):
         self,
         *,
         view: 'TestView',
-        use_summary: bool = View.PresetArgValue(False),
-        use_content: bool = View.PresetArgValue(False),
+        use_summary: bool = False,
+        use_content: bool = False,
         **kwargs):
       if use_summary:
         return view.summary(self, **kwargs)
@@ -299,7 +299,7 @@ class TestView(View):
     def _test_view_summary(
         self,
         view: 'TestView',
-        default_behavior: bool = View.PresetArgValue(False),
+        default_behavior: bool = False,
         **kwargs):
       if default_behavior:
         return view.summary(self, **kwargs)
@@ -309,7 +309,7 @@ class TestView(View):
       del kwargs
       return Document(f'[Custom Content] {self}')
 
-    def bar(self, x: int = View.PresetArgValue(2)):
+    def bar(self, x: int = 2):
       return x
 
   @View.extension_method('_test_view_render')
@@ -317,7 +317,7 @@ class TestView(View):
       self,
       value: Any,
       *,
-      greeting: str = View.PresetArgValue('hi'),
+      greeting: str = 'hi',
       **kwargs):
     return Document(f'{greeting} {value}')
 
@@ -325,7 +325,7 @@ class TestView(View):
   def summary(
       self,
       value: Any,
-      title: str = View.PresetArgValue('abc'),
+      title: str = 'abc',
       **kwargs
   ):
     del kwargs
@@ -340,7 +340,7 @@ class TestView(View):
     del kwargs
     return Document(f'[Default Key] {key}: {value}')
 
-  def foo(self, x: int = View.PresetArgValue(1)):
+  def foo(self, x: int = 1):
     return x
 
 
@@ -378,7 +378,7 @@ class MyObject(TestView.Extension, TestView2.Extension):
     self.y = y
 
   def _test_view_content(
-      self, *, text: str = View.PresetArgValue('MyObject'), **kwargs
+      self, *, text: str = 'MyObject', **kwargs
   ):
     return Document(f'[{text}] {self.x} {self.y}')
 
@@ -459,49 +459,14 @@ class ViewTest(unittest.TestCase):
         {TestView, TestView2}
     )
 
-  def test_supported_preset_args(self):
-    self.assertEqual(
-        TestView.supported_preset_args(),
-        {
-            TestView: {
-                'greeting': View.PresetArgValue('hi'),
-                'title': View.PresetArgValue('abc'),
-                'x': View.PresetArgValue(1),
-            },
-            TestView.Extension: {
-                'default_behavior': View.PresetArgValue(default=False),
-                'use_content': View.PresetArgValue(False),
-                'use_summary': View.PresetArgValue(False),
-                'x': View.PresetArgValue(2),
-            },
-            MyObject: {
-                'text': View.PresetArgValue('MyObject'),
-            },
-        }
-    )
-    self.assertEqual(
-        TestView2.supported_preset_args(),
-        {
-            TestView2: {},
-            MyObject: {
-                'text': View.PresetArgValue('MyObject'),
-            },
-        }
-    )
-
-    with self.assertRaisesRegex(ValueError, 'No `VIEW_ID` is set'):
-      View.supported_preset_args()
-
-  def test_view_method_using_preset_args(self):
+  def test_view_options(self):
     view = View.create('test')
     self.assertEqual(view.foo(), 1)
-    with View.preset_args(x=2):
-      self.assertEqual(view.foo(), 2)
-
-  def test_node_method_using_preset_args(self):
-    self.assertEqual(MyObject(1, '').bar(), 2)
-    with View.preset_args(x=3):
-      self.assertEqual(MyObject(1, '').bar(), 3)
+    with base.view_options(text='hello', use_content=True):
+      self.assertEqual(
+          base.view(MyObject(1, 'a'), view_id='test').content,
+          '[hello] 1 a'
+      )
 
   def test_view_default_behavior(self):
     view = View.create('test')

pyglove/core/views/html/base.py

@@ -285,8 +285,8 @@ class Html(base.Content):
       inner_html: Optional[List[WritableTypes]] = None,
       *,
       options: Union[str, Iterable[str], None] = None,
-      css_class: NestableStr = None,
-      style: Union[str, Dict[str, Any], None] = None,
+      css_classes: NestableStr = None,
+      styles: Union[str, Dict[str, Any], None] = None,
       **properties
   ) -> 'Html':
     """Creates an HTML element.
@@ -296,8 +296,8 @@ class Html(base.Content):
       inner_html: The inner HTML of the element.
       options: Positional options that will be added to the element. E.g. 'open'
         for `<details open>`.
-      css_class: The CSS class name or a list of CSS class names.
-      style: A single CSS style string or a dictionary of CSS properties.
+      css_classes: The CSS class name or a list of CSS class names.
+      styles: A single CSS style string or a dictionary of CSS properties.
       **properties: Keyword arguments for HTML properties. For properties with
         underscore in the name, the underscore will be replaced by dash in the
         generated HTML. E.g. `background_color` will be converted to
@@ -309,14 +309,14 @@ class Html(base.Content):
     s = cls()
 
     # Write the open tag.
-    css_class = cls.concate(css_class)
+    css_classes = cls.concate(css_classes)
     options = cls.concate(options)
-    style = cls.style_str(style)
+    styles = cls.style_str(styles)
     s.write(
         f'<{tag}',
         f' {options}' if options else None,
-        f' class="{css_class}"' if css_class else None,
-        f' style="{style}"' if style else None,
+        f' class="{css_classes}"' if css_classes else None,
+        f' style="{styles}"' if styles else None,
     )
     for k, v in properties.items():
       if v is not None:
@@ -351,18 +351,19 @@ class Html(base.Content):
 
   @classmethod
   def concate(
-      cls, nestable_str: NestableStr, separator: str = ' '
+      cls, nestable_str: NestableStr, separator: str = ' ', dedup: bool = True
   ) -> Optional[str]:
     """Concates the string nodes in a nestable object."""
-    if isinstance(nestable_str, str):
-      return nestable_str
-    elif isinstance(nestable_str, list):
-      flattened = [cls.concate(s) for s in nestable_str]
-      flattened = [s for s in flattened if s is not None]
-      return separator.join(flattened) if flattened else None
-    else:
-      assert nestable_str is None, nestable_str
-      return None
+    flattened = object_utils.flatten(nestable_str)
+    if isinstance(flattened, str):
+      return flattened
+    elif isinstance(flattened, dict):
+      str_items = [v for v in flattened.values() if isinstance(v, str)]
+      if dedup:
+        str_items = list(dict.fromkeys(str_items).keys())
+      if str_items:
+        return separator.join(str_items)
+    return None
 
   @classmethod
   def style_str(

pyglove/core/views/html/base_test.py

@@ -701,6 +701,8 @@ class HtmlTest(TestCase):
     self.assertIsNone(Html.concate([None, [None, [None, None]]]))
     self.assertEqual(Html.concate('a'), 'a')
     self.assertEqual(Html.concate(['a']), 'a')
+    self.assertEqual(Html.concate(['a', 'a']), 'a')
+    self.assertEqual(Html.concate(['a', 'a'], dedup=False), 'a a')
     self.assertEqual(Html.concate(['a', None, 'b']), 'a b')
     self.assertEqual(
         Html.concate(['a', 'b', [None, 'c', [None, 'd']]]), 'a b c d')
@@ -710,11 +712,11 @@ class HtmlTest(TestCase):
     self.assertEqual(Html.element('div').content, '<div></div>')
     # CSS class as list.
     self.assertEqual(
-        Html.element('div', css_class=['a', 'b', None]).content,
+        Html.element('div', css_classes=['a', 'b', None]).content,
         '<div class="a b"></div>',
     )
     self.assertEqual(
-        Html.element('div', css_class=[None, None]).content,
+        Html.element('div', css_classes=[None, None]).content,
         '<div></div>',
     )
     # Style as string.
@@ -726,7 +728,7 @@ class HtmlTest(TestCase):
     self.assertEqual(
         Html.element(
             'div',
-            style=dict(
+            styles=dict(
                 color='red', background_color='blue', width=None,
             )
         ).content,
@@ -735,7 +737,7 @@ class HtmlTest(TestCase):
     self.assertEqual(
         Html.element(
             'div',
-            style=dict(
+            styles=dict(
                 color=None,
             )
         ).content,
@@ -746,7 +748,7 @@ class HtmlTest(TestCase):
         Html.element(
             'details',
             options='open',
-            css_class='my_class',
+            css_classes='my_class',
             id='my_id',
             custom_property='1'
         ).content,
@@ -759,7 +761,7 @@ class HtmlTest(TestCase):
         Html.element(
             'details',
             options=[None],
-            css_class='my_class',
+            css_classes='my_class',
             id='my_id',
             custom_property='1'
         ).content,
@@ -772,7 +774,7 @@ class HtmlTest(TestCase):
     self.assertEqual(
         Html.element(
             'div',
-            css_class='my_class',
+            css_classes='my_class',
             inner_html='<h1>foo</h1>'
         ).content,
         '<div class="my_class"><h1>foo</h1></div>',
@@ -787,7 +789,7 @@ class HtmlTest(TestCase):
                 None,
                 Html.element(
                     'div',
-                    css_class='my_class',
+                    css_classes='my_class',
                 ).add_style('div.my_class { color: red; }')
             ]
         )),