spark-migration 0.1.0__tar.gz

spark_migration-0.1.0/Migration/__init__.py

@@ -0,0 +1,6 @@
+"""Public interface for the Migration framework."""
+
+from Migration.service.main import Migration
+
+__all__ = ["Migration"]
+__version__ = "0.1.0"

spark_migration-0.1.0/Migration/engine/__init__.py

@@ -0,0 +1 @@
+"""Infraestrutura de conexao, tarefas e Spark."""

spark_migration-0.1.0/Migration/engine/connect.py

@@ -0,0 +1,72 @@
+from sqlalchemy import  create_engine, inspect, Engine
+from Migration.logs.logs import logger
+
+#Cria Conexão do banco de dados e retorna o nome de todas as tabelas
+
+class Engine:
+    def __init__(self, url:str, name:str)-> None:
+        
+        #Url que conecta com o banco de dados
+        self.__url = url
+        
+        self.name = name
+        
+        self.eng = self.con()
+    
+    #Cria a engine do banco de dados
+    def con(self) -> Engine:
+        
+        try:
+            logger.info(f"Connecting to database {self.name}...")
+            
+            eng = create_engine(
+                url=self.__url
+            )
+            
+            logger.info(f"Connected to database {self.name}.")
+            
+            return eng
+        
+        except Exception as error:
+            
+            raise Exception(error)
+     
+    #Pega todas as tabelas do banco e retorna em uma lista  
+    def tables(self) -> list:
+        
+        try:
+            logger.info(f"Discovering tables in database {self.name}...")
+            
+            inspector = inspect(self.eng)
+            
+            tables = inspector.get_table_names()
+            
+            logger.info(
+                f"Discovered {len(tables)} table(s): "
+                f"{', '.join(tables) if tables else '[none]'}"
+            )
+            
+            return tables
+        
+        except Exception as error:
+            
+            raise Exception(error)
+        
+    
+        
+        
+    
+        
+        
+        
+            
+        
+        
+        
+    
+        
+        
+        
+        
+        
+

spark_migration-0.1.0/Migration/engine/init_spark.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+from Migration.logs.logs import logger
+from pyspark.sql import SparkSession
+
+logger.info("Starting Spark session...")
+
+# Usa o driver que acompanha o projeto. No Windows, spark.jars.packages tenta
+# baixar/copiar o arquivo via Hadoop e exige winutils.exe/HADOOP_HOME.
+postgres_driver = (
+    Path(__file__).resolve().parents[1]
+    / "drivers"
+    / "postgresql-42.7.12.jar"
+)
+
+if not postgres_driver.is_file():
+    raise FileNotFoundError(f"Driver PostgreSQL nao encontrado: {postgres_driver}")
+
+driver_path = str(postgres_driver)
+
+app_spark = (
+    SparkSession.builder
+    .appName("Migration")
+    .master("local[*]")
+    .config("spark.driver.extraClassPath", driver_path)
+    .config("spark.executor.extraClassPath", driver_path)
+    .getOrCreate()
+)
+logger.info("Spark session started.")
+

spark_migration-0.1.0/Migration/engine/init_task.py

@@ -0,0 +1,61 @@
+from concurrent.futures import ThreadPoolExecutor
+from functools import wraps
+from queue import Queue
+
+from Migration.logs.logs import logger
+
+class Channel:
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.queue = Queue()
+        logger.info(f"Channel {self.name} created.")
+
+    def send(self, result) -> None:
+        self.queue.put(result)
+
+    def get(self):
+        return self.queue.get()
+
+
+class Task:
+    """Executa tarefas em threads para compartilhar uma unica sessao Spark."""
+
+    def __init__(self, max_workers: int, name: str, channel: Channel) -> None:
+        self.name = name
+        self.channel = channel
+        self.executor = ThreadPoolExecutor(
+            max_workers=max_workers,
+            thread_name_prefix=name,
+        )
+
+    def run(self):
+        def decorator(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                future = self.executor.submit(func, *args, **kwargs)
+
+                def finished(completed):
+                    try:
+                        self.channel.send(completed.result())
+                    except BaseException as error:
+                        self.channel.send(error)
+
+                future.add_done_callback(finished)
+                return future
+
+            return wrapper
+
+        return decorator
+
+
+# Canal onde vai receber o resultado das tasks.
+ch = Channel(name="Migrations")
+
+# Threads evitam criar uma JVM/SparkSession por tabela e excecoes nao precisam
+# ser serializadas entre processos.
+task = Task(
+    max_workers=4,
+    name="Migration_task",
+    channel=ch
+)
+

spark_migration-0.1.0/Migration/logs/__init__.py

@@ -0,0 +1 @@
+"""Configuracao de logs do framework."""

spark_migration-0.1.0/Migration/logs/global_logs.py

@@ -0,0 +1,9 @@
+#Cria a configuração global de logs
+import logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+    handlers=[
+        logging.StreamHandler()
+    ]
+)

spark_migration-0.1.0/Migration/logs/logs.py

@@ -0,0 +1,4 @@
+#Pega a configuração global de logs
+from Migration.logs import global_logs
+import logging
+logger = logging.getLogger(__name__)

spark_migration-0.1.0/Migration/schema/__init__.py

@@ -0,0 +1 @@
+"""Modelos e controle da migracao de dados."""

spark_migration-0.1.0/Migration/schema/control.py

@@ -0,0 +1,101 @@
+from Migration.logs.logs import logger
+from Migration.engine.init_spark import app_spark
+from pyspark.sql import DataFrame
+import time
+
+#Essa classe serve para ler e transferir a tabela
+class SparkDb:
+    def __init__(
+        self,
+        url: str,
+        table_name: str,
+        new_url: str,
+        user: str,
+        password: str,
+        new_user: str,
+        new_password: str,
+    ) -> None:
+        
+        self.url = url
+        self.table = table_name
+        self.spark = app_spark
+        self.new_url = new_url
+        self.user = user
+        self.password = password
+        self.new_user = new_user
+        self.new_password = new_password
+        
+    #Le a tabela  
+    def read(self, max_attempts: int = 3)-> DataFrame:
+        for attempt in range(1, max_attempts + 1):
+            try:
+                logger.info(
+                    f"Reading table {self.table} "
+                    f"(attempt {attempt}/{max_attempts})"
+                )
+
+                df = (self.spark.
+                      read.format("jdbc").
+                      option("url", self.url).
+                      option("dbtable", self.table).
+                      option("driver", "org.postgresql.Driver").
+                      option("user", self.user).
+                      option("password", self.password).
+                      option("connectTimeout", "30").
+                      option("socketTimeout", "300").
+                      option("tcpKeepAlive", "true").
+                      load())
+
+                logger.info(f"Table {self.table} loaded.")
+                return df
+
+            except Exception as error:
+                if attempt == max_attempts:
+                    raise RuntimeError(
+                        f"Nao foi possivel ler a tabela {self.table} "
+                        f"apos {max_attempts} tentativas: {error}"
+                    ) from error
+
+                logger.warning(
+                    f"Temporary failure while reading {self.table}: {error}. "
+                    "Retrying..."
+                )
+                time.sleep(3 * attempt)
+        
+    #Salva no novo banco de dados
+    def save(self) -> None:
+        try:
+            logger.info(f"Writing table {self.table}...")
+            
+            (self.df.write.
+             format("jdbc").
+             option("url", self.new_url).
+             option("dbtable", self.table).
+             option("driver", "org.postgresql.Driver").
+             option("user", self.new_user).
+             option("password", self.new_password).
+             mode("append").save()
+             )
+            
+            logger.info(f"Table {self.table} written successfully.")
+            
+        except Exception as error:
+            raise Exception(error)
+        
+    def run(self) -> str:
+        self.df = self.read()
+        self.save()
+        return self.table
+    
+
+            
+        
+        
+    
+                
+            
+        
+        
+    
+        
+    

spark_migration-0.1.0/Migration/schema/model.py

@@ -0,0 +1,22 @@
+from urllib.parse import quote_plus
+#serve pra formatar od dados
+class Formate:
+    
+    def __init__(self, host:str, port:int, user:str, password:str, dbname:str)->None:
+        self.host = host
+        self.port = port
+        self.user = user
+        self.Pass = password
+        self.db = dbname
+       
+    #formata os dados de conexão pra url do spark   
+    def url_spark(self) -> str:
+        return f"jdbc:postgresql://{self.host}:{self.port}/{self.db}"
+    
+    #forma para url do sqlalchemy
+    def url_alchemy(self) ->str:
+         password = quote_plus(self.Pass)
+
+         return f"postgresql://{self.user}:{password}@{self.host}:{self.port}/{self.db}"
+            
+        

spark_migration-0.1.0/Migration/service/__init__.py

@@ -0,0 +1,2 @@
+"""Servico publico de migracao."""
+from Migration.service.main import Migration

spark_migration-0.1.0/Migration/service/main.py

@@ -0,0 +1,81 @@
+from Migration.logs.logs import logger
+from Migration.engine.connect import Engine
+from Migration.tasks.task_db import SaveDb
+from Migration.engine.init_task import ch
+from Migration.schema.model import Formate
+
+#Faz toda migração do banco de dados
+class Migration:
+    def __init__(self, data:dict, new_data:dict)->None:
+        
+        self.__url = Formate(
+            host=data["host"],
+            port=data["port"], 
+            dbname=data["dbname"],
+            password=data["password"],
+            user=data["user"]
+        )
+        
+        self.__newurl = Formate(
+            host=new_data["host"],
+            port=new_data["port"], 
+            dbname=new_data["dbname"],
+            password=new_data["password"],
+            user=new_data["user"]
+        )
+
+        self.__source_user = data["user"]
+        self.__source_password = data["password"]
+        self.__destination_user = new_data["user"]
+        self.__destination_password = new_data["password"]
+        
+        self.tables = Engine(url=self.__url.url_alchemy(), name=data["dbname"]).tables()
+        
+        self.channel = ch
+      
+    #Incia uma task para cada tabela do banco de dados  
+    def init_task(self)->None:
+        for table in self.tables:
+            SaveDb(
+                table_name=table,
+                url=self.__url.url_spark(),
+                new_url=self.__newurl.url_spark(),
+                user=self.__source_user,
+                password=self.__source_password,
+                new_user=self.__destination_user,
+                new_password=self.__destination_password,
+            )
+          
+    #Chama o metodo init_task para iniciar as tasks, e depois entra num loop e espera todas as tasks finalizarem  
+    def run(self) -> None:
+        logger.info("Starting database migration...")
+        
+        self.init_task()
+        
+        tables_finish = []
+        
+        while len(tables_finish) != len(self.tables):
+            
+            data = self.channel.get()
+
+            if isinstance(data, BaseException):
+                raise RuntimeError(f"Falha durante a migracao: {data}") from data
+
+            if data is not None:
+                logger.info(f"Table {data} migrated successfully.")
+                tables_finish.append(data)
+                
+        
+        logger.info("Database migration completed successfully.")
+                
+            
+                
+        
+        
+            
+        
+    
+        
+        
+        
+        

spark_migration-0.1.0/Migration/tasks/__init__.py

@@ -0,0 +1 @@
+"""Tarefas de migracao por tabela."""

spark_migration-0.1.0/Migration/tasks/task_db.py

@@ -0,0 +1,28 @@
+
+from Migration.engine.init_task import task
+from Migration.schema.control import SparkDb
+
+#Transforma todo sparkdb em uma task
+@task.run()
+def SaveDb(
+    url: str,
+    new_url: str,
+    table_name: str,
+    user: str,
+    password: str,
+    new_user: str,
+    new_password: str,
+):
+    tb = SparkDb(
+        url=url,
+        new_url=new_url,
+        table_name=table_name,
+        user=user,
+        password=password,
+        new_user=new_user,
+        new_password=new_password,
+    ).run()
+    return tb
+    
+
+

spark_migration-0.1.0/PKG-INFO

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: spark_migration
+Version: 0.1.0
+Summary: Spark Migration: framework concorrente para migracao de dados PostgreSQL com Apache Spark.
+Keywords: database,migration,postgresql,pyspark,spark,etl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pyspark<5,>=4.0
+Requires-Dist: SQLAlchemy<3,>=2.0
+Requires-Dist: psycopg2-binary<3,>=2.9
+
+<div align="center">
+
+# Spark Migration
+
+### Um framework concorrente para migração de dados PostgreSQL com Apache Spark
+
+[![Python](https://img.shields.io/badge/Python-3.10%2B-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)
+[![Apache Spark](https://img.shields.io/badge/Apache_Spark-4.x-E25A1C?style=for-the-badge&logo=apachespark&logoColor=white)](https://spark.apache.org/)
+[![PostgreSQL](https://img.shields.io/badge/PostgreSQL-Suportado-4169E1?style=for-the-badge&logo=postgresql&logoColor=white)](https://www.postgresql.org/)
+[![Status](https://img.shields.io/badge/Status-Beta-F59E0B?style=for-the-badge)](#status-do-projeto)
+
+Descubra tabelas, execute tarefas concorrentes e transfira dados via JDBC usando uma única sessão Spark compartilhada.
+
+</div>
+
+---
+
+## Visão geral
+
+Spark Migration é um framework Python para copiar dados entre bancos PostgreSQL. Ele combina SQLAlchemy para inspecionar o banco de origem, Apache Spark para transferir os dados via JDBC e um conjunto controlado de threads para processar as tabelas concorrentemente.
+
+A API pública foi projetada para ser simples:
+
+```python
+Migration(data=origem, new_data=destino).run()
+```
+
+## Recursos
+
+- Descoberta automática das tabelas do banco de origem.
+- Leitura e escrita via JDBC com Apache Spark.
+- Execução concorrente de até quatro tabelas.
+- Uma única sessão Spark compartilhada entre todas as tarefas.
+- Até três tentativas para falhas temporárias de leitura.
+- Propagação de erros das tarefas para a thread principal.
+- Driver JDBC do PostgreSQL incluído no pacote.
+- Logs estruturados em inglês.
+
+## Como funciona
+
+```mermaid
+flowchart LR
+    A["PostgreSQL de origem"] -->|"Descobre tabelas"| B["SQLAlchemy"]
+    B --> C["Serviço Spark Migration"]
+    C -->|"Uma tarefa por tabela"| D["Pool de threads"]
+    D --> E["Sessão Spark compartilhada"]
+    E -->|"Leitura JDBC"| A
+    E -->|"Escrita JDBC em append"| F["PostgreSQL de destino"]
+    D -->|"Resultado ou erro"| C
+```
+
+1. `Migration` formata as configurações de conexão da origem e do destino.
+2. O SQLAlchemy conecta-se à origem e descobre suas tabelas.
+3. O serviço cria uma tarefa para cada tabela encontrada.
+4. Cada tarefa lê sua tabela em um DataFrame Spark via JDBC.
+5. O Spark adiciona o DataFrame à tabela correspondente no destino.
+6. A thread principal aguarda os resultados e interrompe a execução quando uma tarefa falha.
+
+## Requisitos
+
+- Python 3.10 ou superior.
+- Java 17 disponível no `PATH`.
+- Bancos PostgreSQL de origem e destino.
+- Acesso de rede aos dois bancos.
+- Permissão de leitura nas tabelas de origem.
+- Permissões de criação e inserção no destino.
+
+## Instalação
+
+Instale o Spark Migration e suas dependências diretamente pelo PyPI:
+
+```bash
+pip install spark_migration
+```
+
+Após a instalação, o framework é importado como `Migration`.
+
+## Uso rápido
+
+Mantenha as credenciais fora do código-fonte. Este exemplo utiliza variáveis de ambiente:
+
+```python
+import os
+
+from Migration import Migration
+
+origem = {
+    "host": os.environ["SOURCE_DB_HOST"],
+    "port": int(os.getenv("SOURCE_DB_PORT", "5432")),
+    "dbname": os.environ["SOURCE_DB_NAME"],
+    "user": os.environ["SOURCE_DB_USER"],
+    "password": os.environ["SOURCE_DB_PASSWORD"],
+}
+
+destino = {
+    "host": os.environ["DESTINATION_DB_HOST"],
+    "port": int(os.getenv("DESTINATION_DB_PORT", "5432")),
+    "dbname": os.environ["DESTINATION_DB_NAME"],
+    "user": os.environ["DESTINATION_DB_USER"],
+    "password": os.environ["DESTINATION_DB_PASSWORD"],
+}
+
+Migration(data=origem, new_data=destino).run()
+```
+
+Execute o arquivo normalmente:
+
+```bash
+python spark_migration.py
+```
+
+Exemplo de saída:
+
+```text
+INFO | Starting Spark session...
+INFO | Spark session started.
+INFO | Connecting to database postgres...
+INFO | Discovered 1 table(s): orders
+INFO | Starting database migration...
+INFO | Reading table orders (attempt 1/3)
+INFO | Table orders written successfully.
+INFO | Database migration completed successfully.
+```
+
+## Configuração da conexão
+
+Os parâmetros `data` e `new_data` recebem os mesmos campos:
+
+| Campo | Tipo | Descrição |
+| --- | --- | --- |
+| `host` | `str` | Endereço ou IP do servidor PostgreSQL |
+| `port` | `int` | Porta do PostgreSQL, normalmente `5432` |
+| `dbname` | `str` | Nome do banco de dados |
+| `user` | `str` | Usuário do banco |
+| `password` | `str` | Senha do banco |
+
+## Comportamento da escrita
+
+A versão atual utiliza o modo `append` do Spark.
+
+- Se a tabela não existir no destino, o Spark a criará com base no DataFrame.
+- Se a tabela já existir, os novos registros serão adicionados.
+- Executar a mesma migração mais de uma vez pode duplicar os dados.
+- Uma falha durante a escrita pode deixar dados parciais no destino.
+
+Utilize um destino limpo para migrações completas e compare a quantidade de registros na origem e no destino antes de repetir uma execução.
+
+## Escopo e limitações atuais
+
+O framework atualmente migra os registros das tabelas. Ele ainda não reproduz todos os objetos e configurações do PostgreSQL, incluindo:
+
+- chaves primárias e estrangeiras;
+- índices e restrições únicas;
+- sequências e seus valores atuais;
+- views e materialized views;
+- triggers e funções armazenadas;
+- usuários, permissões e políticas de segurança em nível de linha;
+- extensões e configurações do banco.
+
+Em migrações de produção, recrie e valide esses objetos separadamente.
+
+## Observações para Windows
+
+O Spark pode informar que `winutils.exe`, `HADOOP_HOME` ou a biblioteca nativa do Hadoop não estão disponíveis. O framework carrega diretamente o driver JDBC incluído no pacote, portanto esses avisos não impedem o fluxo suportado de migração PostgreSQL.
+
+Se o Spark não iniciar, confirme se o Java 17 está instalado:
+
+```powershell
+java -version
+```
+
+## Solução de problemas
+
+### `Connection reset`
+
+O banco ou o gerenciador de conexões encerrou a conexão JDBC. O framework repete automaticamente a leitura até três vezes. Se o problema continuar, verifique o estado do banco, a estabilidade da rede, os requisitos de SSL e os limites do pool de conexões.
+
+### `Migration failed`
+
+A thread principal recebeu uma exceção de uma tarefa. Procure o primeiro erro de banco ou Spark exibido antes dessa mensagem; normalmente ele contém a causa real.
+
+### Porta da interface Spark ocupada
+
+O Spark pode selecionar outra porta quando a porta local `4040` já estiver em uso. Isso é apenas informativo e normalmente não impede a migração.
+
+## Segurança
+
+- Nunca inclua senhas de banco ou tokens do PyPI no repositório.
+- Prefira variáveis de ambiente ou um gerenciador de segredos.
+- Utilize usuários de banco dedicados e com as menores permissões necessárias.
+- Troque credenciais que já tenham sido publicadas ou compartilhadas.
+
+## Status do projeto
+
+Spark Migration está em fase **Beta**. A migração de registros entre bancos PostgreSQL está funcional. Modos de escrita idempotentes, migração completa do esquema, validação automática e suporte a outros bancos ainda estão em desenvolvimento.
+
+## Roadmap
+
+- Modos configuráveis `append`, `overwrite` e falha se a tabela existir.
+- Validação por quantidade de registros e checksum.
+- Migração de esquema, restrições, índices e sequências.
+- Filtros para incluir ou excluir tabelas.
+- Configuração de concorrência e tentativas.
+- Testes automatizados e integração contínua.
+- Suporte a outros bancos compatíveis com JDBC.

spark_migration-0.1.0/README.md

@@ -0,0 +1,205 @@
+<div align="center">
+
+# Spark Migration
+
+### Um framework concorrente para migração de dados PostgreSQL com Apache Spark
+
+[![Python](https://img.shields.io/badge/Python-3.10%2B-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)
+[![Apache Spark](https://img.shields.io/badge/Apache_Spark-4.x-E25A1C?style=for-the-badge&logo=apachespark&logoColor=white)](https://spark.apache.org/)
+[![PostgreSQL](https://img.shields.io/badge/PostgreSQL-Suportado-4169E1?style=for-the-badge&logo=postgresql&logoColor=white)](https://www.postgresql.org/)
+[![Status](https://img.shields.io/badge/Status-Beta-F59E0B?style=for-the-badge)](#status-do-projeto)
+
+Descubra tabelas, execute tarefas concorrentes e transfira dados via JDBC usando uma única sessão Spark compartilhada.
+
+</div>
+
+---
+
+## Visão geral
+
+Spark Migration é um framework Python para copiar dados entre bancos PostgreSQL. Ele combina SQLAlchemy para inspecionar o banco de origem, Apache Spark para transferir os dados via JDBC e um conjunto controlado de threads para processar as tabelas concorrentemente.
+
+A API pública foi projetada para ser simples:
+
+```python
+Migration(data=origem, new_data=destino).run()
+```
+
+## Recursos
+
+- Descoberta automática das tabelas do banco de origem.
+- Leitura e escrita via JDBC com Apache Spark.
+- Execução concorrente de até quatro tabelas.
+- Uma única sessão Spark compartilhada entre todas as tarefas.
+- Até três tentativas para falhas temporárias de leitura.
+- Propagação de erros das tarefas para a thread principal.
+- Driver JDBC do PostgreSQL incluído no pacote.
+- Logs estruturados em inglês.
+
+## Como funciona
+
+```mermaid
+flowchart LR
+    A["PostgreSQL de origem"] -->|"Descobre tabelas"| B["SQLAlchemy"]
+    B --> C["Serviço Spark Migration"]
+    C -->|"Uma tarefa por tabela"| D["Pool de threads"]
+    D --> E["Sessão Spark compartilhada"]
+    E -->|"Leitura JDBC"| A
+    E -->|"Escrita JDBC em append"| F["PostgreSQL de destino"]
+    D -->|"Resultado ou erro"| C
+```
+
+1. `Migration` formata as configurações de conexão da origem e do destino.
+2. O SQLAlchemy conecta-se à origem e descobre suas tabelas.
+3. O serviço cria uma tarefa para cada tabela encontrada.
+4. Cada tarefa lê sua tabela em um DataFrame Spark via JDBC.
+5. O Spark adiciona o DataFrame à tabela correspondente no destino.
+6. A thread principal aguarda os resultados e interrompe a execução quando uma tarefa falha.
+
+## Requisitos
+
+- Python 3.10 ou superior.
+- Java 17 disponível no `PATH`.
+- Bancos PostgreSQL de origem e destino.
+- Acesso de rede aos dois bancos.
+- Permissão de leitura nas tabelas de origem.
+- Permissões de criação e inserção no destino.
+
+## Instalação
+
+Instale o Spark Migration e suas dependências diretamente pelo PyPI:
+
+```bash
+pip install spark_migration
+```
+
+Após a instalação, o framework é importado como `Migration`.
+
+## Uso rápido
+
+Mantenha as credenciais fora do código-fonte. Este exemplo utiliza variáveis de ambiente:
+
+```python
+import os
+
+from Migration import Migration
+
+origem = {
+    "host": os.environ["SOURCE_DB_HOST"],
+    "port": int(os.getenv("SOURCE_DB_PORT", "5432")),
+    "dbname": os.environ["SOURCE_DB_NAME"],
+    "user": os.environ["SOURCE_DB_USER"],
+    "password": os.environ["SOURCE_DB_PASSWORD"],
+}
+
+destino = {
+    "host": os.environ["DESTINATION_DB_HOST"],
+    "port": int(os.getenv("DESTINATION_DB_PORT", "5432")),
+    "dbname": os.environ["DESTINATION_DB_NAME"],
+    "user": os.environ["DESTINATION_DB_USER"],
+    "password": os.environ["DESTINATION_DB_PASSWORD"],
+}
+
+Migration(data=origem, new_data=destino).run()
+```
+
+Execute o arquivo normalmente:
+
+```bash
+python spark_migration.py
+```
+
+Exemplo de saída:
+
+```text
+INFO | Starting Spark session...
+INFO | Spark session started.
+INFO | Connecting to database postgres...
+INFO | Discovered 1 table(s): orders
+INFO | Starting database migration...
+INFO | Reading table orders (attempt 1/3)
+INFO | Table orders written successfully.
+INFO | Database migration completed successfully.
+```
+
+## Configuração da conexão
+
+Os parâmetros `data` e `new_data` recebem os mesmos campos:
+
+| Campo | Tipo | Descrição |
+| --- | --- | --- |
+| `host` | `str` | Endereço ou IP do servidor PostgreSQL |
+| `port` | `int` | Porta do PostgreSQL, normalmente `5432` |
+| `dbname` | `str` | Nome do banco de dados |
+| `user` | `str` | Usuário do banco |
+| `password` | `str` | Senha do banco |
+
+## Comportamento da escrita
+
+A versão atual utiliza o modo `append` do Spark.
+
+- Se a tabela não existir no destino, o Spark a criará com base no DataFrame.
+- Se a tabela já existir, os novos registros serão adicionados.
+- Executar a mesma migração mais de uma vez pode duplicar os dados.
+- Uma falha durante a escrita pode deixar dados parciais no destino.
+
+Utilize um destino limpo para migrações completas e compare a quantidade de registros na origem e no destino antes de repetir uma execução.
+
+## Escopo e limitações atuais
+
+O framework atualmente migra os registros das tabelas. Ele ainda não reproduz todos os objetos e configurações do PostgreSQL, incluindo:
+
+- chaves primárias e estrangeiras;
+- índices e restrições únicas;
+- sequências e seus valores atuais;
+- views e materialized views;
+- triggers e funções armazenadas;
+- usuários, permissões e políticas de segurança em nível de linha;
+- extensões e configurações do banco.
+
+Em migrações de produção, recrie e valide esses objetos separadamente.
+
+## Observações para Windows
+
+O Spark pode informar que `winutils.exe`, `HADOOP_HOME` ou a biblioteca nativa do Hadoop não estão disponíveis. O framework carrega diretamente o driver JDBC incluído no pacote, portanto esses avisos não impedem o fluxo suportado de migração PostgreSQL.
+
+Se o Spark não iniciar, confirme se o Java 17 está instalado:
+
+```powershell
+java -version
+```
+
+## Solução de problemas
+
+### `Connection reset`
+
+O banco ou o gerenciador de conexões encerrou a conexão JDBC. O framework repete automaticamente a leitura até três vezes. Se o problema continuar, verifique o estado do banco, a estabilidade da rede, os requisitos de SSL e os limites do pool de conexões.
+
+### `Migration failed`
+
+A thread principal recebeu uma exceção de uma tarefa. Procure o primeiro erro de banco ou Spark exibido antes dessa mensagem; normalmente ele contém a causa real.
+
+### Porta da interface Spark ocupada
+
+O Spark pode selecionar outra porta quando a porta local `4040` já estiver em uso. Isso é apenas informativo e normalmente não impede a migração.
+
+## Segurança
+
+- Nunca inclua senhas de banco ou tokens do PyPI no repositório.
+- Prefira variáveis de ambiente ou um gerenciador de segredos.
+- Utilize usuários de banco dedicados e com as menores permissões necessárias.
+- Troque credenciais que já tenham sido publicadas ou compartilhadas.
+
+## Status do projeto
+
+Spark Migration está em fase **Beta**. A migração de registros entre bancos PostgreSQL está funcional. Modos de escrita idempotentes, migração completa do esquema, validação automática e suporte a outros bancos ainda estão em desenvolvimento.
+
+## Roadmap
+
+- Modos configuráveis `append`, `overwrite` e falha se a tabela existir.
+- Validação por quantidade de registros e checksum.
+- Migração de esquema, restrições, índices e sequências.
+- Filtros para incluir ou excluir tabelas.
+- Configuração de concorrência e tentativas.
+- Testes automatizados e integração contínua.
+- Suporte a outros bancos compatíveis com JDBC.

spark_migration-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "spark_migration"
+version = "0.1.0"
+description = "Spark Migration: framework concorrente para migracao de dados PostgreSQL com Apache Spark."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pyspark>=4.0,<5",
+    "SQLAlchemy>=2.0,<3",
+    "psycopg2-binary>=2.9,<3",
+]
+keywords = [
+    "database",
+    "migration",
+    "postgresql",
+    "pyspark",
+    "spark",
+    "etl",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["Migration*"]
+namespaces = true
+
+[tool.setuptools.package-data]
+Migration = ["drivers/*.jar"]

spark_migration-0.1.0/setup.cfg

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

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

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: spark_migration
+Version: 0.1.0
+Summary: Spark Migration: framework concorrente para migracao de dados PostgreSQL com Apache Spark.
+Keywords: database,migration,postgresql,pyspark,spark,etl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pyspark<5,>=4.0
+Requires-Dist: SQLAlchemy<3,>=2.0
+Requires-Dist: psycopg2-binary<3,>=2.9
+
+<div align="center">
+
+# Spark Migration
+
+### Um framework concorrente para migração de dados PostgreSQL com Apache Spark
+
+[![Python](https://img.shields.io/badge/Python-3.10%2B-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)
+[![Apache Spark](https://img.shields.io/badge/Apache_Spark-4.x-E25A1C?style=for-the-badge&logo=apachespark&logoColor=white)](https://spark.apache.org/)
+[![PostgreSQL](https://img.shields.io/badge/PostgreSQL-Suportado-4169E1?style=for-the-badge&logo=postgresql&logoColor=white)](https://www.postgresql.org/)
+[![Status](https://img.shields.io/badge/Status-Beta-F59E0B?style=for-the-badge)](#status-do-projeto)
+
+Descubra tabelas, execute tarefas concorrentes e transfira dados via JDBC usando uma única sessão Spark compartilhada.
+
+</div>
+
+---
+
+## Visão geral
+
+Spark Migration é um framework Python para copiar dados entre bancos PostgreSQL. Ele combina SQLAlchemy para inspecionar o banco de origem, Apache Spark para transferir os dados via JDBC e um conjunto controlado de threads para processar as tabelas concorrentemente.
+
+A API pública foi projetada para ser simples:
+
+```python
+Migration(data=origem, new_data=destino).run()
+```
+
+## Recursos
+
+- Descoberta automática das tabelas do banco de origem.
+- Leitura e escrita via JDBC com Apache Spark.
+- Execução concorrente de até quatro tabelas.
+- Uma única sessão Spark compartilhada entre todas as tarefas.
+- Até três tentativas para falhas temporárias de leitura.
+- Propagação de erros das tarefas para a thread principal.
+- Driver JDBC do PostgreSQL incluído no pacote.
+- Logs estruturados em inglês.
+
+## Como funciona
+
+```mermaid
+flowchart LR
+    A["PostgreSQL de origem"] -->|"Descobre tabelas"| B["SQLAlchemy"]
+    B --> C["Serviço Spark Migration"]
+    C -->|"Uma tarefa por tabela"| D["Pool de threads"]
+    D --> E["Sessão Spark compartilhada"]
+    E -->|"Leitura JDBC"| A
+    E -->|"Escrita JDBC em append"| F["PostgreSQL de destino"]
+    D -->|"Resultado ou erro"| C
+```
+
+1. `Migration` formata as configurações de conexão da origem e do destino.
+2. O SQLAlchemy conecta-se à origem e descobre suas tabelas.
+3. O serviço cria uma tarefa para cada tabela encontrada.
+4. Cada tarefa lê sua tabela em um DataFrame Spark via JDBC.
+5. O Spark adiciona o DataFrame à tabela correspondente no destino.
+6. A thread principal aguarda os resultados e interrompe a execução quando uma tarefa falha.
+
+## Requisitos
+
+- Python 3.10 ou superior.
+- Java 17 disponível no `PATH`.
+- Bancos PostgreSQL de origem e destino.
+- Acesso de rede aos dois bancos.
+- Permissão de leitura nas tabelas de origem.
+- Permissões de criação e inserção no destino.
+
+## Instalação
+
+Instale o Spark Migration e suas dependências diretamente pelo PyPI:
+
+```bash
+pip install spark_migration
+```
+
+Após a instalação, o framework é importado como `Migration`.
+
+## Uso rápido
+
+Mantenha as credenciais fora do código-fonte. Este exemplo utiliza variáveis de ambiente:
+
+```python
+import os
+
+from Migration import Migration
+
+origem = {
+    "host": os.environ["SOURCE_DB_HOST"],
+    "port": int(os.getenv("SOURCE_DB_PORT", "5432")),
+    "dbname": os.environ["SOURCE_DB_NAME"],
+    "user": os.environ["SOURCE_DB_USER"],
+    "password": os.environ["SOURCE_DB_PASSWORD"],
+}
+
+destino = {
+    "host": os.environ["DESTINATION_DB_HOST"],
+    "port": int(os.getenv("DESTINATION_DB_PORT", "5432")),
+    "dbname": os.environ["DESTINATION_DB_NAME"],
+    "user": os.environ["DESTINATION_DB_USER"],
+    "password": os.environ["DESTINATION_DB_PASSWORD"],
+}
+
+Migration(data=origem, new_data=destino).run()
+```
+
+Execute o arquivo normalmente:
+
+```bash
+python spark_migration.py
+```
+
+Exemplo de saída:
+
+```text
+INFO | Starting Spark session...
+INFO | Spark session started.
+INFO | Connecting to database postgres...
+INFO | Discovered 1 table(s): orders
+INFO | Starting database migration...
+INFO | Reading table orders (attempt 1/3)
+INFO | Table orders written successfully.
+INFO | Database migration completed successfully.
+```
+
+## Configuração da conexão
+
+Os parâmetros `data` e `new_data` recebem os mesmos campos:
+
+| Campo | Tipo | Descrição |
+| --- | --- | --- |
+| `host` | `str` | Endereço ou IP do servidor PostgreSQL |
+| `port` | `int` | Porta do PostgreSQL, normalmente `5432` |
+| `dbname` | `str` | Nome do banco de dados |
+| `user` | `str` | Usuário do banco |
+| `password` | `str` | Senha do banco |
+
+## Comportamento da escrita
+
+A versão atual utiliza o modo `append` do Spark.
+
+- Se a tabela não existir no destino, o Spark a criará com base no DataFrame.
+- Se a tabela já existir, os novos registros serão adicionados.
+- Executar a mesma migração mais de uma vez pode duplicar os dados.
+- Uma falha durante a escrita pode deixar dados parciais no destino.
+
+Utilize um destino limpo para migrações completas e compare a quantidade de registros na origem e no destino antes de repetir uma execução.
+
+## Escopo e limitações atuais
+
+O framework atualmente migra os registros das tabelas. Ele ainda não reproduz todos os objetos e configurações do PostgreSQL, incluindo:
+
+- chaves primárias e estrangeiras;
+- índices e restrições únicas;
+- sequências e seus valores atuais;
+- views e materialized views;
+- triggers e funções armazenadas;
+- usuários, permissões e políticas de segurança em nível de linha;
+- extensões e configurações do banco.
+
+Em migrações de produção, recrie e valide esses objetos separadamente.
+
+## Observações para Windows
+
+O Spark pode informar que `winutils.exe`, `HADOOP_HOME` ou a biblioteca nativa do Hadoop não estão disponíveis. O framework carrega diretamente o driver JDBC incluído no pacote, portanto esses avisos não impedem o fluxo suportado de migração PostgreSQL.
+
+Se o Spark não iniciar, confirme se o Java 17 está instalado:
+
+```powershell
+java -version
+```
+
+## Solução de problemas
+
+### `Connection reset`
+
+O banco ou o gerenciador de conexões encerrou a conexão JDBC. O framework repete automaticamente a leitura até três vezes. Se o problema continuar, verifique o estado do banco, a estabilidade da rede, os requisitos de SSL e os limites do pool de conexões.
+
+### `Migration failed`
+
+A thread principal recebeu uma exceção de uma tarefa. Procure o primeiro erro de banco ou Spark exibido antes dessa mensagem; normalmente ele contém a causa real.
+
+### Porta da interface Spark ocupada
+
+O Spark pode selecionar outra porta quando a porta local `4040` já estiver em uso. Isso é apenas informativo e normalmente não impede a migração.
+
+## Segurança
+
+- Nunca inclua senhas de banco ou tokens do PyPI no repositório.
+- Prefira variáveis de ambiente ou um gerenciador de segredos.
+- Utilize usuários de banco dedicados e com as menores permissões necessárias.
+- Troque credenciais que já tenham sido publicadas ou compartilhadas.
+
+## Status do projeto
+
+Spark Migration está em fase **Beta**. A migração de registros entre bancos PostgreSQL está funcional. Modos de escrita idempotentes, migração completa do esquema, validação automática e suporte a outros bancos ainda estão em desenvolvimento.
+
+## Roadmap
+
+- Modos configuráveis `append`, `overwrite` e falha se a tabela existir.
+- Validação por quantidade de registros e checksum.
+- Migração de esquema, restrições, índices e sequências.
+- Filtros para incluir ou excluir tabelas.
+- Configuração de concorrência e tentativas.
+- Testes automatizados e integração contínua.
+- Suporte a outros bancos compatíveis com JDBC.

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

@@ -0,0 +1,23 @@
+README.md
+pyproject.toml
+Migration/__init__.py
+Migration/drivers/postgresql-42.7.12.jar
+Migration/engine/__init__.py
+Migration/engine/connect.py
+Migration/engine/init_spark.py
+Migration/engine/init_task.py
+Migration/logs/__init__.py
+Migration/logs/global_logs.py
+Migration/logs/logs.py
+Migration/schema/__init__.py
+Migration/schema/control.py
+Migration/schema/model.py
+Migration/service/__init__.py
+Migration/service/main.py
+Migration/tasks/__init__.py
+Migration/tasks/task_db.py
+spark_migration.egg-info/PKG-INFO
+spark_migration.egg-info/SOURCES.txt
+spark_migration.egg-info/dependency_links.txt
+spark_migration.egg-info/requires.txt
+spark_migration.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,3 @@
+pyspark<5,>=4.0
+SQLAlchemy<3,>=2.0
+psycopg2-binary<3,>=2.9

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

@@ -0,0 +1 @@
+Migration