watchguardian 0.1.0__tar.gz

watchguardian-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: watchguardian
+Version: 0.1.0
+Summary: Observability, logging, database, authentication and server utilities for Python applications.
+Author: Brayan de Souza Dias Vaz
+Project-URL: Repository, https://github.com/BrayanDevZN/WatchGuardian
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: aiosqlite==0.22.1
+Requires-Dist: asyncpg==0.32.0
+Requires-Dist: fastapi==0.143.0
+Requires-Dist: opentelemetry-api==1.45.1
+Requires-Dist: pydantic==2.14.0
+Requires-Dist: PyJWT==2.15.1
+Requires-Dist: python-dotenv==1.2.4
+Requires-Dist: redis==8.1.0
+Requires-Dist: requests==2.34.2
+Requires-Dist: SQLAlchemy==2.1.4
+Requires-Dist: uvicorn==0.54.0

watchguardian-0.1.0/WatchGuardian/__init__.py

@@ -0,0 +1 @@
+from src.service.module import Settings, WatchLogs, WatchObs, WatchAuth

watchguardian-0.1.0/WatchGuardian/database.py

@@ -0,0 +1 @@
+from src.service.module import WatchDb, CacheManage

watchguardian-0.1.0/WatchGuardian/server.py

@@ -0,0 +1 @@
+from src.service.module import ClientHttp, WatchServer

watchguardian-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "watchguardian"
+version = "0.1.0"
+description = "Observability, logging, database, authentication and server utilities for Python applications."
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [
+    { name = "Brayan de Souza Dias Vaz" }
+]
+dependencies = [
+    "aiosqlite==0.22.1",
+    "asyncpg==0.32.0",
+    "fastapi==0.143.0",
+    "opentelemetry-api==1.45.1",
+    "pydantic==2.14.0",
+    "PyJWT==2.15.1",
+    "python-dotenv==1.2.4",
+    "redis==8.1.0",
+    "requests==2.34.2",
+    "SQLAlchemy==2.1.4",
+    "uvicorn==0.54.0",
+]
+
+[project.urls]
+Repository = "https://github.com/BrayanDevZN/WatchGuardian"
+
+[project.scripts]
+watchguardian = "src.cli.main:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["WatchGuardian*", "src*"]

watchguardian-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

watchguardian-0.1.0/src/auth/token.py

@@ -0,0 +1,62 @@
+"gera o token jwt"
+
+from src.logs.module import Logs
+logger = Logs(loglevel="SUCCESS")
+
+
+import jwt
+from jwt.exceptions import InvalidSignatureError
+
+class JWT:
+
+    def __init__(self, secret:str) -> None:
+
+        self.secret = secret
+        self.alg = "HS256"
+
+    #Gera o token
+    async def encode(self, payload:dict) -> str:
+
+        try:
+
+            logger.info("Criando token...")
+
+            token=  jwt.encode(
+                key=self.secret,
+                algorithm=self.alg,
+                payload=payload
+            )
+
+            logger.success("Token criado com sucesso!!")
+
+            return token
+
+        except Exception as error:
+
+            logger.error(f"Erro ao gerar token: {error}")
+            raise 
+
+    async def decode(self, token:str) -> dict:
+
+        try:
+
+            logger.info("Decodificando token...")
+
+            payload = jwt.decode(
+                key=self.secret,
+                algorithms=self.alg,
+                jwt=token
+            )
+
+            logger.success("Toekn decodificado com sucesso!!")
+
+            return payload
+
+        except InvalidSignatureError as error:
+
+            logger.error(f"Erro ao decodificar token: {error}")
+            raise
+
+
+
+        

watchguardian-0.1.0/src/cache/connect.py

@@ -0,0 +1,72 @@
+from src.logs.module import Logs
+logger = Logs(loglevel="SUCCESS")
+import time
+"Cria conexão com redis"
+
+from redis import Redis 
+
+class RedisConnect:
+
+    def __init__(self, host:str, port:str|int, password:str|None = None)-> None:
+
+        self.host = host 
+        self.port = port 
+        self.password = password
+
+    #Cria conexão 
+    def _conn(self) -> None:
+
+        try:
+
+            logger.info("Criando conexão com redis...")
+
+            self.client = (Redis(host=self.host, port=self.port, password=self.password, decode_responses=True)
+                           if self.password is not None else 
+                           Redis(host=self.host, port=self.port, decode_responses=True))
+
+            logger.success("Conexão criada!!")
+
+        except Exception as error:
+
+            logger.error(f"Houve um erro ao criar conexão: {error}")
+            raise 
+
+    #testa a conexão
+    def _test(self) -> None:
+
+        countdown = 0
+
+        while True:
+
+            try:
+
+                logger.info("Testando conexão com redis...")
+
+                self.client.ping()
+
+                logger.success("Conexão ok!!")
+
+                break 
+
+            except Exception as error:
+
+                if countdown !=3:
+
+                    logger.warning("Houve um erro na conexão, executando um novo teste em 5 segundos...")
+                    countdown+=1
+                    time.sleep(5)
+                    continue 
+
+                logger.error(f"Houve um erro ao se conectar: {error}")
+                raise 
+
+    #Executa os metodos e retorna conexão
+    def get_client(self) ->Redis:
+
+        self._conn()
+        self._test()
+        return self.client
+    
+
+                
+        

watchguardian-0.1.0/src/cache/control.py

@@ -0,0 +1,175 @@
+"""
+Cria as operações do Redis
+"""
+
+import asyncio
+
+from typing import Any, AsyncIterator
+
+from redis import Redis
+from redis.exceptions import WatchError
+
+from src.logs.module import Logs
+
+
+logger = Logs(loglevel="SUCCESS")
+
+
+class RedisControl:
+
+    def __init__(self, client: Redis) -> None:
+        self.client = client
+
+    async def incr(self, key: str, time: int | None = None) -> int:
+        logger.info(f"Incrementando chave '{key}'...")
+
+        expire = time if time is not None else 60
+
+        while True:
+            try:
+                with self.client.pipeline(transaction=True) as session:
+                    session.watch(key)
+
+                    session.multi()
+                    session.incr(key)
+                    session.expire(key, expire)
+
+                    result = session.execute()
+                    value = result[0]
+
+                    logger.success(f"Chave '{key}' incrementada com sucesso!")
+                    return value
+
+            except WatchError:
+                logger.warning(f"A chave '{key}' foi alterada por outra operação. Tentando novamente...")
+
+            except Exception as error:
+                logger.error(f"Erro ao incrementar chave '{key}': {error}")
+                raise
+
+    async def hash(self, key: str, data: dict, time: int | None = None) -> None:
+        logger.info(f"Salvando hash '{key}'...")
+
+        expire = time if time is not None else 60
+
+        while True:
+            try:
+                with self.client.pipeline(transaction=True) as session:
+                    session.watch(key)
+
+                    session.multi()
+                    session.hset(key, mapping=data)
+                    session.expire(key, expire)
+
+                    session.execute()
+
+                    logger.success(f"Hash '{key}' salvo com sucesso!")
+                    return
+
+            except WatchError:
+                logger.warning(f"O hash '{key}' foi alterado por outra operação. Tentando novamente...")
+
+            except Exception as error:
+                logger.error(f"Erro ao salvar hash '{key}': {error}")
+                raise
+
+    async def read(self, key: str, hash: bool = False) -> Any:
+        logger.info(f"Lendo chave '{key}'...")
+
+        try:
+            with self.client.pipeline(transaction=True) as session:
+                session.multi()
+
+                if hash:
+                    session.hgetall(key)
+                else:
+                    session.get(key)
+
+                result = session.execute()
+                value = result[0]
+
+                logger.success(f"Chave '{key}' lida com sucesso!")
+                return value
+
+        except Exception as error:
+            logger.error(f"Erro ao ler chave '{key}': {error}")
+            raise
+
+    async def delete(self, key: str) -> bool:
+        logger.info(f"Apagando cache '{key}'...")
+
+        while True:
+            try:
+                with self.client.pipeline(transaction=True) as session:
+                    session.watch(key)
+
+                    session.multi()
+                    session.delete(key)
+
+                    result = session.execute()
+                    deleted = bool(result[0])
+
+                    logger.success(f"Cache '{key}' apagado com sucesso!")
+                    return deleted
+
+            except WatchError:
+                logger.warning(f"A chave '{key}' foi alterada antes de ser apagada. Tentando novamente...")
+
+            except Exception as error:
+                logger.error(f"Erro ao apagar cache '{key}': {error}")
+                raise
+
+    async def publish(self, channel: str, event: str) -> int:
+        logger.info(f"Publicando evento no canal '{channel}'...")
+
+        try:
+            with self.client.pipeline(transaction=True) as session:
+                session.multi()
+                session.publish(channel, event)
+
+                result = session.execute()
+                listeners = result[0]
+
+                logger.success(f"Evento publicado no canal '{channel}' com sucesso!")
+                return listeners
+
+        except Exception as error:
+            logger.error(f"Erro ao publicar evento no canal '{channel}': {error}")
+            raise
+
+    async def listen(self, channel: str) -> AsyncIterator[Any]:
+        logger.info(f"Iniciando escuta do canal '{channel}'...")
+
+        pubsub = self.client.pubsub()
+
+        try:
+            pubsub.subscribe(channel)
+
+            logger.success(f"Escutando canal '{channel}'!")
+
+            while True:
+                message = await asyncio.to_thread(
+                    pubsub.get_message,
+                    ignore_subscribe_messages=True,
+                    timeout=1
+                )
+
+                if message is None:
+                    continue
+
+                logger.info(f"Evento recebido no canal '{channel}'")
+                yield message["data"]
+
+        except Exception as error:
+            logger.error(f"Erro ao escutar canal '{channel}': {error}")
+            raise
+
+        finally:
+            try:
+                pubsub.unsubscribe(channel)
+                pubsub.close()
+
+                logger.info(f"Escuta do canal '{channel}' encerrada")
+
+            except Exception as error:
+                logger.error(f"Erro ao encerrar Pub/Sub '{channel}': {error}")

watchguardian-0.1.0/src/cache/manage.py

@@ -0,0 +1,11 @@
+"junta os modulos de redis"
+
+
+from .connect import RedisConnect
+from .control import RedisControl
+
+class RedisManage(RedisControl):
+    def __init__(self, host:str, port:int|str, password = None):
+        client = RedisConnect(host=host, port=port, password=password).get_client()
+
+        super().__init__(client=client)

watchguardian-0.1.0/src/cli/auth.py

@@ -0,0 +1,88 @@
+"""
+Comandos CLI de autenticação.
+"""
+
+import argparse
+import json
+
+from src.logs.module import Logs
+from src.service.module import Settings, WatchAuth
+
+
+logger = Logs(loglevel="SUCCESS")
+
+
+def auth(subparser) -> None:
+
+    auth_parser = subparser.add_parser("auth")
+
+    auth_parser.add_argument("--env-file")
+
+    auth_cmd = auth_parser.add_subparsers(
+        dest="command",
+        required=True
+    )
+
+    auth_cmd.add_parser("secret")
+
+    token_parser = auth_cmd.add_parser("token")
+    token_parser.add_argument(
+        "--type",
+        dest="token_type",
+        choices=[
+            "user_token",
+            "refresh_token"
+        ],
+        required=True
+    )
+    token_parser.add_argument(
+        "--payload",
+        default=None
+    )
+
+
+async def run_auth(args) -> None:
+
+    if args.command == "secret":
+        watch_auth = WatchAuth()
+        secret = watch_auth.secret()
+
+        logger.success(
+            f"Secret: {logger.highlighted_white(secret)}"
+        )
+
+    elif args.command == "token":
+        env = args.env_file
+
+        settings = (
+            Settings(env_file=env)
+            if env is not None
+            else Settings()
+        )
+
+        settings.add_secret("secret")
+        settings.required_secrets("secret")
+
+        watch_auth = WatchAuth(
+            settings=settings
+        )
+
+        payload = (
+            json.loads(args.payload)
+            if args.payload is not None
+            else None
+        )
+
+        if args.token_type == "user_token":
+            token = await watch_auth.user_token(
+                payload=payload
+            )
+
+        elif args.token_type == "refresh_token":
+            token = await watch_auth.refresh_token(
+                payload=payload
+            )
+
+        logger.success(
+            f"Token: {logger.highlighted_white(token)}"
+        )

watchguardian-0.1.0/src/cli/main.py

@@ -0,0 +1,48 @@
+"""
+Junta todos os comandos CLI
+"""
+
+from .migrate import migrate, run_migrate
+from .auth import auth, run_auth
+from .server import server, run_server
+
+import argparse
+import asyncio
+
+
+async def run() -> None:
+
+    parser = argparse.ArgumentParser()
+
+    modules = parser.add_subparsers(
+        dest="module",
+        required=True
+    )
+
+    commands = [
+        migrate,
+        auth,
+        server,
+    ]
+
+    for command in commands:
+        command(modules)
+
+    args = parser.parse_args()
+
+    if args.module == "migrate":
+        await run_migrate(args)
+
+    elif args.module == "auth":
+        await run_auth(args)
+
+    elif args.module == "server":
+        await run_server(args)
+
+
+def main() -> None:
+    asyncio.run(run())
+
+
+if __name__ == "__main__":
+    main()

watchguardian-0.1.0/src/cli/migrate.py

@@ -0,0 +1,49 @@
+from src.service.module import Settings, WatchDb
+import argparse
+
+
+def migrate(subparser) -> None:
+
+    migrate_parser = subparser.add_parser("migrate")
+
+    migrate_parser.add_argument("--env-file")
+
+    migrate_cmd = migrate_parser.add_subparsers(
+        dest="command",
+        required=True
+    )
+
+    migrate_cmd.add_parser("make_tables")
+    migrate_cmd.add_parser("reset")
+    migrate_cmd.add_parser("drop")
+
+
+async def run_migrate(args) -> None:
+
+    env = args.env_file
+
+    settings = (
+        Settings(env_file=env)
+        if env is not None
+        else Settings()
+    )
+
+    control_db = await WatchDb(
+        settings=settings
+    )
+
+    if args.command == "make_tables":
+        await control_db.create_tables()
+
+    elif args.command == "reset":
+        await control_db.reset_tables()
+
+    elif args.command == "drop":
+        await control_db.drop_tables()
+
+    
+
+
+
+    
+