daedaluspy 1.0.0__tar.gz

daedaluspy-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Golden Valley
+
+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.

daedaluspy-1.0.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: daedaluspy
+Version: 1.0.0
+Summary: Code generation toolkit for data engineering
+Home-page: https://github.com/Golden-Valley-Consulting/DaedalusPy
+Author: Golden Valley Consulting LTDA
+Author-email: Golden Valley Consulting LTDA <contato@goldenvalleyc.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Golden-Valley-Consulting/daedaluspy
+Project-URL: Documentation, https://daedaluspy.readthedocs.io
+Project-URL: Repository, https://github.com/Golden-Valley-Consulting/daedaluspy
+Project-URL: Bug Tracker, https://github.com/Golden-Valley-Consulting/daedaluspy/issues
+Keywords: code-generation,data-engineering,python,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# DaedalusPy
+
+## Visão Geral
+DaedalusPy é um framework open-source para engenharia de dados, criado para acelerar a construção de bibliotecas de dados corporativas e pipelines analíticos modulares, com foco em padronização, governança, reuso e produtividade em ambientes multi-cloud.
+
+## Objetivos
+- Padronizar a modelagem, transformação e integração de dados em projetos analíticos.
+- Centralizar entidades, domínios, validações e funções reutilizáveis.
+- Facilitar a construção, orquestração e manutenção de pipelines robustos e escaláveis.
+- Promover governança, versionamento e documentação centralizada.
+
+## Macro Entregas (Explicação Detalhada)
+
+1. **Geração de Bibliotecas de Dados**
+   - **O que faz:** Cria a estrutura base de uma biblioteca de dados corporativa, centralizando entidades, configurações, serviços e ferramentas reutilizáveis.
+   - **Comando:**
+     ```bash
+     python -m daedaluspy.cli create-lib <nome> [--dataname <entidade>] [--systemname <domínio>]
+     ```
+   - **Como funciona:** Gera uma pasta `<libname>/` com subpastas para `config/`, `data/`, `service/`, `tools/` e arquivos essenciais. Isso garante que todo projeto siga o mesmo padrão e facilite o reuso entre times.
+   - **Quando usar:** Sempre que iniciar um novo domínio de dados ou projeto analítico.
+
+2. **Geração de Entidades de Dados**
+   - **O que faz:** Cria classes de entidades de negócio (ex: ClienteEntity) já com estrutura OOP, enums, validações e templates prontos para uso.
+   - **Comando:**
+     ```bash
+     python -m daedaluspy.cli create-data <ClasseEntidade> --tier <raw|clear|model> --cloud <azure|aws|google> [--columns ...]
+     ```
+   - **Como funciona:** Gera arquivos Python na estrutura correta, com métodos, validações e documentação, prontos para serem usados em pipelines e serviços.
+   - **Quando usar:** Sempre que precisar modelar uma nova entidade de dados, seja para ingestão, transformação ou consumo.
+
+3. **Geração de Serviços**
+   - **O que faz:** Cria serviços de integração (ex: APIs, bancos de dados) já integrados à biblioteca, seguindo padrões de OOP e enums.
+   - **Comando:**
+     ```bash
+     python -m daedaluspy.cli create-service <NomeServico> --type <api|database> [--models ...]
+     ```
+   - **Como funciona:** Gera a estrutura de serviço, facilitando integrações externas e padronizando o acesso a dados.
+   - **Quando usar:** Sempre que precisar integrar uma nova fonte ou destino de dados ao seu ecossistema.
+
+4. **Geração de Pipelines**
+   - **O que faz:** Cria a estrutura de um pipeline modular, pronto para orquestração, sem subpastas desnecessárias e com todos os arquivos essenciais (main, config, steps, etc).
+   - **Comando:**
+     ```bash
+     python -m daedaluspy.cli create-pipeline <domínio> <entidade> --tier <raw|clear|model> --output <pasta> [--template_type ...] [--lib_name ...] [--cloud_provider ...] [--entity_target ...] [--entity_target_class ...]
+     ```
+   - **Como funciona:** Gera uma pasta do pipeline diretamente no local especificado, pronta para receber a lógica de negócio e ser executada.
+   - **Quando usar:** Sempre que precisar criar um novo fluxo de ingestão, transformação ou entrega de dados, reaproveitando entidades e serviços da biblioteca.
+
+---
+
+Cada comando do DaedalusPy foi desenhado para garantir padronização, acelerar o desenvolvimento e permitir que o engenheiro de dados foque no que realmente importa: a lógica de negócio e a entrega de valor. O CLI não substitui o trabalho do desenvolvedor, mas elimina o retrabalho estrutural e direciona o padrão arquitetural do projeto.
+
+## Casos de Uso Reais
+
+- **Criar biblioteca de dados corporativa:**
+  ```bash
+  python -m daedaluspy.cli create-lib corp_data
+  ```
+
+- **Adicionar entidade de negócio:**
+  ```bash
+  python -m daedaluspy.cli create-data ClienteEntity --tier raw --cloud azure
+  ```
+
+- **Adicionar serviço de integração:**
+  ```bash
+  python -m daedaluspy.cli create-service Salesforce --type api
+  ```
+
+- **Gerar pipeline para domínio/entidade/camada:**
+  ```bash
+  python -m daedaluspy.cli create-pipeline vendas ClienteEntity --tier clear --output .
+  ```
+
+## Estrutura Gerada (Exemplo Real)
+
+```
+corp_data/
+  config/
+    __init__.py
+    config.py
+  data/
+    raw/
+      __init__.py
+      ClienteEntity.py
+    clear/
+    model/
+  service/
+    salesforce/
+      __init__.py
+  tools/
+    logger/
+      __init__.py
+  __init__.py
+  README.md
+  setup.py
+
+vendas_ClienteEntity_clear/
+  __init__.py
+  base.py
+  config.py
+  flowbuilder.py
+  main.py
+  README.md
+  requirements.txt
+  steps.py
+```
+
+## Fluxo de Trabalho Típico
+
+1. **Crie a biblioteca:**  
+   `python -m daedaluspy.cli create-lib corp_data`
+2. **Adicione entidades e serviços:**  
+   `python -m daedaluspy.cli create-data ClienteEntity --tier raw --cloud azure`  
+   `python -m daedaluspy.cli create-service Salesforce --type api`
+3. **Gere o pipeline:**  
+   `python -m daedaluspy.cli create-pipeline vendas ClienteEntity --tier clear --output .`
+4. **Implemente lógica e execute.**
+
+## Integração e Extensibilidade
+- Suporte a múltiplos clouds e bancos.
+- Templates customizáveis.
+- Código OOP, enums e tipagem forte.
+- CLI extensível para novos comandos.
+
+## Melhores Práticas
+- Use o CLI para gerar a estrutura base e arquivos padronizados.
+- Implemente a lógica de negócio, transformações e integrações nos arquivos gerados.
+- Siga os padrões de OOP, enums e templates definidos pelo framework.
+- Evite alterar manualmente a estrutura dos arquivos base gerados pelo CLI (exceto para lógica de negócio).
+- Mantenha a biblioteca centralizada e versionada.
+- Use templates para padronizar lógica e documentação.
+
+## Público-Alvo
+- Engenheiros e arquitetos de dados
+- Times de analytics, BI e governança
+- Projetos que exigem padronização, reuso e automação
+
+## Licença
+MIT

daedaluspy-1.0.0/README.md

@@ -0,0 +1,141 @@
+# DaedalusPy
+
+## Visão Geral
+DaedalusPy é um framework open-source para engenharia de dados, criado para acelerar a construção de bibliotecas de dados corporativas e pipelines analíticos modulares, com foco em padronização, governança, reuso e produtividade em ambientes multi-cloud.
+
+## Objetivos
+- Padronizar a modelagem, transformação e integração de dados em projetos analíticos.
+- Centralizar entidades, domínios, validações e funções reutilizáveis.
+- Facilitar a construção, orquestração e manutenção de pipelines robustos e escaláveis.
+- Promover governança, versionamento e documentação centralizada.
+
+## Macro Entregas (Explicação Detalhada)
+
+1. **Geração de Bibliotecas de Dados**
+   - **O que faz:** Cria a estrutura base de uma biblioteca de dados corporativa, centralizando entidades, configurações, serviços e ferramentas reutilizáveis.
+   - **Comando:**
+     ```bash
+     python -m daedaluspy.cli create-lib <nome> [--dataname <entidade>] [--systemname <domínio>]
+     ```
+   - **Como funciona:** Gera uma pasta `<libname>/` com subpastas para `config/`, `data/`, `service/`, `tools/` e arquivos essenciais. Isso garante que todo projeto siga o mesmo padrão e facilite o reuso entre times.
+   - **Quando usar:** Sempre que iniciar um novo domínio de dados ou projeto analítico.
+
+2. **Geração de Entidades de Dados**
+   - **O que faz:** Cria classes de entidades de negócio (ex: ClienteEntity) já com estrutura OOP, enums, validações e templates prontos para uso.
+   - **Comando:**
+     ```bash
+     python -m daedaluspy.cli create-data <ClasseEntidade> --tier <raw|clear|model> --cloud <azure|aws|google> [--columns ...]
+     ```
+   - **Como funciona:** Gera arquivos Python na estrutura correta, com métodos, validações e documentação, prontos para serem usados em pipelines e serviços.
+   - **Quando usar:** Sempre que precisar modelar uma nova entidade de dados, seja para ingestão, transformação ou consumo.
+
+3. **Geração de Serviços**
+   - **O que faz:** Cria serviços de integração (ex: APIs, bancos de dados) já integrados à biblioteca, seguindo padrões de OOP e enums.
+   - **Comando:**
+     ```bash
+     python -m daedaluspy.cli create-service <NomeServico> --type <api|database> [--models ...]
+     ```
+   - **Como funciona:** Gera a estrutura de serviço, facilitando integrações externas e padronizando o acesso a dados.
+   - **Quando usar:** Sempre que precisar integrar uma nova fonte ou destino de dados ao seu ecossistema.
+
+4. **Geração de Pipelines**
+   - **O que faz:** Cria a estrutura de um pipeline modular, pronto para orquestração, sem subpastas desnecessárias e com todos os arquivos essenciais (main, config, steps, etc).
+   - **Comando:**
+     ```bash
+     python -m daedaluspy.cli create-pipeline <domínio> <entidade> --tier <raw|clear|model> --output <pasta> [--template_type ...] [--lib_name ...] [--cloud_provider ...] [--entity_target ...] [--entity_target_class ...]
+     ```
+   - **Como funciona:** Gera uma pasta do pipeline diretamente no local especificado, pronta para receber a lógica de negócio e ser executada.
+   - **Quando usar:** Sempre que precisar criar um novo fluxo de ingestão, transformação ou entrega de dados, reaproveitando entidades e serviços da biblioteca.
+
+---
+
+Cada comando do DaedalusPy foi desenhado para garantir padronização, acelerar o desenvolvimento e permitir que o engenheiro de dados foque no que realmente importa: a lógica de negócio e a entrega de valor. O CLI não substitui o trabalho do desenvolvedor, mas elimina o retrabalho estrutural e direciona o padrão arquitetural do projeto.
+
+## Casos de Uso Reais
+
+- **Criar biblioteca de dados corporativa:**
+  ```bash
+  python -m daedaluspy.cli create-lib corp_data
+  ```
+
+- **Adicionar entidade de negócio:**
+  ```bash
+  python -m daedaluspy.cli create-data ClienteEntity --tier raw --cloud azure
+  ```
+
+- **Adicionar serviço de integração:**
+  ```bash
+  python -m daedaluspy.cli create-service Salesforce --type api
+  ```
+
+- **Gerar pipeline para domínio/entidade/camada:**
+  ```bash
+  python -m daedaluspy.cli create-pipeline vendas ClienteEntity --tier clear --output .
+  ```
+
+## Estrutura Gerada (Exemplo Real)
+
+```
+corp_data/
+  config/
+    __init__.py
+    config.py
+  data/
+    raw/
+      __init__.py
+      ClienteEntity.py
+    clear/
+    model/
+  service/
+    salesforce/
+      __init__.py
+  tools/
+    logger/
+      __init__.py
+  __init__.py
+  README.md
+  setup.py
+
+vendas_ClienteEntity_clear/
+  __init__.py
+  base.py
+  config.py
+  flowbuilder.py
+  main.py
+  README.md
+  requirements.txt
+  steps.py
+```
+
+## Fluxo de Trabalho Típico
+
+1. **Crie a biblioteca:**  
+   `python -m daedaluspy.cli create-lib corp_data`
+2. **Adicione entidades e serviços:**  
+   `python -m daedaluspy.cli create-data ClienteEntity --tier raw --cloud azure`  
+   `python -m daedaluspy.cli create-service Salesforce --type api`
+3. **Gere o pipeline:**  
+   `python -m daedaluspy.cli create-pipeline vendas ClienteEntity --tier clear --output .`
+4. **Implemente lógica e execute.**
+
+## Integração e Extensibilidade
+- Suporte a múltiplos clouds e bancos.
+- Templates customizáveis.
+- Código OOP, enums e tipagem forte.
+- CLI extensível para novos comandos.
+
+## Melhores Práticas
+- Use o CLI para gerar a estrutura base e arquivos padronizados.
+- Implemente a lógica de negócio, transformações e integrações nos arquivos gerados.
+- Siga os padrões de OOP, enums e templates definidos pelo framework.
+- Evite alterar manualmente a estrutura dos arquivos base gerados pelo CLI (exceto para lógica de negócio).
+- Mantenha a biblioteca centralizada e versionada.
+- Use templates para padronizar lógica e documentação.
+
+## Público-Alvo
+- Engenheiros e arquitetos de dados
+- Times de analytics, BI e governança
+- Projetos que exigem padronização, reuso e automação
+
+## Licença
+MIT

daedaluspy-1.0.0/daedaluspy/__init__.py

@@ -0,0 +1,6 @@
+"""
+DaedalusPy - Data Engineering Library Code Generator
+"""
+
+__version__ = "1.0.0"
+__author__ = "Golden Valley Consulting"

daedaluspy-1.0.0/daedaluspy/__main__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""
+DaedalusPy - Toolkit de geração de código para engenharia de dados
+Entry point para execução via python -m daedaluspy
+"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

daedaluspy-1.0.0/daedaluspy/cli.py

@@ -0,0 +1,172 @@
+from daedaluspy.data_pipeline.template.complete_templates import get_template_set
+from daedaluspy.data_pipeline.generator.pipeline_generator_oop import PipelineGenerator, PipelineTier, CloudProvider as PipelineCloudProvider
+import argparse
+import sys
+from enum import Enum
+from daedaluspy.data_lib.generator.library_generator import LibraryGenerator
+from daedaluspy.data_lib.generator.data_entity_oop import DataEntityGenerator, CloudProvider
+from daedaluspy.data_lib.generator.service_generator_oop import ServiceGenerator
+
+class Tier(Enum):
+    RAW = "raw"
+    CLEAR = "clear"
+    MODEL = "model"
+
+class ServiceType(Enum):
+    API = "api"
+    DATABASE = "database"
+
+class Command:
+    def execute(self, args):
+        raise NotImplementedError
+
+class CreateLibCommand(Command):
+    def execute(self, args):
+        generator = LibraryGenerator(
+            name=args.name,
+            data_name=args.dataname,
+            system_name=args.systemname
+        )
+        generator.generate()
+        print(f"Estrutura da biblioteca '{args.name}' criada com sucesso!")
+
+class CreateDataCommand(Command):
+    def execute(self, args):
+        if not args.tier:
+            print("Erro: --tier é obrigatório (raw, clear, model)")
+            sys.exit(1)
+        tier = Tier(args.tier)
+        generator = DataEntityGenerator(
+            classname=args.name,
+            tier=tier,
+            cloud_provider=CloudProvider(args.cloud),
+            columns=args.columns or [],
+            output_path=args.output or f"./{args.name.lower()}/{tier.value}"
+        )
+        generator.generate()
+        print(f"Entidade '{args.name}' criada com sucesso na camada {tier.value}.")
+
+class CreateServiceCommand(Command):
+    def execute(self, args):
+        service_type = ServiceType(args.type)
+        # Permite argumentos opcionais futuros
+        extra_kwargs = {}
+        if hasattr(args, 'output') and args.output:
+            extra_kwargs['output_path'] = args.output
+        # Converter models de lista de strings JSON para lista de dicts
+        import json
+        models = []
+        if args.models:
+            for m in args.models:
+                if isinstance(m, dict):
+                    models.append(m)
+                else:
+                    try:
+                        models.append(json.loads(m))
+                    except Exception:
+                        pass
+        generator = ServiceGenerator(
+            service_name=args.name,
+            service_type=service_type,
+            models=models,
+            **extra_kwargs
+        )
+        generator.generate()
+        print(f"Serviço '{args.name}' ({service_type.value}) criado com sucesso.")
+
+class CreatePipelineCommand(Command):
+    def execute(self, args):
+        tier = PipelineTier(args.tier)
+        # Permitir todos os parâmetros opcionais igual ao create-pipeline-project
+        def enum_from_value(enum_cls, value):
+            for e in enum_cls:
+                if value == e.value or value == e.name or value.upper() == e.name:
+                    return e
+            raise ValueError(f"{value} não é válido para {enum_cls.__name__}")
+
+        generator = PipelineGenerator(
+            system_name=args.system_name,
+            dataname=args.dataname,
+            tier=tier,
+            output_path=args.output if args.output else ".",
+            template_type=getattr(args, "template_type", "all"),
+            lib_name=getattr(args, "lib_name", "atlaspy"),
+            cloud_provider=enum_from_value(PipelineCloudProvider, getattr(args, "cloud_provider", "cloud_azure")),
+            entity_target=getattr(args, "entity_target", None),
+            entity_target_class=getattr(args, "entity_target_class", None)
+        )
+        generator.generate()
+        print(f"Pipeline '{args.system_name}/{args.dataname}/{tier.value}' criado com sucesso.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="DaedalusPy CLI")
+    subparsers = parser.add_subparsers(dest="command")
+    # create pipeline project (completo)
+    parser_pipeline_project = subparsers.add_parser("create-pipeline-project")
+    parser_pipeline_project.add_argument("system_name")
+    parser_pipeline_project.add_argument("dataname")
+    parser_pipeline_project.add_argument("tier", choices=["raw", "clear", "model"])
+    parser_pipeline_project.add_argument("--output", "-o", default=".")
+    parser_pipeline_project.add_argument("--template-type", "-t", choices=["essential", "dev", "all"], default="all")
+    parser_pipeline_project.add_argument("--lib-name", default="atlaspy")
+    parser_pipeline_project.add_argument("--cloud-provider", default="cloud_azure")
+    parser_pipeline_project.add_argument("--entity-target", default="azure_sql_database")
+    parser_pipeline_project.add_argument("--entity-target-class", default="AzureSQLDatabase")
+
+    # create lib
+    parser_lib = subparsers.add_parser("create-lib")
+    parser_lib.add_argument("name")
+    parser_lib.add_argument("--dataname")
+    parser_lib.add_argument("--systemname")
+
+    # create data
+    parser_data = subparsers.add_parser("create-data")
+    parser_data.add_argument("name")
+    parser_data.add_argument("--tier", required=True, choices=[t.value for t in Tier])
+    parser_data.add_argument("--cloud", required=True)
+    parser_data.add_argument("--extension")
+    parser_data.add_argument("--columns", nargs="*")
+    parser_data.add_argument("--imports")
+    parser_data.add_argument("--read_code")
+    parser_data.add_argument("--write_code")
+    parser_data.add_argument("--output")
+    parser_data.add_argument("--lib")
+
+
+    # create service
+    parser_service = subparsers.add_parser("create-service")
+    parser_service.add_argument("name")
+    parser_service.add_argument("--type", required=True, choices=[t.value for t in ServiceType])
+    parser_service.add_argument("--models", nargs="*")
+    parser_service.add_argument("--output")
+
+    # create pipeline
+    parser_pipeline = subparsers.add_parser("create-pipeline")
+    parser_pipeline.add_argument("system_name")
+    parser_pipeline.add_argument("dataname")
+    parser_pipeline.add_argument("--tier", required=True, choices=[t.value for t in PipelineTier])
+    parser_pipeline.add_argument("--output", default=".")
+    parser_pipeline.add_argument("--template_type", default="all")
+    parser_pipeline.add_argument("--lib_name", default="atlaspy")
+    parser_pipeline.add_argument("--cloud_provider", default="cloud_azure")
+    parser_pipeline.add_argument("--entity_target", default="azure_sql_database")
+    parser_pipeline.add_argument("--entity_target_class", default="AzureSQLDatabase")
+
+    args = parser.parse_args()
+
+
+    commands = {
+        "create-lib": CreateLibCommand(),
+        "create-data": CreateDataCommand(),
+        "create-service": CreateServiceCommand(),
+        "create-pipeline": CreatePipelineCommand(),
+    }
+
+    if args.command in commands:
+        commands[args.command].execute(args)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

daedaluspy-1.0.0/daedaluspy/data_lib/__init__.py

@@ -0,0 +1,38 @@
+"""
+DaedalusPy - Framework para Engenharia de Dados Multi-Cloud
+
+Este módulo fornece ferramentas para automatizar e padronizar o desenvolvimento
+de soluções de engenharia de dados em múltiplas plataformas cloud.
+
+Módulos principais:
+- data: Biblioteca para templates e estruturas de dados
+- generator: Biblioteca para geração de entidades e integrações  
+- services: Biblioteca para templates de serviços
+
+Exemplo de uso:
+    from data_lib.generator.data_entity import generate_entity_file
+    
+    generate_entity_file(
+        cloud_provider="azure",
+        classname="MinhaEntidade",
+        file_extension="parquet",
+        columns=['col1', 'col2'],
+        imports="import pandas as pd",
+        read_code="return pd.read_parquet(buffer)",
+        write_code="data.to_parquet(buffer, index=False)",
+        output_path="./output"
+    )
+
+Autor: Golden Valley Consulting LTDA
+Licença: MIT
+"""
+
+__version__ = "1.0.0"
+__author__ = "Golden Valley Consulting LTDA"
+
+# Importações principais
+from . import data
+from . import generator
+from . import services
+
+__all__ = ['data', 'generator', 'services']