param-manager 0.1.0__tar.gz

param_manager-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.1
+Name: param-manager
+Version: 0.1.0
+Summary: Biblioteca para gerenciamento de parâmetros com padrão Singleton,cache e armazenamento local usando TinyDB.
+Author-email: MatheusLPolidoro <mattpolidoro4@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: tinydb
+Requires-Dist: requests
+
+# Biblioteca ParamManager
+
+## Descrição
+Biblioteca Python orientada a objetos que implementa o padrão Singleton para interagir com a API de parâmetros. A biblioteca oferece funcionalidades de cache, armazenamento local com TinyDB e fallback automático em caso de indisponibilidade da API.
+
+## Funcionalidades
+
+- **Padrão Singleton**: Garante que exista apenas uma instância da classe de acesso à API
+- **Cache**: Armazena resultados em memória por até 1 hora para reduzir chamadas à API
+- **Armazenamento Local**: Usa TinyDB para persistir dados localmente
+- **Fallback Automático**: Utiliza dados locais quando a API está indisponível
+- **Recuperação de Parâmetros**: Permite buscar todos os parâmetros de um app ou um parâmetro específico
+
+## Instalação
+
+```bash
+pip install param-manager
+```
+
+## Uso Básico
+
+```python
+from param_manager import ParamManager
+
+# Obter a instância do gerenciador
+param_manager = ParamManager.get_instance()
+
+# Recuperar todos os parâmetros de um app
+params = param_manager.get_all_params('nome_do_app')
+
+# Recuperar um parâmetro específico
+param = param_manager.get_param('nome_do_app', 'NOME_PARAMETRO')
+
+# Limpar o cache para um app específico
+param_manager.clear_cache('nome_do_app')
+
+# Obter informações sobre o cache atual
+cache_info = param_manager.get_cache_info()
+```
+
+## Configuração Avançada
+
+```python
+# Configurar com URL de API personalizada, duração de cache e timeout
+param_manager = ParamManager.get_instance(
+    api_url="http://minha-api.exemplo.com",
+    cache_duration=1800,  # 30 minutos
+    timeout=10  # 10 segundos
+)
+```
+
+## Comportamento de Fallback
+
+Quando a API está indisponível, a biblioteca automaticamente:
+1. Tenta acessar a API
+2. Em caso de falha, busca dados do armazenamento local
+3. Retorna os dados mais recentes disponíveis localmente
+
+## Estrutura de Arquivos
+
+- `param_manager.py`: Implementação principal da biblioteca
+- `test_param_manager.py`: Testes unitários para validar o funcionamento
+- `README.md`: Documentação da biblioteca
+- `requirements.txt`: Dependências necessárias
+
+## Dependências
+
+- Python 3.6+
+- requests
+- tinydb

param_manager-0.1.0/README.md

@@ -0,0 +1,70 @@
+# Biblioteca ParamManager
+
+## Descrição
+Biblioteca Python orientada a objetos que implementa o padrão Singleton para interagir com a API de parâmetros. A biblioteca oferece funcionalidades de cache, armazenamento local com TinyDB e fallback automático em caso de indisponibilidade da API.
+
+## Funcionalidades
+
+- **Padrão Singleton**: Garante que exista apenas uma instância da classe de acesso à API
+- **Cache**: Armazena resultados em memória por até 1 hora para reduzir chamadas à API
+- **Armazenamento Local**: Usa TinyDB para persistir dados localmente
+- **Fallback Automático**: Utiliza dados locais quando a API está indisponível
+- **Recuperação de Parâmetros**: Permite buscar todos os parâmetros de um app ou um parâmetro específico
+
+## Instalação
+
+```bash
+pip install param-manager
+```
+
+## Uso Básico
+
+```python
+from param_manager import ParamManager
+
+# Obter a instância do gerenciador
+param_manager = ParamManager.get_instance()
+
+# Recuperar todos os parâmetros de um app
+params = param_manager.get_all_params('nome_do_app')
+
+# Recuperar um parâmetro específico
+param = param_manager.get_param('nome_do_app', 'NOME_PARAMETRO')
+
+# Limpar o cache para um app específico
+param_manager.clear_cache('nome_do_app')
+
+# Obter informações sobre o cache atual
+cache_info = param_manager.get_cache_info()
+```
+
+## Configuração Avançada
+
+```python
+# Configurar com URL de API personalizada, duração de cache e timeout
+param_manager = ParamManager.get_instance(
+    api_url="http://minha-api.exemplo.com",
+    cache_duration=1800,  # 30 minutos
+    timeout=10  # 10 segundos
+)
+```
+
+## Comportamento de Fallback
+
+Quando a API está indisponível, a biblioteca automaticamente:
+1. Tenta acessar a API
+2. Em caso de falha, busca dados do armazenamento local
+3. Retorna os dados mais recentes disponíveis localmente
+
+## Estrutura de Arquivos
+
+- `param_manager.py`: Implementação principal da biblioteca
+- `test_param_manager.py`: Testes unitários para validar o funcionamento
+- `README.md`: Documentação da biblioteca
+- `requirements.txt`: Dependências necessárias
+
+## Dependências
+
+- Python 3.6+
+- requests
+- tinydb

param_manager-0.1.0/param_manager/__init__.py

@@ -0,0 +1,29 @@
+# ██████╗  █████╗ ██████╗  █████╗ ███╗   ███╗
+# ██╔══██╗██╔══██╗██╔══██╗██╔══██╗████╗ ████║
+# ██████╔╝███████║██████╔╝███████║██╔████╔██║
+# ██╔═══╝ ██╔══██║██╔══██╗██╔══██║██║╚██╔╝██║
+# ██║     ██║  ██║██║  ██║██║  ██║██║ ╚═╝ ██║
+# ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝
+# ███╗   ███╗ █████╗ ███╗   ██╗ █████╗  ██████╗ ███████╗██████╗
+# ████╗ ████║██╔══██╗████╗  ██║██╔══██╗██╔════╝ ██╔════╝██╔══██╗
+# ██╔████╔██║███████║██╔██╗ ██║███████║██║  ███╗█████╗  ██████╔╝
+# ██║╚██╔╝██║██╔══██║██║╚██╗██║██╔══██║██║   ██║██╔══╝  ██╔══██╗
+# ██║ ╚═╝ ██║██║  ██║██║ ╚████║██║  ██║╚██████╔╝███████╗██║  ██║
+# ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝
+"""
+ParamManager
+~~~~~~~~~~~~~~~
+Biblioteca para gerenciamento de parâmetros.
+
+"""
+
+import pathlib
+import sys
+
+sys.path.append(str(pathlib.Path(__file__).parent))
+
+from .manager import ParamManager
+
+__author__ = 'MatheusLPolidoro'
+__version__ = '0.1.0'
+__all__ = ['ParamManager', 'TinyDB']

param_manager-0.1.0/param_manager/manager.py

@@ -0,0 +1,505 @@
+import logging
+import os
+import time
+from datetime import datetime, timedelta
+from typing import Any, Dict, Optional
+
+import requests
+from tinydb import TinyDB
+
+# Configuração de logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+)
+logger = logging.getLogger('ParamManager')
+
+
+class ParamManager:
+    """
+    Gerenciador de parâmetros que implementa o padrão Singleton.
+
+    Esta classe permite recuperar parâmetros de uma API, com sistema de cache
+    e fallback para armazenamento local usando TinyDB quando a API está indisponível.
+    """
+
+    # Atributo de classe para armazenar a instância única (padrão Singleton)
+    __instance = None
+
+    def __new__(cls, *args, **kwargs):
+        """
+        Implementa o padrão Singleton, garantindo uma única instância da classe.
+        """
+        if cls.__instance is None:
+            cls.__instance = super(ParamManager, cls).__new__(cls)
+            logger.info('Nova instância do ParamManager criada')
+        return cls.__instance
+
+    def __init__(
+        self, api_url: str = None, cache_duration: int = 3600, timeout: int = 5
+    ):
+        """
+        Inicializa a instância com configurações.
+
+        Args:
+            api_url: URL base da API de parâmetros. Se None, usa o valor padrão.
+            cache_duration: Duração do cache em segundos (padrão: 1 hora).
+            timeout: Tempo limite para requisições à API em segundos.
+        """
+        # Evita reinicialização se já foi inicializado
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+
+        self._api_base_url = api_url or 'http://10.111.188.61:8084'
+        self._cache_duration = (
+            cache_duration  # em segundos (1 hora por padrão)
+        )
+        self._timeout = timeout  # em segundos
+
+        # Dicionário para armazenar resultados em cache
+        self._cache = {}  # formato: {app_name: {params}}
+
+        # Dicionário para armazenar timestamps de cada cache
+        self._cache_timestamp = {}  # formato: {app_name: timestamp}
+
+        # Cache específico para parâmetros individuais
+        self._param_cache = {}  # formato: {app_name:param_name: param_value}
+        self._param_cache_timestamp = {}  # formato: {app_name:param_name: timestamp}
+
+        # Diretório para o banco de dados local
+        db_dir = os.path.join(os.path.expanduser('~'), '.param_manager')
+        os.makedirs(db_dir, exist_ok=True)
+
+        # Instância do TinyDB para armazenamento local
+        self._db_path = os.path.join(db_dir, 'params_db.json')
+        self._db = TinyDB(self._db_path)
+
+        self._initialized = True
+        logger.info(f'ParamManager inicializado com API: {self._api_base_url}')
+
+    @staticmethod
+    def get_instance(
+        api_url: str = None, cache_duration: int = 3600, timeout: int = 5
+    ) -> 'ParamManager':
+        """
+        Método estático para obter a instância única.
+
+        Args:
+            api_url: URL base da API de parâmetros.
+            cache_duration: Duração do cache em segundos.
+            timeout: Tempo limite para requisições à API em segundos.
+
+        Returns:
+            A instância única de ParamManager.
+        """
+        if ParamManager.__instance is None:
+            ParamManager(api_url, cache_duration, timeout)
+        return ParamManager.__instance
+
+    def get_all_params(self, app_name: str) -> Dict[str, Any]:
+        """
+        Recupera todos os parâmetros de um app específico.
+
+        Args:
+            app_name: Nome do aplicativo.
+
+        Returns:
+            Dicionário com todos os parâmetros do app.
+        """
+        logger.info(f'Solicitando todos os parâmetros para o app: {app_name}')
+
+        # Verifica se há cache válido
+        if self._is_cache_valid(app_name):
+            logger.info(f'Usando cache para o app: {app_name}')
+            return self._cache[app_name]
+
+        # Se não houver cache válido, tenta buscar da API
+        try:
+            params = self._fetch_from_api(app_name)
+            return params
+        except Exception as e:
+            logger.error(f'Erro ao buscar parâmetros da API: {str(e)}')
+            return self._handle_api_error(app_name, None, e)
+
+    def get_param(self, app_name: str, param_name: str) -> Any:
+        """
+        Recupera um parâmetro específico de um app.
+
+        Args:
+            app_name: Nome do aplicativo.
+            param_name: Nome do parâmetro.
+
+        Returns:
+            Valor do parâmetro ou None se não encontrado.
+        """
+        logger.info(
+            f'Solicitando parâmetro {param_name} para o app: {app_name}'
+        )
+
+        # Chave para o cache específico do parâmetro
+        param_cache_key = f'{app_name}:{param_name}'
+
+        # Verifica se há cache específico válido para o parâmetro
+        if self._is_param_cache_valid(app_name, param_name):
+            logger.info(
+                f'Usando cache específico para o parâmetro: {param_name} do app: {app_name}'
+            )
+            return self._param_cache[param_cache_key]['value']
+
+        # Se não houver cache específico válido, verifica o cache global do app
+        if self._is_cache_valid(app_name):
+            logger.info(
+                f'Usando cache global do app para o parâmetro: {param_name}'
+            )
+            params = self._cache[app_name]
+            param_value = params.get(param_name)
+
+            # Atualiza o cache específico do parâmetro
+            if param_value is not None:
+                self._param_cache[param_cache_key] = param_value
+                self._param_cache_timestamp[param_cache_key] = time.time()
+
+            return param_value.get('value')
+
+        # Se não houver cache válido, tenta buscar da API
+        try:
+            # Busca o parâmetro específico da API
+            param_value = self._fetch_param_from_api(app_name, param_name)
+            if not isinstance(param_value, dict):
+                param_value = dict()
+            return param_value.get('value')
+        except Exception as e:
+            logger.error(f'Erro ao buscar parâmetro da API: {str(e)}')
+
+            # Tenta recuperar do banco local
+            params = self._handle_api_error(app_name, param_name, e)
+            return (
+                params.get(param_name, dict()).get('value') if params else None
+            )
+
+    def _fetch_from_api(
+        self, app_name: str, param_name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Faz requisição à API para buscar todos os parâmetros de um app.
+
+        Args:
+            app_name: Nome do aplicativo.
+            param_name: Nome do parâmetro específico (opcional, mantido para compatibilidade).
+
+        Returns:
+            Dicionário com os parâmetros.
+
+        Raises:
+            Exception: Se ocorrer erro na requisição.
+        """
+        # Constrói URL apropriada para todos os parâmetros
+        url = f'{self._api_base_url}/parameters/apps/{app_name}/params'
+
+        logger.info(f'Buscando todos os parâmetros da API: {url}')
+
+        # Faz requisição HTTP
+        response = requests.get(url, timeout=self._timeout, verify=False)
+
+        # Verifica se a requisição foi bem-sucedida
+        if response.status_code != 200:
+            raise Exception(f'API retornou status code {response.status_code}')
+
+        # Processa resposta
+        data = response.json()
+
+        # Extrai parâmetros da resposta
+        params = data.get('params', {})
+
+        # Atualiza cache e timestamp
+        self._cache[app_name] = params
+        self._cache_timestamp[app_name] = time.time()
+
+        # Salva dados localmente
+        self._save_to_local_db(app_name, params)
+
+        return params
+
+    def _fetch_param_from_api(self, app_name: str, param_name: str) -> Any:
+        """
+        Faz requisição à API para buscar um parâmetro específico.
+
+        Args:
+            app_name: Nome do aplicativo.
+            param_name: Nome do parâmetro específico.
+
+        Returns:
+            Valor do parâmetro ou None se não encontrado.
+
+        Raises:
+            Exception: Se ocorrer erro na requisição.
+        """
+        # Constrói URL apropriada para o parâmetro específico
+        url = f'{self._api_base_url}/parameters/apps/{app_name}/params/{param_name}'
+
+        logger.info(f'Buscando parâmetro específico da API: {url}')
+
+        # Faz requisição HTTP
+        response = requests.get(url, timeout=self._timeout, verify=False)
+
+        # Verifica se a requisição foi bem-sucedida
+        if response.status_code != 200:
+            raise Exception(f'API retornou status code {response.status_code}')
+
+        # Processa resposta
+        data = response.json()
+
+        # Extrai parâmetro da resposta
+        param_value = data.get('param')
+
+        # Chave para o cache específico do parâmetro
+        param_cache_key = f'{app_name}:{param_name}'
+
+        # Atualiza o cache específico do parâmetro
+        self._param_cache[param_cache_key] = param_value
+        self._param_cache_timestamp[param_cache_key] = time.time()
+
+        # Também atualiza o cache global se existir
+        if app_name in self._cache:
+            self._cache[app_name][param_name] = param_value
+            self._cache_timestamp[app_name] = time.time()
+
+            # Salva dados localmente
+            self._save_to_local_db(app_name, self._cache[app_name])
+
+        return param_value
+
+    def _is_cache_valid(self, app_name: str) -> bool:
+        """
+        Verifica se o cache global para um app é válido.
+
+        Args:
+            app_name: Nome do aplicativo.
+
+        Returns:
+            True se o cache for válido, False caso contrário.
+        """
+        # Verifica se existe cache para o app
+        if (
+            app_name not in self._cache
+            or app_name not in self._cache_timestamp
+        ):
+            return False
+
+        # Verifica se o timestamp é recente (menos de cache_duration segundos)
+        current_time = time.time()
+        cache_time = self._cache_timestamp[app_name]
+
+        return (current_time - cache_time) < self._cache_duration
+
+    def _is_param_cache_valid(self, app_name: str, param_name: str) -> bool:
+        """
+        Verifica se o cache específico para um parâmetro é válido.
+
+        Args:
+            app_name: Nome do aplicativo.
+            param_name: Nome do parâmetro.
+
+        Returns:
+            True se o cache for válido, False caso contrário.
+        """
+        # Chave para o cache específico do parâmetro
+        param_cache_key = f'{app_name}:{param_name}'
+
+        # Verifica se existe cache específico para o parâmetro
+        if (
+            param_cache_key not in self._param_cache
+            or param_cache_key not in self._param_cache_timestamp
+        ):
+            return False
+
+        # Verifica se o timestamp é recente (menos de cache_duration segundos)
+        current_time = time.time()
+        cache_time = self._param_cache_timestamp[param_cache_key]
+
+        return (current_time - cache_time) < self._cache_duration
+
+    def _save_to_local_db(self, app_name: str, params: Dict[str, Any]) -> None:
+        """
+        Salva parâmetros no banco local.
+
+        Args:
+            app_name: Nome do aplicativo.
+            params: Dicionário com os parâmetros.
+        """
+        logger.info(f'Salvando parâmetros localmente para o app: {app_name}')
+
+        # Define a tabela para o app
+        table = self._db.table(app_name)
+
+        # Limpa a tabela antes de inserir novos dados
+        table.truncate()
+
+        # Insere os parâmetros
+        table.insert({'timestamp': time.time(), 'params': params})
+
+    def _get_from_local_db(
+        self, app_name: str, param_name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Recupera dados do banco local.
+
+        Args:
+            app_name: Nome do aplicativo.
+            param_name: Nome do parâmetro específico (opcional).
+
+        Returns:
+            Dicionário com os parâmetros ou vazio se não encontrado.
+        """
+        logger.info(f'Buscando parâmetros localmente para o app: {app_name}')
+
+        # Define a tabela para o app
+        table = self._db.table(app_name)
+
+        # Busca o registro mais recente
+        records = table.all()
+
+        if not records:
+            logger.warning(
+                f'Nenhum registro local encontrado para o app: {app_name}'
+            )
+            return {}
+
+        # Ordena por timestamp (mais recente primeiro)
+        records.sort(key=lambda x: x.get('timestamp', 0), reverse=True)
+
+        # Obtém os parâmetros do registro mais recente
+        params = records[0].get('params', {})
+
+        # Filtra por param_name se especificado
+        if param_name:
+            if param_name in params:
+                return {param_name: params[param_name]}
+            return {}
+
+        return params
+
+    def _handle_api_error(
+        self, app_name: str, param_name: Optional[str], error: Exception
+    ) -> Dict[str, Any]:
+        """
+        Trata erros de API.
+
+        Args:
+            app_name: Nome do aplicativo.
+            param_name: Nome do parâmetro específico (opcional).
+            error: Exceção ocorrida.
+
+        Returns:
+            Dados locais se disponíveis ou dicionário vazio.
+        """
+        logger.error(f'Erro ao acessar API para {app_name}: {str(error)}')
+        logger.info(f'Tentando usar dados locais para {app_name}')
+
+        # Busca dados locais
+        return self._get_from_local_db(app_name, param_name)
+
+    def clear_cache(
+        self, app_name: Optional[str] = None, param_name: Optional[str] = None
+    ) -> None:
+        """
+        Limpa o cache para um app específico, um parâmetro específico ou para todos os apps.
+
+        Args:
+            app_name: Nome do aplicativo (opcional).
+            param_name: Nome do parâmetro (opcional).
+        """
+        if app_name and param_name:
+            # Limpa o cache específico do parâmetro
+            param_cache_key = f'{app_name}:{param_name}'
+            if param_cache_key in self._param_cache:
+                del self._param_cache[param_cache_key]
+            if param_cache_key in self._param_cache_timestamp:
+                del self._param_cache_timestamp[param_cache_key]
+            logger.info(
+                f'Cache limpo para o parâmetro {param_name} do app: {app_name}'
+            )
+        elif app_name:
+            # Limpa o cache do app
+            if app_name in self._cache:
+                del self._cache[app_name]
+            if app_name in self._cache_timestamp:
+                del self._cache_timestamp[app_name]
+
+            # Limpa também todos os caches específicos relacionados ao app
+            param_cache_keys = [
+                k
+                for k in self._param_cache.keys()
+                if k.startswith(f'{app_name}:')
+            ]
+            for key in param_cache_keys:
+                if key in self._param_cache:
+                    del self._param_cache[key]
+                if key in self._param_cache_timestamp:
+                    del self._param_cache_timestamp[key]
+
+            logger.info(f'Cache limpo para o app: {app_name}')
+        else:
+            # Limpa todos os caches
+            self._cache = {}
+            self._cache_timestamp = {}
+            self._param_cache = {}
+            self._param_cache_timestamp = {}
+            logger.info('Cache limpo para todos os apps e parâmetros')
+
+    def get_cache_info(self) -> Dict[str, Any]:
+        """
+        Retorna informações sobre o cache atual.
+
+        Returns:
+            Dicionário com informações do cache.
+        """
+        info = {
+            'apps_cached': list(self._cache.keys()),
+            'cache_timestamps': {},
+            'cache_valid': {},
+            'params_cached': [],
+            'param_cache_timestamps': {},
+            'param_cache_valid': {},
+        }
+
+        # Informações sobre o cache global
+        for app_name, timestamp in self._cache_timestamp.items():
+            dt = datetime.fromtimestamp(timestamp)
+            expires_at = dt + timedelta(seconds=self._cache_duration)
+            is_valid = self._is_cache_valid(app_name)
+
+            info['cache_timestamps'][app_name] = {
+                'cached_at': dt.isoformat(),
+                'expires_at': expires_at.isoformat(),
+                'seconds_remaining': int(
+                    timestamp + self._cache_duration - time.time()
+                )
+                if is_valid
+                else 0,
+            }
+            info['cache_valid'][app_name] = is_valid
+
+        # Informações sobre o cache específico de parâmetros
+        for param_key, timestamp in self._param_cache_timestamp.items():
+            info['params_cached'].append(param_key)
+
+            dt = datetime.fromtimestamp(timestamp)
+            expires_at = dt + timedelta(seconds=self._cache_duration)
+
+            # Extrai app_name e param_name da chave
+            app_name, param_name = param_key.split(':', 1)
+            is_valid = self._is_param_cache_valid(app_name, param_name)
+
+            info['param_cache_timestamps'][param_key] = {
+                'cached_at': dt.isoformat(),
+                'expires_at': expires_at.isoformat(),
+                'seconds_remaining': int(
+                    timestamp + self._cache_duration - time.time()
+                )
+                if is_valid
+                else 0,
+            }
+            info['param_cache_valid'][param_key] = is_valid
+
+        return info

param_manager-0.1.0/param_manager.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.1
+Name: param-manager
+Version: 0.1.0
+Summary: Biblioteca para gerenciamento de parâmetros com padrão Singleton,cache e armazenamento local usando TinyDB.
+Author-email: MatheusLPolidoro <mattpolidoro4@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: tinydb
+Requires-Dist: requests
+
+# Biblioteca ParamManager
+
+## Descrição
+Biblioteca Python orientada a objetos que implementa o padrão Singleton para interagir com a API de parâmetros. A biblioteca oferece funcionalidades de cache, armazenamento local com TinyDB e fallback automático em caso de indisponibilidade da API.
+
+## Funcionalidades
+
+- **Padrão Singleton**: Garante que exista apenas uma instância da classe de acesso à API
+- **Cache**: Armazena resultados em memória por até 1 hora para reduzir chamadas à API
+- **Armazenamento Local**: Usa TinyDB para persistir dados localmente
+- **Fallback Automático**: Utiliza dados locais quando a API está indisponível
+- **Recuperação de Parâmetros**: Permite buscar todos os parâmetros de um app ou um parâmetro específico
+
+## Instalação
+
+```bash
+pip install param-manager
+```
+
+## Uso Básico
+
+```python
+from param_manager import ParamManager
+
+# Obter a instância do gerenciador
+param_manager = ParamManager.get_instance()
+
+# Recuperar todos os parâmetros de um app
+params = param_manager.get_all_params('nome_do_app')
+
+# Recuperar um parâmetro específico
+param = param_manager.get_param('nome_do_app', 'NOME_PARAMETRO')
+
+# Limpar o cache para um app específico
+param_manager.clear_cache('nome_do_app')
+
+# Obter informações sobre o cache atual
+cache_info = param_manager.get_cache_info()
+```
+
+## Configuração Avançada
+
+```python
+# Configurar com URL de API personalizada, duração de cache e timeout
+param_manager = ParamManager.get_instance(
+    api_url="http://minha-api.exemplo.com",
+    cache_duration=1800,  # 30 minutos
+    timeout=10  # 10 segundos
+)
+```
+
+## Comportamento de Fallback
+
+Quando a API está indisponível, a biblioteca automaticamente:
+1. Tenta acessar a API
+2. Em caso de falha, busca dados do armazenamento local
+3. Retorna os dados mais recentes disponíveis localmente
+
+## Estrutura de Arquivos
+
+- `param_manager.py`: Implementação principal da biblioteca
+- `test_param_manager.py`: Testes unitários para validar o funcionamento
+- `README.md`: Documentação da biblioteca
+- `requirements.txt`: Dependências necessárias
+
+## Dependências
+
+- Python 3.6+
+- requests
+- tinydb

param_manager-0.1.0/param_manager.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+param_manager/__init__.py
+param_manager/manager.py
+param_manager.egg-info/PKG-INFO
+param_manager.egg-info/SOURCES.txt
+param_manager.egg-info/dependency_links.txt
+param_manager.egg-info/requires.txt
+param_manager.egg-info/top_level.txt
+tests/__init__.py
+tests/conftest.py
+tests/test_param_manager.py

param_manager-0.1.0/param_manager.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

param_manager-0.1.0/param_manager.egg-info/requires.txt

@@ -0,0 +1,2 @@
+tinydb
+requests

param_manager-0.1.0/param_manager.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+dist
+docs
+param_manager
+tests

param_manager-0.1.0/pyproject.toml

@@ -0,0 +1,95 @@
+[project]
+name = "param-manager"
+version = "0.1.0"
+description = "Biblioteca para gerenciamento de parâmetros com padrão Singleton,cache e armazenamento local usando TinyDB."
+authors = [{name = "MatheusLPolidoro", email = "mattpolidoro4@gmail.com"}]
+readme = "README.md"
+requires-python = ">=3.8"
+
+dependencies = [
+    "tinydb",
+    "requests"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+
+[build-system]
+requires = ["setuptools>=61.0,<70"]
+build-backend = "setuptools.build_meta"
+
+[tool.ruff]
+line-length = 79
+
+[tool.ruff.lint]
+preview = true
+select = ['I', 'F', 'E', 'W', 'PL', 'PT']
+
+[tool.ruff.format]
+preview = true
+quote-style = 'single'
+
+[tool.taskipy.tasks]
+lint = "ruff check . --diff"
+format = "ruff format ."
+test = "pytest . -s -x --cov=param_manager -vv"
+post_test = "python -m coverage html"
+
+[tool.towncrier]
+package = "param_manager"
+package_dir = "."
+filename = "CHANGELOG.md"
+directory = "chanlogs.d"
+underlines = ["=", "-", "~"]
+title_format = "Versão {version} ({project_date})"
+issue_format = "[#{issue}](https://github.com/seu_usuario/seu_repo/issues/{issue})"
+
+[[tool.towncrier.type]]
+directory = "breaking"
+name = ":warning: MUDANÇAS QUEBRADAS"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "feature"
+name = ":zap: NOVAS FUNCIONALIDADES"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "enhancement"
+name = ":rocket: OTIMIZAÇÕES"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "fix"
+name = ":bug: CORREÇÕES"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "deprecation"
+name = ":wastebasket: OBSOLETOS"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "security"
+name = ":shield: SEGURANÇA"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "docs"
+name = ":open_file_folder: DOCUMENTAÇÃO"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "tests"
+name = ":test_tube: TESTES"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "infra"
+name = ":classical_building: INFRAESTRUTURA"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "chore"
+name = ":broom: LIMPEZA"
+showcontent = true

param_manager-0.1.0/setup.cfg

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

param_manager-0.1.0/tests/conftest.py

@@ -0,0 +1,45 @@
+import os
+import pytest
+from param_manager.manager import ParamManager
+from unittest.mock import patch, MagicMock
+
+
+@pytest.fixture
+def setup_param_manager():
+    """Fixture para configurar o ambiente de teste para o ParamManager."""
+    # Limpa a instância singleton entre os testes
+    ParamManager._ParamManager__instance = None
+
+    # Cria um diretório temporário para o banco de dados de teste
+    test_db_dir = os.path.join(os.path.expanduser('~'), '.param_manager_test')
+    os.makedirs(test_db_dir, exist_ok=True)
+    test_db_path = os.path.join(test_db_dir, 'test_params_db.json')
+
+    # Mock para o TinyDB
+    with patch('param_manager.manager.TinyDB') as mock_db:
+        mock_db_instance = MagicMock()
+        mock_db.return_value = mock_db_instance
+
+        # Mock para a tabela do TinyDB
+        mock_table = MagicMock()
+        mock_db_instance.table.return_value = mock_table
+
+        # Cria a instância do ParamManager com URL de API de teste
+        param_manager = ParamManager.get_instance(
+            api_url='http://test-api.example.com',
+            cache_duration=60,  # 1 minuto para facilitar os testes
+            timeout=2,
+        )
+
+        # Retorna os objetos necessários para os testes
+        yield param_manager, mock_table
+
+    # Limpeza após o teste
+    if os.path.exists(test_db_path):
+        os.remove(test_db_path)
+
+    # Remove o diretório de teste se estiver vazio
+    try:
+        os.rmdir(test_db_dir)
+    except OSError:
+        pass

param_manager-0.1.0/tests/test_param_manager.py

@@ -0,0 +1,332 @@
+import time
+import pytest
+from unittest.mock import patch, MagicMock
+
+import requests
+
+
+@pytest.mark.parametrize(
+    'mock_response_data', [{'param': {'value': 'test_value'}}]
+)
+def test_get_param_from_api_with_individual_cache(
+    setup_param_manager, mock_response_data
+):
+    """Testa a recuperação de um parâmetro específico com cache individual."""
+    param_manager, _ = setup_param_manager
+
+    # Configura o mock para requests.get
+    with patch('param_manager.manager.requests.get') as mock_get:
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_response_data
+        mock_get.return_value = mock_response
+
+        # Primeira chamada - deve acessar a API
+        param1 = param_manager.get_param('test_app', 'PARAM1')
+
+        # Verifica se a API foi chamada corretamente
+        mock_get.assert_called_once_with(
+            'http://test-api.example.com/parameters/apps/test_app/params/PARAM1',
+            timeout=2,
+            verify=False,
+        )
+
+        # Verifica se o parâmetro foi retornado corretamente
+        assert param1 == 'test_value'
+
+        # Verifica se o cache específico foi atualizado
+        assert 'test_app:PARAM1' in param_manager._param_cache
+        assert 'test_app:PARAM1' in param_manager._param_cache_timestamp
+
+        # Reseta o mock para a próxima chamada
+        mock_get.reset_mock()
+
+        # Segunda chamada - deve usar o cache específico
+        param2 = param_manager.get_param('test_app', 'PARAM1')
+
+        # Verifica se a API não foi chamada novamente
+        mock_get.assert_not_called()
+
+        # Verifica se o parâmetro foi retornado corretamente do cache
+        assert param2 == 'test_value'
+
+
+@pytest.mark.parametrize(
+    'mock_response_data',
+    [
+        {
+            'params': {
+                'PARAM1': {'value': 'value1'},
+                'PARAM2': {'value': 'value2'},
+            }
+        }
+    ],
+)
+def test_get_param_from_global_cache(setup_param_manager, mock_response_data):
+    """Testa a recuperação de um parâmetro do cache global quando não há cache específico."""
+    param_manager, _ = setup_param_manager
+
+    # Configura o mock para requests.get para a chamada de todos os parâmetros
+    with patch('param_manager.manager.requests.get') as mock_get:
+        mock_response_all = MagicMock()
+        mock_response_all.status_code = 200
+        mock_response_all.json.return_value = mock_response_data
+        mock_get.return_value = mock_response_all
+
+        # Primeiro, busca todos os parâmetros para preencher o cache global
+        params = param_manager.get_all_params('test_app')
+
+        # Verifica se a API foi chamada corretamente
+        mock_get.assert_called_once_with(
+            'http://test-api.example.com/parameters/apps/test_app/params',
+            timeout=2,
+            verify=False,
+        )
+
+        # Reseta o mock para a próxima chamada
+        mock_get.reset_mock()
+
+        # Agora, busca um parâmetro específico - deve usar o cache global
+        param = param_manager.get_param('test_app', 'PARAM1')
+
+        # Verifica se a API não foi chamada novamente
+        mock_get.assert_not_called()
+
+        # Verifica se o parâmetro foi retornado corretamente do cache global
+        assert param == 'value1'
+
+        # Agora, busca de todos os parametros - deve usar o cache global
+        params = param_manager.get_all_params('test_app')
+
+        # Verifica se o cache específico foi atualizado
+        assert 'test_app:PARAM1' in param_manager._param_cache
+        assert 'test_app:PARAM1' in param_manager._param_cache_timestamp
+
+
+@pytest.mark.parametrize('mock_response_data', [{'param': 'test_value'}])
+def test_cache_expiration_for_individual_param(
+    setup_param_manager, mock_response_data
+):
+    """Testa a expiração do cache para um parâmetro individual."""
+    param_manager, _ = setup_param_manager
+
+    # Configura o mock para requests.get
+    with patch('param_manager.manager.requests.get') as mock_get:
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_response_data
+        mock_get.return_value = mock_response
+
+        # Define uma duração de cache muito curta para o teste
+        param_manager._cache_duration = 0.1  # 100ms
+
+        # Primeira chamada - deve acessar a API
+        param1 = param_manager.get_param('test_app', 'PARAM1')
+
+        # Verifica se a API foi chamada
+        assert mock_get.call_count == 1
+
+        # Espera o cache expirar
+        time.sleep(0.2)
+
+        # Reseta o mock para a próxima chamada
+        mock_get.reset_mock()
+
+        # Segunda chamada - deve acessar a API novamente
+        param2 = param_manager.get_param('test_app', 'PARAM1')
+
+        # Verifica se a API foi chamada novamente
+        assert mock_get.call_count == 1
+
+
+@pytest.mark.parametrize('mock_response_data', [{'param': 'test_value'}])
+def test_clear_cache_for_individual_param(
+    setup_param_manager, mock_response_data
+):
+    """Testa a limpeza do cache para um parâmetro individual."""
+    param_manager, _ = setup_param_manager
+
+    # Configura o mock para requests.get
+    with patch('param_manager.manager.requests.get') as mock_get:
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_response_data
+        mock_get.return_value = mock_response
+
+        # Primeira chamada - deve acessar a API
+        param1 = param_manager.get_param('test_app', 'PARAM1')
+
+        # Verifica se a API foi chamada
+        assert mock_get.call_count == 1
+
+        # Limpa o cache específico
+        param_manager.clear_cache('test_app', 'PARAM1')
+
+        # Reseta o mock para a próxima chamada
+        mock_get.reset_mock()
+
+        # Segunda chamada - deve acessar a API novamente
+        param2 = param_manager.get_param('test_app', 'PARAM1')
+
+        # Verifica se a API foi chamada novamente
+        assert mock_get.call_count == 1
+
+
+@pytest.mark.parametrize('mock_response_data', [{'param': 'test_value'}])
+def test_clear_cache_for_app_clears_all_related_params(
+    setup_param_manager, mock_response_data
+):
+    """Testa se a limpeza do cache de um app limpa todos os parâmetros relacionados."""
+    param_manager, _ = setup_param_manager
+
+    # Configura o mock para requests.get
+    with patch('param_manager.manager.requests.get') as mock_get:
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_response_data
+        mock_get.return_value = mock_response
+
+        # Busca dois parâmetros diferentes para preencher o cache
+        param1 = param_manager.get_param('test_app', 'PARAM1')
+        param2 = param_manager.get_param('test_app', 'PARAM2')
+
+        # Verifica se a API foi chamada duas vezes
+        assert mock_get.call_count == 2
+
+        # Verifica se os caches específicos foram criados
+        assert 'test_app:PARAM1' in param_manager._param_cache
+        assert 'test_app:PARAM2' in param_manager._param_cache
+
+        # Limpa o cache do app
+        param_manager.clear_cache('test_app')
+
+        # Verifica se os caches específicos foram limpos
+        assert 'test_app:PARAM1' not in param_manager._param_cache
+        assert 'test_app:PARAM2' not in param_manager._param_cache
+
+
+def test_api_error_fallback_for_individual_param(setup_param_manager):
+    """Testa o fallback para dados locais quando a API falha para um parâmetro individual."""
+    param_manager, mock_table = setup_param_manager
+
+    # Configura o mock para requests.get para lançar uma exceção
+    with patch('param_manager.manager.requests.get') as mock_get:
+        mock_get.side_effect = requests.exceptions.RequestException(
+            'API indisponível'
+        )
+
+        # Configura o mock para retornar dados locais
+        mock_table.all.return_value = [
+            {
+                'timestamp': time.time(),
+                'params': {'PARAM1': {'value': 'local_value'}},
+            }
+        ]
+
+        # Chama o método para buscar um parâmetro específico
+        param = param_manager.get_param('test_app', 'PARAM1')
+
+        # Verifica se a API foi chamada
+        mock_get.assert_called_once()
+
+        # Verifica se os dados locais foram buscados
+        mock_table.all.assert_called_once()
+
+        # Verifica se o parâmetro local foi retornado
+        assert param == 'local_value'
+
+
+def test_api_error_fallback_for_all_params(setup_param_manager):
+    """Testa o fallback para dados locais quando a API falha para um parâmetro individual."""
+    param_manager, mock_table = setup_param_manager
+
+    # Configura o mock para requests.get para lançar uma exceção
+    with patch('param_manager.manager.requests.get') as mock_get:
+        mock_get.side_effect = requests.exceptions.RequestException(
+            'API indisponível'
+        )
+
+        result = {'PARAM1': {'value': 'value1'}, 'PARAM2': {'value': 'value2'}}
+        # Configura o mock para retornar dados locais
+        mock_table.all.return_value = [
+            {
+                'timestamp': time.time(),
+                'params': result,
+            }
+        ]
+
+        # Chama o método para buscar um parâmetro específico
+        params = param_manager.get_all_params('test_app')
+
+        # Verifica se a API foi chamada
+        mock_get.assert_called_once()
+
+        # Verifica se os dados locais foram buscados
+        mock_table.all.assert_called_once()
+
+        # Verifica se o parâmetro local foi retornado
+        assert params == result
+
+
+@pytest.mark.parametrize(
+    'mock_response_data', [{'param': {'value': 'test_value'}}]
+)
+def test_api_error_status_code(setup_param_manager, mock_response_data):
+    """Testa se o a chamada da API retorna algo diferente de 200"""
+    param_manager, _ = setup_param_manager
+
+    # Define uma duração de cache muito curta para o teste
+    param_manager._cache_duration = 0  # 100ms
+    
+    # Configura o mock para requests.get
+    with patch('param_manager.manager.requests.get') as mock_get:
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_response_data
+        mock_get.return_value = mock_response
+
+        # Busca um parâmetro para preencher o cache
+        param = param_manager.get_param('test_app', 'PARAM1')
+
+        # Verifica se o parâmetro local foi retornado
+        assert param == 'test_value'
+    
+        mock_response.status_code = 500
+
+        # Busca um parâmetro para preencher o cache
+        param = param_manager.get_param('test_app', 'PARAM1')
+
+        assert param == None
+
+
+@pytest.mark.parametrize(
+    'mock_response_data', [{'param': {'value': 'test_value'}}]
+)
+def test_get_cache_info_includes_param_cache(
+    setup_param_manager, mock_response_data
+):
+    """Testa se o método get_cache_info inclui informações sobre o cache de parâmetros individuais."""
+    param_manager, _ = setup_param_manager
+
+    # Configura o mock para requests.get
+    with patch('param_manager.manager.requests.get') as mock_get:
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_response_data
+        mock_get.return_value = mock_response
+
+        # Busca um parâmetro para preencher o cache
+        param = param_manager.get_param('test_app', 'PARAM1')
+
+        # Obtém informações do cache
+        cache_info = param_manager.get_cache_info()
+
+        # Verifica se as informações sobre o cache de parâmetros estão presentes
+        assert 'params_cached' in cache_info
+        assert 'param_cache_timestamps' in cache_info
+        assert 'param_cache_valid' in cache_info
+
+        # Verifica se o parâmetro específico está nas informações
+        assert 'test_app:PARAM1' in cache_info['params_cached']
+        assert 'test_app:PARAM1' in cache_info['param_cache_timestamps']
+        assert 'test_app:PARAM1' in cache_info['param_cache_valid']