datasecops-cli 0.1.0__py3-none-any.whl

datasecops_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

datasecops_cli/config.py

@@ -0,0 +1,100 @@
+from pathlib import Path
+from typing import Optional
+
+from datasecops_cli.models.project_config import (
+    DatasecopsConfig, ProjectSettings, SourceControl, ProjectProfile, DbtTarget
+)
+from datasecops_cli.utilities.yaml_utils import read_datasecops_config, read_dbt_project
+from datasecops_cli.utilities.display import error_line, info_line
+
+
+class Config:
+    """Central configuration for the CLI, loaded from .datasecops.yml and native app."""
+    
+    def __init__(self):
+        self.datasecops: DatasecopsConfig = DatasecopsConfig()
+        self.project_settings: ProjectSettings = ProjectSettings()
+        self.source_control: SourceControl = SourceControl()
+        self.profile: Optional[ProjectProfile] = None
+        self.all_profiles: list[ProjectProfile] = []
+        self.project_dir: Path = Path.cwd()
+        self.dbt_project_dir: Path = Path.cwd()
+        self.profile_name: str = ""
+    
+    def load(self, project_dir: Path = None) -> bool:
+        """Load configuration from .datasecops.yml and dbt_project.yml."""
+        self.project_dir = project_dir or Path.cwd()
+        
+        # Load .datasecops.yml
+        raw = read_datasecops_config(self.project_dir)
+        if raw is None:
+            error_line("No .datasecops.yml found. Run setup.sh/setup.ps1 first.")
+            return False
+        
+        self.datasecops = DatasecopsConfig(
+            connection_name=raw.get("connection_name", ""),
+            app_database=raw.get("app_database", ""),
+            profile_name=raw.get("profile_name", ""),
+        )
+        
+        if not self.datasecops.connection_name or not self.datasecops.app_database:
+            error_line(".datasecops.yml is missing connection_name or app_database.")
+            return False
+        
+        # Load dbt_project.yml to get profile name
+        dbt_data = read_dbt_project(self.project_dir)
+        if dbt_data:
+            self.profile_name = dbt_data.get("profile", self.datasecops.profile_name)
+        else:
+            self.profile_name = self.datasecops.profile_name
+        
+        # Resolve dbt project directory
+        for candidate in [self.project_dir / "dbt", self.project_dir]:
+            if (candidate / "dbt_project.yml").exists():
+                self.dbt_project_dir = candidate
+                break
+        
+        return True
+    
+    def load_from_native_app(self, snowflake_service) -> bool:
+        """Load configuration from the native app database."""
+        try:
+            # Load project settings
+            raw = snowflake_service.get_framework_config("PROJECT")
+            if raw:
+                self.project_settings = ProjectSettings(**{k: v for k, v in raw.items() if k in ProjectSettings.model_fields})
+            
+            # Load source control
+            raw = snowflake_service.get_framework_config("SOURCE_CONTROL")
+            if raw:
+                self.source_control = SourceControl(**{k: v for k, v in raw.items() if k in SourceControl.model_fields})
+            
+            # Load project profiles
+            profiles_data = snowflake_service.get_project_profiles()
+            if profiles_data:
+                self.all_profiles = [ProjectProfile(**{k.lower(): v for k, v in p.items()}) for p in profiles_data]
+            
+            # Find the active profile
+            if self.profile_name:
+                for p in self.all_profiles:
+                    if p.profile_name == self.profile_name:
+                        self.profile = p
+                        break
+            
+            if not self.profile and self.all_profiles:
+                self.profile = self.all_profiles[0]
+                self.profile_name = self.profile.profile_name
+            
+            return True
+        except Exception as e:
+            error_line(f"Failed to load from native app: {e}")
+            return False
+    
+    def get_dbt_profiles_dir(self) -> Path:
+        return Path(self.project_settings.profile_dir).expanduser()
+    
+    def get_default_target(self) -> Optional[DbtTarget]:
+        return self.project_settings.get_default_target()
+    
+    def get_deployment_branches(self) -> dict[str, str]:
+        return {b: b for b in self.project_settings.get_deployment_branches()}

datasecops_cli/main.py

@@ -0,0 +1,122 @@
+import sys
+from pathlib import Path
+
+from datasecops_cli.config import Config
+from datasecops_cli.services.snowflake_service import SnowflakeService
+from datasecops_cli.services.dbt_runner import DbtRunner
+from datasecops_cli.services.git_service import GitService
+from datasecops_cli.services.linting_service import LintingService
+from datasecops_cli.services.download_service import DownloadService
+from datasecops_cli.services.skill_service import SkillService
+from datasecops_cli.menus.development import DevelopmentMenu
+from datasecops_cli.menus.git_operations import GitOperationsMenu
+from datasecops_cli.menus.downloads import DownloadsMenu
+from datasecops_cli.utilities.display import (
+    clear, section_header, menu_option, get_input_number,
+    info_line, error_line, success_line
+)
+
+
+def main():
+    """Main entry point for the datasecops CLI."""
+    config = Config()
+    
+    if not config.load():
+        sys.exit(1)
+    
+    # Connect to Snowflake
+    sf_config = config.datasecops
+    sf_service = SnowflakeService(sf_config)
+    
+    try:
+        info_line(f"Connecting to Snowflake ({sf_config.connection_name})...")
+        sf_service.connect()
+        success_line("Connected")
+    except Exception as e:
+        error_line(f"Failed to connect to Snowflake: {e}")
+        sys.exit(1)
+    
+    try:
+        # Load config from native app
+        info_line("Loading framework configuration...")
+        config.load_from_native_app(sf_service)
+        
+        if not config.profile:
+            error_line(f"Profile '{config.profile_name}' not found in native app")
+            sys.exit(1)
+        
+        success_line(f"Profile: {config.profile.project_name} ({config.profile_name})")
+        
+        # Initialize services
+        dbt_runner = DbtRunner(
+            project_dir=config.dbt_project_dir,
+            profiles_dir=config.get_dbt_profiles_dir(),
+            target=config.project_settings.get_default_target().target_name if config.get_default_target() else "dev"
+        )
+        
+        try:
+            git_service = GitService(config.project_dir)
+        except Exception:
+            git_service = None
+        
+        linting_service = LintingService(config.dbt_project_dir)
+        download_service = DownloadService(sf_service, config.project_dir)
+        skill_service = SkillService(sf_service)
+        
+        # Main menu loop
+        _main_menu(config, dbt_runner, git_service, linting_service, 
+                    download_service, skill_service, sf_service)
+    
+    finally:
+        sf_service.close()
+
+
+def _main_menu(config: Config, dbt_runner: DbtRunner, git_service: GitService,
+               linting_service: LintingService, download_service: DownloadService,
+               skill_service: SkillService, sf_service: SnowflakeService):
+    """Main menu loop."""
+    profile_name = config.profile_name
+    
+    _show_main_menu(profile_name, git_service)
+    option = get_input_number("Choose an option: ")
+    
+    while option != 0:
+        if option == 1:
+            if git_service:
+                dev_menu = DevelopmentMenu(dbt_runner, linting_service, git_service, profile_name)
+            else:
+                dev_menu = DevelopmentMenu(dbt_runner, linting_service, None, profile_name)
+            dev_menu.show()
+        
+        elif option == 2 and git_service:
+            git_menu = GitOperationsMenu(
+                git_service, config.source_control,
+                config.get_deployment_branches(), profile_name
+            )
+            git_menu.show()
+        
+        elif option == 3:
+            dl_menu = DownloadsMenu(
+                download_service, skill_service, dbt_runner,
+                profile_name, config.dbt_project_dir
+            )
+            dl_menu.show()
+        
+        _show_main_menu(profile_name, git_service)
+        option = get_input_number("Choose an option: ")
+    
+    info_line("Exiting DataSecOps Framework CLI")
+
+
+def _show_main_menu(profile_name: str, git_service: GitService = None):
+    clear()
+    branch = git_service.get_current_branch() if git_service else None
+    section_header("DataSecOps Framework CLI", profile_name, branch)
+    menu_option(1, "development   - dbt Development Commands")
+    menu_option(2, "git           - Source Control Operations")
+    menu_option(3, "downloads     - Download Configs & Skills")
+    menu_option(0, "exit          - Exit")
+
+
+if __name__ == "__main__":
+    main()

datasecops_cli/menus/__init__.py

@@ -0,0 +1 @@
+

datasecops_cli/menus/development.py

@@ -0,0 +1,160 @@
+from datasecops_cli.services.dbt_runner import DbtRunner
+from datasecops_cli.services.linting_service import LintingService
+from datasecops_cli.services.git_service import GitService
+from datasecops_cli.utilities.display import (
+    clear, section_header, display_action_header, menu_option, 
+    get_input_number, get_input_string, get_input_true_false, complete_action,
+    info_line, error_line
+)
+
+
+class DevelopmentMenu:
+    def __init__(self, dbt_runner: DbtRunner, linting_service: LintingService, 
+                 git_service: GitService, profile_name: str):
+        self.dbt = dbt_runner
+        self.linting = linting_service
+        self.git = git_service
+        self.profile_name = profile_name
+    
+    def show(self) -> None:
+        self._menu()
+        option = get_input_number("Choose an option: ")
+        while option != 0:
+            if option == 1:
+                self._run_menu()
+            elif option == 2:
+                self._test_menu()
+            elif option == 3:
+                self._lint_menu()
+            elif option == 4:
+                display_action_header("dbt docs")
+                self.dbt.docs_generate()
+                if get_input_true_false("Serve docs?"):
+                    self.dbt.docs_serve()
+                complete_action()
+            elif option == 5:
+                display_action_header("dbt seed")
+                self.dbt.seed()
+                complete_action()
+            elif option == 6:
+                display_action_header("dbt deps")
+                self.dbt.deps()
+                complete_action()
+            elif option == 7:
+                display_action_header("dbt compile")
+                self.dbt.compile()
+                complete_action()
+            elif option == 8:
+                display_action_header("dbt snapshot")
+                self.dbt.snapshot()
+                complete_action()
+            elif option == 9:
+                display_action_header("dbt source freshness")
+                self.dbt.source_freshness()
+                complete_action()
+            elif option == 10:
+                display_action_header("dbt clean")
+                self.dbt.clean()
+                complete_action()
+            elif option == 11:
+                display_action_header("dbt debug")
+                self.dbt.debug()
+                complete_action()
+            elif option == 12:
+                display_action_header("dbt list")
+                self.dbt.list_models()
+                complete_action()
+            elif option == 13:
+                display_action_header("dbt retry")
+                self.dbt.retry()
+                complete_action()
+            self._menu()
+            option = get_input_number("Choose an option: ")
+    
+    def _menu(self) -> None:
+        clear()
+        section_header("Development Menu", self.profile_name, self.git.get_current_branch() if self.git else None)
+        menu_option(1,  "run           - Run dbt models")
+        menu_option(2,  "test          - Run dbt tests")
+        menu_option(3,  "lint          - SQLFluff linting")
+        menu_option(4,  "docs          - Generate & serve dbt docs")
+        menu_option(5,  "seed          - Load seed data")
+        menu_option(6,  "deps          - Install dbt packages")
+        menu_option(7,  "compile       - Compile dbt models")
+        menu_option(8,  "snapshot      - Run dbt snapshots")
+        menu_option(9,  "freshness     - Check source freshness")
+        menu_option(10, "clean         - Clean dbt target")
+        menu_option(11, "debug         - Debug dbt connection")
+        menu_option(12, "list          - List dbt resources")
+        menu_option(13, "retry         - Retry failed dbt run")
+        menu_option(0,  "back          - Return to main menu")
+    
+    def _run_menu(self) -> None:
+        clear()
+        display_action_header("dbt Run Options")
+        menu_option(1, "full run      - Run all models")
+        menu_option(2, "modified      - Run modified models only (state:modified+)")
+        menu_option(3, "specific      - Run specific model(s)")
+        menu_option(4, "macro         - Run a dbt macro")
+        menu_option(5, "retry         - Retry failed run")
+        menu_option(0, "back          - Return to development menu")
+        option = get_input_number("Choose an option: ")
+        if option == 1:
+            full_refresh = get_input_true_false("Full refresh?", "n")
+            self.dbt.run(full_refresh=full_refresh)
+        elif option == 2:
+            full_refresh = get_input_true_false("Full refresh?", "n")
+            self.dbt.run(modified_only=True, full_refresh=full_refresh)
+        elif option == 3:
+            select = get_input_string("Enter model selector: ")
+            if select != "0":
+                self.dbt.run(select=select)
+        elif option == 4:
+            macro = get_input_string("Enter macro name: ")
+            if macro != "0":
+                args_str = get_input_string("Enter args (JSON or empty): ", allow_empty=True)
+                self.dbt.run_operation(macro, args_str if args_str else None)
+        elif option == 5:
+            self.dbt.retry()
+        complete_action()
+    
+    def _test_menu(self) -> None:
+        clear()
+        display_action_header("dbt Test Options")
+        menu_option(1, "all tests     - Run all tests")
+        menu_option(2, "specific      - Run specific test(s)")
+        menu_option(0, "back          - Return to development menu")
+        option = get_input_number("Choose an option: ")
+        if option == 1:
+            self.dbt.test()
+        elif option == 2:
+            select = get_input_string("Enter test selector: ")
+            if select != "0":
+                self.dbt.test(select=select)
+        complete_action()
+    
+    def _lint_menu(self) -> None:
+        clear()
+        display_action_header("SQLFluff Linting Options")
+        menu_option(1, "find modified - Lint modified SQL files")
+        menu_option(2, "fix modified  - Fix modified SQL files")
+        menu_option(3, "find all      - Lint all SQL files")
+        menu_option(4, "fix all       - Fix all SQL files")
+        menu_option(5, "specific      - Lint specific file")
+        menu_option(0, "back          - Return to development menu")
+        option = get_input_number("Choose an option: ")
+        if option == 1:
+            changed = [f.file for f in self.git.get_changed_files()] if self.git else []
+            self.linting.lint_modified(fix=False, changed_files=changed)
+        elif option == 2:
+            changed = [f.file for f in self.git.get_changed_files()] if self.git else []
+            self.linting.lint_modified(fix=True, changed_files=changed)
+        elif option == 3:
+            self.linting.lint_file(fix=False)
+        elif option == 4:
+            self.linting.lint_file(fix=True)
+        elif option == 5:
+            path = get_input_string("Enter file path: ")
+            if path != "0":
+                self.linting.lint_file(file_path=path, fix=False)
+        complete_action()

datasecops_cli/menus/downloads.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+
+from datasecops_cli.services.download_service import DownloadService
+from datasecops_cli.services.skill_service import SkillService
+from datasecops_cli.services.dbt_runner import DbtRunner
+from datasecops_cli.utilities.display import (
+    clear, section_header, display_action_header, menu_option,
+    get_input_number, get_input_true_false, complete_action,
+    info_line, select_from_list
+)
+
+
+class DownloadsMenu:
+    def __init__(self, download_service: DownloadService, skill_service: SkillService,
+                 dbt_runner: DbtRunner, profile_name: str, dbt_project_dir: Path):
+        self.downloads = download_service
+        self.skills = skill_service
+        self.dbt = dbt_runner
+        self.profile_name = profile_name
+        self.dbt_project_dir = dbt_project_dir
+    
+    def show(self) -> None:
+        self._menu()
+        option = get_input_number("Choose an option: ")
+        while option != 0:
+            if option == 1:
+                display_action_header("Download SQLFluff Config")
+                self.downloads.download_sqlfluff_config()
+                complete_action()
+            elif option == 2:
+                display_action_header("Download Pipeline Files")
+                platform = select_from_list(["github", "azuredevops"], "platform", add_back=False)
+                self.downloads.download_pipelines(platform=platform)
+                complete_action()
+            elif option == 3:
+                display_action_header("Download dbt Packages")
+                self.downloads.download_dbt_packages(self.dbt_project_dir)
+                if get_input_true_false("Run dbt deps now?"):
+                    self.dbt.deps()
+                complete_action()
+            elif option == 4:
+                self._skills_menu()
+            self._menu()
+            option = get_input_number("Choose an option: ")
+    
+    def _menu(self) -> None:
+        clear()
+        section_header("Downloads", self.profile_name)
+        menu_option(1, "sqlfluff      - Download SQLFluff configuration")
+        menu_option(2, "pipelines     - Download CI/CD pipeline files")
+        menu_option(3, "dbt packages  - Download dbt package versions")
+        menu_option(4, "skills        - Cortex Code skills")
+        menu_option(0, "back          - Return to main menu")
+    
+    def _skills_menu(self) -> None:
+        clear()
+        display_action_header("Cortex Code Skills")
+        menu_option(1, "list          - List available skills")
+        menu_option(2, "install       - Install a specific skill")
+        menu_option(3, "install all   - Install all available skills")
+        menu_option(4, "update        - Update installed skills")
+        menu_option(0, "back          - Return to downloads menu")
+        option = get_input_number("Choose an option: ")
+        if option == 1:
+            self.skills.list_skills()
+        elif option == 2:
+            available = self.skills.get_available_skills()
+            if available:
+                names = {s.name: s for s in available}
+                selected = select_from_list(list(names.keys()), "skill")
+                if selected != "back" and selected in names:
+                    self.skills.install_skill(names[selected])
+            else:
+                info_line("No skills available")
+        elif option == 3:
+            self.skills.install_all()
+        elif option == 4:
+            self.skills.update_skills()
+        complete_action()

datasecops_cli/menus/git_operations.py

@@ -0,0 +1,213 @@
+from datasecops_cli.services.git_service import GitService
+from datasecops_cli.models.project_config import SourceControl
+from datasecops_cli.utilities.display import (
+    clear, section_header, display_action_header, menu_option,
+    get_input_number, get_input_string, get_input_true_false,
+    complete_action, info_line, error_line, warning_line,
+    select_from_dict, select_from_list
+)
+
+
+class GitOperationsMenu:
+    def __init__(self, git_service: GitService, source_control: SourceControl,
+                 deployment_branches: dict[str, str], profile_name: str):
+        self.git = git_service
+        self.source_control = source_control
+        self.deployment_branches = deployment_branches
+        self.profile_name = profile_name
+    
+    def show(self) -> None:
+        self._menu()
+        option = get_input_number("Choose an option: ")
+        while option != 0:
+            if option == 1:
+                self._branch_menu()
+            elif option == 2:
+                self._commit()
+            elif option == 3:
+                self._push()
+            elif option == 4:
+                self._pull()
+            elif option == 5:
+                self._rebase_menu()
+            elif option == 6:
+                self._deploy()
+            elif option == 7:
+                self._squash_merge_test()
+            elif option == 8:
+                self._cherry_pick_test()
+            self._menu()
+            option = get_input_number("Choose an option: ")
+    
+    def _menu(self) -> None:
+        clear()
+        section_header("Git Operations", self.profile_name, self.git.get_current_branch())
+        menu_option(1, "branching         - Manage branches")
+        menu_option(2, "commit            - Commit changes")
+        menu_option(3, "push              - Push to remote")
+        menu_option(4, "pull              - Pull from remote")
+        menu_option(5, "rebase            - Rebase with main")
+        menu_option(6, "deploy            - Deploy to environment")
+        menu_option(7, "squash to test    - Squash merge into test")
+        menu_option(8, "cherry-pick test  - Cherry-pick commits from test")
+        menu_option(0, "back              - Return to main menu")
+    
+    def _branch_menu(self) -> None:
+        clear()
+        display_action_header("Branch Management")
+        menu_option(1, "new      - Create new branch")
+        menu_option(2, "checkout - Checkout remote branch")
+        menu_option(3, "switch   - Switch to local branch")
+        menu_option(4, "delete   - Delete local branch")
+        menu_option(5, "prune    - Prune remote branches")
+        menu_option(6, "reset    - Reset to main")
+        menu_option(0, "back     - Return to git menu")
+        option = get_input_number("Choose an option: ")
+        if option == 1:
+            self._create_branch()
+        elif option == 2:
+            branches = self.git.get_remote_branches()
+            if branches:
+                selected = select_from_dict(branches, "branch")
+                if selected != "back":
+                    self.git.checkout_branch(selected)
+            else:
+                info_line("No remote branches found")
+        elif option == 3:
+            branches = self.git.get_local_branches()
+            selected = select_from_dict(branches, "branch")
+            if selected != "back":
+                self.git.switch_branch(selected)
+        elif option == 4:
+            branches = self.git.get_local_branches()
+            selected = select_from_dict(branches, "branch")
+            if selected != "back":
+                self.git.delete_branch(selected)
+        elif option == 5:
+            self.git.prune_remote_branches()
+        elif option == 6:
+            if get_input_true_false("This will delete all local branches. Continue?", "n"):
+                self.git.reset_to_main()
+        complete_action()
+    
+    def _create_branch(self) -> None:
+        branch_types = {bt.name: bt.name for bt in self.source_control.branch_types}
+        if not branch_types:
+            branch_types = {"feature": "feature", "bugfix": "bugfix", "hotfix": "hotfix"}
+        
+        selected_type = select_from_dict(branch_types, "branch type")
+        if selected_type == "back":
+            return
+        
+        ticket = ""
+        if self.source_control.ticket_number_required:
+            ticket = get_input_string("Enter ticket number: ")
+            if ticket == "0":
+                return
+        else:
+            ticket = get_input_string("Enter ticket number (or press Enter to skip): ", allow_empty=True)
+        
+        name = get_input_string("Enter branch name: ")
+        if name == "0":
+            return
+        
+        self.git.create_branch(selected_type, ticket, name.replace(" ", "-").lower())
+    
+    def _commit(self) -> None:
+        display_action_header("Commit Changes")
+        if not self.git.is_dirty():
+            info_line("No changes to commit")
+            complete_action()
+            return
+        
+        info_line(f"{self.git.get_uncommitted_file_count()} change(s) detected")
+        for f in self.git.get_changed_files():
+            info_line(f"  M {f.file}")
+        for f in self.git.get_new_files():
+            info_line(f"  + {f.file}")
+        
+        message = get_input_string("Enter commit message (0 to cancel): ")
+        if message == "0":
+            return
+        
+        self.git.commit_changes(message)
+        self.git.push_branch()
+        complete_action()
+    
+    def _push(self) -> None:
+        display_action_header("Push")
+        self.git.push_branch()
+        complete_action()
+    
+    def _pull(self) -> None:
+        display_action_header("Pull")
+        self.git.pull_branch()
+        complete_action()
+    
+    def _rebase_menu(self) -> None:
+        clear()
+        display_action_header("Rebase Options")
+        menu_option(1, "rebase           - Standard rebase with main")
+        menu_option(2, "squash & rebase  - Squash commits then rebase")
+        menu_option(3, "continue         - Continue after resolving conflicts")
+        menu_option(4, "abort            - Abort rebase")
+        menu_option(0, "back             - Return to git menu")
+        option = get_input_number("Choose an option: ")
+        if option == 1:
+            self.git.rebase_with_main()
+        elif option == 2:
+            self.git.squash_and_rebase()
+        elif option == 3:
+            self.git.rebase_continue()
+        elif option == 4:
+            self.git.rebase_abort()
+        complete_action()
+    
+    def _deploy(self) -> None:
+        display_action_header("Deploy to Environment")
+        if not self.deployment_branches:
+            error_line("No deployment branches configured")
+            complete_action()
+            return
+        
+        selected = select_from_dict(self.deployment_branches, "environment")
+        if selected == "back":
+            return
+        
+        current = self.git.get_current_branch()
+        if selected.lower() == "prod" and current.lower() != "main":
+            warning_line("Production deployments must come from the main branch")
+            if get_input_true_false("Switch to main and deploy?", "n"):
+                self.git.checkout_branch("main")
+                self.git.pull_branch()
+            else:
+                return
+        
+        force = selected.lower() != "prod"
+        self.git.push_branch_to_destination(selected, force=force)
+        complete_action()
+    
+    def _squash_merge_test(self) -> None:
+        display_action_header("Squash Merge into Test")
+        current = self.git.get_current_branch()
+        info_line(f"This will squash merge {current} into the test branch")
+        if get_input_true_false("Continue?", "n"):
+            self.git.squash_merge_into_test()
+        complete_action()
+    
+    def _cherry_pick_test(self) -> None:
+        display_action_header("Cherry-pick from Test")
+        commits = self.git.get_test_commits()
+        if not commits:
+            info_line("No commits found on test branch")
+            complete_action()
+            return
+        
+        info_line("Recent commits on test:")
+        for i, c in enumerate(commits):
+            info_line(f"  [{i+1}] {c['sha'][:8]} - {c['message'][:60]}")
+        
+        choice = get_input_number("Select commit number (0 to cancel): ")
+        if 0 < choice <= len(commits):
+            self.git.cherry_pick_from_test(commits[choice-1]["sha"])
+        complete_action()

datasecops_cli/models/__init__.py

@@ -0,0 +1 @@
+