gridappsd-field-bus 2023.5__tar.gz

gridappsd_field_bus-2023.5/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: gridappsd-field-bus
+Version: 2023.5
+Summary: GridAPPS-D Field Bus Implementation
+Home-page: https://gridappsd.readthedocs.io
+License: BSD-3-Clause
+Keywords: gridappsd,grid,activmq,powergrid,simulation,library
+Author: C. Allwardt
+Author-email: 3979063+craig8@users.noreply.github.com
+Requires-Python: >=3.7.9,<4.0
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: cim-graph (>=2023.5.1a3,<2024.0.0)
+Requires-Dist: gridappsd-python (>=2023.5,<2024.0)
+Project-URL: Repository, https://github.com/GRIDAPPSD/gridappsd-python
+Description-Content-Type: text/markdown
+
+

gridappsd_field_bus-2023.5/gridappsd/field_interface/__init__.py

@@ -0,0 +1,9 @@
+from typing import List
+
+from gridappsd.field_interface.context import LocalContext
+from gridappsd.field_interface.interfaces import MessageBusDefinition
+
+__all__: List[str] = [
+    "LocalContext",
+    "MessageBusDefinition"
+]

gridappsd_field_bus-2023.5/gridappsd/field_interface/agents/__init__.py

@@ -0,0 +1,15 @@
+from typing import List
+
+from gridappsd.field_interface.agents.agents import (
+    FeederAgent,
+    DistributedAgent,
+    CoordinatingAgent,
+    SwitchAreaAgent,
+    SecondaryAreaAgent
+)
+
+__all__: List[str] = [
+    "FeederAgent",
+    "DistributedAgent",
+    "CoordinatingAgent"
+]

gridappsd_field_bus-2023.5/gridappsd/field_interface/agents/agents.py

@@ -0,0 +1,353 @@
+import dataclasses
+import importlib
+import json
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict
+
+from cimgraph.loaders import ConnectionParameters, gridappsd
+from cimgraph.loaders.gridappsd import GridappsdConnection
+from cimgraph.models import DistributedModel, SecondaryArea, SwitchArea
+
+import gridappsd.topics as t
+from gridappsd.field_interface.context import LocalContext
+from gridappsd.field_interface.gridappsd_field_bus import GridAPPSDMessageBus
+from gridappsd.field_interface.interfaces import (FieldMessageBus,
+                                                  MessageBusDefinition)
+
+cim = None
+sparql = None
+
+_log = logging.getLogger(__name__)
+
+
+def set_cim_profile(cim_profile):
+    global cim
+    cim = importlib.import_module('cimgraph.data_profile.' + cim_profile)
+    gridappsd.set_cim_profile(cim_profile)
+
+
+@dataclass
+class AgentRegistrationDetails:
+    agent_id: str
+    app_id: str
+    description: str
+    upstream_message_bus_id: FieldMessageBus.id
+    downstream_message_bus_id: FieldMessageBus.id
+
+
+class DistributedAgent:
+
+    def __init__(self,
+                 upstream_message_bus_def: MessageBusDefinition,
+                 downstream_message_bus_def: MessageBusDefinition,
+                 agent_config,
+                 agent_area_dict=None,
+                 simulation_id=None,
+                 cim_profile: str = None):
+        """
+        Creates a DistributedAgent object that connects to the specified message
+        buses and gets context based on feeder id and area id.
+        """
+        _log.debug(f"Creating DistributedAgent: {self.__class__.__name__}")
+        self.upstream_message_bus = None
+        self.downstream_message_bus = None
+        self.simulation_id = simulation_id
+        self.context = None
+
+        #TODO: Change params and connection to local connection
+        self.params = ConnectionParameters()
+        self.connection = GridappsdConnection(self.params)
+
+        self.app_id = agent_config['app_id']
+        self.description = agent_config['description']
+        dt = datetime.now()
+        ts = datetime.timestamp(dt)
+        self.agent_id = "da_" + self.app_id + "_" + str(int(ts))
+        self.agent_area_dict = agent_area_dict
+
+        if upstream_message_bus_def is not None:
+            if upstream_message_bus_def.is_ot_bus:
+                self.upstream_message_bus = GridAPPSDMessageBus(
+                    upstream_message_bus_def)
+        #            else:
+        #                self.upstream_message_bus = VolttronMessageBus(upstream_message_bus_def)
+
+        if downstream_message_bus_def is not None:
+            if downstream_message_bus_def.is_ot_bus:
+                self.downstream_message_bus = GridAPPSDMessageBus(
+                    downstream_message_bus_def)
+        #            else:
+        #                self.downstream_message_bus = VolttronMessageBus(downstream_message_bus_def)
+
+        # self.context = ContextManager.get(self.feeder_id, self.area_id)
+
+        #if agent_dict is not None:
+        #    self.addressable_equipments = agent_dict['addressable_equipment']
+        #    self.unaddressable_equipments = agent_dict['unaddressable_equipment']
+
+    def connect(self):
+
+        if self.upstream_message_bus is not None:
+            self.upstream_message_bus.connect()
+        if self.downstream_message_bus is not None:
+            self.downstream_message_bus.connect()
+        if self.downstream_message_bus is None and self.upstream_message_bus is None:
+            raise ValueError(
+                "Either upstream or downstream bus must be specified!")
+            
+        if self.agent_area_dict is None:
+            context = LocalContext.get_context_by_message_bus(
+                self.downstream_message_bus)
+            self.agent_area_dict = context['data']
+
+        self.subscribe_to_measurement()
+        self.subscribe_to_messages()
+        self.subscribe_to_requests()
+
+        if ('context_manager' not in self.app_id):
+            LocalContext.register_agent(self.downstream_message_bus,
+                                        self.upstream_message_bus, self)
+
+    def subscribe_to_measurement(self):
+        if self.simulation_id is None:
+            self.downstream_message_bus.subscribe(
+                t.field_output_topic(self.downstream_message_bus.id),
+                self.on_measurement)
+        else:
+            topic = t.field_output_topic(self.downstream_message_bus.id,
+                                         self.simulation_id)
+            _log.debug(f"subscribing to simulation output on topic {topic}")
+            self.downstream_message_bus.subscribe(topic,
+                                                  self.on_simulation_output)
+
+    def subscribe_to_messages(self):
+
+        self.downstream_message_bus.subscribe(
+            t.field_message_bus_topic(self.downstream_message_bus),
+            self.on_downstream_message)
+        self.downstream_message_bus.subscribe(
+            t.field_message_bus_topic(self.upstream_message_bus),
+            self.on_upstream_message)
+
+        _log.debug(
+            f"Subscribing to messages on application topics: \n {t.field_message_bus_app_topic(self.downstream_message_bus.id, self.app_id)} \
+                                                                    \n {t.field_message_bus_app_topic(self.upstream_message_bus.id, self.app_id)}"
+        )
+        self.downstream_message_bus.subscribe(
+            t.field_message_bus_app_topic(self.downstream_message_bus.id,
+                                          self.app_id),
+            self.on_downstream_message)
+        self.downstream_message_bus.subscribe(
+            t.field_message_bus_app_topic(self.upstream_message_bus.id,
+                                          self.app_id),
+            self.on_upstream_message)
+
+        _log.debug(
+            f"Subscribing to message on agents topics: \n {t.field_message_bus_agent_topic(self.downstream_message_bus.id, self.agent_id)} \
+                                                            \n {t.field_message_bus_agent_topic(self.upstream_message_bus.id, self.agent_id)}"
+        )
+        self.downstream_message_bus.subscribe(
+            t.field_message_bus_agent_topic(self.downstream_message_bus.id,
+                                            self.agent_id),
+            self.on_downstream_message)
+        self.downstream_message_bus.subscribe(
+            t.field_message_bus_agent_topic(self.upstream_message_bus.id,
+                                            self.agent_id),
+            self.on_upstream_message)
+
+    def subscribe_to_requests(self):
+
+        _log.debug(
+            f"Subscribing to requests on agents queue: \n {t.field_agent_request_queue(self.downstream_message_bus.id, self.agent_id)} \
+                                                            \n {t.field_agent_request_queue(self.upstream_message_bus.id, self.agent_id)}"
+        )
+        self.downstream_message_bus.subscribe(
+            t.field_agent_request_queue(self.downstream_message_bus.id,
+                                        self.agent_id),
+            self.on_request_from_downstream)
+        self.downstream_message_bus.subscribe(
+            t.field_agent_request_queue(self.upstream_message_bus.id,
+                                        self.agent_id),
+            self.on_request_from_uptream)
+
+    def on_measurement(self, headers: Dict, message) -> None:
+        raise NotImplementedError(
+            f"{self.__class__.__name__} must be overriden in child class")
+
+    def on_simulation_output(self, headers, message):
+        self.on_measurement(headers=headers, message=message)
+
+    def on_upstream_message(self, headers: Dict, message) -> None:
+        raise NotImplementedError(
+            f"{self.__class__.__name__} must be overriden in child class")
+
+    def on_downstream_message(self, headers: Dict, message) -> None:
+        raise NotImplementedError(
+            f"{self.__class__.__name__} must be overriden in child class")
+
+    def on_request_from_uptream(self, headers: Dict, message):
+        self.on_request(self.upstream_message_bus, headers, message)
+
+    def on_request_from_downstream(self, headers: Dict, message):
+        self.on_request(self.downstream_message_bus, headers, message)
+
+    def on_request(self, message_bus, headers: Dict, message):
+        raise NotImplementedError(
+            f"{self.__class__.__name__} must be overriden in child class")
+
+    def get_registration_details(self):
+        details = AgentRegistrationDetails(str(self.agent_id), self.app_id,
+                                           self.description,
+                                           self.upstream_message_bus.id,
+                                           self.downstream_message_bus.id)
+        return dataclasses.asdict(details)
+
+
+'''  TODO this has not been implemented yet, so we are commented them out for now.
+    # not all agent would use this    
+    def on_control(self, control):
+        device_id = control.get('device')
+        command = control.get('command')
+        self.control_device(device_id, command)
+
+    def control_device(self, device_id, command):
+        device_topic = self.devices.get(device_id)
+        self.secondary_message_bus.publish(device_topic, command)'''
+
+
+class FeederAgent(DistributedAgent):
+
+    def __init__(self,
+                 upstream_message_bus_def: MessageBusDefinition,
+                 downstream_message_bus_def: MessageBusDefinition,
+                 agent_config: Dict,
+                 feeder_dict=None,
+                 simulation_id=None):
+        super(FeederAgent,
+              self).__init__(upstream_message_bus_def,
+                             downstream_message_bus_def, agent_config,
+                             feeder_dict, simulation_id)
+        self.feeder_area = None
+        self.downstream_message_bus_def = downstream_message_bus_def
+        if self.agent_area_dict is not None:
+            feeder = cim.Feeder(mRID=self.downstream_message_bus_def.id)
+            self.feeder_area = DistributedModel(connection=self.connection,
+                                                feeder=feeder,
+                                                topology=self.agent_area_dict)
+    
+
+    def connect(self):
+        super().connect()
+        if self.feeder_area is None:
+            feeder = cim.Feeder(mRID=self.downstream_message_bus_def.id)
+            self.feeder_area = DistributedModel(connection=self.connection,
+                                                feeder=feeder,
+                                                topology=self.agent_area_dict)
+
+
+class SwitchAreaAgent(DistributedAgent):
+
+    def __init__(self,
+                 upstream_message_bus_def: MessageBusDefinition,
+                 downstream_message_bus_def: MessageBusDefinition,
+                 agent_config: Dict,
+                 switch_area_dict=None,
+                 simulation_id=None):
+        super().__init__(upstream_message_bus_def, downstream_message_bus_def,
+                         agent_config, switch_area_dict, simulation_id)
+        self.switch_area = None
+        self.downstream_message_bus_def = downstream_message_bus_def
+        if self.agent_area_dict is not None:
+            self.switch_area = SwitchArea(self.downstream_message_bus_def.id,
+                                          self.connection)
+            self.switch_area.initialize_switch_area(self.agent_area_dict)
+    
+
+    def connect(self):
+        super().connect()
+        if self.switch_area is None:
+            self.switch_area = SwitchArea(self.downstream_message_bus_def.id,
+                                          self.connection)
+            self.switch_area.initialize_switch_area(self.agent_area_dict)
+
+
+class SecondaryAreaAgent(DistributedAgent):
+
+    def __init__(self,
+                 upstream_message_bus_def: MessageBusDefinition,
+                 downstream_message_bus_def: MessageBusDefinition,
+                 agent_config: Dict,
+                 secondary_area_dict=None,
+                 simulation_id=None):
+        super().__init__(upstream_message_bus_def, downstream_message_bus_def,
+                         agent_config, secondary_area_dict, simulation_id)
+        self.secondary_area = None
+        self.downstream_message_bus_def = downstream_message_bus_def
+        if self.agent_area_dict is not None:
+            self.secondary_area = SecondaryArea(self.downstream_message_bus_def.id,
+                                                self.connection)
+            self.secondary_area.initialize_secondary_area(self.agent_area_dict)
+    
+
+    def connect(self):
+        super().connect()
+        if self.secondary_area is None:
+            self.secondary_area = SecondaryArea(self.downstream_message_bus_def.id,
+                                                self.connection)
+            self.secondary_area.initialize_secondary_area(self.agent_area_dict)
+
+
+class CoordinatingAgent:
+    """
+    A CoordinatingAgent performs following functions:
+        1. Spawns distributed agents
+        2. Publishes compiled output to centralized OT bus
+        3. Distributes centralized output to Feeder bus and distributed agents
+        4. May have connected devices and control those devices
+
+        upstream, peer , downstream and broadcast
+    """
+
+    def __init__(self,
+                 feeder_id,
+                 system_message_bus_def: MessageBusDefinition,
+                 simulation_id=None):
+        self.feeder_id = feeder_id
+        self.distributed_agents = []
+
+        self.system_message_bus = GridAPPSDMessageBus(system_message_bus_def)
+        self.system_message_bus.connect()
+
+        #This will change when we have multiple feeders per system
+        self.downstream_message_bus = self.system_message_bus
+
+        # self.context = ContextManager.getContextByFeeder(self.feeder_id)
+        # print(self.context)
+        # self.addressable_equipments = self.context['data']['addressable_equipment']
+        # self.unaddressable_equipments = self.context['data']['unaddressable_equipment']
+        # self.switch_areas = self.context['data']['switch_areas']
+
+        # self.subscribe_to_feeder_bus()
+
+    def spawn_distributed_agent(self, distributed_agent: DistributedAgent):
+        distributed_agent.connect()
+        self.distributed_agents.append(distributed_agent)
+
+
+'''    
+    def on_control(self, control):
+        device_id = control.get('device')
+        command = control.get('command')
+        self.control_device(device_id, command)
+
+    def publish_to_distribution_bus(self,message):
+        self.publish_to_downstream_bus(message)
+
+    def publish_to_distribution_bus_agent(self,agent_id, message):
+        self.publish_to_downstream_bus_agent(agent_id, message)
+
+    def control_device(self, device_id, command):
+        device_topic = self.devices.get(device_id)
+        self.secondary_message_bus.publish(device_topic, command)'''

gridappsd_field_bus-2023.5/gridappsd/field_interface/context.py

@@ -0,0 +1,51 @@
+from gridappsd.field_interface.interfaces import FieldMessageBus
+import dataclasses
+import gridappsd.topics as t
+import json
+
+
+
+class LocalContext:
+    
+    @classmethod
+    def get_context_by_feeder(cls, downstream_message_bus: FieldMessageBus, feeder_mrid, area_id=None):
+        
+        request = {'request_type' : 'get_context',
+                    'modelId': feeder_mrid,
+                   'areaId': area_id}
+        response = downstream_message_bus.get_response(t.context_request_queue(downstream_message_bus.id), request, timeout=10)
+        return response
+
+    @classmethod
+    def get_context_by_message_bus(cls, downstream_message_bus: FieldMessageBus):
+        """
+        return agents/devices based on downstream message bus as input
+
+        """
+        request = {'request_type' : 'get_context',
+                   'downstream_message_bus_id': downstream_message_bus.id
+                   }
+        return downstream_message_bus.get_response(t.context_request_queue(downstream_message_bus.id), request)
+    
+    @classmethod
+    def register_agent(cls, downstream_message_bus: FieldMessageBus, upstream_message_bus: FieldMessageBus, agent):
+        """
+        Sends the newly created distributed agent's info to OT bus
+
+        """
+        request = {'request_type' : 'register_agent',
+                   'agent' : agent.get_registration_details()}
+        downstream_message_bus.send(t.context_request_queue(downstream_message_bus.id), request)
+        upstream_message_bus.send(t.context_request_queue(upstream_message_bus.id), request)
+    
+    @classmethod
+    def get_agents(cls, downstream_message_bus: FieldMessageBus):
+        """
+        Sends the newly created distributed agent's info to OT bus
+
+        """
+        request = {'request_type' : 'get_agents'}
+        return downstream_message_bus.get_response(t.context_request_queue(downstream_message_bus.id), request)
+
+# Provide context based on router (ip trace) or PKI
+# Maybe able to emulate/simulate

gridappsd_field_bus-2023.5/gridappsd/field_interface/gridappsd_field_bus.py

@@ -0,0 +1,58 @@
+from gridappsd import GridAPPSD
+from gridappsd.field_interface.interfaces import FieldMessageBus
+from gridappsd.field_interface.interfaces import MessageBusDefinition
+from typing import Any
+
+
+class GridAPPSDMessageBus(FieldMessageBus):
+    def __init__(self, definition: MessageBusDefinition):
+        super(GridAPPSDMessageBus, self).__init__(definition)
+        self._id = definition.id
+
+        self._user = definition.conneciton_args["GRIDAPPSD_USER"]
+        self._password = definition.conneciton_args["GRIDAPPSD_PASSWORD"]
+        self._address = definition.conneciton_args["GRIDAPPSD_ADDRESS"]
+
+        self.gridappsd_obj = None
+        
+    def query_devices(self) -> dict:
+        pass
+
+    def is_connected(self) -> bool:
+        """
+        Is this object connected to the message bus
+        """
+        pass
+
+    def connect(self):
+        """
+        Connect to the concrete message bus that implements this interface.
+        """
+        self.gridappsd_obj = GridAPPSD()
+
+    def subscribe(self, topic, callback):
+        if self.gridappsd_obj is not None:
+            self.gridappsd_obj.subscribe(topic, callback)
+
+    def unsubscribe(self, topic):
+        pass
+
+    def send(self, topic: str, message: Any):
+        """
+        Publish device specific data to the concrete message bus.
+        """
+        if self.gridappsd_obj is not None:
+            self.gridappsd_obj.send(topic, message)
+            
+    def get_response(self, topic, message, timeout=5):
+        """
+        Sends a message on a specific concrete queue, waits and returns the response
+        """
+        if self.gridappsd_obj is not None:
+            return self.gridappsd_obj.get_response(topic, message, timeout)
+        
+    def disconnect(self):
+        """
+        Disconnect the device from the concrete message bus.
+        """
+        pass

gridappsd_field_bus-2023.5/gridappsd/field_interface/interfaces.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+import gridappsd.topics as t
+import logging
+from os import PathLike
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+
+import yaml
+
+
+_log = logging.getLogger(__name__)
+
+
+class FieldProtocol(Enum):
+    PROTOCOL_2030_5 = "2030.5"
+    PROTOCOL_DNP3 = "DNP3"
+
+
+class SerializationProtocol(Enum):
+    JSON = "JSON"
+    XML = "XML"
+
+
+class ConnectionType(Enum):
+    # VOLTTRON based connection
+    CONNECTION_TYPE_VOLTTRON = "VIP"
+    # Web Socket
+    # CONNECTION_TYPE_WS = "WS"
+    # CONNECTION_TYPE_HTTP = "HTTP"
+    # CONNECTION_TYPE_TCP = "TCP"
+    CONNECTION_TYPE_GRIDAPPSD = "CONNECTION_TYPE_GRIDAPPSD"
+
+
+class ProtocolTransformer(ABC):
+    @staticmethod
+    @abstractmethod
+    def to_cim(data) -> str:
+        """
+        Create a cim message based upon the data passed for a given
+        concrete protocol.  This is set as a static class because
+        all transformers should have this capability.
+
+        This function should return a string that can be manipulated
+        to go onto whatever message bus is necessary.
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def to_protocol(cim_data: str, from_format: Optional[str] = None):
+        """
+        Change passed cim data into a protocol complient data stream
+        and return it.
+
+        cim_data: string representing cim data structures/change structure
+        from_format: specifies the type 
+        """
+        pass
+
+
+
+@dataclass
+class MessageBusDefinition:
+    """
+    A `MessageBusDefinition` class is used to define how to connect to the
+    message bus.
+    """
+
+    """
+    A global unique string representing a specific message bus.
+    """
+    id: str
+
+    """
+    connection_type describes how the agent/endpoint will connect to the message bus
+    """
+    connection_type: ConnectionType
+
+    """
+    connection_args allows dynamic key/value paired strings to be added to allow connections.
+    """
+    conneciton_args: Dict[str, str]
+
+    """
+    Determines whether or not this message bus has the role of ot bus.
+    """
+    is_ot_bus: bool = False
+
+    @staticmethod
+    def load(config_file) -> MessageBusDefinition:
+        """
+
+        """
+        config = yaml.load(open(config_file),Loader=yaml.FullLoader)['connections']
+        
+        required = ["id", "connection_type", "connection_args"]
+        for k in required:
+            if k not in config:
+                raise ValueError(f"Missing keys for connection {k}")
+
+        definition = MessageBusDefinition(config[required[0]], config[required[1]], config[required[2]])
+        for k in config:
+            if k == "connection_args":
+                definition.conneciton_args = dict()
+                for k1, v1 in config[k].items():
+                    definition.conneciton_args[k1] = v1
+            else:
+                setattr(definition, k, config[k])
+
+        if not hasattr(definition, "is_ot_bus"):
+            setattr(definition, "is_ot_bus", False)
+            
+        return definition
+
+
+class FieldMessageBus:
+    def __init__(self, config: MessageBusDefinition):
+        self._devices = dict()
+        self._is_ot_bus = config.is_ot_bus
+        self._id = config.id
+
+    @property
+    def id(self):
+        return self._id
+
+    @property
+    def is_ot_bus(self):
+        return self._is_ot_bus
+
+    def add_device(self, device: "DeviceFieldInterface"):
+        self._devices[device.id] = device
+
+    def disconnect_device(self, id: str):
+        del self._devices[id]
+
+    @abstractmethod
+    def query_devices(self) -> dict:
+        pass
+
+    @abstractmethod
+    def is_connected(self) -> bool:
+        """
+        Is this object connected to the message bus
+        """
+        pass
+
+    @abstractmethod
+    def connect(self):
+        """
+        Connect to the concrete message bus that implements this interface.
+        """
+        pass
+
+    @abstractmethod
+    def subscribe(self, topic, callback):
+        pass
+
+    @abstractmethod
+    def unsubscribe(self, topic):
+        pass
+
+    @abstractmethod
+    def send(self, topic, message):
+        """
+        Publish device specific message to the concrete message bus.
+        """
+        pass
+    
+    @abstractmethod
+    def get_response(self, topic, message, timeout):
+        """
+        Sends a message on a specific queue, waits and returns the response
+        """
+        
+    def get_agent_response(self, agent_id, message, timeout):
+        """
+        Sends a message on a specific agent's request queue, waits and returns the response
+        """
+        topic = "{}.request.{}.{}".format(t.BASE_FIELD_QUEUE,self.id, agent_id)
+        self.get_response(topic, message, timeout)
+
+    @abstractmethod
+    def disconnect(self):
+        """
+        Disconnect the device from the concrete message bus.
+        """
+        pass
+
+
+class MessageBusDefinitions:
+    def __init__(
+        self,
+        config: Optional[Union[dict, str]] = None,
+        yamlfile: Optional[Union[str, PathLike]] = None,
+    ):
+        self._buses = dict()
+
+        if config is None and yamlfile is None:
+            raise ValueError("Must have either config specified")
+
+        if config and yamlfile:
+            raise ValueError("Must have at least one of config or yamlfile specified.")
+
+        if yamlfile:
+            if not Path(yamlfile).exists():
+                raise ValueError(f"Invalid path for yamlfile {yamlfile}")
+            with open(yamlfile) as fp:
+                config = yaml.safe_load(fp)
+        elif isinstance(config, str):
+            config = yaml.load(config)
+
+        if config.get("connections"):
+            for con in config.get("connections"):
+                obj = MessageBusDefinition.load(con)
+                if self._buses.get(obj.id):
+                    raise ValueError(f"Duplicate messagebus id specified for {obj.id}")
+                self._buses[obj.id] = obj
+        else:
+            obj = MessageBusDefinition.load(config)
+            self._buses[obj.id] = obj
+
+        self._iterator = None
+
+    def get(self, id: str) -> Union[MessageBusDefinition, None]:
+        return self._buses.get(id)
+
+    def __iter__(self):
+        if self._iterator is None:
+            self._iterator = iter(self._buses)
+        return self._iterator
+
+    def __next__(self) -> MessageBusDefinition:
+        try:
+            definition = next(self._iterator)
+        except StopIteration:
+            self._iterator = None
+            return None
+        else:
+            return definition
+
+
+class DeviceFieldInterface:
+    def __init__(
+        self,
+        id: str,
+        field_bus: FieldMessageBus,
+        publish_topic: str,
+        control_topic: str,
+    ):
+        self._id = id
+        self._field_bus = field_bus
+        self._publish_topic = publish_topic
+        self._control_topic = control_topic
+        self._running = False
+
+    @property
+    def id(self):
+        return self._id
+
+    @property
+    def publish_topic(self):
+        return self._publish_topic
+
+    @property
+    def control_topic(self):
+        return self._control_topic
+
+    def publish_field_bus(self, cim_data):
+        self._field_bus.publish(topic=self._publish_topic, data=cim_data)
+
+    @abstractmethod
+    def on_control_message(self, message):
+        pass
+
+    @abstractmethod
+    def on_state_change(self):
+        """
+        This event should be triggered by the device/protocol that
+        is used.  
+        """
+        pass

gridappsd_field_bus-2023.5/pyproject.toml

@@ -0,0 +1,39 @@
+[tool.poetry]
+name = "gridappsd-field-bus"
+version = "2023.5"
+description = "GridAPPS-D Field Bus Implementation"
+authors = [
+    "C. Allwardt <3979063+craig8@users.noreply.github.com>",
+    "P. Sharma <poorva.sharma@pnnl.gov",
+    "A. Fisher <andrew.fisher@pnnl.gov"
+]
+license = "BSD-3-Clause"
+
+repository = "https://github.com/GRIDAPPSD/gridappsd-python"
+homepage = "https://gridappsd.readthedocs.io"
+
+keywords = ["gridappsd", "grid", "activmq", "powergrid", "simulation", "library"]
+
+readme = "README.md"
+
+
+packages = [
+    { include = 'gridappsd'}
+]
+
+
+[tool.poetry.dependencies]
+python = ">=3.7.9,<4.0"
+gridappsd-python = "^2023.5"
+cim-graph = "^2023.5.1a3"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^6.2.2"
+pytest-html = "^3.1.1"
+mock = "^4.0.3"
+docker = "^4.4.4"
+yapf = "^0.32.0"
+
+[build-system]
+requires = ["poetry-core>=1.2.0"]
+build-backend = "poetry.core.masonry.api"