python-sdk-remote 0.0.91__tar.gz → 0.0.93__tar.gz

{python_sdk_remote-0.0.91 → python_sdk_remote-0.0.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sdk-remote
-Version: 0.0.91
+Version: 0.0.93
 Summary: PyPI Package for Circles Python SDK Local Python
 Home-page: https://github.com/circles-zone/python-sdk-remote-python-package
 Author: Circles

{python_sdk_remote-0.0.91 → python_sdk_remote-0.0.93}/README.md

@@ -1,4 +1,7 @@
-# python-package-backend-template
+# python-sdk-package
+
+https://github.com/grosser/repo_dependency_graph Ruby, Graph the dependencies of your repositories
+https://github.com/thebjorn/pydeps Python
 
 To create local package and remote package layers (not to create GraphQL and REST-API layers)
 

{python_sdk_remote-0.0.91 → python_sdk_remote-0.0.93}/python_sdk_remote/src/constants.py

@@ -3,7 +3,7 @@ import os
 from logger_local.LoggerComponentEnum import LoggerComponentEnum
 
 PYTHON_SDK_LOCAL_COMPONENT_ID = 184
-PYTHON_SDK_LOCAL_COMPONENT_NAME = 'python_sdk_local'
+PYTHON_SDK_LOCAL_COMPONENT_NAME = 'python_sdk_remote'
 
 ENVIRONMENT_NAME = os.getenv("ENVIRONMENT_NAME")
 BRAND_NAME = os.getenv("BRAND_NAME")

python_sdk_remote-0.0.93/python_sdk_remote/src/get_dependencies.py

@@ -0,0 +1,58 @@
+# pip install BeautifulSoup4 requests importlib-metadata
+import subprocess
+import sys
+import json
+from collections import defaultdict
+
+import importlib_metadata
+import requests
+from bs4 import BeautifulSoup
+
+
+def install(packages):
+    print("Installing...", packages)
+    if isinstance(packages, str):
+        packages = [packages]
+    try:
+        subprocess.run([sys.executable, "-m", "pip", "install", "-U", "--no-deps"] + packages, check=False)
+    except Exception as e:
+        print(e)
+
+
+def get_dependencies_per_package(include_packages):
+    dependencies_per_package = defaultdict(list)
+    for dist in importlib_metadata.distributions():
+        package_name = dist.metadata['Name']
+        if package_name not in include_packages:
+            continue
+
+        dependencies = dist.metadata.get_all('Requires-Dist', [])
+        for dependency in dependencies:
+            depend_on = dependency.split()[0]
+            if depend_on in include_packages:
+                dependencies_per_package[depend_on].append(package_name)
+
+    return dependencies_per_package
+
+
+def get_included_packages():
+    url = "https://pypi.org/user/circles/"
+    class_name = "package-snippet__title"
+
+    response = requests.get(url)
+    soup = BeautifulSoup(response.text, "html.parser")
+    package_names = soup.find_all("h3", class_=class_name)
+    included_packages = [package_name.text for package_name in package_names]
+    install(included_packages)
+    return included_packages
+
+
+def main():
+    include_packages = get_included_packages()
+    dependencies_per_package = get_dependencies_per_package(include_packages)
+    with open('dependencies.json', 'w') as f:
+        json.dump(dependencies_per_package, f, indent=4)
+
+
+if __name__ == "__main__":
+    main()

python_sdk_remote-0.0.93/python_sdk_remote/src/http_response.py

@@ -0,0 +1,72 @@
+import json
+from http_constants import status
+
+from .mini_logger import MiniLogger as logger
+
+HEADERS_KEY = 'headers'
+AUTHORIZATION_KEY = 'authorization'
+AUTHORIZATION_PREFIX = 'Bearer '
+
+# TODO Align those methods with typescript-sdk https://github.com/circles-zone/typescript-sdk-remote-typescript-package/blob/dev/typescript-sdk/src/utils/index.ts  # noqa501
+# TODO Shall we create also createInternalServerErrorHttpResponse(), createOkHttpResponse() like we have in TypeScript?
+
+# Former name was create_http_headers()
+def create_authorization_http_headers(user_jwt: str) -> dict:
+    logger.start(object={"user_jwt": user_jwt})
+    authorization_http_headers = {
+        'Content-Type': 'application/json',
+        'Authorization': AUTHORIZATION_PREFIX + user_jwt,
+    }
+    logger.end(object={"authorization_http_headers": authorization_http_headers})
+    return authorization_http_headers
+
+
+def get_user_jwt_from_event(event: dict) -> str:
+    logger.start(object={"event": event})
+    auth_header = event.get(HEADERS_KEY, {}).get(AUTHORIZATION_KEY)
+    if auth_header is None:
+        auth_header = event.get(HEADERS_KEY, {}).get(AUTHORIZATION_KEY.capitalize())
+    user_jwt = auth_header.split(AUTHORIZATION_PREFIX)[1]
+    logger.end(object={"user_jwt": user_jwt})
+    return user_jwt
+
+
+def create_return_http_headers() -> dict:
+    logger.start()
+    return_http_headers = {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+    }
+    logger.end(object={"return_http_headers": return_http_headers})
+    return return_http_headers
+
+def create_error_http_response(exception: Exception) -> dict:
+    logger.start(object={"exception": exception})
+    error_http_response = {
+            "statusCode": status.BAD_GATEWAY,
+            "headers": create_return_http_headers(),
+            "body": create_http_body({"error": str(exception)})
+        }
+    logger.end(object={"error_http_response": error_http_response})
+    return error_http_response
+
+
+def create_ok_http_response(body: dict) -> dict:
+    logger.start(object={"body": body})
+    ok_http_response = {
+        "statusCode": status.OK,
+        "headers": create_return_http_headers(),
+        "body": create_http_body(body)
+    }
+    logger.end(object={"ok_http_response": ok_http_response})
+    return ok_http_response
+
+
+# https://google.github.io/styleguide/jsoncstyleguide.xml?showone=Property_Name_Format#Property_Name_Format
+def create_http_body(body: dict) -> str:
+    # TODO console.warning() if the body is not a valid camelCase JSON
+    # https://stackoverflow.com/questions/17156078/converting-identifier-naming-between-camelcase-and-underscores-during-json-seria
+    logger.start(object={"body": body})
+    http_body = json.dumps(body)
+    logger.end(object={"http_body": http_body})
+    return http_body

{python_sdk_remote-0.0.91 → python_sdk_remote-0.0.93}/python_sdk_remote/src/utilities.py

@@ -1,11 +1,12 @@
-import json
 import os
 from datetime import date, datetime, time, timedelta
 from dotenv import load_dotenv
 from url_remote.environment_name_enum import EnvironmentName
 from urllib.parse import urlparse
-from http_constants import status
 
+from .http_response import (create_authorization_http_headers, get_user_jwt_from_event,  # noqa - used for backwards compatibility
+                            create_return_http_headers, create_error_http_response, create_ok_http_response,
+                            create_http_body)
 from .mini_logger import MiniLogger as logger
 
 load_dotenv()
@@ -51,56 +52,54 @@ def is_valid_time_range(time_range: tuple) -> bool:
     """
     Validate that the time range is in the format 'HH:MM:SS'.
     """
-    IS_VALID_TIME_RANGE_METHOD_NAME = "is_valid_time_range"
-    logger.start(IS_VALID_TIME_RANGE_METHOD_NAME, object={
-        "time_range": time_range.__str__()})
+    logger.start(object={"time_range": time_range.__str__()})
     if len(time_range) != 2:
-        logger.end(IS_VALID_TIME_RANGE_METHOD_NAME, object={
-            "is_valid_time_range_result": False, "reason": "len(time_range) != 2"})
+        logger.end(object={"is_valid_time_range_result": False, "reason": "len(time_range) != 2"})
         return False
 
     for time_obj in time_range:
         if not isinstance(time_obj, time):
-            logger.end(IS_VALID_TIME_RANGE_METHOD_NAME, object={
+            logger.end(object={
                 "is_valid_time_range_result": False, "reason": "time_range contains non-time objects"})
             return False
         time_str = time_obj.strftime('%H:%M:%S')
         if time_obj.strftime('%H:%M:%S') != time_str:
-            logger.end(IS_VALID_TIME_RANGE_METHOD_NAME, object={
+            logger.end(object={
                 "is_valid_time_range_result": False, "reason": "time_range contains invalid time format"})
             return False
 
-    logger.end(IS_VALID_TIME_RANGE_METHOD_NAME, object={
-        "is_valid_time_range_result": True})
+    logger.end(object={"is_valid_time_range_result": True})
     return True
 
 
+# TODO shall we also use Url type and not only str? - Strongly Type which I prefer
+#   (if yes we should change it also in all the calls to this function)
 def validate_url(url: str):
+    logger.start(object={"url": url})
     if url is not None or url != "":
         parsed_url = urlparse(url)
-        return parsed_url.scheme and parsed_url.netloc
-    return True
+        is_valid_url = parsed_url.scheme and parsed_url.netloc
+    else:
+        is_valid_url = True
+    logger.end(object={"is_valid_url": is_valid_url})
+    return is_valid_url
 
 
 def is_valid_date_range(date_range: tuple) -> bool:
     """
     Validate that the date range is in the format 'YYYY-MM-DD'.
     """
-    IS_VALID_DATE_RANGE_METHOD_NAME = "is_valid_date_range"
-    logger.start(IS_VALID_DATE_RANGE_METHOD_NAME, object={
-        "date_range": date_range.__str__()})
+    logger.start(object={"date_range": date_range.__str__()})
     if len(date_range) != 2:
-        logger.end(IS_VALID_DATE_RANGE_METHOD_NAME, object={
-            "is_valid_date_range_result": False, "reason": "len(date_range) != 2"})
+        logger.end(object={"is_valid_date_range_result": False, "reason": "len(date_range) != 2"})
         return False
 
     for date_obj in date_range:
         if not isinstance(date_obj, date):
-            logger.end(IS_VALID_DATE_RANGE_METHOD_NAME, object={
+            logger.end(object={
                 "is_valid_date_range_result": False, "reason": "date_range contains non-date objects"})
             return False
-    logger.end(IS_VALID_DATE_RANGE_METHOD_NAME, object={
-        "is_valid_date_range_result": True})
+    logger.end(object={"is_valid_date_range_result": True})
     return True
 
 
@@ -108,21 +107,16 @@ def is_valid_datetime_range(datetime_range: tuple) -> bool:
     """
     Validate that the datetime range is in the format 'YYYY-MM-DD HH:MM:SS'.
     """
-    IS_VALID_DATETIME_RANGE_METHOD_NAME = "is_valid_datetime_range"
-    logger.start(IS_VALID_DATETIME_RANGE_METHOD_NAME, object={
-        "datetime_range": datetime_range.__str__()})
+    logger.start(object={"datetime_range": datetime_range.__str__()})
     if len(datetime_range) != 2:
-        logger.end(IS_VALID_DATETIME_RANGE_METHOD_NAME, object={
-            "is_valid_datetime_range_result": False, "reason": "len(datetime_range) != 2"})
+        logger.end(object={"is_valid_datetime_range_result": False, "reason": "len(datetime_range) != 2"})
         return False
 
     for datetime_obj in datetime_range:
         if not isinstance(datetime_obj, datetime):
-            logger.end(IS_VALID_DATETIME_RANGE_METHOD_NAME, object={
-                "is_valid_datetime_range_result": False, "reason": "datetime_range contains non-datetime objects"})
+            logger.end(object={"is_valid_datetime_range_result": False, "reason": "datetime_range contains non-datetime objects"})
             return False
-    logger.end(IS_VALID_DATETIME_RANGE_METHOD_NAME, object={
-        "is_valid_datetime_range_result": True})
+    logger.end(object={"is_valid_datetime_range_result": True})
     return True
 
 
@@ -148,27 +142,25 @@ def is_list_of_dicts(obj: object) -> bool:
         >>> is_list_of_dicts(1)
         False
     """
-    IS_LIST_OF_DICTS_FUNCTION_NAME = "is_list_of_dicts"
-    logger.start(IS_LIST_OF_DICTS_FUNCTION_NAME, object={"obj": obj})
+    logger.start(object={"obj": obj})
     try:
         if not isinstance(obj, list):
             is_list_of_dicts_result = False
-            logger.end(IS_LIST_OF_DICTS_FUNCTION_NAME, object={
-                "is_list_of_dicts_result": is_list_of_dicts_result})
+            logger.end(object={"is_list_of_dicts_result": is_list_of_dicts_result})
             return is_list_of_dicts_result
         for item in obj:
             if not isinstance(item, dict):
                 is_list_of_dicts_result = False
-                logger.end(IS_LIST_OF_DICTS_FUNCTION_NAME, object={
+                logger.end(object={
                     "is_list_of_dicts_result": is_list_of_dicts_result})
                 return is_list_of_dicts_result
         is_list_of_dicts_result = True
-        logger.end(IS_LIST_OF_DICTS_FUNCTION_NAME, object={
+        logger.end(object={
             "is_list_of_dicts_result": is_list_of_dicts_result})
         return is_list_of_dicts_result
     except Exception as exception:
-        logger.exception(IS_LIST_OF_DICTS_FUNCTION_NAME, exception)
-        logger.end(IS_LIST_OF_DICTS_FUNCTION_NAME)
+        logger.exception(object=exception)
+        logger.end()
         raise
 
 
@@ -183,15 +175,14 @@ def is_time_in_time_range(check_time: time, time_range: tuple) -> bool:
     Returns:
         bool: True if the check_time is within the time range, False otherwise.
     """
-    IS_TIME_IN_TIME_RANGE_METHOD_NAME = "is_time_in_time_range"
-    logger.start(IS_TIME_IN_TIME_RANGE_METHOD_NAME, object={
+    logger.start(object={
         "check_time": check_time.__str__(), "time_range": time_range.__str__()})
     if not is_valid_time_range(time_range) or not isinstance(check_time, time):
-        logger.end(IS_TIME_IN_TIME_RANGE_METHOD_NAME, object={
+        logger.end(object={
             "is_time_in_time_range_result": False})
         return False
     start_time, end_time = time_range
-    logger.end(IS_TIME_IN_TIME_RANGE_METHOD_NAME, object={
+    logger.end(object={
         "is_time_in_time_range_result": start_time <= check_time <= end_time})
     return start_time <= check_time <= end_time
 
@@ -207,16 +198,15 @@ def is_date_in_date_range(check_date: date, date_range: tuple) -> bool:
     Returns:
         bool: True if the check_date is within the date range, False otherwise.
     """
-    IS_DATE_IN_DATE_RANGE_METHOD_NAME = "is_date_in_date_range"
-    logger.start(IS_DATE_IN_DATE_RANGE_METHOD_NAME, object={
+    logger.start(object={
         "check_date": check_date.__str__(), "date_range": date_range.__str__()})
     if not is_valid_date_range(date_range) or not isinstance(check_date, date):
-        logger.end(IS_DATE_IN_DATE_RANGE_METHOD_NAME, object={
+        logger.end(object={
             "is_date_in_date_range_result": False})
         return False
 
     start_date, end_date = date_range
-    logger.end(IS_DATE_IN_DATE_RANGE_METHOD_NAME, object={
+    logger.end(object={
         "is_date_in_date_range_result": start_date <= check_date <= end_date})
     return start_date <= check_date <= end_date
 
@@ -232,67 +222,19 @@ def is_datetime_in_datetime_range(check_datetime: datetime, datetime_range: tupl
     Returns:
         bool: True if the check_datetime is within the datetime range, False otherwise.
     """
-    IS_DATETIME_IN_DATETIME_RANGE_METHOD_NAME = "is_datetime_in_datetime_range"
-    logger.start(IS_DATETIME_IN_DATETIME_RANGE_METHOD_NAME)
+    logger.start()
     if not is_valid_datetime_range(datetime_range) or not isinstance(check_datetime, datetime):
-        logger.end(IS_DATETIME_IN_DATETIME_RANGE_METHOD_NAME, object={
+        logger.end(object={
             "is_valid_datetime_range": False})
         return False
 
     start_datetime, end_datetime = datetime_range
     is_datetime_in_datetime_range_result = start_datetime <= check_datetime <= end_datetime
-    logger.end(IS_DATETIME_IN_DATETIME_RANGE_METHOD_NAME, object={
+    logger.end(object={
         "is_datetime_in_datetime_range_result": is_datetime_in_datetime_range_result})
     return is_datetime_in_datetime_range_result
 
 
-# TODO Align those methods with typescript-sdk https://github.com/circles-zone/typescript-sdk-remote-typescript-package/blob/dev/typescript-sdk/src/utils/index.ts  # noqa501
-# TODO Take those three functions to a separate file http_response.py
-# TODO Shall we create also createInternalServerErrorHttpResponse(), createOkHttpResponse() like we have in TypeScript?
-
-# Former name was create_http_headers()
-def create_authorization_http_headers(user_jwt: str) -> dict:
-    return {
-        'Content-Type': 'application/json',
-        'Authorization': f'Bearer {user_jwt}',
-    }
-
-
-def get_user_jwt_from_event(event: dict) -> str:
-    auth_header = event.get('headers', {}).get('authorization')
-    if auth_header is None:
-        auth_header = event.get('headers', {}).get('Authorization')
-    return auth_header.split('Bearer ')[1]
-
-
-def create_return_http_headers() -> dict:
-    return {
-        "Content-Type": "application/json",
-        "Access-Control-Allow-Origin": "*",
-    }
-
-def create_error_http_response(exception: Exception) -> dict:
-    return {
-            "statusCode": status.BAD_GATEWAY,
-            "headers": create_return_http_headers(),
-            "body": create_http_body({"error": str(exception)})
-        }
-
-def create_ok_http_response(body: dict) -> dict:
-    return {
-        "statusCode": status.OK,
-        "headers": create_return_http_headers(),
-        "body": create_http_body(body)
-    }
-
-
-# https://google.github.io/styleguide/jsoncstyleguide.xml?showone=Property_Name_Format#Property_Name_Format
-def create_http_body(body: dict) -> str:
-    # TODO console.warning() if the body is not a valid camelCase JSON
-    # https://stackoverflow.com/questions/17156078/converting-identifier-naming-between-camelcase-and-underscores-during-json-seria
-    return json.dumps(body)
-
-
 def get_brand_name() -> str:
     return our_get_env("BRAND_NAME")
 
@@ -304,10 +246,12 @@ def get_environment_name() -> str:
 
 
 def our_get_env(key: str, default: str = None, raise_if_not_found: bool = True) -> str:
-    result = os.getenv(key, default)
-    if raise_if_not_found and result is None:
+    logger.start(object={"key": key, "default": default, "raise_if_not_found": raise_if_not_found})
+    env_var = os.getenv(key, default)
+    if raise_if_not_found and env_var is None:
         raise Exception(f"Environment variable {key} not found")
-    return result
+    logger.end(object={"env_var": env_var})
+    return env_var
 
 
 def get_sql_hostname() -> str:

{python_sdk_remote-0.0.91 → python_sdk_remote-0.0.93}/python_sdk_remote.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sdk-remote
-Version: 0.0.91
+Version: 0.0.93
 Summary: PyPI Package for Circles Python SDK Local Python
 Home-page: https://github.com/circles-zone/python-sdk-remote-python-package
 Author: Circles

{python_sdk_remote-0.0.91 → python_sdk_remote-0.0.93}/python_sdk_remote.egg-info/SOURCES.txt

@@ -8,6 +8,8 @@ python_sdk_remote.egg-info/requires.txt
 python_sdk_remote.egg-info/top_level.txt
 python_sdk_remote/src/__init__.py
 python_sdk_remote/src/constants.py
+python_sdk_remote/src/get_dependencies.py
+python_sdk_remote/src/http_response.py
 python_sdk_remote/src/item.py
 python_sdk_remote/src/mini_logger.py
 python_sdk_remote/src/our_object.py

{python_sdk_remote-0.0.91 → python_sdk_remote-0.0.93}/setup.py

@@ -7,7 +7,7 @@ package_dir = PACKAGE_NAME.replace("-", "_")
 # python -m build needs pyproject.toml or setup.py
 setuptools.setup(
     name=PACKAGE_NAME,
-    version='0.0.91',  # https://pypi.org/project/python-sdk-remote/
+    version='0.0.93',  # https://pypi.org/project/python-sdk-remote/
     author="Circles",
     author_email="info@circles.life",
     description="PyPI Package for Circles Python SDK Local Python",