pump-aws-radar 0.1.0__tar.gz

pump_aws_radar-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Pump
+Portions copyright (c) 2026 Mor Michaeli (upstream aws-radar, https://github.com/gomorsmi/aws-radar)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pump_aws_radar-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: pump-aws-radar
+Version: 0.1.0
+Summary: Fork of aws-radar that pushes AWS inventory + billing CSVs to Pump's self-serve onboarding
+Author: Pump
+Maintainer: Pump
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/meku-pump/pump-aws-radar
+Project-URL: Repository, https://github.com/meku-pump/pump-aws-radar
+Project-URL: Upstream, https://github.com/gomorsmi/aws-radar
+Keywords: aws,cloud,inventory,cost-explorer,billing,finops,pump,onboarding
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: boto3>=1.34.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# pump-aws-radar
+
+A fork of [aws-radar](https://github.com/gomorsmi/aws-radar) that adds a one-command **push** of
+your AWS inventory and billing CSVs to Pump's self-serve onboarding endpoint — no standing
+cross-account role required.
+
+Everything upstream (`inventory`, `billing`, `diagram`, `run`) works unchanged. The only addition is
+`run --upload-token`.
+
+## Install
+
+```bash
+pip install pump-aws-radar
+```
+
+The console script is `pump-aws-radar`, so it installs alongside upstream `aws-radar` without
+colliding.
+
+## Pump onboarding
+
+1. In the Pump app, mint an upload token (this calls `POST /api/v1/estimate/radar/mint`). Pump shows
+   you a ready-to-paste command.
+2. Run it against the AWS account you want to onboard:
+
+   ```bash
+   pump-aws-radar run --all-regions --tags --billing --upload-token <TOKEN>
+   ```
+
+   This inventories the account read-only, pulls Cost Explorer billing, and uploads both
+   `inventory.csv` and `billing.csv` straight to Pump. No diagram is generated on this path.
+3. Pump detects both files, runs its analysis, and surfaces the findings in the app.
+
+### What leaves your machine
+
+Only the two CSVs. The token carries no AWS credentials and no company id — Pump binds the company
+and derives the S3 key server-side, so a token can only ever write its own upload's prefix. Each file
+goes to S3 through a short-lived presigned `PUT` URL that Pump mints on demand.
+
+### Pointing at a non-prod backend
+
+The token exchange defaults to `https://api.pump.co`. Override it for local testing:
+
+```bash
+pump-aws-radar run --billing --upload-token <TOKEN> --api-base http://localhost:8001
+# or
+PUMP_API_BASE=http://localhost:8001 pump-aws-radar run --billing --upload-token <TOKEN>
+```
+
+## How the push works
+
+`pump_aws_radar/upload.py`:
+
+1. For each role (`inventory`, `billing`), `POST {api_base}/api/v1/estimate/radar/urls` with
+   `{"token", "role"}` and receives a presigned S3 `PUT` URL.
+2. `PUT`s the corresponding CSV with `Content-Type: text/csv` (the presigned URL signs the
+   content-type, so it must match).
+
+## Relationship to upstream
+
+This is a derivative work of [aws-radar](https://github.com/gomorsmi/aws-radar), MIT-licensed, with
+upstream copyright preserved in `LICENSE`. The scanning, billing, and diagram code is upstream's; the
+Pump push is the fork's addition.

pump_aws_radar-0.1.0/README.md

@@ -0,0 +1,62 @@
+# pump-aws-radar
+
+A fork of [aws-radar](https://github.com/gomorsmi/aws-radar) that adds a one-command **push** of
+your AWS inventory and billing CSVs to Pump's self-serve onboarding endpoint — no standing
+cross-account role required.
+
+Everything upstream (`inventory`, `billing`, `diagram`, `run`) works unchanged. The only addition is
+`run --upload-token`.
+
+## Install
+
+```bash
+pip install pump-aws-radar
+```
+
+The console script is `pump-aws-radar`, so it installs alongside upstream `aws-radar` without
+colliding.
+
+## Pump onboarding
+
+1. In the Pump app, mint an upload token (this calls `POST /api/v1/estimate/radar/mint`). Pump shows
+   you a ready-to-paste command.
+2. Run it against the AWS account you want to onboard:
+
+   ```bash
+   pump-aws-radar run --all-regions --tags --billing --upload-token <TOKEN>
+   ```
+
+   This inventories the account read-only, pulls Cost Explorer billing, and uploads both
+   `inventory.csv` and `billing.csv` straight to Pump. No diagram is generated on this path.
+3. Pump detects both files, runs its analysis, and surfaces the findings in the app.
+
+### What leaves your machine
+
+Only the two CSVs. The token carries no AWS credentials and no company id — Pump binds the company
+and derives the S3 key server-side, so a token can only ever write its own upload's prefix. Each file
+goes to S3 through a short-lived presigned `PUT` URL that Pump mints on demand.
+
+### Pointing at a non-prod backend
+
+The token exchange defaults to `https://api.pump.co`. Override it for local testing:
+
+```bash
+pump-aws-radar run --billing --upload-token <TOKEN> --api-base http://localhost:8001
+# or
+PUMP_API_BASE=http://localhost:8001 pump-aws-radar run --billing --upload-token <TOKEN>
+```
+
+## How the push works
+
+`pump_aws_radar/upload.py`:
+
+1. For each role (`inventory`, `billing`), `POST {api_base}/api/v1/estimate/radar/urls` with
+   `{"token", "role"}` and receives a presigned S3 `PUT` URL.
+2. `PUT`s the corresponding CSV with `Content-Type: text/csv` (the presigned URL signs the
+   content-type, so it must match).
+
+## Relationship to upstream
+
+This is a derivative work of [aws-radar](https://github.com/gomorsmi/aws-radar), MIT-licensed, with
+upstream copyright preserved in `LICENSE`. The scanning, billing, and diagram code is upstream's; the
+Pump push is the fork's addition.

pump_aws_radar-0.1.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pump-aws-radar"
+version = "0.1.0"
+description = "Fork of aws-radar that pushes AWS inventory + billing CSVs to Pump's self-serve onboarding"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+  { name = "Pump" },
+]
+maintainers = [
+  { name = "Pump" },
+]
+keywords = ["aws", "cloud", "inventory", "cost-explorer", "billing", "finops", "pump", "onboarding"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Intended Audience :: System Administrators",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: System :: Systems Administration",
+  "Topic :: Utilities",
+]
+dependencies = [
+  "boto3>=1.34.0",
+  "rich>=13.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=7.0",
+  "build",
+  "twine",
+]
+
+[project.urls]
+Homepage   = "https://github.com/meku-pump/pump-aws-radar"
+Repository = "https://github.com/meku-pump/pump-aws-radar"
+Upstream   = "https://github.com/gomorsmi/aws-radar"
+
+[project.scripts]
+pump-aws-radar = "pump_aws_radar.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts   = "-v --tb=short"

pump_aws_radar-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pump_aws_radar-0.1.0/src/pump_aws_radar/__init__.py

@@ -0,0 +1,14 @@
+"""
+pump-aws-radar — a fork of aws-radar (gomorsmi/aws-radar) that adds a one-command
+push of the inventory + billing CSVs to Pump's self-serve onboarding endpoint.
+
+Upstream scans an AWS account read-only and writes a CSV inventory, a Cost Explorer
+billing CSV, and a draw.io diagram. This fork adds `run --upload-token`, which sends
+the two CSVs to Pump instead of drawing a diagram (see pump_aws_radar.upload).
+
+Quick start (Pump onboarding):
+    pump-aws-radar run --all-regions --tags --billing --upload-token <TOKEN>
+"""
+
+__version__ = "0.1.0"
+__author__ = "Pump (fork of aws-radar by Mor Michaeli)"

pump_aws_radar-0.1.0/src/pump_aws_radar/__main__.py

@@ -0,0 +1,201 @@
+"""
+Entry point for:
+    python -m pump_aws_radar
+    pump-aws-radar      (after pip install)
+
+This is a fork of gomorsmi/aws-radar. The only functional addition is the
+`run --upload-token` path, which pushes the inventory and billing CSVs to Pump's
+self-serve onboarding endpoint (see pump_aws_radar.upload).
+"""
+
+import argparse
+import os
+import sys
+
+# Mirrors pump_aws_radar.billing.METRICS. Duplicated here so `--help` works without
+# boto3 installed — importing billing pulls in boto3 at module scope.
+# tests/test_pump_aws_radar.py keeps the two lists in sync.
+METRICS = [
+    "UnblendedCost", "AmortizedCost", "BlendedCost",
+    "NetUnblendedCost", "NetAmortizedCost", "UsageQuantity",
+]
+
+# Where the Pump backend lives. Overridable for local testing via --api-base or
+# the PUMP_API_BASE env var (e.g. http://localhost:8001).
+DEFAULT_API_BASE = os.environ.get("PUMP_API_BASE", "https://api.pump.co")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="pump-aws-radar",
+        description="AWS resource inventory & draw.io architecture diagram generator",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # ── inventory sub-command ──
+    inv = sub.add_parser("inventory", help="Scan AWS account and list all resources")
+    inv.add_argument("--region",      default=None,  help="AWS region (default: boto3 default)")
+    inv.add_argument("--profile",     default=None,  help="AWS SSO/named profile")
+    inv.add_argument("--role-arn",    default=None,  help="IAM role ARN to assume")
+    inv.add_argument("--all-regions", action="store_true", help="Scan all enabled regions")
+    inv.add_argument("--ai", action=argparse.BooleanOptionalAction, default=True,
+                     help="Scan AI/ML services (Bedrock, SageMaker, Rekognition, Lex, Kendra, …). On by default; pass --no-ai to skip them")
+    inv.add_argument("--tags",        action="store_true", help="Fetch resource tags and add a 'Tags' column")
+    inv.add_argument("--tags-wide",   action="store_true", help="Also write a CSV with one column per tag key (implies --tags)")
+    inv.add_argument("--cost-allocation-tags", action="store_true", help="Add a 'CostAllocTags' column with billing-activated tags (implies --tags)")
+    inv.add_argument("--include-aws-tags", action="store_true", help="Include aws:-prefixed system tags (excluded by default)")
+    inv.add_argument("--billing",     action="store_true", help="Also pull Cost Explorer daily cost by service and write a CSV")
+    inv.add_argument("--billing-days", type=int, default=None, help="Billing window in days (default: 90)")
+    inv.add_argument("--billing-metric", default=None, choices=METRICS, help="Cost Explorer metric (default: UnblendedCost)")
+    inv.add_argument("--billing-output", metavar="FILE.csv", default=None, help="Billing CSV path (default: billing.csv)")
+    inv.add_argument("--include-zero", action="store_true", help="Keep zero-cost service/day buckets in the billing CSV")
+    inv.add_argument("--export",      metavar="FILE.csv", help="Export results to CSV")
+
+    # ── billing sub-command ──
+    bil = sub.add_parser("billing", help="Pull Cost Explorer daily cost by service to CSV")
+    bil.add_argument("--profile", default=None, help="AWS SSO/named profile")
+    bil.add_argument("--days",    type=int, default=90, help="Trailing window in days (default: 90)")
+    bil.add_argument("--metric",  default="UnblendedCost", choices=METRICS, help="Cost Explorer metric (default: UnblendedCost)")
+    bil.add_argument("--include-zero", action="store_true", help="Keep service/day buckets with zero cost")
+    bil.add_argument("--output",  metavar="FILE.csv", default="billing.csv", help="CSV output path (default: billing.csv)")
+
+    # ── diagram sub-command ──
+    dia = sub.add_parser("diagram", help="Generate draw.io diagram from inventory CSV")
+    dia.add_argument("--input",  required=True,          help="CSV produced by 'inventory'")
+    dia.add_argument("--output", default="architecture.drawio", help="Output .drawio file")
+
+    # ── all-in-one sub-command ──
+    run = sub.add_parser("run", help="Inventory + diagram in one shot (or push CSVs to Pump)")
+    run.add_argument("--region",      default=None)
+    run.add_argument("--profile",     default=None)
+    run.add_argument("--role-arn",    default=None)
+    run.add_argument("--all-regions", action="store_true")
+    run.add_argument("--ai", action=argparse.BooleanOptionalAction, default=True,
+                     help="Scan AI/ML services (on by default; --no-ai to skip)")
+    run.add_argument("--tags",   action="store_true", help="Fetch resource tags and add a 'Tags' column")
+    run.add_argument("--tags-wide", action="store_true", help="Also write a CSV with one column per tag key (implies --tags)")
+    run.add_argument("--cost-allocation-tags", action="store_true", help="Add a 'CostAllocTags' column with billing-activated tags (implies --tags)")
+    run.add_argument("--include-aws-tags", action="store_true", help="Include aws:-prefixed system tags (excluded by default)")
+    run.add_argument("--billing", action="store_true", help="Also pull Cost Explorer daily cost by service and write a CSV")
+    run.add_argument("--billing-days", type=int, default=None, help="Billing window in days (default: 90)")
+    run.add_argument("--billing-metric", default=None, choices=METRICS, help="Cost Explorer metric (default: UnblendedCost)")
+    run.add_argument("--billing-output", metavar="FILE.csv", default=None, help="Billing CSV path (default: billing.csv)")
+    run.add_argument("--include-zero", action="store_true", help="Keep zero-cost service/day buckets in the billing CSV")
+    run.add_argument("--csv",    default="inventory.csv",      help="Intermediate CSV path")
+    run.add_argument("--output", default="architecture.drawio", help="Output .drawio file")
+    # ── Pump onboarding push (fork addition) ──
+    run.add_argument("--upload-token", default=None,
+                     help="Pump upload token: push the inventory + billing CSVs to Pump instead of drawing a diagram")
+    run.add_argument("--api-base", default=DEFAULT_API_BASE,
+                     help=f"Pump API base for --upload-token (default: {DEFAULT_API_BASE}; or set PUMP_API_BASE)")
+
+    args = parser.parse_args()
+
+    if args.command == "inventory":
+        from pump_aws_radar.inventory import main as inv_main
+        sys.argv = _rebuild_argv("inventory", args)
+        inv_main()
+
+    elif args.command == "billing":
+        from pump_aws_radar.billing import main as bil_main
+        sys.argv = _rebuild_argv("billing", args)
+        bil_main()
+
+    elif args.command == "diagram":
+        from pump_aws_radar.drawio import main as dia_main
+        sys.argv = _rebuild_argv("diagram", args)
+        dia_main()
+
+    elif args.command == "run":
+        _run(args)
+
+
+def _run(args):
+    from pump_aws_radar.inventory import main as inv_main
+
+    uploading = bool(args.upload_token)
+    # The Pump flow needs both CSVs: the backend only starts analysis once
+    # inventory.csv and billing.csv are both present.
+    if uploading and not args.billing:
+        sys.exit(
+            "Error: --upload-token requires --billing so both CSVs are produced.\n"
+            "Run: pump-aws-radar run --all-regions --tags --billing --upload-token <TOKEN>"
+        )
+
+    total = 2 if uploading else 2
+    # Step 1 — inventory (and billing, when --billing is set)
+    print(f"── Step 1/{total}: Running inventory ──")
+    inv_args = ["pump-aws-radar"]
+    if args.profile:     inv_args += ["--profile", args.profile]
+    if args.role_arn:    inv_args += ["--role-arn", args.role_arn]
+    if args.region:      inv_args += ["--region", args.region]
+    if args.all_regions: inv_args += ["--all-regions"]
+    # Ternary, not `if args.ai:` — a bare if would emit nothing for --no-ai
+    # and let inventory.py's own default (True) decide instead.
+    inv_args += ["--ai"] if args.ai else ["--no-ai"]
+    if args.tags:                 inv_args += ["--tags"]
+    if args.tags_wide:            inv_args += ["--tags-wide"]
+    if args.cost_allocation_tags: inv_args += ["--cost-allocation-tags"]
+    if args.include_aws_tags:     inv_args += ["--include-aws-tags"]
+    if args.billing:              inv_args += ["--billing"]
+    if args.billing_days is not None:   inv_args += ["--billing-days", str(args.billing_days)]
+    if args.billing_metric:             inv_args += ["--billing-metric", args.billing_metric]
+    if args.billing_output:             inv_args += ["--billing-output", args.billing_output]
+    if args.include_zero:               inv_args += ["--include-zero"]
+    inv_args += ["--export", args.csv]
+    sys.argv = inv_args
+    inv_main()
+
+    if uploading:
+        # Step 2 — push both CSVs to Pump
+        from pump_aws_radar.upload import UploadError, upload_csvs
+
+        billing_csv = args.billing_output or "billing.csv"
+        print(f"\n── Step 2/{total}: Uploading to Pump ({args.api_base}) ──")
+        try:
+            upload_csvs(
+                api_base=args.api_base,
+                token=args.upload_token,
+                files={"inventory": args.csv, "billing": billing_csv},
+            )
+        except UploadError as e:
+            sys.exit(f"\nUpload failed: {e}")
+        print("\n✓ Done! Your inventory and billing data are on their way to Pump.")
+        return
+
+    # Step 2 — diagram (default, non-upload path)
+    from pump_aws_radar.drawio import main as dia_main
+
+    print(f"\n── Step 2/{total}: Generating diagram ──")
+    sys.argv = ["pump-aws-radar", "--input", args.csv, "--output", args.output]
+    dia_main()
+    print(f"\n✓ Done! Open {args.output} at https://app.diagrams.net/")
+
+
+# Dests whose False value is meaningful and so must be forwarded explicitly.
+# inventory.py re-parses this argv with its own parser and its own defaults, so
+# a flag omitted here is decided by that parser, not by the user. That is only
+# correct for plain store_true flags, which default to False on both sides.
+NEGATABLE = {"inventory": {"ai"}, "run": {"ai"}}
+
+
+def _rebuild_argv(cmd, args):
+    argv = ["pump-aws-radar"]
+    negatable = NEGATABLE.get(cmd, frozenset())
+    d = vars(args)
+    for k, v in d.items():
+        if k == "command":
+            continue
+        flag = "--" + k.replace("_", "-")
+        if isinstance(v, bool):
+            if v:
+                argv.append(flag)
+            elif k in negatable:
+                argv.append("--no-" + k.replace("_", "-"))
+        elif v is not None:
+            argv += [flag, str(v)]
+    return argv
+
+
+if __name__ == "__main__":
+    main()