awsimple 3.10.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

awsimple/__init__.py

@@ -1,5 +1,6 @@
 from .__version__ import __application_name__, __version__, __author__, __title__
 from .mock import use_moto_mock_env_var, is_mock, use_localstack_env_var, is_using_localstack
+from .exceptions import DynamoDBItemAlreadyExists, S3BucketAlreadyExistsNotOwnedByYou
 from .aws import AWSAccess, AWSimpleException, boto_error_to_string
 from .cache import get_disk_free, get_directory_size, lru_cache_write, CacheAccess, CACHE_DIR_ENV_VAR
 from .dynamodb import DynamoDBAccess, dict_to_dynamodb, DBItemNotFound, DynamoDBTableNotFound, dynamodb_to_json, dynamodb_to_dict, QuerySelection, DictKey, convert_serializable_special_cases

awsimple/__version__.py

@@ -1,7 +1,7 @@
 __application_name__ = "awsimple"
 __title__ = __application_name__
 __author__ = "abel"
-__version__ = "3.10.0"
+__version__ = "4.0.0"
 __author_email__ = "j@abel.co"
 __url__ = "https://github.com/jamesabel/awsimple"
 __download_url__ = "https://github.com/jamesabel/awsimple"

awsimple/dynamodb.py

@@ -9,7 +9,7 @@ from collections import OrderedDict, defaultdict, namedtuple
 import datetime
 from pathlib import Path
 from os.path import getsize, getmtime
-from typing import List, Union, Any, Type, Dict, Callable, Literal
+from typing import List, Union, Any, Type, Dict, Callable
 from pprint import pformat
 from itertools import islice
 import json
@@ -21,14 +21,13 @@ from collections.abc import Iterable
 from logging import getLogger
 
 
-import boto3
 from botocore.exceptions import EndpointConnectionError, ClientError
 from boto3.dynamodb.conditions import Key
 from typeguard import typechecked
 from dictim import dictim  # type: ignore
-from yasf import sf
 
-from awsimple import CacheAccess, __application_name__, AWSimpleException
+from . import CacheAccess, __application_name__, AWSimpleException
+from .exceptions import DynamoDBItemAlreadyExists
 
 # don't require pillow, but convert images with it if it exists
 pil_exists = False
@@ -47,6 +46,9 @@ handle_inexact_error = True
 # for scan to dict
 DictKey = namedtuple("DictKey", ["partition", "sort"])  # only for Primary Key with both partition and sort keys
 
+metadata_table_name = f"__{__application_name__}_metadata__"
+dynamodb_name = "dynamodb"
+
 log = getLogger(__application_name__)
 
 
@@ -219,6 +221,10 @@ def _is_valid_db_pickled_file(file_path: Path, cache_life: Union[float, int, Non
 
 
 class DynamoDBAccess(CacheAccess):
+    """
+    AWS DynamoDB access
+    """
+
     @typechecked()
     def __init__(self, table_name: Union[str, None] = None, **kwargs):
         """
@@ -232,8 +238,12 @@ class DynamoDBAccess(CacheAccess):
         self.secondary_index_postfix = "-index"
 
         self.table_name = table_name  # can be None (the default) if we're only doing things that don't require a table name such as get_table_names()
-        if self.table_name is not None:
-            self.metadata_table = _DynamoDBMetadataTable(self.table_name)
+
+        # avoid recursion
+        if self.table_name is not None and self.table_name != metadata_table_name:
+            self.metadata_table = _DynamoDBMetadataTable(dynamodb_name, self.table_name, **kwargs)
+        else:
+            self.metadata_table = None
 
         super().__init__(resource_name="dynamodb", **kwargs)
 
@@ -508,7 +518,8 @@ class DynamoDBAccess(CacheAccess):
                 created = True
             except ClientError as e:
                 log.warning(e)
-        self.metadata_table.update_table_mtime()
+        if self.metadata_table is not None:
+            self.metadata_table.update_table_mtime()
 
         return created
 
@@ -729,9 +740,41 @@ class DynamoDBAccess(CacheAccess):
         try:
             table = self.resource.Table(self.table_name)
             table.put_item(Item=item)
-            self.metadata_table.update_table_mtime()
+            if self.metadata_table is not None:
+                self.metadata_table.update_table_mtime()
+        except self.client.exceptions.ResourceNotFoundException:
+            raise DynamoDBTableNotFound(str(self.table_name))
+
+    def put_item_if_not_exists(self, item: dict):
+        """
+        Put (write) a DynamoDB table dict item if it doesn't already exist.  If the item already exists, it is not modified and DynamoDBItemAlreadyExists is raised.
+
+        :param item: item
+        """
+        assert self.resource is not None
+        primary_partition_key = self.get_primary_partition_key()
+        primary_sort_key = self.get_primary_sort_key()
+        try:
+            table = self.resource.Table(self.table_name)
+            if primary_sort_key is None:
+                table.put_item(Item=item, ConditionExpression="attribute_not_exists(#pk)", ExpressionAttributeNames={"#pk": primary_partition_key})
+            else:
+                table.put_item(
+                    Item=item,
+                    ConditionExpression="attribute_not_exists(#pk) AND attribute_not_exists(#sk)",
+                    ExpressionAttributeNames={"#pk": primary_partition_key, "#sk": primary_sort_key},
+                )
+            if self.metadata_table is not None:
+                self.metadata_table.update_table_mtime()
+            already_exists = False
         except self.client.exceptions.ResourceNotFoundException:
             raise DynamoDBTableNotFound(str(self.table_name))
+        except self.client.exceptions.ConditionalCheckFailedException:
+            already_exists = True
+        if already_exists:
+            primary_partition_value = str(item.get(primary_partition_key, ""))
+            primary_sort_value = str(item.get(primary_sort_key, ""))
+            raise DynamoDBItemAlreadyExists(str(self.table_name), primary_partition_value, primary_sort_value)
 
     # cant' do a @typechecked() since optional item requires a single type
     def get_item(
@@ -886,6 +929,9 @@ class DynamoDBAccess(CacheAccess):
             if len(filtered_row) > 0:
                 filtered_rows.append(filtered_row)
         field_names = sorted(field_names_set)
+        primary_partition_key = self.get_primary_partition_key()
+        primary_sort_key = self.get_primary_sort_key()
+        filtered_rows.sort(key=lambda x: (x[primary_partition_key], x.get(primary_sort_key)))  # sort by primary partition key, then sort key if it exists
 
         file_path.parent.mkdir(parents=True, exist_ok=True)
         with open(file_path, "w", newline="") as csvfile:
@@ -897,38 +943,21 @@ class DynamoDBAccess(CacheAccess):
         log.info(f"wrote {len(filtered_rows)} rows to {file_path}")
 
 
-
-metadata_table_name = f"__{__application_name__}_metadata__"
-
-
-class _DynamoDBMetadataTable:
+class _DynamoDBMetadataTable(DynamoDBAccess):
     """
     Access metadata (e.g. most recent modification time) for DynamoDB tables.
     """
 
     @typechecked()
-    def __init__(self, table_name: str):
-        self.table_name = table_name  # table we're storing metadata *for* (not the name of this metadata table)
-        self.primary_partition_key = "service"
+    def __init__(self, service: str, service_name: str, **kwargs):
+        self.service = service  # DynamoDB, SNS, SQS, etc.
+        self.service_name = service_name  # table name, queue name, topic name, etc.
+        self.primary_partition_key = "service"  # e.g. "dynamodb", "sqs", "sns", etc.
         self.primary_sort_key = "name"  # e.g. table name
         self.mtime_f_string = "mtime_f"
         self.mtime_human_string = "mtime_human"
-        self.service = "dynamodb"  # type: Literal["dynamodb"]
-        self.client = boto3.client(self.service)
-        self.resource = boto3.resource(self.service)
-        self.table = self.resource.Table(metadata_table_name)
-
-    def create_table(self):
-        key_schema = [{"AttributeName": self.primary_partition_key, "KeyType": "HASH"}, {"AttributeName": self.primary_sort_key, "KeyType": "RANGE"}]  # Partition key  # Sort key
-
-        attribute_definitions = [{"AttributeName": self.primary_partition_key, "AttributeType": "S"}, {"AttributeName": self.primary_sort_key, "AttributeType": "S"}]
-
-        self.table = self.resource.create_table(
-            TableName=metadata_table_name, KeySchema=key_schema, AttributeDefinitions=attribute_definitions, BillingMode="PAY_PER_REQUEST"  # on-demand capacity mode
-        )
-
-        # Wait until the table exists
-        self.table.meta.client.get_waiter("table_exists").wait(TableName=metadata_table_name)
+        super().__init__(metadata_table_name, **kwargs)
+        self.create_table(partition_key=self.primary_partition_key, sort_key=self.primary_sort_key, partition_key_type=str, sort_key_type=str)
 
     def update_table_mtime(self):
         """
@@ -938,27 +967,12 @@ class _DynamoDBMetadataTable:
         item = dict_to_dynamodb(
             {
                 self.primary_partition_key: self.service,
-                self.primary_sort_key: self.table_name,
+                self.primary_sort_key: self.service_name,
                 self.mtime_f_string: m_time,
                 self.mtime_human_string: datetime.datetime.fromtimestamp(m_time).astimezone().isoformat(),
             }
         )
-        log.debug(sf(item=item))
-        retry_put = False
-        try:
-            self.table.put_item(Item=item)
-        except ClientError as e:
-            error_code = e.response["Error"]["Code"]
-            if error_code == "ValidationException":
-                self.client.delete_table(TableName=metadata_table_name)
-                self.table.meta.client.get_waiter("table_not_exists").wait(TableName=metadata_table_name)
-            if error_code == "ValidationException" or error_code == "ResourceNotFoundException":
-                self.create_table()  # table doesn't exist, so create it
-                retry_put = True  # and retry the put
-            else:
-                raise  # some other exception, so re-raise it
-        if retry_put:
-            self.table.put_item(Item=item)
+        self.put_item(item=item)
 
     @typechecked()
     def get_table_mtime_f(self) -> Union[float | None]:
@@ -966,13 +980,10 @@ class _DynamoDBMetadataTable:
         Get a table's mtime from the metadata table.
         :return: table's mtime as a float or None if table hasn't been written to
         """
-        mtime_f = None
-        key = {self.primary_partition_key: self.service, self.primary_sort_key: self.table_name}
-        try:
-            response = self.table.get_item(Key=key)
-            if (mtime_item := response.get("Item")) is not None and (mtime_f_as_decimal := mtime_item.get(self.mtime_f_string)) is not None:
-                assert isinstance(mtime_f_as_decimal, Decimal)  # mainly for mypy
-                mtime_f = float(mtime_f_as_decimal)  # boto3 uses Decimal for numbers, but we want a float
-        except DBItemNotFound:
-            pass
+        item = self.get_item(self.primary_partition_key, self.service, self.primary_sort_key, self.service_name)
+        if (mtime := item.get(self.mtime_f_string)) is None:
+            mtime_f = None
+        else:
+            mtime_f = float(mtime)
+
         return mtime_f

awsimple/exceptions.py

@@ -0,0 +1,24 @@
+class AWSimpleExceptionBase(Exception):
+    """Base exception for AWSimple errors."""
+
+    pass
+
+
+class DynamoDBItemAlreadyExists(AWSimpleExceptionBase):
+    """Raised when an item already exists in DynamoDB."""
+
+    def __init__(self, table_name: str, primary_partition_value: str, primary_sort_value: str):
+        if len(primary_sort_value) < 1:
+            sort_message = ""
+        else:
+            sort_message = f" and {primary_sort_value=}"
+        message = f"Item with {primary_partition_value=}{sort_message} already exists in table {table_name}"
+        super().__init__(message)
+
+
+class S3BucketAlreadyExistsNotOwnedByYou(AWSimpleExceptionBase):
+    """Raised when an S3 bucket already exists and is not owned by you."""
+
+    def __init__(self, bucket_name: str):
+        message = f'S3 Bucket "{bucket_name}" already exists and is not owned by you'
+        super().__init__(message)

awsimple/pubsub.py

@@ -3,7 +3,7 @@ pub/sub abstraction on top of AWS SNS and SQS using boto3.
 """
 
 import time
-from typing import Any, Dict, List, Callable
+from typing import Any, Dict, List, Callable, Union
 from datetime import timedelta
 from multiprocessing import Process, Queue, Event
 from threading import Thread
@@ -24,9 +24,13 @@ log = Logger(__application_name__)
 
 queue_timeout = timedelta(days=30).total_seconds()
 
+sqs_name = "sqs"
+
 
 @typechecked()
-def remove_old_queues(channel: str) -> list[str]:
+def remove_old_queues(
+    channel: str, profile_name: Union[str, None] = None, aws_access_key_id: Union[str, None] = None, aws_secret_access_key: Union[str, None] = None, region_name: Union[str, None] = None
+) -> list[str]:
     """
     Remove old SQS queues that have not been used recently.
     """
@@ -35,10 +39,12 @@ def remove_old_queues(channel: str) -> list[str]:
         log.warning(f"blank channel ({channel=}) - not deleting any queues")
         return removed
     for sqs_queue_name in get_all_sqs_queues(channel):
-        sqs_metadata = _DynamoDBMetadataTable(sqs_queue_name)
+        sqs_metadata = _DynamoDBMetadataTable(
+            sqs_name, sqs_queue_name, profile_name=profile_name, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key, region_name=region_name
+        )
         mtime = sqs_metadata.get_table_mtime_f()
         if mtime is not None and time.time() - mtime > queue_timeout:
-            sqs = SQSPollAccess(sqs_queue_name)
+            sqs = SQSPollAccess(sqs_queue_name, profile_name=profile_name, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key, region_name=region_name)
             try:
                 sqs.delete_queue()
                 log.info(f'deleted "{sqs_queue_name}",{mtime=}')
@@ -49,20 +55,18 @@ def remove_old_queues(channel: str) -> list[str]:
 
 
 @typechecked()
-def _connect_sns_to_sqs(channel_name: str, sqs_queue_name: str, sqs: SQSPollAccess) -> None:
+def _connect_sns_to_sqs(sqs: SQSPollAccess, sns: SNSAccess) -> None:
     """
     Connect an SQS queue to an SNS topic.
 
-    :param channel_name: SNS topic name.
-    :param sqs_queue_name: SQS queue name.
-    :param sqs: SQSPollAccess instance for the SQS queue.
+    :param sqs: SQS access object
+    :param sns: SNS access object
     :return: None
     """
 
     sqs_arn = sqs.get_arn()
 
     # Find the topic by name
-    sns = SNSAccess(channel_name)
     sns.create_topic()
     topic_arn = sns.get_arn()
     assert sns.resource is not None
@@ -71,7 +75,7 @@ def _connect_sns_to_sqs(channel_name: str, sqs_queue_name: str, sqs: SQSPollAcce
     # Subscribe queue to topic
     queue_arn = sqs.get_arn()
     subscription = topic.subscribe(Protocol="sqs", Endpoint=queue_arn)
-    log.info(f"Subscribed {sqs_queue_name} to topic {topic_arn}. Subscription ARN: {subscription.arn}")
+    log.info(f"Subscribed {sqs.queue_name} to topic {topic_arn}. Subscription ARN: {subscription.arn}")
 
     # Update queue policy to allow SNS -> SQS
     policy = {
@@ -90,7 +94,7 @@ def _connect_sns_to_sqs(channel_name: str, sqs_queue_name: str, sqs: SQSPollAcce
     }
     assert sqs.queue is not None
     sqs.queue.set_attributes(Attributes={"Policy": json.dumps(policy)})
-    log.debug(f"Queue {sqs_queue_name} policy updated to allow topic {topic_arn}.")
+    log.debug(f"Queue {sqs.queue_name} policy updated to allow topic {topic_arn}.")
 
 
 class _SubscriptionThread(Thread):
@@ -118,7 +122,16 @@ class _SubscriptionThread(Thread):
 class PubSub(Process):
 
     @typechecked()
-    def __init__(self, channel: str, node_name: str = get_node_name(), sub_callback: Callable | None = None) -> None:
+    def __init__(
+        self,
+        channel: str,
+        node_name: str = get_node_name(),
+        sub_callback: Callable | None = None,
+        profile_name: Union[str, None] = None,
+        aws_access_key_id: Union[str, None] = None,
+        aws_secret_access_key: Union[str, None] = None,
+        region_name: Union[str, None] = None,
+    ) -> None:
         """
         Pub and Sub.
         Create in a separate process to offload from main thread. Also facilitates use of moto mock in tests.
@@ -131,6 +144,11 @@ class PubSub(Process):
         self.node_name = node_name  # e.g., computer name
         self.sub_callback = sub_callback
 
+        self.profile_name = profile_name
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+        self.region_name = region_name
+
         self._pub_queue = Queue()  # type: Queue[Dict[str, Any]]
         self._sub_queue = Queue()  # type: Queue[str]
 
@@ -143,13 +161,31 @@ class PubSub(Process):
         sqs_prefix = f"{self.channel}-"
         sqs_queue_name = f"{sqs_prefix}{self.node_name}"
 
-        sns = SNSAccess(self.channel, auto_create=True)
-        sqs_metadata = _DynamoDBMetadataTable(sqs_queue_name)
-
-        sqs = SQSPollAccess(sqs_queue_name)
+        sns = SNSAccess(
+            self.channel,
+            auto_create=True,
+            profile_name=self.profile_name,
+            aws_access_key_id=self.aws_access_key_id,
+            aws_secret_access_key=self.aws_secret_access_key,
+            region_name=self.region_name,
+        )
+        sqs_metadata = _DynamoDBMetadataTable(
+            sqs_name, sqs_queue_name, profile_name=self.profile_name, aws_access_key_id=self.aws_access_key_id, aws_secret_access_key=self.aws_secret_access_key, region_name=self.region_name
+        )
+
+        sqs = SQSPollAccess(
+            sqs_queue_name, profile_name=self.profile_name, aws_access_key_id=self.aws_access_key_id, aws_secret_access_key=self.aws_secret_access_key, region_name=self.region_name
+        )
         if not sqs.exists():
             sqs.create_queue()
-            _connect_sns_to_sqs(self.channel, sqs_queue_name, sqs)
+            sns = SNSAccess(
+                topic_name=self.channel,
+                profile_name=self.profile_name,
+                aws_access_key_id=self.aws_access_key_id,
+                aws_secret_access_key=self.aws_secret_access_key,
+                region_name=self.region_name,
+            )
+            _connect_sns_to_sqs(sqs, sns)
 
         sqs_metadata.update_table_mtime()  # update SQS use time (the existing infrastructure calls it a "table", but we're using it for the SQS queue)
         remove_old_queues(sqs_prefix)  # clean up old queues

awsimple/s3.py

@@ -23,7 +23,7 @@ from typeguard import typechecked
 from hashy import get_string_sha512, get_file_sha512, get_bytes_sha512, get_dls_sha512
 from yasf import sf
 
-from awsimple import CacheAccess, __application_name__, lru_cache_write, AWSimpleException, convert_serializable_special_cases
+from awsimple import CacheAccess, __application_name__, lru_cache_write, AWSimpleException, convert_serializable_special_cases, S3BucketAlreadyExistsNotOwnedByYou
 
 # Use this project's name as a prefix to avoid string collisions.  Use dashes instead of underscore since that's AWS's convention.
 sha512_string = f"{__application_name__}-sha512"
@@ -518,17 +518,18 @@ class S3Access(CacheAccess):
         else:
             location = {"LocationConstraint": region}
 
-        created = False
-        if not self.bucket_exists():
-            try:
-                if self.public_readable:
-                    self.client.create_bucket(Bucket=self.bucket_name, CreateBucketConfiguration=location, ACL="public-read")
-                else:
-                    self.client.create_bucket(Bucket=self.bucket_name, CreateBucketConfiguration=location)
-                self.client.get_waiter("bucket_exists").wait(Bucket=self.bucket_name)
-                created = True
-            except ClientError as e:
-                log.warning(f"{self.bucket_name=} {e=}")
+        try:
+            if self.public_readable:
+                self.client.create_bucket(Bucket=self.bucket_name, CreateBucketConfiguration=location, ACL="public-read")
+            else:
+                self.client.create_bucket(Bucket=self.bucket_name, CreateBucketConfiguration=location)
+            self.client.get_waiter("bucket_exists").wait(Bucket=self.bucket_name)
+            created = True
+        except self.client.exceptions.BucketAlreadyOwnedByYou:
+            created = False  # already exists and owned by you
+        except self.client.exceptions.BucketAlreadyExists as e:
+            # bucket already exists and is owned by someone else
+            raise S3BucketAlreadyExistsNotOwnedByYou(str(self.bucket_name)) from e
         return created
 
     @typechecked()

{awsimple-3.10.0.dist-info → awsimple-4.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awsimple
-Version: 3.10.0
+Version: 4.0.0
 Summary: Simple AWS API for S3, DynamoDB, SNS, and SQS
 Home-page: https://github.com/jamesabel/awsimple
 Download-URL: https://github.com/jamesabel/awsimple

awsimple-4.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+awsimple/__init__.py,sha256=RT9hATlcKnnvJYnSh7tCWEeeT2LyleL_vT1Zdz0nSkM,1051
+awsimple/__version__.py,sha256=Bry6FGgVAiNxrCSmMuhVuRDUuAgjUcP10LSWqTEROD0,323
+awsimple/aws.py,sha256=NbRu1v_J5j2-pcefNZ5Xggii3mM9nHpeHMz9L9K9r-U,7653
+awsimple/cache.py,sha256=_LvPx76215t8KhAJOin6Pe2b4lWpB6kbKpdzgR4FeA4,7206
+awsimple/dynamodb.py,sha256=7MNxAutOCMTS4JSX-DLOwzaImJ2TzIc7kfQzQPAy5y8,41193
+awsimple/dynamodb_miv.py,sha256=4xPxQDYkIM-BVDGyAre6uqwJHsxguEbHbof8ztt-V7g,4645
+awsimple/exceptions.py,sha256=Ew-S8YkHVWrZFI_Yik5n0cJ7Ss4Kig5JsEPQ-9z18SU,922
+awsimple/logs.py,sha256=s9FhdDFWjfxGCVDx-FNTPgJ-YN1AOAgz4HNxTVfRARE,4108
+awsimple/mock.py,sha256=eScbnxFF9xAosOAsL-NZgp_P-fezB6StQMkb85Y3TNo,574
+awsimple/platform.py,sha256=TObvLIVgRGh-Mh4ZCxFfxAmrn8KNMHktr6XkDZX8JYE,376
+awsimple/pubsub.py,sha256=AIWtY5PxTIwqol2l3FlSUPZaIQzkwywTiRboAUAVrgo,9403
+awsimple/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+awsimple/s3.py,sha256=OhWF1uv4oLmBF5jAhKIi918iUQxx4CX8bTEvQ5wLYr8,24050
+awsimple/sns.py,sha256=T_FyN8eSmBPo213HOfB3UBlMrvtBK768IaRo_ks-7do,3526
+awsimple/sqs.py,sha256=9ZY7161CpmYpcxlCFIfW8bvMn9SGl4cgGR79I4MFLDk,17281
+awsimple-4.0.0.dist-info/licenses/LICENSE,sha256=d956YAgtDaxgxQmccyUk__EfhORZyBjvmJ8pq6zYTxk,1093
+awsimple-4.0.0.dist-info/licenses/LICENSE.txt,sha256=d956YAgtDaxgxQmccyUk__EfhORZyBjvmJ8pq6zYTxk,1093
+awsimple-4.0.0.dist-info/METADATA,sha256=eVU_aKuAzloCJ7HMbidHYJSYrbfps9r3Oa5B60ESODI,6640
+awsimple-4.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+awsimple-4.0.0.dist-info/top_level.txt,sha256=mwqCoH_8vAaK6iYioiRbasXmVCQM7AK3grNWOKp2VHE,9
+awsimple-4.0.0.dist-info/RECORD,,

awsimple-3.10.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-awsimple/__init__.py,sha256=yo9COyuJZonzuW_5h2yvsQOtTqnwh8e_iMsMBqQxir0,964
-awsimple/__version__.py,sha256=7f2QtdJhuSXcZ0FT7TWbKMnjn0kMNBF-iRvyVI8FxF8,324
-awsimple/aws.py,sha256=NbRu1v_J5j2-pcefNZ5Xggii3mM9nHpeHMz9L9K9r-U,7653
-awsimple/cache.py,sha256=_LvPx76215t8KhAJOin6Pe2b4lWpB6kbKpdzgR4FeA4,7206
-awsimple/dynamodb.py,sha256=07Qz9j0GB5de5k6-OraDR3YCxTzIJa72jKGu5XWG9aY,40674
-awsimple/dynamodb_miv.py,sha256=4xPxQDYkIM-BVDGyAre6uqwJHsxguEbHbof8ztt-V7g,4645
-awsimple/logs.py,sha256=s9FhdDFWjfxGCVDx-FNTPgJ-YN1AOAgz4HNxTVfRARE,4108
-awsimple/mock.py,sha256=eScbnxFF9xAosOAsL-NZgp_P-fezB6StQMkb85Y3TNo,574
-awsimple/platform.py,sha256=TObvLIVgRGh-Mh4ZCxFfxAmrn8KNMHktr6XkDZX8JYE,376
-awsimple/pubsub.py,sha256=HzwkjIwFicoV--30ctov8oVlKfXWe7eaLOF1dieV7qk,7692
-awsimple/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-awsimple/s3.py,sha256=ydYLDj51b38lYI6LsJlc4i0PDj2vnWBuSkzdRKcWAUg,23858
-awsimple/sns.py,sha256=T_FyN8eSmBPo213HOfB3UBlMrvtBK768IaRo_ks-7do,3526
-awsimple/sqs.py,sha256=9ZY7161CpmYpcxlCFIfW8bvMn9SGl4cgGR79I4MFLDk,17281
-awsimple-3.10.0.dist-info/licenses/LICENSE,sha256=d956YAgtDaxgxQmccyUk__EfhORZyBjvmJ8pq6zYTxk,1093
-awsimple-3.10.0.dist-info/licenses/LICENSE.txt,sha256=d956YAgtDaxgxQmccyUk__EfhORZyBjvmJ8pq6zYTxk,1093
-awsimple-3.10.0.dist-info/METADATA,sha256=u4tpQmqUL8lZXkDPRbKC83mgZ_Sk8fcK5h7EFOdMNxU,6641
-awsimple-3.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-awsimple-3.10.0.dist-info/top_level.txt,sha256=mwqCoH_8vAaK6iYioiRbasXmVCQM7AK3grNWOKp2VHE,9
-awsimple-3.10.0.dist-info/RECORD,,