lenskit.pipeline ================ .. py:module:: lenskit.pipeline .. autoapi-nested-parse:: LensKit pipeline abstraction. Submodules ---------- .. autoapisummary:: lenskit.pipeline.components lenskit.pipeline.config lenskit.pipeline.nodes .. toctree:: :hidden: :maxdepth: 1 /api/lenskit/pipeline/components/index /api/lenskit/pipeline/config/index /api/lenskit/pipeline/nodes/index Attributes ---------- .. autoapisummary:: lenskit.pipeline.CloneMethod Classes ------- .. autoapisummary:: lenskit.pipeline.PipelineBuilder lenskit.pipeline.PipelineCache lenskit.pipeline.RecPipelineBuilder lenskit.pipeline.ComponentInputHook lenskit.pipeline.Pipeline lenskit.pipeline.PipelineProfiler lenskit.pipeline.ProfileSink lenskit.pipeline.PipelineState Functions --------- .. autoapisummary:: lenskit.pipeline.predict_pipeline lenskit.pipeline.topn_pipeline Package Contents ---------------- .. py:class:: PipelineBuilder(name = None, version = None) :canonical: lenskit.pipeline._builder.PipelineBuilder Builder for LensKit recommendation pipelines. :ref:`Pipelines ` are the core abstraction for using LensKit models and other components to produce recommendations in a useful way. They allow you to wire together components in (mostly) abitrary graphs, train them on data, and serialize the resulting pipelines to disk for use elsewhere. The builder configures and builds pipelines that can then be run. If you have a scoring model and just want to generate recommenations with a default setup and minimal configuration, see :func:`~lenskit.pipeline.topn_pipeline` or :class:`~lenskit.pipeline.RecPipelineBuilder`. :param name: A name for the pipeline. :param version: A numeric version for the pipeline. :Stability: Caller .. py:attribute:: name :type: str | None :value: None The pipeline name. .. py:attribute:: version :type: str | None :value: None The pipeline version string. .. py:method:: from_pipeline(pipeline) :classmethod: Create a builder initialized with a pipeline's internal state. See :meth:`Pipeline.modify` for details — that is the main entry point, and this method exists to be the implementation of that method. .. py:method:: meta(*, include_hash = True) Get the metadata (name, version, hash, etc.) for this pipeline without returning the whole config. :param include_hash: Whether to include a configuration hash in the metadata. .. py:method:: nodes() Get the nodes in the pipeline graph. .. py:method:: node(node: str, *, missing: Literal['error'] = 'error') -> lenskit.pipeline.nodes.Node[object] node(node: str, *, missing: Literal['none'] | None) -> lenskit.pipeline.nodes.Node[object] | None node(node: lenskit.pipeline.nodes.Node[T]) -> lenskit.pipeline.nodes.Node[T] Get the pipeline node with the specified name. If passed a node, it returns the node or fails if the node is not a member of the pipeline. :param node: The name of the pipeline node to look up, or a node to check for membership. :returns: The pipeline node, if it exists. :raises KeyError: The specified node does not exist. .. py:property:: default_node :type: lenskit.pipeline.nodes.Node[Any] | None Get the default node for this pipeline. .. py:method:: create_input[T](name, *types) Create an input node for the pipeline. Pipelines expect their inputs to be provided when they are run. :param name: The name of the input. The name must be unique in the pipeline (among both components and inputs). :param types: The allowable types of the input; input data can be of any specified type. If ``None`` is among the allowed types, the input can be omitted. :returns: A pipeline node representing this input. :raises ValueError: a node with the specified ``name`` already exists. .. py:method:: literal[T](value, *, name = None) Create a literal node (a node with a fixed value). .. note:: Literal nodes cannot be serialized witih :meth:`get_config` or :meth:`save_config`. .. py:method:: default_connection(name, node) Set the default wiring for a component input. Components that declare an input parameter with the specified ``name`` but no configured input will be wired to this node. This is intended to be used for things like wiring up `user` parameters to semi-automatically receive the target user's identity and history. .. important:: Defaults are a feature of the builder only, and are resolved in :meth:`build`. They are not included in serialized configuration or resulting pipeline. :param name: The name of the parameter to set a default for. :param node: The node or literal value to wire to this parameter. .. py:method:: default_component(node) Set the default node for the pipeline. If :meth:`Pipeline.run` is called without a node, then it will run this node (and all of its dependencies). .. py:method:: remove_alias(alias, *, exist_ok = False) Remove an alias from the builder. .. py:method:: alias(alias, node, *, replace = False) Create an alias for a node. After aliasing, the node can be retrieved from :meth:`node` using either its original name or its alias. :param alias: The alias to add to the node. :param node: The node (or node name) to alias. :param replace: If ``True``, replace the alias if one already exists. :raises ValueError: if the alias is already used as an alias or node name. .. py:method:: add_component[CFG, T](name: str, cls: lenskit.pipeline.components.ComponentConstructor[CFG, T], config: CFG = None, /, **inputs: lenskit.pipeline.nodes.Node[Any]) -> lenskit.pipeline.nodes.Node[T] add_component(name: str, instance: lenskit.pipeline.components.Component[T] | lenskit.pipeline.components.PipelineFunction[T], /, **inputs: lenskit.pipeline.nodes.Node[Any] | object) -> lenskit.pipeline.nodes.Node[T] Add a component and connect it into the graph. :param name: The name of the component in the pipeline. The name must be unique in the pipeline (among both components and inputs). :param cls: A component class. :param config: The configuration object for the component class. :param instance: A raw function or pre-instantiated component. :param inputs: The component's input wiring. See :ref:`pipeline-connections` for details. :returns: The node representing this component in the pipeline. .. py:method:: replace_component[CFG, T](name: str | lenskit.pipeline.nodes.Node[T], cls: lenskit.pipeline.components.ComponentConstructor[CFG, T], config: CFG = None, /, **inputs: lenskit.pipeline.nodes.Node[Any]) -> lenskit.pipeline.nodes.Node[T] replace_component(name: str | lenskit.pipeline.nodes.Node[T], instance: lenskit.pipeline.components.Component[T] | lenskit.pipeline.components.PipelineFunction[T], /, **inputs: lenskit.pipeline.nodes.Node[Any] | object) -> lenskit.pipeline.nodes.Node[T] Replace a component in the graph. The new component must have a type that is compatible with the old component. Both input and output connections are retained, except for those overridden with with keyword arguments. :param name: The name or node to replace. :param comp: The component or constructor to use instead of the current node's component. :param config: A configuration for the component (if passed as a class or constructor). :param inputs: New input wiring(s) for the new component. .. py:method:: connect(obj, **inputs) Provide additional input connections for a component that has already been added. See :ref:`pipeline-connections` for details. :param obj: The name or node of the component to wire. :param inputs: The component's input wiring. For each keyword argument in the component's function signature, that argument can be provided here with an input that the pipeline will provide to that argument of the component when the pipeline is run. .. py:method:: clear_inputs(node) Remove input wirings for a node. :param node: The node whose input wiring should be removed. .. py:method:: add_run_hook(name, hook, *, priority = 1) Add a hook to be called when the pipeline is run (see :ref:`pipeline-hooks`). :param name: The name of the hook to add a handler for. :param hook: The hook function to run. :param priority: The hook priority. Hooks are run in ascending priority, and hooks with the same priority are run in the order they are added. LensKit's built-in hooks run at priority 0. .. py:method:: validate() Check the built pipeline for errors. .. py:method:: clone() Clone the pipeline builder. The resulting builder starts as a copy of this builder, and any subsequent modifications only the copy to which they are applied. .. py:method:: build_config(*, include_hash = True) Get this pipeline's configuration for serialization. The configuration consists of all inputs and components along with their configurations and input connections. It can be serialized to disk (in JSON, YAML, or a similar format) to save a pipeline. The configuration does **not** include any trained parameter values, although the configuration may include things such as paths to checkpoints to load such parameters, depending on the design of the components in the pipeline. .. note:: Literal nodes (from :meth:`literal`, or literal values wired to inputs) cannot be serialized, and this method will fail if they are present in the pipeline. .. py:method:: config_hash() Get a hash of the pipeline's configuration to uniquely identify it for logging, version control, or other purposes. The hash format and algorithm are not guaranteed, but hashes are stable within a LensKit version. For the same version of LensKit and component code, the same configuration will produce the same hash, so long as there are no literal nodes. Literal nodes will *usually* hash consistently, but since literals other than basic JSON values are hashed by pickling, hash stability depends on the stability of the pickle bytestream. In LensKit 2025.1, the configuration hash is computed by computing the JSON serialization of the pipeline configuration *without* a hash and returning the hex-encoded SHA256 hash of that configuration. .. py:method:: load_config(cfg_file) :classmethod: Load a pipeline from a saved configuration file. :param cfg_file: The path to a TOML, YAML, or JSON file containing the pipeline configuration. :returns: The consructed pipeline. .. seealso:: :meth:`from_config` for the actual pipeline instantiation logic. .. py:method:: from_config(config, *, file_path = None) :classmethod: Reconstruct a pipeline builder from a serialized configuration. :param config: The configuration object, as loaded from JSON, TOML, YAML, or similar. Will be validated into a :class:`PipelineConfig`. :returns: The configured (but not trained) pipeline. :raises PipelineError: If there is a configuration error reconstructing the pipeline. :Warns: **PipelineWarning** -- If the configuration is funny but usable; for example, the configuration includes a hash but the constructed pipeline does not have a matching hash. .. py:method:: apply_config(config, *, extend = False, check_hash = False) Apply a configuration to this builder. :param config: The pipeline configuration to apply. :param extend: Whether the configuration should extend the current pipeline, or fail when there are conflicting definitions. .. py:method:: use_first_of[T](name, primary, fallback) Ergonomic method to create a new node that returns the result of its ``input`` if it is provided and not ``None``, and otherwise returns the result of ``fallback``. This method is used for things like filling in optional pipeline inputs. For example, if you want the pipeline to take candidate items through an ``items`` input, but look them up from the user's history and the training data if ``items`` is not supplied, you would do: .. code:: python pipe = Pipeline() # allow candidate items to be optionally specified items = pipe.create_input('items', list[EntityId], None) # find candidates from the training data (optional) lookup_candidates = pipe.add_component( 'select-candidates', TrainingItemsCandidateSelector(), user=history, ) # if the client provided items as a pipeline input, use those; otherwise # use the candidate selector we just configured. candidates = pipe.use_first_of('candidates', items, lookup_candidates) .. note:: This method does not distinguish between an input being unspecified and explicitly specified as ``None``. .. note:: This method does *not* implement item-level fallbacks, only fallbacks at the level of entire results. For item-level score fallbacks, see :class:`~lenskit.basic.FallbackScorer`. .. note:: If one of the fallback elements is a component ``A`` that depends on another component or input ``B``, and ``B`` is missing or returns ``None`` such that ``A`` would usually fail, then ``A`` will be skipped and the fallback will move on to the next node. This works with arbitrarily-deep transitive chains. :param name: The name of the node. :param primary: The node to use as the primary input, if it is available. :param fallback: The node to use if the primary input does not provide a value. .. py:method:: build(cache = None) Build the pipeline. :param cache: The pipeline cache to use. .. py:class:: PipelineCache :canonical: lenskit.pipeline._cache.PipelineCache A cache to share components between pipelines. This cache can be used by :class:`~lenskit.pipeline.PipelineBuilder` to cache pipeline component instances between multiple pipelines using the same components with the same configuration. .. py:method:: get_cached(ctor, config) .. py:method:: cache(ctor, config, instance) .. py:method:: get_instance(ctor, config) Get a component instance from the cache, creating if it necessry. .. py:class:: RecPipelineBuilder :canonical: lenskit.pipeline._common.RecPipelineBuilder Builder to help assemble common pipeline patterns. This is a convenience class; you can always directly assemble a :class:`Pipeline` if this class's behavior is inadquate. :Stability: Caller .. py:attribute:: is_predictor :type: bool :value: False .. py:method:: scorer(score, config = None) Specify the scoring model. .. py:method:: ranker(rank = None, config = None, *, n = None) Specify the ranker to use. If ``None``, sets up a :class:`TopNRanker` with ``n=n``. .. py:method:: candidate_selector(sel, config = None) Specify the candidate selector component. The component should accept a query as its input and return an item list. .. py:method:: predicts_ratings(*, transform = None, fallback = None) Specify that this pipeline will predict ratings, optionally providing a rating transformer and fallback scorer for the rating predictions. :param transform: A component to transform scores prior to returning them. If supplied, it will be applied to both primary scores and fallback scores. :param fallback: A fallback scorer to use when the primary scorer cannot score an item. The fallback should accept ``query`` and ``items`` inputs, and return an item list. .. py:method:: build(name = None) Build the specified pipeline. .. py:method:: reranker(reranker, config = None) Specify a reranker to add to the pipeline. :param reranker: The reranker to use in the pipeline. :param config: Configuration parameters to initialize the reranker if a reranker is specified. .. py:function:: predict_pipeline(scorer, *, fallback = True, name = None) Create a pipeline that predicts ratings, but does **not** include any ranking capabilities. Mostly userful for testing and historical purposes. The resulting pipeline **must** be called with an item list. :Stability: Caller :param scorer: The scorer to use in the pipeline (it will added with the component name ``scorer``, see :ref:`pipeline-names`). :param fallback: Whether to use a fallback predictor when the scorer cannot score. When configured, the `scorer` node is the scorer, and the `rating-predictor` node applies the fallback. :param name: The pipeline name. .. py:function:: topn_pipeline(scorer, config = None, *, predicts_ratings = False, n = None, name = None) Create a pipeline that produces top-N recommendations using a scoring model. :Stability: Caller :param scorer: The scorer to use in the pipeline (it will added with the component name ``scorer``, see :ref:`pipeline-names`). :param predicts_ratings: If ``True``, make set up to predict ratings (``rating-predictor``), using ``scorer`` with a fallback of :class:`BiasScorer`; if ``"raw"``, use ``scorer`` directly with no fallback. :param n: The recommendation list length to configure in the pipeline. :param name: The pipeline name. .. py:class:: ComponentInputHook :canonical: lenskit.pipeline._hooks.ComponentInputHook Bases: :py:obj:`Protocol` Inspect or process data as it passes to a component's input. As with all :ref:`pipeline-hooks`, an input hook is a callable that is run at the appropriate stage of the input. Component input hooks are installed under the name ``component-input``. :Stability: Experimental .. py:method:: __call__(node, input, value, **context) Inspect or process the component input data. :param node: The component node being invoked. :param input_name: The name of the component's input that will receive the data. :param input_type: The type of data the component expects for this input, if one was specified in the component definition. :param value: The data value to be supplied. This is declared :class:`object`, because its type is not known or guaranteed in the genral case. :param context: Additional context variables, mostly for the use of internal hooks. :returns: The value to pass to the component. For inspection-only hooks, this will just be ``value``; hooks can also substitute alternative values depending on application needs. .. py:type:: CloneMethod :canonical: Literal['config', 'pipeline-config'] .. py:class:: Pipeline(config, nodes, *, run_hooks) :canonical: lenskit.pipeline._impl.Pipeline LensKit recommendation pipeline. This is the core abstraction for using LensKit models and other components to produce recommendations in a useful way. It allows you to wire together components in (mostly) abitrary graphs, train them on data, and serialize pipelines to disk for use elsewhere. Pipelines should not be directly instantiated; they must be built with a :class:`~lenskit.pipeline.PipelineBuilder` class, or loaded from a configuration with :meth:`from_config`. If you have a scoring model and just want to generate recommenations with a default setup and minimal configuration, see :func:`~lenskit.pipeline.topn_pipeline` or :class:`~lenskit.pipeline.RecPipelineBuilder`. Pipelines are also :class:`~lenskit.training.Trainable`, and train all trainable components. :Stability: Caller .. py:property:: config :type: lenskit.pipeline.config.PipelineConfig Get the pipline configuration. .. important:: Do not modify the configuration returned, or it will become out-of-sync with the pipeline and likely not behave correctly. .. py:property:: name :type: str | None Get the pipeline name (if configured). .. py:property:: version :type: str | None Get the pipeline version (if configured). .. py:method:: meta() Get the metadata (name, version, hash, etc.) for this pipeline without returning the whole config. .. py:method:: nodes() Get the nodes in the pipeline graph. .. py:method:: node(node: str, *, missing: Literal['error'] = 'error') -> lenskit.pipeline.nodes.Node[object] node(node: str, *, missing: Literal['none'] | None) -> lenskit.pipeline.nodes.Node[object] | None node(node: lenskit.pipeline.nodes.Node[T]) -> lenskit.pipeline.nodes.Node[T] Get the pipeline node with the specified name. If passed a node, it returns the node or fails if the node is not a member of the pipeline. :param node: The name of the pipeline node to look up, or a node to check for membership. :returns: The pipeline node, if it exists. :raises KeyError: The specified node does not exist. .. py:property:: default_node :type: lenskit.pipeline.nodes.Node[Any] | None Get the default node for this pipeline. .. py:method:: component_names() Get the component names (in topological order). .. py:method:: node_input_connections(node) Get the input wirings for a node. .. py:method:: component(node) Get the component at a particular node, if any. .. py:method:: clone() Clone the pipeline, **without** its trained parameters. :returns: A new pipeline with the same components and wiring, but fresh instances created by round-tripping the configuration. .. py:property:: config_hash :type: str Get a hash of the pipeline's configuration to uniquely identify it for logging, version control, or other purposes. The hash format and algorithm are not guaranteed, but is stable within a LensKit version. For the same version of LensKit and component code, the same configuration will produce the same hash, so long as there are no literal nodes. Literal nodes will *usually* hash consistently, but since literals other than basic JSON values are hashed by pickling, hash stability depends on the stability of the pickle bytestream. In LensKit 2025.1, the configuration hash is computed by computing the JSON serialization of the pipeline configuration *without* a hash and returning the hex-encoded SHA256 hash of that configuration. .. py:method:: from_config(config, file_path = None) :staticmethod: Reconstruct a pipeline from a serialized configuration. :param config: The configuration object, as loaded from JSON, TOML, YAML, or similar. Will be validated into a :class:`PipelineConfig`. :param file_path: The path of the file from which the configuration was read, when available. :returns: The configured (but not trained) pipeline. :raises PipelineError: If there is a configuration error reconstructing the pipeline. :Warns: **PipelineWarning** -- If the configuration is funny but usable; for example, the configuration includes a hash but the constructed pipeline does not have a matching hash. .. py:method:: load_config(cfg_file) :classmethod: Load a pipeline from a saved configuration file. :param cfg_file: The path to a TOML, YAML, or JSON file containing the pipeline configuration. :returns: The consructed pipeline. .. seealso:: :meth:`from_config` for the actual pipeline instantiation logic. .. py:method:: modify() Create a pipeline builder from this pipeline in order to modify it. Pipelines cannot be modified in-place, but this method sets up a new builder that will create a modified copy of the pipeline. Unmodified component instances are reused as-is. .. note:: Since default connections are applied in :meth:`~lenskit.pipeline.PipelineBuilder.build`, the modifying builder does not have default connections. .. py:method:: train(data, options = None) Trains the pipeline's trainable components (those implementing the :class:`Trainable` interface) on some training data. If the :attr:`~TrainingOptions.retrain` option is ``False``, this method will skip training components that are already trained (as reported by the :meth:`~Trainable.is_trained` method). .. admonition:: Random Number Generation :class: note If :attr:`TrainingOptions.rng` is set and is not a generator or bit generator (i.e. it is a seed), then this method wraps the seed in a :class:`~numpy.random.SeedSequence` and calls :class:`~numpy.random.SeedSequence.spawn()` to generate a distinct seed for each component in the pipeline. :param data: The dataset to train on. :param options: The training options. If ``None``, default options are used. .. py:method:: run(/, **kwargs: object) -> object run(node: str, /, **kwargs: object) -> object run(nodes: tuple[str, Ellipsis], /, **kwargs: object) -> tuple[object, Ellipsis] run(node: lenskit.pipeline.nodes.Node[T], /, **kwargs: object) -> T run(nodes: tuple[lenskit.pipeline.nodes.Node[T1], lenskit.pipeline.nodes.Node[T2]], /, **kwargs: object) -> tuple[T1, T2] run(nodes: tuple[lenskit.pipeline.nodes.Node[T1], lenskit.pipeline.nodes.Node[T2], lenskit.pipeline.nodes.Node[T3]], /, **kwargs: object) -> tuple[T1, T2, T3] run(nodes: tuple[lenskit.pipeline.nodes.Node[T1], lenskit.pipeline.nodes.Node[T2], lenskit.pipeline.nodes.Node[T3], lenskit.pipeline.nodes.Node[T4]], /, **kwargs: object) -> tuple[T1, T2, T3, T4] run(nodes: tuple[lenskit.pipeline.nodes.Node[T1], lenskit.pipeline.nodes.Node[T2], lenskit.pipeline.nodes.Node[T3], lenskit.pipeline.nodes.Node[T4], lenskit.pipeline.nodes.Node[T5]], /, **kwargs: object) -> tuple[T1, T2, T3, T4, T5] Run the pipeline and obtain the return value(s) of one or more of its components. See :ref:`pipeline-execution` for details of the pipeline execution model. :param nodes: The component(s) to run. :param kwargs: The pipeline's inputs, as defined with :meth:`create_input`. These are passed as-is to :meth:`run_all`, so they can also contain auxillary options like `_profile`. :returns: The pipeline result. If no nodes are supplied, this is the result of the default node. If a single node is supplied, it is the result of that node. If a tuple of nodes is supplied, it is a tuple of their results. :raises PipelineError: when there is a pipeline configuration error (e.g. a cycle). :raises ValueError: when one or more required inputs are missing. :raises TypeError: when one or more required inputs has an incompatible type. :raises other: exceptions thrown by components are passed through. .. py:method:: run_all(*nodes, _profile = None, **kwargs) Run all nodes in the pipeline, or all nodes required to fulfill the requested node, and return a mapping with the full pipeline state (the data attached to each node). This is useful in cases where client code needs to be able to inspect the data at arbitrary steps of the pipeline. It differs from :meth:`run` in two ways: 1. It returns the data from all nodes as a mapping (dictionary-like object), not just the specified nodes as a tuple. 2. If no nodes are specified, it runs *all* nodes. This has the consequence of running nodes that are not required to fulfill the last node (such scenarios typically result from using :meth:`use_first_of`). :param nodes: The nodes to run, as positional arguments (if no nodes are specified, this method runs all nodes). :param _profile: A profiler to profile this pipeline run. :param kwargs: The pipeline inputs. :returns: The full pipeline state, with :attr:`~PipelineState.default` set to the last node specified. .. py:class:: PipelineProfiler(pipeline, file) :canonical: lenskit.pipeline._profiling.PipelineProfiler Collect pipeline run statistics for profiling pipeline executions. .. py:attribute:: writer :type: csv.DictWriter[str] .. py:attribute:: output :type: TextIO .. py:attribute:: sink_id :type: uuid.UUID .. py:method:: set_stages(stages) .. py:method:: multiprocess() .. py:method:: close() .. py:method:: record(record) .. py:method:: run_profiler() .. py:method:: __enter__() .. py:method:: __exit__(*args) .. py:class:: ProfileSink :canonical: lenskit.pipeline._profiling.ProfileSink Bases: :py:obj:`lenskit.logging.multiprocess.RecordSink`\ [\ :py:obj:`dict`\ [\ :py:obj:`str`\ , :py:obj:`float`\ ]\ ], :py:obj:`Protocol` Interface for creating recording pipeline run profiling information. .. py:method:: multiprocess() Obtain a version of this sink that can be shared across processes. .. py:method:: run_profiler() Get a profiler for a single run using this sink. .. py:class:: PipelineState(state = None, aliases = None, default = None, meta = None) :canonical: lenskit.pipeline._state.PipelineState Bases: :py:obj:`collections.abc.Mapping`\ [\ :py:obj:`str`\ , :py:obj:`Any`\ ] Full results of running a pipeline. A pipeline state is a dictionary mapping node names to their results; it is implemented as a separate class instead of directly using a dictionary to allow data to be looked up by node aliases in addition to original node names (and to be read-only). Client code will generally not construct this class directly. :Stability: Calller :param state: The pipeline state to wrap. The state object stores a reference to this dictionary. :param aliases: Dictionary of node aliases. :param default: The name of the default node (whose data should be returned by :attr:`default` ). :param meta: The metadata for the pipeline generating this state. .. py:attribute:: meta :type: lenskit.pipeline.config.PipelineMeta | None Pipeline metadata. .. py:property:: default :type: Any Return the data from of the default node (typically the last node run). :returns: The data associated with the default node. :raises ValueError: if there is no specified default node. .. py:property:: default_node :type: str | None Return the name of the default node (typically the last node run). .. py:method:: __len__() .. py:method:: __contains__(key) .. py:method:: __getitem__(key) .. py:method:: __iter__() .. py:method:: __str__() .. py:method:: __repr__() Exported Aliases ---------------- .. py:exception:: lenskit.pipeline.PipelineError Re-exported alias for :py:exc:`lenskit.diagnostics.PipelineError`. .. py:exception:: lenskit.pipeline.PipelineWarning Re-exported alias for :py:exc:`lenskit.diagnostics.PipelineWarning`. .. py:class:: lenskit.pipeline.Lazy Re-exported alias for :py:class:`lenskit.lazy.Lazy`. .. py:class:: lenskit.pipeline.Component Re-exported alias for :py:class:`lenskit.pipeline.components.Component`. .. py:class:: lenskit.pipeline.ComponentConstructor Re-exported alias for :py:class:`lenskit.pipeline.components.ComponentConstructor`. .. py:data:: lenskit.pipeline.PipelineFunction Re-exported alias for :py:data:`lenskit.pipeline.components.PipelineFunction`. .. py:class:: lenskit.pipeline.PipelineConfig Re-exported alias for :py:class:`lenskit.pipeline.config.PipelineConfig`. .. py:class:: lenskit.pipeline.Node Re-exported alias for :py:class:`lenskit.pipeline.nodes.Node`.