better-aws-tags 0.2.0__tar.gz → 0.3.1__tar.gz

better_aws_tags-0.3.1/.github/workflows/release.yml

@@ -0,0 +1,23 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{better_aws_tags-0.2.0 → better_aws_tags-0.3.1}/Makefile

@@ -10,7 +10,7 @@ dev: ## Run in development mode
 
 .PHONY: run
 run: ## Run debug script
-	uv run python debug_bats.py
+	uv run python -i debug_bats.py
 
 .PHONY: test
 test: ## Run tests on all Python versions

better_aws_tags-0.3.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: better-aws-tags
+Version: 0.3.1
+Summary: A unified Python interface for managing AWS resource tags
+Author-email: Andrey Gubarev <andrey@andreygubarev.com>
+Requires-Python: >=3.10
+Requires-Dist: boto3~=1.0
+Description-Content-Type: text/markdown
+
+# better-aws-tags
+
+A unified Python interface for managing AWS resource tags.
+
+AWS provides multiple tagging APIs across services, including the Resource Groups Tagging API and service-specific implementations such as EC2, S3, and IAM. This library abstracts these differences behind a single API that accepts any valid ARN and handles service routing, tag validation, and error reporting automatically.
+
+## Getting Started
+
+```python
+import better_aws_tags as bats
+```

better_aws_tags-0.3.1/README.md

@@ -0,0 +1,11 @@
+# better-aws-tags
+
+A unified Python interface for managing AWS resource tags.
+
+AWS provides multiple tagging APIs across services, including the Resource Groups Tagging API and service-specific implementations such as EC2, S3, and IAM. This library abstracts these differences behind a single API that accepts any valid ARN and handles service routing, tag validation, and error reporting automatically.
+
+## Getting Started
+
+```python
+import better_aws_tags as bats
+```

{better_aws_tags-0.2.0 → better_aws_tags-0.3.1}/src/better_aws_tags/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.0"
+__version__ = "0.3.1"
 
 from .tags import get_tags as get_tags
 from .tags import set_tags as set_tags

better_aws_tags-0.3.1/src/better_aws_tags/arnparse.py

@@ -0,0 +1,139 @@
+"""ARN parsing utilities."""
+
+import re
+from typing import NamedTuple
+
+REGEX_RESOURCE_TYPE = re.compile(r"^[a-zA-Z0-9-]+$")
+
+class ResourceNotFound(Exception):
+    def __init__(self, service, resource):
+        super().__init__(f"Cannot determine resource format for service {service}: {resource}")
+
+class ARN(NamedTuple):
+    partition: str
+    service: str
+    region: str
+    account: str
+    resource_type: str | None
+    resource_id: str
+    resource_name: str
+
+
+class Resource(NamedTuple):
+    resource_type: str | None
+    resource_id: str
+    resource_name: str
+
+
+def find_resource(service, resource):
+    separators = resource.count("/") + resource.count(":")
+    segments = [s for segment in resource.split("/") for s in segment.split(":")]
+    prefix = segments[0]
+    suffix = resource[len(prefix) + 1:]
+
+    if service == "apigateway":
+        if separators == 2:
+            return Resource(segments[1], segments[2], segments[2])
+        else:
+            raise ResourceNotFound(service, resource)
+    elif service == "autoscaling":
+        if segments[0] == "autoScalingGroup" and segments[2] == "autoScalingGroupName":
+            return Resource(segments[0], segments[1], segments[3])
+        else:
+            raise ResourceNotFound(service, resource)
+    elif service == "cloudformation":
+        if separators == 2:
+            return Resource(segments[0], segments[2], segments[1])
+        else:
+            raise ResourceNotFound(service, resource)
+    elif service == "cloudwatch":
+        if prefix == "alarm":
+            return Resource(prefix, suffix, suffix)
+        else:
+            raise ResourceNotFound(service, resource)
+    elif service == "elasticloadbalancing":
+        if prefix == "loadbalancer":
+            if separators == 3:
+                return Resource(f"{segments[0]}/{segments[1]}", segments[3], segments[2])
+            elif separators == 1:
+                return Resource(segments[0], segments[1], segments[1])
+            else:
+                raise ResourceNotFound(service, resource)
+        elif prefix == "targetgroup":
+            if separators == 2:
+                return Resource(prefix, segments[2], segments[1])
+            else:
+                raise ResourceNotFound(service, resource)
+        else:
+            raise ResourceNotFound(service, resource)
+    elif service == "logs":
+        if prefix == "log-group":
+            return Resource(prefix, suffix, suffix)
+        else:
+            raise ResourceNotFound(service, resource)
+    elif service == "secretsmanager":
+        if prefix == "secret":
+            return Resource(prefix, suffix, suffix)
+        else:
+            raise ResourceNotFound(service, resource)
+    elif service == "ssm":
+        if prefix == "parameter":
+            return Resource(prefix, "/" + suffix, "/" + suffix)
+        else:
+            raise ResourceNotFound(service, resource)
+    elif service == "wafv2":
+        if prefix == "global":
+            return Resource(f"{segments[0]}/{segments[1]}", segments[2], segments[2])
+        elif prefix == "regional":
+            return Resource(f"{segments[0]}/{segments[1]}", segments[3], segments[2])
+        else:
+            raise ResourceNotFound(service, resource)
+    elif separators == 1:
+        return Resource(segments[0], segments[1], segments[1])
+    elif separators == 0:
+        return Resource(None, segments[0], segments[0])
+    else:
+        raise ResourceNotFound(service, resource)
+
+
+def arnparse(arn):
+    """Parse an ARN string into components."""
+    parts = arn.split(":", 5)
+    if len(parts) != 6:
+        raise ValueError(f"Invalid ARN format: {arn}")
+
+    if parts[0] != "arn":
+        raise ValueError(f"ARN must start with 'arn': {arn}")
+
+    _, partition, service, region, account, resource = parts
+
+    # Global services - no region, no account
+    if service in {"s3", "route53"}:
+        if region or account:
+            raise ValueError(f"Service {service} must have empty region and account: {arn}")
+
+    # Global services - no region, has account
+    if service in {"cloudfront", "iam"}:
+        if region:
+            raise ValueError(f"Service {service} must have empty region: {arn}")
+        if not account:
+            raise ValueError(f"Service {service} must have account: {arn}")
+
+    # Regional services - has region, no account
+    if service in {"apigateway"}:
+        if not region:
+            raise ValueError(f"Service {service} must have region: {arn}")
+        if account:
+            raise ValueError(f"Service {service} must have empty account: {arn}")
+
+    resource = find_resource(service, resource)
+
+    return ARN(
+        partition=partition,
+        service=service,
+        region=region,
+        account=account,
+        resource_type=resource.resource_type,
+        resource_id=resource.resource_id,
+        resource_name=resource.resource_name,
+    )

better_aws_tags-0.3.1/src/better_aws_tags/handlers.py

@@ -0,0 +1,134 @@
+from abc import ABC, abstractmethod
+
+import boto3
+
+from .arnparse import arnparse
+
+class Handler(ABC):
+    @classmethod
+    @abstractmethod
+    def get_tags(cls, session, arns):
+        pass
+
+    @classmethod
+    @abstractmethod
+    def set_tags(cls, session, arns, tags):
+        pass
+
+
+class IAMHandler(Handler):
+    """Handler for IAM resources using dedicated IAM tagging API."""
+
+    @classmethod
+    def get_tags(cls, session, arns):
+        if not arns:
+            raise ValueError("At least one ARN must be provided to get_tags.")
+
+        client = session.client("iam")
+        result = {}
+
+        for arn in arns:
+            arn_data = arnparse(arn)
+            resource_type = arn_data.resource_type
+            resource_name = arn_data.resource_name
+
+            if resource_type == "role":
+                response = client.list_role_tags(RoleName=resource_name)
+            elif resource_type == "user":
+                response = client.list_user_tags(UserName=resource_name)
+            elif resource_type == "policy":
+                response = client.list_policy_tags(PolicyArn=arn)
+            elif resource_type == "instance-profile":
+                response = client.list_instance_profile_tags(InstanceProfileName=resource_name)
+            else:
+                response = None
+
+            if response:
+                result[arn] = {t["Key"]: t["Value"] for t in response["Tags"]}
+            else:
+                result[arn] = None
+
+        return result
+
+    @classmethod
+    def set_tags(cls, session, arns, tags):
+        if not arns:
+            raise ValueError("At least one ARN must be provided to set_tags.")
+
+        client = session.client("iam")
+        result = {}
+        payload = [{"Key": k, "Value": v} for k, v in tags.items()]
+
+        for arn in arns:
+            arn_data = arnparse(arn)
+            resource_type = arn_data.resource_type
+            resource_name = arn_data.resource_name
+
+            try:
+                if resource_type == "role":
+                    response = client.tag_role(RoleName=resource_name, Tags=payload)
+                elif resource_type == "user":
+                    response = client.tag_user(UserName=resource_name, Tags=payload)
+                elif resource_type == "policy":
+                    response = client.tag_policy(PolicyArn=arn, Tags=payload)
+                elif resource_type == "instance-profile":
+                    response = client.tag_instance_profile(InstanceProfileName=resource_name, Tags=payload)
+                else:
+                    result[arn] = None
+                    continue
+            except client.exceptions.NoSuchEntityException:
+                result[arn] = None
+                continue
+
+            result[arn] = response["ResponseMetadata"]["HTTPStatusCode"] == 200
+
+        return result
+
+
+class TaggingAPIHandler(Handler):
+    @classmethod
+    def get_tags(cls, session, arns):
+        if not arns:
+            raise ValueError("At least one ARN must be provided to get_tags.")
+
+        client = session.client("resourcegroupstaggingapi")
+        result = {}
+
+        # https://docs.aws.amazon.com/resourcegroupstagging/latest/APIReference/API_GetResources.html
+        batch_size = 100
+        for i in range(0, len(arns), batch_size):
+            batch = arns[i : i + batch_size]
+            response = client.get_resources(ResourceARNList=batch)
+            response = response["ResourceTagMappingList"]
+            for arn in batch:
+                if arn in response:
+                    result[arn] = {
+                        t["Key"]: t["Value"] for t in response[arn].get("Tags", [])
+                    }
+                else:
+                    result[arn] = None
+        return result
+
+    @classmethod
+    def set_tags(cls, session, arns, tags):
+        if not arns:
+            raise ValueError("At least one ARN must be provided to set_tags.")
+
+        if len(tags) == 0:
+            raise ValueError("At least one tag must be provided to set_tags.")
+
+        if len(tags) > 50:
+            raise ValueError("A maximum of 50 tags can be set at once.")
+
+        client = session.client("resourcegroupstaggingapi")
+        result = {}
+
+        # https://docs.aws.amazon.com/resourcegroupstagging/latest/APIReference/API_TagResources.html
+        batch_size = 20
+        for i in range(0, len(arns), batch_size):
+            batch = arns[i : i + batch_size]
+            response = client.tag_resources(ResourceARNList=batch, Tags=tags)
+            for arn in batch:
+                result[arn] = arn not in response["FailedResourcesMap"]
+
+        return result

better_aws_tags-0.3.1/src/better_aws_tags/tags.py

@@ -0,0 +1,45 @@
+"""AWS resource tag operations."""
+
+import boto3
+
+from .arnparse import arnparse
+from .handlers import IAMHandler, TaggingAPIHandler
+
+
+def get_tags(arns, session=None):
+    """Get tags for AWS resources."""
+    session = session or boto3.Session()
+    handlers = dispatch(arns)
+    results = {}
+    for handler, handler_arns in handlers.items():
+        r = handler.get_tags(session, handler_arns)
+        results.update(r)
+    return results
+
+
+def set_tags(arns, tags, session=None):
+    """Set tags on AWS resources."""
+    session = session or boto3.Session()
+    handlers = dispatch(arns)
+    results = {}
+    for handler, handler_arns in handlers.items():
+        r = handler.set_tags(session, handler_arns, tags)
+        results.update(r)
+    return results
+
+
+def dispatch(arns):
+    """Group ARNs by handler."""
+    handler_to_arns = {}
+    for arn in arns:
+        arn_data = arnparse(arn)
+
+        if arn_data.service == "iam":
+            handler = IAMHandler
+        else:
+            handler = TaggingAPIHandler
+
+        if handler not in handler_to_arns:
+            handler_to_arns[handler] = []
+        handler_to_arns[handler].append(arn)
+    return handler_to_arns

better_aws_tags-0.3.1/tests/test_arnparse.py

@@ -0,0 +1,363 @@
+"""Tests for ARN parsing."""
+
+from better_aws_tags.arnparse import arnparse
+
+
+def test_arnparse_acm():
+    result = arnparse("arn:aws:acm:us-east-1:012345678901:certificate/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
+    assert result.resource_type == "certificate"
+    assert result.resource_id == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+    assert result.resource_name == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+
+
+def test_arnparse_apigateway():
+    result = arnparse("arn:aws:apigateway:us-east-1::/restapis/abc123def4")
+    assert result.resource_type == "restapis"
+    assert result.resource_id == "abc123def4"
+    assert result.resource_name == "abc123def4"
+
+
+def test_arnparse_athena():
+    result = arnparse("arn:aws:athena:us-east-1:012345678901:workgroup/workgroup1")
+    assert result.resource_type == "workgroup"
+    assert result.resource_id == "workgroup1"
+    assert result.resource_name == "workgroup1"
+
+
+def test_arnparse_autoscaling():
+    result = arnparse("arn:aws:autoscaling:us-east-1:012345678901:autoScalingGroup:aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee:autoScalingGroupName/asg1")
+    assert result.resource_type == "autoScalingGroup"
+    assert result.resource_id == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+    assert result.resource_name == "asg1"
+
+
+def test_arnparse_backup():
+    result = arnparse("arn:aws:backup:us-east-1:012345678901:backup-vault:vault1")
+    assert result.resource_type == "backup-vault"
+    assert result.resource_id == "vault1"
+    assert result.resource_name == "vault1"
+
+
+def test_arnparse_cloudformation():
+    result = arnparse("arn:aws:cloudformation:us-east-1:012345678901:stack/stack1/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
+    assert result.resource_type == "stack"
+    assert result.resource_id == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+    assert result.resource_name == "stack1"
+
+
+def test_arnparse_cloudfront():
+    result = arnparse("arn:aws:cloudfront::012345678901:distribution/ABCDEFGHIJKLMN")
+    assert result.resource_type == "distribution"
+    assert result.resource_id == "ABCDEFGHIJKLMN"
+    assert result.resource_name == "ABCDEFGHIJKLMN"
+
+
+def test_arnparse_cloudtrail():
+    result = arnparse("arn:aws:cloudtrail:us-east-1:012345678901:trail/trailname1")
+    assert result.resource_type == "trail"
+    assert result.resource_id == "trailname1"
+    assert result.resource_name == "trailname1"
+
+
+def test_arnparse_cloudwatch():
+    result = arnparse("arn:aws:cloudwatch:us-east-1:012345678901:alarm:CPU Utilization - High Warning - service-production-1")
+    assert result.resource_type == "alarm"
+    assert result.resource_id == "CPU Utilization - High Warning - service-production-1"
+    assert result.resource_name == "CPU Utilization - High Warning - service-production-1"
+
+
+def test_arnparse_codebuild():
+    result = arnparse("arn:aws:codebuild:us-east-1:012345678901:project/build_image")
+    assert result.resource_type == "project"
+    assert result.resource_id == "build_image"
+    assert result.resource_name == "build_image"
+
+
+def test_arnparse_codecommit():
+    result = arnparse("arn:aws:codecommit:us-east-1:012345678901:repository1")
+    assert result.resource_type is None
+    assert result.resource_id == "repository1"
+    assert result.resource_name == "repository1"
+
+
+def test_arnparse_codepipeline():
+    result = arnparse("arn:aws:codepipeline:us-east-1:012345678901:deploy_pipeline")
+    assert result.resource_type is None
+    assert result.resource_id == "deploy_pipeline"
+    assert result.resource_name == "deploy_pipeline"
+
+
+def test_arnparse_datasync():
+    result = arnparse("arn:aws:datasync:us-east-1:012345678901:task/task-0123456789abcdef0")
+    assert result.resource_type == "task"
+    assert result.resource_id == "task-0123456789abcdef0"
+    assert result.resource_name == "task-0123456789abcdef0"
+
+
+def test_arnparse_dynamodb():
+    result = arnparse("arn:aws:dynamodb:us-east-1:012345678901:table/table1")
+    assert result.resource_type == "table"
+    assert result.resource_id == "table1"
+    assert result.resource_name == "table1"
+
+
+def test_arnparse_ec2():
+    result = arnparse("arn:aws:ec2:us-east-1:012345678901:instance/i-0123456789abcdef0")
+    assert result.resource_type == "instance"
+    assert result.resource_id == "i-0123456789abcdef0"
+    assert result.resource_name == "i-0123456789abcdef0"
+
+    result = arnparse("arn:aws:ec2:us-east-1:012345678901:volume/vol-0123456789abcdef0")
+    assert result.resource_type == "volume"
+    assert result.resource_id == "vol-0123456789abcdef0"
+
+    result = arnparse("arn:aws:ec2:us-east-1:012345678901:snapshot/snap-0123456789abcdef0")
+    assert result.resource_type == "snapshot"
+    assert result.resource_id == "snap-0123456789abcdef0"
+
+    result = arnparse("arn:aws:ec2:us-east-1:012345678901:image/ami-0123456789abcdef0")
+    assert result.resource_type == "image"
+    assert result.resource_id == "ami-0123456789abcdef0"
+
+    result = arnparse("arn:aws:ec2:us-east-1:012345678901:elastic-ip/eipalloc-0123456789abcdef0")
+    assert result.resource_type == "elastic-ip"
+    assert result.resource_id == "eipalloc-0123456789abcdef0"
+
+    result = arnparse("arn:aws:ec2:us-east-1:012345678901:natgateway/nat-0123456789abcdef0")
+    assert result.resource_type == "natgateway"
+    assert result.resource_id == "nat-0123456789abcdef0"
+
+    result = arnparse("arn:aws:ec2:us-east-1:012345678901:vpc-endpoint/vpce-0123456789abcdef0")
+    assert result.resource_type == "vpc-endpoint"
+    assert result.resource_id == "vpce-0123456789abcdef0"
+
+    result = arnparse("arn:aws:ec2:us-east-1:012345678901:launch-template/lt-0123456789abcdef0")
+    assert result.resource_type == "launch-template"
+    assert result.resource_id == "lt-0123456789abcdef0"
+
+    result = arnparse("arn:aws:ec2:us-east-1:012345678901:reserved-instances/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
+    assert result.resource_type == "reserved-instances"
+    assert result.resource_id == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+
+    result = arnparse("arn:aws:ec2:us-east-1:012345678901:spot-instances-request/sir-abcd1234")
+    assert result.resource_type == "spot-instances-request"
+    assert result.resource_id == "sir-abcd1234"
+
+
+def test_arnparse_ecr():
+    result = arnparse("arn:aws:ecr:us-east-1:012345678901:repository/web-service")
+    assert result.resource_type == "repository"
+    assert result.resource_id == "web-service"
+    assert result.resource_name == "web-service"
+
+
+def test_arnparse_eks():
+    result = arnparse("arn:aws:eks:us-east-1:012345678901:cluster/c1")
+    assert result.resource_type == "cluster"
+    assert result.resource_id == "c1"
+    assert result.resource_name == "c1"
+
+
+def test_arnparse_elasticache():
+    result = arnparse("arn:aws:elasticache:us-east-1:012345678901:cluster:redis-cluster-node-001")
+    assert result.resource_type == "cluster"
+    assert result.resource_id == "redis-cluster-node-001"
+
+    result = arnparse("arn:aws:elasticache:us-east-1:012345678901:parametergroup:redis-cluster-params-redis7")
+    assert result.resource_type == "parametergroup"
+    assert result.resource_id == "redis-cluster-params-redis7"
+
+    result = arnparse("arn:aws:elasticache:us-east-1:012345678901:replicationgroup:redis-repl-group1")
+    assert result.resource_type == "replicationgroup"
+    assert result.resource_id == "redis-repl-group1"
+
+    result = arnparse("arn:aws:elasticache:us-east-1:012345678901:reserved-instance:reserved-node-prod1")
+    assert result.resource_type == "reserved-instance"
+    assert result.resource_id == "reserved-node-prod1"
+
+    result = arnparse("arn:aws:elasticache:us-east-1:012345678901:subnetgroup:cache-subnet-group1")
+    assert result.resource_type == "subnetgroup"
+    assert result.resource_id == "cache-subnet-group1"
+
+    result = arnparse("arn:aws:elasticache:us-east-1:012345678901:user:default")
+    assert result.resource_type == "user"
+    assert result.resource_id == "default"
+
+
+def test_arnparse_elasticfilesystem():
+    result = arnparse("arn:aws:elasticfilesystem:us-east-1:012345678901:file-system/fs-01234567")
+    assert result.resource_type == "file-system"
+    assert result.resource_id == "fs-01234567"
+    assert result.resource_name == "fs-01234567"
+
+
+def test_arnparse_elasticloadbalancing():
+    # Classic LB
+    result = arnparse("arn:aws:elasticloadbalancing:us-east-1:012345678901:loadbalancer/a0123456789abcdef0123456789abcde")
+    assert result.resource_type == "loadbalancer"
+    assert result.resource_id == "a0123456789abcdef0123456789abcde"
+
+    # ALB
+    result = arnparse("arn:aws:elasticloadbalancing:us-east-1:012345678901:loadbalancer/app/alb-application-lb-name/0123456789abcdef")
+    assert result.resource_type == "loadbalancer/app"
+    assert result.resource_id == "0123456789abcdef"
+    assert result.resource_name == "alb-application-lb-name"
+
+    # NLB
+    result = arnparse("arn:aws:elasticloadbalancing:us-east-1:012345678901:loadbalancer/net/nlb-network-load-balancer/0123456789abcdef")
+    assert result.resource_type == "loadbalancer/net"
+    assert result.resource_id == "0123456789abcdef"
+    assert result.resource_name == "nlb-network-load-balancer"
+
+    # Target group
+    result = arnparse("arn:aws:elasticloadbalancing:us-east-1:012345678901:targetgroup/target-grp-1/0123456789abcdef")
+    assert result.resource_type == "targetgroup"
+    assert result.resource_id == "0123456789abcdef"
+    assert result.resource_name == "target-grp-1"
+
+
+def test_arnparse_es():
+    result = arnparse("arn:aws:es:us-east-1:012345678901:domain/search-domain-prod")
+    assert result.resource_type == "domain"
+    assert result.resource_id == "search-domain-prod"
+    assert result.resource_name == "search-domain-prod"
+
+
+def test_arnparse_events():
+    result = arnparse("arn:aws:events:us-east-1:012345678901:event-bus/default")
+    assert result.resource_type == "event-bus"
+    assert result.resource_id == "default"
+
+    result = arnparse("arn:aws:events:us-east-1:012345678901:rule/ScheduledEventRule01")
+    assert result.resource_type == "rule"
+    assert result.resource_id == "ScheduledEventRule01"
+
+
+def test_arnparse_guardduty():
+    result = arnparse("arn:aws:guardduty:us-east-1:012345678901:detector/0123456789abcdef0123456789abcdef")
+    assert result.resource_type == "detector"
+    assert result.resource_id == "0123456789abcdef0123456789abcdef"
+    assert result.resource_name == "0123456789abcdef0123456789abcdef"
+
+
+def test_arnparse_iam():
+    result = arnparse("arn:aws:iam::012345678901:user/admin")
+    assert result.resource_type == "user"
+    assert result.resource_id == "admin"
+    assert result.resource_name == "admin"
+
+    result = arnparse("arn:aws:iam::012345678901:role/lambda-execution-role")
+    assert result.resource_type == "role"
+    assert result.resource_id == "lambda-execution-role"
+
+    result = arnparse("arn:aws:iam::012345678901:policy/custom-policy")
+    assert result.resource_type == "policy"
+    assert result.resource_id == "custom-policy"
+
+    result = arnparse("arn:aws:iam::012345678901:group/developers")
+    assert result.resource_type == "group"
+    assert result.resource_id == "developers"
+
+    result = arnparse("arn:aws:iam::012345678901:instance-profile/ec2-profile")
+    assert result.resource_type == "instance-profile"
+    assert result.resource_id == "ec2-profile"
+
+
+def test_arnparse_kms():
+    result = arnparse("arn:aws:kms:us-east-1:012345678901:key/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
+    assert result.resource_type == "key"
+    assert result.resource_id == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+    assert result.resource_name == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+
+
+def test_arnparse_lambda():
+    result = arnparse("arn:aws:lambda:us-east-1:012345678901:function:ProcessDataHandler")
+    assert result.resource_type == "function"
+    assert result.resource_id == "ProcessDataHandler"
+    assert result.resource_name == "ProcessDataHandler"
+
+
+def test_arnparse_logs():
+    result = arnparse("arn:aws:logs:us-east-1:012345678901:log-group:/aws/lambda/function-logs")
+    assert result.resource_type == "log-group"
+    assert result.resource_id == "/aws/lambda/function-logs"
+    assert result.resource_name == "/aws/lambda/function-logs"
+
+
+def test_arnparse_rds():
+    result = arnparse("arn:aws:rds:us-east-1:012345678901:cluster:database-cluster-1")
+    assert result.resource_type == "cluster"
+    assert result.resource_id == "database-cluster-1"
+
+    result = arnparse("arn:aws:rds:us-east-1:012345678901:cluster-snapshot:snap001")
+    assert result.resource_type == "cluster-snapshot"
+    assert result.resource_id == "snap001"
+
+    result = arnparse("arn:aws:rds:us-east-1:012345678901:db:database-instance-1")
+    assert result.resource_type == "db"
+    assert result.resource_id == "database-instance-1"
+
+    result = arnparse("arn:aws:rds:us-east-1:012345678901:ri:reserved01")
+    assert result.resource_type == "ri"
+    assert result.resource_id == "reserved01"
+
+    result = arnparse("arn:aws:rds:us-east-1:012345678901:snapshot:final-database-backup-01234567")
+    assert result.resource_type == "snapshot"
+    assert result.resource_id == "final-database-backup-01234567"
+
+
+def test_arnparse_route53():
+    result = arnparse("arn:aws:route53:::healthcheck/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
+    assert result.resource_type == "healthcheck"
+    assert result.resource_id == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+
+    result = arnparse("arn:aws:route53:::hostedzone/Z0123456789ABCDEFGHIJ")
+    assert result.resource_type == "hostedzone"
+    assert result.resource_id == "Z0123456789ABCDEFGHIJ"
+
+
+def test_arnparse_s3():
+    result = arnparse("arn:aws:s3:::example-bucket-01")
+    assert result.resource_type is None
+    assert result.resource_id == "example-bucket-01"
+    assert result.resource_name == "example-bucket-01"
+
+
+def test_arnparse_secretsmanager():
+    result = arnparse("arn:aws:secretsmanager:us-east-1:012345678901:secret:/app/secrets/service-name/production-AbCdEf")
+    assert result.resource_type == "secret"
+    assert result.resource_id == "/app/secrets/service-name/production-AbCdEf"
+    assert result.resource_name == "/app/secrets/service-name/production-AbCdEf"
+
+
+def test_arnparse_sns():
+    result = arnparse("arn:aws:sns:us-east-1:012345678901:topic1")
+    assert result.resource_type is None
+    assert result.resource_id == "topic1"
+    assert result.resource_name == "topic1"
+
+
+def test_arnparse_sqs():
+    result = arnparse("arn:aws:sqs:us-east-1:012345678901:processing-queue-1")
+    assert result.resource_type is None
+    assert result.resource_id == "processing-queue-1"
+    assert result.resource_name == "processing-queue-1"
+
+
+def test_arnparse_ssm():
+    result = arnparse("arn:aws:ssm:us-east-1:012345678901:parameter/config_val")
+    assert result.resource_type == "parameter"
+    assert result.resource_id == "/config_val"
+    assert result.resource_name == "/config_val"
+
+
+def test_arnparse_wafv2():
+    result = arnparse("arn:aws:wafv2:us-east-1:012345678901:global/webacl/WebACL-for-CloudFront-01/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
+    assert result.resource_type == "global/webacl"
+    assert result.resource_id == "WebACL-for-CloudFront-01"
+    assert result.resource_name == "WebACL-for-CloudFront-01"
+
+    result = arnparse("arn:aws:wafv2:us-east-1:012345678901:regional/webacl/webacl-production-acl/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
+    assert result.resource_type == "regional/webacl"
+    assert result.resource_id == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+    assert result.resource_name == "webacl-production-acl"

better_aws_tags-0.2.0/.claude/settings.local.json

@@ -1,16 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "mcp__plugin_adaptivegears_adaptivegears__search",
-      "mcp__plugin_adaptivegears_adaptivegears__read",
-      "Bash(uv init:*)",
-      "Bash(uv venv:*)",
-      "Bash(uv add:*)",
-      "Bash(make)",
-      "Bash(git branch:*)"
-    ]
-  },
-  "enabledPlugins": {
-    "adaptivegears@adaptivegears-marketplace": true
-  }
-}

better_aws_tags-0.2.0/PKG-INFO

@@ -1,18 +0,0 @@
-Metadata-Version: 2.4
-Name: better-aws-tags
-Version: 0.2.0
-Summary: A unified Python interface for managing AWS resource tags
-Author-email: Andrey Gubarev <andrey@andreygubarev.com>
-Requires-Python: >=3.10
-Requires-Dist: boto3~=1.0
-Description-Content-Type: text/markdown
-
-# better-aws-tags
-
-A unified Python interface for managing AWS resource tags. AWS provides multiple tagging APIs across services, including the Resource Groups Tagging API and service-specific implementations such as EC2, S3, and IAM. This library abstracts these differences behind a single API that accepts any valid ARN and handles service routing, tag validation, and error reporting automatically.
-
-## Getting Started
-
-```python
-import better_aws_tags as bats
-```

better_aws_tags-0.2.0/README.md

@@ -1,9 +0,0 @@
-# better-aws-tags
-
-A unified Python interface for managing AWS resource tags. AWS provides multiple tagging APIs across services, including the Resource Groups Tagging API and service-specific implementations such as EC2, S3, and IAM. This library abstracts these differences behind a single API that accepts any valid ARN and handles service routing, tag validation, and error reporting automatically.
-
-## Getting Started
-
-```python
-import better_aws_tags as bats
-```

better_aws_tags-0.2.0/src/better_aws_tags/tags.py

@@ -1,39 +0,0 @@
-"""AWS resource tag operations."""
-
-import boto3
-
-
-def get_tags(
-    arn: str | list[str],
-    session: boto3.Session | None = None,
-) -> dict[str, str] | dict[str, dict[str, str]]:
-    """Get tags for one or more AWS resources.
-
-    Args:
-        arn: Single ARN or list of ARNs.
-        session: Optional boto3 session. Uses default if not provided.
-
-    Returns:
-        Single ARN: {"Key": "Value", ...}
-        Multiple ARNs: {"arn1": {"Key": "Value"}, "arn2": {...}}
-    """
-    raise NotImplementedError
-
-
-def set_tags(
-    arn: str | list[str],
-    tags: dict[str, str],
-    session: boto3.Session | None = None,
-) -> bool | dict[str, bool]:
-    """Set tags on one or more AWS resources.
-
-    Args:
-        arn: Single ARN or list of ARNs.
-        tags: Tags to set (merged with existing).
-        session: Optional boto3 session. Uses default if not provided.
-
-    Returns:
-        Single ARN: True if successful.
-        Multiple ARNs: {"arn1": True, "arn2": False, ...}
-    """
-    raise NotImplementedError