PyAutomationIO 1.1.1__py3-none-any.whl

automation/dbmodels/users.py

@@ -0,0 +1,259 @@
+import secrets
+from peewee import CharField, IntegerField, ForeignKeyField
+from ..dbmodels.core import BaseModel
+from ..modules.users.users import Users as CVTUsers
+from ..modules.users.roles import Roles as CVTRoles
+from ..modules.users.roles import Role
+from ..modules.users.users import User
+from werkzeug.security import generate_password_hash, check_password_hash
+
+users = CVTUsers()
+roles = CVTRoles()
+
+class Roles(BaseModel):
+    
+    identifier = CharField(unique=True, max_length=16)
+    name = CharField(unique=True, max_length=32)
+    level = IntegerField()
+    __defaults__ = [
+        {"name": "sudo", "level": 0, "identifier": secrets.token_hex(4)},
+        {"name": "admin", "level": 1, "identifier": secrets.token_hex(4)},
+        {"name": "supervisor", "level": 2, "identifier": secrets.token_hex(4)},
+        {"name": "operator", "level": 10, "identifier": secrets.token_hex(4)},
+        {"name": "auditor", "level": 100, "identifier": secrets.token_hex(4)},
+        {"name": "guest", "level": 256, "identifier": secrets.token_hex(4)}
+    ]
+
+    @classmethod
+    def create(cls, name:str, level:int, identifier:str)->tuple:
+        
+        name = name.upper()
+
+        if cls.name_exist(name):
+
+            return None, f"role {name} is already used"
+
+        if cls.identifier_exist(identifier):
+                
+            return None, f"identifier {identifier} is already used"
+        
+        query = cls(name=name, level=level, identifier=identifier)
+        query.save()
+        
+        return query, f"Role creation successful"
+
+    @classmethod
+    def read_by_name(cls, name:str):
+      
+        return cls.get_or_none(name=name.upper())
+    
+    @classmethod
+    def read_by_identifier(cls, identifier:str):
+      
+        return cls.get_or_none(identifier=identifier)
+
+    @classmethod
+    def name_exist(cls, name:str)->bool:
+        
+        return True if cls.get_or_none(name=name.upper()) else False
+    
+    @classmethod
+    def identifier_exist(cls, identifier:str)->bool:
+
+        return True if cls.get_or_none(identifier=identifier) else False
+    
+    @classmethod
+    def read_names(cls)->list:
+
+        return [role.name for role in cls.select()]
+    
+    @classmethod
+    def fill_cvt_roles(cls):
+        r"""
+        Documentation here
+        """
+        for role in cls.select():
+
+            _role = Role(
+                name=role.name,
+                level=role.level,
+                identifier=role.identifier
+            )
+
+            roles.add(role=_role)
+
+    def serialize(self)->dict:
+        r"""
+        Serialize database record to a jsonable object
+        """
+
+        return {
+            "id": self.id,
+            "identifier": self.identifier,
+            "name": self.name,
+            "level": self.level
+        }
+
+
+class Users(BaseModel):
+    
+    identifier = CharField(unique=True, max_length=16)
+    username = CharField(unique=True, max_length=64)
+    role = ForeignKeyField(Roles, backref='users', on_delete='CASCADE')
+    email = CharField(unique=True, max_length=128)
+    password = CharField()
+    token = CharField(null=True)
+    name = CharField(max_length=64, null=True)
+    lastname = CharField(max_length=64, null=True)
+
+    @classmethod
+    def create(cls, user:User)-> dict:
+
+        if cls.username_exist(user.username):
+
+            return None, f"username {user.username} is already used"
+
+        if cls.email_exist(user.email):
+
+            return None, f"email {user.email} is already used"
+        
+        if cls.identifier_exist(user.identifier):
+
+            return None, f"identifier {user.identifier} is already used"
+        
+        query = cls(
+            username=user.username,
+            role=Roles.read_by_name(name=user.role.name),
+            email=user.email,
+            password=user.password,
+            identifier=user.identifier,
+            name=user.name,
+            lastname=user.lastname,
+            token=user.token
+            )
+        query.save()
+
+        return query, f"User creation successful"
+    
+    @classmethod
+    def login(cls, password:str, username:str="", email:str=""):
+        r"""
+        Documentation here
+        """
+        if username:
+
+            user = cls.get_or_none(username=username)
+
+        if email:
+
+            user = cls.get_or_none(email=email)
+        
+        if user:
+
+            if user.decode_password(password):
+                
+                if not user.token:
+                    
+                    user.token = cls.encode(secrets.token_hex(4))
+                    user.save()
+                
+                users.login(password=password, token=user.token, username=username, email=email)
+
+                return user, f"Login successfull"
+
+            return None, f"Invalid credentials" 
+
+        return None, f"Invalid Username or Email"      
+    
+    @classmethod
+    def logout(cls, token:str):
+        r"""
+        Documentation here
+        """
+        user = cls.get_or_none(token=token)
+
+        if user:
+
+            user.token = None
+            user.save()
+
+            return user, "Logout successfull"
+        
+        return None, "Invalid Token"
+
+    @classmethod
+    def read_by_username(cls, username:str):
+   
+        return cls.get_or_none(username=username)
+
+    @classmethod
+    def read_by_name(cls, name:str):
+   
+        return cls.get_or_none(name=name)
+
+    @classmethod
+    def name_exist(cls, name:str)->bool:
+
+        return True if cls.get_or_none(name=name) else False
+    
+    @classmethod
+    def username_exist(cls, username:str)->bool:
+
+        return True if cls.get_or_none(username=username) else False
+    
+    @classmethod
+    def email_exist(cls, email:str)->bool:
+
+        return True if cls.get_or_none(email=email) else False
+    
+    @classmethod
+    def identifier_exist(cls, identifier:str)->bool:
+
+        return True if cls.get_or_none(identifier=identifier) else False
+    
+    @classmethod
+    def encode(cls, value:str)->str:
+
+        return generate_password_hash(value)
+    
+
+    def decode_password(self, password:str)->str:
+
+        return check_password_hash(self.password, password)
+    
+    def decode_token(self, token:str)->str:
+
+        return check_password_hash(self.token, token)
+    
+    @classmethod
+    def fill_cvt_users(cls):
+        r"""
+        Documentation here
+        """
+        for user in cls.select():
+
+            users.signup(
+                username=user.username,
+                role_name=user.role.name,
+                email=user.email,
+                password=user.password,
+                name=user.name,
+                lastname=user.lastname,
+                identifier=user.identifier,
+                encode_password=False
+            )
+
+    def serialize(self)-> dict:
+        r"""
+        Serialize database record to a jsonable object
+        """
+
+        return {
+            "id": self.id,
+            "identifier": self.identifier,
+            "username": self.username,
+            "email": self.email,
+            "role": self.role.serialize(),
+            "name": self.name,
+            "lastname": self.lastname
+        }

automation/extensions/__init__.py

@@ -0,0 +1,15 @@
+from .api import Api
+from .cors import Cors
+
+_api = Api()
+_cors = Cors()
+
+def init_app(app):
+    """
+    Application extensions initialization.
+    """
+    extensions = ( _api, _cors)
+
+    for extension in extensions:
+        
+        extension.init_app(app)

automation/extensions/api.py

@@ -0,0 +1,149 @@
+from flask import Blueprint, request
+from flask_restx import abort
+from flask_restx import Api as API
+from ..singleton import Singleton
+from functools import wraps
+import logging, jwt
+from ..utils.decorators import decorator
+from ..dbmodels.users import Users
+from ..modules.users.users import Users as CVTUsers
+
+
+authorizations = {
+    'apikey' : {
+        'type' : 'apiKey',
+        'in' : 'header',
+        'name' : 'X-API-KEY'
+    }
+}
+
+
+blueprint = Blueprint('api', __name__, url_prefix='/api')
+
+api = API(blueprint, version='1.0', 
+        title='PyAutomation API',
+        description="""
+        This API groups all namespaces defined in every module's resources for PyAutomation App.
+        """, 
+        doc='/docs',
+        authorizations=authorizations
+    )
+
+users = CVTUsers()
+
+class Api(Singleton):
+
+    def __init__(self):
+
+        self.app = None
+
+    def init_app(self, app):
+        r"""
+        Documentation here
+        """
+        self.app = self.create_api(app)
+
+        return app
+
+    def create_api(self, app):
+        r"""
+        Documentation here
+        """
+        app.register_blueprint(blueprint)
+
+        return api
+    
+    @staticmethod
+    def verify_tpt(tpt:str):
+        r"""
+        Verify Third Party Token
+        """
+        from .. import server
+        try:
+
+            jwt.decode(tpt, server.config["TPT_TOKEN"], algorithms=["HS256"])
+
+            return True
+
+        except:
+
+            return 
+        
+    @classmethod
+    def validate_reqparser(cls, reqparser):
+        def _validate_reqparser(f):
+                
+            @wraps(f)
+            def decorated(*args, **kwargs):
+                
+                reqparser.parse_args() 
+                result = f(*args, **kwargs)
+                return result
+
+            return decorated
+        
+        return _validate_reqparser
+    
+    @classmethod
+    def token_required(cls, auth:bool=False):
+        
+        def _token_required(f):
+            
+            @wraps(f)
+            def decorated(*args, **kwargs):
+                try:
+
+                    if auth:
+
+                        token = None
+
+                        if 'X-API-KEY' in request.headers:
+                            
+                            token = request.headers['X-API-KEY']
+
+                        elif 'Authorization' in request.headers:
+                            
+                            token = request.headers['Authorization'].split('Token ')[-1]
+
+                        if not token:
+                            
+                            return {'message' : 'Key is missing.'}, 401
+                        
+                        user = Users.get_or_none(token=token)
+
+                        if user:
+
+                            return f(*args, **kwargs)
+
+                        if Api.verify_tpt(tpt=token):
+                    
+                            return f(*args, **kwargs)
+
+                        return {'message' : 'Invalid token'}, 401                  
+                
+                except Exception as err:
+                    logger = logging.getLogger("pyautomation")
+                    logger.error(str(err))
+
+            return decorated
+
+        return _token_required
+    
+    @classmethod
+    def get_current_user(cls):
+
+        token = None
+
+        if 'X-API-KEY' in request.headers:
+                            
+            token = request.headers['X-API-KEY']
+
+        elif 'Authorization' in request.headers:
+            
+            token = request.headers['Authorization'].split('Token ')[-1]
+
+        if token:
+
+            return users.get_active_user(token=token)
+
+        return None

automation/extensions/cors.py

@@ -0,0 +1,18 @@
+from flask_cors import CORS
+from ..singleton import Singleton
+
+
+class Cors(Singleton):
+
+    def __init__(self):
+        
+        self.app = None
+
+    def init_app(self, app):
+        r"""
+        Documentation here
+        """
+
+        self.app = CORS(app, resources={r"/*": {"origins": "*"}})
+
+        return app

automation/filter/__init__.py

@@ -0,0 +1,19 @@
+from ..utils.decorators import decorator
+
+
+@decorator
+def filter(func, args, kwargs):
+    r"""
+    Documentation here
+    """
+    cvt = args[0]
+    tag_id = kwargs["id"]
+    value = kwargs["value"]
+    tag = cvt.get_tag(id=tag_id)
+    if tag.gaussian_filter:
+        
+        kwargs["value"] = tag.filter(value, threshold=tag.gaussian_filter_threshold, r_value=tag.gaussian_filter_r_value)
+
+        return func(*args, **kwargs)
+    
+    return func(*args, **kwargs)

automation/iad/__init__.py

@@ -0,0 +1,3 @@
+from .frozen_data import iad_frozen_data
+from .out_of_range import iad_out_of_range
+from .outliers import iad_outlier

automation/iad/frozen_data.py

@@ -0,0 +1,54 @@
+from ..utils.decorators import decorator
+from ..buffer import Buffer
+import math
+
+data = dict()
+
+def __iad(data:Buffer, tag_name:str):
+    r"""
+    Frozen Data Algorithm
+    """
+    from ..managers.alarms import AlarmManager
+    alarm_manager = AlarmManager()
+    alarm = alarm_manager.get_alarm_by_name(name=f"alarm.iad.{tag_name}")
+
+    if alarm:
+        if alarm.state.alarm_status.lower() == "not active":
+
+            mean = sum(data) / len(data)
+            variance = sum((x - mean) ** 2 for x in data) / len(data)
+            std_dev = math.sqrt(variance)
+            
+            if abs(std_dev) < 0.001:
+                
+                alarm.description = f"Frozen data anomaly"
+                alarm.abnormal_condition()
+            
+            else:
+                
+                alarm.description = ""
+                alarm.normal_condition()
+
+@decorator
+def iad_frozen_data(func, args, kwargs):
+    r"""
+    Documentation here
+    """
+    
+    cvt = args[0]
+    tag_id = kwargs["id"]
+    value = kwargs["value"]
+    tag = cvt.get_tag(id=tag_id)
+    if tag.frozen_data_detection:
+        
+        if tag.name not in data:
+            
+            data[tag.name] = Buffer()
+
+        data[tag.name](value)
+        # Apply IAD logic
+        if len(data[tag.name]) >= data[tag.name].size:
+            
+            __iad(data[tag.name], tag_name=tag.name)
+
+    return func(*args, **kwargs)

automation/iad/out_of_range.py

@@ -0,0 +1,51 @@
+from ..utils.decorators import decorator
+from ..buffer import Buffer
+
+data = dict()
+
+def __iad(data:Buffer, tag_name:str):
+    r"""
+    Out Of Range Algorithm
+    """
+    from ..managers.alarms import AlarmManager
+    alarm_manager = AlarmManager()
+    alarm = alarm_manager.get_alarm_by_name(name=f"alarm.iad.{tag_name}")
+    if alarm:
+        if alarm.state.alarm_status.lower() == "not active":
+
+            mean = sum(data) / len(data)
+            # variance = sum((x - mean) ** 2 for x in data) / len(data)
+            # std_dev = math.sqrt(variance)
+            
+            # if abs(std_dev) < 0.01:
+                
+            #     alarm.description = f"Out Of Range anomaly"
+            #     alarm.abnormal_condition()
+            
+            # else:
+                
+            #     alarm.description = ""
+            #     alarm.normal_condition()
+
+@decorator
+def iad_out_of_range(func, args, kwargs):
+    r"""
+    Documentation here
+    """
+    cvt = args[0]
+    tag_id = kwargs["id"]
+    value = kwargs["value"]
+    tag = cvt.get_tag(id=tag_id)
+    if tag.out_of_range_detection:
+        
+        if tag.name not in data:
+            
+            data[tag.name] = Buffer()
+        
+        data[tag.name](value)
+        # Apply IAD logic
+        if len(data[tag.name]) >= data[tag.name].size:
+            
+            __iad(data[tag.name], tag_name=tag.name)
+
+    return func(*args, **kwargs)

automation/iad/outliers.py

@@ -0,0 +1,51 @@
+from ..utils.decorators import decorator
+from ..buffer import Buffer
+
+data = dict()
+
+def __iad(data:Buffer, tag_name:str):
+    r"""
+    Outliers Algorithm
+    """
+    from ..managers.alarms import AlarmManager
+    alarm_manager = AlarmManager()
+    alarm = alarm_manager.get_alarm_by_name(name=f"alarm.iad.{tag_name}")
+    if alarm:
+        if alarm.state.alarm_status.lower() == "not active":
+
+            mean = sum(data) / len(data)
+            # variance = sum((x - mean) ** 2 for x in data) / len(data)
+            # std_dev = math.sqrt(variance)
+            
+            # if abs(std_dev) < 0.01:
+                
+            #     alarm.description = f"Outlier anomaly"
+            #     alarm.abnormal_condition()
+            
+            # else:
+                
+            #     alarm.description = ""
+            #     alarm.normal_condition()
+
+@decorator
+def iad_outlier(func, args, kwargs):
+    r"""
+    Documentation here
+    """
+    cvt = args[0]
+    tag_id = kwargs["id"]
+    value = kwargs["value"]
+    tag = cvt.get_tag(id=tag_id)
+    if tag.outlier_detection:
+        
+        if tag.name not in data:
+            
+            data[tag.name] = Buffer()
+    
+        data[tag.name](value)
+        # Apply IAD logic
+        if len(data[tag.name]) >= data[tag.name].size:
+            
+            __iad(data[tag.name], tag_name=tag.name)
+
+    return func(*args, **kwargs)