aws-annoying 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

aws_annoying/session_manager/session_manager.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import platform
+import re
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, NamedTuple
+
+import boto3
+
+from aws_annoying.utils.platform import command_as_root, is_root, os_release
+
+from .errors import PluginNotInstalledError, UnsupportedPlatformError
+
+if TYPE_CHECKING:
+    from aws_annoying.utils.downloader import AbstractDownloader
+
+logger = logging.getLogger(__name__)
+
+# TODO(lasuillard): Platform checking is spread everywhere, should be moved to a single place
+
+
+class SessionManager:
+    """AWS Session Manager plugin manager."""
+
+    def __init__(self, *, session: boto3.session.Session | None = None, downloader: AbstractDownloader) -> None:
+        """Initialize SessionManager.
+
+        Args:
+            session: Boto3 session to use for AWS operations.
+            downloader: File downloader to use for downloading the plugin.
+        """
+        self.session = session or boto3.session.Session()
+        self.downloader = downloader
+
+    # ------------------------------------------------------------------------
+    # Installation
+    # ------------------------------------------------------------------------
+    def verify_installation(self) -> tuple[bool, Path | None, str | None]:
+        """Verify installation of AWS Session Manager plugin.
+
+        Returns:
+            3-tuple of boolean flag indicating whether plugin installed, binary path and version string.
+        """
+        # Find plugin binary
+        if not (binary_path := self._get_binary_path()):
+            return False, None, None
+
+        # Check version
+        result_bytes = subprocess.run(  # noqa: S603
+            [str(binary_path), "--version"],
+            check=True,
+            capture_output=True,
+        )
+        result = result_bytes.stdout.decode().strip()
+        if not bool(re.match(r"[\d\.]+", result)):
+            return False, binary_path, result
+
+        return True, binary_path, result
+
+    def _get_binary_path(self) -> Path | None:
+        """Get the path to the session-manager-plugin binary."""
+        binary_path_str = shutil.which("session-manager-plugin")
+        if not binary_path_str:
+            if platform.system() == "Windows":
+                # Windows: use the default installation path
+                binary_path = (
+                    Path(os.environ["ProgramFiles"])  # noqa: SIM112
+                    / "Amazon"
+                    / "SessionManagerPlugin"
+                    / "bin"
+                    / "session-manager-plugin.exe"
+                )
+                if binary_path.is_file():
+                    return binary_path.absolute()
+
+            return None
+
+        return Path(binary_path_str).absolute()
+
+    def install(
+        self,
+        *,
+        os: str | None = None,
+        linux_distribution: _LinuxDistribution | None = None,
+        arch: str | None = None,
+        root: bool | None = None,
+    ) -> None:
+        """Install AWS Session Manager plugin.
+
+        Args:
+            os: The operating system to install the plugin on. If `None`, will use the current operating system.
+            linux_distribution: The Linux distribution to install the plugin on.
+                If `None` and current `os` is `"Linux"`, will try to detect the distribution from current system.
+            arch: The architecture to install the plugin on. If `None`, will use the current architecture.
+            root: Whether to run the installation as root. If `None`, will check if the current user is root.
+        """
+        os = os or platform.system()
+        arch = arch or platform.machine()
+
+        if os == "Windows":
+            self._install_windows()
+        elif os == "Darwin":
+            self._install_macos(arch=arch, root=root or is_root())
+        elif os == "Linux":
+            linux_distribution = linux_distribution or _detect_linux_distribution()
+            self._install_linux(linux_distribution=linux_distribution, arch=arch, root=root or is_root())
+        else:
+            msg = f"Unsupported operating system: {os}"
+            raise UnsupportedPlatformError(msg)
+
+    def before_install(self, command: list[str]) -> None:
+        """Hook to run before invoking plugin installation command."""
+
+    # https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-windows.html
+    def _install_windows(self) -> None:
+        """Install session-manager-plugin on Windows via EXE installer."""
+        download_url = (
+            "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/windows/SessionManagerPluginSetup.exe"
+        )
+        with tempfile.TemporaryDirectory() as temp_dir:
+            p = Path(temp_dir)
+            exe_installer = self.downloader.download(download_url, to=p / "SessionManagerPluginSetup.exe")
+            command = [str(exe_installer), "/quiet"]
+            self.before_install(command)
+            subprocess.call(command, cwd=p)  # noqa: S603
+
+    # https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html
+    def _install_macos(self, *, arch: str, root: bool) -> None:
+        """Install session-manager-plugin on macOS via signed installer."""
+        # ! Intel chip will not be supported
+        if arch == "x86_64":
+            download_url = (
+                "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/mac/session-manager-plugin.pkg"
+            )
+        elif arch == "arm64":
+            download_url = (
+                "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/mac_arm64/session-manager-plugin.pkg"
+            )
+        else:
+            msg = f"Architecture {arch} not supported for macOS"
+            raise UnsupportedPlatformError(msg)
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            p = Path(temp_dir)
+            pkg_installer = self.downloader.download(download_url, to=p / "session-manager-plugin.pkg")
+
+            # Run installer
+            command = command_as_root(
+                ["installer", "-pkg", str(pkg_installer), "-target", "/"],
+                root=root,
+            )
+            self.before_install(command)
+            subprocess.call(command, cwd=p)  # noqa: S603
+
+            # Symlink
+            command = [
+                "ln",
+                "-s",
+                "/usr/local/sessionmanagerplugin/bin/session-manager-plugin",
+                "/usr/local/bin/session-manager-plugin",
+            ]
+            if not root:
+                command = ["sudo", *command]
+
+            logger.info("Running %s to create symlink", " ".join(command))
+            Path("/usr/local/bin").mkdir(exist_ok=True)
+            subprocess.call(command, cwd=p)  # noqa: S603
+
+    # https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-linux-overview.html
+    def _install_linux(
+        self,
+        *,
+        linux_distribution: _LinuxDistribution,
+        arch: str,
+        root: bool,
+    ) -> None:
+        name = linux_distribution.name
+        version = linux_distribution.version
+
+        # Debian / Ubuntu
+        if name in ("debian", "ubuntu"):
+            logger.info("Detected Linux distribution: Debian / Ubuntu")
+
+            # Download installer
+            url_map = {
+                "x86_64": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/ubuntu_64bit/session-manager-plugin.deb",
+                "x86": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/ubuntu_32bit/session-manager-plugin.deb",
+                "arm64": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/ubuntu_arm64/session-manager-plugin.deb",
+            }
+            download_url = url_map.get(arch)
+            if not download_url:
+                msg = f"Architecture {arch} not supported for distribution {name}"
+                raise UnsupportedPlatformError(msg)
+
+            with tempfile.TemporaryDirectory() as temp_dir:
+                p = Path(temp_dir)
+                deb_installer = self.downloader.download(download_url, to=p / "session-manager-plugin.deb")
+
+                # Invoke installation command
+                command = command_as_root(["dpkg", "--install", str(deb_installer)], root=root)
+                self.before_install(command)
+                subprocess.call(command, cwd=p)  # noqa: S603
+
+        # Amazon Linux / RHEL
+        elif name in ("amzn", "rhel"):
+            logger.info("Detected Linux distribution: Amazon Linux / RHEL")
+
+            # Determine package URL and package manager
+            url_map = {
+                "x86_64": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/linux_64bit/session-manager-plugin.rpm",
+                "x86": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/linux_32bit/session-manager-plugin.rpm",
+                "arm64": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/linux_arm64/session-manager-plugin.rpm",
+            }
+            package_url = url_map.get(arch)
+            if not package_url:
+                msg = f"Architecture {arch} not supported for distribution {name}"
+                raise UnsupportedPlatformError(msg)
+
+            use_yum = (
+                # Amazon Linux 2
+                name == "amzn" and version.startswith("2")
+            ) or (
+                # RHEL 7 Maipo (8 Ootpa / 9 Plow)
+                name == "rhel" and "Maipo" in version
+            )  # ... else use dnf
+            package_manager = "yum" if use_yum else "dnf"
+
+            # Invoke installation command
+            command = command_as_root([package_manager, "install", "-y", package_url], root=root)
+            self.before_install(command)
+            subprocess.call(command)  # noqa: S603
+
+        else:
+            msg = f"Unsupported distribution: {name}"
+            raise UnsupportedPlatformError(msg)
+
+    # ------------------------------------------------------------------------
+    # Session
+    # ------------------------------------------------------------------------
+    def start(
+        self,
+        *,
+        target: str,
+        document_name: str,
+        parameters: dict[str, Any],
+        reason: str | None = None,
+        log_file: Path | None = None,
+    ) -> subprocess.Popen:
+        """Start new session.
+
+        Args:
+            target: The target instance ID or name.
+            document_name: The SSM document name to use for the session.
+            parameters: The parameters to pass to the SSM document.
+            reason: The reason for starting the session.
+            log_file: Optional file to log output to.
+
+        Returns:
+            Process ID of the session.
+        """
+        is_installed, binary_path, version = self.verify_installation()
+        if not is_installed:
+            msg = "Session Manager plugin is not installed."
+            raise PluginNotInstalledError(msg)
+
+        ssm = self.session.client("ssm")
+        response = ssm.start_session(
+            Target=target,
+            DocumentName=document_name,
+            Parameters=parameters,
+            # ? Reason is optional but it doesn't allow empty string or `None`
+            **({"Reason": reason} if reason else {}),
+        )
+
+        region = self.session.region_name
+        command = [
+            str(binary_path),
+            json.dumps(response),
+            region,
+            "StartSession",
+            self.session.profile_name,
+            json.dumps({"Target": target}),
+            f"https://ssm.{region}.amazonaws.com",
+        ]
+
+        stdout: subprocess._FILE
+        if log_file is not None:  # noqa: SIM108
+            stdout = log_file.open(mode="at+", buffering=1)
+        else:
+            stdout = subprocess.DEVNULL
+
+        return subprocess.Popen(  # noqa: S603
+            command,
+            stdout=stdout,
+            stderr=subprocess.STDOUT,
+            text=True,
+            close_fds=False,  # FD inherited from parent process
+        )
+
+
+# ? Could be moved to utils, but didn't because it's too specific to this module
+class _LinuxDistribution(NamedTuple):
+    name: str
+    version: str
+
+
+def _detect_linux_distribution() -> _LinuxDistribution:
+    """Autodetect current Linux distribution."""
+    osr = os_release()
+    name = osr.get("ID", "").lower()
+    version = osr.get("VERSION", "")
+    return _LinuxDistribution(name=name, version=version)

aws_annoying/utils/downloader.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+import requests
+from tqdm import tqdm
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class AbstractDownloader(ABC):
+    """Abstract downloader class for downloading files."""
+
+    @abstractmethod
+    def download(self, url: str, *, to: Path) -> Path:
+        """Download file from URL to path."""
+
+
+class DummyDownloader(AbstractDownloader):
+    """Dummy downloader that does nothing (mainly for testing purposes)."""
+
+    def download(self, url: str, *, to: Path) -> Path:
+        """Download file from URL to path."""
+        logger.debug("Dummy downloader called for URL (%s) to %s.", url, to)
+        return to.absolute()
+
+
+class TQDMDownloader(AbstractDownloader):
+    """Downloader with TQDM progress bar."""
+
+    def download(self, url: str, *, to: Path) -> Path:
+        """Download file from URL to path."""
+        # https://gist.github.com/yanqd0/c13ed29e29432e3cf3e7c38467f42f51
+        logger.info("Downloading file from URL (%s) to %s.", url, to)
+        with requests.get(url, stream=True, timeout=10) as response:
+            response.raise_for_status()
+            total_size = int(response.headers.get("content-length", 0))
+            with (
+                to.open("wb") as f,
+                tqdm(
+                    # Make the URL less verbose in the progress bar
+                    desc=url.replace("https://s3.amazonaws.com/session-manager-downloads/plugin", "..."),
+                    total=total_size,
+                    unit="iB",
+                    unit_scale=True,
+                    unit_divisor=1_024,
+                ) as pbar,
+            ):
+                for chunk in response.iter_content(chunk_size=8_192):
+                    size = f.write(chunk)
+                    pbar.update(size)
+
+        return to.absolute()

aws_annoying/utils/platform.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def command_as_root(command: list[str], *, root: bool | None = None) -> list[str]:
+    """Modify a command to run as root (`sudo`) if not already running as root."""
+    root = root or is_root()
+    if not root:
+        command = ["sudo", *command]
+
+    return command
+
+
+def is_root() -> bool:
+    """Check if the current user is root."""
+    return os.geteuid() == 0
+
+
+def os_release() -> dict[str, str]:
+    """Parse `/etc/os-release` file into a dictionary."""
+    content = Path("/etc/os-release").read_text()
+    return {
+        key.strip('"'): value.strip('"')
+        for key, value in (line.split("=", 1) for line in content.splitlines() if "=" in line)
+    }

aws_annoying/variables.py

@@ -0,0 +1,133 @@
+# flake8: noqa: B008
+from __future__ import annotations
+
+import json
+from typing import Any, TypedDict
+
+import boto3
+
+# Type aliases for readability
+_ARN = str
+_Variables = dict[str, Any]
+
+# TODO(lasuillard): Need some refactoring (with #2, #3)
+# TODO(lasuillard): Put some logging
+
+
+class _LoadStatsDict(TypedDict):
+    secrets: int
+    parameters: int
+
+
+class VariableLoader:  # noqa: D101
+    def __init__(self, *, dry_run: bool) -> None:
+        """Initialize the VariableLoader.
+
+        Args:
+            dry_run: Whether to run in dry-run mode.
+            console: Rich console instance.
+        """
+        self.dry_run = dry_run
+
+    # TODO(lasuillard): Currently not using pagination (do we need more than 10-20 secrets or parameters each?)
+    #                   ; consider adding it if needed
+    def load(self, map_arns: dict[str, _ARN]) -> tuple[dict[str, Any], _LoadStatsDict]:
+        """Load the variables from the AWS Secrets Manager and SSM Parameter Store.
+
+        Each secret or parameter should be a valid dictionary, where the keys are the variable names
+        and the values are the variable values.
+
+        The items are merged in the order of the key of provided mapping, overwriting the variables with the same name
+        in the order of the keys.
+        """
+        # Split the ARNs by resource types
+        secrets_map, parameters_map = {}, {}
+        for idx, arn in map_arns.items():
+            if arn.startswith("arn:aws:secretsmanager:"):
+                secrets_map[idx] = arn
+            elif arn.startswith("arn:aws:ssm:"):
+                parameters_map[idx] = arn
+            else:
+                msg = f"Unsupported resource: {arn!r}"
+                raise ValueError(msg)
+
+        # Retrieve variables from AWS resources
+        secrets: dict[str, _Variables]
+        parameters: dict[str, _Variables]
+        if self.dry_run:
+            secrets = {idx: {} for idx, _ in secrets_map.items()}
+            parameters = {idx: {} for idx, _ in parameters_map.items()}
+        else:
+            secrets = self._retrieve_secrets(secrets_map)
+            parameters = self._retrieve_parameters(parameters_map)
+
+        load_stats: _LoadStatsDict = {
+            "secrets": len(secrets),
+            "parameters": len(parameters),
+        }
+
+        # Merge the variables in order
+        full_variables = secrets | parameters  # Keys MUST NOT conflict
+        merged_in_order = {}
+        for _, variables in sorted(full_variables.items()):
+            merged_in_order.update(variables)
+
+        return merged_in_order, load_stats
+
+    def _retrieve_secrets(self, secrets_map: dict[str, _ARN]) -> dict[str, _Variables]:
+        """Retrieve the secrets from AWS Secrets Manager."""
+        if not secrets_map:
+            return {}
+
+        secretsmanager = boto3.client("secretsmanager")
+
+        # Retrieve the secrets
+        arns = list(secrets_map.values())
+        response = secretsmanager.batch_get_secret_value(SecretIdList=arns)
+        if errors := response["Errors"]:
+            msg = f"Failed to retrieve secrets: {errors!r}"
+            raise ValueError(msg)
+
+        # Parse the secrets
+        secrets = response["SecretValues"]
+        result = {}
+        for secret in secrets:
+            arn = secret["ARN"]
+            order_key = next(key for key, value in secrets_map.items() if value == arn)
+            data = json.loads(secret["SecretString"])
+            if not isinstance(data, dict):
+                msg = f"Secret data must be a valid dictionary, but got: {type(data)!r}"
+                raise TypeError(msg)
+
+            result[order_key] = data
+
+        return result
+
+    def _retrieve_parameters(self, parameters_map: dict[str, _ARN]) -> dict[str, _Variables]:
+        """Retrieve the parameters from AWS SSM Parameter Store."""
+        if not parameters_map:
+            return {}
+
+        ssm = boto3.client("ssm")
+
+        # Retrieve the parameters
+        parameter_names = list(parameters_map.values())
+        response = ssm.get_parameters(Names=parameter_names, WithDecryption=True)
+        if errors := response["InvalidParameters"]:
+            msg = f"Failed to retrieve parameters: {errors!r}"
+            raise ValueError(msg)
+
+        # Parse the parameters
+        parameters = response["Parameters"]
+        result = {}
+        for parameter in parameters:
+            arn = parameter["ARN"]
+            order_key = next(key for key, value in parameters_map.items() if value == arn)
+            data = json.loads(parameter["Value"])
+            if not isinstance(data, dict):
+                msg = f"Parameter data must be a valid dictionary, but got: {type(data)!r}"
+                raise TypeError(msg)
+
+            result[order_key] = data
+
+        return result

{aws_annoying-0.2.1.dist-info → aws_annoying-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-annoying
-Version: 0.2.1
+Version: 0.4.0
 Summary: Utils to handle some annoying AWS tasks.
 Project-URL: Homepage, https://github.com/lasuillard/aws-annoying
 Project-URL: Repository, https://github.com/lasuillard/aws-annoying.git
@@ -9,13 +9,16 @@ Author-email: Yuchan Lee <lasuillard@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: <4.0,>=3.9
-Requires-Dist: boto3>=1.37.1
-Requires-Dist: pydantic>=2.10.6
-Requires-Dist: typer>=0.15.1
+Requires-Dist: boto3<2,>=1
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: requests<3,>=2
+Requires-Dist: tqdm<5,>=4
+Requires-Dist: typer<1,>=0
 Provides-Extra: dev
-Requires-Dist: boto3-stubs[ecs,secretsmanager,ssm,sts]>=1.37.1; extra == 'dev'
+Requires-Dist: boto3-stubs[ec2,ecs,secretsmanager,ssm,sts]>=1.37.1; extra == 'dev'
 Requires-Dist: mypy~=1.15.0; extra == 'dev'
 Requires-Dist: ruff<0.12.0,>=0.9.9; extra == 'dev'
+Requires-Dist: types-requests>=2.31.0.6; extra == 'dev'
 Provides-Extra: test
 Requires-Dist: coverage<7.9,>=7.6; extra == 'test'
 Requires-Dist: moto[ecs,secretsmanager,server,ssm]~=5.1.1; extra == 'test'

aws_annoying-0.4.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+aws_annoying/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aws_annoying/mfa.py,sha256=m6-V1bWeUWsAmRddl-lv13mPCMnftoPzJoNnZ0kiaWQ,2007
+aws_annoying/variables.py,sha256=a9cMS9JU-XA2h1tztO7ofixoDEpqtS_eVEiWrQ75mTo,4761
+aws_annoying/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aws_annoying/cli/app.py,sha256=sp50uVoAl4D6Wk3DFpzKZzSsxmSxNYejFxm62b_Kxps,201
+aws_annoying/cli/ecs_task_definition_lifecycle.py,sha256=O36Bf5LBnVJNyYmdlUxhtsIHNoxky1t5YacAXiL9UEI,2803
+aws_annoying/cli/load_variables.py,sha256=eWNByUEc1ijF8uCe_egdAnjWxfMNCZeVr0vtTtQLe3Y,5086
+aws_annoying/cli/main.py,sha256=TSzPeMkgIgKFf3bom_vDkFYK0bHF1r5K9ADreZUV3k4,503
+aws_annoying/cli/mfa/__init__.py,sha256=rbEGhw5lOQZV_XAc3nSbo56JVhsSPpeOgEtiAy9qzEA,50
+aws_annoying/cli/mfa/_app.py,sha256=Ub7gxb6kGF3Ve1ucQSOjHmc4jAu8mxgegcXsIbOzLLQ,189
+aws_annoying/cli/mfa/configure.py,sha256=vsoHfTVFF2dPgiYsp2L-EkMwtAA0_-tVwFd6Wv6DscU,3746
+aws_annoying/cli/session_manager/__init__.py,sha256=FkT6jT6OXduOURN61d-U6hgd-XluQbvuVtKXXiXgSEk,105
+aws_annoying/cli/session_manager/_app.py,sha256=OVOHW0iyKzunvaqLhjoseHw1-WxJ1gGb7QmiyAEezyY,221
+aws_annoying/cli/session_manager/_common.py,sha256=0fCm6Zx6P1NcyyiHlSoB9PgIdrxzUXLVPqKJWQnJ8I4,792
+aws_annoying/cli/session_manager/install.py,sha256=zX2cu-IBYlf9yl8z9P0CTQz72BP6aAMo-KnolC_PGsU,1443
+aws_annoying/cli/session_manager/port_forward.py,sha256=uMcsafTNAHZh-0E1yWXCliMivWyuWV2K9DdVhBZ9pG8,4327
+aws_annoying/cli/session_manager/start.py,sha256=1yaMuy-7IWrrDoPHjgygOP_-g_tajfnpaVPZanxsZxs,215
+aws_annoying/cli/session_manager/stop.py,sha256=ttU6nlbVgBkZDtY-DwUyCstv5TFtat5TljkyuY8QICU,1482
+aws_annoying/session_manager/__init__.py,sha256=swbRdFh9CdO6tzyBjSxN0KC7MMASvptIpbsijUPIZgI,243
+aws_annoying/session_manager/errors.py,sha256=YioKlRtZ-GUP0F_ts_ebw7-HYkxe8mTes6HK821Kuiw,353
+aws_annoying/session_manager/session_manager.py,sha256=7tqfFPA4bWF0Me_VbUDcq5Cpl1sw3bevGyT8QWfLTOk,12454
+aws_annoying/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aws_annoying/utils/debugger.py,sha256=UFllDCGI2gPtwo1XS5vqw0qyR6bYr7XknmBwSxalKIc,754
+aws_annoying/utils/downloader.py,sha256=aB5RzT-LpbFX24-2HXlAkdgVowc4TR9FWT_K8WwZ1BE,1923
+aws_annoying/utils/platform.py,sha256=h3DUWmTMM-_4TfTWNqY0uNqyVsBjAuMm2DEbG-daxe8,742
+aws_annoying-0.4.0.dist-info/METADATA,sha256=9u5wofuLZXXPrAj1YcOhbqPlPH46jtub8AUvs2KNZ9s,1916
+aws_annoying-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aws_annoying-0.4.0.dist-info/entry_points.txt,sha256=DcKE5V0WvVJ8wUOHxyUz1yLAJOuuJUgRPlMcQ4O7jEs,66
+aws_annoying-0.4.0.dist-info/licenses/LICENSE,sha256=Q5GkvYijQ2KTQ-QWhv43ilzCno4ZrzrEuATEQZd9rYo,1067
+aws_annoying-0.4.0.dist-info/RECORD,,

aws_annoying-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aws-annoying = aws_annoying.cli.main:entrypoint