dbt-cube-sync 0.1.0a1__py3-none-any.whl

dbt_cube_sync/__init__.py

@@ -0,0 +1,5 @@
+"""
+dbt-cube-sync: Synchronization tool for dbt models to Cube.js schemas and BI tools
+"""
+
+__version__ = "0.1.0"

dbt_cube_sync/cli.py

@@ -0,0 +1,135 @@
+"""
+CLI interface for dbt-cube-sync tool
+"""
+import click
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .core.dbt_parser import DbtParser
+from .core.cube_generator import CubeGenerator
+from .connectors.base import ConnectorRegistry
+from .config import Config
+
+# Import connectors to register them
+from .connectors import superset, tableau, powerbi
+
+
+class CustomGroup(click.Group):
+    def get_command(self, ctx, cmd_name):
+        # Handle common mistake of typing dbt-cube-sync twice
+        if cmd_name == 'dbt-cube-sync':
+            click.echo("❌ Error: You typed 'dbt-cube-sync' twice!")
+            click.echo("💡 Just run: dbt-cube-sync <command>")
+            click.echo("\nAvailable commands:")
+            click.echo("  dbt-cube-sync --help                                    # Show help")
+            click.echo("  dbt-cube-sync --version                                 # Show version")
+            click.echo("  dbt-cube-sync dbt-to-cube -m manifest -c catalog -o output # Generate Cube.js schemas")
+            click.echo("  dbt-cube-sync cube-to-bi superset -c cubes -u url -n user -p pass -d Cube # Sync to BI tool")
+            ctx.exit(1)
+        
+        return super().get_command(ctx, cmd_name)
+
+
+@click.group(cls=CustomGroup)
+@click.version_option()
+def main():
+    """dbt-cube-sync: Synchronization tool for dbt models to Cube.js schemas and BI tools"""
+    pass
+
+
+@main.command()
+@click.option('--manifest', '-m', 
+              required=True,
+              help='Path to dbt manifest.json file')
+@click.option('--catalog', '-c',
+              required=True,
+              help='Path to dbt catalog.json file')
+@click.option('--output', '-o',
+              required=True,
+              help='Output directory for Cube.js files')
+@click.option('--template-dir', '-t',
+              default='./cube/templates',
+              help='Directory containing Cube.js templates')
+def dbt_to_cube(manifest: str, catalog: str, output: str, template_dir: str):
+    """Generate Cube.js schemas from dbt models"""
+    try:
+        click.echo("🔄 Parsing dbt manifest...")
+        parser = DbtParser(manifest, catalog)
+        models = parser.parse_models()
+        
+        click.echo(f"📊 Found {len(models)} dbt models")
+        
+        click.echo("🏗️  Generating Cube.js schemas...")
+        generator = CubeGenerator(template_dir, output)
+        generated_files = generator.generate_cube_files(models)
+        
+        click.echo(f"✅ Generated {len(generated_files)} Cube.js files:")
+        for file_path in generated_files:
+            click.echo(f"   • {file_path}")
+            
+    except Exception as e:
+        click.echo(f"❌ Error: {str(e)}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('bi_tool', type=click.Choice(['superset', 'tableau', 'powerbi']))
+@click.option('--cube-files', '-c',
+              required=True,
+              help='Directory containing Cube.js metric files')
+@click.option('--url', '-u',
+              required=True,
+              help='BI tool URL (e.g., http://localhost:8088)')
+@click.option('--username', '-n',
+              required=True,
+              help='BI tool username')
+@click.option('--password', '-p',
+              required=True,
+              help='BI tool password')
+@click.option('--cube-connection-name', '-d',
+              default='Cube',
+              help='Name of the Cube database connection in the BI tool (default: Cube)')
+def cube_to_bi(bi_tool: str, cube_files: str, url: str, username: str, password: str, cube_connection_name: str):
+    """Sync Cube.js schemas to BI tool datasets"""
+    try:
+        click.echo(f"🔄 Connecting to {bi_tool.title()} at {url}...")
+        
+        # Create connector config from command line params
+        connector_config = {
+            'url': url,
+            'username': username,
+            'password': password,
+            'database_name': cube_connection_name
+        }
+        
+        connector_instance = ConnectorRegistry.get_connector(bi_tool, **connector_config)
+        
+        click.echo(f"📊 Syncing Cube.js schemas to {bi_tool.title()}...")
+        results = connector_instance.sync_cube_schemas(cube_files)
+        
+        successful = sum(1 for r in results if r.status == 'success')
+        failed = sum(1 for r in results if r.status == 'failed')
+        
+        click.echo(f"✅ Sync complete: {successful} successful, {failed} failed")
+        
+        # Show detailed results
+        for result in results:
+            status_emoji = "✅" if result.status == 'success' else "❌"
+            click.echo(f"   {status_emoji} {result.file_or_dataset}: {result.message}")
+            
+    except Exception as e:
+        click.echo(f"❌ Error: {str(e)}", err=True)
+        sys.exit(1)
+
+
+
+@main.command()
+def version():
+    """Show version information"""
+    from . import __version__
+    click.echo(f"dbt-cube-sync version {__version__}")
+
+
+if __name__ == '__main__':
+    main()

dbt_cube_sync/config.py

@@ -0,0 +1,121 @@
+"""
+Configuration management for dbt-cube-sync
+"""
+import yaml
+from typing import Dict, Any, Optional
+from pathlib import Path
+from pydantic import BaseModel, validator
+
+
+class ConnectorConfig(BaseModel):
+    """Configuration for a BI tool connector"""
+    type: str
+    url: Optional[str] = None
+    username: Optional[str] = None
+    password: Optional[str] = None
+    database_name: Optional[str] = "Cube"
+    
+    @validator('type')
+    def validate_type(cls, v):
+        supported_types = ['superset', 'tableau', 'powerbi']
+        if v not in supported_types:
+            raise ValueError(f"Unsupported connector type: {v}. Supported: {supported_types}")
+        return v
+
+
+class Config(BaseModel):
+    """Main configuration class"""
+    connectors: Dict[str, ConnectorConfig] = {}
+    
+    @classmethod
+    def load_from_file(cls, config_path: str) -> 'Config':
+        """
+        Load configuration from YAML file
+        
+        Args:
+            config_path: Path to the YAML configuration file
+            
+        Returns:
+            Config instance
+        """
+        config_file = Path(config_path)
+        if not config_file.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+        
+        with open(config_file, 'r') as f:
+            data = yaml.safe_load(f)
+        
+        # Parse connector configurations
+        connectors = {}
+        for name, connector_data in data.get('connectors', {}).items():
+            connectors[name] = ConnectorConfig(**connector_data)
+        
+        return cls(connectors=connectors)
+    
+    def get_connector_config(self, connector_name: str) -> Dict[str, Any]:
+        """
+        Get configuration for a specific connector
+        
+        Args:
+            connector_name: Name of the connector (e.g., 'superset')
+            
+        Returns:
+            Dictionary with connector configuration
+        """
+        if connector_name not in self.connectors:
+            available = list(self.connectors.keys())
+            raise ValueError(f"Connector '{connector_name}' not found in config. Available: {available}")
+        
+        config = self.connectors[connector_name]
+        return config.dict()
+    
+    def save_to_file(self, config_path: str) -> None:
+        """
+        Save configuration to YAML file
+        
+        Args:
+            config_path: Path to save the configuration file
+        """
+        data = {
+            'connectors': {
+                name: config.dict() for name, config in self.connectors.items()
+            }
+        }
+        
+        config_file = Path(config_path)
+        config_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(config_file, 'w') as f:
+            yaml.dump(data, f, default_flow_style=False, indent=2)
+    
+    @classmethod
+    def create_sample_config(cls, config_path: str) -> None:
+        """
+        Create a sample configuration file
+        
+        Args:
+            config_path: Path to create the sample configuration file
+        """
+        sample_config = cls(
+            connectors={
+                'superset': ConnectorConfig(
+                    type='superset',
+                    url='http://localhost:8088',
+                    username='admin',
+                    password='admin',
+                    database_name='Cube'
+                ),
+                'tableau': ConnectorConfig(
+                    type='tableau',
+                    url='https://your-tableau-server.com',
+                    username='your-username',
+                    password='your-password'
+                ),
+                'powerbi': ConnectorConfig(
+                    type='powerbi',
+                    # Add PowerBI specific configuration fields here
+                )
+            }
+        )
+        
+        sample_config.save_to_file(config_path)

dbt_cube_sync/connectors/__init__.py

@@ -0,0 +1 @@
+"""BI tool connectors for syncing Cube.js schemas"""

dbt_cube_sync/connectors/base.py

@@ -0,0 +1,95 @@
+"""
+Abstract base connector for BI tools
+"""
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any
+from pathlib import Path
+
+from ..core.models import SyncResult
+
+
+class BaseConnector(ABC):
+    """Abstract base class for BI tool connectors"""
+    
+    def __init__(self, **config):
+        """
+        Initialize the connector with configuration
+        
+        Args:
+            **config: Connector-specific configuration parameters
+        """
+        self.config = config
+        self._validate_config()
+    
+    @abstractmethod
+    def _validate_config(self) -> None:
+        """Validate the provided configuration"""
+        pass
+    
+    @abstractmethod
+    def connect(self) -> None:
+        """Establish connection to the BI tool"""
+        pass
+    
+    @abstractmethod
+    def sync_cube_schemas(self, cube_dir: str) -> List[SyncResult]:
+        """
+        Sync all Cube.js schemas from directory to BI tool
+        
+        Args:
+            cube_dir: Directory containing Cube.js schema files
+            
+        Returns:
+            List of SyncResult objects with status of each file
+        """
+        pass
+    
+    @abstractmethod
+    def sync_single_schema(self, cube_file_path: str) -> SyncResult:
+        """
+        Sync a single Cube.js schema file to BI tool
+        
+        Args:
+            cube_file_path: Path to the Cube.js schema file
+            
+        Returns:
+            SyncResult object with status
+        """
+        pass
+    
+    def _get_cube_files(self, cube_dir: str) -> List[Path]:
+        """Get all .js files from the cube directory"""
+        cube_path = Path(cube_dir)
+        if not cube_path.exists():
+            raise FileNotFoundError(f"Cube directory not found: {cube_dir}")
+        
+        return list(cube_path.glob("*.js"))
+    
+    def get_connector_type(self) -> str:
+        """Return the type of this connector"""
+        return self.__class__.__name__.replace('Connector', '').lower()
+
+
+class ConnectorRegistry:
+    """Registry for managing available connectors"""
+    
+    _connectors: Dict[str, type] = {}
+    
+    @classmethod
+    def register(cls, name: str, connector_class: type) -> None:
+        """Register a connector class"""
+        cls._connectors[name] = connector_class
+    
+    @classmethod
+    def get_connector(cls, name: str, **config) -> BaseConnector:
+        """Get an instance of a registered connector"""
+        if name not in cls._connectors:
+            available = list(cls._connectors.keys())
+            raise ValueError(f"Unknown connector '{name}'. Available: {available}")
+        
+        return cls._connectors[name](**config)
+    
+    @classmethod
+    def list_connectors(cls) -> List[str]:
+        """List all registered connector names"""
+        return list(cls._connectors.keys())

dbt_cube_sync/connectors/powerbi.py

@@ -0,0 +1,34 @@
+"""
+PowerBI connector placeholder for future implementation
+"""
+from typing import List
+from .base import BaseConnector, ConnectorRegistry
+from ..core.models import SyncResult
+
+
+class PowerBIConnector(BaseConnector):
+    """Connector for Microsoft Power BI (placeholder implementation)"""
+    
+    def _validate_config(self) -> None:
+        """Validate the provided configuration"""
+        # TODO: Implement PowerBI-specific validation
+        pass
+    
+    def connect(self) -> None:
+        """Establish connection to Power BI"""
+        # TODO: Implement PowerBI connection logic
+        raise NotImplementedError("PowerBI connector not yet implemented")
+    
+    def sync_cube_schemas(self, cube_dir: str) -> List[SyncResult]:
+        """Sync all Cube.js schemas from directory to Power BI"""
+        # TODO: Implement PowerBI sync logic
+        raise NotImplementedError("PowerBI connector not yet implemented")
+    
+    def sync_single_schema(self, cube_file_path: str) -> SyncResult:
+        """Sync a single Cube.js schema file to Power BI"""
+        # TODO: Implement single schema sync for PowerBI
+        raise NotImplementedError("PowerBI connector not yet implemented")
+
+
+# Register the PowerBI connector
+ConnectorRegistry.register('powerbi', PowerBIConnector)