pyglove 0.5.0.dev202509260810__py3-none-any.whl → 0.5.0.dev202509270808__py3-none-any.whl

pyglove/core/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2019 The PyGlove Authors
+# Copyright 2025 The PyGlove Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -353,6 +353,12 @@ from pyglove.core import coding
 
 from pyglove.core import logging
 
+#
+# Symbols from `monitoring.py`.
+#
+
+from pyglove.core import monitoring
+
 # pylint: enable=g-import-not-at-top
 # pylint: enable=reimported
 # pylint: enable=unused-import

pyglove/core/monitoring.py

@@ -0,0 +1,522 @@
+# Copyright 2025 The PyGlove Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Pluggable metric systems for monitoring.
+
+This module allows PyGlove to plugin metrics to monitor the execution of
+programs.
+"""
+
+import abc
+import collections
+import math
+import threading
+import typing
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+
+
+try:
+  import numpy  # pylint: disable=g-import-not-at-top
+except ImportError:
+  numpy = None
+
+
+class Metric(metaclass=abc.ABCMeta):
+  """Base class for metrics."""
+
+  def __init__(
+      self,
+      namespace: str,
+      name: str,
+      description: str,
+      parameter_definitions: Dict[str, Type[Union[int, str, bool]]]
+  ) -> None:
+    self._namespace = namespace
+    self._name = name
+    self._description = description
+    self._parameter_definitions = parameter_definitions
+
+  @property
+  def namespace(self) -> str:
+    """Returns the namespace of the metric."""
+    return self._namespace
+
+  @property
+  def name(self) -> str:
+    """Returns the name of the metric."""
+    return self._name
+
+  @property
+  def full_name(self) -> str:
+    """Returns the full name of the metric."""
+    return f'{self.namespace}/{self.name}'
+
+  @property
+  def description(self) -> str:
+    """Returns the description of the metric."""
+    return self._description
+
+  @property
+  def parameter_definitions(self) -> Dict[str, Type[Union[int, str, bool]]]:
+    """Returns the parameter definitions of the metric."""
+    return self._parameter_definitions
+
+  def _parameters_key(self, **parameters) -> Tuple[Any, ...]:
+    """Returns the parameters tuple for the metric."""
+    for k, t in self._parameter_definitions.items():
+      v = parameters.get(k)
+      if v is None:
+        raise KeyError(
+            f'Metric {self.full_name!r}: Parameter {k!r} is required but not '
+            f'given.'
+        )
+      if not isinstance(v, t):
+        raise TypeError(
+            f'Metric {self.full_name!r}: Parameter {k!r} has type '
+            f'{type(v)} but expected type {t}.'
+        )
+    for k in parameters:
+      if k not in self._parameter_definitions:
+        raise KeyError(
+            f'Metric {self.full_name!r}: Parameter {k!r} is not defined but '
+            f'provided. Available parameters: '
+            f'{list(self._parameter_definitions.keys())}'
+        )
+    return tuple(parameters[k] for k in self._parameter_definitions)
+
+
+class Counter(Metric):
+  """Base class for counters."""
+
+  @abc.abstractmethod
+  def increment(self, delta: int = 1, **parameters) -> int:
+    """Increments the counter by delta and returns the new value.
+
+    Args:
+      delta: The amount to increment the counter by.
+      **parameters: Parameters for parameterized counters.
+
+    Returns:
+      The new value of the counter.
+    """
+
+  @abc.abstractmethod
+  def value(self, **parameters) -> int:
+    """Returns the value of the counter for the given parameters.
+
+    Args:
+      **parameters: Parameters for parameterized counters.
+
+    Returns:
+      The value of the counter.
+    """
+
+
+class Distribution(metaclass=abc.ABCMeta):
+  """Distribution of scalar values."""
+
+  @property
+  @abc.abstractmethod
+  def count(self) -> int:
+    """Returns the number of samples in the distribution."""
+
+  @property
+  @abc.abstractmethod
+  def sum(self) -> float:
+    """Returns the sum of the distribution."""
+
+  @property
+  @abc.abstractmethod
+  def mean(self) -> float:
+    """Returns the mean of the distribution."""
+
+  @property
+  @abc.abstractmethod
+  def stddev(self) -> float:
+    """Returns the standard deviation of the distribution."""
+
+  @property
+  def median(self) -> float:
+    """Returns the standard deviation of the distribution."""
+    return self.percentile(50)
+
+  @property
+  @abc.abstractmethod
+  def variance(self) -> float:
+    """Returns the variance of the distribution."""
+
+  @abc.abstractmethod
+  def percentile(self, n: float) -> float:
+    """Returns the median of the distribution.
+
+    Args:
+      n: The percentile to return. Should be in the range [0, 100].
+
+    Returns:
+      The n-th percentile of the distribution.
+    """
+
+  @abc.abstractmethod
+  def fraction_less_than(self, value: float) -> float:
+    """Returns the fraction of values in the distribution less than value."""
+
+
+class Scalar(Metric):
+  """Base class for scalar values."""
+
+  @abc.abstractmethod
+  def record(self, value: int, **parameters) -> None:
+    """Records a value to the scalar.
+
+    Args:
+      value: The value to record.
+      **parameters: Parameters for parameterized scalars.
+    """
+
+  @abc.abstractmethod
+  def distribution(self, **parameters) -> Distribution:
+    """Returns the distribution of the scalar.
+
+    Args:
+      **parameters: Parameters for parameterized scalars.
+
+    Returns:
+      The distribution of the scalar.
+    """
+
+
+class MetricCollection(metaclass=abc.ABCMeta):
+  """Base class for counter collections."""
+
+  def __init__(
+      self,
+      namespace: str,
+      default_parameters: Optional[
+          Dict[str, Type[Union[int, str, bool]]]
+      ] = None
+  ):
+    """Initializes the metric collection.
+
+    Args:
+      namespace: The namespace of the metric collection.
+      default_parameters: The default parameters used to create metrics
+        if not specified.
+    """
+    self._namespace = namespace
+    self._default_parameter_definitions = default_parameters or {}
+    self._metrics = self._metric_container()
+
+  @property
+  def namespace(self) -> str:
+    """Returns the namespace of the metric collection."""
+    return self._namespace
+
+  def metrics(self) -> List[Metric]:
+    """Returns the names of the metrics."""
+    return [m for m in self._metrics.values() if m.namespace == self._namespace]
+
+  def _metric_container(self) -> dict[str, Metric]:
+    """Returns the container for metrics."""
+    return {}
+
+  def _get_or_create_metric(
+      self,
+      metric_cls: Type[Metric],
+      create_metric_fn: Callable[
+          [str, str, Dict[str, Type[Union[int, str, bool]]]],
+          Metric
+      ],
+      name: str,
+      description: str,
+      parameter_definitions: Dict[str, Type[Union[int, str, bool]]]
+  ) -> Metric:
+    """Gets or creates a metric with the given name."""
+    full_name = f'{self._namespace}/{name}'
+    metric = self._metrics.get(full_name)
+    if metric is not None:
+      if not isinstance(metric, metric_cls):
+        raise ValueError(
+            f'Metric {full_name!r} already exists with a different type '
+            f'({type(metric)}).'
+        )
+      if description != metric.description:
+        raise ValueError(
+            f'Metric {full_name!r} already exists with a different description '
+            f'({metric.description!r}).'
+        )
+      if parameter_definitions != metric.parameter_definitions:
+        raise ValueError(
+            f'Metric {full_name!r} already exists with different parameter '
+            f'definitions ({metric.parameter_definitions!r}).'
+        )
+    else:
+      metric = create_metric_fn(name, description, parameter_definitions)
+      self._metrics[full_name] = metric
+    return metric
+
+  def get_counter(
+      self,
+      name: str,
+      description: str,
+      parameters: Optional[Dict[str, Type[Union[int, str, bool]]]] = None,
+      **kwargs
+  ) -> Counter:
+    """Gets or creates a counter with the given name.
+
+    Args:
+      name: The name of the counter.
+      description: The description of the counter.
+      parameters: The definitions of the parameters for the counter.
+        `default_parameters` from the collection will be used if not specified.
+      **kwargs: Additional arguments for creating the counter.
+
+    Returns:
+      The counter with the given name.
+    """
+    if parameters is None:
+      parameters = self._default_parameter_definitions
+    return typing.cast(
+        Counter, self._get_or_create_metric(
+            Counter, self._create_counter, name, description, parameters,
+            **kwargs
+        )
+    )
+
+  @abc.abstractmethod
+  def _create_counter(
+      self,
+      name: str,
+      description: str,
+      parameter_definitions: Dict[str, Type[Union[int, str, bool]]],
+      **kwargs
+  ) -> Counter:
+    """Creates a counter with the given name."""
+
+  def get_scalar(
+      self,
+      name: str,
+      description: str,
+      parameters: Optional[Dict[str, Type[Union[int, str, bool]]]] = None,
+      **kwargs
+  ) -> Scalar:
+    """Gets or creates a scalar with the given name.
+
+    Args:
+      name: The name of the counter.
+      description: The description of the counter.
+      parameters: The definitions of the parameters for the counter.
+        `default_parameters` from the collection will be used if not specified.
+      **kwargs: Additional arguments for creating the scalar.
+
+    Returns:
+      The counter with the given name.
+    """
+    if parameters is None:
+      parameters = self._default_parameter_definitions
+    return typing.cast(
+        Scalar,
+        self._get_or_create_metric(
+            Scalar, self._create_scalar, name, description, parameters, **kwargs
+        )
+    )
+
+  @abc.abstractmethod
+  def _create_scalar(
+      self,
+      name: str,
+      description: str,
+      parameter_definitions: Dict[str, Type[Union[int, str, bool]]],
+      **kwargs
+  ) -> Scalar:
+    """Creates a counter with the given name."""
+
+#
+# InMemoryMetricCollection.
+#
+
+
+class _InMemoryCounter(Counter):
+  """In-memory counter."""
+
+  def __init__(self, *args, **kwargs):
+    super().__init__(*args, **kwargs)
+    self._counter = collections.defaultdict(int)
+    self._lock = threading.Lock()
+
+  def increment(self, delta: int = 1, **parameters) -> int:
+    """Increments the counter by delta and returns the new value."""
+    parameters_key = self._parameters_key(**parameters)
+    with self._lock:
+      value = self._counter[parameters_key]
+      value += delta
+      self._counter[parameters_key] = value
+      return value
+
+  def value(self, **parameters) -> int:
+    """Returns the value of the counter based on the given parameters."""
+    return self._counter[self._parameters_key(**parameters)]
+
+
+class _InMemoryScalar(Scalar):
+  """In-memory scalar."""
+
+  def __init__(self, *args, window_size: int = 1024 * 1024, **kwargs):
+    super().__init__(*args, **kwargs)
+    self._window_size = window_size
+    self._distributions = collections.defaultdict(
+        lambda: _InMemoryDistribution(self._window_size)
+    )
+    self._lock = threading.Lock()
+
+  def record(self, value: Any, **parameters) -> None:
+    """Records a value to the scalar."""
+    parameters_key = self._parameters_key(**parameters)
+    self._distributions[parameters_key].add(value)
+
+  def distribution(self, **parameters) -> Distribution:
+    """Returns the distribution of the scalar."""
+    parameters_key = self._parameters_key(**parameters)
+    return self._distributions[parameters_key]
+
+
+class _InMemoryDistribution(Distribution):
+  """In memory distribution of scalar values."""
+
+  def __init__(self, window_size: int = 1024 * 1024):
+    self._window_size = window_size
+    self._data = []
+    self._sum = 0.0
+    self._square_sum = 0.0
+    self._count = 0
+    self._lock = threading.Lock()
+
+  def add(self, value: int):
+    """Adds a value to the distribution."""
+    with self._lock:
+      if len(self._data) == self._window_size:
+        x = self._data.pop(0)
+        self._sum -= x
+        self._count -= 1
+        self._square_sum -= x ** 2
+
+      self._data.append(value)
+      self._count += 1
+      self._sum += value
+      self._square_sum += value ** 2
+
+  @property
+  def count(self) -> int:
+    """Returns the number of samples in the distribution."""
+    return self._count
+
+  @property
+  def sum(self) -> float:
+    """Returns the sum of the distribution."""
+    return self._sum
+
+  @property
+  def mean(self) -> float:
+    """Returns the mean of the distribution."""
+    return self._sum / self._count if self._count else 0.0
+
+  @property
+  def stddev(self) -> float:
+    """Returns the standard deviation of the distribution."""
+    return math.sqrt(self.variance)
+
+  @property
+  def variance(self) -> float:
+    """Returns the variance of the distribution."""
+    if self._count < 2:
+      return 0.0
+    return self._square_sum / self._count - self.mean ** 2
+
+  def percentile(self, n: float) -> float:
+    """Returns the median of the distribution."""
+    if n < 0 or n > 100:
+      raise ValueError(f'Percentile {n} is not in the range [0, 100].')
+
+    if self._count == 0:
+      return 0.0
+
+    if numpy is not None:
+      return numpy.percentile(self._data, n)  # pytype: disable=attribute-error
+
+    sorted_data = sorted(self._data)
+    index = (n / 100) * (len(sorted_data) - 1)
+    if index % 1 == 0:
+      return sorted_data[int(index)]
+    else:
+      # Interpolate the value at the given percentile.
+      lower_index = int(index)
+      fraction = index - lower_index
+
+      # Get the values at the two surrounding integer indices
+      lower_value = sorted_data[lower_index]
+      upper_value = sorted_data[lower_index + 1]
+      return lower_value + fraction * (upper_value - lower_value)
+
+  def fraction_less_than(self, value: float) -> float:
+    """Returns the fraction of values in the distribution less than value."""
+    if self._count == 0:
+      return 0.0
+    with self._lock:
+      return len([x for x in self._data if x < value]) / self._count
+
+
+class InMemoryMetricCollection(MetricCollection):
+  """In-memory counter."""
+
+  def _create_counter(
+      self,
+      name: str,
+      description: str,
+      parameter_definitions: Dict[str, Type[Union[int, str, bool]]],
+      **kwargs
+  ) -> Counter:
+    return _InMemoryCounter(
+        self._namespace, name, description, parameter_definitions
+    )
+
+  def _create_scalar(
+      self,
+      name: str,
+      description: str,
+      parameter_definitions: Dict[str, Type[Union[int, str, bool]]],
+      *,
+      window_size: int = 1024 * 1024,
+      **kwargs
+  ) -> Scalar:
+    return _InMemoryScalar(
+        self._namespace, name, description, parameter_definitions,
+        window_size=window_size, **kwargs
+    )
+
+
+_METRIC_COLLECTION_CLS = InMemoryMetricCollection  # pylint: disable=invalid-name
+
+
+def metric_collection(namespace: str, **kwargs) -> MetricCollection:
+  """Creates a metric collection."""
+  return _METRIC_COLLECTION_CLS(namespace, **kwargs)
+
+
+def set_default_metric_collection_cls(cls: Type[MetricCollection]) -> None:
+  """Sets the default metric collection class."""
+  global _METRIC_COLLECTION_CLS
+  _METRIC_COLLECTION_CLS = cls
+
+
+def default_metric_collection_cls() -> Type[MetricCollection]:
+  """Returns the default metric collection class."""
+  return _METRIC_COLLECTION_CLS

pyglove/core/monitoring_test.py

@@ -0,0 +1,230 @@
+# Copyright 2025 The PyGlove Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+from pyglove.core import monitoring
+
+
+class MetricCollectionTest(unittest.TestCase):
+  """Tests for metric collection."""
+
+  def test_default_metric_collection_cls(self):
+    self.assertIs(
+        monitoring.default_metric_collection_cls(),
+        monitoring.InMemoryMetricCollection
+    )
+
+    class TestMetricCollection(monitoring.MetricCollection):
+      pass
+
+    monitoring.set_default_metric_collection_cls(TestMetricCollection)
+    self.assertIs(
+        monitoring.default_metric_collection_cls(),
+        TestMetricCollection
+    )
+    monitoring.set_default_metric_collection_cls(
+        monitoring.InMemoryMetricCollection
+    )
+    self.assertIs(
+        monitoring.default_metric_collection_cls(),
+        monitoring.InMemoryMetricCollection
+    )
+
+  def test_metric_collection(self):
+    collection = monitoring.metric_collection('/test')
+    self.assertEqual(collection.namespace, '/test')
+    self.assertIsInstance(collection, monitoring.InMemoryMetricCollection)
+
+  def test_creation_failures(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    counter = collection.get_counter('counter', 'counter description')
+    self.assertIsInstance(counter, monitoring.Counter)
+    with self.assertRaisesRegex(
+        ValueError, 'Metric .* already exists with a different type'
+    ):
+      collection.get_scalar('counter', 'counter description')
+
+    with self.assertRaisesRegex(
+        ValueError, 'Metric .* already exists with a different description'
+    ):
+      collection.get_counter('counter', 'different description')
+
+    with self.assertRaisesRegex(
+        ValueError,
+        'Metric .* already exists with different parameter definitions'
+    ):
+      collection.get_counter(
+          'counter', 'counter description', parameters={'field1': str}
+      )
+
+
+class InMemoryDistributionTest(unittest.TestCase):
+  """Tests for in memory distribution."""
+
+  def test_empty_distribution(self):
+    dist = monitoring._InMemoryDistribution()
+    self.assertEqual(dist.count, 0)
+    self.assertEqual(dist.sum, 0.0)
+    self.assertEqual(dist.mean, 0.0)
+    self.assertEqual(dist.stddev, 0.0)
+    self.assertEqual(dist.variance, 0.0)
+    self.assertEqual(dist.median, 0.0)
+    self.assertEqual(dist.percentile(50), 0.0)
+    self.assertEqual(dist.fraction_less_than(100), 0.0)
+
+  def test_add_value(self):
+    dist = monitoring._InMemoryDistribution()
+    dist.add(1)
+    dist.add(3)
+    dist.add(10)
+    dist.add(2)
+    self.assertEqual(dist.count, 4)
+    self.assertEqual(dist.sum, 16.0)
+    self.assertEqual(dist.mean, 4.0)
+    self.assertEqual(dist.stddev, 3.5355339059327378)
+    self.assertEqual(dist.variance, 12.5)
+    self.assertEqual(dist.median, 2.5)
+    self.assertEqual(dist.percentile(50), 2.5)
+    self.assertEqual(dist.percentile(10), 1.3)
+    self.assertEqual(dist.fraction_less_than(100), 1.0)
+    self.assertEqual(dist.fraction_less_than(1), 0.0)
+    self.assertEqual(dist.fraction_less_than(10), 0.75)
+
+  def test_add_value_no_numpy(self):
+    numpy = monitoring.numpy
+    monitoring.numpy = None
+    dist = monitoring._InMemoryDistribution()
+    dist.add(1)
+    dist.add(3)
+    dist.add(10)
+    dist.add(2)
+    self.assertEqual(dist.count, 4)
+    self.assertEqual(dist.sum, 16.0)
+    self.assertEqual(dist.mean, 4.0)
+    self.assertEqual(dist.stddev, 3.5355339059327378)
+    self.assertEqual(dist.variance, 12.5)
+    self.assertEqual(dist.median, 2.5)
+    self.assertEqual(dist.percentile(50), 2.5)
+    self.assertEqual(dist.percentile(10), 1.3)
+    self.assertEqual(dist.fraction_less_than(100), 1.0)
+    self.assertEqual(dist.fraction_less_than(1), 0.0)
+    self.assertEqual(dist.fraction_less_than(10), 0.75)
+    monitoring.numpy = numpy
+
+  def test_window_size(self):
+    dist = monitoring._InMemoryDistribution(window_size=3)
+    dist.add(1)
+    dist.add(3)
+    dist.add(10)
+    dist.add(2)
+    self.assertEqual(dist.count, 3)
+    self.assertEqual(dist.sum, 15.0)
+    self.assertEqual(dist.mean, 5.0)
+    self.assertEqual(dist.stddev, 3.5590260840104366)
+    self.assertEqual(dist.variance, 12.666666666666664)
+    self.assertEqual(dist.median, 3.0)
+    self.assertEqual(dist.percentile(50), 3.0)
+    self.assertEqual(dist.percentile(10), 2.2)
+    self.assertEqual(dist.fraction_less_than(100), 1.0)
+    self.assertEqual(dist.fraction_less_than(1), 0.0)
+    self.assertEqual(dist.fraction_less_than(10), 0.6666666666666666)
+
+
+class InMemoryCounterTest(unittest.TestCase):
+  """Tests for in memory counter."""
+
+  def test_counter_without_parameters(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    counter = collection.get_counter('counter', 'counter description')
+    self.assertEqual(counter.namespace, '/test')
+    self.assertEqual(counter.name, 'counter')
+    self.assertEqual(counter.description, 'counter description')
+    self.assertEqual(counter.parameter_definitions, {})
+    self.assertEqual(counter.full_name, '/test/counter')
+    self.assertEqual(counter.value(), 0)
+    self.assertEqual(counter.increment(), 1)
+    self.assertEqual(counter.value(), 1)
+    self.assertEqual(counter.increment(2), 3)
+    self.assertEqual(counter.value(), 3)
+    self.assertIs(collection.metrics()[0], counter)
+
+  def test_counter_with_parameters(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    counter = collection.get_counter(
+        'counter', 'counter description', {'field1': str}
+    )
+    self.assertEqual(counter.namespace, '/test')
+    self.assertEqual(counter.name, 'counter')
+    self.assertEqual(counter.description, 'counter description')
+    self.assertEqual(counter.parameter_definitions, {'field1': str})
+    self.assertEqual(counter.full_name, '/test/counter')
+    self.assertEqual(counter.value(field1='foo'), 0)
+    self.assertEqual(counter.increment(field1='foo'), 1)
+    self.assertEqual(counter.value(field1='bar'), 0)
+    self.assertEqual(counter.increment(field1='bar'), 1)
+    self.assertEqual(counter.increment(field1='foo', delta=2), 3)
+    self.assertEqual(counter.value(field1='foo'), 3)
+
+    with self.assertRaisesRegex(TypeError, '.* has type .* but expected type'):
+      counter.increment(field1=1)
+
+    with self.assertRaisesRegex(KeyError, '.* is required but not given'):
+      counter.increment()
+
+    with self.assertRaisesRegex(KeyError, '.* is not defined but provided'):
+      counter.increment(field1='foo', field2='a')
+
+
+class InMemoryScalarTest(unittest.TestCase):
+  """Tests for in memory scalar."""
+
+  def test_scalar_without_parameters(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    scalar = collection.get_scalar('scalar', 'scalar description')
+    self.assertEqual(scalar.namespace, '/test')
+    self.assertEqual(scalar.name, 'scalar')
+    self.assertEqual(scalar.description, 'scalar description')
+    self.assertEqual(scalar.parameter_definitions, {})
+    self.assertEqual(scalar.full_name, '/test/scalar')
+    dist = scalar.distribution()
+    self.assertEqual(dist.count, 0)
+    scalar.record(1)
+    scalar.record(2)
+    scalar.record(3)
+    scalar.distribution()
+    self.assertEqual(dist.count, 3)
+
+  def test_scalar_with_parameters(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    scalar = collection.get_scalar(
+        'scalar', 'scalar description', {'field1': str}
+    )
+    self.assertEqual(scalar.namespace, '/test')
+    self.assertEqual(scalar.name, 'scalar')
+    self.assertEqual(scalar.description, 'scalar description')
+    self.assertEqual(scalar.parameter_definitions, {'field1': str})
+    self.assertEqual(scalar.full_name, '/test/scalar')
+    dist = scalar.distribution(field1='foo')
+    self.assertEqual(dist.count, 0)
+    scalar.record(1, field1='foo')
+    scalar.record(2, field1='foo')
+    scalar.record(3, field1='bar')
+    dist = scalar.distribution(field1='foo')
+    self.assertEqual(dist.count, 2)
+    dist = scalar.distribution(field1='bar')
+    self.assertEqual(dist.count, 1)
+
+
+if __name__ == '__main__':
+  unittest.main()

{pyglove-0.5.0.dev202509260810.dist-info → pyglove-0.5.0.dev202509270808.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyglove
-Version: 0.5.0.dev202509260810
+Version: 0.5.0.dev202509270808
 Summary: PyGlove: A library for manipulating Python objects.
 Home-page: https://github.com/google/pyglove
 Author: PyGlove Authors

{pyglove-0.5.0.dev202509260810.dist-info → pyglove-0.5.0.dev202509270808.dist-info}/RECORD

@@ -1,7 +1,9 @@
 pyglove/__init__.py,sha256=LP1HNk_VVWMHaakX3HZ0NeZ2c4lq2uJaRbalvT8haOg,1352
-pyglove/core/__init__.py,sha256=H4Yah3bYPrEqvuwRvhbA1MbQn7W6l2j5mmXkeAUNI30,9700
+pyglove/core/__init__.py,sha256=WPTvhQXv63f4-AkYH__RwVKQyr8vHr5e3tGqT2OxRGM,9774
 pyglove/core/logging.py,sha256=zTNLGnWrl6kkjjEjTphQMeNf9FfqFtl1G9VCh2LhnHg,4614
 pyglove/core/logging_test.py,sha256=ioDbmf4S6xQXeyGWihvk6292wfYdldBw_TK1WXvIq5k,1648
+pyglove/core/monitoring.py,sha256=6QWbnCBC9HOc6_lnPmoDi-JTsusNwlXz4_LPnwWjjsw,15143
+pyglove/core/monitoring_test.py,sha256=47zjsNiYEMKOOdYpUue7_BPJYi1z9eJN_t6cw65TB-4,8558
 pyglove/core/coding/__init__.py,sha256=tuHIg19ZchtkOQbdFVTVLkUpBa5f1eo66XtnKw3lcIU,1645
 pyglove/core/coding/errors.py,sha256=aP3Y4amBzOKdlb5JnESJ3kdoijQXbiBiPDMeA88LNrk,3310
 pyglove/core/coding/errors_test.py,sha256=fwOR8vLiRvLadubsccyE19hLHj-kThlCQt88qmUYk9M,2311
@@ -216,8 +218,8 @@ pyglove/ext/scalars/randoms.py,sha256=LkMIIx7lOq_lvJvVS3BrgWGuWl7Pi91-lA-O8x_gZs
 pyglove/ext/scalars/randoms_test.py,sha256=nEhiqarg8l_5EOucp59CYrpO2uKxS1pe0hmBdZUzRNM,2000
 pyglove/ext/scalars/step_wise.py,sha256=IDw3tuTpv0KVh7AN44W43zqm1-E0HWPUlytWOQC9w3Y,3789
 pyglove/ext/scalars/step_wise_test.py,sha256=TL1vJ19xVx2t5HKuyIzGoogF7N3Rm8YhLE6JF7i0iy8,2540
-pyglove-0.5.0.dev202509260810.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-pyglove-0.5.0.dev202509260810.dist-info/METADATA,sha256=itSuEYa6B_MjlxjPTUoiFAEb_KcjWxrKbYNmgdG-_I4,7089
-pyglove-0.5.0.dev202509260810.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyglove-0.5.0.dev202509260810.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
-pyglove-0.5.0.dev202509260810.dist-info/RECORD,,
+pyglove-0.5.0.dev202509270808.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+pyglove-0.5.0.dev202509270808.dist-info/METADATA,sha256=V_xogke2HnisdqNjo0a6ZL4iQhbaJyeh1toYIFFDl5Y,7089
+pyglove-0.5.0.dev202509270808.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyglove-0.5.0.dev202509270808.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
+pyglove-0.5.0.dev202509270808.dist-info/RECORD,,