message

class MessageType(*values)

announce = 'announce'

identify = 'identify'

process = 'process'

init = 'init'

deinit = 'deinit'

ping = 'ping'

start = 'start'

status = 'status'

stop = 'stop'

event = 'event'

error = 'error'

class NodeStatus(*values)

stopped = 'stopped'

Node is deinitialized - does not have an instantiated node, etc., but is responsive.

waiting = 'waiting'

Node is waiting for its dependency nodes to be ready

ready = 'ready'

Node is ready to process events

running = 'running'

Node is running in free-run mode. Note that we do not update status for every process call at the moment, as that level of granularity is not relevant to the command node when sending commands

closed = 'closed'

Node is permanently gone, should not be expected to respond to further messages.

pydantic model Message

Show JSON schema

{
   "title": "Message",
   "type": "object",
   "properties": {
      "type": {
         "$ref": "#/$defs/MessageType"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "default": null,
         "title": "Value"
      }
   },
   "$defs": {
      "MessageType": {
         "enum": [
            "announce",
            "identify",
            "process",
            "init",
            "deinit",
            "ping",
            "start",
            "status",
            "stop",
            "event",
            "error"
         ],
         "title": "MessageType",
         "type": "string"
      }
   },
   "required": [
      "type",
      "node_id"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• node_id (str)

• timestamp (datetime.datetime)

• type_ (noob.network.message.MessageType)

• value (Any)

field node_id: str [Required]

field timestamp: datetime [Optional]

field type_: MessageType [Required] (alias 'type')

field value: Any = None

classmethod from_bytes(msg: list[bytes]) → Message

to_bytes() → bytes

class IdentifyValue

node_id: str

outbox: str

status: NodeStatus

signals: list[str] | None

slots: list[str] | None

class AnnounceValue

inbox: str

nodes: dict[str, IdentifyValue]

class ErrorValue

err_type: type[Exception]

err_args: tuple

traceback: str

class ProcessValue

epoch: int

input: dict | None

pydantic model AnnounceMsg

Command node ‘announces’ identities of other peers and the events they emit

Show JSON schema

{
   "title": "AnnounceMsg",
   "description": "Command node 'announces' identities of other peers and the events they emit",
   "type": "object",
   "properties": {
      "type": {
         "const": "announce",
         "default": "announce",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "$ref": "#/$defs/AnnounceValue"
      }
   },
   "$defs": {
      "AnnounceValue": {
         "properties": {
            "inbox": {
               "title": "Inbox",
               "type": "string"
            },
            "nodes": {
               "additionalProperties": {
                  "$ref": "#/$defs/IdentifyValue"
               },
               "title": "Nodes",
               "type": "object"
            }
         },
         "required": [
            "inbox",
            "nodes"
         ],
         "title": "AnnounceValue",
         "type": "object"
      },
      "IdentifyValue": {
         "properties": {
            "node_id": {
               "title": "Node Id",
               "type": "string"
            },
            "outbox": {
               "title": "Outbox",
               "type": "string"
            },
            "status": {
               "$ref": "#/$defs/NodeStatus"
            },
            "signals": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Signals"
            },
            "slots": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Slots"
            }
         },
         "required": [
            "node_id",
            "outbox",
            "status",
            "signals",
            "slots"
         ],
         "title": "IdentifyValue",
         "type": "object"
      },
      "NodeStatus": {
         "enum": [
            "stopped",
            "waiting",
            "ready",
            "running",
            "closed"
         ],
         "title": "NodeStatus",
         "type": "string"
      }
   },
   "required": [
      "node_id",
      "value"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.announce])

• value (noob.network.message.AnnounceValue)

field type_: Literal[MessageType.announce] = MessageType.announce (alias 'type')

field value: AnnounceValue [Required]

pydantic model IdentifyMsg

A node sends its configuration to the command node on initialization

Show JSON schema

{
   "title": "IdentifyMsg",
   "description": "A node sends its configuration to the command node on initialization",
   "type": "object",
   "properties": {
      "type": {
         "const": "identify",
         "default": "identify",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "$ref": "#/$defs/IdentifyValue"
      }
   },
   "$defs": {
      "IdentifyValue": {
         "properties": {
            "node_id": {
               "title": "Node Id",
               "type": "string"
            },
            "outbox": {
               "title": "Outbox",
               "type": "string"
            },
            "status": {
               "$ref": "#/$defs/NodeStatus"
            },
            "signals": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Signals"
            },
            "slots": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Slots"
            }
         },
         "required": [
            "node_id",
            "outbox",
            "status",
            "signals",
            "slots"
         ],
         "title": "IdentifyValue",
         "type": "object"
      },
      "NodeStatus": {
         "enum": [
            "stopped",
            "waiting",
            "ready",
            "running",
            "closed"
         ],
         "title": "NodeStatus",
         "type": "string"
      }
   },
   "required": [
      "node_id",
      "value"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.identify])

• value (noob.network.message.IdentifyValue)

field type_: Literal[MessageType.identify] = MessageType.identify (alias 'type')

field value: IdentifyValue [Required]

pydantic model PingMsg

Request other nodes to identify themselves and report their status

Show JSON schema

{
   "title": "PingMsg",
   "description": "Request other nodes to identify themselves and report their status",
   "type": "object",
   "properties": {
      "type": {
         "const": "ping",
         "default": "ping",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "default": null,
         "title": "Value",
         "type": "null"
      }
   },
   "required": [
      "node_id"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.ping])

• value (None)

field type_: Literal[MessageType.ping] = MessageType.ping (alias 'type')

field value: None = None

pydantic model ProcessMsg

Process a single iteration of the graph

Show JSON schema

{
   "title": "ProcessMsg",
   "description": "Process a single iteration of the graph",
   "type": "object",
   "properties": {
      "type": {
         "const": "process",
         "default": "process",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "$ref": "#/$defs/ProcessValue"
      }
   },
   "$defs": {
      "ProcessValue": {
         "properties": {
            "epoch": {
               "title": "Epoch",
               "type": "integer"
            },
            "input": {
               "anyOf": [
                  {
                     "additionalProperties": true,
                     "type": "object"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Input"
            }
         },
         "required": [
            "epoch",
            "input"
         ],
         "title": "ProcessValue",
         "type": "object"
      }
   },
   "required": [
      "node_id",
      "value"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.process])

• value (noob.network.message.ProcessValue)

field type_: Literal[MessageType.process] = MessageType.process (alias 'type')

field value: ProcessValue [Required]

Any process-scoped input passed to the process call

pydantic model InitMsg

Initialize nodes within node runners

Show JSON schema

{
   "title": "InitMsg",
   "description": "Initialize nodes within node runners",
   "type": "object",
   "properties": {
      "type": {
         "const": "init",
         "default": "init",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "default": null,
         "title": "Value",
         "type": "null"
      }
   },
   "required": [
      "node_id"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.init])

• value (None)

field type_: Literal[MessageType.init] = MessageType.init (alias 'type')

field value: None = None

pydantic model DeinitMsg

Deinitializes nodes within node runners

Show JSON schema

{
   "title": "DeinitMsg",
   "description": "Deinitializes nodes within node runners",
   "type": "object",
   "properties": {
      "type": {
         "const": "deinit",
         "default": "deinit",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "default": null,
         "title": "Value",
         "type": "null"
      }
   },
   "required": [
      "node_id"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.deinit])

• value (None)

field type_: Literal[MessageType.deinit] = MessageType.deinit (alias 'type')

field value: None = None

pydantic model StartMsg

Start free-running nodes

Show JSON schema

{
   "title": "StartMsg",
   "description": "Start free-running nodes",
   "type": "object",
   "properties": {
      "type": {
         "const": "start",
         "default": "start",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "anyOf": [
            {
               "type": "integer"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Value"
      }
   },
   "required": [
      "node_id"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.start])

• value (int | None)

field type_: Literal[MessageType.start] = MessageType.start (alias 'type')

field value: int | None = None

pydantic model StatusMsg

Node updating its current status

Show JSON schema

{
   "title": "StatusMsg",
   "description": "Node updating its current status",
   "type": "object",
   "properties": {
      "type": {
         "const": "status",
         "default": "status",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "$ref": "#/$defs/NodeStatus"
      }
   },
   "$defs": {
      "NodeStatus": {
         "enum": [
            "stopped",
            "waiting",
            "ready",
            "running",
            "closed"
         ],
         "title": "NodeStatus",
         "type": "string"
      }
   },
   "required": [
      "node_id",
      "value"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.status])

• value (noob.network.message.NodeStatus)

field type_: Literal[MessageType.status] = MessageType.status (alias 'type')

field value: NodeStatus [Required]

pydantic model StopMsg

Stop processing

Show JSON schema

{
   "title": "StopMsg",
   "description": "Stop processing",
   "type": "object",
   "properties": {
      "type": {
         "const": "stop",
         "default": "stop",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "default": null,
         "title": "Value",
         "type": "null"
      }
   },
   "required": [
      "node_id"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.stop])

• value (None)

field type_: Literal[MessageType.stop] = MessageType.stop (alias 'type')

field value: None = None

pydantic model ErrorMsg

An error occurred in one of the processing nodes

Show JSON schema

{
   "title": "ErrorMsg",
   "description": "An error occurred in one of the processing nodes",
   "type": "object",
   "properties": {
      "type": {
         "const": "error",
         "default": "error",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "$ref": "#/$defs/ErrorValue"
      }
   },
   "$defs": {
      "ErrorValue": {
         "properties": {
            "err_type": {
               "title": "Err Type"
            },
            "err_args": {
               "items": {},
               "title": "Err Args",
               "type": "array"
            },
            "traceback": {
               "title": "Traceback",
               "type": "string"
            }
         },
         "required": [
            "err_type",
            "err_args",
            "traceback"
         ],
         "title": "ErrorValue",
         "type": "object"
      }
   },
   "required": [
      "node_id",
      "value"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.error])

• value (Annotated[noob.network.message.ErrorValue, pydantic.functional_validators.BeforeValidator(func=noob.types._from_jsonable_pickle, json_schema_input_type=PydanticUndefined), pydantic.functional_serializers.WrapSerializer(func=noob.types._to_jsonable_pickle, return_type=PydanticUndefined, when_used=json)])

field type_: Literal[MessageType.error] = MessageType.error (alias 'type')

field value: Annotated[ErrorValue, BeforeValidator(func=_from_jsonable_pickle, json_schema_input_type=PydanticUndefined), WrapSerializer(func=_to_jsonable_pickle, return_type=PydanticUndefined, when_used=json)] [Required]

Constraints:

• func = <function _to_jsonable_pickle at 0x77de2d438ae0>

• json_schema_input_type = PydanticUndefined

• return_type = PydanticUndefined

• when_used = json

to_exception() → Exception

pydantic model EventMsg

Show JSON schema

{
   "title": "EventMsg",
   "type": "object",
   "properties": {
      "type": {
         "const": "event",
         "default": "event",
         "title": "Type",
         "type": "string"
      },
      "node_id": {
         "title": "Node Id",
         "type": "string"
      },
      "timestamp": {
         "format": "date-time",
         "title": "Timestamp",
         "type": "string"
      },
      "value": {
         "items": {
            "$ref": "#/$defs/Event"
         },
         "title": "Value",
         "type": "array"
      }
   },
   "$defs": {
      "Event": {
         "description": "Container for a single value returned from a single :meth:`.Node.process` call",
         "properties": {
            "id": {
               "title": "Id",
               "type": "integer"
            },
            "timestamp": {
               "format": "date-time",
               "title": "Timestamp",
               "type": "string"
            },
            "node_id": {
               "title": "Node Id",
               "type": "string"
            },
            "signal": {
               "title": "Signal",
               "type": "string"
            },
            "epoch": {
               "title": "Epoch",
               "type": "integer"
            },
            "value": {
               "title": "Value"
            }
         },
         "required": [
            "id",
            "timestamp",
            "node_id",
            "signal",
            "epoch",
            "value"
         ],
         "title": "Event",
         "type": "object"
      }
   },
   "required": [
      "node_id",
      "value"
   ]
}

Config:

• use_enum_values: bool = True

• validate_by_alias: bool = True

• serialize_by_alias: bool = True

Fields:

• type_ (Literal[noob.network.message.MessageType.event])

• value (list[Annotated[noob.event.Event, pydantic.functional_serializers.WrapSerializer(func=noob.network.message._to_json, return_type=PydanticUndefined, when_used=json), pydantic.functional_validators.BeforeValidator(func=noob.network.message._from_json, json_schema_input_type=PydanticUndefined)]])

field type_: Literal[MessageType.event] = MessageType.event (alias 'type')

field value: list[Annotated[Event, WrapSerializer(func=_to_json, return_type=PydanticUndefined, when_used=json), BeforeValidator(func=_from_json, json_schema_input_type=PydanticUndefined)]] [Required]