bindings->ports nomenclature update

python/reactivedataflow/reactivedataflow/__init__.py

@@ -1,14 +1,6 @@
 # Copyright (c) 2024 Microsoft Corporation.
 """The reactivedataflow Library."""
 
-from .bindings import (
-    ArrayInput,
-    Bindings,
-    Config,
-    Input,
-    NamedInputs,
-    Output,
-)
 from .decorators import (
     apply_decorators,
     connect_input,
@@ -30,6 +22,14 @@
     VerbInput,
     VerbOutput,
 )
+from .ports import (
+    ArrayInput,
+    Config,
+    Input,
+    NamedInputs,
+    Output,
+    Ports,
+)
 from .registry import Registry
 
 # Public API
@@ -44,7 +44,6 @@
 # - recativedataflow.model - this contains the Pydantic model for graph assembly.
 __all__ = [
     "ArrayInput",
-    "Bindings",
     "Config",
     "EmitMode",
     "ExecutionGraph",
@@ -57,6 +56,7 @@
     "Node",
     "Output",
     "OutputMode",
+    "Ports",
     "Registry",
     "VerbInput",
     "VerbOutput",

python/reactivedataflow/reactivedataflow/decorators/connect_input.py

@@ -4,20 +4,20 @@
 from collections.abc import Callable
 from typing import Any, ParamSpec, TypeVar, cast
 
-from reactivedataflow.bindings import Bindings
 from reactivedataflow.nodes import VerbInput
+from reactivedataflow.ports import Ports
 
 T = TypeVar("T")
 P = ParamSpec("P")
 
 
 def connect_input(
-    bindings: Bindings,
+    ports: Ports,
 ) -> Callable[[Callable[P, T]], Callable[[VerbInput], T]]:
     """Decorate an execution function with input conditions.
 
     Args:
-        bindings (Bindings): The input bindings for the function.
+        ports (Ports): The ports for the function.
     """
 
     def wrap_fn(
@@ -27,27 +27,26 @@ def wrapped_fn(inputs: VerbInput, *args: P.args, **kwargs: P.kwargs) -> T:
             fn_kwargs = {**kwargs}
 
             # Inject named-input Dictionary
-            named_inputs_port = bindings.named_inputs
+            named_inputs_port = ports.named_inputs
             if (
                 named_inputs_port is not None
                 and named_inputs_port.parameter is not None
             ):
                 fn_kwargs[named_inputs_port.parameter] = inputs.named_inputs
 
             # Inject array input
-            array_port = bindings.array_input
+            array_port = ports.array_input
             if array_port is not None and array_port.parameter is not None:
                 fn_kwargs[array_port.parameter] = inputs.array_inputs
 
             # Inject named parameters
             fn_kwargs.update({
                 p.parameter or p.name: inputs.named_inputs.get(p.name)
-                for p in bindings.input
+                for p in ports.input
             })
             # Inject configuration values
             fn_kwargs.update({
-                p.parameter or p.name: inputs.config.get(p.name)
-                for p in bindings.config
+                p.parameter or p.name: inputs.config.get(p.name) for p in ports.config
             })
 
             return cast(Any, fn)(*args, **fn_kwargs)

python/reactivedataflow/reactivedataflow/decorators/verb.py

@@ -4,13 +4,13 @@
 from collections.abc import Callable
 from typing import Any, ParamSpec
 
-from reactivedataflow.bindings import Binding, Bindings
 from reactivedataflow.nodes import (
     EmitCondition,
     FireCondition,
     InputMode,
     OutputMode,
 )
+from reactivedataflow.ports import PortBinding, Ports
 from reactivedataflow.registry import Registration, Registry
 
 from .apply_decorators import Decorator
@@ -23,7 +23,7 @@ def verb(
     adapters: list[Decorator] | None = None,
     fire_conditions: list[FireCondition] | None = None,
     emit_conditions: list[EmitCondition] | None = None,
-    bindings: list[Binding] | None = None,
+    ports: list[PortBinding] | None = None,
     registry: Registry | None = None,
     input_mode: InputMode | None = None,
     output_mode: OutputMode | None = None,
@@ -40,7 +40,7 @@ def verb(
         adapters (list[Decorator] | None): A list of decorators to apply to the verb before any other decoration.
         fire_conditions (list[FireCondition] | None): A list of fire conditions.
         emit_conditions (list[EmitCondition] | None): A list of emit conditions.
-        bindings (list[Binding] | None): A list of verb bindings, which are used to inject config, input, and map output values.
+        ports (list[PortBinding] | None): A list of port bindings, which are used to inject config, input, and map output values.
         registry (Registry | None): The registry to register the verb with. If None, then the default registry will be used.
         input_mode (InputMode | None): The input mode of the verb. If raw, then the function is expected to adhere to the VerbFunction interface.
         output_mode (OutputMode | None): The output mode of the verb, either a single-value or tuple.
@@ -55,8 +55,8 @@ def verb(
     def wrap_fn(verb: Callable[P, Any]) -> Callable[P, Any]:
         registration = Registration(
             fn=verb,
-            bindings=Bindings(
-                bindings or [],
+            ports=Ports(
+                ports or [],
                 include_default_output if include_default_output is not None else True,
             ),
             fire_conditions=fire_conditions or [],

python/reactivedataflow/reactivedataflow/graph_builder.py

@@ -167,7 +167,7 @@ def build_nodes() -> dict[str, Node]:
                 node_global_config = {
                     key: value
                     for key, value in config.items()
-                    if key in registration.bindings.config_names
+                    if key in registration.ports.config_names
                 }
                 node_config = {**node_global_config, **node_config}
 
@@ -246,7 +246,7 @@ def validate_inputs():
 
             # Validate the inputs and config
             registration = registry.get(node["verb"])
-            bindings = registration.bindings
+            bindings = registration.ports
             execution_node = nodes[nid]
 
             if isinstance(execution_node, ExecutionNode):

python/reactivedataflow/reactivedataflow/bindings.py → python/reactivedataflow/reactivedataflow/ports.py

@@ -82,20 +82,20 @@ class Config(BaseModel, extra="allow"):
     )
 
 
-Binding = Input | ArrayInput | NamedInputs | Config | Output
+PortBinding = Input | ArrayInput | NamedInputs | Config | Output
 
 
-class Bindings:
-    """Node Binding Manager class.
+class Ports:
+    """Node Ports Manager class.
 
     Node bindings are used to map processing-graph inputs, outputs, and configuration values into the appropriate
     function parameters. This class is used to manage the bindings for a node.
     """
 
-    _bindings: list[Binding]
+    _bindings: list[PortBinding]
     _has_default_output: bool
 
-    def __init__(self, bindings: list[Binding], has_default_output: bool = False):
+    def __init__(self, bindings: list[PortBinding], has_default_output: bool = False):
         """Initialize the Bindings object.
 
         Args:
@@ -117,7 +117,7 @@ def _validate(self):
             raise PortNamesMustBeUniqueError
 
     @property
-    def bindings(self) -> list[Binding]:
+    def bindings(self) -> list[PortBinding]:
         """Return the bindings."""
         return self._bindings
 

python/reactivedataflow/reactivedataflow/registry/registration.py

@@ -4,14 +4,14 @@
 from collections.abc import Callable
 from dataclasses import dataclass
 
-from reactivedataflow.bindings import Bindings
 from reactivedataflow.decorators import Decorator
 from reactivedataflow.nodes import (
     EmitCondition,
     FireCondition,
     InputMode,
     OutputMode,
 )
+from reactivedataflow.ports import Ports
 
 
 @dataclass
@@ -21,7 +21,7 @@ class Registration:
     fn: Callable
     """The verb function."""
 
-    bindings: Bindings
+    ports: Ports
     """The ports of the verb function."""
 
     adapters: list[Decorator]

python/reactivedataflow/reactivedataflow/registry/verb_constructor.py

@@ -1,7 +1,6 @@
 # Copyright (c) 2024 Microsoft Corporation.
 """reactivedataflow Verb Registry."""
 
-from reactivedataflow.bindings import Config, Input
 from reactivedataflow.conditions import (
     array_input_values_are_defined,
     output_changed,
@@ -26,6 +25,7 @@
     OutputMode,
     VerbFunction,
 )
+from reactivedataflow.ports import Config, Input
 
 from .registry import Registration
 
@@ -57,15 +57,14 @@ def push(x):
         )
 
     if registration.input_mode == InputMode.PortMapped:
-        input_parameter_map = _input_parameter_map(registration.bindings.input)
-        config_parameter_map = _config_parameter_map(registration.bindings.config)
+        input_parameter_map = _input_parameter_map(registration.ports.input)
+        config_parameter_map = _config_parameter_map(registration.ports.config)
         array_inputs_parameter: str | None = (
-            registration.bindings.array_input
-            and registration.bindings.array_input.parameter
+            registration.ports.array_input and registration.ports.array_input.parameter
         )
         dict_inputs_parameter: str | None = (
-            registration.bindings.named_inputs
-            and registration.bindings.named_inputs.parameter
+            registration.ports.named_inputs
+            and registration.ports.named_inputs.parameter
         )
         is_input_connection_required = (
             len(input_parameter_map) > 0
@@ -74,7 +73,7 @@ def push(x):
             or dict_inputs_parameter
         )
         if is_input_connection_required:
-            push(connect_input(bindings=registration.bindings))
+            push(connect_input(ports=registration.ports))
 
     if len(fire_conditions) > 0:
         push(firing_conditions_decorator(*fire_conditions))
@@ -89,19 +88,16 @@ def _infer_firing_conditions(
 ) -> list[FireCondition]:
     firing_conditions = []
     required_inputs: list[str] = [
-        p.name for p in registration.bindings.input if p.required
+        p.name for p in registration.ports.input if p.required
     ]
     required_config: list[str] = [
-        p.name for p in registration.bindings.config if p.required
+        p.name for p in registration.ports.config if p.required
     ]
 
-    if registration.bindings.array_input and registration.bindings.array_input.required:
+    if registration.ports.array_input and registration.ports.array_input.required:
         firing_conditions.append(array_input_values_are_defined())
-    if (
-        registration.bindings.named_inputs
-        and registration.bindings.named_inputs.required
-    ):
-        required_inputs.extend(registration.bindings.named_inputs.required)
+    if registration.ports.named_inputs and registration.ports.named_inputs.required:
+        required_inputs.extend(registration.ports.named_inputs.required)
 
     if len(required_inputs) > 0:
         firing_conditions.append(require_inputs(*required_inputs))
@@ -117,9 +113,7 @@ def _infer_emit_conditions(
     result: list[EmitCondition] = []
 
     # Create a composite emit condition. Any output that emits a changed value will allow an emit.
-    ports = [
-        p for p in registration.bindings.outputs if p.emits_on == EmitMode.OnChange
-    ]
+    ports = [p for p in registration.ports.outputs if p.emits_on == EmitMode.OnChange]
     if len(ports) > 0:
         change_checks = [output_changed(p.name) for p in ports]
 

python/reactivedataflow/reactivedataflow/types.py

@@ -1,19 +1,19 @@
 # Copyright (c) 2024 Microsoft Corporation.
 """reactivedataflow Types."""
 
-from .bindings import Binding
 from .decorators import AnyFn, Decorator
 from .nodes import EmitCondition, FireCondition, VerbFunction
+from .ports import PortBinding
 from .registry import VerbConstructor
 from .utils.equality import IsEqualCheck
 
 __all__ = [
     "AnyFn",
-    "Binding",
     "Decorator",
     "EmitCondition",
     "FireCondition",
     "IsEqualCheck",
+    "PortBinding",
     "VerbConstructor",
     "VerbFunction",
 ]

python/reactivedataflow/tests/unit/decorators/test_connect_input.py

@@ -3,18 +3,18 @@
 
 from reactivedataflow import (
     ArrayInput,
-    Bindings,
     Config,
     Input,
     NamedInputs,
+    Ports,
     VerbInput,
     connect_input,
 )
 
 
 def test_named_input_mapping():
     @connect_input(
-        bindings=Bindings([
+        ports=Ports([
             Input(name="input_1", parameter="a"),
             Input(name="input_2", parameter="b"),
         ])
@@ -28,7 +28,7 @@ def stub(a: int, b: int) -> int:
 
 def test_input_with_default_parameter_names():
     @connect_input(
-        bindings=Bindings([
+        ports=Ports([
             Input(name="a"),
             Input(name="b"),
         ])
@@ -41,7 +41,7 @@ def stub(a: int, b: int) -> int:
 
 
 def test_input_dict_mapping():
-    @connect_input(Bindings([NamedInputs(parameter="inputs", required=["a", "b"])]))
+    @connect_input(Ports([NamedInputs(parameter="inputs", required=["a", "b"])]))
     def stub(inputs: dict[str, int]) -> int:
         return sum(inputs.values())
 
@@ -51,7 +51,7 @@ def stub(inputs: dict[str, int]) -> int:
 
 def test_config_parameters_mapping():
     @connect_input(
-        bindings=Bindings([
+        ports=Ports([
             Config(name="in_1", parameter="a"),
             Config(name="in_2", parameter="b"),
         ])
@@ -64,7 +64,7 @@ def stub(a: str, b: str) -> str:
 
 
 def test_array_parameter_mapping():
-    @connect_input(bindings=Bindings([ArrayInput(parameter="values")]))
+    @connect_input(ports=Ports([ArrayInput(parameter="values")]))
     def stub(values: list[int]) -> int:
         return sum(values)