pax_global_header00006660000000000000000000000064146512764330014525gustar00rootroot0000000000000052 comment=d5547dad87ba05eba3121911fc58a36cc0910a85 python-postman-python-postman-release/000077500000000000000000000000001465127643300205055ustar00rootroot00000000000000python-postman-python-postman-release/.github/000077500000000000000000000000001465127643300220455ustar00rootroot00000000000000python-postman-python-postman-release/.github/workflows/000077500000000000000000000000001465127643300241025ustar00rootroot00000000000000python-postman-python-postman-release/.github/workflows/python-publish.yml000066400000000000000000000020741465127643300276150ustar00rootroot00000000000000# This workflow will upload a Python Package using Twine when a release is created # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries # This workflow uses actions that are not certified by GitHub. # They are provided by a third-party and are governed by # separate terms of service, privacy policy, and support # documentation. name: Upload Python Package on: release: types: [published] permissions: contents: read jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Set up Python uses: actions/setup-python@v3 with: python-version: '3.x' - name: Install dependencies run: | python -m pip install --upgrade pip pip install build - name: Build package run: python -m build - name: Publish package uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29 with: user: __token__ password: ${{ secrets.PYPI_API_TOKEN }} python-postman-python-postman-release/.gitignore000066400000000000000000000034221465127643300224760ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ pip-wheel-metadata/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # PEP 582; used by e.g. github.com/David-OConnor/pyflow __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ .DS_Store python-postman-python-postman-release/LICENSE000066400000000000000000000020501465127643300215070ustar00rootroot00000000000000MIT License Copyright (c) 2022 Yudiell Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. python-postman-python-postman-release/README.md000066400000000000000000000011671465127643300217710ustar00rootroot00000000000000# 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-python-postman-release/pyproject.toml000066400000000000000000000023721465127643300234250ustar00rootroot00000000000000[tool.poetry] name = "python-postman" version = "0.6.0" description = "Pypostman allows users to parse postman environments and postman collections." authors = ["Data Engineering Team "] 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-python-postman-release/src/000077500000000000000000000000001465127643300212745ustar00rootroot00000000000000python-postman-python-postman-release/src/python_postman/000077500000000000000000000000001465127643300243565ustar00rootroot00000000000000python-postman-python-postman-release/src/python_postman/__init__.py000066400000000000000000000000001465127643300264550ustar00rootroot00000000000000python-postman-python-postman-release/src/python_postman/__main__.py000066400000000000000000000006741465127643300264570ustar00rootroot00000000000000from typing import List from pypostman import postman from .environment import Environment from .collection import Collection def main(): environments_dir = "pypostman/environments" environments: List[Environment] = postman._get_environments(dir=environments_dir) collections_dir = "pypostman/collections" collections: List[Collection] = postman._get_collections(dir=collections_dir) if __name__ == "__main__": main() python-postman-python-postman-release/src/python_postman/auth.py000066400000000000000000000045151465127643300256760ustar00rootroot00000000000000from requests.auth import HTTPBasicAuth, AuthBase from .config import Auth as ConfigAuth class BearerAuth(AuthBase): def __init__(self, token): self.token = token def __call__(self, r): r.headers["Authorization"] = f"Bearer {self.token}" return r class ApiKeyAuth(AuthBase): def __init__(self, apikey): self.apikey = apikey def __call__(self, r): """ The postman collection auth determines where the apikey should be applied. 1. Query: Is to be added to the query params. 2. Header: Is to be added to the header. The postman collection auth apikey is to be applied to - the query params if the auth api key contains the key "in". """ key = self.apikey["key"] value = self.apikey["value"] if self.apikey.get("in") is not None: r.prepare_url(url=r.url, params={key: value}) else: r.headers[key] = value return r class Auth: def __init__(self, auth: ConfigAuth): self.type = auth.type if auth else None self.__auth_config = ( auth.noauth or auth.basic or auth.apikey or auth.bearer if auth else None ) self.http_auth = ( self.noauth or self.basic or self.apikey or self.bearer if auth else None ) @property def noauth(self) -> None: if self.__auth_config and self.type == "noauth": return None @property def basic(self) -> HTTPBasicAuth: if self.__auth_config and self.type == "basic": basic = {} for item in self.__auth_config: basic[item.key] = item.value # print(basic) return HTTPBasicAuth(username=basic["username"], password=basic["password"]) @property def apikey(self) -> ApiKeyAuth: if self.__auth_config and self.type == "apikey": apikey = {} for item in self.__auth_config: apikey[item.key] = item.value return ApiKeyAuth(apikey=apikey) @property def bearer(self) -> BearerAuth: if self.__auth_config and self.type == "bearer": bearer = {} for item in self.__auth_config: bearer[item.key] = item.value # print(bearer) return BearerAuth(token=bearer["token"]) python-postman-python-postman-release/src/python_postman/body.py000066400000000000000000000015651465127643300256740ustar00rootroot00000000000000from 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-python-postman-release/src/python_postman/collection.py000066400000000000000000000025621465127643300270700ustar00rootroot00000000000000import os import json from pathlib import Path from .config import Config from .variable import Variables from .auth import Auth from .event import Events from .item import Items from .template import CustomTemplate class Collection: def __init__(self, collection_file) -> None: with open(Path(collection_file)) as file: text = file.read().replace("{{", "${").replace("}}", "}") template: str = CustomTemplate(text).safe_substitute(os.environ) data: dict = json.loads(template) self._template = template self._collection = Config(**data) self._info = self._collection.info self._variables: Variables = Variables(variables=self._collection.variables) self._auth: Auth = Auth(auth=self._collection.auth) self._events = Events(events=self._collection.events) self._test = self._events.test self._prerequest = self._events.prerequest self._items: Items = Items(items=self._collection.items) self._requests = self._items.requests() for request in self._requests: request.auth = self._auth if not request.auth else request.auth if request.url: template: str = CustomTemplate(request.url.base).safe_substitute( self._variables.as_dict ) request.url.base_url = template python-postman-python-postman-release/src/python_postman/config.py000066400000000000000000000054301465127643300261770ustar00rootroot00000000000000from 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-python-postman-release/src/python_postman/environment.py000066400000000000000000000067171465127643300273070ustar00rootroot00000000000000import os import json from typing import List, Optional, Dict from pydantic import Field, BaseModel from pathlib import Path from .template import CustomTemplate class Variable(BaseModel): key: str value: str type: Optional[str] = None enabled: bool class Environment(BaseModel): """ Examples # Load Environment environment: Environment = Environment.load("environment.json") # Access Properties print(environment.id) # Environment Id print(environment.name) # Environment Name print(environment.variables[0].key) # First Variable Key # As Dictionary variables_as_dict: dict = environment.variables_as_dict print(variables_as_dict) # {'key': 'value'} """ id: str name: str postman_variable_scope: str = Field(None, alias="_postman_variable_scope") postman_exported_at: str = Field(None, alias="_postman_exported_at") postman_exported_using: str = Field(None, alias="_postman_exported_using") variables: List[Variable] = Field(None, alias="values") def load(environment_file: str) -> "Environment": """ Loads a Postman environment.json file. Replaces the postman {{var}} with a python ${var} ready for use with - string template. Replaces ${VAR} with os environment variables. The os env variables must match the ${VAR} name. Unpacs the environment json to an Environment. Returns an Environment Object. """ assert ( ".postman_environment.json" in environment_file ), f"File Error: {environment_file} - Please verify that you are using a postman_envrionment file." def replace(json_data: str) -> str: """ This function takes a string of JSON data and replaces the the variable value with the variable key if the variable name is value - if the variable is enabled otherwise if the variable is disabled it will not be included in the return JSON data string. This behaviour is similar to the behaviour implemented on the Postman Envrironments Returns a JSON data string. """ data: dict = json.loads(json_data) for variable in data["values"]: value = not variable["value"] is_enabled = bool(variable["enabled"]) replace = all([value, is_enabled]) if replace: variable["value"] = f"""${{{variable["key"]}}}""" elif not is_enabled: data["values"].remove(variable) return json.dumps(data) with open(Path(environment_file)) as file: json_data: str = file.read().replace("{{", "${").replace("}}", "}") text = replace(json_data=json_data) template: CustomTemplate = CustomTemplate(text).safe_substitute(os.environ) data: dict = json.loads(template) environment = Environment(**data) return environment @property def variables_as_dict(self) -> Dict[str, str]: """ This property returns the environment as a - python dictionary. This dictionary is used when replacing the - required parameters in the Postman Collection. """ variables: List[Variable] = self.variables variables_as_dict: dict = {} for variable in variables: variables_as_dict[variable.key] = variable.value return variables_as_dict python-postman-python-postman-release/src/python_postman/event.py000066400000000000000000000013031465127643300260460ustar00rootroot00000000000000from .config import Event from .config import Script class Events: def __init__(self, events: Event) -> None: self.events = events @property def test(self) -> Script: if not self.events: return None for event in self.events: if event.listen == "test": return event.script @property def prerequest(self) -> Script: if not self.events: return None for event in self.events: if event.listen == "prerequest": return event.script def script_as_str(self, script: Script) -> str: if not script: return None return "".join(script.exec) python-postman-python-postman-release/src/python_postman/header.py000066400000000000000000000006651465127643300261670ustar00rootroot00000000000000from typing import Dict, List from .config import Header class Headers: def __init__(self, headers: List[Header]) -> None: self.headers = headers @property def as_dict(self) -> Dict[str, str]: if not self.headers: return None headers = {} for header in self.headers: if not header.disabled: headers[header.key] = header.value return headers python-postman-python-postman-release/src/python_postman/item.py000066400000000000000000000013161465127643300256670ustar00rootroot00000000000000from typing import List from .config import Item from .request import Request class Item: def __init__(self, item: Item) -> None: self.name = item.name self.item = item.item self.events = item.events self.request = item.request self.type = item.type class Items: def __init__(self, items: List[Item]) -> None: self.items = items def requests(self) -> List[Request]: requests = [] for item in self.items: if item.request: request = Request(item=item) requests.append(request) if item.item: requests.extend(Items(items=item.item).requests()) return requests python-postman-python-postman-release/src/python_postman/modules/000077500000000000000000000000001465127643300260265ustar00rootroot00000000000000python-postman-python-postman-release/src/python_postman/modules/file.py000066400000000000000000000176541465127643300273340ustar00rootroot00000000000000import os import platform import gzip import boto3 import pytz import tempfile import glob from pathlib import PurePath from zipfile import ZipFile from typing import Iterator from datetime import datetime from .logger import Log class File: def __init__(self) -> None: self.log = Log() self.tempdir = tempfile.TemporaryDirectory() self.current_os = platform.system() def unzip(self, file: str, path: str, extn: str) -> list: """ param: file: str -> The file to be unzipped. param: path: str -> The path where the unzipped file will be written to. param: extn: str -> The unzipped file extension. Ex: csv, json Returns a file(s) list that match the extn param. """ self.log.info(f"Unzipping file: {file}") with ZipFile(file=file, mode="r") as zipfile: zipfile.extractall(path=path) files = glob.glob(f"{path}/*.{extn}") self.log.info(f"File(s) unzipped: {files}") return files def compress(self, file: str) -> str: """ gzip the imput temp file. returns the filename. """ if self.current_os == "Windows": with gzip.open(f"{file}.gz", "wb") as compressed: chunks = self.read_file_in_chunks(file=file, n=10000) for chunk in chunks: compressed.write(chunk) self.log.info(f"{file} Compressed.") return compressed.name else: self.log.info(f"Compressing file {file}...") os.system(f"gzip {file}") self.log.info(f"{file} compressed successfully.") return f"{file}.gz" def write(self, payload: Iterator, filename: str) -> str: """ : param payload: Any response payload, csv, json, zip, gzip. : param filename: Any preferred filename, ex. myFile.csv. (Will be written to a temporary) Returns the temporary directory path + filename. The temprary directory will be garbage collected if the File object is disposed or due to an exception. """ tempfile = "".join([self.tempdir.name, "/", filename]) tempfile = PurePath(tempfile) self.log.info(f"Writing to: {tempfile}...") with open(file=tempfile, mode="wb") as file: payload_size = 0 total_size = 0 for chunk in payload: payload_size += payload.__sizeof__() total_size += len(chunk) file.write(chunk) self.log.info(f"Write to file completed.") return tempfile def s3_upload(self, filepath: str, bucket: str, key: str) -> None: """ Upload a file to S3. :param filepath: The source file path. :param bucket: The s3 target bucket name. :param key: The s3 object name. (File name in s3, ex. /dev/business_unit/dataset/subdataset/daily/date/filename.json.gz) """ self.log.info(f"Uploading file to S3...") self.log.info(f"Source: {filepath}") self.log.info(f"Target: {key}") client = boto3.client("s3") client.upload_file(Filename=filepath, Bucket=bucket, Key=key) self.log.info(f"File uploaded successfully to: {key}") def list_objects(self, bucket: str, prefix: str) -> list: """ List objects from the bucket. :param bucket: Name of the bucket :type bucket: str :param prefix: The key prefix :type prefix: str :return: Metadata for all objects from the bucket :rtype: collections.Iterable[dict[str, any]] """ client = boto3.client("s3") # Use paginator abstraction to seamlessly iterate over pages. # list_objects_v2 provides maximum 1000 objects per request, pagination # is used in AWS sdk in order to split large collections into several # smaller, limited requests) paginator = client.get_paginator("list_objects_v2") page = 1 for result in paginator.paginate( Bucket=bucket, Prefix=prefix, RequestPayer="requester" ): self.log.info("\tReading page {}.".format(page)) page += 1 for item in result.get("Contents", []): yield item def s3_delete( self, bucket: str, prefix: str, last_modified: datetime, max_count: int = 20 ) -> bool: """ Delete a file from an S3 bucket ***** Please verify that the prefix parameter is correct... Objects are permanetnly deleted. ***** :param bucket, Bucket to delete from :param prefix, filter to be passed to the s3 bucket it selects the objects that match the prefix. Ex: dev/system/prefix1/prefix2/prefix3 :param last_modified, Select files oder than the timestamp passed. The filter targets the s3 object's last modified date. Ex: last_modified = datetime.now() - timedelta(days=31). Uses last_modified.replace(tzinfo=pytz.UTC) :param max_count (not required, default = 20), pass a value if you need more than 20 objects deleted. Returns True if objects were deleted, else False Logs the s3 response. """ # self.log.info('Deleting files from S3.') last_modified = last_modified.replace(tzinfo=pytz.UTC) self.log.info(f"Bucket: {bucket}") self.log.info(f"Prefix: {prefix}") self.log.info(f"Last modified: {last_modified}") self.log.info(f"Max count: {max_count}") # Deleted files client = boto3.client("s3") bucket = bucket content = self.list_objects(bucket=bucket, prefix=prefix) if content: delete = {} delete["Objects"] = [ {"Key": item["Key"]} for item in content if item["LastModified"] < last_modified ] delete_count = len(delete["Objects"]) if delete_count != 0: assert delete_count <= max_count, self.log.error( f"""Delete count: {delete_count}\r\nThere are too many objects to delete, please verify that the prefix is correct. Max count = {max_count} ----> Objects available for deletion [{delete_count}].""" ) self.log.info(f"Deleting objects with prefix: {prefix}") delete_response = client.delete_objects(Bucket=bucket, Delete=delete) self.log.info(delete_response) return True else: self.log.info( f"No objects met the last modified condition {last_modified}" ) return False else: self.log.info(f"No objects met the prefix condition {prefix}") return False def get_file_extension(self, content_type: str) -> str: """ This function takes in a content type as an argument and returns the corresponding file extension as a string. If no corresponding file extension exists, it returns '.bin' as the file extension. """ self.log.info(f"API response content type: {content_type}") extensions = { "image/jpeg": ".jpg", "image/png": ".png", "image/gif": ".gif", "image/bmp": ".bmp", "audio/mp3": ".mp3", "audio/wav": ".wav", "audio/aac": ".aac", "video/mp4": ".mp4", "video/avi": ".avi", "video/mkv": ".mkv", "text/html": ".html", "text/plain": ".txt", "text/javascript": ".js", "application/pdf": ".pdf", "application/json": ".json", "application/xml": ".xml", "application/csv": ".csv", "application/x-zip-compressed": ".zip", } ext: str = None for extension in extensions: if extension in content_type: ext = extensions[extension] if ext: return ext return ".bin" python-postman-python-postman-release/src/python_postman/modules/http.py000066400000000000000000000133241465127643300273620ustar00rootroot00000000000000import os import json import re from requests import Session, Response from urllib3 import Timeout from ..request import Request as CollectionRequest from ..template import CustomTemplate from .logger import Log class Request(Session): def __init__( self, request: CollectionRequest, timeout: Timeout = Timeout(connect=15, read=60), stream: bool = True, ) -> None: super().__init__() self._request: CollectionRequest = request self.log: Log = Log() 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_headers(self, headers: dict): """ Set the headers of the request. Args: headers (dict): The headers to set. Returns: None """ 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.headers = headers def set_params(self, params: dict): """ Set URL parameters on the request object. Args: params (dict): Parameters to set on the request object. Returns: None """ 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.params = params def set_path_vars(self, path_variables: dict): """ This function sets the path variables for a given request. Parameters: path_variables (dict): The data to be substituted into the url template. Returns: None """ if self._request.url.base_url: request_url = self._request.url.base_url 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'(? None: if self._request.auth and self._request.auth.type == "bearer": self._request.auth.http_auth.token = CustomTemplate( self._request.auth.http_auth.token ).safe_substitute(os.environ) @property def send(self) -> Response: log: Log = self.log with Session() as session: # Setting the requests request: CollectionRequest = self._request log.info(f"Request Name: {request.name}") # Substitute the a bearer token at the API call level. # This is a substitution for the postman "test" script that sets a bearer token. self.substitute_bearer_token() # Setting the request params method = request.method url = self.url headers = self._request.headers.as_dict params = self.params 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, url=url, headers=headers, params=params, data=data, stream=stream, timeout=timeout, cookies=prepare_cookies, ) if response.ok: self.log.successful(url=url) else: self.log.raise_error(url=url, response=response) return response python-postman-python-postman-release/src/python_postman/modules/logger.py000066400000000000000000000031751465127643300276650ustar00rootroot00000000000000import sys from requests import Response from logbook import Logger, StreamHandler # from loguru import logger class Log(Logger): def __init__(self) -> None: """ Sets loging and inherits from Logger """ super().__init__("Message") # Used to get messages from retry. No messages if removed. # logging.basicConfig(level=logging.DEBUG) # USE THIS TO DEBG THE PACKAGE # Logbook logger. StreamHandler(sys.stdout).push_application() def request(self, url: str, message: str = "->") -> None: """ Logs the request """ self.info(f"{message} Requesting data from: {url}") def raise_error(self, url: str, response: Response) -> None: """ Logs the api url response error text, status code - headers and raises for status. """ self.error(f"{url} response text: {response.text}") self.error(f"{url} response code: {response.status_code}") self.error(f"{url} response headers: {response.headers}") response.raise_for_status() def errors(self, url: str, response: Response) -> None: """ Logs the api url response error text, status code - headers and raises for status. """ self.error(f"{url} response text: {response.text}") self.error(f"{url} response code: {response.status_code}") self.error(f"{url} response headers: {response.headers}") def successful(self, url: str, message: str = "->") -> None: """ Logs the successful api requests. """ self.info(f"{message} Response sucessful from: {url}") python-postman-python-postman-release/src/python_postman/postman.py000066400000000000000000000111071465127643300264110ustar00rootroot00000000000000import glob from typing import List from .modules.logger import Log from .environment import Environment from .collection import Collection from .request import Request log = Log() class Postman: def __init__(self) -> None: pass def get_postman_environment_files(self, dir: str) -> List[str]: """ This function returns a list of all the postman environments in the given directory - if the file name contains .postman_environment.json """ environments = glob.glob(f"{dir}/*") environments = [ environment for environment in environments if ".postman_environment.json" in environment ] return environments def get_postman_collection_files(self, dir: str) -> List[str]: """ This function returns a list of all the postman collections in the given directory - if the file name contains .postman_collection.json """ collections = glob.glob(f"{dir}/*") collections = [ collection for collection in collections if ".postman_collection.json" in collection ] return collections def _get_environments(self, dir: str) -> List[Environment]: """ Retrieve a list of Postman environments from the given directory. Args: dir (str): The directory containing Postman environments. Returns: List[Environment]: List of Postman environments. """ environment_files = self.get_postman_environment_files(dir=dir) return [ Environment.load(environment_file=environment_file) for environment_file in environment_files ] def _get_environment( self, environments: List[Environment], name: str ) -> Environment: """ This function finds an Environment in a list of Environments based on its name and returns it. Args: environments (List[Environment]): List of Environment objects. name (str): Name of the Environment to be found. Returns: Environment: Environment object with the same name as the argument. """ for environment in environments: if environment.name == name: return environment def _get_collections(self, dir: str) -> List[Collection]: """ Gets the postman collection files in the given directory and returns a list of Collection objects. If no collection files are found, an error is logged. Parameters: dir (str): The directory path to search for postman collection files Returns: List[Collection]: A list of Collection objects """ collections_files = self.get_postman_collection_files(dir=dir) if len(collections_files) > 0: return [ Collection(collection_file=collection_file) for collection_file in collections_files ] log.error(f'No collection files were found in path "{dir}"') def _get_collection(self, name: str, collections: List[Collection]) -> Collection: """ Gets the specified collection from the list of collections. Args: name (str): Name of the collection. collections (List[Collection]): List of collections. Returns: Collection: The specified collection. Raises: error (Exception): No collection named "{name}" was found. """ for collection in collections: if collection._info.name == name: return collection log.error(f'No collection named "{name}" was found.') def _get_requests(self, collection: Collection) -> List[Request]: """ This function returns a list of requests from a given collection. Args: collection (Collection): The collection to get requests from. Returns: List[Request]: A list of requests from the collection. """ requests = collection._requests return requests def _get_request(self, name: str, requests: List[Request]): """ Get the request object from the list of requests. Args: name (str): The name of the request. requests (List[Request]): The list of requests. Returns: Request: The request object. """ for request in requests: if request.name == name: return request log.error(f"The request {name} was not found. Please verify the request name.") python-postman-python-postman-release/src/python_postman/request.py000066400000000000000000000012651465127643300264240ustar00rootroot00000000000000from .config import Item from .header import Headers from .auth import Auth from .body import Body from .event import Events from .url import Url class Request: def __init__(self, item: Item) -> None: self.name: str = item.name self.events: Events = Events(events=item.events) if item.events else None self.method: str = item.request.method self.auth: Auth = Auth(auth=item.request.auth) if item.request.auth else None self.headers: Headers = Headers(headers=item.request.headers) self.body: Body = Body(body=item.request.body) if item.request.body else None self.url: Url = Url(url=item.request.url) if item.request.url else None python-postman-python-postman-release/src/python_postman/template.py000066400000000000000000000001451465127643300265430ustar00rootroot00000000000000from string import Template class CustomTemplate(Template): idpattern = r"[a-z][\.\-_a-z0-9]*" python-postman-python-postman-release/src/python_postman/url.py000066400000000000000000000057511465127643300255420ustar00rootroot00000000000000from typing import Dict, List from .config import Url, Param, Variable class Variable: def __init__(self, variable: Variable) -> None: self.key: str = variable.key self.value: str = variable.value self.description: str = variable.description class Param: def __init__(self, param: Param) -> None: self.key: str = param.key self.value: str = param.value self.description: str = param.description self.disabled: str = param.disabled class Url: def __init__(self, url: Url) -> None: self.raw: str = url.raw self.protocol: str = url.protocol self.host: str = url.host self.path: str = url.path self.variables: List[Variable] = url.variable self.query: List[Param] = url.query self.base_url: str = None @property def base(self) -> str: """ This property returns a complete URL from the provided host and path. If no protocol is given, it defaults to 'https://'. Raises an AssertionError if no host or path are found in the postman collection. """ assert self.host and self.path, print( "Error: No host or path were found in the postman collection." ) protocol = f"{self.protocol}" if self.protocol else "https://" host = ".".join(self.host) + "/" path = "/".join(self.update_path()) url = "".join([protocol, host, path]) url = "".join([host, path]) return url @property def params(self) -> Dict[str, str]: """ A parameter is enabled/disabled in the Postman App. Enabled parameters are parameters that do not contain a "disabled: true" key: value returns a dictionary of enabled parameters. """ if self.query: params: Dict = {} for param in self.query: param = Param(param=param) if not param.disabled: params[param.key] = param.value return params @property def path_variables(self) -> Dict[str, str]: """ A parameter is enabled/disabled in the Postman App. Enabled parameters are parameters that do not contain a "disabled: true" key: value returns a dictionary of enabled parameters. """ if self.variables: variables: Dict = {} for variable in self.variables: variable = Variable(variable=variable) variables[variable.key] = variable.value return variables def update_path(self): """ Update the path to replace each colon ":" with "${}" Args: self: The object itself Returns: path: The updated path """ path = self.path for i, element in enumerate(path): if ":" in element: element = element.replace(":", "${") element = element + "}" self.path[i] = element return path python-postman-python-postman-release/src/python_postman/utils/000077500000000000000000000000001465127643300255165ustar00rootroot00000000000000python-postman-python-postman-release/src/python_postman/utils/cli.py000066400000000000000000000030201465127643300266320ustar00rootroot00000000000000import argparse class Cli: def __init__(self) -> None: pass @property def envs(self): envs: list = ["temp", "dev", "prod", "qa"] return envs def parse_arguments(self): # setup parser parser = argparse.ArgumentParser() parser.add_argument( "-e", "--environment", type=str, required=True, help="target environment", choices=self.envs, ) parser.add_argument( "-t", "--tag", type=str, 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="Add a date to refresh the data.", ) # get args args = parser.parse_args() return args python-postman-python-postman-release/src/python_postman/utils/load_dotenvc.py000066400000000000000000000065461465127643300305440ustar00rootroot00000000000000""" 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() python-postman-python-postman-release/src/python_postman/variable.py000066400000000000000000000044041465127643300265170ustar00rootroot00000000000000import os import pendulum from string import Template from .template import CustomTemplate from .config import Variables class Variables: def __init__(self, variables: Variables) -> None: # load_dotenv() self.variables = variables @property def as_dict(self): collection_variables = {} if self.variables: for variable in self.variables: collection_variables[variable.key] = variable.value # collection_variables.update(os.environ) return collection_variables @property def api_tags(self): """ This property fetches the API tags associated with this object. It searches through the variables associated with the object and looks for keys called 'API_TAGS', 'TAGS', or 'TAG'. If one of these is found, the associated value is split into a list by comma and returned. If none of these are found, an empty list is returned. """ if self.variables: for variable in self.variables: if variable.key.upper() in ["API_TAGS", "TAGS", "TAG"]: return variable.value.split(",") return [] def s3_prefix(self, **kwargs): """ This function takes in an environment string and returns the S3 prefix based on the provided environment and the current date. The S3 prefix is based on the variables stored in self.variables and is created using the CustomTemplate class. """ if self.variables: for variable in self.variables: if variable.key.upper() in ["S3_PREFIX", "PREFIX"]: s3_prefix = CustomTemplate(variable.value).safe_substitute(**kwargs) return s3_prefix @property def model_name(self): """ This function takes in an environment string and returns the S3 prefix based on the provided environment and the current date. The S3 prefix is based on the variables stored in self.variables and is created using the CustomTemplate class. """ if self.variables: for variable in self.variables: if variable.key.upper() in ["MODEL_NAME", "MODEL"]: return variable.value