python-postman 0.3.0__tar.gz → 0.6.0__tar.gz

python_postman-0.6.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.1
+Name: python-postman
+Version: 0.6.0
+Summary: Pypostman allows users to parse postman environments and postman collections.
+Author: Data Engineering Team
+Author-email: DataEngineering@loves.com
+Requires-Python: >=3.8.1,<4.0.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: boto3 (>=1.34.67,<2.0.0)
+Requires-Dist: cryptography (>=42.0.5,<43.0.0)
+Requires-Dist: logbook (>=1.7.0.post0,<2.0.0)
+Requires-Dist: pendulum (>=3.0.0,<4.0.0)
+Requires-Dist: pydantic (>=2.6.4,<3.0.0)
+Requires-Dist: pytz (>=2024.1,<2025.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: urllib3 (>=1.25.4,<2.0.0)
+Description-Content-Type: text/markdown
+
+# Python Postman
+
+**pypostman** is a command-line interface that allows to `automate` multiple api calls from postman collections, additionally it also allow you to `compress` and `save` the response to a local directory or to an AWS S3 bucket.
+Thereby allowing you to manage your api calls using postman, then `automate` and `process` their response using python.
+
+Example:
+
+```
+https://github.com/yudiell/energy-apis
+```
+
+### Included Modules
+- http.py
+- logger.py
+
+## Installation
+See the example.
+
+### Python >= 3.8.1
+
+Pypi:
+  ```  
+  pip install python-postman
+  ```
+
+## How to Use It
+
+See example
+

python_postman-0.6.0/README.md

@@ -0,0 +1,28 @@
+# Python Postman
+
+**pypostman** is a command-line interface that allows to `automate` multiple api calls from postman collections, additionally it also allow you to `compress` and `save` the response to a local directory or to an AWS S3 bucket.
+Thereby allowing you to manage your api calls using postman, then `automate` and `process` their response using python.
+
+Example:
+
+```
+https://github.com/yudiell/energy-apis
+```
+
+### Included Modules
+- http.py
+- logger.py
+
+## Installation
+See the example.
+
+### Python >= 3.8.1
+
+Pypi:
+  ```  
+  pip install python-postman
+  ```
+
+## How to Use It
+
+See example

python_postman-0.6.0/pyproject.toml

@@ -0,0 +1,59 @@
+[tool.poetry]
+name = "python-postman"
+version = "0.6.0"
+description = "Pypostman allows users to parse postman environments and postman collections."
+authors = ["Data Engineering Team <DataEngineering@loves.com>"]
+readme = "README.md"
+
+[tool.isort]
+profile = "black"
+
+
+[tool.poetry.dependencies]
+python = "^3.8.1"
+requests = "^2.32.3"
+pyyaml = "^6.0.1"
+pydantic = "^2.6.4"
+cryptography = "^42.0.5"
+urllib3 = "^1.25.4"
+logbook = "^1.7.0.post0"
+pendulum = "^3.0.0"
+boto3 = "^1.34.67"
+pytz = "^2024.1"
+
+
+[tool.poetry.group.lint.dependencies]
+flake8-annotations = "^3.0.1"
+flake8-builtins = "^2.1.0"
+flake8-docstrings = "^1.7.0"
+flake8-eradicate = "^1.5.0"
+flake8-future-annotations = "^1.1.0"
+flake8-isort = "^6.0.0"
+flake8-new-union-types = "^0.4.1"
+flake8-pep585 = "^0.1.7"
+flake8-secure-coding-standard = "^1.4.0"
+flake8-type-checking = "^2.4.1"
+flake8-use-pathlib = "^0.3.0"
+flake8-variables-names = "^0.0.6"
+pep8-naming = "^0.13.3"
+black = "^24.3.0"
+isort = "^5.12.0"
+pip-audit = "^2.6.1"
+mypy = "^1.9.0"
+
+
+[tool.poetry.group.test.dependencies]
+pytest = "^7.4.0"
+
+
+[tool.poetry.group.dev.dependencies]
+pre-commit = "^3.3.3"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.poetry.scripts]
+pypostman = "pypostman.__main__:main"

python_postman-0.6.0/src/python_postman/body.py

@@ -0,0 +1,33 @@
+from typing import Dict
+from .config import Body
+
+
+class Body:
+    def __init__(self, body: Body) -> None:
+        self.mode = body.mode
+        self.raw = body.raw
+        self.options = body.options
+        self.formdata = body.formdata
+        self.urlencoded = body.urlencoded
+
+    @property
+    def urlencoded_as_dict(self) -> Dict[str, str]:
+        if not self.urlencoded:
+            return None
+
+        body = {}
+        for option in self.urlencoded:
+            if not option.get("disabled", False):
+                body[option["key"]] = option["value"]
+        return body
+
+    @property
+    def formdata_as_dict(self) -> Dict[str, str]:
+        if not self.formdata:
+            return None
+
+        body = {}
+        for option in self.formdata:
+            if not option.get("disabled", False):
+                body[option["key"]] = option["value"]
+        return body

python_postman-0.6.0/src/python_postman/config.py

@@ -0,0 +1,110 @@
+from typing import List, Dict, Union, Optional
+from pydantic import Field, BaseModel
+
+
+class Info(BaseModel):
+    postman_id: str = Field(None, alias="_postman_id")
+    name: str
+    postman_schema: str = Field(None, alias="schema")
+    exporter_id: str = Field(None, alias="_exporter_id")
+
+
+# Variable Related Objects
+class Variables(BaseModel):
+    key: Optional[str] = None
+    value: Optional[str] = None
+    type: Optional[str] = None
+    disabled: Optional[bool] = None
+
+
+# Auth Related Objects
+class AuthValues(BaseModel):
+    key: str
+    value: str
+    type: str
+    disabled: Optional[bool] = None
+
+
+class Auth(BaseModel):
+    type: str
+    noauth: Optional[List[AuthValues]] = None
+    basic: Optional[List[AuthValues]] = None
+    apikey: Optional[List[AuthValues]] = None
+    bearer: Optional[List[AuthValues]] = None
+
+
+# Collection and Request Related Objects
+class Script(BaseModel):
+    type: Optional[str] = None
+    exec: List[str]
+
+
+class Event(BaseModel):
+    listen: Optional[str] = None
+    script: Optional[Script] = None
+
+
+# Request Related Objects
+class Header(BaseModel):
+    key: Optional[str] = None
+    value: Optional[str] = None
+    description: Optional[str] = None
+    disabled: Optional[bool] = None
+
+
+class Variable(BaseModel):
+    key: Optional[str] = None
+    value: Optional[str] = None
+    description: Optional[str] = None
+
+
+class Param(BaseModel):
+    key: Optional[str] = None
+    value: Optional[str] = None
+    description: Optional[str] = None
+    disabled: Optional[bool] = None
+
+
+class Body(BaseModel):
+    mode: Optional[str] = None
+    raw: Optional[str] = None
+    formdata: Optional[List[Dict[str, Union[str, bool]]]] = None
+    urlencoded: Optional[List[Dict[str, Union[str, bool]]]] = None
+    options: Optional[Dict[str, Dict[str, Union[str, bool]]]] = None
+
+
+class Url(BaseModel):
+    raw: Optional[str] = None
+    protocol: Optional[str] = None
+    host: Optional[List[str]] = None
+    path: Optional[List[str]] = None
+    variable: Optional[List[Variable]] = None
+    query: Optional[List[Param]] = None
+
+
+class Request(BaseModel):
+    auth: Optional[Auth] = None
+    method: str
+    headers: List[Header] = Field(None, alias="header")
+    url: Optional[Url] = None
+    body: Optional[Body] = None
+
+
+# Collection Related Objects
+class Item(BaseModel):
+    name: str
+    item: Optional[List["Item"]] = None
+    events: Optional[List[Event]] = Field(None, alias="event")
+    request: Optional[Request] = None
+
+    @property
+    def type(self):
+        return "request" if self.request else "folder"
+
+
+class Config(BaseModel):
+    info: Optional[Info] = None
+    items: Optional[List[Item]] = Field(None, alias="item")
+    variables: Optional[List[Variables]] = Field(None, alias="variable")
+    events: Optional[List[Event]] = Field(None, alias="event")
+    auth: Optional[Auth] = None

{python-postman-0.3.0/pypostman → python_postman-0.6.0/src/python_postman}/environment.py

@@ -10,7 +10,7 @@ from .template import CustomTemplate
 class Variable(BaseModel):
     key: str
     value: str
-    type: Optional[str]
+    type: Optional[str] = None
     enabled: bool
 
 

{python-postman-0.3.0/pypostman → python_postman-0.6.0/src/python_postman}/modules/http.py

@@ -1,5 +1,6 @@
 import os
 import json
+import re
 from requests import Session, Response
 from urllib3 import Timeout
 
@@ -21,46 +22,48 @@ class Request(Session):
         self.timeout: Timeout = timeout
         self.stream: bool = stream
         self.url: str = self._request.url.base_url
+        self.body = None
+        self.prepare_cookies = None
 
-    def set_params(self, params: dict):
+    def set_headers(self, headers: dict):
         """
-        Set URL parameters on the request object.
+        Set the headers of the request.
 
         Args:
-            params (dict): Parameters to set on the request object.
+            headers (dict): The headers to set.
 
         Returns:
             None
         """
-        if self._request.url.params:
-            text = json.dumps(self._request.url.params)
-            template: str = CustomTemplate(text).safe_substitute(params)
-            params = {
+        if self._request.headers:
+            text = json.dumps(self._request.headers.as_dict)
+            template: str = CustomTemplate(text).safe_substitute(headers)
+            headers = {
                 key: value
                 for key, value in json.loads(template).items()
                 if "${" not in value
             }
-            self.params = params
+            self.headers = headers
 
-    def set_headers(self, headers: dict):
+    def set_params(self, params: dict):
         """
-        Set the headers of the request.
+        Set URL parameters on the request object.
 
         Args:
-            headers (dict): The headers to set.
+            params (dict): Parameters to set on the request object.
 
         Returns:
             None
         """
-        if self._request.headers:
-            text = json.dumps(self._request.headers.as_dict)
-            template: str = CustomTemplate(text).safe_substitute(headers)
-            headers = {
+        if self._request.url.params:
+            text = json.dumps(self._request.url.params)
+            template: str = CustomTemplate(text).safe_substitute(params)
+            params = {
                 key: value
                 for key, value in json.loads(template).items()
                 if "${" not in value
             }
-            self.headers = headers
+            self.params = params
 
     def set_path_vars(self, path_variables: dict):
         """
@@ -77,6 +80,62 @@ class Request(Session):
             path: str = CustomTemplate(request_url).safe_substitute(path_variables)
             self.url = path
 
+    def set_body(self, body: dict, with_quuotes: bool = True):
+        """
+        Set body payload.
+
+        Args:
+            body (dict): Parameters to set on the request object.
+            with_quotes (bool) default=True: Add/remove quotes on body parameters.
+        Returns:
+            None
+        """
+        # The pattern looks for ${...} that's not surrounded by quotes
+        pattern = r'(?<!")(\$\{[^}]+\})(?!")'
+        # Replacement pattern that adds quotes around the matched pattern
+        if with_quuotes:
+            replacement = r'"\1"'
+        else:
+            replacement = r"\1"
+        raw = (
+            re.sub(pattern, replacement, self._request.body.raw)
+            if self._request.body.raw
+            else None
+        )
+
+        formdata = (
+            json.dumps(self._request.body.formdata_as_dict)
+            if self._request.body.formdata_as_dict
+            else None
+        )
+
+        urlencoded = (
+            json.dumps(self._request.body.urlencoded_as_dict)
+            if self._request.body.urlencoded_as_dict
+            else None
+        )
+
+        options_list = [
+            formdata,
+            urlencoded,
+        ]
+        options = next(
+            (option for option in options_list if option is not None),
+            ModuleNotFoundError,
+        )
+        if self._request.body.formdata or self._request.body.urlencoded:
+            text = options
+            template: str = CustomTemplate(text).safe_substitute(body)
+            items = {
+                key: value
+                for key, value in json.loads(template).items()
+                if "${" not in value
+            }
+            self.body = items
+        else:
+            substitute_body: str = CustomTemplate(raw).safe_substitute(body)
+            self.body = substitute_body
+
     def substitute_bearer_token(self) -> None:
         if self._request.auth and self._request.auth.type == "bearer":
             self._request.auth.http_auth.token = CustomTemplate(
@@ -100,13 +159,13 @@ class Request(Session):
             url = self.url
             headers = self._request.headers.as_dict
             params = self.params
-            data = request.body.raw if request.body else None
+            data = self.body
             timeout = self.timeout
             stream = self.stream
             auth = request.auth.http_auth
+            prepare_cookies = self.prepare_cookies
 
             self.log.request(url=url)
-
             response = session.request(
                 auth=auth,
                 method=method,
@@ -116,6 +175,7 @@ class Request(Session):
                 data=data,
                 stream=stream,
                 timeout=timeout,
+                cookies=prepare_cookies,
             )
 
             if response.ok:

{python-postman-0.3.0/pypostman → python_postman-0.6.0/src/python_postman}/utils/cli.py

@@ -7,7 +7,7 @@ class Cli:
 
     @property
     def envs(self):
-        envs: list = ["temp", "dev", "prod"]
+        envs: list = ["temp", "dev", "prod", "qa"]
         return envs
 
     def parse_arguments(self):
@@ -28,13 +28,33 @@ class Cli:
             required=False,
             help="Tag that determines which tagged flow runs, select from the flows corresponding model flow.",
         )
+
+        parser.add_argument(
+            "--select",
+            metavar="SELECT",
+            type=str,
+            nargs="*",
+            required=False,
+            help="Select allows you to select multiple tags, ex: --select tag:tag1 tag:tag2 tag:tag3",
+            default=[],
+        )
+
+        parser.add_argument(
+            "--args",
+            metavar="ARGS",
+            type=str,
+            nargs="*",
+            required=False,
+            help="Additional arguments to pass to the flow, ex: --args arg1 arg2 arg3",
+            default=[],
+        )
+
         parser.add_argument(
             "-r",
             "--refresh",
             type=str,
             required=False,
-            help="",
-            choices=["full"],
+            help="Add a date to refresh the data.",
         )
         # get args
         args = parser.parse_args()

python_postman-0.6.0/src/python_postman/utils/load_dotenvc.py

@@ -0,0 +1,101 @@
+"""
+This script provides functionalities for encrypting a file and decrypting an AES encrypted file.
+The decrypted file's contents are then loaded into the environment using the dotenv library.
+"""
+
+import os
+import argparse
+import pyAesCrypt
+from getpass import getpass
+from dotenv import load_dotenv
+
+from pypostman.modules.logger import Log
+
+log = Log()  # Initialize the logger
+
+
+def parse_arguments(description, arguments):
+    """
+    Parses command line arguments.
+
+    Parameters:
+    description (str): Description of the command line program.
+    arguments (list): A list of tuples, where each tuple is an argument in the format (short_option, long_option, description).
+
+    Returns:
+    argparse.Namespace: The parsed command line arguments.
+    """
+    parser = argparse.ArgumentParser(description=description)
+    for argument in arguments:
+        parser.add_argument(
+            argument[0], argument[1], type=str, required=True, help=argument[2]
+        )
+    return parser.parse_args()
+
+
+def encrypt_file():
+    """
+    Encrypts a file with AES encryption. The password and file path are provided as command line arguments.
+    """
+    args = parse_arguments(
+        "Encrypt a file",
+        [
+            ("-p", "--password", "The password to encrypt the file"),
+            ("-f", "--file", "The path to the file to encrypt"),
+        ],
+    )
+    filepath = args.file
+    password = args.password
+    bufferSize = 64 * 1024  # Encryption/decryption buffer size
+    confirm_password = getpass("Please confirm your password: ")
+
+    if password != confirm_password:
+        log.error("Passwords do not match!")
+        return
+
+    encrypted_filepath = filepath + ".aes"  # Generate encrypted file path
+    pyAesCrypt.encryptFile(
+        filepath, encrypted_filepath, password, bufferSize
+    )  # Encrypt the file
+
+    try:
+        log.info(
+            f"Encrypted file: {encrypted_filepath}"
+        )  # Log the path of the encrypted file
+    except ValueError as ve:
+        log.error(ve)
+
+
+def decrypt_and_loadenv(password: str, filepath: str, remove_decrypted: bool = True):
+    """
+    Decrypts an AES encrypted file and loads its contents to the environment using the dotenv library.
+
+    Parameters:
+    password (str): The password to decrypt the AES encrypted file.
+    filepath (str): The path to the AES encrypted file that needs to be decrypted.
+    remove_decrypted (bool): A flag that, if True, removes the decrypted file after its contents are loaded to the environment.
+                             Default value is True. If False, the decrypted file will remain in the file system,
+                             and its path will be logged.
+    """
+    bufferSize = 64 * 1024  # Encryption/decryption buffer size
+    decrypted_filepath = filepath.replace(".aes", "")  # Generate decrypted file path
+
+    try:
+        pyAesCrypt.decryptFile(
+            filepath, decrypted_filepath, password, bufferSize
+        )  # Decrypt the file
+        load_dotenv(
+            dotenv_path=decrypted_filepath
+        )  # Load the decrypted content to environment
+    except Exception as e:
+        log.error(f"An error occurred during decryption: {str(e)}")
+        return
+
+    if remove_decrypted:
+        os.remove(decrypted_filepath)  # Remove the decrypted file
+    else:
+        log.info(decrypted_filepath)  # Log the path of the decrypted file
+
+
+if __name__ == "__main__":
+    encrypt_file()