Code Cleanup

    def add_device(self, topology_id: TopologyId, device: Device) -> None:

        topology_uuid = topology_id.topology_uuid.uuid

        device_uuid = device.device_id.device_uuid.uuid

        record_uuid = f'{topology_uuid}:device:{device_uuid}'

        record_uuid = '{:s}:device:{:s}'.format(topology_uuid, device_uuid)

        self._add_record(record_uuid, (topology_id, device))

    def add_link(self, topology_id: TopologyId, link: Link) -> None:

        topology_uuid = topology_id.topology_uuid.uuid

        link_uuid = link.link_id.link_uuid.uuid

        record_uuid = f'{topology_uuid}:link:{link_uuid}'

        record_uuid = '{:s}:link:{:s}'.format(topology_uuid, link_uuid)

        self._add_record(record_uuid, (topology_id, link))

    def add_service(self, topology_id: TopologyId, service: Service) -> None:

        topology_uuid = topology_id.topology_uuid.uuid

        context_uuid = service.service_id.context_id.context_uuid.uuid

        service_uuid = service.service_id.service_uuid.uuid

        record_uuid = f'{topology_uuid}:service:{context_uuid}/{service_uuid}'

        record_uuid = '{:s}:service:{:s}/{:s}'.format(topology_uuid, context_uuid, service_uuid)

        self._add_record(record_uuid, (topology_id, service))

    def add_slice(self, topology_id: TopologyId, slice_: Slice) -> None:

        topology_uuid = topology_id.topology_uuid.uuid

        context_uuid = slice_.slice_id.context_id.context_uuid.uuid

        slice_uuid = slice_.slice_id.slice_uuid.uuid

        record_uuid = f'{topology_uuid}:slice:{context_uuid}/{slice_uuid}'

        record_uuid = '{:s}:slice:{:s}/{:s}'.format(topology_uuid, context_uuid, slice_uuid)

        self._add_record(record_uuid, (topology_id, slice_))

    async def commit(self) -> None:

                dlt_device_id.topology_id.CopyFrom(topology_id)  # pylint: disable=no-member

                dlt_device_id.device_id.CopyFrom(device_id)      # pylint: disable=no-member

                tasks.append(self.dlt_connector_client.RecordDevice(dlt_device_id))

#                await self.dlt_connector_client.RecordDevice(dlt_device_id)

            elif isinstance(dlt_record, Link):

                link_id = dlt_record.link_id

                if self.dlt_connector_client is None: continue

                dlt_link_id.topology_id.CopyFrom(topology_id)    # pylint: disable=no-member

                dlt_link_id.link_id.CopyFrom(link_id)            # pylint: disable=no-member

                tasks.append(self.dlt_connector_client.RecordLink(dlt_link_id))

                #await self.dlt_connector_client.RecordLink(dlt_link_id)

            elif isinstance(dlt_record, Service):

                service_id = dlt_record.service_id

                if self.dlt_connector_client is None: continue

                dlt_service_id.topology_id.CopyFrom(topology_id) # pylint: disable=no-member

                dlt_service_id.service_id.CopyFrom(service_id)   # pylint: disable=no-member

                tasks.append(self.dlt_connector_client.RecordService(dlt_service_id))

                #await self.dlt_connector_client.RecordService(dlt_service_id)

            elif isinstance(dlt_record, Slice):

                slice_id = dlt_record.slice_id

                if self.dlt_connector_client is None: continue

                dlt_slice_id.topology_id.CopyFrom(topology_id)   # pylint: disable=no-member

                dlt_slice_id.slice_id.CopyFrom(slice_id)         # pylint: disable=no-member

                tasks.append(self.dlt_connector_client.RecordSlice(dlt_slice_id))

                #await self.dlt_connector_client.RecordSlice(dlt_slice_id)

            else:

                LOGGER.error(f'Unsupported Record({str(dlt_record)})')