Up to [cvs.NetBSD.org] / pkgsrc / sysutils / py-structlog
Request diff between arbitrary revisions
Keyword substitution: kv
Default branch: MAIN
py-structlog: updated to 26.1.0 26.1.0 Removed - Python 3.8 and 3.9 support. Deprecated - Support for *better-exceptions* is deprecated and will be removed within a year. Use our Rich integration or copy-paste the [one line of code you need](https://github.com/hynek/structlog/blob/2c059a0dc029d9370e1e4a6e9683063205bbb68f/src/structlog/dev.py#L488-L498). Added - Python 3.15 support. - `structlog.dev.rich_monochrome_traceback` for Rich-based monochrome exception rendering and add support for it throughout `structlog.dev.ConsoleRenderer` when the user asks for no colors. - `structlog.BytesLogger` now has a `name` attribute which allows you to use it with the `structlog.stdlib.add_logger_name()` processor *without* using the standard library integration. - `structlog.processors.CallsiteParameterAdder` now supports `CallsiteParameter.QUAL_MODULE` that adds the qualified import name of the module of the callsite, or `__main__` if the module is the entry point. This is only available for *structlog*-originated events since the standard library has no equivalent (except for the convention of setting the logger's name to `__name__`). - `structlog.stdlib.BoundLogger` now has `is_enabled_for()` and `get_effective_level()` methods that are snake_case aliases for its `isEnabledFor()` and `getEffectiveLevel()` methods. This makes it more compatible with the native `structlog.typing.FilteringBoundLogger`, so you can swap configurations without changing your call sites. Changed - `structlog.dev.ConsoleRenderer` does not warn anymore when the `exception` key has a rendered value despite having a fancy formatter configured. Fixed - `structlog.BytesLogger`, `structlog.PrintLogger`, and `structlog.WriteLogger` now hold *weak* references to the files they use for output. This prevents their leakage in long-running processes that open many logfiles, such as task executors that create a per-task `BytesLogger` or `WriteLogger`. - `structlog.WriteLogger` is usable after unpickling. - `structlog.processors.CallsiteParameterAdder` now reports the calling thread's id and name for async log methods, instead of the thread from the executor pool that runs the underlying sync logger.
py-structlog: updated to 25.5.0
25.5.0
Deprecated
- `structlog.dev.ConsoleRenderer()`'s *pad_event* argument has been renamed to *pad_event_to* to differentiate it from the boolean *pad_level* argument.
*pad_event* is now deprecated.
Added
- Added `structlog.dev.ConsoleRenderer.get_active()` that returns the currently active `structlog.dev.ConsoleRenderer()`.
- `structlog.dev.ConsoleRenderer()` now supports setting the `exception_formatter` attribute.
You can now disable the pretty-printing of exceptions by setting it to `structlog.dev.plain_traceback`:
```python
cr = structlog.dev.ConsoleRenderer.get_active()
cr.exception_formatter = structlog.dev.plain_traceback
```
Same goes for *sort_keys*, *columns*, *colors*, *force_colors*, *level_styles*, *pad_event_to*, *event_key*, *timestamp_key*, and *repr_native_str*.
- Added `structlog.dev.ConsoleRenderer.get_default_column_styles()` for reuse the default column styles.
- `structlog.testing.capture_logs()` now optionally accepts *processors* to apply before capture.
- `structlog.dev.RichTracebackFormatter` now exposes the upstream *code_width* parameter.
Default *width* is now `None` for full terminal width.
Full terminal width is now handled by Rich itself, bringing support for reflow and `COLUMN` environment variable.
Passing `-1` for *width* is now deprecated and automatically replaced by `None`.
- Native loggers now allow the passing of a dictionary for dictionary-based interpolation `log.info("hello %(name)s!", {"name": "world"})`.
- On Python 3.11+, `structlog.processors.CallsiteParameterAdder` now supports `CallsiteParameter.QUAL_NAME` that adds the qualified name of the callsite, including scope and class names.
This is only available for *structlog*-originated events since the standard library has no equivalent.
- `structlog.stdlib.LoggerFactory` now supports the *stacklevel* parameter.
Changed
- `structlog.dev.rich_traceback()` now throws a more helpful error when Rich is missing.
Fixed
- `structlog.processors.MaybeTimeStamper` now respects the *key* argument when determining whether to overwrite the timestamp field.
- `structlog.tracebacks.extract()` no longer raises a `RecursionError` when the cause chain of an exception contains itself.
- Default config now respects `FORCE_COLOR` on Windows.
py-structlog: updated to 25.4.0 25.4.0 Added - Support for Python 3.14 and Python 3.13.4. Python 3.14 has an backwards-incompatible change to `logging.Logger.isEnabledFor()` (it now always returns False if a log entry is in flight) that has been backported to 3.13.4 (expected on 2025-06-03). It mainly affects `structlog.stdlib.filter_by_level()`. - `structlog.tracebacks` now handles [exception groups](https://docs.python.org/3/library/exceptions.html#exception-groups). `structlog.tracebacks.Stack` has two new fields, `is_group: bool` and `exceptions: list[Trace]`. This works similarly to what Rich v14.0.0 does. Fixed - `structlog.processors.ExceptionPrettyPrinter` now respects the *exception_formatter* arguments instead of always using the default formatter.
py-structlog: updated to 25.3.0 25.3.0 Fixed - `structlog.processors.TimeStamper` now again uses timestamps using UTC for custom format strings when `utc=True`.
py-structlog: updated to 25.2.0 25.2.0 Added - `structlog.tracebacks.Stack` now includes an `exc_notes` field reflecting the notes attached to the exception. Changed - `structlog.stdlib.BoundLogger`'s binding-related methods now also return `Self`. - `structlog.processors.TimeStamper` now produces internally timezone-aware `datetime` objects. Default output hasn't changed, but you can now use `%z` in your *fmt* string. Fixed - Expose `structlog.dev.RichTracebackFormatter` for imports. - Expose `structlog.processors.LogfmtRenderer` for imports.
py-structlog: updated to 25.1.0
25.1.0
Added
- Add `structlog.stdlib.render_to_log_args_and_kwargs` processor.
Same as `structlog.stdlib.render_to_log_kwargs`, but also allows to pass positional arguments to `logging`.
With it, you do not need to add `structlog.stdlib.PositionalArgumentsFormatter` processor to format positional arguments from *structlog* loggers.
- Native loggers now have `is_enabled_for()` and `get_effective_level()` methods that mirror the behavior of the standard library's `logging.Logger.isEnabledFor()` and `logging.Logger.getEffectiveLevel()`.
Changed
- `structlog.typing.BindableLogger` protocol now returns `Self` instead of `BindableLogger`.
This adds a dependency on [*typing-extensions*](https://pypi.org/project/typing-extensions/) for Pythons older than 3.11.
- `structlog.dev.ConsoleRenderer` will quote string value with special characters.
- `structlog.stdlib.recreate_defaults()` now also adds `structlog.stdlib.PositionalArgumentsFormatter`.
In default native mode, this is done by the loggers at the edge.
- `structlog.make_filtering_bound_logger()` now also accepts a string for *min_level*.
Fixed
- Fix handling calls to `{logger}.exception()` outside of exception blocks.
Depending on the structlog configuration,
this either resulted in an event dict key `exception: "MISSING"` or lead to an error.
Now, an invalid or missing `exc_info` will just be ignored.
This means, that calling `{logger}.exception()` outside of an exception block is basically the same as calling `{logger}.error()`.
- Instantiating `structlog.dev.ConsoleRenderer` does not mutate the passed *styles* dict anymore.
- The native `FilteringBoundLogger.fatal()` method now maps to the critical level, as it does in the standard library.
Note that the level is discouraged to use there, so we recommend to stick to `error()` or `critical()`.
- `structlog.tracebacks.ExceptionDictTransformer` now actually accepts `None` for `locals_max_length` and `locals_max_string`.
py-structlog: updated to 24.4.0 24.4.0 Changed No code changes since 24.3.0 24.3.0 Added - Restore feature parity between `structlog.traceback.ExceptionDictTransformer` and Rich's traceback extractor: - When displaying locals, use Rich for formatting if it is available. - When displaying locals, call `repr()` on strings, too (improves handling of `SecretStr` implementations). - Add `locals_max_length` config option - Add `locals_hide_sunder` config option - Add `locals_hide_dunder` config option - Add `suppress` config option
py-structlog: updated to 24.2.0 24.2.0 Added - It is now possible to disable log level-padding in `structlog.dev.LogLevelColumnFormatter` and `structlog.dev.ConsoleRenderer`. - The `structlog.processors.CallsiteParameterAdder` can now be pickled. - `structlog.processors.CallsiteParameterAdder` now also works with `structlog.stdlib.BoundLogger`'s non-standard async methods (`ainfo()`, and so forth) Changed - `structlog.processors.LogfmtRenderer` now escapes newlines. - `structlog.processors.LogfmtRenderer` now escapes backslashes and double quotes. - `structlog.processors.CallsiteParameterAdder` has been optimized to be about 2x faster. Fixed - `structlog.stdlib.render_to_log_kwargs` now correctly passes stacklevel as a kwarg to stdlib logging.
py-structlog: updated to 24.1.0 24.1.0 Fixed - The lazy logger proxy returned by `structlog.get_logger()` now returns its initial values when asked for context. When asked for context before binding for the first time, it returned an empty dictionary in 23.3.0. - The displayed level name when using `structlog.stdlib.BoundLogger.exception()` is `"error"` instead of `"exception"`. Fixes regression in 23.3.0. - Don't ignore the `width` argument of `RichTracebackFormatter`. 23.3.0 Added - The colorful development logger is now even more configurable! Choose freely your colors and the order of the key-value pairs! Implement your own formatters for certain keys! Implementing the output on top of the new columns API has changed the default very slightly, but shouldn't be noticeable. - Async log methods (those starting with an `a`) now also support the collection of callsite information using `structlog.processors.CallsiteParameterAdder`. Changed - `structlog.stdlib.recreate_defaults()` now also adds `structlog.stdlib.add_logger_name` to the processors. Check out the [updated screenshot](https://raw.githubusercontent.com/hynek/structlog/main/docs/_static/console_renderer.png)! Fixed - The return value from `get_logger()` (a `BoundLoggerLazyProxy`) now passes `isinstance`-checks against `structlog.typing.BindableLogger` on Python 3.12. - `structlog.threadlocal.tmp_bind()` now also works with `BoundLoggerLazyProxy` (in other words: before anything is bound to a bound logger). - stdlib: `ProcessorFormatter` can now be told to not render the log record message using `getMessage` and just `str(record.msg)` instead. - stdlib: `structlog.stdlib.BoundLogger.exception()`'s handling of`LogRecord.exc_info` is now set consistent with `logging`.
py-structlog: updated to 21.5.0 21.5.0 (2021-12-16) ------------------- Changes: - Added the ``structlog.processors.LogfmtRenderer`` processor to render log lines using the `logfmt <https://brandur.org/logfmt>`_ format. - Added the ``structlog.stdlib.ExtraAdder`` processor that adds extra attributes of ``logging.LogRecord`` objects to the event dictionary. This processor can be used for adding data passed in the ``extra`` parameter of the ``logging`` module's log methods to the event dictionary. - Added the ``structlog.processor.CallsiteParameterAdder`` processor that adds parameters of the callsite that an event dictionary orginated from to the event dictionary. This processor can be used to enrich events dictionaries with information such as the function name, line number and filename that an event dictionary orignated from. 21.4.0 (2021-11-25) ------------------- Changes: - Fixed import when running in optimized mode (``PYTHONOPTIMIZE=2`` or ``python -OO``). - Added the ``structlog.threadlocal.bound_threadlocal`` and ``structlog.contextvars.bound_contextvars`` decorator/context managers to temporarily bind key/value pairs to a thread-local and context-local context. 21.3.0 (2021-11-20) ------------------- Backward-incompatible changes: - ``structlog`` switched its packaging to `flit <https://flit.readthedocs.io/>`_. Users shouldn't notice a difference, but (re-)packagers might. Changes: - ``structlog.dev.ConsoleRenderer`` now has ``sort_keys`` boolean parameter that allows to disable the sorting of keys on output. - ``structlog.processors.TimeStamper`` now works well with FreezeGun even when it gets applied before the loggers are configured. - ``structlog.stdlib.AsyncBoundLogger`` now determines the running loop when logging, not on instantiation. That has a minor performance impact, but makes it more robust when loops change (e.g. ``aiohttp.web.run_app()``), or you want to use ``sync_bl`` *before* a loop has started. - ``structlog.stdlib.ProcessorFormatter`` now has a *processors* argument that allows to define a processor chain to run over *all* log entries. Before running the chain, two additional keys are added to the event dictionary: ``_record`` and ``_from_structlog``. With them it's possible to extract information from ``logging.LogRecord``\s and differentiate between ``structlog`` and ``logging`` log entries while processing them. The old *processor* (singular) parameter is now deprecated, but no plans exist to remove it.
py-structlog: updated to 21.2.0 21.2.0 (2021-10-12) ------------------- Backward-incompatible changes: - To implement pretty exceptions (see Changes below), ``structlog.dev.ConsoleRenderer`` now formats exceptions itself. Make sure to remove ``format_exc_info`` from your processor chain if you configure ``structlog`` manually. This change is not really breaking, because the old use-case will keep working as before. However if you pass ``pretty_exceptions=True`` (which is the default if either ``rich`` or ``better-exceptions`` is installed), a warning will be raised and the exception will be renderered without prettyfication. Changes: - ``structlog`` is now importable if ``sys.stdout`` is ``None`` (e.g. when running using ``pythonw``). - ``structlog.threadlocal.get_threadlocal()`` and ``structlog.contextvars.get_contextvars()`` can now be used to get a copy of the current thread-local/context-local context that has been bound using ``structlog.threadlocal.bind_threadlocal()`` and ``structlog.contextvars.bind_contextvars()``. - ``structlog.threadlocal.get_merged_threadlocal(bl)`` and ``structlog.contextvars.get_merged_contextvars(bl)`` do the same, but also merge the context from a bound logger *bl*. Same pull requests as previous change. - ``structlog.contextvars.bind_contextvars()`` now returns a mapping of keys to ``contextvars.Token``\s, allowing you to reset values using the new ``structlog.contextvars.reset_contextvars()``. - Exception rendering in ``structlog.dev.ConsoleLogger`` is now configurable using the ``exception_formatter`` setting. If either the `rich <https://github.com/willmcgugan/rich>`_ or the `better-exceptions <https://github.com/qix-/better-exceptions>`_ package is present, ``structlog`` will use them for pretty-printing tracebacks. ``rich`` takes precedence over ``better-exceptions`` if both are present. This only works if ``format_exc_info`` is **absent** in the processor chain. - All use of ``colorama`` on non-Windows systems has been excised. Thus, colors are now enabled by default in ``structlog.dev.ConsoleRenderer`` on non-Windows systems. You can keep using ``colorama`` to customize colors, of course. - The final processor can now return a ``bytearray`` (additionally to ``str`` and ``bytes``).
sysutils: Replace RMD160 checksums with BLAKE2s checksums All checksums have been double-checked against existing RMD160 and SHA512 hashes
sysutils: Remove SHA1 hashes for distfiles
py-structlog: updated to 21.1.0 21.1.0 (2021-02-18) Changes: - ``structlog.threadlocal.wrap_dict()`` now has a correct type annotation. - Fix isolation in ``structlog.contextvars``. - The default configuration and loggers are pickleable again. - ``structlog.dev.ConsoleRenderer`` will now look for a ``logger_name`` key if no ``logger`` key is set.
py-structlog: updated to 20.2.0 20.2.0 Backward-incompatible changes: - Python 2.7 and 3.5 aren't supported anymore. The package meta data should ensure that you keep getting 20.1.0 on those versions. - ``structlog`` is now fully type-annotated. This won't break your applications, but if you use Mypy, it will most likely break your CI. Check out the new chapter on typing for details. Deprecations: - Accessing the ``_context`` attribute of a bound logger is now deprecated. Please use the new ``structlog.get_context()``. Changes: - ``structlog`` has now type hints for all of its APIs! Since ``structlog`` is highly dynamic and configurable, this led to a few concessions like a specialized ``structlog.stdlib.get_logger()`` whose only difference to ``structlog.get_logger()`` is that it has the correct type hints. We consider them provisional for the time being – i.e. the backward compatibility does not apply to them in its full strength until we feel we got it right. Please feel free to provide feedback! - Added ``structlog.make_filtering_logger`` that can be used like ``configure(wrapper_class=make_filtering_bound_logger(logging.INFO))``. It creates a highly optimized bound logger whose inactive methods only consist of a ``return None``. This is now also the default logger. - As a complement, ``structlog.stdlib.add_log_level()`` can now additionally be imported as ``structlog.processors.add_log_level`` since it just adds the method name to the event dict. - ``structlog.processors.add_log_level()`` is now part of the default configuration. - ``structlog.stdlib.ProcessorFormatter`` no longer uses exceptions for control flow, allowing ``foreign_pre_chain`` processors to use ``sys.exc_info()`` to access the real exception. - Added ``structlog.BytesLogger`` to avoid unnecessary encoding round trips. Concretely this is useful with *orjson* which returns bytes. - The final processor now also may return bytes that are passed untouched to the wrapped logger. - ``structlog.get_context()`` allows you to retrieve the original context of a bound logger. - ``structlog.PrintLogger`` now supports ``copy.deepcopy()``. - Added ``structlog.testing.CapturingLogger`` for more unit testing goodness. - Added ``structlog.stdlib.AsyncBoundLogger`` that executes logging calls in a thread executor and therefore doesn't block.
py-structlog: updated to 20.1.0 20.1.0 Deprecations: - This is the last version to support Python 2.7 (including PyPy) and 3.5. All following versions will only support Python 3.6 or later. Changes: - Added a new module ``structlog.contextvars`` that allows to have a global but context-local ``structlog`` context the same way as with ``structlog.threadlocal`` since 19.2.0. - Added a new module ``structlog.testing`` for first class testing support. The first entry is the context manager ``capture_logs()`` that allows to make assertions about structured log calls. - Added ``structlog.threadlocal.unbind_threadlocal()``. - The logger created by ``structlog.get_logger()`` is not detected as an abstract method anymore, when attached to an abstract base class. - ``colorama`` isn't initialized lazily on Windows anymore because it breaks rendering.
py-structlog: updated to 19.2.0
19.2.0:
Backward-incompatible changes:
- Python 3.4 is not supported anymore.
It has been unsupported by the Python core team for a while now and its PyPI downloads are negligible.
It's very unlikely that ``structlog`` will break under 3.4 anytime soon, but we don't test it anymore.
Changes:
- Full Python 3.8 support for ``structlog.stdlib``.
- Added more pass-through properties to ``structlog.stdlib.BoundLogger``.
To makes it easier to use it as a drop-in replacement for ``logging.Logger``.
- ``structlog.stdlib.ProcessorFormatter`` now takes a logger object as an optional keyword argument.
This makes ``ProcessorFormatter`` work properly with ``stuctlog.stdlib.filter_by_level()``.
- ``structlog.dev.ConsoleRenderer`` now uses no colors by default, if ``colorama`` is not available.
- ``structlog.dev.ConsoleRenderer`` now initializes ``colorama`` lazily, to prevent accidental side-effects just by importing ``structlog``.
- Added new processor ``structlog.dev.set_exc_info()`` that will set ``exc_info=True`` if the method's name is `exception` and ``exc_info`` isn't set at all.
*This is only necessary when the standard library integration is not used*.
It fixes the problem that in the default configuration, ``structlog.get_logger().exception("hi")`` in an ``except`` block would not print the exception without passing ``exc_info=True`` to it explicitly.
- A best effort has been made to make as much of ``structlog`` pickleable as possible to make it friendlier with ``multiprocessing`` and similar libraries.
Some classes can only be pickled on Python 3 or using the `dill <https://pypi.org/project/dill/>`_ library though and that is very unlikely to change.
So far, the configuration proxy, ``structlog.processor.TimeStamper``, ``structlog.BoundLogger``, ``structlog.PrintLogger`` and ``structlog.dev.ConsoleRenderer`` have been made pickelable.
- Added a new thread-local API that allows binding values to a thread-local context explicitly without affecting the default behavior of ``bind()``.
- Added ``pass_foreign_args`` argument to ``structlog.stdlib.ProcessorFormatter``.
It allows to pass a foreign log record's ``args`` attribute to the event dictionary under the ``positional_args`` key.
- ``structlog.dev.ConsoleRenderer`` now calls ``str()`` on the event value.
py-structlog: updated to 19.1.0 19.1.0: Backward-incompatible changes: - As announced in 18.1.0, pip install -e .[dev] now installs all development dependencies. Sorry for the inconveniences this undoubtedly will cause! Changes: - structlog.ReturnLogger and structlog.PrintLogger now have a fatal() log method. - Under certain (rather unclear) circumstances, the frame extraction could throw an SystemError: error return without exception set. A workaround has been added. - structlog now tolerates passing through dict\ s to stdlib logging.
py-structlog: updated to 18.2.0 18.2.0: Changes: - Added structlog.stdlib.add_log_level_number() processor that adds the level *number* to the event dictionary. Can be used to simplify log filtering. - structlog.processors.JSONRenderer now allows for overwriting the *default* argument of its serializer. - Added try_unbind() that works like unbind() but doesn't raise a KeyError if one of the keys is missing.
py-structlog: updated to 18.1.0 18.1.0: Deprecations: - The meaning of the structlog[dev] installation target will change from "colorful output" to "dependencies to develop structlog" in 19.1.0. The main reason behind this decision is that it's impossible to have a structlog in your normal dependencies and additionally a structlog[dev] for developement (pip will report an error). Changes: - Empty strings are valid events now. - Do not encapsulate Twisted failures twice with newer versions of Twisted. - structlog.dev.ConsoleRenderer now accepts a *force_colors* argument to output colored logs even if the destination is not a tty. Use this option if your logs are stored in files that are intended to be streamed to the console. - structlog.dev.ConsoleRenderer now accepts a *level_styles* argument for overriding the colors for individual levels, as well as to add new levels. - structlog.stdlib.BoundLogger.exception() now uses the exc_info argument if it has been passed instead of setting it unconditionally to True. - Default configuration now uses plain dict\ s on Python 3.6+ and PyPy since they are ordered by default. - Added structlog.is_configured() to check whether or not structlog has been configured. - Added structlog.get_config() to introspect current configuration.
py-structlog: update to 17.2.0 17.2.0: - ``structlog.stdlib.ProcessorFormatter`` now accepts *keep_exc_info* and *keep_stack_info* arguments to control what to do with this information on log records. Most likely you want them both to be ``False`` therefore it's the default. - ``structlog.stdlib.add_logger_name()`` now works in ``structlog.stdlib.ProcessorFormatter``'s ``foreign_pre_chain``. - Clear log record args in ``structlog.stdlib.ProcessorFormatter`` after rendering. This fix is for you if you tried to use it and got ``TypeError: not all arguments converted during string formatting`` exceptions.
Add SHA512 digests for distfiles for sysutils category Problems found with existing digests: Package memconf distfile memconf-2.16/memconf.gz b6f4b736cac388dddc5070670351cf7262aba048 [recorded] 95748686a5ad8144232f4d4abc9bf052721a196f [calculated] Problems found locating distfiles: Package dc-tools: missing distfile dc-tools/abs0-dc-burn-netbsd-1.5-0-gae55ec9 Package ipw-firmware: missing distfile ipw2100-fw-1.2.tgz Package iwi-firmware: missing distfile ipw2200-fw-2.3.tgz Package nvnet: missing distfile nvnet-netbsd-src-20050620.tgz Package syslog-ng: missing distfile syslog-ng-3.7.2.tar.gz Otherwise, existing SHA1 digests verified and found to be the same on the machine holding the existing distfiles (morden). All existing SHA1 digests retained for now as an audit trail.
========= Changelog ========= - :release:`15.1.0 <2015-02-24>` - :bug:`- major` Tolerate frames without a ``__name__``. - :release:`15.0.0 <2015-01-23>` - :feature:`44` Add :func:`structlog.stdlib.add_log_level` and :func:`structlog.stdlib.add_logger_name` processors. - :feature:`42` Add :func:`structlog.stdlib.BoundLogger.log`. - :feature:`19` Pass positional arguments to stdlib wrapped loggers that use string formatting. - :feature:`28` structlog is now dually licensed under the `Apache License, Version 2 <http://choosealicense.com/licenses/apache-2.0/>`_ and the `MIT <http://choosealicense.com/licenses/mit/>`_ license. Therefore it is now legal to use structlog with `GPLv2 <http://choosealicense.com/licenses/gpl-2.0/>`_-licensed projects. - :feature:`22` Add :func:`structlog.stdlib.BoundLogger.exception`.
Import py27-structlog-0.4.2 as sysutils/py-structlog. structlog makes structured logging in Python easy by augmenting your existing logger. It allows you to split your log entries up into key/value pairs and build them incrementally without annoying boilerplate code.