SIENTIAPDE-1318

Refactor project structure and update configurations

- Deleted the empty `__init__.py` file to clean up the project structure.
- Renamed the project from "laborious" to "ingestor" in `pyproject.toml`, updating the description accordingly.
- Improved type hints and conditional checks in the `Ingestor`, `DataManager`, `IngestorManager`, and `OpcManager` classes for better code clarity and type safety.
- Enhanced error handling and assertions in various methods to ensure robustness.
- Updated unit tests to reflect changes in class names and error handling improvements.

ingestor/managers/data_manager.py

@@ -129,7 +129,7 @@ class DataManager(BaseActivity):
         self.connection_string = mongo_connection_string
         self.database = mongo_database
 
-        self.mongo_client = MongoClient(self.connection_string)
+        self.mongo_client: MongoClient = MongoClient(self.connection_string)
         self.mongo_client.server_info()
 
         self.metadata = metadata
@@ -176,7 +176,7 @@ class DataManager(BaseActivity):
     def __del__(self):
         self.shutdown()
 
-    def delivery_report(self, msg: str):
+    def delivery_report(self, msg):
         """
         Callback for successful Kafka message delivery reports.
 
@@ -191,7 +191,7 @@ class DataManager(BaseActivity):
             f'Record successfully produced to {msg.topic} [{msg.partition}] at offset {msg.offset}'
         )
 
-    def delivery_error(self, err: str):
+    def delivery_error(self, err):
         """
         Callback for Kafka message delivery error reports.
 
@@ -218,7 +218,7 @@ class DataManager(BaseActivity):
             Exception: If there is an error during message delivery, it will be handled by the `delivery_error` callback.
         """
 
-        if self.export_to_kafka:
+        if self.export_to_kafka and self.kafka_producer:
             try:
                 self.logger.debug(f'Publishing message to topic {topic}: {data}')
                 self.kafka_producer.send(topic=topic, value=data).add_callback(

ingestor/managers/ingestor_manager.py

@@ -72,10 +72,10 @@ class IngestorManager(BaseActivity):
         notification_handler: NotificationHandler,
         export_to_kafka: bool = False,
     ):
-        redis_host = redis_data.get('host')
-        redis_port = redis_data.get('port')
-        redis_username = redis_data.get('username', None)
-        redis_password = redis_data.get('password', None)
+        redis_host: str = redis_data['host']
+        redis_port: int = int(redis_data['port'])
+        redis_username: str | None = redis_data.get('username', None)
+        redis_password: str | None = redis_data.get('password', None)
 
         self.data_manager = DataManager(
             kafka_servers=kafka_servers,
@@ -86,7 +86,7 @@ class IngestorManager(BaseActivity):
             logger=logger,
             notification_handler=notification_handler,
         )
-        self.opc_managers = {}
+        self.opc_managers: dict = {}
         self.resource_manager = ResourceManager(
             host=redis_host,
             port=redis_port,
@@ -100,8 +100,8 @@ class IngestorManager(BaseActivity):
         )
         self.number_of_slots = 0
         self.poll_interval = poll_interval
-        self.managed_tags = {}
-        self.opc_servers = {}
+        self.managed_tags: dict = {}
+        self.opc_servers: dict = {}
 
         self.metadata = metadata
 
@@ -457,8 +457,7 @@ class IngestorManager(BaseActivity):
             - Logs informational messages for updated slot configurations.
         """
 
-        removed_slots = []
-        update = {}
+        removed_slots: list[str] = []
         for slot, _slot_config in self.managed_tags.items():
             self.resource_manager.renew_tag_lease(slot)
             update = self.resource_manager.get_tag_slot(slot)

ingestor/managers/opc_manager.py

@@ -64,21 +64,21 @@ class OpcManager(BaseActivity):
         server_uri: str,
         notification_handler: NotificationHandler,
         metadata: dict,
-        cert_path: str = None,
-        private_key_path: str = None,
-        server_cert_path: str = None,
+        cert_path: str | None = None,
+        private_key_path: str | None = None,
+        server_cert_path: str | None = None,
     ):
         self.url = url
         self.name = name
         self.server_uri = server_uri
-        self.data_queue = {}
+        self.data_queue: dict = {}
         self.non_receive_count = 0
-        self.client = None
+        self.client: Client | None = None
         self.cert_path = cert_path
         self.private_key_path = private_key_path
         self.server_cert_path = server_cert_path
-        self.nodes = {}
-        self.subscriptions = {}
+        self.nodes: dict = {}
+        self.subscriptions: dict = {}
         self.data_manager = data_manager
         self.metadata = metadata
 
@@ -147,20 +147,21 @@ class OpcManager(BaseActivity):
             raise ValueError(
                 'Certificate and private key paths must be provided for secure connection.'
             )
-        cert = Path(self.cert_path)
-        private_key = Path(self.private_key_path)
+        cert = Path(self.cert_path) if self.cert_path else None
+        private_key = Path(self.private_key_path) if self.private_key_path else None
         server_cert = Path(self.server_cert_path) if self.server_cert_path else None
 
-        await self.client.set_application_uri(self.server_uri)
-        self.logger.info('Setting security...')
-        await self.client.set_security(
-            SecurityPolicyBasic256,
-            certificate=str(cert),
-            private_key=str(private_key),
-            server_certificate=str(server_cert),
-        )
-        await self.client.set_secure_channel_timeout(10000000)
-        await self.client.set_session_timeout(10000000)
+        if self.client:
+            await self.client.set_application_uri(self.server_uri)
+            self.logger.info('Setting security...')
+            await self.client.set_security(
+                SecurityPolicyBasic256,
+                certificate=str(cert),
+                private_key=str(private_key),
+                server_certificate=str(server_cert),
+            )
+            await self.client.set_secure_channel_timeout(10000000)
+            await self.client.set_session_timeout(10000000)
 
     async def connect(self):
         """
@@ -187,6 +188,7 @@ class OpcManager(BaseActivity):
         metrics.OPC_CONNECTIONS_TOTAL.labels(pod_id=self.pod_id, server_name=self.name).inc()
         try:
             self.client = Client(self.url, watchdog_intervall=3600000)
+            assert self.client is not None  # Informa ao mypy que client não é None
             self.client.name = self.pod_id
             if self.cert_path:
                 await self.set_security()
@@ -268,6 +270,7 @@ class OpcManager(BaseActivity):
 
         self.logger.info(f'Subscribing to {subscription} on {self.name}...')
         self.logger.info(f'Subscribing to nodes: {nodes}')
+        assert self.client is not None  # Informa ao mypy que client não é None
         addr_nodes = [self.client.get_node(n) for n in nodes]
         self.logger.debug(f'Addr nodes: {addr_nodes}')
         self.nodes.update(nodes)
@@ -400,7 +403,8 @@ class OpcManager(BaseActivity):
             'value': value,
         }
 
-        _a = [self.data_manager.publish(e, data) for e in self.nodes[tag]['topics']]
+        for topic in self.nodes[tag]['topics']:
+            self.data_manager.publish(topic, data)
 
     def check_cycles(self):
         """

ingestor/managers/resource_manager.py

@@ -154,7 +154,7 @@ class ResourceManager(BaseActivity):
             )
             raise
 
-    def get(self, key: str) -> dict:
+    def get(self, key: str) -> dict | None:
         """
         Retrieve a value from Redis by its key and return it as a dictionary.
 
@@ -176,7 +176,7 @@ class ResourceManager(BaseActivity):
         history = self._execute_redis_op('get', self.redis.get, key)
         return json.loads(history) if history else None
 
-    def get_tag_slot(self, id: str) -> dict:
+    def get_tag_slot(self, tag_id: str) -> dict | None:
         """
         Retrieve the tag slot information for a given ID.
 
@@ -194,7 +194,7 @@ class ResourceManager(BaseActivity):
         and delegates to the get() method for the actual Redis operation.
         """
 
-        return self.get(f'slot:opc_tags:{id}')
+        return self.get(f'slot:opc_tags:{tag_id}')
 
     def ingestor_heartbeat(self) -> None:
         """