awskit 0.0.0__tar.gz

awskit-0.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: awskit
+Version: 0.0.0
+Author: André Bienemann
+Author-email: andre.bienemann@gmail.com
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: dev
+Provides-Extra: docs

awskit-0.0.0/README.md

@@ -0,0 +1,7 @@
+# AWS
+
+AWS Docs
+
+https://docs.aws.amazon.com/index.html
+
+https://docs.aws.amazon.com/IAM/latest/UserGuide/create-signed-request.html

awskit-0.0.0/awesome/interfaces/__init__.py

@@ -0,0 +1,5 @@
+from .dynamodb import DynamoDb
+from .sg import SecurityGroup
+from .sqs import Sqs
+from .subnet import Subnet
+from .vpc import Vpc

awskit-0.0.0/awesome/interfaces/dynamodb.py

@@ -0,0 +1,5 @@
+from lib.interface import AwsInterface
+
+
+class DynamoDb(AwsInterface):
+    pass

awskit-0.0.0/awesome/interfaces/s3.py

@@ -0,0 +1,14 @@
+from lib.interface import AwsInterface
+
+
+class S3(AwsInterface):
+
+    def __init__(self):
+        super().__init__("s3", "2006-03-01")
+    
+    def CreateBucket(self, region: str, **kwargs) -> dict:
+        """
+        """
+
+        resp = self.post(region, "CreateBucket", **kwargs)
+        return resp["CreateSecurityGroupResponse"]

awskit-0.0.0/awesome/interfaces/sg.py

@@ -0,0 +1,31 @@
+from lib.interface import AwsInterface
+
+
+class SecurityGroup(AwsInterface):
+
+    def __init__(self):
+        super().__init__("ec2", "2016-11-15")
+    
+    def CreateSecurityGroup(self, region: str, **kwargs) -> dict:
+        """
+        Given a region and request arguments, creates a security group
+        """
+
+        resp = self.post(region, "CreateSecurityGroup", **kwargs)
+        return resp["CreateSecurityGroupResponse"]
+
+    def DescribeSecurityGroups(self, region: str) -> list:
+        """
+        Given a region, returns a list of all security groups available in that region
+        """
+
+        resp = self.get(region, "DescribeSecurityGroups")
+        return resp["DescribeSecurityGroupsResponse"]
+
+    def DeleteSecurityGroup(self, region: str, **kwargs) -> dict:
+        """
+        Given a region and request arguments, deletes a security group
+        """
+
+        resp = self.post(region, "DeleteSecurityGroup", **kwargs)
+        return resp["DeleteSecurityGroupResponse"]

awskit-0.0.0/awesome/interfaces/sqs.py

@@ -0,0 +1,59 @@
+from lib.interface import AwsInterface
+
+
+class Sqs(AwsInterface):
+
+    def __init__(self):
+        super().__init__("sqs", "2012-11-05")
+
+    def CreateQueue(self, region: str, **kwargs) -> dict:
+        """
+        Given a region and request arguments, creates a queue
+
+        QueueName
+        """
+
+        resp = self.post(region, "CreateQueue", **kwargs)
+        return resp["CreateQueueResponse"]
+
+    def ListQueues(self, region: str) -> list:
+        """
+        Given a region, returns a list of all queues available in that region
+        """
+
+        resp = self.get(region, "ListQueues")
+        return resp["ListQueuesResponse"]
+
+    def DeleteQueue(self, region: str, **kwargs) -> dict:
+        """
+        Given a region and request arguments, deletes a queue
+
+        QueueUrl
+        """
+
+        resp = self.post(region, "DeleteQueue", **kwargs)
+        return resp["DeleteQueueResponse"]
+
+    def SendMessage(self, region: str, **kwargs) -> dict:
+        """
+        Given a region and request arguments, sends a message
+        """
+
+        resp = self.post(region, "SendMessage", **kwargs)
+        return resp["SendMessageResponse"]
+    
+    def ReceiveMessage(self, region: str, **kwargs) -> dict:
+        """
+        Given a region and request arguments, receives a message
+        """
+
+        resp = self.post(region, "ReceiveMessage", **kwargs)
+        return resp["ReceiveMessageResponse"]
+
+    def DeleteMessage(self, region: str, **kwargs) -> dict:
+        """
+        Given a region and request arguments, deletes a message
+        """
+
+        resp = self.post(region, "DeleteMessage", **kwargs)
+        return resp["DeleteMessageResponse"]

awskit-0.0.0/awesome/interfaces/subnet.py

@@ -0,0 +1,31 @@
+from lib.interface import AwsInterface
+
+
+class Subnet(AwsInterface):
+
+    def __init__(self):
+        super().__init__("ec2", "2016-11-15")
+
+    def CreateSubnet(self, region: str, **kwargs) -> dict:
+        """
+        Given a region and request arguments, creates a subnet
+        """
+
+        resp = self.post(region, "CreateSubnet", **kwargs)
+        return resp["CreateSubnetResponse"]
+
+    def DescribeSubnets(self, region: str) -> list:
+        """
+        Given a region, returns a list of all subnets available in that region
+        """
+
+        resp = self.get(region, "DescribeSubnets")
+        return resp["DescribeSubnetsResponse"]
+
+    def DeleteSubnet(self, region: str,**kwargs) -> dict:
+        """
+        Given a region and request arguments, deletes a subnet
+        """
+
+        resp = self.post(region, "DeleteSubnet", **kwargs)
+        return resp["DeleteSubnetResponse"]

awskit-0.0.0/awesome/interfaces/vpc.py

@@ -0,0 +1,31 @@
+from lib.interface import AwsInterface
+
+
+class Vpc(AwsInterface):
+
+    def __init__(self):
+        super().__init__("ec2", "2016-11-15")
+
+    def CreateVpc(self, region: str, **kwargs) -> dict:
+        """
+        Given a region and request arguments, creates a VPC
+        """
+
+        resp = self.post(region, "CreateVpc", **kwargs)
+        return resp["CreateVpcResponse"]
+
+    def DescribeVpcs(self, region: str) -> list:
+        """
+        Given a region, returns a list of all VPCs available in that region
+        """
+
+        resp = self.get(region, "DescribeVpcs")
+        return resp["DescribeVpcsResponse"]
+
+    def DeleteVpc(self, region: str,**kwargs) -> dict:
+        """
+        Given a region and request arguments, deletes a VPC
+        """
+
+        resp = self.post(region, "DeleteVpc", **kwargs)
+        return resp["DeleteVpcResponse"]

awskit-0.0.0/awesome/lib/auth.py

@@ -0,0 +1,123 @@
+import os
+import datetime
+import hashlib
+import hmac
+
+from requests.auth import AuthBase
+from requests.compat import urlparse
+
+
+class AwsAuth(AuthBase):
+    """
+    AWS Authentification using AWS Signature Version 4
+    """
+
+    def __init__(self, service: str, region: str):
+        """
+        Parameters
+        service: AWS service name
+        region: AWS region name
+        """
+
+        self.service = service
+        self.region = region
+
+    def __call__(self, request):
+        """
+        Parameters
+        request: request to be signed
+        """
+
+        now = datetime.datetime.utcnow()
+
+        amz_date = now.strftime("%Y%m%dT%H%M%SZ")
+        datestamp = now.strftime("%Y%m%d")
+
+        url = urlparse(request.url)
+
+        if "Host" not in request.headers:
+            request.headers["Host"] = url.hostname
+
+        if "Content-Type" not in request.headers:
+            request.headers["Content-Type"] = (
+                "application/x-www-form-urlencoded; charset=utf-8"
+            )
+
+        if request.method == "GET":
+            payload_hash = hashlib.sha256("".encode("utf-8")).hexdigest()
+        else:
+            if request.body:
+                if isinstance(request.body, bytes):
+                    payload_hash = hashlib.sha256(request.body).hexdigest()
+                else:
+                    payload_hash = hashlib.sha256(
+                        request.body.encode("utf-8")
+                    ).hexdigest()
+            else:
+                payload_hash = hashlib.sha256(b"").hexdigest()
+
+        request.headers["x-amz-content-sha256"] = payload_hash
+        request.headers["X-AMZ-Date"] = amz_date
+
+        headers_to_sign = sorted(
+            (
+                header
+                for header in (header.lower() for header in request.headers.keys())
+                if header.startswith("x-amz-") or header == "host"
+            )
+        )
+
+        canonical_headers = "".join(
+            (f"{header}:{request.headers[header]}\n" for header in headers_to_sign)
+        )
+
+        canonical_query_string = "&".join(
+            ("=".join(t) for t in sorted((s.split("=") for s in url.query.split("&"))))
+        )
+
+        signed_headers = ";".join(headers_to_sign)
+
+        canonical_request = (
+            f"{request.method}\n"
+            f"{url.path}\n"
+            f"{canonical_query_string}\n"
+            f"{canonical_headers}\n"
+            f"{signed_headers}\n"
+            f"{payload_hash}"
+        )
+
+        credential_scope = f"{datestamp}/{self.region}/{self.service}/aws4_request"
+
+        string_to_sign = (
+            "AWS4-HMAC-SHA256\n"
+            f"{amz_date}\n"
+            f"{credential_scope}\n"
+            f"{hashlib.sha256(canonical_request.encode('utf-8')).hexdigest()}"
+        ).encode("utf-8")
+
+        k_key = f"AWS4{os.getenv('AWS_SECRET_ACCESS_KEY')}".encode("utf-8")
+        k_date = self.sign_msg(k_key, datestamp)
+        k_region = self.sign_msg(k_date, self.region)
+        k_service = self.sign_msg(k_region, self.service)
+        k_signing = self.sign_msg(k_service, "aws4_request")
+        signature = hmac.new(k_signing, string_to_sign, hashlib.sha256).hexdigest()
+
+        request.headers["Authorization"] = (
+            "AWS4-HMAC-SHA256 Credential="
+            f"{os.getenv('AWS_ACCESS_KEY_ID')}/{credential_scope}, "
+            f"SignedHeaders={signed_headers}, "
+            f"Signature={signature}"
+        )
+
+        return request
+
+    def sign_msg(self, key: str, msg: str) -> str:
+        """
+        Given a key and a message returns a hash-based message authentication code
+
+        Parameters
+        key: key to be used for encryption
+        msg: message to be signed by the key
+        """
+
+        return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()

awskit-0.0.0/awesome/lib/interface.py

@@ -0,0 +1,114 @@
+import requests
+import xmltodict
+
+from lib.auth import AwsAuth
+
+
+class AwsInterface:
+
+    def __init__(self, service, version):
+        self.service = service
+        self.version = version
+
+    def post(self, region: str, action: str, **kwargs) -> dict:
+        """
+        Creates a POST request to AWS API
+
+        Parameters
+        region: geographic location
+        action: request action
+        """
+
+        return self._request("POST", region, action, **kwargs)
+
+    def get(self, region: str, action: str, **kwargs) -> dict:
+        """
+        Creates a GET request to AWS API
+
+        Parameters
+        region: geographic location
+        action: request action
+        """
+
+        return self._request("GET", region, action, **kwargs)
+
+    def _request(self, method: str, region: str, action: str, **kwargs) -> dict:
+        """
+        Creates a request to AWS API
+
+        Parameters
+        method: request method
+        region: geographic location
+        action: request action
+        """
+
+        auth = AwsAuth(self.service, region)
+        url = f"https://{self.service}.{region}.amazonaws.com"
+
+        if method == "GET":
+            params = self._params(action, **kwargs)
+            response = requests.request(method=method, auth=auth, url=url, params=params)
+            return self._parse(response)
+
+        elif method == "POST":
+            data = self._data(action, **kwargs)
+            response = requests.request(method=method, auth=auth, url=url, data=data)
+            return self._parse(response)
+
+    def _parse(self, response: requests.Response) -> dict:
+        """
+        Returns a parsed dictionary
+        """
+
+        data = xmltodict.parse(response.text)
+
+        if response.status_code != 200:
+
+            print(data)
+
+            if "Response" in data:
+                raise Exception(
+                    data["Response"]
+                    .get("Errors", {})
+                    .get("Error", {})
+                    .get("Message", "")
+                )
+
+            elif "ErrorResponse" in data:
+                raise Exception(
+                    data["ErrorResponse"]
+                    .get("Error", {})
+                    .get("Message", "")
+                )
+            
+            elif "Error" in data:
+                raise Exception(
+                    data["Error"].
+                    get("Message", "")
+                )
+
+            raise Exception("Failed to parse error message")
+
+        return data
+
+    def _data(self, action: str, **kwargs) -> dict:
+        """
+        Returns data dictionary
+        """
+
+        data = {"Version": self.version, "Action": action}
+
+        data.update(kwargs)
+
+        return data
+
+    def _params(self, action: str, **kwargs) -> str:
+        """
+        Returns URL query parameters
+        """
+
+        params = [f"Version={self.version}", f"Action={action}"]
+
+        params.extend([f"{key}={value}" for key, value in kwargs.items()])
+
+        return "&".join(params)

awskit-0.0.0/awskit.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: awskit
+Version: 0.0.0
+Author: André Bienemann
+Author-email: andre.bienemann@gmail.com
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: dev
+Provides-Extra: docs

awskit-0.0.0/awskit.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+setup.py
+awesome/interfaces/__init__.py
+awesome/interfaces/dynamodb.py
+awesome/interfaces/s3.py
+awesome/interfaces/sg.py
+awesome/interfaces/sqs.py
+awesome/interfaces/subnet.py
+awesome/interfaces/vpc.py
+awesome/lib/auth.py
+awesome/lib/interface.py
+awskit.egg-info/PKG-INFO
+awskit.egg-info/SOURCES.txt
+awskit.egg-info/dependency_links.txt
+awskit.egg-info/requires.txt
+awskit.egg-info/top_level.txt

awskit-0.0.0/awskit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

awskit-0.0.0/awskit.egg-info/requires.txt

@@ -0,0 +1,11 @@
+
+[dev]
+black
+coverage
+isort
+twine
+wheel
+
+[docs]
+mkdocs
+mkdocs-material

awskit-0.0.0/awskit.egg-info/top_level.txt

@@ -0,0 +1 @@
+awesome

awskit-0.0.0/setup.cfg

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

awskit-0.0.0/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup
+
+setup(
+    name="awskit",
+    version="0.0.0",
+    author="André Bienemann",
+    author_email="andre.bienemann@gmail.com",
+    extras_require={
+        "dev": [
+            "black",
+            "coverage",
+            "isort",
+            "twine",
+            "wheel",
+        ],
+        "docs": [
+            "mkdocs",
+            "mkdocs-material",
+        ],
+    },
+    classifiers=[
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+)