PyAutomationIO 0.0.0__py3-none-any.whl

automation/workers/logger.py

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+"""rackio/workers/logger.py
+
+This module implements Logger Worker.
+"""
+import logging, time, datetime, os, shutil
+from .worker import BaseWorker
+from ..managers import DBManager
+from ..opcua.models import Client
+from ..logger.datalogger import DataLoggerEngine
+from ..tags.cvt import CVTEngine
+import sqlite3
+from peewee import SqliteDatabase
+from ..dbmodels.tags import TagValue
+from ..dbmodels.alarms import AlarmSummary
+from ..dbmodels.events import Events
+from ..dbmodels.logs import Logs
+
+
+class LoggerWorker(BaseWorker):
+
+    def __init__(self, manager:DBManager, period:int=5.0):
+
+        super(LoggerWorker, self).__init__()
+        
+        self._manager = manager
+        self._period = period
+        self.logger = DataLoggerEngine()
+        self.cvt = CVTEngine()
+        self.sqlite_db = None
+        self.sqlite_db_name = None
+
+    def sqlite_db_backup(self):
+        if self.sqlite_db:
+            file_size_mb = os.path.getsize(self.sqlite_db_name) / 1024 / 1024 
+            if file_size_mb > 1 * 1024: # 1 Gb: 
+                timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+                name = self.sqlite_db_name.split(".db")[0]
+                name = name.split(os.path.sep)[-1]
+                backup_file = os.path.join(".", "db", "backups", f"{name}_{timestamp}.db")
+                shutil.copy2(os.path.join(".", "db", "app.db"), backup_file)
+                logger = logging.getLogger("pyautomation")
+                logger.info(f"Backup creado: {backup_file}")
+                # Empty TagValue 
+                query = TagValue.delete()
+                query.execute()
+                # Empty Alarm Summary
+                query = AlarmSummary.delete()
+                query.execute()
+                # Empty Events
+                query = Events.delete()
+                query.execute()
+                # Empty Logs
+                query = Logs.delete()
+                query.execute()
+                # Execute Vacuum to compact DB
+                self.sqlite_db.close()
+                conn = sqlite3.connect(self.sqlite_db_name)
+                cur = conn.cursor()
+                cur.execute("VACUUM;")
+                conn.commit()
+                conn.close()
+                # Reopen DB connection
+                from ..dbmodels import proxy
+                self._db = self._manager.get_db()
+                proxy.initialize(self._db)
+
+        else:
+            db = self.logger.logger.get_db()
+            if db:
+                if isinstance(db, SqliteDatabase):
+                    self.sqlite_db = db
+                    self.sqlite_db_name = db.database
+
+
+    def check_opcua_connection(self):
+        from automation import PyAutomation
+        app = PyAutomation()
+        if app.opcua_client_manager._clients:
+            for _, opcua_client in app.opcua_client_manager._clients.items():
+
+                if isinstance(opcua_client, Client):
+                    
+                    opcua_client.reconnect()
+        else:
+            
+            app.load_opcua_clients_from_db()
+
+    def get_tags_from_queue(self, _queue):
+        from .. import SEGMENT, MANUFACTURER
+        tags = list()
+        while not _queue.empty():
+
+            item = _queue.get(block=False)
+            tag_name = item["tag"]
+            tag = self.cvt.get_tag_by_name(name=tag_name)
+            if tag:
+
+                if tag.manufacturer==MANUFACTURER and tag.segment==SEGMENT:
+
+                    value = item['value']
+                    timestamp = item["timestamp"]
+                    tags.append({"tag":tag_name, "value":value, "timestamp":timestamp})
+
+                elif not MANUFACTURER and not SEGMENT:
+
+                    value = item['value']
+                    timestamp = item["timestamp"]
+                    tags.append({"tag":tag_name, "value":value, "timestamp":timestamp})
+
+        return tags
+
+    def reconnect_to_db(self):
+        from automation import PyAutomation
+        app = PyAutomation()
+        
+        if self.db_reconnection:
+            
+            logging.critical("Trying reconnect to DB...")
+        
+        self.db_reconnection = False
+        db_connected = app.reconnect_to_db()
+                
+        if db_connected:
+            
+            logging.critical("Reconnection successfully")
+            self.db_reconnection = True
+
+    def run(self):
+        r"""
+        Documentation here
+        """       
+        _queue = self._manager.get_queue()
+        self.db_reconnection = True
+
+        while True:
+
+            if self.db_reconnection:
+
+                db_connection = self.logger.logger.check_connectivity()
+            
+                if db_connection:
+                    self.sqlite_db_backup()
+                    tags = self.get_tags_from_queue(_queue=_queue)
+            
+                    if tags:
+                        
+                        self.logger.write_tags(tags=tags)
+                    
+                else:
+
+                    self.reconnect_to_db()
+            
+            else:
+
+                self.reconnect_to_db()
+
+            self.check_opcua_connection()
+
+            if self.stop_event.is_set():
+                logging.critical("Alarm worker shutdown successfully!")
+                break
+
+            time.sleep(self._period)

automation/workers/state_machine.py

@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+"""automation/workers/state.py
+
+This module implements State Machine Worker.
+"""
+import heapq
+import logging
+import time
+from collections import deque
+from threading import Thread
+from .worker import BaseWorker
+
+
+class MachineScheduler():
+
+    def __init__(self):
+
+        self._ready = deque()
+        self._sleeping = list()
+        self._sequence = 0
+        self.last = None
+        self._stop = False
+
+    def call_soon(self, func):
+        
+        self._ready.append(func)
+
+    def call_later(self, delay, func, machine):
+        self._sequence += 1
+        deadline = time.time() + delay
+        heapq.heappush(self._sleeping, (deadline, self._sequence, func, machine))
+
+    def stop(self):
+
+        self._stop = True
+    
+    def run(self):
+
+        self.set_last()
+        
+        while self._ready or self._sleeping:
+
+            if self._stop:
+                break
+
+            if not self._ready and self._sleeping:
+                deadline, _, func, machine = heapq.heappop(self._sleeping)
+                self.sleep_elapsed(machine)
+                
+                self._ready.append(func)
+
+            while self._ready:
+                func = self._ready.popleft()
+                func()
+
+    def set_last(self):
+
+        self.last = time.time()
+
+        return self.last
+
+    def sleep_elapsed(self, machine):
+        elapsed = time.time() - self.last
+        interval = machine.get_interval()
+        
+        try:
+            time.sleep(interval - elapsed)
+            self.set_last()
+        except ValueError:
+            self.set_last()
+            logger = logging.getLogger("pyautomation")
+            logger.warning(f"State Machine: {machine.name.value} NOT executed on time - Execution Interval: {interval} - Elapsed: {elapsed}")
+
+
+class SchedThread(Thread):
+
+    def __init__(self, machine):
+
+        super(SchedThread, self).__init__()
+
+        self.machine = machine
+
+    def stop(self):
+
+        self.scheduler.stop()
+
+    def loop_closure(self, machine, scheduler:MachineScheduler):
+
+        def loop():
+            machine.loop()
+            interval = machine.get_interval()
+            scheduler.call_later(interval, loop, machine)
+    
+        return loop
+    
+    def target(self, machine):
+        scheduler = MachineScheduler()
+        self.scheduler = scheduler
+        func = self.loop_closure(machine, scheduler)
+        scheduler.call_soon(func)
+        scheduler.run() 
+
+    def run(self):
+        
+        self.target(self.machine)
+
+
+class AsyncStateMachineWorker(BaseWorker):
+
+    def __init__(self):
+
+        super(AsyncStateMachineWorker, self).__init__()
+        self._machines = list()
+        self._schedulers = list()
+        self.jobs = list()
+
+    def add_machine(self, machine):
+
+        self._machines.append(machine)
+
+    def run(self):
+
+        for machine in self._machines:
+
+            sched = SchedThread(machine)
+            self._schedulers.append(sched)
+
+        for sched in self._schedulers:
+
+            sched.daemon = True
+            sched.start()
+
+    def join(self, machine):
+
+        sched = SchedThread(machine)
+        self._schedulers.append(sched)
+        sched.daemon = True
+        sched.start()
+
+    def drop(self, machine):
+        r"""
+        Documentation here
+        """
+        sched_to_drop = None
+        for index, sched in enumerate(self._schedulers):
+            if machine==sched.machine:
+
+                sched_to_drop = self._schedulers.pop(index)
+                break
+        
+        if sched_to_drop:
+            sched.stop()
+
+    def stop(self):
+
+        for sched in self._schedulers:
+            try:
+                sched.stop()
+            except Exception as e:
+                message = "Error on async scheduler stop"
+                logger = logging.getLogger("pyautomation")
+                logger.error(f"{message} - {e}")
+    
+
+class StateMachineWorker(BaseWorker):
+
+    def __init__(self, manager):
+
+        super(StateMachineWorker, self).__init__()
+        
+        self._manager = manager
+        self._sync_scheduler = MachineScheduler()
+        self._async_scheduler = AsyncStateMachineWorker()
+        self.jobs = list()
+
+    def loop_closure(self, machine):
+        
+        self._machine = machine
+
+        def loop():
+            machine.loop()
+            interval = machine.get_interval()
+            self._sync_scheduler.call_later(interval, loop, machine)
+
+        return loop
+
+    def run(self):
+        
+        for machine, interval, mode in self._manager.get_machines():
+    
+            if mode == "async":
+                
+                self._async_scheduler.add_machine(machine)                
+                
+            else:
+
+                func = self.loop_closure(machine)
+                self._sync_scheduler.call_soon(func)
+
+        self._async_scheduler.run()
+        self._sync_scheduler.run()
+
+    def stop(self):
+        
+        self._async_scheduler.stop()
+        self._sync_scheduler.stop()
+    

automation/workers/worker.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""workers/worker.py
+
+This module implements all thread classes for workers.
+"""
+from threading import Thread
+from threading import Event as ThreadEvent
+
+
+class BaseWorker(Thread):
+
+    def  __init__(self):
+
+        super(BaseWorker, self).__init__()
+
+        self.stop_event = ThreadEvent()
+
+    def get_stop_event(self):
+
+        return self.stop_event
+
+    def stop(self):
+        
+        self.stop_event.set()
+
+    def __getstate__(self):
+
+        state = self.__dict__.copy()
+        del state['stop_event']
+        return state
+
+    def __setstate__(self, state):
+        
+        self.__dict__.update(state)
+        self.stop_event = ThreadEvent()
+    

pyautomationio-0.0.0.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: PyAutomationIO
+Version: 0.0.0
+Summary: A python library to develop automation continuous tasks using sync or async concurrent threads
+Home-page: https://github.com/know-ai/PyAutomation
+Author: KnowAI
+Author-email: dev.know.ai@gmail.com
+License: GNU AFFERO GENERAL PUBLIC LICENSE
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: System :: Monitoring
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-statemachine==2.4.0
+Requires-Dist: python-statemachine[diagrams]
+Requires-Dist: peewee==3.17.8
+Requires-Dist: psycopg2-binary==2.9.9; sys_platform != "win32"
+Requires-Dist: psycopg2==2.9.9; sys_platform == "win32"
+Requires-Dist: numpy==1.25.0
+Requires-Dist: PyWavelets==1.7.0
+Requires-Dist: dash==2.18.2
+Requires-Dist: dash-bootstrap-components==1.6.0
+Requires-Dist: dash-mantine-components==0.14.7
+Requires-Dist: dash-iconify==0.1.2
+Requires-Dist: opcua==0.98.13
+Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: cryptography==43.0.3
+Requires-Dist: Flask-Cors==5.0.0
+Requires-Dist: flask-restx==1.3.0
+Requires-Dist: Flask-SocketIO==5.4.1
+Requires-Dist: gunicorn==23.0.0
+Requires-Dist: websocket-client==1.8.0
+Requires-Dist: gevent-websocket==0.10.1
+Requires-Dist: PyJWT==2.9.0
+Requires-Dist: pydot==3.0.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# PyAutomation
+
+The development intention of this framework is to provide the ability to develop industrial applications where processes need to be executed concurrently and field data need to be managed for monitoring, control, and supervision applications.
+
+
+
+![Core](docs/img/PyAutomationCore.svg)
+
+In the image above, you can generally see the architecture and interaction of the different modules that make up the framework.
+
+For this, state machines are available that run in the background and concurrently to acquire data by query (DAQ), Acquire Data by Exception (DAS) and any other general purpose state machine.
+
+It has a memory persistence module for real-time variables that we call (CVT, Current Value Table).
+
+There is also an alarm management system
+
+And finally, the disk persistence of the variables to provide functionalities for historical trends of the field variables.
+
+
+# Run Config Page
+
+## Crearte Virtual Environment
+
+```python
+python3 -m venv venv
+. venv/bin/activate
+```
+## Install Dependencies
+
+```python
+pip install --upgrade pip
+pip install -r requirements.txt
+```
+
+## Run Config page
+
+```python
+python run.py
+```
+
+or 
+
+```python
+
+./docker-entrypoint.sh
+```
+
+## Deploy documentation on Development mode With mkautodoc
+
+### Install Wheel
+
+```python
+pip install wheel
+```
+
+### Create PyAutomation's package
+
+Execute this code where is setup.py file
+
+```python
+python3 setup.py bdist_wheel
+```
+
+This create some folders
+
+- build
+- dist
+- PyAutomation.egg-info
+
+### Install PyAutomation Folder
+
+Located into "dist" folder
+
+```python
+pip install dist/PyAutomation-1.0.0-py3-none-any.whl
+```
+
+After that, you can run mkdocs serve
+
+
+# Deploy
+
+Make the following `.env` file:
+
+```
+PORT=5000
+```
+
+## Docker
+
+Export environment variables
+
+```
+export $(grep -v '^#' .env | xargs)
+```
+
+Start the app
+
+```
+sudo docker run -d \
+  --name PyAutomation \
+  -p ${PORT}:${PORT}\
+  -v $(pwd)/temp/db:/app/db \
+  -v $(pwd)/temp/logs:/app/logs \
+  -e PORT=${PORT} \
+  knowai/automation:1.0.0
+```
+
+## Docker Compose
+
+If you want to deploy it using docker compose, make the following `docker-compose.yml` file:
+
+```YaMl
+version: '3.3'
+
+services:
+
+  automation:
+    container_name: "PyAutomation"
+    image: "knowai/automation:1.0.0"
+    restart: always
+    ports:
+      - ${PORT}:${PORT}
+    volumes:
+      - ./temp/db:/app/db
+      - ./temp/logs:/app/logs
+    environment:
+      PORT: ${PORT}
+      OPCUA_SERVER_PORT: ${OPCUA_SERVER_PORT}
+    healthcheck:
+      test: ["CMD-SHELL", "curl --fail -s -k http://0.0.0.0:${PORT}/api/healthcheck/ || curl --fail -s -k https://0.0.0.0:${PORT}/api/healthcheck/ || exit 1"]
+      interval: 15s
+      timeout: 10s
+      retries: 3
+
+```
+
+Start the docker compose file
+
+```
+sudo docker-compose --env-file .env up -d
+```
+
+
+Go to http://host:${PORT} to view the config page