nate2-scripts 1.0.0__py3-none-any.whl

nate2_scripts/console/hashGrabber.py

@@ -0,0 +1,178 @@
+import re
+import shutil
+import sqlite3
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+SUPPORTED_BROWSERS = {
+    "com.google.chrome": "chrome",
+    "org.mozilla.firefox": "firefox",
+}
+
+WAIT_SECONDS = 10  # Time to wait for the browser to open and record the hash
+
+ONLY_HASH_SECONDS = 5 # Time to wait for the browser to open and record the hash, but only return the hash if found
+
+
+class HashGrabber:
+
+    @staticmethod
+    def _get_default_browser() -> str:
+        """Return 'chrome' or 'firefox'. Prints to stderr and exits for unsupported browsers."""
+        result = subprocess.run(
+            [
+                "defaults", "read",
+                str(Path.home() / "Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure"),
+                "LSHandlers",
+            ],
+            capture_output=True,
+            text=True,
+        )
+        # Find the block containing LSHandlerURLScheme = https and extract LSHandlerRoleAll
+        match = re.search(
+            r'LSHandlerRoleAll\s*=\s*"([^"]+)";\s*LSHandlerURLScheme\s*=\s*https;',
+            result.stdout,
+        )
+        bundle_id = match.group(1).lower() if match else ""
+
+        if bundle_id in SUPPORTED_BROWSERS:
+            return SUPPORTED_BROWSERS[bundle_id]
+
+        print(
+            f"Unsupported default browser: {bundle_id or 'unknown'}. Only Chrome and Firefox are supported.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    @staticmethod
+    def get_hash(id: str, time_started: float) -> str:
+        """Search the default browser's history for the most recent AWS console URL matching the account ID.
+
+        Polls up to WAIT_SECONDS for a URL visited after time_started.
+        Returns the hash portion from URLs like https://{id}-{hash}.{region}.console.aws.amazon.com/*
+        or empty string for URLs like https://{region}.console.aws.amazon.com/*.
+
+        Raises RuntimeError if no matching URL is found within the timeout.
+        """
+        default = HashGrabber._get_default_browser()
+
+        pattern_with_hash = re.compile(
+            rf"https://{re.escape(id)}-([a-z0-9]+)\.[a-z0-9-]+\.console\.aws\.amazon\.com"
+        )
+        pattern_without_hash = re.compile(
+            r"https://[a-z0-9-]+\.console\.aws\.amazon\.com"
+        )
+
+        fetch_fn = {
+            "chrome": HashGrabber._chrome_history,
+            "firefox": HashGrabber._firefox_history,
+        }[default]
+
+        deadline = time_started + WAIT_SECONDS
+        hash_only_deadline = time_started + ONLY_HASH_SECONDS
+        time.sleep(0.5)
+
+        while time.time() < deadline:
+            try:
+                print("-----------------------------------------")
+                for url, visit_time in fetch_fn(id, time_started):
+                    print(url, visit_time)
+                    match = pattern_with_hash.search(url)
+                    if match:
+                        return match.group(1)
+                    elif time.time() >= hash_only_deadline and pattern_without_hash.search(url):
+                        return ""
+            except (OSError, sqlite3.Error):
+                pass
+
+            time.sleep(0.5)
+
+        raise RuntimeError(
+            f"No AWS console URL found for account {id} within {WAIT_SECONDS}s"
+        )
+
+    @staticmethod
+    def _chrome_history(account_id: str, time_started: float) -> list[tuple[str, float]]:
+        db_path = HashGrabber._chrome_sqlite_path()
+        if not db_path.exists():
+            return []
+
+        # Chrome stores time as microseconds since 1601-01-01
+        chrome_epoch_offset = 11644473600
+        chrome_time_started = int((time_started + chrome_epoch_offset) * 1_000_000)
+
+        with tempfile.NamedTemporaryFile(suffix=".sqlite") as tmp:
+            shutil.copy2(db_path, tmp.name)
+            conn = sqlite3.connect(tmp.name)
+            try:
+                cursor = conn.execute(
+                    """
+                    SELECT url, last_visit_time
+                    FROM urls
+                    WHERE (url LIKE ? OR url LIKE '%console.aws.amazon.com%')
+                      AND last_visit_time > ?
+                    ORDER BY last_visit_time DESC
+                    LIMIT 10
+                    """,
+                    (f"%{account_id}%console.aws.amazon.com%", chrome_time_started),
+                )
+                return cursor.fetchall()
+            finally:
+                conn.close()
+
+    @staticmethod
+    def _firefox_history(account_id: str, time_started: float) -> list[tuple[str, float]]:
+        db_path = HashGrabber._firefox_sqlite_path()
+        if not db_path or not db_path.exists():
+            return []
+
+        # Firefox stores time as microseconds since Unix epoch
+        firefox_time_started = int(time_started * 1_000_000)
+
+        with tempfile.NamedTemporaryFile(suffix=".sqlite") as tmp:
+            shutil.copy2(db_path, tmp.name)
+            conn = sqlite3.connect(tmp.name)
+            try:
+                cursor = conn.execute(
+                    """
+                    SELECT p.url, v.visit_date
+                    FROM moz_places p
+                    JOIN moz_historyvisits v ON v.place_id = p.id
+                    WHERE (p.url LIKE ? OR p.url LIKE '%console.aws.amazon.com%')
+                      AND v.visit_date > ?
+                    ORDER BY v.visit_date DESC
+                    LIMIT 10
+                    """,
+                    (f"%{account_id}%console.aws.amazon.com%", firefox_time_started),
+                )
+                return cursor.fetchall()
+            finally:
+                conn.close()
+
+    @staticmethod
+    def _chrome_sqlite_path() -> Path:
+        return Path.home() / "Library/Application Support/Google/Chrome/Default/History"
+
+    @staticmethod
+    def _firefox_sqlite_path() -> Path | None:
+        profiles_dir = Path.home() / "Library/Application Support/Firefox/Profiles"
+        if not profiles_dir.exists():
+            return None
+
+        for pattern in ["*.default-release", "*.default"]:
+            matches = list(profiles_dir.glob(pattern))
+            if matches:
+                db = matches[0] / "places.sqlite"
+                if db.exists():
+                    return db
+
+        for profile in profiles_dir.iterdir():
+            if profile.is_dir():
+                db = profile / "places.sqlite"
+                if db.exists():
+                    return db
+
+        return None

nate2_scripts/console/regionCache.py

@@ -0,0 +1,50 @@
+import json
+import os
+from pathlib import Path
+
+DEFAULT_REGION = "us-east-1"
+DEFAULT_REGIONS = ["us-east-1", "us-east-2", "us-west-1", "us-west-2"]
+
+
+class RegionCache:
+    """Loads and persists the list of AWS regions and the default region.
+
+    Configuration is read from XDG_STATE_HOME/console-regions.json
+    (defaulting to ~/.local/state/console-regions.json). If the file is
+    absent or invalid it is recreated with the built-in defaults.
+    """
+
+    # Resolve the config file path from XDG_STATE_HOME or the default ~/.local/state
+    PATH = (
+        Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local" / "state"))
+        / "console-regions.json"
+    )
+
+    # Class-level defaults; overwritten per-instance when the config file is loaded
+    regions: list[str] = DEFAULT_REGIONS
+    default: str = DEFAULT_REGION
+
+    def __init__(self):
+        """Load region config from disk, falling back to defaults if unavailable."""
+        if self.PATH.exists():
+            try:
+                file = json.loads(self.PATH.read_text())
+                if file.get("regions"):
+                    self.regions = file["regions"]
+                if file.get("default"):
+                    self.default = file["default"]
+                return
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        # File is missing or corrupt — write defaults so subsequent reads succeed
+        self.PATH.parent.mkdir(parents=True, exist_ok=True)
+        self.PATH.write_text(json.dumps({"regions": DEFAULT_REGIONS, "default": DEFAULT_REGION}))
+
+    def get_regions(self) -> list[str]:
+        """Return the list of configured AWS regions."""
+        return self.regions
+
+    def get_default_region(self) -> str:
+        """Return the default AWS region."""
+        return self.default

nate2_scripts/console/resourceIdResolver.py

@@ -0,0 +1,174 @@
+import re
+import sys
+from typing import NoReturn
+import boto3
+from botocore.exceptions import ClientError
+
+from nate2_scripts.console.regionCache import RegionCache
+
+
+class ResourceIdResolver:
+
+    region_cache: RegionCache
+    mdn: str
+
+    def __init__(self, region_cache: RegionCache, multisession_domain_name: str):
+        self.region_cache = region_cache
+        self.mdn = multisession_domain_name
+
+    _KMS_UUID = re.compile(
+        r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
+    )
+    _KMS_MRK = re.compile(r"^mrk-[0-9a-f]{32}$")
+
+    def try_parse_resource_id(self, resource_id: str) -> str | None:
+        kind = self._kind(resource_id)
+        if kind is None:
+            return None
+
+        # IAM resources are global — no region search needed
+        if kind == "role":
+            name = resource_id[5:]
+            try:
+                boto3.client("iam").get_role(RoleName=name)
+            except ClientError:
+                self._not_found(resource_id)
+            return f"https://{self.mdn}us-east-1.console.aws.amazon.com/iam/home#/roles/{name}"
+        if kind == "user":
+            name = resource_id[4:]
+            try:
+                boto3.client("iam").get_user(UserName=name)
+            except ClientError:
+                self._not_found(resource_id)
+            return f"https://{self.mdn}us-east-1.console.aws.amazon.com/iam/home#/users/{name}"
+
+        # regional resources — find the region that actually holds the resource
+        for region in self.region_cache.get_regions():
+            url = self._resolve_in_region(kind, resource_id, region)
+            if url:
+                return url
+
+        self._not_found(resource_id)
+
+    def _kind(self, resource_id: str) -> str | None:
+        if re.match(r"^i-[0-9a-f]{8,17}$", resource_id):
+            return "instance"
+        if re.match(r"^vpc-[0-9a-f]{8,17}$", resource_id):
+            return "vpc"
+        if re.match(r"^subnet-[0-9a-f]{8,17}$", resource_id):
+            return "subnet"
+        if re.match(r"^sg-[0-9a-f]{8,17}$", resource_id):
+            return "sg"
+        if re.match(r"^ami-[0-9a-f]{8,17}$", resource_id):
+            return "ami"
+        if re.match(r"^lt-[0-9a-f]{8,17}$", resource_id):
+            return "lt"
+        if re.match(r"^rtb-[0-9a-f]{8,17}$", resource_id):
+            return "rtb"
+        if re.match(r"^vol-[0-9a-f]{8,17}$", resource_id):
+            return "vol"
+        if re.match(r"^snap-[0-9a-f]{8,17}$", resource_id):
+            return "snap"
+        if re.match(r"^eni-[0-9a-f]{8,17}$", resource_id):
+            return "eni"
+        if re.match(r"^nat-[0-9a-f]{8,17}$", resource_id):
+            return "nat"
+        # no idea where this is supposed to go, but it's a thing that exists
+        # keeping it here in case I figure out later
+        # if re.match(r"^fl-[0-9a-f]{8,17}$", resource_id):
+        #     return "fl"
+        if self._KMS_UUID.match(resource_id) or self._KMS_MRK.match(resource_id):
+            return "kms"
+        if resource_id.startswith("db/"):
+            return "rds"
+        if resource_id.startswith("role/"):
+            return "role"
+        if resource_id.startswith("usr/"):
+            return "user"
+        return None
+
+    def _resolve_in_region(
+        self, kind: str, resource_id: str, region: str
+    ) -> str | None:
+        base = f"https://{self.mdn}{region}.console.aws.amazon.com"
+        try:
+            match kind:
+                case "instance":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_instances(InstanceIds=[resource_id])["Reservations"]:
+                        return f"{base}/ec2/v2/home?region={region}#InstanceDetails:instanceId={resource_id}"
+                case "vpc":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_vpcs(VpcIds=[resource_id])["Vpcs"]:
+                        return f"{base}/vpcconsole/home?region={region}#VpcDetails:VpcId={resource_id}"
+                case "subnet":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_subnets(SubnetIds=[resource_id])["Subnets"]:
+                        return f"{base}/vpcconsole/home?region={region}#SubnetDetails:subnetId={resource_id}"
+                case "sg":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_security_groups(GroupIds=[resource_id])[
+                        "SecurityGroups"
+                    ]:
+                        return f"{base}/ec2/v2/home?region={region}#SecurityGroup:groupId={resource_id}"
+                case "ami":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_images(ImageIds=[resource_id])["Images"]:
+                        return f"{base}/ec2/home?region={region}#ImageDetails:imageId={resource_id}"
+                case "lt":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_launch_templates(LaunchTemplateIds=[resource_id])[
+                        "LaunchTemplates"
+                    ]:
+                        return f"{base}/ec2/home?region={region}#LaunchTemplateDetails:launchTemplateId={resource_id}"
+                case "rtb":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_route_tables(RouteTableIds=[resource_id])[
+                        "RouteTables"
+                    ]:
+                        return f"{base}/vpcconsole/home?region={region}#RouteTableDetails:RouteTableId={resource_id}"
+                case "vol":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_volumes(VolumeIds=[resource_id])["Volumes"]:
+                        return f"{base}/ec2/home?region={region}#VolumeDetails:volumeId={resource_id}"
+                case "snap":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_snapshots(SnapshotIds=[resource_id])["Snapshots"]:
+                        return f"{base}/ec2/home?region={region}#SnapshotDetails:snapshotId={resource_id}"
+                case "eni":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_network_interfaces(NetworkInterfaceIds=[resource_id])["NetworkInterfaces"]:
+                        return f"{base}/ec2/home?region={region}#NetworkInterface:networkInterfaceId={resource_id}"
+                case "nat":
+                    ec2 = boto3.client("ec2", region_name=region)
+                    if ec2.describe_nat_gateways(NatGatewayIds=[resource_id])["NatGateways"]:
+                        return f"{base}/vpcconsole/home?region={region}#NatGatewayDetails:natGatewayId={resource_id}"
+                # case "fl":
+                #     ec2 = boto3.client("ec2", region_name=region)
+                #     if ec2.describe_flow_logs(FlowLogIds=[resource_id])["FlowLogs"]:
+                #         return f"{base}/vpcconsole/home?region={region}#FlowLogs:flowLogId={resource_id}"
+                case "kms":
+                    boto3.client("kms", region_name=region).describe_key(
+                        KeyId=resource_id
+                    )
+                    return f"{base}/kms/home?region={region}#/kms/keys/{resource_id}"
+                # TODO test this
+                case "rds":
+                    name = resource_id[3:]
+                    if boto3.client("rds", region_name=region).describe_db_instances(
+                        DBInstanceIdentifier=name
+                    )["DBInstances"]:
+                        return f"{base}/rds/home?region={region}#database:id={name};is-cluster=false"
+        except ClientError:
+            # not present (or not accessible) in this region — try the next one
+            return None
+        return None
+
+    def _not_found(self, resource_id: str) -> NoReturn:
+        regions = ", ".join(self.region_cache.get_regions())
+        print(
+            f"Error: '{resource_id}' not found or not accessible in regions: {regions}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+

nate2_scripts/console/sessionCache.py

@@ -0,0 +1,96 @@
+from pathlib import Path
+import os
+import json
+import time
+from datetime import datetime, timezone
+
+
+class SessionCache:
+    """Persists AWS console federation session hashes to avoid redundant federated sign-ins.
+
+    The cache is stored as a JSON file at XDG_STATE_HOME/console-sessions.json
+    (defaulting to ~/.local/state/console-sessions.json). Each entry maps an AWS
+    profile name to its federated_at timestamp and session hash.
+    """
+
+    # Resolve the cache file path from XDG_STATE_HOME or the default ~/.local/state
+    PATH = (
+        Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local" / "state"))
+        / "console-sessions.json"
+    )
+
+    def _load_cache(self) -> dict:
+        """Read the cache file and return its contents as a dict.
+
+        Returns an empty dict if the file does not exist or is unreadable/corrupt.
+        """
+        if self.PATH.exists():
+            try:
+                return json.loads(self.PATH.read_text())
+            except (json.JSONDecodeError, OSError):
+                return {}
+        return {}
+
+    def _save_cache(self, cache: dict) -> None:
+        """Persist the cache dict to disk, creating parent directories as needed."""
+        self.PATH.parent.mkdir(parents=True, exist_ok=True)
+        self.PATH.write_text(json.dumps(cache))
+
+    def get_session_hash(self, profile: str, creds: dict) -> None | str:
+        """Return the cached session hash for a profile if it is still valid.
+
+        A cached entry is considered invalid (returns None) when:
+        - No entry exists for the profile.
+        - The STS credential Expiration timestamp has already passed.
+        - The entry was federated more than 11 hours ago (AWS console session limit).
+
+        Args:
+            profile: The AWS profile name used to look up the cache entry.
+            creds: STS credentials dict; may contain an "Expiration" ISO-8601 string.
+
+        Returns:
+            The cached session hash string, or None if the cache is missing/expired.
+        """
+        cache = self._load_cache()
+        entry = cache.get(profile)
+
+        if not entry:
+            return None
+
+        # Honour the STS credential expiration if present
+        expiration = creds.get("Expiration")
+        if expiration:
+            try:
+                exp_time = datetime.fromisoformat(expiration.replace("Z", "+00:00"))
+                if datetime.now(timezone.utc) >= exp_time:
+                    return None
+            except ValueError:
+                return None
+
+        # AWS federated console sessions expire after 12 hours; evict after 11 to be safe
+        if time.time() - entry["federated_at"] > 11 * 3600:
+            return None
+
+        return entry.get("hash")
+
+    def record_valid_hash(self, profile: str, hash: str) -> None:
+        """Store a newly obtained session hash and evict entries older than 12 hours.
+
+        Args:
+            profile: The AWS profile name to associate with the hash.
+            hash: The session hash returned after a successful federation sign-in.
+        """
+        cache = self._load_cache()
+        # Record the new entry with the current epoch time
+        cache[profile] = {"federated_at": time.time(), "hash": hash}
+        # Prune stale entries to keep the cache file small
+        cache = {
+            k: v
+            for k, v in cache.items()
+            if time.time() - v.get("federated_at", 0) < 12 * 3600
+        }
+        self._save_cache(cache)
+
+    def reset(self) -> None:
+        """Clear the entire session cache."""
+        self._save_cache({})

nate2_scripts/test.py

@@ -0,0 +1,98 @@
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+import urllib.parse
+import webbrowser
+import argparse
+from dataclasses import dataclass
+from pathlib import Path
+
+import argcomplete
+import boto3
+from botocore.exceptions import ClientError
+
+def get_credentials() -> dict:
+    result = subprocess.run(
+        ["aws", "configure", "export-credentials"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        print(f"Error: Failed to export credentials.\n{result.stderr}", file=sys.stderr)
+        sys.exit(1)
+    return json.loads(result.stdout)
+
+
+def get_signin_token(creds: dict) -> str:
+    session = json.dumps(
+        {
+            "sessionId": creds["AccessKeyId"],
+            "sessionKey": creds["SecretAccessKey"],
+            "sessionToken": creds["SessionToken"],
+        }
+    )
+    sess = urllib.parse.quote(session)
+    token_url = (
+        f"https://signin.aws.amazon.com/federation?Action=getSigninToken&Session={sess}"
+    )
+    result = subprocess.run(
+        ["curl", "-s", token_url], capture_output=True, text=True, check=True
+    )
+    try:
+        return json.loads(result.stdout)["SigninToken"]
+    except json.JSONDecodeError:
+        print("Error: Failed to parse JSON response. You may not have credentials.")
+        sys.exit(1)
+
+creds = get_credentials()
+print(creds)
+
+signin_token = get_signin_token(creds)
+
+print(signin_token)
+
+# Build the federation login URL
+destination = "https://us-east-1.console.aws.amazon.com/console/home?region=us-east-1"
+dest_encoded = urllib.parse.quote(destination, safe="")
+login_url = f"https://signin.aws.amazon.com/federation?Action=login&Issuer=&Destination={dest_encoded}&SigninToken={signin_token}"
+
+# Follow redirects and capture the final URL
+# print("\nFollowing federation redirect chain...")
+# result = subprocess.run(
+#     ["curl", "-s", "-L", "-o", "/dev/null", "-w", "%{url_effective}", login_url],
+#     capture_output=True,
+#     text=True,
+# )
+# final_url = result.stdout.strip()
+# print(f"Final URL: {final_url}")
+
+print(" ".join(["curl", "-s", "-L", "-v", login_url]))
+sys.exit(0)
+# Also check just the first redirect (without following)
+signin_token2 = get_signin_token(creds)
+login_url2 = f"https://signin.aws.amazon.com/federation?Action=login&Issuer=&Destination={dest_encoded}&SigninToken={signin_token2}"
+
+result2 = subprocess.run(
+    ["curl", "-s", "-o", "/dev/null", "-w", "%{redirect_url}", login_url2],
+    capture_output=True,
+    text=True,
+)
+first_redirect = result2.stdout.strip()
+print(f"First redirect URL: {first_redirect}")
+
+# Check if either contains the account-specific hash pattern
+pattern = r"(\d{12})-([a-z0-9]+)\.[a-z0-9-]+\.console\.aws\.amazon\.com"
+for label, url in [("Final", final_url), ("First redirect", first_redirect)]:
+    match = re.search(pattern, url)
+    if match:
+        account_id, console_hash = match.groups()
+        print(f"\n>>> Found hash in {label} URL!")
+        print(f"    Account ID: {account_id}")
+        print(f"    Console hash: {console_hash}")
+        break
+else:
+    print("\n>>> No account-specific hash found in redirects.")
+    print("    The rewrite is likely done client-side by JavaScript.")

nate2_scripts-1.0.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: nate2-scripts
+Version: 1.0.0
+Summary: Utility scripts for AWS development on macOS
+Project-URL: Homepage, https://github.com/tennex-nwestfall/nate2-scripts
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: argcomplete
+Requires-Dist: boto3

nate2_scripts-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+nate2_scripts/__init__.py,sha256=Odk0uF1h2RuL1xKI0M2Fp8A_Be7pT0PLkAw2nB9wC9M,101
+nate2_scripts/bing_wrapper.py,sha256=AKeIYAfFCFDVkP3PMdj7TEx25M_JpYRJHMN9SRqln5U,4694
+nate2_scripts/test.py,sha256=IlsOWc3eE_komf774xFBisu2ui1a28QmVPcySsVeG9s,3204
+nate2_scripts/console/__init__.py,sha256=_PGvw96WrEQNjJOZe0RmRvOClZ44L_y8hXY8P88AG_o,5050
+nate2_scripts/console/arnResolver.py,sha256=tiBw_XVlEWtj322jZWk0RVz9Pe6fdBk2C-lzMOPhxUE,24934
+nate2_scripts/console/destitationResolver.py,sha256=myZW81U7Deh0nPv4jfIvNVd8_XFf3d22_VX0_7ExjiY,5630
+nate2_scripts/console/hashGrabber.py,sha256=ydSqDCqCwG1YaqO5WKWWqMm0dLxR9GODX7BwYyXpcFo,6437
+nate2_scripts/console/regionCache.py,sha256=2yHSfP1bXBqL3QoSVEXw1pO4cuCIIYjm7h1qOYAwfWc,1812
+nate2_scripts/console/resourceIdResolver.py,sha256=QH7QA17n-jsJ7yj9ulyHP6MFT94jochXi9CX0-xkcqY,8185
+nate2_scripts/console/sessionCache.py,sha256=q60C_0vIg8h5oPP1Bh3rTdrMPn5mEkPQz7FR8DhrHmA,3562
+nate2_scripts-1.0.0.dist-info/METADATA,sha256=ibx35mXSfjLFA7bdsqxzTgvQlI9jgOwfwzbd4DjllgY,278
+nate2_scripts-1.0.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+nate2_scripts-1.0.0.dist-info/entry_points.txt,sha256=PvmjaUn-B1nck47azFCr4HYs0si1LRe-hMqEYwvIFCM,102
+nate2_scripts-1.0.0.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+nate2_scripts-1.0.0.dist-info/RECORD,,

nate2_scripts-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

nate2_scripts-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+bing-wrapper = nate2_scripts.bing_wrapper:main
+console = nate2_scripts.console:main