python-sdk-local 0.0.51__tar.gz → 0.0.126__tar.gz

{python-sdk-local-0.0.51 → python_sdk_local-0.0.126}/PKG-INFO

@@ -1,13 +1,17 @@
 Metadata-Version: 2.1
 Name: python-sdk-local
-Version: 0.0.51
+Version: 0.0.126
 Summary: PyPI Package for Circles Python SDK Local Python
-Home-page: https://github.com/circles
+Home-page: https://github.com/circles-zone/python-sdk-remote-python-package
 Author: Circles
-Author-email: info@circles.life
+Author-email: info@circlez.ai
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: python-dotenv
+Requires-Dist: url-remote
+Requires-Dist: pyjwt
 
 This is a package for sharing common functions used in different repositories

python_sdk_local-0.0.126/README.md

@@ -0,0 +1,11 @@
+# TODO: rewrite with more example
+
+In serverless, use this decorator:
+```py
+from python_sdk_remote.http_response import handler_decorator
+from logger_local.Logger import Logger
+logger = Logger.create_logger(object=your_logger_object)
+@handler_decorator(logger=logger)
+def my_handler(request_parameters: dict) -> dict:
+  # here you can use both camelCase and snake_case keys from request_parameters
+```

python_sdk_local-0.0.126/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.poetry]
+name = "python-sdk-local"
+version = "0.0.76" # https://pypi.org/project/python-sdk-local
+description = "python-sdk-local Python Package"
+readme = "README.md"
+authors = [
+    "Circlez.ai <info@circlez.ai>",
+]

{python-sdk-local-0.0.51 → python_sdk_local-0.0.126}/python_sdk_local.egg-info/PKG-INFO

@@ -1,13 +1,17 @@
 Metadata-Version: 2.1
 Name: python-sdk-local
-Version: 0.0.51
+Version: 0.0.126
 Summary: PyPI Package for Circles Python SDK Local Python
-Home-page: https://github.com/circles
+Home-page: https://github.com/circles-zone/python-sdk-remote-python-package
 Author: Circles
-Author-email: info@circles.life
+Author-email: info@circlez.ai
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: python-dotenv
+Requires-Dist: url-remote
+Requires-Dist: pyjwt
 
 This is a package for sharing common functions used in different repositories

python_sdk_local-0.0.126/python_sdk_local.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+setup.py
+python_sdk_local.egg-info/PKG-INFO
+python_sdk_local.egg-info/SOURCES.txt
+python_sdk_local.egg-info/dependency_links.txt
+python_sdk_local.egg-info/requires.txt
+python_sdk_local.egg-info/top_level.txt
+python_sdk_remote/src/__init__.py
+python_sdk_remote/src/constants.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/src/unified_json.py
+python_sdk_remote/src/utilities.py
+python_sdk_remote/src/valid_json_versions.py
+python_sdk_remote/src/validate_environment.py

python_sdk_local-0.0.126/python_sdk_local.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests
+python-dotenv
+url-remote
+pyjwt

python_sdk_local-0.0.126/python_sdk_local.egg-info/top_level.txt

@@ -0,0 +1 @@
+python_sdk_remote

python_sdk_local-0.0.126/python_sdk_remote/src/constants.py

@@ -0,0 +1,28 @@
+import os
+
+from logger_local.LoggerComponentEnum import LoggerComponentEnum
+
+PYTHON_SDK_REMOTE_COMPONENT_ID = 184
+PYTHON_SDK_REMOTE_COMPONENT_NAME = 'python_sdk_remote'
+
+ENVIRONMENT_NAME = os.getenv("ENVIRONMENT_NAME")
+BRAND_NAME = os.getenv("BRAND_NAME")
+LOGZIO_TOKEN = os.getenv("LOGZIO_TOKEN")
+# TODO Shall Can we use python-sdk function to get the value from Environment?
+# TODO Shall we get the value from environment here of send the value to the function as @akiva-skolnik did?
+GOOGLE_PORT_FOR_AUTHENTICATION = os.getenv("PORT_FOR_AUTHENTICATION")
+
+OBJECT_TO_INSERT_CODE = {
+    'component_id': PYTHON_SDK_REMOTE_COMPONENT_ID,
+    'component_name': PYTHON_SDK_REMOTE_COMPONENT_NAME,
+    'component_category': LoggerComponentEnum.ComponentCategory.Code.value,
+    'developer_email': 'sahar.g@circ.zone'
+}
+
+OBJECT_TO_INSERT_TEST = {
+    'component_id': PYTHON_SDK_REMOTE_COMPONENT_ID,
+    'component_name': PYTHON_SDK_REMOTE_COMPONENT_NAME,
+    'component_category': LoggerComponentEnum.ComponentCategory.Unit_Test.value,
+    'testing_framework': LoggerComponentEnum.testingFramework.pytest.value,
+    'developer_email': 'sahar.g@circ.zone'
+}

python_sdk_local-0.0.126/python_sdk_remote/src/http_response.py

@@ -0,0 +1,139 @@
+import traceback
+from functools import wraps
+from http import HTTPStatus
+from typing import Any
+
+from .mini_logger import MiniLogger as logger
+from .utilities import camel_to_snake, snake_to_camel, to_dict, to_json
+
+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
+# TODO Shall we create also createInternalServerErrorHttpResponse(), createOkHttpResponse() like we have in TypeScript?
+
+# TODO: add handler wrapper?
+
+def get_payload_dict_from_event(event: dict) -> dict:
+    """Extracts params sent with payload"""
+    return to_dict(event.get('body'))
+
+
+def get_path_parameters_dict_from_event(event: dict) -> dict:
+    """Extracts params sent implicitly: `url/param?test=5` -> param
+    (when the path is defined with /{param})"""
+    return event.get('pathParameters') or {}
+
+
+def get_query_string_parameters_from_event(event: dict) -> dict:
+    """Extracts params sent explicitly: `url/test?a=1&b=2` ->  {'a': '1', 'b': '2'}"""
+    return event.get("queryStringParameters") or {}  # params sent with ?a=1&b=2
+
+
+def get_request_parameters_from_event(event: dict) -> dict:
+    """Extracts all params from the event object.
+    The order of precedence is: payload > path > query string
+    returns a dictionary with all the parameters, with both camelCase and snake_case keys."""
+    all_params = get_payload_dict_from_event(event)
+    all_params.update(get_path_parameters_dict_from_event(event))
+    all_params.update(get_query_string_parameters_from_event(event))
+    all_params = {camel_to_snake(key): value for key, value in all_params.items()}
+    all_params.update({snake_to_camel(key): value for key, value in all_params.items()})
+    return all_params
+
+
+# TODO: test
+def handler_decorator(logger):
+    """Decorator for AWS Lambda handler functions. It wraps the handler function with logging and error handling.
+    Usage:
+    from python_sdk_remote.http_response import handler_decorator
+    logger = ...
+    @handler_decorator(logger=logger)
+    def my_handler(request_parameters: dict) -> dict:
+        return {"message": "Hello, World!"}"""
+
+    def decorator(handler: callable) -> callable:
+        @wraps(handler)
+        def wrapper(event, context):
+            handler_response = None
+            try:
+                logger.start(object={"event": event, "context": context})
+                request_parameters = get_request_parameters_from_event(event)
+                body_result: dict = handler(request_parameters)
+                handler_response = create_ok_http_response(body_result)
+            except Exception as e:
+                handler_response = create_error_http_response(e)
+            finally:
+                logger.end(object={"handler_response": handler_response})
+            return handler_response
+
+        return wrapper
+
+    return decorator
+
+
+# TODO: should we auto detect user_jwt if not provided?
+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, status_code: HTTPStatus = HTTPStatus.BAD_REQUEST) -> dict:
+    logger.start(object={"exception": exception})
+    error_http_response = {
+        "statusCode": status_code.value,
+        "headers": create_return_http_headers(),
+        "body": create_http_body({"error": str(exception)}),
+        "traceback": traceback.format_exc()
+    }
+    logger.end(object={"error_http_response": error_http_response})
+    return error_http_response
+
+
+def create_ok_http_response(body: Any) -> dict:
+    logger.start(object={"body": body})
+    # TODO: test sending statusCode/headers/body inside the body
+    ok_http_response = {
+        "statusCode": body.get("statusCode") or HTTPStatus.OK.value,
+        "headers": body.get("headers") or create_return_http_headers(),
+        "body": create_http_body(body.get("body") or 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: Any) -> 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 = to_json(body)
+    logger.end(object={"http_body": http_body})
+    return http_body

{python-sdk-local-0.0.51/sdk → python_sdk_local-0.0.126/python_sdk_remote}/src/item.py

@@ -1,13 +1,12 @@
 from abc import abstractmethod
+
 from .our_object import OurObject
 
 
 class Item(OurObject):
-
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
     @abstractmethod
     def get_id(self):
         raise NotImplementedError("Subclasses must implement the 'get_id' method.")
-

python_sdk_local-0.0.126/python_sdk_remote/src/mini_logger.py

@@ -0,0 +1,131 @@
+import logging
+import os
+import sys
+
+LOGGER_MINIMUM_SEVERITY = os.getenv("LOGGER_MINIMUM_SEVERITY", "INFO").upper()
+# logging expects NOTSET/DEBUG/INFO/WARNING/ERROR/FATAL/CRITICAL
+if LOGGER_MINIMUM_SEVERITY.isdigit():
+    logger_minimum_severity = int(LOGGER_MINIMUM_SEVERITY)
+    # Values from Logger.MessageSeverity
+    if logger_minimum_severity < 400:
+        LOGGER_MINIMUM_SEVERITY = "DEBUG"
+    elif logger_minimum_severity < 600:
+        LOGGER_MINIMUM_SEVERITY = "INFO"
+    elif logger_minimum_severity < 700:
+        LOGGER_MINIMUM_SEVERITY = "WARNING"
+    elif logger_minimum_severity < 800:
+        LOGGER_MINIMUM_SEVERITY = "ERROR"
+    else:
+        LOGGER_MINIMUM_SEVERITY = "CRITICAL"
+
+logging.basicConfig(level=LOGGER_MINIMUM_SEVERITY, stream=sys.stdout,
+                    format="%(asctime)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+class MiniLogger:
+    # TODO Can we so one generic function call by all
+
+    @staticmethod
+    def start(message: str = "", object: dict = None):
+        """
+        Print a log message with the current time.
+
+        Parameters:
+            message (str): The message to be printed.
+            object (dict): The object to be printed.
+        """
+        if object is None:
+            logger.debug(f"START - {message}")
+        else:
+            logger.debug(f"START - {message} - {object}")
+
+    @staticmethod
+    def end(message: str = "", object: dict = None):
+        """
+        Print a log message with the current time.
+
+        Parameters:
+            message (str): The message to be printed.
+        """
+        if object is None:
+            logger.debug(f"END - {message}")
+        else:
+            logger.debug(f"END - {message} - {object}")
+
+    @staticmethod
+    def debug(message: str = "", object: dict = None):
+        """
+        Print a log message with the current time.
+
+        Parameters:
+            message (str): The message to be printed.
+            object (dict): The object to be printed.
+        """
+        if object is None:
+            logger.debug(f"DEBUG - {message}")
+        else:
+            logger.debug(f"DEBUG {message} - {object}")
+
+    @staticmethod
+    def info(message: str = "", object: dict = None):
+        """
+        Print a log message with the current time.
+
+        Parameters:
+            message (str): The message to be printed.
+            object (dict): The object to be printed.
+        """
+        if object is None:
+            logger.info(f"INFO - {message}")
+        else:
+            logger.info(f"INFO {message} - {object}")
+
+    @staticmethod
+    def warning(message: str = "", object: dict = None):
+        """
+        Print a log message with the current time.
+
+        Parameters:
+            message (str): The message to be printed.
+            object (dict): The object to be printed.
+        """
+        if object is None:
+            logger.warning(f"WARNING - {message}")
+        else:
+            logger.warning(f"WARNING {message} - {object}")
+
+    @staticmethod
+    def error(message: str = "", object: dict = None):
+        """
+        Print a log error message with the current time.
+
+        Parameters:
+            message (str): The message to be printed.
+            object (dict): The object to be printed.
+        """
+        if object is None:
+            logger.error(f"ERROR - {message}")
+        else:
+            logger.error(f"ERROR - {message} - {object}")
+
+    @staticmethod
+    def exception(message: str = "", object: Exception or dict = None):
+        """
+        Print a log error message with the current time.
+
+        Parameters:
+            message (str): The message to be printed.
+            object (dict / Exception): The object / Exception to be printed.
+        """
+        if isinstance(object, Exception):
+            exception = object
+        elif isinstance(object, dict):
+            exception = object.get("exception")
+        else:
+            exception = None
+
+        if object is None:
+            logger.exception(f"EXCEPTION - {message}")
+        else:
+            logger.exception(f"EXCEPTION- {message} - {object}", exc_info=exception)

{python-sdk-local-0.0.51/sdk → python_sdk_local-0.0.126/python_sdk_remote}/src/our_object.py

@@ -1,19 +1,11 @@
-from __future__ import annotations
 import json
-import sys
-import os
-from dotenv import load_dotenv
-sys.path.append(os.getcwd())
-from .constants import *  # noqa: E402
-load_dotenv()
-from logger_local.Logger import Logger  # noqa: E402
-from abc import ABC, abstractmethod  # noqa: E402
+from abc import ABC, abstractmethod
 
-logger = Logger.create_logger(object=OBJECT_TO_INSERT_CODE)
+from .mini_logger import MiniLogger as logger
 
 
+# TODO Where are we using it? Shall we extend the usage of OurObject as the father of all our entities?
 class OurObject(ABC):
-
     def __init__(self, **kwargs):
         INIT_METHOD_NAME = '__init__'
         logger.start(INIT_METHOD_NAME, object={'kwargs': kwargs})
@@ -22,10 +14,12 @@ class OurObject(ABC):
 
     @abstractmethod
     def get_name(self):
+        """Returns the name of the object"""
         raise NotImplementedError(
             "Subclasses must implement the 'get_name' method.")
 
     def get(self, attr_name: str):
+        """Returns the value of the attribute with the given name"""
         GET_METHOD_NAME = 'get'
         logger.start(GET_METHOD_NAME, object={'attr_name': attr_name})
         arguments = getattr(self, 'kwargs', None)
@@ -34,12 +28,15 @@ class OurObject(ABC):
         return value
 
     def get_all_arguments(self):
+        """Returns all the arguments passed to the constructor as a dictionary"""
         return getattr(self, 'kwargs', None)
 
     def to_json(self) -> str:
+        """Returns a json string representation of this object"""
         return json.dumps(self.__dict__)
 
-    def from_json(self, json_string: str) -> OurObject:
+    def from_json(self, json_string: str) -> 'OurObject':
+        """Returns an instance of the class from a json string"""
         FROM_JSON_METHOD_NAME = 'from_json'
         logger.start(FROM_JSON_METHOD_NAME,
                      object={'json_string': json_string})
@@ -49,9 +46,11 @@ class OurObject(ABC):
         return self
 
     def __eq__(self, other) -> bool:
+        """Checks if two objects are equal"""
         if not isinstance(other, OurObject):
             return False
         return self.__dict__ == other.__dict__
 
     def __ne__(self, other) -> bool:
+        """Checks if two objects are not equal"""
         return not self.__eq__(other)

python_sdk_local-0.0.126/python_sdk_remote/src/unified_json.py

@@ -0,0 +1,28 @@
+from .valid_json_versions import valid_json_versions
+
+
+# TODO Shall we merge it with the machine-learning-unified-json?
+class UnifiedJson:
+    def __init__(self, data: dict, json_version: str):
+        if json_version not in valid_json_versions:
+            raise Exception(
+                f"version {json_version} is not in valid_json_versions {valid_json_versions}, "
+                f"please make sure you run sql2code."
+            )
+        self.json_version = json_version
+        self.data = data
+
+    def get_unified_json(self):
+        return {"version": self.json_version, "data": self.data}
+
+    def get_data(self):
+        return self.data
+
+    def get_json_version(self):
+        return self.json_version
+
+    def __str__(self):
+        return self.get_unified_json()
+
+    def __repr__(self):
+        return self.__str__()