manage-sql 0.2.2__py3-none-any.whl

manage_sql/SQLITE.py

@@ -0,0 +1,444 @@
+import sqlite3 as sq
+import hashlib as sh
+from pathlib import Path
+from deprecated import deprecated
+import os
+
+class SQLITE:
+    '''
+    Faça a gestão dos seus bancos de dados com esta classe.
+    
+    Importe a classe e use um dos métodos abaixo:
+    ```python
+    # Importando a classe
+    from manage-sql import SQLITE
+    
+    # Instacioando a classe
+    db = SQLITE('nome_do_banco')
+    
+    # Usar cada um dos metodos:
+    db.criarTabela()
+    db.inserirDados()
+    db.apagarDados()
+    db.editarDados()
+    db.adicionarColuna()
+    db.apagarColuna()
+    db.apagarTabela()
+    db.verDados()
+    db.encriptarValor()
+    ```
+    
+    Funções descontinuadas
+    ```python
+    # Encriptar valores
+    db.encryptPass() # Função antiga
+    db.encriptarValor() # Nova função
+    
+    # Consultar dados
+    db.verDadosPlus() # Função antiga
+    db.verDados() # Função em uso
+    ```
+    '''
+
+    def __init__(self, nomeBanco: str):
+        """
+        Inicializa a classe com o nome do banco de dados.
+        
+        :param nomeBanco: Nome do banco de dados a ser utilizado.
+        
+        Exemplo de uso:
+        ```python
+        db = SQLITE('meu_banco)
+        ```
+        """
+        self.nomeBanco = nomeBanco
+
+    def conectarBanco(self):
+        """
+        Conecta ao banco de dados e cria a pasta 'database' se não existir.
+
+        :return: Um objeto de conexão e cursor do banco de dados.
+        
+        Exemplo de uso:
+        ```python
+        db = SQLITE('meu_banco')
+        database, cursor = db.conectarBanco()
+        ```
+        """
+        path = Path.cwd() / "database"
+        path.mkdir(parents=True, exist_ok=True)
+        
+        database = sq.connect(f'database/{self.nomeBanco}.db')
+        cursor = database.cursor()
+
+        return database, cursor
+
+    def criarTabela(self, nomeTabela: str, Colunas: list, ColunasTipo: list):
+        """
+        Cria uma tabela no banco de dados.
+
+        :param nomeTabela: Nome da tabela a ser criada.
+        :param Colunas: Lista com os nomes das colunas.
+        :param ColunasTipo: Lista com os tipos das colunas.
+
+        Exemplo de uso:
+        ```python
+        db = SQLITE('meu_banco')
+        db.criarTabela(
+            nomeTabela='minha_tabela',
+            Colunas=['coluna1', 'coluna2'],
+            ColunasTipo=['TEXT', 'INTEGER']
+        )
+        ```
+        """
+        if type(Colunas) == list and type(ColunasTipo) == list:
+            if len(Colunas) == len(ColunasTipo):
+                database, cursor = self.conectarBanco()
+                ListaColunas = []
+
+                for i in range(len(Colunas)):
+                    ListaColunas.append(f'{Colunas[i]} {ColunasTipo[i]}')
+
+                ColunaSQL = ','.join(ListaColunas)
+
+                cursor.execute(f'CREATE TABLE IF NOT EXISTS {nomeTabela} (id INTEGER PRIMARY KEY AUTOINCREMENT,{ColunaSQL})')
+
+                database.commit()
+                database.close()
+            else:
+                print('Impossível criar tabelas: quantidade de colunas e tipos não coincide.')
+        else:
+            print('Impossível criar tabelas: parâmetros devem ser listas.')
+
+    def inserirDados(self, nomeTabela: str, Colunas: list, dados: list):
+        """
+        Insere dados em uma tabela do banco de dados.
+
+        :param nomeTabela: Nome da tabela onde os dados serão inseridos.
+        :param Colunas: Lista com os nomes das colunas.
+        :param dados: Lista com os valores a serem inseridos.
+        
+        Exemplo de uso:
+        ```python
+        db = SQLITE('meu_banco')
+        db.inserirDados(
+            nomeTabela='minha_tabela',
+            Colunas=['coluna1', 'coluna2'],
+            dados=['valor1', 123]
+        )
+        ```
+        """
+        if type(Colunas) == list and type(dados) == list:
+            if len(Colunas) == len(dados):
+                database, cursor = self.conectarBanco()
+
+                ColunaSQL = ', '.join(Colunas)
+
+                Dados = []
+
+                for dado in dados:
+                    if type(dado) == str or type(dado) == bool:
+                        Dados.append(f"'{dado}'")
+                    else:
+                        Dados.append(str(dado))
+
+                params = ', '.join('?' for _ in Dados)
+
+                cursor.execute(f'INSERT INTO {nomeTabela} ({ColunaSQL}) VALUES ({params})', (Dados))
+
+                database.commit()
+                database.close()
+            else:
+                print('Impossível inserir dados: quantidade de colunas e valores não coincide.')
+        else:
+            print('Impossível inserir dados: parâmetros devem ser listas.')
+
+    def apagarDados(self, nomeTabela: str, conditions: str = ''):
+        """
+        Apaga registros de uma tabela no banco de dados SQLite.
+
+        :param nomeTabela: Nome da tabela da qual os dados serão apagados.
+        :param conditions: Condição SQL para selecionar os registros a serem apagados. Se vazio, todos os registros serão apagados.
+        
+        Exemplo de uso:
+        
+        ```python
+        db = SQLITE('meu_banco')
+        
+        # Apaga registros com id = 1
+        db.apagarDados("minha_tabela", "id = 1")
+        
+        # Apaga todos os registros da tabela
+        db.apagarDados("minha_tabela")
+        ```
+        """
+        database, cursor = self.conectarBanco()
+
+        if conditions == '':
+            cursor.execute(f'DELETE FROM {nomeTabela}')
+        
+        else:
+            cursor.execute(f'DELETE FROM {nomeTabela} WHERE {conditions}')
+        
+        database.commit()
+        database.close()
+
+    def editarDados(self, nomeTabela: str, Coluna: str, Valor: str, conditions: str = ''):
+        """
+        Edita registros em uma tabela no banco de dados SQLite.
+
+        :param nomeTabela: Nome da tabela a ser editada.
+        :param Coluna: Nome da coluna a ser editada.
+        :param Valor: Novo valor a ser atribuído à coluna.
+        :param conditions: Condição SQL para selecionar os registros a serem editados. Se vazio, todos os registros serão atualizados.
+        
+        Exemplo de uso:
+        ```python
+        db = SQLITE('meu_banco')
+        
+        # Edita registros com id = 1
+        db.editarDados("minha_tabela", "nome_coluna", "novo_valor", "id = 1")
+        
+        # Edita todos os registros da tabela
+        db.editarDados("minha_tabela", "nome_coluna", "novo_valor")
+        ```
+        """
+        database, cursor = self.conectarBanco()
+
+        if conditions == '':
+            cursor.execute(f"UPDATE {nomeTabela} SET {Coluna} = ?", (Valor,))
+        
+        else:
+            cursor.execute(f"UPDATE {nomeTabela} SET {Coluna} = ? WHERE {conditions}", (Valor,))
+        
+        database.commit()
+        database.close()
+
+    def adicionarColuna(self, nomeTabela: str, Coluna: str, ColunaTipo: str):
+        """
+        Adiciona uma nova coluna a uma tabela no banco de dados SQLite.
+
+        :param nomeTabela: Nome da tabela na qual a coluna será adicionada.
+        :param Coluna: Nome da nova coluna.
+        :param ColunaTipo: Tipo de dados da nova coluna (por exemplo, INTEGER, TEXT).
+        
+        Exemplo de uso:
+        ```python
+        db_manager = DatabaseManager()
+        
+        # Adiciona uma coluna do tipo TEXT
+        db_manager.adicionarColuna("minha_tabela", "nova_coluna", "TEXT")```
+        """
+        database, cursor = self.conectarBanco()
+
+        cursor.execute(f'ALTER TABLE {nomeTabela} ADD COLUMN {Coluna} {ColunaTipo}')
+
+        database.commit()
+        database.close()
+    
+    def apagarColuna(self, nomeTabela: str, Coluna: str):
+        """
+        Apaga uma coluna de uma tabela do banco de dados.
+
+        :param nomeTabela: Nome da tabela onde a coluna será apagada.
+        :param Coluna: Nome da coluna a ser apagada.
+        
+        Exemplo de uso:
+        ```python
+        db = SQLITE('meu_banco')
+        db.apagarColuna('minha_tabela', 'coluna2')
+        ```
+        """
+        database, cursor = self.conectarBanco()
+
+        cursor.execute(f'ALTER TABLE {nomeTabela} DROP COLUMN {Coluna}')
+
+        database.commit()
+        database.close()
+
+    def apagarTabela(self, nomeTabela: str):
+        """
+        Apaga uma tabela do banco de dados.
+
+        :param nomeTabela: Nome da tabela a ser apagada.
+        
+        Exemplo de uso:
+        ```python
+        db = SQLITE('meu_banco')
+        db.apagarTabela('minha_tabela')
+        ```
+        """
+        database, cursor = self.conectarBanco()
+
+        cursor.execute(f'DROP TABLE IF EXISTS {nomeTabela}')
+
+        database.commit()
+        database.close()
+
+    def verDados(self, nomeTabela: str, conditions: str = '', colunas: str = '*'):
+        """
+        Consulta dados de uma tabela do banco de dados.
+
+        :param nomeTabela: Nome da tabela a ser consultada.
+        :param conditions: Condições para a consulta (opcional).
+        :param colunas: Colunas a serem selecionadas (opcional).
+        :return: Dados consultados.
+        
+        Exemplo de uso:
+        ```python
+        db = SQLITE('meu_banco')
+        dados = db.verDados('minha_tabela')
+        print(dados)
+        ```
+        """
+        database, cursor = self.conectarBanco()
+
+        if conditions == '':
+            cursor.execute(f'SELECT {colunas} FROM {nomeTabela}')
+        else:
+            cursor.execute(f'SELECT {colunas} FROM {nomeTabela} WHERE {conditions}')
+
+        dados = cursor.fetchall()
+
+        database.commit()
+        database.close()
+
+        return dados
+    
+    @deprecated(reason='Esta função será descontinuada nas versões subsequentes. Considere usar função verDados()')
+    def verDadosPlus(self, query: str, params: list):
+        """
+        Consulta dados com base em uma query SQL customizada.
+
+        :param query: Query SQL a ser executada.
+        :param params: Parâmetros para a query SQL.
+        :return: Dados consultados.
+        
+        ```python
+        db = SQLITE('meu_banco')
+        query = "SELECT * FROM minha_tabela WHERE coluna1 = ? AND coluna2 = ?"
+        params = ['valor1', 123]
+        dados = db.verDadosPlus(query, params)
+        print(dados)
+        ```
+        """
+        database, cursor = self.conectarBanco()
+        
+        cursor.execute(query, params)
+        dados = cursor.fetchall()
+        
+        database.commit()
+        database.close()
+        
+        return dados
+
+    @deprecated(reason='Esta função vai ser descontinuada nas versões subsequentes. Considere usar a função encriptarValor()')
+    def encryptPass(self, value: str):
+        """
+        Gera um hash SHA-512 de um valor fornecido.
+
+        :param value: Valor a ser criptografada.
+        :return: Valor criptografado em SHA-512.
+        
+        Exemplo de uso:
+        ```python
+        db = SQLITE('meu_banco')
+        value_hashed = db.encryptPass('minha_senha')
+        print(value_hashed)
+        ```
+        """
+        hash = sh.sha512()
+        hash.update(value.encode('UTF-8'))
+        value_hashed = hash.hexdigest()
+
+        return value_hashed
+    
+    def encriptarValor(self, value: str):
+        """
+        Gera um hash SHA-512 de um valor fornecido.
+
+        :param value: Valor a ser criptografada.
+        :return: Valor criptografado em SHA-512.
+        
+        Exemplo de uso:
+        ```python
+        db = SQLITE('meu_banco')
+        value_hashed = db.encryptValor('valor')
+        print(value_hashed)
+        ```
+        """
+        hash = sh.sha512()
+        hash.update(value.encode('UTF-8'))
+        value_hashed = hash.hexdigest()
+
+        return value_hashed
+
+
+if __name__ == '__main__':
+    # Exemplo de uso da classe SQLITE
+    db = SQLITE('users')
+
+    # Criar tabela
+    db.criarTabela(
+        nomeTabela='users',
+        Colunas=['nome', 'username', 'senha'],
+        ColunasTipo=['TEXT', 'TEXT', 'TEXT']
+    )
+
+    # Inserir dados
+    db.inserirDados(
+        nomeTabela='users',
+        Colunas=['nome', 'username', 'senha'],
+        dados=['Alexandre Zunguze', 'azunguze', db.encriptarValor('Aa123')]
+    )
+    
+    # Adicionar coluna
+    db.adicionarColuna(
+        nomeTabela='users',
+        Coluna='ColunaB',
+        ColunaTipo='TEXT'
+    ),
+    
+    # Editar dados
+    db.editarDados(
+        nomeTabela='users',
+        Coluna='ColunaB',
+        Valor='Teste'
+    )
+    
+    # Ver dados
+    dados = db.verDados('users')
+    print(dados)
+    
+    # Apagar Coluna
+    db.apagarColuna(
+        nomeTabela='users',
+        Coluna='senha'
+    )
+    
+    # Ver dados
+    dados = db.verDados('users')
+    print(dados)
+    
+    # Inserir dados
+    db.inserirDados(
+        nomeTabela='users',
+        Colunas=['nome', 'username', 'ColunaB'],
+        dados=['Alexandre Zunguze', 'azunguze', 'Qualquer coisa']
+    )
+    
+    # Apagar dados
+    db.apagarDados(
+        nomeTabela='users',
+        conditions='id = 1'
+    )
+    
+    # Ver dados
+    dados = db.verDados('users')
+    print(dados)
+
+    # Apagar tabela
+    db.apagarTabela('users')
+    
+    # Apagar o Banco de Dados
+    os.remove(rf'{Path.cwd()}\database\users.db')

manage_sql/__init__.py

@@ -0,0 +1,2 @@
+from .SQLITE import SQLITE
+from .test_SQLITE import TestSQLITE

manage_sql/test_SQLITE.py

@@ -0,0 +1,96 @@
+import unittest
+from pathlib import Path
+import os
+from dataclasses import is_dataclass
+
+try:
+    from SQLITE import SQLITE
+
+except:
+    from manage_sql import SQLITE
+
+
+class TestSQLITE(unittest.TestCase):
+    
+    @classmethod
+    def setUp(self):
+        self.db_name: str = 'db_test'
+        self.table_name = 'tabela_test'
+        self.columns = ['Col_1', 'Col_2', 'Col_3']
+        self.columns_type = ['TEXT', 'TEXT', 'INTEGER']
+        self.path: str = rf"{Path.cwd()}\database\{self.db_name}.db"
+        self.database: SQLITE = SQLITE(self.db_name)
+        self.database.criarTabela(
+            nomeTabela=self.table_name,
+            Colunas=self.columns,
+            ColunasTipo=self.columns_type
+        )
+    
+    def tearDown(self) -> None:
+        os.remove(self.path)
+    
+    # Testando a classe importada
+    def test_e_classe(self):
+        self.assertFalse(is_dataclass(SQLITE))
+    
+    # Testando a conexão
+    def test_conectarBanco(self):
+        database = SQLITE(self.db_name).conectarBanco()
+        database[0].close()
+        self.assertEqual(type(database), tuple)
+    
+    def test_inserirDados(self):
+        self.database.inserirDados(
+            nomeTabela=self.table_name,
+            Colunas=self.columns,
+            dados=['A1','A2', 123]
+        )
+        data = self.database.verDados(
+            nomeTabela=self.table_name,
+            conditions='id = 1'
+        )
+        self.assertEqual(len(data), 1)
+    
+    def test_adicionarColuna(self):
+        self.database.adicionarColuna(
+            nomeTabela=self.table_name,
+            Coluna='Col_4',
+            ColunaTipo='TEXT'
+        )
+    
+    def test_editarDados(self):
+        self.database.inserirDados(
+            nomeTabela=self.table_name,
+            Colunas=self.columns,
+            dados=['A1','A2', 123]
+        )
+        
+        self.database.editarDados(
+            nomeTabela=self.table_name,
+            Coluna=self.columns[2],
+            Valor='125'
+        )
+        
+        data = self.database.verDados(
+            nomeTabela=self.table_name
+        )
+        
+        self.assertEqual(data[0][3], 125)
+    
+    def test_apagarDados(self):
+        self.database.inserirDados(
+            nomeTabela=self.table_name,
+            Colunas=self.columns,
+            dados=['A1','A2', 123]
+        )
+        self.database.apagarDados(
+            nomeTabela=self.table_name
+        )
+        data = self.database.verDados(
+            nomeTabela=self.table_name
+        )
+        self.assertEqual(len(data), 0)
+        
+
+if __name__ == '__main__':
+    unittest.main()

manage_sql-0.2.2.dist-info/LICENCE

@@ -0,0 +1,9 @@
+The MIT Licence (MIT)
+
+Copyright 2024 Web Tech Moz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

manage_sql-0.2.2.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.1
+Name: manage-sql
+Version: 0.2.2
+Summary: Biblioteca Python para gestão de bases de dados SQLite com maior eficiência
+Home-page: https://github.com/webtechmoz/manage-sql
+Author: Web Tech Moz
+Author-email: zoidycine@gmail.com
+License: MIT
+Keywords: manage-sql,sqlite,sqlite manager
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: deprecated
+Requires-Dist: dataclasses
+Requires-Dist: pathlib
+
+# SQLITE.py
+
+`SQLITE.py` é uma classe Python para interagir com bancos de dados SQLite de forma simplificada. Esta classe fornece métodos para conectar a um banco de dados, criar tabelas, inserir dados e outras operações básicas.
+
+## Índice
+1. [Introdução](#introdução)
+2. [Instalação](#instalação)
+3. [Uso da Classe SQLITE](#uso-da-classe-sqlite)
+    1. [Instanciando a Classe](#instanciando-a-classe)
+    2. [Métodos Disponíveis](#métodos-disponíveis)
+        - [conectarBanco](#conectarbanco)
+        - [criarTabela](#criartabela)
+        - [inserirDados](#inserirdados)
+        - [apagarDados](#apagardados)
+        - [editarDados](#editardados)
+        - [adicionarColuna](#adicionarcoluna)
+        - [apagarColuna](#apagarcoluna)
+        - [apagarTabela](#apagartabela)
+        - [verDados](#verdados)
+        - [encryptPass (descontinuado)](#encryptpass-descontinuado)
+        - [encriptarValor](#encriptarvalor)
+        - [verDadosPlus (descontinuado)](#verdadosplus-descontinuado)
+
+4. [Contibuição](#contribuição)
+5. [Licença](#licença)
+
+## Instalação
+
+Não há requisitos especiais de instalação além do Python 3.6+.
+
+## Uso
+
+Primeiro, importe a classe `SQLITE` e crie uma instância fornecendo o nome do banco de dados:
+
+```python
+# Importando a biblioteca
+from manage-sql import SQLITE
+
+# Instanciando a classe SQLITE
+db = SQLITE('meu_banco')
+```
+
+## Métodos
+
+### __init__
+Inicializa a classe com o nome do banco de dados.
+
+#### Parâmetros:
+nomeBanco (str): Nome do banco de dados a ser utilizado.
+
+#### Exemplo de uso:
+```python
+db = SQLITE('meu_banco')
+```
+
+### Conectar Banco
+Conecta ao banco de dados e cria a pasta database se não existir.
+
+#### Retorno:
+Um objeto de conexão e cursor do banco de dados.
+
+#### Exemplo de uso:
+```python
+database, cursor = db.conectarBanco()
+```
+
+### Criar Tabela
+Cria uma tabela no banco de dados.
+
+#### Parâmetros:
+nomeTabela (str): Nome da tabela a ser criada.
+Colunas (list): Lista com os nomes das colunas.
+ColunasTipo (list): Lista com os tipos das colunas.
+
+#### Exemplo de uso:
+```python
+db.criarTabela(
+    nomeTabela='minha_tabela',
+    Colunas=['coluna1', 'coluna2'],
+    ColunasTipo=['TEXT', 'INTEGER']
+)
+```
+
+### Inserir Dados
+Insere dados na tabela especificada.
+
+#### Parâmetros:
+nomeTabela (str): Nome da tabela onde os dados serão inseridos.
+Colunas (list): Lista com os nomes das colunas onde os dados serão inseridos.
+Valores (list): Lista com os valores a serem inseridos.
+
+#### Exemplo de uso:
+```python
+db.inserirDados(
+    nomeTabela='minha_tabela',
+    Colunas=['coluna1', 'coluna2'],
+    Valores=['valor1', 123]
+)
+```
+
+### Consultar Dados
+Consulta dados da tabela especificada.
+
+#### Parâmetros:
+nomeTabela (str): Nome da tabela de onde os dados serão consultados.
+Colunas (list): Lista com os nomes das colunas a serem consultadas.
+
+#### Exemplo de uso:
+```python
+resultados = db.consultarDados(
+    nomeTabela='minha_tabela',
+    Colunas=['coluna1', 'coluna2']
+)
+```
+
+### Apagar Dados
+Deleta dados da tabela especificada com base em uma condição.
+
+#### Parâmetros:
+nomeTabela (str): Nome da tabela de onde os dados serão deletados.
+Condicao (str): Condição para deletar os dados.
+
+#### Exemplo de uso:
+```python
+db.deletarDados(
+    nomeTabela='minha_tabela',
+    Condicao='coluna1 = "valor1"'
+)
+```
+
+## Contribuição
+Sinta-se à vontade para contribuir com melhorias e novas funcionalidades.
+
+## Licença
+Este projeto está licenciado sob a licença MIT.

manage_sql-0.2.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+manage_sql/SQLITE.py,sha256=PzCgVgaPbid55oM54TCT6jJA0Hc3K7JLdd2pVbegfg0,13494
+manage_sql/__init__.py,sha256=kyMrX4tZGLHK5eDRFzIct6dHIJ08k9w7rkGEOR5xNUY,63
+manage_sql/test_SQLITE.py,sha256=xNR1_wWMkPLzfF7r6yawf-VPiKYjAvxDs3oFBQ8Lp94,2684
+manage_sql-0.2.2.dist-info/LICENCE,sha256=Jrj79HT3Z-YHl370yCwRDTNJE2EjDOuspVtay-FVMWE,1090
+manage_sql-0.2.2.dist-info/METADATA,sha256=q_53KWPee-kx_ZYvCqMP1l_TTlcGu6pXM-OTwHkUYQU,4244
+manage_sql-0.2.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+manage_sql-0.2.2.dist-info/top_level.txt,sha256=Q-4U0UfXC7Qs41XpM-YMCGajKed55PYKglYmslcz3nI,11
+manage_sql-0.2.2.dist-info/RECORD,,

manage_sql-0.2.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

manage_sql-0.2.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+manage_sql