twc-cli 1.0.0rc0__py3-none-any.whl

twc/commands/__init__.py

@@ -0,0 +1,286 @@
+"""TWC CLI commands package.
+
+__init__.py module contains common functions, decorators and variables.
+"""
+
+import os
+import sys
+import logging
+
+import click
+import toml
+
+from twc.__version__ import __version__, __pyversion__
+from twc.api import TimewebCloud
+from twc.api import (
+    UnauthorizedError,
+    NonJSONResponseError,
+    BadResponseError,
+    UnexpectedResponseError,
+)
+
+
+# -----------------------------------------------------------------------
+# Configuration
+
+
+USER_AGENT = f"TWC-CLI/{__version__} Python {__pyversion__}"
+DEFAULT_CONFIG = {"default": {"token": ""}}
+DEFAULT_CONFIGURATOR_ID = 11
+REGIONS_WITH_CONFIGURATOR = ["ru-1"]
+REGIONS_WITH_IPV6 = ["ru-1"]
+
+
+def get_default_config_file() -> str:
+    if os.name == "nt":
+        env_home = "USERPROFILE"
+    else:
+        env_home = "HOME"
+    return os.path.join(os.getenv(env_home), ".twcrc")
+
+
+def load_config(filepath: str = get_default_config_file()):
+    """Load configuration from TOML config file."""
+    try:
+        with open(filepath, "r", encoding="utf-8") as file:
+            return toml.load(file)
+    except (OSError, FileNotFoundError) as error:
+        sys.exit(f"Error: {filepath}: {error}: Try run 'twc config'")
+    except toml.TomlDecodeError as error:
+        sys.exit(f"Error: {filepath}: {error}")
+
+
+def set_value_from_config(ctx, param, value):
+    """Callback for Click to load option values from configuration file."""
+    if value is None:
+        if not os.path.exists(ctx.params["config"]):
+            return None
+        try:
+            value = load_config(ctx.params["config"])[ctx.params["profile"]][
+                param.name
+            ]
+        except KeyError:
+            return None
+    return value
+
+
+# -----------------------------------------------------------------------
+# Logger
+
+
+def set_logger(ctx, param, value):
+    """Click callback for '--verbose' option. Set logger settings.
+    Log HTTP requests and anything else.
+    """
+    if value:
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format="%(asctime)s:%(levelname)s:%(name)s: %(message)s",
+            datefmt="%Y-%m-%dT%H:%M:%S%z",
+        )
+
+
+def log(message: str, *args, **kwargs):
+    """Print DEBUG log message"""
+    logging.debug(message, *args, **kwargs)
+
+
+def log_request(response: object):
+    """Log data from `requests.PreparedRequest` and `requests.Response`
+    objects. Hide auth Bearer token.
+    """
+    request_headers = response.request.headers
+    request_headers.update(
+        {"Authorization": "Bearer <SENSITIVE_DATA_DELETED>"}
+    )
+
+    for key in list(request_headers.keys()):
+        log(f"Request header: {key}: {request_headers[key]}")
+
+    if response.request.method in ["POST", "PUT", "PATCH"]:
+        log(f"Request body (raw): {response.request.body}")
+
+    for key in list(response.headers.keys()):
+        log(f"Response header: {key}: {response.headers[key]}")
+
+
+# -----------------------------------------------------------------------
+# CLI
+
+
+GLOBAL_OPTIONS = [
+    click.help_option("--help"),
+    click.version_option(__version__, "--version", prog_name="twc"),
+    click.option(
+        "--verbose",
+        "-v",
+        is_flag=True,
+        envvar="TWC_DEBUG",
+        callback=set_logger,
+        help="Enable verbose mode.",
+    ),
+    click.option(
+        "--config",
+        "-c",
+        metavar="FILE",
+        envvar="TWC_CONFIG_FILE",
+        default=get_default_config_file(),
+        is_eager=True,
+        show_default=True,
+        help="Use config file.",
+    ),
+    click.option(
+        "--profile",
+        "-p",
+        envvar="TWC_PROFILE",
+        default="default",
+        show_default=True,
+        is_eager=True,
+        help="Use profile.",
+    ),
+]
+
+OUTPUT_FORMAT_OPTION = [
+    click.option(
+        "--output",
+        "-o",
+        "output_format",
+        type=click.Choice(["default", "raw", "json", "yaml"]),
+        envvar="TWC_OUTPUT_FORMAT",
+        callback=set_value_from_config,
+        help="Output format.",
+    )
+]
+
+
+def options(options_list: list):
+    """Add multiple options to command."""
+
+    def wrapper(func):
+        for option in reversed(options_list):
+            func = option(func)
+        return func
+
+    return wrapper
+
+
+class MutuallyExclusiveOption(click.Option):
+    """Add mutually exclusive options support for Click. Example::
+
+    @click.option(
+        "--dry",
+        is_flag=True,
+        cls=MutuallyExclusiveOption,
+        mutually_exclusive=["wet"],
+    )
+    @click.option("--wet", is_flag=True)
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.mutually_exclusive = set(kwargs.pop("mutually_exclusive", []))
+        help = kwargs.get("help", "")  # pylint: disable=redefined-builtin
+        if self.mutually_exclusive:
+            kwargs["help"] = help + (
+                " NOTE: This argument is mutually exclusive with "
+                f"arguments: [{', '.join(self.mutually_exclusive)}]."
+            )
+        super().__init__(*args, **kwargs)
+
+    def handle_parse_result(self, ctx, opts, args):
+        if self.mutually_exclusive.intersection(opts) and self.name in opts:
+            raise click.UsageError(
+                f"Illegal usage: '{self.name}' is mutually exclusive with "
+                f"arguments: [{', '.join(self.mutually_exclusive)}]."
+            )
+        return super().handle_parse_result(ctx, opts, args)
+
+
+def confirm_action(question: str, default: str = "no"):
+    """Ask a yes/no question via input() and return their answer.
+
+    The "answer" return value is True for "yes" or False for "no".
+    """
+    valid = {
+        "yes": True,
+        "y": True,
+        "ye": True,
+        "no": False,
+        "n": False,
+    }
+    if default is None:
+        prompt = "[y/n]"
+    elif default == "yes":
+        prompt = "[Y/n]"
+    elif default == "no":
+        prompt = "[y/N]"
+    else:
+        raise ValueError(f"Invalid default answer: '{default}'")
+
+    while True:
+        choice = input(f"{question} {prompt}: ").lower()
+        if default is not None and choice == "":
+            return valid[default]
+        if choice in valid:
+            return valid[choice]
+        sys.exit("Please respond with 'yes' or 'no' (or 'y' or 'n').")
+
+
+# -----------------------------------------------------------------------
+# API interaction
+
+
+def handle_request(func):
+    def wrapper(*args, **kwargs):
+        try:
+            response = func(*args, **kwargs)
+
+            log_request(response)
+            if not response.text:
+                log("No response body")
+
+            if response.status_code not in [200, 201, 204]:
+                raise BadResponseError
+        except UnauthorizedError:
+            print(
+                "Error: Unauthorized. "
+                + "Please check your API access token. Try run 'twc config'",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        except BadResponseError:
+            resp = response.json()
+            print("Error occurred. Details:", file=sys.stderr)
+            print(f"Status code: {resp['status_code']}", file=sys.stderr)
+            print(f" Error code: {resp['error_code']}", file=sys.stderr)
+            if isinstance(resp["message"], list):
+                for message in resp["message"]:
+                    print(f"    Message: {message}", file=sys.stderr)
+            else:
+                print(f"    Message: {resp['message']}", file=sys.stderr)
+            print(f"Response ID: {resp['response_id']}", file=sys.stderr)
+            sys.exit(1)
+        except (NonJSONResponseError, UnexpectedResponseError) as error:
+            sys.exit(f"Error: {error}")
+        return response
+
+    return wrapper
+
+
+def create_client(config, profile):
+    """Create API client instance with access token."""
+
+    log(f"TWC CLI {__version__} Python {__pyversion__}")
+    log(f"Args: {sys.argv[1:]}")
+
+    env_token = os.getenv("TWC_TOKEN")
+
+    if env_token:
+        log("Get Timeweb Cloud token from environment variable")
+        return TimewebCloud(env_token, user_agent=USER_AGENT)
+
+    try:
+        log(f"Configuration: config file={config}; profile={profile}")
+        token = load_config(config)[profile]["token"]
+        return TimewebCloud(token, user_agent=USER_AGENT)
+    except KeyError:
+        sys.exit(f"Profile '{profile}' not found in {config}")

twc/commands/account.py

@@ -0,0 +1,178 @@
+"""Account management commands."""
+
+import click
+
+from twc import fmt
+from . import (
+    create_client,
+    handle_request,
+    options,
+    GLOBAL_OPTIONS,
+    OUTPUT_FORMAT_OPTION,
+)
+
+
+@handle_request
+def _account_finances(client):
+    return client.get_account_finances()
+
+
+@handle_request
+def _account_status(client):
+    return client.get_account_status()
+
+
+@handle_request
+def _restrictions_status(client):
+    return client.get_account_restrictions()
+
+
+# ------------------------------------------------------------- #
+# $ twc account                                                 #
+# ------------------------------------------------------------- #
+
+
+@click.group()
+@options(GLOBAL_OPTIONS[:2])
+def account():
+    """Manage Timeweb Cloud account."""
+
+
+# ------------------------------------------------------------- #
+# $ twc account status                                          #
+# ------------------------------------------------------------- #
+
+
+def print_account_status(response: object):
+    table = fmt.Table()
+    status = response.json()["status"]
+    translated_keys = {
+        "company_info": "Company",
+        "ym_client_id": "Yandex.Metrika client ID",
+        "is_blocked": "Blocked",
+        "is_permanent_blocked": "Permanently blocked",
+        "is_send_bill_letters": "Send bill emails",
+        "last_password_changed_at": "Password changed at",
+    }
+    for key in status.keys():
+        try:
+            if key == "company_info":
+                table.row([translated_keys[key], ":", status[key]["name"]])
+            else:
+                table.row([translated_keys[key], ":", status[key]])
+        except KeyError:
+            pass
+    table.print()
+
+
+@account.command("status", help="Get account status.")
+@options(GLOBAL_OPTIONS)
+@options(OUTPUT_FORMAT_OPTION)
+def account_status(config, profile, verbose, output_format):
+    client = create_client(config, profile)
+    response = _account_status(client)
+    fmt.printer(
+        response, output_format=output_format, func=print_account_status
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc account finances                                        #
+# ------------------------------------------------------------- #
+
+
+def print_account_finances(response: object):
+    table = fmt.Table()
+    finances = response.json()["finances"]
+    translated_keys = {
+        "balance": "Balance",
+        "currency": "Currency",
+        "discount_end_date_at": "Discount ends at",
+        "discount_percent": "Discount",
+        "hourly_cost": "Hourly cost",
+        "hourly_fee": "Hourly fee",
+        "monthly_cost": "Monthly cost",
+        "monthly_fee": "Monthly fee",
+        "total_paid": "Total paid",
+        "hours_left": "Hours left",
+        "autopay_card_info": "Autopay Card",
+    }
+    for key in finances.keys():
+        try:
+            table.row([translated_keys[key], ":", finances[key]])
+        except KeyError:
+            pass
+    table.print()
+
+
+@account.command("finances", help="Get finances.")
+@options(GLOBAL_OPTIONS)
+@options(OUTPUT_FORMAT_OPTION)
+def account_finances(config, profile, verbose, output_format):
+    client = create_client(config, profile)
+    response = _account_finances(client)
+    fmt.printer(
+        response, output_format=output_format, func=print_account_finances
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc account access                                          #
+# ------------------------------------------------------------- #
+
+
+@account.group()
+@options(GLOBAL_OPTIONS[:2])
+def access():
+    """Manage account access restrictions."""
+
+
+# ------------------------------------------------------------- #
+# $ twc account access restrictions                             #
+# ------------------------------------------------------------- #
+
+
+def print_restrictions_status(response: object, by_ip: bool, by_country: bool):
+    restrictions = response.json()
+
+    if not by_ip and not by_country:
+        by_ip = by_country = True
+
+    if by_ip:
+        if restrictions["is_ip_restrictions_enabled"]:
+            click.echo("IP restrictions: enabled")
+            click.echo("Allowed IPs:")
+            for ip_addr in restrictions["white_list"]["ips"]:
+                click.echo(f" - {ip_addr}")
+        else:
+            click.echo("IP restrictions: disabled")
+
+    if by_country:
+        if restrictions["is_country_restrictions_enabled"]:
+            click.echo("Country restrictions: enabled")
+            click.echo("Allowed countries:")
+            for country in restrictions["white_list"]["countries"]:
+                click.echo(f" - {country}")
+        else:
+            click.echo("Country restrictions: disabled")
+
+
+@access.command("restrictions", help="View access restrictions status.")
+@options(GLOBAL_OPTIONS)
+@options(OUTPUT_FORMAT_OPTION)
+@click.option("--by-ip", is_flag=True, help="Display IP restrictions.")
+@click.option(
+    "--by-country", is_flag=True, help="Display country restrictions."
+)
+def restrictions_status(
+    config, profile, verbose, output_format, by_ip, by_country
+):
+    client = create_client(config, profile)
+    response = _restrictions_status(client)
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=print_restrictions_status,
+        by_ip=by_ip,
+        by_country=by_country,
+    )

twc/commands/config.py

@@ -0,0 +1,46 @@
+"""CLI configuration."""
+
+import os
+import sys
+import ctypes
+
+import toml
+import click
+
+from . import options, get_default_config_file, GLOBAL_OPTIONS, DEFAULT_CONFIG
+
+
+def make_config(filepath: str = get_default_config_file()):
+    """Create new configuration file."""
+    if os.path.exists(filepath):
+        sys.exit(f"File '{filepath}' already exists.")
+    else:
+        click.echo("Create new configuration file. Enter your API token.")
+        while True:
+            token = input("Token: ")
+            if token:
+                DEFAULT_CONFIG.update({"default": {"token": token}})
+                break
+            click.echo("Please enter token. Press ^C to cancel.")
+        try:
+            with open(filepath, "w", encoding="utf-8") as file:
+                toml.dump(DEFAULT_CONFIG, file)
+            if os.name == "nt":
+                hidden_file_attr = 0x02
+                ctypes.windll.kernel32.SetFileAttributesW(
+                    filepath, hidden_file_attr
+                )
+            click.echo(f"Success! Configuration is saved in {filepath}")
+        except OSError as error:
+            sys.exit(f"Error: {error}")
+
+
+# ------------------------------------------------------------- #
+# $ twc config                                                  #
+# ------------------------------------------------------------- #
+
+
+@click.command("config", help="Make new configuration file.")
+@options(GLOBAL_OPTIONS[:2])
+def config():
+    make_config()