finops-scan 0.1.0__py3-none-any.whl

finops_scan/analyzer.py

@@ -0,0 +1,217 @@
+"""
+Analyzer — derives waste insights from Cost Explorer data.
+No AWS API calls here — pure computation on DailySpend records.
+Separated from fetcher so it can be unit tested without AWS credentials.
+"""
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import List, Dict
+from src.finops_scan.fetcher import DailySpend
+
+
+@dataclass
+class ServiceSummary:
+    service:       str
+    total_30d:     Decimal
+    daily_average: Decimal
+    trend:         str    # "increasing" | "decreasing" | "stable"
+
+
+@dataclass
+class WasteOpportunity:
+    rank:         int
+    service:      str
+    finding:      str
+    monthly_cost: Decimal
+    action:       str
+
+
+class CostAnalyzer:
+    """
+    Derives ranked waste opportunities from DailySpend records.
+
+    All methods are pure functions — same input always produces
+    same output. No side effects, no API calls.
+    Easy to unit test without AWS credentials.
+    """
+
+    # Services that typically indicate waste when spend is high
+    # relative to their utility
+    IDLE_SIGNALS = {
+        "Amazon Elastic Compute Cloud - Compute": "EC2 instances",
+        "Amazon Relational Database Service":     "RDS instances",
+        "Amazon ElastiCache":                     "ElastiCache clusters",
+        "Amazon Redshift":                        "Redshift clusters",
+        "AWS Lambda":                              "Lambda functions",
+    }
+
+    AI_SERVICES = {
+        "Amazon Bedrock",
+        "Amazon SageMaker",
+    }
+
+    def summarize_by_service(
+            self,
+            records: List[DailySpend],
+    ) -> List[ServiceSummary]:
+        """
+        Aggregates DailySpend records into per-service summaries.
+        Sorted by total_30d descending — highest spend first.
+        """
+        totals:  Dict[str, Decimal] = {}
+        counts:  Dict[str, int]     = {}
+        first7:  Dict[str, Decimal] = {}
+        last7:   Dict[str, Decimal] = {}
+
+        sorted_records = sorted(records, key=lambda r: r.date)
+        all_dates = sorted(set(r.date for r in sorted_records))
+        first_7_dates = set(all_dates[:7])
+        last_7_dates  = set(all_dates[-7:])
+
+        for r in records:
+            totals[r.service]  = totals.get(r.service, Decimal("0")) + r.amount
+            counts[r.service]  = counts.get(r.service, 0) + 1
+            if r.date in first_7_dates:
+                first7[r.service] = first7.get(r.service,
+                                               Decimal("0")) + r.amount
+            if r.date in last_7_dates:
+                last7[r.service]  = last7.get(r.service,
+                                              Decimal("0")) + r.amount
+
+        summaries = []
+        for service, total in totals.items():
+            count = counts[service]
+            daily_avg = total / count if count > 0 else Decimal("0")
+            f = first7.get(service, Decimal("0"))
+            l = last7.get(service, Decimal("0"))
+            if l > f * Decimal("1.10"):
+                trend = "increasing"
+            elif l < f * Decimal("0.90"):
+                trend = "decreasing"
+            else:
+                trend = "stable"
+
+            summaries.append(ServiceSummary(
+                service=service,
+                total_30d=total,
+                daily_average=daily_avg,
+                trend=trend,
+            ))
+
+        return sorted(summaries, key=lambda s: s.total_30d, reverse=True)
+
+    def identify_waste(
+            self,
+            summaries: List[ServiceSummary],
+            tag_coverage: dict,
+    ) -> List[WasteOpportunity]:
+        """
+        Produces ranked waste opportunities from service summaries.
+        Each opportunity has a specific finding and action.
+        """
+        opportunities: List[WasteOpportunity] = []
+        rank = 1
+
+        # Opportunity 1: increasing spend on compute services
+        for s in summaries:
+            if s.trend == "increasing" and s.service in self.IDLE_SIGNALS:
+                name = self.IDLE_SIGNALS[s.service]
+                opportunities.append(WasteOpportunity(
+                    rank=rank,
+                    service=s.service,
+                    finding=(
+                        f"{name} spend increased 10%+ over the last 7 days. "
+                        f"30-day total: ${s.total_30d:,.2f}"
+                    ),
+                    monthly_cost=s.total_30d,
+                    action=(
+                        f"Review {name} utilization. "
+                        f"Rightsizing or stopping idle instances "
+                        f"could reduce this cost by 20-40%."
+                    ),
+                ))
+                rank += 1
+
+        # Opportunity 2: high spend on data transfer
+        for s in summaries:
+            if "Data Transfer" in s.service and s.total_30d > Decimal("100"):
+                opportunities.append(WasteOpportunity(
+                    rank=rank,
+                    service=s.service,
+                    finding=(
+                        f"Data transfer cost ${s.total_30d:,.2f} in 30 days. "
+                        f"Often caused by cross-AZ traffic or "
+                        f"unoptimized S3 access patterns."
+                    ),
+                    monthly_cost=s.total_30d,
+                    action=(
+                        "Move resources to the same AZ. "
+                        "Use S3 VPC endpoints to eliminate "
+                        "data transfer charges."
+                    ),
+                ))
+                rank += 1
+
+        # Opportunity 3: low tag coverage
+        if tag_coverage.get("untagged_pct", 100) > 20:
+            untagged = tag_coverage.get("untagged_spend", Decimal("0"))
+            opportunities.append(WasteOpportunity(
+                rank=rank,
+                service="All services",
+                finding=(
+                    f"{tag_coverage['untagged_pct']}% of spend "
+                    f"(${untagged:,.2f}) has no team tag. "
+                    f"You cannot allocate what you cannot attribute."
+                ),
+                monthly_cost=untagged,
+                action=(
+                    "Apply team tags to all resources. "
+                    "fynC can automate tag suggestions "
+                    "based on resource naming patterns."
+                ),
+            ))
+            rank += 1
+
+        # Opportunity 4: AI services with no visibility
+        ai_spend = sum(
+            s.total_30d for s in summaries
+            if any(ai in s.service for ai in self.AI_SERVICES)
+        )
+        if ai_spend > Decimal("0"):
+            opportunities.append(WasteOpportunity(
+                rank=rank,
+                service="AI Services",
+                finding=(
+                    f"${ai_spend:,.2f} spent on AI services in 30 days "
+                    f"with no model-level breakdown. "
+                    f"You cannot optimize what you cannot see."
+                ),
+                monthly_cost=ai_spend,
+                action=(
+                    "Track AI spend at the model level with fynC. "
+                    "See which team is driving cost and "
+                    "which model gives the best cost/quality ratio."
+                ),
+            ))
+            rank += 1
+
+        return opportunities[:10]  # top 10 only
+
+    def total_spend(self, records: List[DailySpend]) -> Decimal:
+        """Total spend across all services for the period."""
+        return sum((r.amount for r in records), Decimal("0"))
+
+    def estimated_savings(
+            self,
+            opportunities: List[WasteOpportunity],
+    ) -> Decimal:
+        """
+        Conservative savings estimate: 20% of waste opportunity costs.
+        Real savings depend on which actions are taken.
+        """
+        total = sum(
+            (o.monthly_cost for o in opportunities
+             if o.service != "All services"),
+            Decimal("0"),
+        )
+        return total * Decimal("0.20")

finops_scan/cli.py

@@ -0,0 +1,118 @@
+"""
+CLI entry point for finops-scan.
+Uses Click for argument parsing and command structure.
+Orchestrates: fetcher → analyzer → reporter.
+"""
+import sys
+from decimal import Decimal
+
+import click
+from rich.console import Console
+
+console = Console()
+
+
+@click.command()
+@click.option(
+    "--access-key",
+    envvar="AWS_ACCESS_KEY_ID",
+    required=True,
+    help="AWS Access Key ID (or set AWS_ACCESS_KEY_ID env var)",
+)
+@click.option(
+    "--secret-key",
+    envvar="AWS_SECRET_ACCESS_KEY",
+    required=True,
+    help="AWS Secret Access Key (or set AWS_SECRET_ACCESS_KEY env var)",
+)
+@click.option(
+    "--region",
+    default="us-east-1",
+    show_default=True,
+    help="AWS region",
+)
+@click.option(
+    "--account-id",
+    default="my-account",
+    help="AWS account ID or alias (display only)",
+)
+def main(
+        access_key: str,
+        secret_key:  str,
+        region:      str,
+        account_id:  str,
+) -> None:
+    """
+    finops-scan — scan your AWS account for cloud waste in 60 seconds.
+
+    Reads cost data via AWS Cost Explorer API (read-only).
+    No data is stored. No resources are modified.
+
+    Required IAM permission: ce:GetCostAndUsage
+
+    Example:
+
+        finops-scan --access-key AKIA... --secret-key ... --region us-east-1
+
+    Or use environment variables:
+
+        export AWS_ACCESS_KEY_ID=AKIA...
+
+        export AWS_SECRET_ACCESS_KEY=...
+
+        finops-scan
+    """
+    from src.finops_scan.fetcher   import CostExplorerFetcher
+    from src.finops_scan.analyzer  import CostAnalyzer
+    from src.finops_scan.reporter  import WasteReporter
+
+    reporter = WasteReporter()
+    reporter.print_header(account_id)
+
+    # Step 1 — Fetch
+    console.print("[dim]Fetching cost data from AWS Cost Explorer...[/dim]")
+    try:
+        fetcher = CostExplorerFetcher(
+            aws_access_key=access_key,
+            aws_secret_key=secret_key,
+            region=region,
+        )
+        records      = fetcher.fetch_last_30_days()
+        tag_coverage = fetcher.fetch_tag_coverage()
+
+    except Exception as e:
+        console.print(f"[red]✗ Failed to connect to AWS:[/red] {e}")
+        console.print(
+            "[dim]Check your credentials and ensure "
+            "ce:GetCostAndUsage permission is attached.[/dim]"
+        )
+        sys.exit(1)
+
+    if not records:
+        console.print(
+            "[yellow]No cost data found for the last 30 days.[/yellow]"
+        )
+        sys.exit(0)
+
+    console.print(
+        f"[dim]✓ Fetched {len(records)} cost records.[/dim]"
+    )
+
+    # Step 2 — Analyze
+    console.print("[dim]Analyzing waste patterns...[/dim]")
+    analyzer     = CostAnalyzer()
+    summaries    = analyzer.summarize_by_service(records)
+    opportunities = analyzer.identify_waste(summaries, tag_coverage)
+    total        = analyzer.total_spend(records)
+    savings      = analyzer.estimated_savings(opportunities)
+    console.print("[dim]✓ Analysis complete.[/dim]\n")
+
+    # Step 3 — Report
+    reporter.print_summary(total, savings, tag_coverage)
+    reporter.print_top_services(summaries)
+    reporter.print_waste_opportunities(opportunities)
+    reporter.print_cta()
+
+
+if __name__ == "__main__":
+    main()

finops_scan/fetcher.py

@@ -0,0 +1,142 @@
+"""
+AWS Cost Explorer fetcher.
+Pulls cost and usage data using the Cost Explorer API.
+Works on any AWS account — no CUR or S3 setup required.
+Just needs Access Key + Secret Key with ce:GetCostAndUsage permission.
+"""
+from dataclasses import dataclass
+from datetime import date, timedelta
+from decimal import Decimal
+from typing import List, Optional
+
+import boto3
+
+
+@dataclass
+class DailySpend:
+    date:     str
+    service:  str
+    amount:   Decimal
+    currency: str = "USD"
+
+
+@dataclass
+class ResourceWaste:
+    service:      str
+    resource_id:  str
+    monthly_cost: Decimal
+    reason:       str
+    savings:      Decimal
+
+
+class CostExplorerFetcher:
+    """
+    Fetches cost data from AWS Cost Explorer API.
+
+    Required IAM permissions:
+      ce:GetCostAndUsage
+      ce:GetCostAndUsageWithResources (optional — for resource-level)
+
+    These are read-only permissions. fynC and finops-scan
+    never write to or modify any AWS resources.
+    """
+
+    def __init__(
+            self,
+            aws_access_key: str,
+            aws_secret_key: str,
+            region:         str = "us-east-1",
+    ) -> None:
+        self._client = boto3.client(
+            "ce",
+            aws_access_key_id=aws_access_key,
+            aws_secret_access_key=aws_secret_key,
+            region_name=region,
+        )
+
+    def fetch_last_30_days(self) -> List[DailySpend]:
+        """
+        Fetches daily spend by service for the last 30 days.
+        Returns a flat list of DailySpend records.
+        """
+        end   = date.today()
+        start = end - timedelta(days=30)
+
+        response = self._client.get_cost_and_usage(
+            TimePeriod={
+                "Start": start.isoformat(),
+                "End":   end.isoformat(),
+            },
+            Granularity="DAILY",
+            Metrics=["BlendedCost"],
+            GroupBy=[{"Type": "DIMENSION", "Key": "SERVICE"}],
+        )
+
+        records: List[DailySpend] = []
+
+        for result in response.get("ResultsByTime", []):
+            period = result["TimePeriod"]["Start"]
+            for group in result.get("Groups", []):
+                service = group["Keys"][0]
+                amount  = Decimal(
+                    group["Metrics"]["BlendedCost"]["Amount"]
+                )
+                if amount > Decimal("0.001"):  # skip negligible costs
+                    records.append(DailySpend(
+                        date=period,
+                        service=service,
+                        amount=amount,
+                    ))
+
+        return records
+
+    def fetch_tag_coverage(self) -> dict:
+        """
+        Fetches tag coverage — what fraction of spend has team tags.
+        Returns dict with tagged_pct, untagged_pct, untagged_spend.
+        """
+        end   = date.today()
+        start = end - timedelta(days=30)
+
+        tagged = self._client.get_cost_and_usage(
+            TimePeriod={"Start": start.isoformat(), "End": end.isoformat()},
+            Granularity="MONTHLY",
+            Metrics=["BlendedCost"],
+            Filter={
+                "Tags": {
+                    "Key":    "team",
+                    "Values": ["*"],
+                    "MatchOptions": ["EXISTS"],
+                }
+            },
+        )
+
+        total = self._client.get_cost_and_usage(
+            TimePeriod={"Start": start.isoformat(), "End": end.isoformat()},
+            Granularity="MONTHLY",
+            Metrics=["BlendedCost"],
+        )
+
+        def extract(resp) -> Decimal:
+            results = resp.get("ResultsByTime", [])
+            if not results:
+                return Decimal("0")
+            return Decimal(
+                results[0]["Total"]["BlendedCost"]["Amount"]
+            )
+
+        tagged_spend = extract(tagged)
+        total_spend  = extract(total)
+
+        if total_spend == Decimal("0"):
+            return {"tagged_pct": 0.0, "untagged_pct": 100.0,
+                    "untagged_spend": Decimal("0")}
+
+        tagged_pct   = float(tagged_spend / total_spend * 100)
+        untagged_pct = 100.0 - tagged_pct
+
+        return {
+            "tagged_pct":     round(tagged_pct, 1),
+            "untagged_pct":   round(untagged_pct, 1),
+            "untagged_spend": total_spend - tagged_spend,
+        }

finops_scan/reporter.py

@@ -0,0 +1,162 @@
+"""
+Reporter — formats and prints the waste report to the terminal.
+Uses Rich for colored, structured output.
+Separated from analyzer: formatting concerns are independent
+of business logic. Easy to add JSON or CSV output later.
+"""
+from decimal import Decimal
+from typing import List
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich import box
+
+from src.finops_scan.analyzer import ServiceSummary, WasteOpportunity
+
+console = Console()
+
+
+class WasteReporter:
+    """
+    Prints the finops-scan waste report to the terminal.
+    All output goes through Rich for consistent formatting.
+    """
+
+    TREND_ICONS = {
+        "increasing": "[red]↑[/red]",
+        "decreasing": "[green]↓[/green]",
+        "stable":     "[yellow]→[/yellow]",
+    }
+
+    def print_header(self, account_id: str) -> None:
+        """Prints the fynC branded header."""
+        console.print()
+        console.print(Panel(
+            Text.from_markup(
+                "[bold #E8460A]finops-scan[/bold #E8460A]  "
+                "[dim]by fynC[/dim]\n"
+                "[dim]Cloud waste scanner · "
+                "Read-only · No data stored[/dim]"
+            ),
+            border_style="#E8460A",
+            padding=(0, 2),
+        ))
+        console.print(
+            f"[dim]Account:[/dim] [bold]{account_id}[/bold]  "
+            f"[dim]Period:[/dim] [bold]Last 30 days[/bold]"
+        )
+        console.print()
+
+    def print_summary(
+            self,
+            total_spend:       Decimal,
+            estimated_savings: Decimal,
+            tag_coverage:      dict,
+    ) -> None:
+        """Prints the 3-number KPI summary at the top."""
+        table = Table(box=box.SIMPLE, show_header=False, padding=(0, 3))
+        table.add_column(style="dim")
+        table.add_column(style="bold")
+
+        table.add_row(
+            "Total 30-day spend",
+            f"[bold white]${total_spend:,.2f}[/bold white]",
+        )
+        table.add_row(
+            "Estimated savings available",
+            f"[bold green]${estimated_savings:,.2f}[/bold green]",
+        )
+        table.add_row(
+            "Tag coverage",
+            f"[bold {'green' if tag_coverage['tagged_pct'] >= 80 else 'red'}]"
+            f"{tag_coverage['tagged_pct']}%[/bold]",
+        )
+
+        console.print(Panel(table, title="[bold]Summary[/bold]",
+                            border_style="dim"))
+
+    def print_top_services(
+            self,
+            summaries: List[ServiceSummary],
+            top_n: int = 8,
+    ) -> None:
+        """Prints the top N services by spend."""
+        table = Table(
+            title="Top Services by Spend",
+            box=box.SIMPLE_HEAD,
+            show_lines=False,
+            title_style="bold",
+        )
+        table.add_column("#",        style="dim",   width=3)
+        table.add_column("Service",  style="white", min_width=35)
+        table.add_column("30-day",   style="bold",  justify="right")
+        table.add_column("Daily avg",               justify="right")
+        table.add_column("Trend",                   justify="center")
+
+        for i, s in enumerate(summaries[:top_n], 1):
+            # Shorten long AWS service names
+            name = s.service.replace(
+                "Amazon Elastic Compute Cloud - Compute", "EC2 Compute"
+            ).replace(
+                "Amazon Relational Database Service", "RDS"
+            ).replace(
+                "Amazon Simple Storage Service", "S3"
+            )
+            table.add_row(
+                str(i),
+                name,
+                f"${s.total_30d:,.2f}",
+                f"${s.daily_average:,.2f}",
+                self.TREND_ICONS.get(s.trend, "→"),
+            )
+
+        console.print(table)
+
+    def print_waste_opportunities(
+            self,
+            opportunities: List[WasteOpportunity],
+    ) -> None:
+        """Prints ranked waste opportunities with actions."""
+        console.print()
+        console.print("[bold]Waste Opportunities[/bold]")
+        console.print("[dim]Ranked by estimated impact[/dim]")
+        console.print()
+
+        if not opportunities:
+            console.print(
+                "[green]✓ No significant waste detected.[/green] "
+                "Your account looks well optimized."
+            )
+            return
+
+        for opp in opportunities:
+            console.print(
+                f"[bold #E8460A]#{opp.rank}[/bold #E8460A]  "
+                f"[bold]{opp.service}[/bold]"
+            )
+            console.print(
+                f"   [dim]Finding:[/dim]  {opp.finding}"
+            )
+            console.print(
+                f"   [dim]Action:[/dim]   [green]{opp.action}[/green]"
+            )
+            console.print()
+
+    def print_cta(self) -> None:
+        """Prints the call to action at the end."""
+        console.print(Panel(
+            Text.from_markup(
+                "[bold]Want this monitored automatically?[/bold]\n\n"
+                "fynC tracks your cloud and AI spend continuously,\n"
+                "alerts you when costs spike, and attributes every\n"
+                "dollar to a team — without any manual work.\n\n"
+                "[bold #E8460A]→ fync.io/early-access[/bold #E8460A]   "
+                "[dim](or reply to the Show HN post)[/dim]"
+            ),
+            border_style="#E8460A",
+            title="[bold #E8460A]fynC[/bold #E8460A]",
+            padding=(1, 3),
+        ))
+        console.print()

finops_scan-0.1.0.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: finops-scan
+Version: 0.1.0
+Summary: Scan your AWS account for cloud waste in 60 seconds
+Project-URL: Homepage, https://fync.io
+Project-URL: Repository, https://github.com/yourusername/finops-scan
+Project-URL: Bug Tracker, https://github.com/yourusername/finops-scan/issues
+License: MIT
+Keywords: aws,cloud,cost,finops,optimization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Requires-Dist: boto3>=1.35.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Description-Content-Type: text/markdown
+
+# finops-scan
+
+**Scan your AWS account for cloud waste in 60 seconds.**
+
+Free, open source, read-only. No data stored. No resources modified.
+
+```bash
+pip install finops-scan
+finops-scan --access-key AKIA... --secret-key ...
+```
+
+---
+
+## What it does
+
+finops-scan connects to your AWS Cost Explorer API (read-only) and produces a ranked waste report in your terminal:
+
+- **Top services by spend** — with 30-day trend (increasing/decreasing/stable)
+- **Waste opportunities** — ranked by estimated impact, with specific actions
+- **Tag coverage score** — what % of your spend has team attribution
+- **Estimated savings** — conservative 20% estimate of actionable waste
+
+## Example output
+╭─────────────────────────────────────────────╮
+│  finops-scan  by fynC                        │
+│  Cloud waste scanner · Read-only             │
+╰─────────────────────────────────────────────╯
+Account: my-aws-account   Period: Last 30 days
+Total 30-day spend        $18,420.55
+Estimated savings          $3,684.11
+Tag coverage                    42%
+Top Services by Spend
+Service          30-day      Daily avg   Trend
+1  EC2 Compute    $9,240.00      $308.00      ↑
+2  RDS            $4,100.00      $136.67      →
+3  S3             $1,820.00       $60.67      ↓
+Waste Opportunities
+#1  EC2 Compute
+Finding:  EC2 Compute spend increased 10%+ over the last 7 days.
+30-day total: $9,240.00
+Action:   Review EC2 utilization. Rightsizing or stopping idle
+instances could reduce this cost by 20-40%.
+#2  All services
+Finding:  58% of spend ($10,683.92) has no team tag.
+You cannot allocate what you cannot attribute.
+Action:   Apply team tags to all resources.
+╭─────────────────────────────────────────────╮
+│  Want this monitored automatically?          │
+│                                              │
+│  fynC tracks your cloud and AI spend         │
+│  continuously, alerts you when costs spike,  │
+│  and attributes every dollar to a team.      │
+│                                              │
+│  → fync.io/early-access                      │
+╰─────────────────────────────────────────────╯
+
+## Required IAM permission
+
+finops-scan only needs one permission:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": [
+        "ce:GetCostAndUsage"
+      ],
+      "Resource": "*"
+    }
+  ]
+}
+```
+
+Create a read-only IAM user with this policy and pass the credentials to finops-scan.
+
+## Installation
+
+```bash
+pip install finops-scan
+```
+
+## Usage
+
+```bash
+# Using flags
+finops-scan \
+  --access-key YOUR_ACCESS_KEY \
+  --secret-key YOUR_SECRET_KEY \
+  --region us-east-1 \
+  --account-id my-company
+
+# Using environment variables (recommended)
+export AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY
+export AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY
+finops-scan
+```
+
+## What it does NOT do
+
+- Does not store any data
+- Does not modify any AWS resources
+- Does not require CUR or S3 setup
+- Does not need root AWS credentials
+- Does not send data anywhere except your terminal
+
+## Built by fynC
+
+finops-scan is the free CLI companion to
+[fynC](https://fync.io) — a FinOps platform for cloud
+and AI spend visibility.
+
+fynC monitors your spend continuously, alerts you on anomalies,
+attributes costs to teams automatically, and tracks AI/LLM spend
+at the model level alongside cloud infrastructure costs.
+
+[Join the early access list →](https://fync.io/early-access)
+
+## License
+
+MIT

finops_scan-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+finops_scan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+finops_scan/analyzer.py,sha256=_QuPtDOfIRp7H4qPAUzlDYBdhhioW3szWavXR-FPL1g,8127
+finops_scan/cli.py,sha256=3BkI17MBg9mWO78H-wCVO_CWkRKxSgj31sLMRKE3IBc,3300
+finops_scan/fetcher.py,sha256=hMvA5jf96VA5zS9aBGpzj5SlEKr3tzJGzSdUNDmZrxo,4371
+finops_scan/reporter.py,sha256=orY4NiM9TXIqPzg7WEQJgmkd6reI_yo_8ZFebHSGU8I,5647
+finops_scan-0.1.0.dist-info/METADATA,sha256=D1U0cUyLjodM0TpEDLfQvHDtgDhsV9kAyYxb0-6EaeI,4737
+finops_scan-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+finops_scan-0.1.0.dist-info/entry_points.txt,sha256=UXcJDrrUbxpR0Sj0O2BvQ785_CxkLx48mPCUSpx5bBs,53
+finops_scan-0.1.0.dist-info/RECORD,,

finops_scan-0.1.0.dist-info/WHEEL

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

finops_scan-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+finops-scan = finops_scan.cli:main