konecty-sdk-python 0.1.0__tar.gz

konecty_sdk_python-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# PyPI
+.pypirc

konecty_sdk_python-0.1.0/.python-version

@@ -0,0 +1 @@
+3.11

konecty_sdk_python-0.1.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: konecty-sdk-python
+Version: 0.1.0
+Summary: Konecty SDK Python
+Author-email: Leonardo Leal <leonardo.leal@konecty.com>, Derotino Silveira <derotino.silveira@konecty.com>
+License: MIT
+Keywords: api,konecty,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.11.11
+Requires-Dist: asyncio>=3.4.3
+Requires-Dist: black>=24.10.0
+Requires-Dist: email-validator>=2.2.0
+Requires-Dist: inquirer>=3.4.0
+Requires-Dist: pydantic>=2.11.4
+Requires-Dist: pymongo>=4.10.1
+Requires-Dist: requests>=2.32.3
+Requires-Dist: rich>=13.9.4
+Requires-Dist: typing-extensions>=4.12.2
+Description-Content-Type: text/markdown
+
+## Konecty Python SDK
+
+> 🛠️ Work in progress

konecty_sdk_python-0.1.0/README.md

@@ -0,0 +1,3 @@
+## Konecty Python SDK
+
+> 🛠️ Work in progress

konecty_sdk_python-0.1.0/__init__.py

@@ -0,0 +1,5 @@
+"""Konecty metadata management package."""
+
+from .cli import apply_command, backup_command, pull_command
+
+__all__ = ["apply_command", "backup_command", "pull_command"]

konecty_sdk_python-0.1.0/cli/__init__.py

@@ -0,0 +1,7 @@
+"""CLI tools for Konecty metadata management."""
+
+from .apply import apply_command
+from .backup import backup_command
+from .pull import pull_command
+
+__all__ = ["apply_command", "backup_command", "pull_command"]

konecty_sdk_python-0.1.0/cli/apply.py

@@ -0,0 +1,455 @@
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#     "click",
+#     "inquirer",
+#     "pymongo",
+#     "rich",
+# ]
+# ///
+"""Script para aplicar alterações locais ao MongoDB."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Set, Tuple, TypedDict, cast
+
+import inquirer
+from pymongo import MongoClient
+from rich.console import Console
+from rich.progress import Progress
+from rich.table import Table
+
+
+class DocFiles(TypedDict):
+    document: List[Path]
+    view: List[Path]
+    list: List[Path]
+    pivot: List[Path]
+    access: List[Path]
+    hook: List[Path]
+
+
+DocType = Literal["document", "view", "list", "pivot", "access", "hook"]
+MetaType = Literal["view", "list", "pivot", "access"]
+
+
+console = Console()
+
+
+def load_json_file(file_path: Path) -> dict:
+    """Carrega um arquivo JSON."""
+    try:
+        return json.loads(file_path.read_text())
+    except Exception as error:
+        console.print(f"[red]Erro ao ler arquivo {file_path}[/red]: {str(error)}")
+        return {}
+
+
+def find_metadata_files(metadata_dir: Path) -> Dict[str, DocFiles]:
+    """Encontra todos os arquivos de metadados no diretório."""
+    result: Dict[str, DocFiles] = {}
+
+    for doc_dir in metadata_dir.iterdir():
+        if not doc_dir.is_dir():
+            continue
+
+        doc_files: DocFiles = {
+            "document": [],
+            "view": [],
+            "list": [],
+            "pivot": [],
+            "access": [],
+            "hook": [],
+        }
+
+        # Documento principal
+        doc_file = doc_dir / "document.json"
+        if doc_file.exists():
+            doc_files["document"].append(doc_file)
+
+        # Views, lists, pivots e access
+        for type_name in ("view", "list", "pivot", "access"):
+            type_name_key = cast(MetaType, type_name)
+            type_dir = doc_dir / type_name
+            if type_dir.exists():
+                doc_files[type_name_key].extend(sorted(type_dir.glob("*.json")))
+
+        # Hooks
+        hook_dir = doc_dir / "hook"
+        if hook_dir.exists():
+            doc_files["hook"].extend(sorted(hook_dir.glob("*.*")))
+
+        if any(files for files in doc_files.values()):
+            result[doc_dir.name] = doc_files
+
+    return result
+
+
+def is_equal_documents(doc1: dict, doc2: dict) -> bool:
+    """Compara dois documentos ignorando campos específicos."""
+    # Campos para ignorar na comparação
+    ignore_fields = ["_id", "_createdAt", "_updatedAt", "_createdBy", "_updatedBy"]
+
+    # Cria cópias para não modificar os originais
+    doc1_copy = doc1.copy()
+    doc2_copy = doc2.copy()
+
+    # Remove campos ignorados
+    for field in ignore_fields:
+        doc1_copy.pop(field, None)
+        doc2_copy.pop(field, None)
+
+    return doc1_copy == doc2_copy
+
+
+async def apply_document(
+    collection,
+    doc_name: str,
+    doc_files: DocFiles,
+    dry_run: bool = False,
+) -> Tuple[List[str], List[str], List[str]]:
+    """Aplica as alterações de um documento."""
+    applied = []
+    errors = []
+    skipped = []
+
+    # Documento principal
+    if doc_files["document"]:
+        doc_data = load_json_file(doc_files["document"][0])
+        if doc_data:
+            existing_doc = collection.find_one({"name": doc_name, "type": {"$in": ["composite", "document"]}})
+
+            if existing_doc and is_equal_documents(doc_data, existing_doc):
+                skipped.append(f"⚡ {doc_name} (document) [identical]")
+            else:
+                if not dry_run:
+                    try:
+                        collection.replace_one(
+                            {"name": doc_name, "type": {"$in": ["composite", "document"]}}, doc_data, upsert=True
+                        )
+                        applied.append(f"✓ {doc_name} (document)")
+                    except Exception as error:
+                        errors.append(f"✗ {doc_name} (document): {str(error)}")
+                else:
+                    applied.append(f"✓ {doc_name} (document) [dry-run]")
+
+    # Views, lists, pivots e access
+    existing_data: dict[str, Any] | None = None
+    data: Any
+
+    for type_name in ("view", "list", "pivot", "access"):
+        type_name_key = cast(MetaType, type_name)
+        for file_path in doc_files[type_name_key]:
+            data = load_json_file(file_path)
+            if data:
+                existing_data = collection.find_one({"name": data["name"], "type": type_name, "document": doc_name})
+
+                if existing_data and is_equal_documents(data, existing_data):
+                    skipped.append(f"⚡ {doc_name}/{type_name}/{data['name']} [identical]")
+                else:
+                    if not dry_run:
+                        try:
+                            collection.replace_one(
+                                {"name": data["name"], "type": type_name, "document": doc_name}, data, upsert=True
+                            )
+                            applied.append(f"✓ {doc_name}/{type_name}/{data['name']}")
+                        except Exception as error:
+                            errors.append(f"✗ {doc_name}/{type_name}/{data['name']}: {str(error)}")
+                    else:
+                        applied.append(f"✓ {doc_name}/{type_name}/{data['name']} [dry-run]")
+
+    # Hooks
+    for file_path in doc_files["hook"]:
+        data = file_path.read_text()
+        if data:
+            existing_data = collection.find_one({"name": doc_name, "type": {"$in": ["composite", "document"]}})
+            hook_name = file_path.stem
+            if existing_data:
+                if existing_data.get(hook_name, None) == data:
+                    skipped.append(f"⚡ {doc_name}/{hook_name} [identical]")
+                else:
+                    if not dry_run:
+                        try:
+                            collection.update_one(
+                                {"name": doc_name, "type": {"$in": ["composite", "document"]}},
+                                {"$set": {hook_name: data}},
+                            )
+                            applied.append(f"✓ {doc_name}/{hook_name}")
+                        except Exception as error:
+                            errors.append(f"✗ {doc_name}/{hook_name}: {str(error)}")
+                    else:
+                        applied.append(f"✓ {doc_name}/{hook_name} [dry-run]")
+
+    return applied, errors, skipped
+
+
+async def prune_documents(
+    collection,
+    local_docs: Set[str],
+    dry_run: bool = False,
+) -> Tuple[List[str], List[str]]:
+    """Remove documentos que não existem localmente."""
+    pruned = []
+    errors = []
+
+    # Encontra documentos no banco que não existem localmente
+    remote_docs = set(
+        doc["name"]
+        for doc in collection.find({"type": {"$in": ["composite", "document"]}, "name": {"$ne": "_id"}}, {"name": 1})
+    )
+
+    to_remove = remote_docs - local_docs
+
+    for doc_name in to_remove:
+        if not dry_run:
+            try:
+                # Remove documento principal
+                collection.delete_one({"name": doc_name, "type": {"$in": ["composite", "document"]}})
+                # Remove documentos relacionados
+                collection.delete_many({"document": doc_name})
+                pruned.append(f"✓ {doc_name}")
+            except Exception as error:
+                errors.append(f"✗ {doc_name}: {str(error)}")
+        else:
+            pruned.append(f"✓ {doc_name} [dry-run]")
+
+    return pruned, errors
+
+
+async def apply_namespace(
+    collection,
+    metadata_dir: Path,
+    dry_run: bool = False,
+) -> Tuple[List[str], List[str], List[str]]:
+    """Aplica as alterações do Namespace."""
+    applied = []
+    errors = []
+    skipped = []
+
+    base_namespace = {
+        "_id": "Namespace",
+        "name": "konecty",
+        "type": "namespace",
+        "ns": "konecty",
+        "active": True,
+    }
+
+    namespace_file = metadata_dir / "Namespace.json"
+    if not namespace_file.exists():
+        namespace_data = base_namespace
+    else:
+        namespace_data = load_json_file(namespace_file)
+        if not namespace_data:
+            return [], ["✗ Namespace.json: Arquivo vazio ou inválido"], []
+
+    existing_namespace = collection.find_one({"_id": "Namespace"})
+
+    def compare_namespace(ns1: dict, ns2: dict) -> bool:
+        """Compara dois namespaces ignorando _id e name."""
+        ns1_copy = ns1.copy()
+        ns2_copy = ns2.copy()
+
+        ignore_fields = ["_id", "name", "ns"]
+        for field in ignore_fields:
+            ns1_copy.pop(field, None)
+            ns2_copy.pop(field, None)
+
+        return ns1_copy == ns2_copy
+
+    if existing_namespace and compare_namespace(namespace_data, existing_namespace):
+        skipped.append("⚡ Namespace.json [identical]")
+    else:
+        if not dry_run:
+            try:
+                if existing_namespace:
+                    collection.update_one({"_id": "Namespace"}, {"$set": namespace_data})
+                else:
+                    collection.insert_one({**base_namespace, **namespace_data})
+                applied.append("✓ Namespace.json")
+            except Exception as error:
+                errors.append(f"✗ Namespace.json: {str(error)}")
+        else:
+            applied.append("✓ Namespace.json [dry-run]")
+
+    return applied, errors, skipped
+
+
+async def apply_command(
+    metadata_dir: str = "metadata",
+    host: str = "localhost",
+    port: int = 27017,
+    database: str = "default",
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    replicaset: Optional[str] = None,
+    document: Optional[str] = None,
+    prune: bool = False,
+    dry_run: bool = False,
+    direct_connection: bool = False,
+    retry_writes: bool = True,
+    w: str = "majority",
+) -> None:
+    """Aplica alterações locais ao MongoDB."""
+    metadata_path = Path(metadata_dir).resolve()
+    if not metadata_path.exists():
+        console.print(f"[red]Diretório {metadata_dir} não encontrado[/red]")
+        return
+
+    uri_params = []
+    if replicaset:
+        uri_params.extend(
+            [
+                f"replicaSet={replicaset}",
+                f"directConnection={'true' if direct_connection else 'false'}",
+                f"retryWrites={'true' if retry_writes else 'false'}",
+                f"w={w}",
+            ]
+        )
+
+    uri_suffix = f"?{'&'.join(uri_params)}" if uri_params else ""
+
+    if username and password:
+        uri = f"mongodb://{username}:{password}@{host}:{port}/admin{uri_suffix}"
+    else:
+        uri = f"mongodb://{host}:{port}{uri_suffix}"
+
+    client = MongoClient(
+        uri, serverSelectionTimeoutMS=30000, connectTimeoutMS=20000, socketTimeoutMS=20000, maxPoolSize=1
+    )
+    db = client[database]
+    collection = db["MetaObjects"]
+
+    # Se o documento for Namespace, aplica apenas o Namespace
+    if document == "Namespace":
+        namespace_applied, namespace_errors, namespace_skipped = await apply_namespace(
+            collection, metadata_path, dry_run
+        )
+        table = Table(title="Resultados da Aplicação")
+        table.add_column("Documento")
+        table.add_column("Status")
+        table.add_column("Pulados")
+        table.add_column("Erros")
+        if namespace_applied or namespace_errors or namespace_skipped:
+            table.add_row(
+                "@Namespace", "\n".join(namespace_applied), "\n".join(namespace_skipped), "\n".join(namespace_errors)
+            )
+        client.close()
+        console.print(table)
+        return
+
+    # Encontra todos os arquivos de metadados
+    all_files = find_metadata_files(metadata_path)
+
+    if not all_files:
+        console.print("[yellow]Nenhum arquivo de metadados encontrado[/yellow]")
+        return
+
+    # Se nenhum documento específico foi fornecido, pergunta ao usuário
+    if document is None:
+        choices = [
+            {"name": "Todos", "value": "all"},
+            *[{"name": name, "value": name} for name in sorted(all_files.keys())],
+        ]
+
+        questions = [
+            inquirer.List(
+                "document",
+                message="Qual documento você deseja aplicar?",
+                choices=[choice["name"] for choice in choices],
+            )
+        ]
+
+        answers = inquirer.prompt(questions)
+        if answers is None:
+            console.print("[red]Operação cancelada pelo usuário[/red]")
+            return
+
+        document = "all" if answers["document"] == "Todos" else answers["document"]
+
+    # Determina quais documentos processar
+    docs_to_process = list(all_files.keys()) if document == "all" else [document]
+
+    if document != "all" and document not in all_files:
+        console.print(f"[red]Documento {document} não encontrado[/red]")
+        return
+
+    # Aplica o Namespace primeiro
+    namespace_applied, namespace_errors, namespace_skipped = await apply_namespace(collection, metadata_path, dry_run)
+
+    table = Table(title="Resultados da Aplicação")
+    table.add_column("Documento")
+    table.add_column("Status")
+    table.add_column("Pulados")
+    table.add_column("Erros")
+
+    if namespace_applied or namespace_errors or namespace_skipped:
+        table.add_row(
+            "@Namespace", "\n".join(namespace_applied), "\n".join(namespace_skipped), "\n".join(namespace_errors)
+        )
+
+    with Progress() as progress:
+        task = progress.add_task("[cyan]Aplicando alterações...", total=len(docs_to_process))
+
+        for doc_name in docs_to_process:
+            applied, errors, skipped = await apply_document(collection, doc_name, all_files[doc_name], dry_run)
+
+            table.add_row(doc_name, "\n".join(applied), "\n".join(skipped), "\n".join(errors) if errors else "")
+
+            progress.update(task, advance=1)
+
+    if prune:
+        pruned, prune_errors = await prune_documents(collection, set(all_files.keys()), dry_run)
+        if pruned or prune_errors:
+            table.add_row("Prune", "\n".join(pruned), "", "\n".join(prune_errors) if prune_errors else "")
+
+    client.close()
+    console.print(table)
+
+
+def main():
+    """Função principal para execução via linha de comando."""
+    import argparse
+    import asyncio
+    import sys
+
+    parser = argparse.ArgumentParser(description="Aplica alterações locais ao MongoDB")
+    parser.add_argument("--host", default="localhost", help="Host do MongoDB")
+    parser.add_argument("--port", type=int, default=27017, help="Porta do MongoDB")
+    parser.add_argument("--database", required=True, help="Nome do banco de dados")
+    parser.add_argument("--metadata-dir", default="metadata", help="Diretório dos metadados")
+    parser.add_argument("--username", help="Usuário do MongoDB")
+    parser.add_argument("--password", help="Senha do MongoDB")
+    parser.add_argument("--replicaset", help="Nome do ReplicaSet do MongoDB (ex: rs0)")
+    parser.add_argument("--document", help="Nome do documento específico para aplicar")
+    parser.add_argument("--prune", action="store_true", help="Remove documentos que não existem localmente")
+    parser.add_argument("--dry-run", action="store_true", help="Executa sem fazer alterações")
+    parser.add_argument("--direct-connection", action="store_true", help="Usa conexão direta com o MongoDB")
+    parser.add_argument("--no-retry-writes", action="store_true", help="Desativa retry writes")
+    parser.add_argument("--write-concern", default="majority", help="Write concern (ex: majority, 1)")
+
+    args = parser.parse_args()
+
+    if sys.platform == "win32":
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+    asyncio.run(
+        apply_command(
+            metadata_dir=args.metadata_dir,
+            host=args.host,
+            port=args.port,
+            database=args.database,
+            username=args.username,
+            password=args.password,
+            replicaset=args.replicaset,
+            document=args.document,
+            prune=args.prune,
+            dry_run=args.dry_run,
+            direct_connection=args.direct_connection,
+            retry_writes=not args.no_retry_writes,
+            w=args.write_concern,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

konecty_sdk_python-0.1.0/cli/backup.py

@@ -0,0 +1,129 @@
+"""Script para fazer backup dos documentos do MongoDB."""
+
+import json
+import tarfile
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from pymongo import MongoClient
+from rich.console import Console
+from rich.progress import Progress
+
+console = Console()
+
+
+async def backup_command(
+    host: str = "localhost",
+    port: int = 27017,
+    database: str = "default",
+    output: str = "backups",
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    replicaset: Optional[str] = None,
+    version: Optional[str] = None,
+) -> None:
+    """Gera backup dos documentos do MongoDB."""
+    output_dir = Path(output).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Gera nome do arquivo de backup
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    version_label = f"_{version}" if version else ""
+    backup_file = output_dir / f"backup_{timestamp}{version_label}.tar.gz"
+
+    uri_params = []
+    if replicaset:
+        uri_params.extend([f"replicaSet={replicaset}", "directConnection=false", "retryWrites=true", "w=majority"])
+
+    uri_suffix = f"?{'&'.join(uri_params)}" if uri_params else ""
+
+    if username and password:
+        uri = f"mongodb://{username}:{password}@{host}:{port}/admin{uri_suffix}"
+    else:
+        uri = f"mongodb://{host}:{port}{uri_suffix}"
+
+    client = MongoClient(
+        uri, serverSelectionTimeoutMS=30000, connectTimeoutMS=20000, socketTimeoutMS=20000, maxPoolSize=1
+    )
+    db = client[database]
+    collection = db["MetaObjects"]
+
+    # Cria diretório temporário
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+
+        # Busca todos os documentos
+        documents = list(collection.find({"type": {"$in": ["composite", "document"]}}))
+
+        with Progress() as progress:
+            task = progress.add_task("[cyan]Gerando backup...", total=len(documents))
+
+            # Processa cada documento
+            for doc in documents:
+                doc_path = temp_path / doc["name"]
+                doc_path.mkdir(parents=True, exist_ok=True)
+
+                # Salva documento principal
+                doc_file = doc_path / "document.json"
+                doc_file.write_text(json.dumps(doc, indent=2))
+
+                # Busca documentos relacionados
+                related = list(collection.find({"document": doc["name"]}))
+
+                for rel in related:
+                    rel_type = rel["type"]
+                    type_path = doc_path / rel_type
+                    type_path.mkdir(exist_ok=True)
+
+                    rel_file = type_path / f"{rel['name']}.json"
+                    rel_file.write_text(json.dumps(rel, indent=2))
+
+                progress.update(task, advance=1)
+
+        # Cria arquivo tar.gz
+        with tarfile.open(backup_file, "w:gz") as tar:
+            tar.add(temp_dir, arcname="metadata")
+
+    client.close()
+    console.print(f"[green]Backup concluído com sucesso:[/green] [cyan]{backup_file}[/cyan]")
+
+
+def main():
+    """Função principal para execução via linha de comando."""
+    import argparse
+    import asyncio
+    import sys
+
+    parser = argparse.ArgumentParser(description="Gera backup dos documentos do MongoDB")
+    parser.add_argument("--host", default="localhost", help="Host do MongoDB")
+    parser.add_argument("--port", type=int, default=27017, help="Porta do MongoDB")
+    parser.add_argument("--database", required=True, help="Nome do banco de dados")
+    parser.add_argument("--output", default="backups", help="Diretório para salvar o backup")
+    parser.add_argument("--username", help="Usuário do MongoDB")
+    parser.add_argument("--password", help="Senha do MongoDB")
+    parser.add_argument("--replicaset", help="Nome do ReplicaSet do MongoDB (ex: rs0)")
+    parser.add_argument("--version", help="Rótulo de versão para o arquivo de backup")
+
+    args = parser.parse_args()
+
+    if sys.platform == "win32":
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+    asyncio.run(
+        backup_command(
+            host=args.host,
+            port=args.port,
+            database=args.database,
+            output=args.output,
+            username=args.username,
+            password=args.password,
+            replicaset=args.replicaset,
+            version=args.version,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()