developers-chamber 0.1.39__py3-none-any.whl

developers_chamber/bin/pydev.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+import logging.config
+import os
+import sys
+from pathlib import Path
+from importlib.machinery import SourceFileLoader
+
+import click_completion
+import coloredlogs
+from dotenv import load_dotenv
+from developers_chamber.utils import INSTALLED_MODULES
+
+for config_path in (Path.home(), Path.cwd()):
+    if (config_path / ".pydev").exists() and (config_path / ".pydev").is_dir():
+        for file in (config_path / ".pydev").iterdir():
+            if (
+                file.is_file()
+                and file.suffix == ".conf"
+                and not file.name.startswith("~")
+            ):
+                load_dotenv(dotenv_path=str(file), override=True)
+
+
+from developers_chamber.scripts import cli
+
+if "bitbucket" in INSTALLED_MODULES:
+    from developers_chamber.scripts.bitbucket import *
+from developers_chamber.scripts.docker import *
+
+if "aws" in INSTALLED_MODULES:
+    from developers_chamber.scripts.ecs import *
+
+if "git" in INSTALLED_MODULES:
+    from developers_chamber.scripts.git import *
+
+from developers_chamber.scripts.gitlab import *
+
+if "jira" in INSTALLED_MODULES:
+    from developers_chamber.scripts.jira import *
+
+if "qa" in INSTALLED_MODULES:
+    from developers_chamber.scripts.qa import *
+
+from developers_chamber.scripts.sh import *
+
+if "slack" in INSTALLED_MODULES:
+    from developers_chamber.scripts.slack import *
+
+if "toggle" in INSTALLED_MODULES:
+    from developers_chamber.scripts.toggle import *
+
+from developers_chamber.scripts.version import *
+from developers_chamber.scripts.project import *
+
+click_completion.init()
+
+# Import external scripts
+for base_path in (Path.home(), Path.cwd()):
+    if (base_path / ".pydev" / "scripts" / "__init__.py").exists():
+        SourceFileLoader(
+            "*", str(base_path / ".pydev" / "scripts" / "__init__.py")
+        ).load_module()
+
+from developers_chamber.scripts.init_aliasses import *
+
+coloredlogs.install(milliseconds=True)
+
+
+@cli.command()
+@click.option(
+    "--append/--overwrite", help="Append the completion code to the file", default=None
+)
+@click.option(
+    "-i", "--case-insensitive/--no-case-insensitive", help="Case insensitive completion"
+)
+@click.argument(
+    "shell",
+    required=False,
+    type=click_completion.DocumentedChoice(click_completion.core.shells),
+)
+@click.argument("path", required=False)
+def init_completion(append, case_insensitive, shell, path):
+    """Install the pydev completion"""
+    extra_env = {"_PYDEV_CASE_INSENSITIVE_COMPLETE": "ON"} if case_insensitive else {}
+    shell, path = click_completion.core.install(
+        shell=shell, path=path, append=append, extra_env=extra_env
+    )
+    click.echo("{} completion installed in  {}".format(shell, path))
+
+
+if __name__ == "__main__":
+    cli()

developers_chamber/bitbucket_utils.py

@@ -0,0 +1,94 @@
+import requests
+from click import UsageError
+from requests.auth import HTTPBasicAuth
+
+
+def get_commit_builds(username, password, repository_name, commit):
+    response = requests.get(
+        "https://api.bitbucket.org/2.0/repositories/{repository}/commit/{commit}/statuses".format(
+            repository=repository_name, commit=commit
+        ),
+        headers={"content-type": "application/json"},
+        auth=HTTPBasicAuth(username, password),
+    )
+    if response.status_code != 200:
+        raise UsageError("Bitbucket error: {}".format(response.content.decode("utf-8")))
+    return [
+        build_data
+        for build_data in response.json()["values"]
+        if build_data["type"] == "build"
+    ]
+
+
+def get_current_user_uuid(username, password):
+    response = requests.get(
+        "https://api.bitbucket.org/2.0/user",
+        headers={"content-type": "application/json"},
+        auth=HTTPBasicAuth(username, password),
+    )
+    if response.status_code != 200:
+        raise UsageError("Bitbucket error: {}".format(response.content.decode("utf-8")))
+    return response.json()["uuid"]
+
+
+def get_default_reviewers(username, password, repository_name):
+    url = "https://api.bitbucket.org/2.0/repositories/{repository}/default-reviewers".format(
+        repository=repository_name
+    )
+    response = requests.get(
+        url,
+        headers={"content-type": "application/json"},
+        auth=HTTPBasicAuth(username, password),
+    )
+    if response.status_code != 200:
+        raise UsageError("Bitbucket error: {}".format(response.content.decode("utf-8")))
+    current_user_uuid = get_current_user_uuid(username, password)
+    return [
+        {"uuid": reviewer_data["uuid"]}
+        for reviewer_data in response.json()["values"]
+        if reviewer_data["uuid"] != current_user_uuid
+    ]
+
+
+def create_pull_request(
+    username,
+    password,
+    title,
+    description,
+    source_branch_name,
+    destination_branch_name,
+    repository_name,
+):
+    url = "https://api.bitbucket.org/2.0/repositories/{repository}/pullrequests".format(
+        repository=repository_name
+    )
+    json_data = {
+        "title": title,
+        "description": description,
+        "source": {"branch": {"name": source_branch_name}},
+        "destination": {"branch": {"name": destination_branch_name}},
+        "reviewers": get_default_reviewers(username, password, repository_name),
+    }
+    response = requests.post(
+        url,
+        headers={"content-type": "application/json"},
+        json=json_data,
+        auth=HTTPBasicAuth(username, password),
+    )
+    if response.status_code != 201:
+        raise UsageError("Bitbucket error: {}".format(response.content.decode("utf-8")))
+    return response.json()["links"]["html"]["href"]
+
+
+def create_merge_release_pull_request(
+    username, password, source_branch_name, destination_branch_name, repository_name
+):
+    return create_pull_request(
+        username=username,
+        password=password,
+        title='Merge branch "{}"'.format(source_branch_name),
+        description="",
+        source_branch_name=source_branch_name,
+        destination_branch_name=destination_branch_name,
+        repository_name=repository_name,
+    )

developers_chamber/click/alias.py

@@ -0,0 +1,130 @@
+import re
+import shlex
+from gettext import gettext as _
+
+import click
+from click.formatting import wrap_text
+
+
+def find_and_replace_command_variable(arg, command, index):
+    match = re.match(r"^--(?P<arg_name>[^=\ ]+)[\ =](?P<arg_value>.+)", arg)
+    if match:
+        arg_name, arg_value = match.groups()
+        if f"${arg_name}" in command:
+            return True, command.replace(f"${arg_name}", arg_value)
+        elif f'${arg_name.replace("-", "_")}' in command:
+            return True, command.replace(f'${arg_name.replace("-", "_")}', arg_value)
+    if f"${index}" in command:
+        return True, command.replace(f"${index}", arg)
+    return False, command
+
+
+def parse_alias(alias):
+    from developers_chamber.scripts import cli
+
+    command_parts = list(shlex.split(alias))
+    used_command_parts = []
+
+    click_command = cli
+    while command_parts:
+        command_part = command_parts[0]
+        current_click_command = click_command.get_command(None, command_part)
+        if current_click_command is None:
+            raise click.ClickException(
+                'Command to the alias "{}" cannot be found'.format(alias)
+            )
+
+        used_command_parts.append(command_parts.pop(0))
+        click_command = current_click_command
+        if not isinstance(current_click_command, click.Group):
+            break
+    return used_command_parts, command_parts, click_command, alias
+
+
+class AliasCommand(click.Command):
+
+    def __init__(self, commands, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._parse_alias(commands)
+
+    def _parse_alias(self, commands):
+        if isinstance(commands, str):
+            commands = [commands]
+            description = ""
+        elif isinstance(commands, list):
+            commands = commands
+            description = ""
+        elif isinstance(commands, dict):
+            description = commands["description"]
+            commands = commands["command"]
+        else:
+            raise click.ClickException("Invalid alias type")
+
+        commands = [commands] if isinstance(commands, str) else commands
+        self.aliases = [(parse_alias(alias)) for alias in commands]
+        self.short_help = description
+
+    def format_help_text(self, ctx, formatter) -> None:
+        formatter.write_paragraph()
+        with formatter.indentation():
+            if self.short_help:
+                formatter.write_text(self.short_help)
+                formatter.write_paragraph()
+            formatter.write_text("Alias to commands: ")
+            with formatter.indentation():
+                for (
+                    used_command_parts,
+                    remaining_command_parts,
+                    click_command,
+                    alias_str,
+                ) in self.aliases:
+                    formatter.write_text("* " + " ".join(used_command_parts))
+                    if remaining_command_parts:
+                        with formatter.indentation(), formatter.indentation():
+                            formatter.write_text(" ".join(remaining_command_parts))
+
+    def format_epilog(self, ctx, formatter) -> None:
+        with formatter.section(_("Commands in alias help")):
+            for (
+                used_command_parts,
+                remaining_command_parts,
+                click_command,
+                alias_str,
+            ) in self.aliases:
+                with formatter.indentation():
+                    formatter.write_paragraph()
+                    formatter.write_text("* " + " ".join(used_command_parts))
+                    with formatter.indentation(), formatter.indentation():
+                        click_command.format_help_text(ctx, formatter)
+                        click_command.format_options(ctx, formatter)
+                        formatter.write_paragraph()
+
+    def shell_complete(self, ctx, param):
+        from click.shell_completion import CompletionItem
+
+        return [CompletionItem(param, type="file")]
+
+    def invoke(self, ctx):
+        from developers_chamber.scripts import cli
+
+        for i, (
+            used_command_parts,
+            remaining_command_parts,
+            click_command,
+            alias_str,
+        ) in enumerate(self.aliases):
+            if i == 0:
+                alias_args = []
+
+                for index, arg in enumerate(ctx.args, start=1):
+                    replaced_arg, alias_str = find_and_replace_command_variable(
+                        arg, alias_str, index
+                    )
+                    if not replaced_arg:
+                        alias_args.append(arg)
+
+                if "$@" in alias_str:
+                    alias_str = alias_str.replace("$@", " ".join(ctx.args))
+                    alias_args = []
+
+            cli.main(args=shlex.split(alias_str) + alias_args, standalone_mode=False)

developers_chamber/click/options.py

@@ -0,0 +1,86 @@
+import click
+
+
+class RequiredIfNotEmpty(click.Option):
+
+    def __init__(self, *args, **kwargs):
+        self.required_if_not_empty = kwargs.pop("required_if_empty")
+        if not self.required_if_not_empty:
+            raise ValueError(
+                '"required_if_not_empty" argument is required for "RequiredIfNotEmpty" option'
+            )
+        kwargs["help"] += " NOTE: This option is required with {}".format(
+            self.required_if_not_empty
+        )
+
+        super().__init__(*args, **kwargs)
+
+    def handle_parse_result(self, ctx, opts, args):
+        if self.required_if_not_empty in opts:
+            if self.name not in opts:
+                raise click.UsageError(
+                    "Illegal usage: {} is required with {}".format(
+                        self.name, self.required_if_not_empty
+                    )
+                )
+            else:
+                self.prompt = None
+
+        return super().handle_parse_result(ctx, opts, args)
+
+
+class ContainerDirToCopyType(click.ParamType):
+
+    name = "container_dir_to_copy"
+
+    def convert(self, value, param, ctx):
+        try:
+            container_name, container_dir, host_dir = value.split(":")
+            return container_name, container_dir, host_dir
+        except ValueError:
+            self.fail(
+                'Invalid value "{}" format must be "DOCKER_CONTAINER_NAME:CONTAINER_DIRECTORY:HOST_DIRECTORY"'.format(
+                    value
+                ),
+                param,
+                ctx,
+            )
+
+
+class ContainerCommandType(click.ParamType):
+
+    name = "container_command_type"
+
+    def convert(self, value, param, ctx):
+        if value:
+            try:
+                container_name, command = value.split(":")
+                return container_name, command
+            except ValueError:
+                self.fail(
+                    'Invalid value "{}" format must be "DOCKER_CONTAINER_NAME:COMMAND"'.format(
+                        value
+                    ),
+                    param,
+                    ctx,
+                )
+
+
+class ContainerEnvironment(click.ParamType):
+
+    name = "container_environment"
+
+    def convert(self, value, param, ctx):
+        try:
+            return {
+                variable.split("=")[0]: variable.split("=")[1]
+                for variable in value.split(" ")
+            }
+        except ValueError:
+            self.fail(
+                'Invalid value "{}" format must be "NAME=VALUE [NAME2=VALUE2]"'.format(
+                    value
+                ),
+                param,
+                ctx,
+            )

developers_chamber/docker_utils.py

@@ -0,0 +1,15 @@
+from developers_chamber.utils import call_command
+
+
+def login_client(username, password, registry):
+    call_command(
+        ["docker", "login", "--username", username, "--password", password, registry]
+    )
+
+
+def tag(source_image, target_image):
+    call_command(["docker", "tag", source_image, target_image])
+
+
+def push_image(repository, tag):
+    call_command(["docker", "push", "{}:{}".format(repository, tag)])