RSVP for your your local TensorFlow Everywhere event today!

tfx.orchestration.beam.beam_dag_runner.PipelineNodeAsDoFn

Wrap node as beam DoFn.

tfx.orchestration.beam.beam_dag_runner.PipelineNodeAsDoFn(
    pipeline_node: pipeline_pb2.PipelineNode,
    mlmd_connection_config: tfx.orchestration.metadata.ConnectionConfigType,
    pipeline_info: pipeline_pb2.PipelineInfo,
    pipeline_runtime_spec: pipeline_pb2.PipelineRuntimeSpec,
    executor_spec: Optional[message.Message],
    custom_driver_spec: Optional[message.Message],
    deployment_config: Optional[message.Message]
)

pipeline_node The specification of the node that this launcher lauches.
mlmd_connection_config ML metadata connection config.
pipeline_info The information of the pipeline that this node runs in.
pipeline_runtime_spec The runtime information of the pipeline that this node runs in.
executor_spec Specification for the executor of the node. This is expected for all nodes. This will be used to determine the specific ExecutorOperator class to be used to execute and will be passed into ExecutorOperator.
custom_driver_spec Specification for custom driver. This is expected only for advanced use cases.
deployment_config Deployment Config for the pipeline.

Child Classes

class BundleFinalizerParam

class RestrictionParam

class StateParam

class TimerParam

class WatermarkEstimatorParam

Methods

default_label

default_label()

default_type_hints

default_type_hints()

display_data

display_data()

Returns the display data associated to a pipeline component.

It should be reimplemented in pipeline components that wish to have static display data.

Returns
Dict[str, Any]: A dictionary containing key:value pairs. The value might be an integer, float or string value; a :class:DisplayDataItem for values that have more data (e.g. short value, label, url); or a :class:HasDisplayData instance that has more display data that should be picked up. For example::

{ 'key1': 'string_value', 'key2': 1234, 'key3': 3.14159265, 'key4': DisplayDataItem('apache.org', url='http://apache.org'), 'key5': subComponent }

finish_bundle

finish_bundle()

Called after a bundle of elements is processed on a worker.

from_callable

@staticmethod
from_callable(
    fn
)

from_runner_api

@classmethod
from_runner_api(
    fn_proto, context
)

Converts from an FunctionSpec to a Fn object.

Prefer registering a urn with its parameter type and constructor.

get_function_arguments

get_function_arguments(
    func
)

get_type_hints

get_type_hints()

Gets and/or initializes type hints for this object.

If type hints have not been set, attempts to initialize type hints in this order:

  • Using self.default_type_hints().
  • Using self.class type hints.

infer_output_type

infer_output_type(
    input_type
)

process

View source

process(
    element: Any,
    *signals
) -> None

Executes node based on signals.

Args
element a signal element to trigger the node.
*signals side input signals indicate completeness of upstream nodes.

register_pickle_urn

@classmethod
register_pickle_urn(
    pickle_urn
)

Registers and implements the given urn via pickling.

register_urn

@classmethod
register_urn(
    urn, parameter_type, fn=None
)

Registers a urn with a constructor.

For example, if 'beam:fn:foo' had parameter type FooPayload, one could write RunnerApiFn.register_urn('bean:fn:foo', FooPayload, foo_from_proto) where foo_from_proto took as arguments a FooPayload and a PipelineContext. This function can also be used as a decorator rather than passing the callable in as the final parameter.

A corresponding to_runner_api_parameter method would be expected that returns the tuple ('beam:fn:foo', FooPayload)

setup

setup()

Called to prepare an instance for processing bundles of elements.

This is a good place to initialize transient in-memory resources, such as network connections. The resources can then be disposed in DoFn.teardown.

start_bundle

start_bundle()

Called before a bundle of elements is processed on a worker.

Elements to be processed are split into bundles and distributed to workers. Before a worker calls process() on the first element of its bundle, it calls this method.

teardown

teardown()

Called to use to clean up this instance before it is discarded.

A runner will do its best to call this method on any given instance to prevent leaks of transient resources, however, there may be situations where this is impossible (e.g. process crash, hardware failure, etc.) or unnecessary (e.g. the pipeline is shutting down and the process is about to be killed anyway, so all transient resources will be released automatically by the OS). In these cases, the call may not happen. It will also not be retried, because in such situations the DoFn instance no longer exists, so there's no instance to retry it on.

Thus, all work that depends on input elements, and all externally important side effects, must be performed in DoFn.process or DoFn.finish_bundle.

to_runner_api

to_runner_api(
    context
)

Returns an FunctionSpec encoding this Fn.

Prefer overriding self.to_runner_api_parameter.

to_runner_api_parameter

to_runner_api_parameter(
    context
)

unbounded_per_element

@staticmethod
unbounded_per_element()

A decorator on process fn specifying that the fn performs an unbounded amount of work per input element.

with_input_types

with_input_types(
    *arg_hints, **kwarg_hints
)

with_output_types

with_output_types(
    *arg_hints, **kwarg_hints
)

DoFnProcessParams

DynamicTimerTagParam

ElementParam

KeyParam

PaneInfoParam

SideInputParam

TimestampParam

WindowParam