boto3-assist 0.8.0__tar.gz → 0.9.1__tar.gz

{boto3_assist-0.8.0 → boto3_assist-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boto3_assist
-Version: 0.8.0
+Version: 0.9.1
 Summary: Additional boto3 wrappers to make your life a little easier
 Author-email: Eric Wilson <boto3-assist@geekcafe.com>
 License-File: LICENSE-EXPLAINED.txt

{boto3_assist-0.8.0 → boto3_assist-0.9.1}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/boto3_assist"]
 
 [project]
 name = "boto3_assist"
-version = "0.8.0"
+version = "0.9.1"
 
 authors = [
   { name="Eric Wilson", email="boto3-assist@geekcafe.com" }

{boto3_assist-0.8.0 → boto3_assist-0.9.1}/requirements-dev.txt

@@ -7,6 +7,7 @@ mypy_boto3_ec2
 mypy_boto3_cloudwatch
 mypy_boto3_s3
 mypy_boto3_cognito_idp
+mypy_boto3_securityhub
 
 moto [dynamodb2] # mocks for unit tests
 # setuptools

{boto3_assist-0.8.0 → boto3_assist-0.9.1}/src/boto3_assist/connection.py

@@ -31,17 +31,10 @@ class Connection:
         aws_secret_access_key: Optional[str] = None,
         aws_end_point_url: Optional[str] = None,
     ) -> None:
-        # TODO: determine if we want to pull from environment vars or not
-        self.aws_profile = aws_profile or EnvironmentVariables.AWS.profile()
-        self.aws_region = aws_region or EnvironmentVariables.AWS.region()
-
-        self.aws_access_key_id = (
-            aws_access_key_id or EnvironmentVariables.AWS.DynamoDB.aws_access_key_id()
-        )
-        self.aws_secret_access_key = (
-            aws_secret_access_key
-            or EnvironmentVariables.AWS.DynamoDB.aws_secret_access_key()
-        )
+        self.__aws_profile = aws_profile
+        self.__aws_region = aws_region
+        self.__aws_access_key_id = aws_access_key_id
+        self.__aws_secret_access_key = aws_secret_access_key
         self.end_point_url = aws_end_point_url
         self.__session: Boto3SessionManager | None = None
 
@@ -84,6 +77,45 @@ class Connection:
 
         tracker.add(service_name=self.service_name)
 
+    @property
+    def asw_profile(self) -> str | None:
+        """The AWS Profile"""
+        return self.__aws_profile or EnvironmentVariables.AWS.profile()
+
+    @asw_profile.setter
+    def aws_profile(self, value: str | None):
+        self.__aws_profile = value
+
+    @property
+    def aws_region(self) -> str | None:
+        """The AWS Region"""
+        return self.__aws_region or EnvironmentVariables.AWS.region()
+
+    @aws_region.setter
+    def aws_region(self, value: str | None):
+        self.__aws_region = value
+
+    @property
+    def aws_access_key_id(self) -> str | None:
+        """The AWS Access Key"""
+        return self.__aws_access_key_id or EnvironmentVariables.AWS.aws_access_key_id()
+
+    @aws_access_key_id.setter
+    def aws_access_key_id(self, value: str | None):
+        self.__aws_access_key_id = value
+
+    @property
+    def aws_secret_access_key(self) -> str | None:
+        """The AWS Access Key"""
+        return (
+            self.__aws_secret_access_key
+            or EnvironmentVariables.AWS.aws_secret_access_key()
+        )
+
+    @aws_secret_access_key.setter
+    def aws_secret_access_key(self, value: str | None):
+        self.__aws_secret_access_key = value
+
     @property
     def service_name(self) -> str:
         """Service Name"""

{boto3_assist-0.8.0 → boto3_assist-0.9.1}/src/boto3_assist/environment_services/environment_loader.py

@@ -5,7 +5,7 @@ MIT License.  See Project Root for the license information.
 """
 
 import os
-
+import json
 from typing import List, Union, Optional, IO
 from pathlib import Path
 from dotenv import load_dotenv
@@ -109,3 +109,20 @@ class EnvironmentLoader:
             )
 
         return None
+
+    def load_event_file(self, full_path: str) -> dict:
+        """Loads an AWS event file"""
+        if not os.path.exists(full_path):
+            raise RuntimeError(f"Failed to locate event file: {full_path}")
+
+        event = {}
+        with open(full_path, mode="r", encoding="utf-8") as json_file:
+            event = json.load(json_file)
+
+        if isinstance(event, dict) and "message" in event:
+            event = event.get("message", {})
+
+        if isinstance(event, dict) and "event" in event:
+            event = event.get("event", {})
+
+        return event

boto3_assist-0.9.1/src/boto3_assist/s3/s3_event_data.py

@@ -0,0 +1,168 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+from typing import Dict, Any, List
+from boto3_assist.utilities.numbers_utility import NumberUtility
+
+
+class EventData:
+    """An Event Data Object"""
+
+    def __init__(self, event: Dict[str, Any]):
+        self.__event = event
+
+    @property
+    def version(self) -> str:
+        """Event Version"""
+        return self.__event.get("version")
+
+    @property
+    def id(self) -> str:
+        """Event Id"""
+        return self.__event.get("id")
+
+    @property
+    def detail_type(self) -> str:
+        """Event Detail Type"""
+        return self.__event.get("detail-type")
+
+    @property
+    def source(self) -> str:
+        """Event Source"""
+        return self.__event.get("source")
+
+    @property
+    def account(self) -> str:
+        """Event Account"""
+        return self.__event.get("account")
+
+    @property
+    def time(self) -> str:
+        """Event Time"""
+        return self.__event.get("time")
+
+    @property
+    def region(self) -> str:
+        """Event Region"""
+        return self.__event.get("region")
+
+    @property
+    def resources(self) -> List[str]:
+        """Event Resources"""
+        return self.__event.get("resources", [])
+
+
+class S3BucketData:
+    """S3 Bucket Data"""
+
+    def __init__(self, bucket_event_data: Dict[str, Any]):
+        self.__bucket = bucket_event_data
+
+    @property
+    def name(self) -> str | None:
+        """Bucket Name Key"""
+
+        return self.__bucket.get("name")
+
+
+class S3ObjectData:
+    """S3 Object"""
+
+    def __init__(self, object_data: Dict[str, Any]):
+        self.__s3_object_data = object_data
+
+    @property
+    def key(self) -> str | None:
+        """Object Key"""
+        return self.__s3_object_data.get("key")
+
+    @property
+    def size(self) -> int:
+        """Object size in bytes"""
+        size = NumberUtility.to_number(self.__s3_object_data.get("size"))
+        return size
+
+    @property
+    def etag(self) -> str | None:
+        """Object eTag"""
+        return self.__s3_object_data.get("etag")
+
+    @property
+    def version_id(self) -> str | None:
+        """Object Version Id"""
+        return self.__s3_object_data.get("version-id")
+
+    @property
+    def sequencer(self) -> str | None:
+        """Object eTag"""
+        return self.__s3_object_data.get("sequencer")
+
+
+class S3EventDetail:
+    """The Event Detail"""
+
+    def __init__(self, event: Dict[str, Any]):
+        self.__event = event
+        self.__s3_object_data: S3ObjectData | None = None
+        self.__s3_bucket_data: S3BucketData | None = None
+
+    @property
+    def version(self) -> str | None:
+        """Object Key"""
+
+        return self.__event.get("version")
+
+    @property
+    def bucket(self) -> S3BucketData:
+        """S# Bucket Information"""
+        if not self.__s3_bucket_data:
+            self.__s3_bucket_data = S3BucketData(self.__event.get("bucket", {}))
+        return self.__s3_bucket_data
+
+    @property
+    def object(self) -> S3ObjectData:
+        """S3 Object Information"""
+        if not self.__s3_object_data:
+            self.__s3_object_data = S3ObjectData(self.__event.get("object", {}))
+
+        return self.__s3_object_data
+
+    @property
+    def request_id(self) -> str | None:
+        """Detail Request Id"""
+
+        return self.__event.get("request-id")
+
+    @property
+    def requester(self) -> str | None:
+        """Detail Requestor"""
+
+        return self.__event.get("requester")
+
+    @property
+    def source_ip_address(self) -> str | None:
+        """Source IP Address"""
+
+        return self.__event.get("source-ip-address")
+
+    @property
+    def reason(self) -> str | None:
+        """Reason"""
+
+        return self.__event.get("reason")
+
+
+class S3Event(EventData):
+    """S3 Data Event"""
+
+    def __init__(self, event):
+        super().__init__(event)
+        self.__detail: S3EventDetail = S3EventDetail(event=event.get("detail", {}))
+
+    @property
+    def detail(self) -> S3EventDetail:
+        """S3 Specific Detail"""
+        return self.__detail

{boto3_assist-0.8.0 → boto3_assist-0.9.1}/src/boto3_assist/s3/s3_object.py

@@ -183,7 +183,7 @@ class S3Object:
             )
 
         end = DatetimeUtility.get_utc_now()
-        logger.debug(f"Signed URL created in {end-start}")
+        logger.debug(f"Signed URL created in {end - start}")
 
         response = {
             "signed_url": signed_url,
@@ -604,3 +604,65 @@ class S3Object:
                 versions.extend(page["Versions"])
 
         return versions
+
+    def copy(
+        self,
+        source_bucket: str,
+        source_key: str,
+        destination_bucket: str,
+        destination_key: str,
+    ) -> Dict[str, Any]:
+        """
+        Copies an object from one location to another.
+        The original is kept.
+        """
+
+        if source_key.startswith("/"):
+            # remove the first slash
+            source_key = source_key[1:]
+
+        if destination_key.startswith("/"):
+            # remove the first slash
+            destination_key = destination_key[1:]
+
+        response = self.connection.client.copy_object(
+            CopySource={"Bucket": source_bucket, "Key": source_key},
+            Bucket=destination_bucket,
+            Key=destination_key,
+        )
+
+        return response
+
+    def move(
+        self,
+        source_bucket: str,
+        source_key: str,
+        destination_bucket: str,
+        destination_key: str,
+    ) -> Dict[str, Any]:
+        """
+        Copies an object from one location to another then deletes the source.
+        The source is only deleted if the copy is successful
+        """
+
+        copy_response = self.connection.client.copy_object(
+            CopySource={"Bucket": source_bucket, "Key": source_key},
+            Bucket=destination_bucket,
+            Key=destination_key,
+        )
+
+        status_code = copy_response.get("statusCode")
+        delete_response = {}
+        if status_code == 200:
+            if source_key.startswith("/"):
+                source_key = source_key[1:]
+            delete_response = self.delete(bucket_name=source_bucket, key=source_key)
+            status_code = copy_response.get("statusCode", status_code)
+
+        response = {
+            "status_code": status_code,
+            "copy": copy_response,
+            "delete": delete_response,
+        }
+
+        return response

boto3_assist-0.9.1/src/boto3_assist/securityhub/securityhub.py

@@ -0,0 +1,150 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+import os
+from typing import Optional
+
+from aws_lambda_powertools import Logger
+
+from boto3_assist.securityhub.securityhub_connection import SecurityHubConnection
+
+logger = Logger("security-hub-service")
+
+
+class SecurityHub(SecurityHubConnection):
+    """Security Hub Service"""
+
+    def update_findings_status(
+        self,
+        region_name: str,
+        workflow_status: str,
+        note_text: Optional[str] = None,
+        updated_by: Optional[str] = None,
+    ):
+        """
+        Updates the workflow status for all findings in the specified region.
+
+        :param region_name: AWS region where Security Hub findings are located.
+        :param workflow_status: The new workflow status to apply (e.g., NEW, NOTIFIED, SUPPRESSED, RESOLVED).
+        """
+        # Initialize Security Hub client
+        client = self.client
+
+        findings_to_update = []
+        next_token = None
+
+        logger.info(f"Fetching findings in region: {region_name}...")
+
+        try:
+            # Paginate through findings
+            while True:
+                response = client.get_findings(
+                    MaxResults=100,
+                    Filters={
+                        "Region": [
+                            {"Value": region_name, "Comparison": "EQUALS"},
+                        ]
+                    },
+                    NextToken=next_token if next_token else "",
+                )
+
+                for finding in response.get("Findings", []):
+                    current_status = finding.get("Workflow", {}).get("Status")
+                    if (
+                        current_status
+                        and str(current_status).lower() != str(workflow_status).lower()
+                    ):
+                        findings_to_update.append(
+                            {
+                                "Id": finding["Id"],
+                                "ProductArn": finding["ProductArn"],
+                            }
+                        )
+                    else:
+                        logger.debug(
+                            f"Skipping: {finding['Id']} with a status of {current_status}"
+                        )
+
+                next_token = response.get("NextToken")
+                if not next_token:
+                    break
+
+            print(f"Found {len(findings_to_update)} findings to update.")
+
+            note_text = note_text or "Automated Update"
+            updated_by = updated_by or "System"
+            # Update workflow status in batches of 100
+            for i in range(0, len(findings_to_update), 100):
+                batch = findings_to_update[i : i + 100]
+                response = client.batch_update_findings(
+                    FindingIdentifiers=batch,
+                    Workflow={"Status": str(workflow_status).upper()},
+                    Note={"Text": note_text, "UpdatedBy": updated_by},
+                )
+                logger.debug(
+                    f"Updated findings {i + 1} to {i + len(batch)} to status: {workflow_status}"
+                )
+                print(response)
+
+            logger.info("All findings updated successfully!")
+
+        except Exception as e:
+            logger.exception(f"An error occurred: {str(e)}")
+            raise
+
+
+def main():
+    status = "RESOLVED"  # Change to NEW, NOTIFIED, SUPPRESSED, or RESOLVED
+    note_text = "This region is now disabled."
+    # these are my linked regions and the only ones I care about
+    # if have SCP's in place for the other regions
+    regions_to_skip = ["us-east-1", "us-west-2", "eu-west-2"]
+
+    aws_profile = os.getenv("SECURITY_HUB_PROFILE")
+
+    aws_regions = {
+        "af-south-1": "Africa (Cape Town)",
+        "ap-east-1": "Asia Pacific (Hong Kong)",
+        "ap-northeast-1": "Asia Pacific (Tokyo)",
+        "ap-northeast-2": "Asia Pacific (Seoul)",
+        "ap-northeast-3": "Asia Pacific (Osaka)",
+        "ap-south-1": "Asia Pacific (Mumbai)",
+        "ap-south-2": "Asia Pacific (Hyderabad)",
+        "ap-southeast-1": "Asia Pacific (Singapore)",
+        "ap-southeast-2": "Asia Pacific (Sydney)",
+        "ap-southeast-3": "Asia Pacific (Jakarta)",
+        "ap-southeast-4": "Asia Pacific (Melbourne)",
+        "ap-southeast-5": "Asia Pacific (Auckland)",
+        "ca-central-1": "Canada (Central)",
+        "ca-west-1": "Canada (West)",
+        "eu-central-1": "Europe (Frankfurt)",
+        "eu-central-2": "Europe (Zurich)",
+        "eu-north-1": "Europe (Stockholm)",
+        "eu-south-1": "Europe (Milan)",
+        "eu-south-2": "Europe (Spain)",
+        "eu-west-1": "Europe (Ireland)",
+        "eu-west-2": "Europe (London)",
+        "eu-west-3": "Europe (Paris)",
+        "il-central-1": "Israel (Tel Aviv)",
+        "me-central-1": "Middle East (UAE)",
+        "sa-east-1": "South America (São Paulo)",
+        "us-east-1": "US East (N. Virginia)",
+        "us-east-2": "US East (Ohio)",
+        "us-west-1": "US West (N. California)",
+        "us-west-2": "US West (Oregon)",
+    }
+
+    sh: SecurityHub = SecurityHub(aws_profile=aws_profile)
+    for region in aws_regions:
+        print(region)
+        if region not in regions_to_skip:
+            sh.update_findings_status(region, status, note_text=note_text)
+        else:
+            print(f"Skipping region: {region}")
+
+
+if __name__ == "__main__":
+    main()

boto3_assist-0.9.1/src/boto3_assist/securityhub/securityhub_connection.py

@@ -0,0 +1,57 @@
+"""
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License.  See Project Root for the license information.
+"""
+
+from typing import Optional
+from typing import TYPE_CHECKING
+
+from aws_lambda_powertools import Logger
+
+from boto3_assist.connection import Connection
+
+if TYPE_CHECKING:
+    from mypy_boto3_securityhub import SecurityHubClient
+else:
+    SecurityHubClient = object
+
+
+logger = Logger()
+
+
+class SecurityHubConnection(Connection):
+    """Connection"""
+
+    def __init__(
+        self,
+        *,
+        aws_profile: Optional[str] = None,
+        aws_region: Optional[str] = None,
+        aws_end_point_url: Optional[str] = None,
+        aws_access_key_id: Optional[str] = None,
+        aws_secret_access_key: Optional[str] = None,
+    ) -> None:
+        super().__init__(
+            service_name="securityhub",
+            aws_profile=aws_profile,
+            aws_region=aws_region,
+            aws_access_key_id=aws_access_key_id,
+            aws_secret_access_key=aws_secret_access_key,
+            aws_end_point_url=aws_end_point_url,
+        )
+
+        self.__client: SecurityHubClient | None = None
+
+    @property
+    def client(self) -> SecurityHubClient:
+        """Client Connection"""
+        if self.__client is None:
+            self.__client = self.session.client
+
+        return self.__client
+
+    @client.setter
+    def client(self, value: SecurityHubClient):
+        logger.info("Setting Client")
+        self.__client = value

{boto3_assist-0.8.0 → boto3_assist-0.9.1}/src/boto3_assist/utilities/numbers_utility.py

@@ -47,12 +47,20 @@ class NumberUtility:
     @staticmethod
     def to_number_or_none(value: str) -> float | int | None:
         """Converts a string to a number."""
-        if value is not None and NumberUtility.is_numeric(value):
-            if "." in str(value):
-                return float(value)
-            else:
-                return int(value)
-        return None
+        if value is None:
+            return None
+
+        if str(value).lower() == "nan":
+            return None
+
+        try:
+            numeric_value = float(value)
+            # Check if the number is an integer (e.g., 7.0) and return as int
+            if numeric_value.is_integer():
+                return int(numeric_value)
+            return numeric_value
+        except (ValueError, TypeError):
+            return None
 
     @staticmethod
     def to_float(
@@ -111,6 +119,7 @@ class NumberUtility:
         Returns:
             int: number of decimal places
         """
+
         number_str = f"{number}"
         if "." in number_str:
             to_the_right = number_str.split(".")[1]
@@ -178,6 +187,30 @@ class NumberUtility:
 
         return 0.0
 
+    @staticmethod
+    def to_number(
+        value: str | float | int,
+        raise_errors: Optional[bool] = False,
+        error_message: Optional[str] = None,
+    ) -> int | float:
+        """Converts a string to a number."""
+        try:
+            numeric_value = float(value)
+            # Check if the number is an integer (e.g., 7.0) and return as int
+            if numeric_value.is_integer():
+                return int(numeric_value)
+            return numeric_value
+        except Exception as e:  # noqa: E722, pylint: disable=w0718
+            logger.error(f"Unable to convert {value} to number")
+            if raise_errors:
+                if error_message:
+                    raise ValueError(
+                        f"Unable to convert {value} to number, {error_message}"
+                    ) from e
+                else:
+                    raise ValueError(f"Unable to convert {value} to number") from e
+            return 0
+
     @staticmethod
     def to_significant_figure(
         number: int | float | str, sig_figs: int
@@ -201,10 +234,14 @@ class NumberUtility:
             return number
 
         if NumberUtility.is_numeric(number) and isinstance(number, str):
-            if "." in str(number):
-                number = float(number)
-            else:
-                number = int(number)
+            number = NumberUtility.to_number(
+                number,
+                raise_errors=True,
+                error_message=(
+                    f"Error attempting to set significant figure for value {number}"
+                    f", sigfig {sig_figs}"
+                ),
+            )
 
         if number == 0:
             if sig_figs > 1:

boto3_assist-0.9.1/src/boto3_assist/version.py

@@ -0,0 +1 @@
+__version__ = '0.9.1'

boto3_assist-0.9.1/tests/s3/s3_event_data_test.py

@@ -0,0 +1,68 @@
+import unittest
+
+from boto3_assist.s3.s3_event_data import S3Event
+
+
+class S3EventDataTests(unittest.TestCase):
+    """Test S3 Event Data parsing"""
+
+    def test_event_info(self):
+        """Test the event information is parsed correctly"""
+        event = self.helper_get_event_sample()
+        s3_event: S3Event = S3Event(event=event)
+
+        self.assertEqual(s3_event.version, "0")
+        self.assertEqual(s3_event.id, "c576a9d9-edef-6aeb-cf6c-4fc0234bacdc")
+        self.assertEqual(s3_event.detail_type, "Object Created")
+        self.assertEqual(s3_event.source, "aws.s3")
+        self.assertEqual(s3_event.account, "1111111111")
+        self.assertEqual(s3_event.time, "2025-02-05T23:55:22Z")
+        self.assertEqual(s3_event.region, "us-east-1")
+        self.assertEqual(s3_event.resources, ["arn:aws:s3:::my_object_key"])
+        self.assertEqual(s3_event.detail.version, "0")
+        self.assertEqual(s3_event.detail.bucket.name, "my_object_key")
+        self.assertEqual(
+            s3_event.detail.object.key,
+            "tenants/aaaaaaaaaaaaaa/users/bbbbbbbbbbbbbbbb/sample.json",
+        )
+        self.assertEqual(s3_event.detail.object.size, 6904)
+        self.assertEqual(
+            s3_event.detail.object.etag, "f50341a4fa42e09016e76d7878c4fdc5"
+        )
+        self.assertEqual(
+            s3_event.detail.object.version_id, "58QKYNXF62Wo1y7CZUDrDM0ILh5ncSwf"
+        )
+        self.assertEqual(s3_event.detail.object.sequencer, "0067A3FA6A303C91A8")
+        self.assertEqual(s3_event.detail.request_id, "F82R8XDNW8385Q6Y")
+        self.assertEqual(s3_event.detail.requester, "959096737760")
+        self.assertEqual(s3_event.detail.source_ip_address, "192.168.0.52")
+        self.assertEqual(s3_event.detail.reason, "PutObject")
+
+    def helper_get_event_sample(self):
+        event = {
+            "version": "0",
+            "id": "c576a9d9-edef-6aeb-cf6c-4fc0234bacdc",
+            "detail-type": "Object Created",
+            "source": "aws.s3",
+            "account": "1111111111",
+            "time": "2025-02-05T23:55:22Z",
+            "region": "us-east-1",
+            "resources": ["arn:aws:s3:::my_object_key"],
+            "detail": {
+                "version": "0",
+                "bucket": {"name": "my_object_key"},
+                "object": {
+                    "key": "tenants/aaaaaaaaaaaaaa/users/bbbbbbbbbbbbbbbb/sample.json",
+                    "size": 6904,
+                    "etag": "f50341a4fa42e09016e76d7878c4fdc5",
+                    "version-id": "58QKYNXF62Wo1y7CZUDrDM0ILh5ncSwf",
+                    "sequencer": "0067A3FA6A303C91A8",
+                },
+                "request-id": "F82R8XDNW8385Q6Y",
+                "requester": "959096737760",
+                "source-ip-address": "192.168.0.52",
+                "reason": "PutObject",
+            },
+        }
+
+        return event

boto3_assist-0.8.0/src/boto3_assist/version.py

@@ -1 +0,0 @@
-__version__ = '0.8.0'