python-sdk-local 0.0.38__tar.gz → 0.0.40__tar.gz

{python-sdk-local-0.0.38 → python-sdk-local-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sdk-local
-Version: 0.0.38
+Version: 0.0.40
 Summary: PyPI Package for Circles Python SDK Local Python
 Home-page: https://github.com/circles
 Author: Circles

{python-sdk-local-0.0.38 → python-sdk-local-0.0.40}/python_sdk_local.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sdk-local
-Version: 0.0.38
+Version: 0.0.40
 Summary: PyPI Package for Circles Python SDK Local Python
 Home-page: https://github.com/circles
 Author: Circles

{python-sdk-local-0.0.38 → python-sdk-local-0.0.40}/python_sdk_local.egg-info/SOURCES.txt

@@ -8,9 +8,7 @@ python_sdk_local.egg-info/top_level.txt
 sdk/__init__.py
 sdk/src/__init__.py
 sdk/src/constants.py
+sdk/src/item.py
 sdk/src/mini_logger.py
 sdk/src/our_object.py
-sdk/src/utilities.py
-sdk/tests/__init__.py
-sdk/tests/our_object_test.py
-sdk/tests/utilities_test.py
+sdk/src/utilities.py

{python-sdk-local-0.0.38 → python-sdk-local-0.0.40}/sdk/src/constants.py

@@ -7,7 +7,7 @@ OBJECT_TO_INSERT_CODE = {
     'component_id': PYTHON_SDK_LOCAL_COMPONENT_ID,
     'component_name': PYTHON_SDK_LOCAL_COMPONENT_NAME,
     'component_category': LoggerComponentEnum.ComponentCategory.Code.value,
-    'developer_email': 'tal.g@circ.zone'
+    'developer_email': 'sahar.g@circ.zone'
 }
 
 OBJECT_TO_INSERT_TEST = {
@@ -15,5 +15,5 @@ OBJECT_TO_INSERT_TEST = {
     'component_name': PYTHON_SDK_LOCAL_COMPONENT_NAME,
     'component_category': LoggerComponentEnum.ComponentCategory.Unit_Test.value,
     'testing_framework': LoggerComponentEnum.testingFramework.pytest.value,
-    'developer_email': 'tal.g@circ.zone'
+    'developer_email': 'sahar.g@circ.zone'
 }

python-sdk-local-0.0.40/sdk/src/item.py

@@ -0,0 +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):
+        pass  # This method needs to be implemented in subclasses

python-sdk-local-0.0.40/sdk/src/mini_logger.py

@@ -0,0 +1,61 @@
+import sys
+from datetime import datetime
+
+
+class MiniLogger:
+
+    @staticmethod
+    def start(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:
+            print(f"{datetime.now()} - START - {message}")
+        else:
+            print(f"{datetime.now()} - 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:
+            print(f"{datetime.now()} - END - {message}")
+        else:
+            print(f"{datetime.now()} - END - {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:
+            print(f"{datetime.now()} - INFO - {message}")
+        else:
+            print(f"{datetime.now()} - INFO {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:
+            print(f"{datetime.now()} - ERROR - {message}",
+                  file=sys.stderr)
+        else:
+            print(
+                f"{datetime.now()} - ERROR - {message} - {object}", file=sys.stderr)

python-sdk-local-0.0.40/sdk/src/our_object.py

@@ -0,0 +1,56 @@
+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
+
+logger = Logger.create_logger(object=OBJECT_TO_INSERT_CODE)
+
+
+class OurObject(ABC):
+
+    def __init__(self, **kwargs):
+        INIT_METHOD_NAME = '__init__'
+        logger.start(INIT_METHOD_NAME, object={'kwargs': kwargs})
+        self.kwargs = kwargs
+        logger.end(INIT_METHOD_NAME, object={'kwargs': kwargs})
+
+    @abstractmethod
+    def get_name(self):
+        pass  # This method needs to be implemented in subclasses
+
+    def get(self, attr_name: str):
+        GET_METHOD_NAME = 'get'
+        logger.start(GET_METHOD_NAME, object={'attr_name': attr_name})
+        arguments = getattr(self, 'kwargs', None)
+        value = arguments.get(attr_name, None)
+        logger.end(GET_METHOD_NAME, object={'attr_name': attr_name})
+        return value
+
+    def get_all_arguments(self):
+        return getattr(self, 'kwargs', None)
+
+    def to_json(self) -> str:
+        return json.dumps(self.__dict__)
+
+    def from_json(self, json_string: str) -> OurObject:
+        FROM_JSON_METHOD_NAME = 'from_json'
+        logger.start(FROM_JSON_METHOD_NAME,
+                     object={'json_string': json_string})
+        self.__dict__ = json.loads(json_string)
+        logger.end(FROM_JSON_METHOD_NAME,
+                   object={'json_dict': self.__dict__})
+        return self
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, OurObject):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other) -> bool:
+        return not self.__eq__(other)

{python-sdk-local-0.0.38 → python-sdk-local-0.0.40}/sdk/src/utilities.py

@@ -1,13 +1,15 @@
 import sys
 import os
-from datetime import time, datetime, timedelta, date
+script_directory = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.join(script_directory, '..'))
+
 from dotenv import load_dotenv
-sys.path.append(os.getcwd())
+from datetime import time, datetime, timedelta, date
 from .constants import *  # noqa: E402¸
 load_dotenv()
-# from logger_local.Logger import Logger  # noqa: E402
+from logger_local.Logger import Logger  # noqa: E402
 
-# logger = Logger.create_logger(object=OBJECT_TO_INSERT_CODE)
+logger = Logger.create_logger(object=OBJECT_TO_INSERT_CODE)
 
 
 def timedelta_to_time_format(timedelta: timedelta) -> str:
@@ -30,7 +32,8 @@ def timedelta_to_time_format(timedelta: timedelta) -> str:
         '02:30:45'
     """
     TIMEDELTA_TO_TIME_FORMAT_METHOD_NAME = "timedelta_to_time_format"
-    # logger.start(TIMEDELTA_TO_TIME_FORMAT_METHOD_NAME)
+    logger.start(TIMEDELTA_TO_TIME_FORMAT_METHOD_NAME,
+                 object={'timedelta': timedelta.__str__()})
 
     # Calculate the total seconds and convert to HH:MM:SS format
     total_seconds = int(timedelta.total_seconds())
@@ -41,8 +44,8 @@ def timedelta_to_time_format(timedelta: timedelta) -> str:
     # Format as "HH:MM:SS"
     formatted_time = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
 
-   # logger.end(TIMEDELTA_TO_TIME_FORMAT_METHOD_NAME,
-    #    object={'formatted_time': formatted_time})
+    logger.end(TIMEDELTA_TO_TIME_FORMAT_METHOD_NAME,
+               object={'formatted_time': formatted_time})
     return formatted_time
 
 
@@ -51,25 +54,26 @@ 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)
+    logger.start(IS_VALID_TIME_RANGE_METHOD_NAME, 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(IS_VALID_TIME_RANGE_METHOD_NAME, 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={
-            #     "is_valid_time_range_result": False, "reason": "time_range contains non-time objects"})
+            logger.end(IS_VALID_TIME_RANGE_METHOD_NAME, 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={
-            #     "is_valid_time_range_result": False, "reason": "time_range contains invalid time format"})
+            logger.end(IS_VALID_TIME_RANGE_METHOD_NAME, 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(IS_VALID_TIME_RANGE_METHOD_NAME, object={
+               "is_valid_time_range_result": True})
     return True
 
 
@@ -78,19 +82,20 @@ 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)
+    logger.start(IS_VALID_DATE_RANGE_METHOD_NAME, 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(IS_VALID_DATE_RANGE_METHOD_NAME, 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={
-            #     "is_valid_date_range_result": False, "reason": "date_range contains non-date objects"})
+            logger.end(IS_VALID_DATE_RANGE_METHOD_NAME, 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(IS_VALID_DATE_RANGE_METHOD_NAME, object={
+               "is_valid_date_range_result": True})
     return True
 
 
@@ -99,19 +104,20 @@ 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)
+    logger.start(IS_VALID_DATETIME_RANGE_METHOD_NAME, 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(IS_VALID_DATETIME_RANGE_METHOD_NAME, 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(IS_VALID_DATETIME_RANGE_METHOD_NAME, 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(IS_VALID_DATETIME_RANGE_METHOD_NAME, object={
+               "is_valid_datetime_range_result": True})
     return True
 
 
@@ -139,25 +145,25 @@ def is_list_of_dicts(obj):
         False
     """
     IS_LIST_OF_DICTS_FUNCTION_NAME = "is_list_of_dicts"
-    # logger.start(IS_LIST_OF_DICTS_FUNCTION_NAME, object={"obj": obj})
+    logger.start(IS_LIST_OF_DICTS_FUNCTION_NAME, 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(IS_LIST_OF_DICTS_FUNCTION_NAME, 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={
-                #            "is_list_of_dicts_result": is_list_of_dicts_result})
+                logger.end(IS_LIST_OF_DICTS_FUNCTION_NAME, 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={
-        #            "is_list_of_dicts_result": is_list_of_dicts_result})
+        logger.end(IS_LIST_OF_DICTS_FUNCTION_NAME, object={
+                   "is_list_of_dicts_result": is_list_of_dicts_result})
         return is_list_of_dicts_result
     except Exception as e:
-        # logger.end(IS_LIST_OF_DICTS_FUNCTION_NAME, exception=e)
+        logger.end(IS_LIST_OF_DICTS_FUNCTION_NAME, exception=e)
         raise e
 
 
@@ -172,13 +178,16 @@ 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)
+    IS_TIME_IN_TIME_RANGE_METHOD_NAME = "is_time_in_time_range"
+    logger.start(IS_TIME_IN_TIME_RANGE_METHOD_NAME, 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={
+                   "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={
-    #            "is_time_in_time_range_result": start_time <= check_time <= end_time})
+    logger.end(IS_TIME_IN_TIME_RANGE_METHOD_NAME, object={
+               "is_time_in_time_range_result": start_time <= check_time <= end_time})
     return start_time <= check_time <= end_time
 
 
@@ -193,14 +202,17 @@ 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)
+    IS_DATE_IN_DATE_RANGE_METHOD_NAME = "is_date_in_date_range"
+    logger.start(IS_DATE_IN_DATE_RANGE_METHOD_NAME, 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={
+                   "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={
-    #            "is_date_in_date_range_result": start_date <= check_date <= end_date})
+    logger.end(IS_DATE_IN_DATE_RANGE_METHOD_NAME, object={
+               "is_date_in_date_range_result": start_date <= check_date <= end_date})
     return start_date <= check_date <= end_date
 
 
@@ -215,12 +227,22 @@ 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)
+    IS_DATETIME_IN_DATETIME_RANGE_METHOD_NAME = "is_datetime_in_datetime_range"
+    logger.start(IS_DATETIME_IN_DATETIME_RANGE_METHOD_NAME)
     if not is_valid_datetime_range(datetime_range) or not isinstance(check_datetime, datetime):
+        logger.end(IS_DATETIME_IN_DATETIME_RANGE_METHOD_NAME, object={
+                   "is_datetime_in_datetime_range_result": False})
         return False
 
     start_datetime, end_datetime = datetime_range
-    # logger.end(IS_DATETIME_IN_DATETIME_RANGE_METHOD_NAME, object={
-    #            "is_datetime_in_datetime_range_result": start_datetime <= check_datetime <= end_datetime})
+    logger.end(IS_DATETIME_IN_DATETIME_RANGE_METHOD_NAME, object={
+               "is_datetime_in_datetime_range_result": start_datetime <= check_datetime <= end_datetime})
     return start_datetime <= check_datetime <= end_datetime
+
+
+def create_http_headers(jwt_token: str):
+    headers = {
+        'Content-Type': 'application/json',
+        'Authorization': f'Bearer {jwt_token}',
+    }
+    return headers

{python-sdk-local-0.0.38 → python-sdk-local-0.0.40}/setup.py

@@ -3,7 +3,7 @@ import setuptools
 # python -m build needs pyproject.toml or setup.py
 setuptools.setup(
     name='python-sdk-local',
-    version='0.0.38',  # https://pypi.org/project/python-sdk-local/
+    version='0.0.40',  # https://pypi.org/project/python-sdk-local/
     author="Circles",
     author_email="info@circles.life",
     description="PyPI Package for Circles Python SDK Local Python",

python-sdk-local-0.0.38/sdk/src/mini_logger.py

@@ -1,35 +0,0 @@
-import sys
-from datetime import datetime
-
-
-class MiniLogger:
-
-    @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:
-            print(f"{datetime.now()} - {message}")
-        else:
-            print(f"{datetime.now()} - {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:
-            print(f"{datetime.now()} - ERROR - {message}",
-                  file=sys.stderr)
-        else:
-            print(
-                f"{datetime.now()} - ERROR - {message} - {object}", file=sys.stderr)

python-sdk-local-0.0.38/sdk/src/our_object.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-import json
-import sys
-import os
-from dotenv import load_dotenv
-sys.path.append(os.getcwd())
-from python_sdk_local.sdk.src.constants import *  # noqa: E402
-load_dotenv()
-# from logger_local.Logger import Logger  # noqa: E402
-
-
-# logger = Logger.create_logger(object=OBJECT_TO_INSERT_CODE)
-
-
-class OurObject:
-
-    def __init__(self, **kwargs):
-        # INIT_METHOD_NAME = '__init__'
-        # logger.start(INIT_METHOD_NAME, object={'kwargs': kwargs})
-        self.kwargs = kwargs
-        # logger.end(INIT_METHOD_NAME, object={'kwargs': kwargs})
-
-    def get(self, attr_name: str):
-        arguments = getattr(self, 'kwargs', None)
-        value = arguments.get(attr_name, None)
-        return value
-
-    def get_all_arguments(self):
-        return getattr(self, 'kwargs', None)
-
-    def to_json(self) -> str:
-        return json.dumps(self.__dict__)
-
-    def from_json(self, json_string: str) -> OurObject:
-        self.__dict__ = json.loads(json_string)
-        return self
-
-    def __eq__(self, other) -> bool:
-        if not isinstance(other, OurObject):
-            return False
-        return self.__dict__ == other.__dict__
-
-    def __ne__(self, other) -> bool:
-        return not self.__eq__(other)
-
-    # TODO Shall we call it get_http_headers()? create_http_headers()?
-    def make_header(self, jwt_token: str):
-        headers = {
-            'Content-Type': 'application/json',
-            'Authorization': f'Bearer {jwt_token}',
-        }
-        return headers

python-sdk-local-0.0.38/sdk/tests/our_object_test.py

@@ -1,63 +0,0 @@
-import sys
-import os
-from dotenv import load_dotenv
-
-sys.path.append(os.getcwd())
-from python_sdk_local.sdk.src import our_object  # noqa: E402
-from python_sdk_local.sdk.src.constants import *  # noqa: E402
-load_dotenv()
-# from logger_local.Logger import Logger  # noqa: E402
-
-# logger = Logger.create_logger(object=OBJECT_TO_INSERT_TEST)
-
-
-def test_our_object():
-    # TEST_OUR_OBJECT_FUNCTION_NAME = "test_our_object"
-    # logger.start(TEST_OUR_OBJECT_FUNCTION_NAME)
-
-    our_object_1 = our_object.OurObject(a=1, b="Our Object Test")
-    our_object_2 = our_object.OurObject(a=1, b="Our Object Test")
-    our_object_3 = our_object.OurObject(a="Object3", b=3)
-
-    # Test == and != operators
-    assert our_object_1 == our_object_2
-    assert our_object_1 != our_object_3
-
-    # Test get() method
-    a1 = our_object_1.get('a')
-    a2 = our_object_2.get('a')
-    a3 = our_object_3.get('a')
-    b1 = our_object_1.get('b')
-    b2 = our_object_2.get('b')
-    b3 = our_object_3.get('b')
-
-    assert a1 == a2 == 1
-    assert a3 == "Object3"
-    assert b1 == b2 == "Our Object Test"
-    assert b3 == 3
-
-    # Test get_all_arguments() method
-    assert our_object_1.get_all_arguments() == {'a': 1, 'b': 'Our Object Test'}
-    assert our_object_2.get_all_arguments() == {'a': 1, 'b': 'Our Object Test'}
-    assert our_object_3.get_all_arguments() == {'a': 'Object3', 'b': 3}
-
-    # Test to_json() and from_json() methods
-    our_object_1_json = our_object_1.to_json()
-    our_object_2_json = our_object_2.to_json()
-    our_object_3_json = our_object_3.to_json()
-    assert our_object_1_json == '{"kwargs": {"a": 1, "b": "Our Object Test"}}'
-    assert our_object_2_json == '{"kwargs": {"a": 1, "b": "Our Object Test"}}'
-    assert our_object_3_json == '{"kwargs": {"a": "Object3", "b": 3}}'
-
-    our_object4 = our_object.OurObject()
-    our_object5 = our_object.OurObject()
-    our_object6 = our_object.OurObject()
-    assert our_object4.from_json(our_object_1_json) == our_object_1
-    assert our_object5.from_json(our_object_2_json) == our_object_2
-    assert our_object6.from_json(our_object_3_json) == our_object_3
-
-    # # Test make_header
-    # header = our_object_1.make_header(logger.userContext.get_user_JWT())
-    # assert 'Authorization' in header
-
-    # logger.end(TEST_OUR_OBJECT_FUNCTION_NAME)

python-sdk-local-0.0.38/sdk/tests/utilities_test.py

@@ -1,137 +0,0 @@
-from datetime import time, datetime, timedelta, date
-import sys
-import os
-from dotenv import load_dotenv
-from python_sdk_local.sdk.src import utilities
-from python_sdk_local.sdk.src.mini_logger import MiniLogger
-sys.path.append(os.getcwd())
-from python_sdk_local.sdk.src.constants import *  # noqa: E402
-load_dotenv()
-# from logger_local.Logger import Logger  # noqa: E402
-
-# logger = Logger.create_logger(object=OBJECT_TO_INSERT_TEST)
-
-TEST_TIME_DELTA = timedelta(seconds=25853)
-TEST_TIME_FORMAT = "07:10:53"
-
-
-def test_timedelta_to_time_format():
-    # TEST_TIMEDELTA_TO_TIME_FORMAT_METHOD_NAME = "test_timedelta_to_time_format"
-    # logger.start(TEST_TIMEDELTA_TO_TIME_FORMAT_METHOD_NAME)
-
-    time_format = utilities.timedelta_to_time_format(TEST_TIME_DELTA)
-    assert time_format == TEST_TIME_FORMAT
-
-    # logger.end(TEST_TIMEDELTA_TO_TIME_FORMAT_METHOD_NAME)
-
-
-def test_is_list_of_dicts():
-    # TEST_IS_LIST_OF_DICTS_METHOD_NAME = "test_is_list_of_dicts"
-    # logger.start(TEST_IS_LIST_OF_DICTS_METHOD_NAME)
-
-    assert utilities.is_list_of_dicts([]) == True
-    assert utilities.is_list_of_dicts([{'a': 1}, {'b': 2}]) == True
-    assert utilities.is_list_of_dicts([{'a': 1}, {'b': 2}, 3]) == False
-    assert utilities.is_list_of_dicts([{'a': 1}, {'b': 2}, 'c']) == False
-    assert utilities.is_list_of_dicts([{'a': 1}, {'b': 2}, {'c': 3}]) == True
-    assert utilities.is_list_of_dicts(
-        [{'a': 1}, {'b': 2}, {'c': {'d': 5}}, 4]) == False
-
-    # logger.end(TEST_IS_LIST_OF_DICTS_METHOD_NAME)
-
-
-def test_is_valid_time_range():
-    valid_time_range = (time(12, 34, 56), time(23, 45, 12))
-    invalid_time_range = (time(12, 34, 56), time(
-        11, 22).hour)  # Invalid format
-
-    assert utilities.is_valid_time_range(valid_time_range) is True
-    assert utilities.is_valid_time_range(invalid_time_range) is False
-
-
-def test_is_valid_date_range():
-    valid_date_range = (date(2023, 10, 26), date(2023, 10, 27))
-    invalid_date_range = (date(2023, 10, 26), time(
-        23, 45, 12))  # Invalid format
-    check_date_inside = date(2023, 10, 27)
-    check_date_outside = date(2023, 10, 25)
-
-    assert utilities.is_valid_date_range(valid_date_range) is True
-    assert utilities.is_valid_date_range(invalid_date_range) is False
-    assert utilities.is_date_in_date_range(
-        check_date_inside, valid_date_range) is True
-    assert utilities.is_date_in_date_range(
-        check_date_outside, valid_date_range) is False
-
-
-def test_is_valid_datetime_range():
-    valid_datetime_range = (
-        datetime(2023, 10, 26, 12, 34, 56), datetime(2023, 10, 27, 23, 45, 12))
-    invalid_datetime_range = (
-        datetime(2023, 10, 26, 12, 34, 56), time(23, 45, 12))  # Invalid format
-    check_datetime_inside = datetime(2023, 10, 27, 15, 0, 0)
-    check_datetime_outside = datetime(2023, 10, 25, 5, 0, 0)
-
-    assert utilities.is_valid_datetime_range(valid_datetime_range) is True
-    assert utilities.is_valid_datetime_range(invalid_datetime_range) is False
-    assert utilities.is_datetime_in_datetime_range(
-        check_datetime_inside, valid_datetime_range) is True
-    assert utilities.is_datetime_in_datetime_range(
-        check_datetime_outside, valid_datetime_range) is False
-
-
-def test_timedelta_to_time_format():
-    duration = timedelta(hours=2, minutes=30, seconds=45)
-    formatted_time = utilities.timedelta_to_time_format(duration)
-    assert formatted_time == "02:30:45"
-
-
-def test_is_time_in_time_range():
-    valid_time_range = (time(12, 34, 56), time(23, 45, 12))
-    invalid_time_range = (time(12, 34, 56), time(23, 45))  # Invalid format
-    check_time_inside = time(15, 0, 0)
-    check_time_outside = time(5, 0, 0)
-
-    assert utilities.is_time_in_time_range(
-        check_time_inside, valid_time_range) is True
-    assert utilities.is_time_in_time_range(
-        check_time_outside, valid_time_range) is False
-
-
-def test_is_date_in_date_range():
-    valid_date_range = [date(2023, 10, 26), date(2023, 10, 27)]
-    invalid_date_range = [date(2023, 10, 26), time(
-        23, 45, 12)]  # Invalid format
-    check_date_inside = date(2023, 10, 27)
-    check_date_outside = date(2023, 10, 25)
-
-    assert utilities.is_date_in_date_range(
-        check_date_inside, valid_date_range) is True
-    assert utilities.is_date_in_date_range(
-        check_date_outside, valid_date_range) is False
-    assert utilities.is_date_in_date_range(
-        check_date_inside, invalid_date_range) is False
-
-
-def test_is_datetime_in_datetime_range():
-    valid_datetime_range = [
-        datetime(2023, 10, 26, 12, 34, 56), datetime(2023, 10, 27, 23, 45, 12)]
-    invalid_datetime_range = [
-        datetime(2023, 10, 26, 12, 34, 56), time(23, 45, 12)]  # Invalid format
-    check_datetime_inside = datetime(2023, 10, 27, 15, 0, 0)
-    check_datetime_outside = datetime(2023, 10, 25, 5, 0, 0)
-
-    assert utilities.is_datetime_in_datetime_range(
-        check_datetime_inside, valid_datetime_range) is True
-    assert utilities.is_datetime_in_datetime_range(
-        check_datetime_outside, valid_datetime_range) is False
-    assert utilities.is_datetime_in_datetime_range(
-        check_datetime_inside, invalid_datetime_range) is False
-
-
-def test_minilogger_info():
-    MiniLogger.info("test_minilogger_info")
-
-
-def test_minilogger_error():
-    MiniLogger.error("test_minilogger_error")