python-sdk-remote 0.0.60__tar.gz → 0.0.63__tar.gz

{python-sdk-remote-0.0.60 → python-sdk-remote-0.0.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sdk-remote
-Version: 0.0.60
+Version: 0.0.63
 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.60 → python-sdk-remote-0.0.63}/README.md

@@ -1,21 +1,24 @@
 # python-package-backend-template
+
 To create local package and remote package layers (not to create GraphQL and REST-API layers)
 
 #database Python scripts in /db folder
 Please place <table-name>.py in /db<br>
 No need for seperate file for _ml table<br>
 Please delete the example file if not needed<br>
-  
+
 # Create the files to create the database schema, tables, view and populate Meta Data and Test Date
+
 /db/<table-name>.py - CREATE SCHEMA ... CREATE TABLE ... CREATE VIEW ...<br>
 /db/<table-name>_insert.py to create records
 
 # Update the setup.py (i.e.name, version)
- 
+
 # Please create test directory inside the directory of the project i.e. /<project-name>/tests
 
 # Update the serverless.yml in the root directory
+
 provider:
-  stage: play1
-  
+stage: play1
+
 Update the endpoints in serverless.yml

{python-sdk-remote-0.0.60 → python-sdk-remote-0.0.63}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "setuptools.build_meta"
 [tool.poetry]
 name = "python-sdk-local"
 # I believe we are still using the version from setup.py and not from here until potery will work
-version = "0.0.59" # https://pypi.org/project/python-sdk-local i.e. https://pypi.org/project/storage-local/
+version = "0.0.1" # https://pypi.org/project/python-sdk-local i.e. https://pypi.org/project/storage-local/
 description = "python-sdk-local Python Package"
 readme = "README.md"
 authors = [

python-sdk-remote-0.0.63/python_sdk_remote/src/constants.py

@@ -0,0 +1,25 @@
+import os
+
+from logger_local.LoggerComponentEnum import LoggerComponentEnum
+
+PYTHON_SDK_LOCAL_COMPONENT_ID = 184
+PYTHON_SDK_LOCAL_COMPONENT_NAME = 'python_sdk_local'
+
+ENVIRONMENT_NAME = os.getenv("ENVIRONMENT_NAME")
+BRAND_NAME = os.getenv("BRAND_NAME")
+LOGZIO_TOKEN = os.getenv("LOGZIO_TOKEN")
+
+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': 'sahar.g@circ.zone'
+}
+
+OBJECT_TO_INSERT_TEST = {
+    'component_id': PYTHON_SDK_LOCAL_COMPONENT_ID,
+    'component_name': PYTHON_SDK_LOCAL_COMPONENT_NAME,
+    'component_category': LoggerComponentEnum.ComponentCategory.Unit_Test.value,
+    'testing_framework': LoggerComponentEnum.testingFramework.pytest.value,
+    'developer_email': 'sahar.g@circ.zone'
+}

python-sdk-remote-0.0.63/python_sdk_remote/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):
+        raise NotImplementedError("Subclasses must implement the 'get_id' method.")

python-sdk-remote-0.0.63/python_sdk_remote/src/mini_logger.py

@@ -0,0 +1,91 @@
+import sys
+from datetime import datetime
+
+
+class MiniLogger:
+    # TODO Can we so one generic function call by all
+    # TODO Shall we user the Python logging package?
+
+    @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} - {str(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} - {str(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} - {str(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:
+            print(f"{datetime.now()} - WARNING - {message}")
+        else:
+            print(f"{datetime.now()} - WARNING {message} - {str(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} - {str(object)}", file=sys.stderr)
+
+    @staticmethod
+    def exception(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()} - EXCEPTION - {message}", file=sys.stderr)
+        else:
+            print(
+                f"{datetime.now()} - EXCEPTION- {message} - {str(object)}", file=sys.stderr)

python-sdk-remote-0.0.63/python_sdk_remote/src/our_object.py

@@ -0,0 +1,59 @@
+import json
+from abc import ABC, abstractmethod
+
+from logger_local.Logger import Logger  # TODO Shouldn't we use mini logger?
+
+from .constants import OBJECT_TO_INSERT_CODE
+
+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):
+        """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)
+        value = arguments.get(attr_name, None)
+        logger.end(GET_METHOD_NAME, object={'attr_name': attr_name})
+        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':
+        """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})
+        self.__dict__ = json.loads(json_string)
+        logger.end(FROM_JSON_METHOD_NAME,
+                   object={'json_dict': self.__dict__})
+        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-remote-0.0.63/python_sdk_remote/src/unified_json.py

@@ -0,0 +1,18 @@
+from .valid_json_version import valid_json_versions
+class UnifiedJson:
+    def __init__(self, data: dict, version: str):
+        if version not in valid_json_versions:
+            raise Exception(
+                f"version {version} is not in valid_json_versions {valid_json_versions}"
+            )
+        self.version = version
+        self.data = data
+
+    def get_unified_json(self):
+        return {"version": self.version, "data": self.data}
+
+    def __str__(self):
+        return self.get_unified_json()
+
+    def __repr__(self):
+        return self.__str__()

python-sdk-remote-0.0.63/python_sdk_remote/src/utilities.py

@@ -0,0 +1,303 @@
+import json
+import os
+from datetime import date, datetime, time, timedelta
+from urllib.parse import urlparse
+
+from dotenv import load_dotenv
+from logger_local.Logger import Logger
+
+from .constants import (BRAND_NAME, ENVIRONMENT_NAME,  # noqa: E402
+                        OBJECT_TO_INSERT_CODE)
+from .validate_environment import validate_brand_name  # noqa: E402
+from .validate_environment import validate_environment_name
+
+load_dotenv()  # for our_get_env
+logger = Logger.create_logger(object=OBJECT_TO_INSERT_CODE)
+
+
+def timedelta_to_time_format(time_delta: timedelta) -> str:
+    """
+    Convert a timedelta to a time format in HH:MM:SS.
+
+    Parameters:
+        time_delta (datetime.timedelta): The timedelta to be converted.
+
+    Returns:
+        str: A string in HH:MM:SS format representing the time duration.
+
+    Example:
+        Usage of timedelta_to_time_format:
+
+        >>> from datetime import timedelta
+        >>> duration = timedelta(hours=2, minutes=30, seconds=45)
+        >>> formatted_time = timedelta_to_time_format(duration)
+        >>> print(formatted_time)
+        '02:30:45'
+    """
+    TIMEDELTA_TO_TIME_FORMAT_METHOD_NAME = "timedelta_to_time_format"
+    logger.start(TIMEDELTA_TO_TIME_FORMAT_METHOD_NAME, object={'time_delta': time_delta})
+
+    # Calculate the total seconds and convert to HH:MM:SS format
+    total_seconds = int(time_delta.total_seconds())
+    hours = total_seconds // 3600
+    minutes = (total_seconds % 3600) // 60
+    seconds = total_seconds % 60
+
+    # 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})
+    return formatted_time
+
+
+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__()})
+    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"})
+        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"})
+            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"})
+            return False
+
+    logger.end(IS_VALID_TIME_RANGE_METHOD_NAME, object={
+        "is_valid_time_range_result": True})
+    return True
+
+
+def validate_url(url):
+    if url is not None or url != "":
+        parsed_url = urlparse(url)
+        return parsed_url.scheme and parsed_url.netloc
+    return True
+
+
+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__()})
+    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"})
+        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"})
+            return False
+    logger.end(IS_VALID_DATE_RANGE_METHOD_NAME, object={
+        "is_valid_date_range_result": True})
+    return True
+
+
+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__()})
+    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"})
+        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"})
+            return False
+    logger.end(IS_VALID_DATETIME_RANGE_METHOD_NAME, object={
+        "is_valid_datetime_range_result": True})
+    return True
+
+
+def is_list_of_dicts(obj):
+    """
+    Check if an object is a list of dictionaries.
+
+    Parameters:
+        obj (object): The object to be checked.
+
+    Returns:
+        bool: True if the object is a list of dictionaries, False otherwise.
+
+    Example:
+        Usage of is_list_of_dicts:
+
+        >>> data = [{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}]
+        >>> result = is_list_of_dicts(data)
+        >>> print(result)
+        True
+
+        >>> data = [1, 2, 3]
+        >>> result = is_list_of_dicts(data)
+        >>> print(result)
+        False
+    """
+    IS_LIST_OF_DICTS_FUNCTION_NAME = "is_list_of_dicts"
+    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})
+            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})
+                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})
+        return is_list_of_dicts_result
+    except Exception as e:
+        logger.end(IS_LIST_OF_DICTS_FUNCTION_NAME, exception=e)
+        raise e
+
+
+def is_time_in_time_range(check_time: time, time_range: tuple) -> bool:
+    """
+    Check if the given time is within the specified time range.
+
+    Parameters:
+        check_time (str): The time to check in 'HH:MM:SS' format.
+        time_range (tuple): A tuple containing start and end times in 'HH:MM:SS' format.
+
+    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={
+        "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})
+    return start_time <= check_time <= end_time
+
+
+def is_date_in_date_range(check_date: date, date_range: tuple) -> bool:
+    """
+    Check if the given date is within the specified date range.
+
+    Parameters:
+        check_date (str): The date to check in 'YYYY-MM-DD' format.
+        date_range (tuple): A tuple containing start and end dates in 'YYYY-MM-DD' format.
+
+    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={
+        "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})
+    return start_date <= check_date <= end_date
+
+
+def is_datetime_in_datetime_range(check_datetime: datetime, datetime_range: tuple) -> bool:
+    """
+    Check if the given datetime is within the specified datetime range.
+
+    Parameters:
+        check_datetime (str): The datetime to check in 'YYYY-MM-DD HH:MM:SS' format.
+        datetime_range (tuple): A tuple containing start and end datetimes in 'YYYY-MM-DD HH:MM:SS' format.
+
+    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)
+    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_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={
+        "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):
+    http_headers = {
+        'Content-Type': 'application/json',
+        'Authorization': f'Bearer {user_jwt}',
+    }
+    return http_headers
+
+
+def create_return_http_headers():
+    return {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+    }
+
+
+# https://google.github.io/styleguide/jsoncstyleguide.xml?showone=Property_Name_Format#Property_Name_Format
+def create_http_body(body):
+    # 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():
+    validate_brand_name()
+    return BRAND_NAME
+
+
+def get_environment_name():
+    validate_environment_name()
+    return ENVIRONMENT_NAME
+
+
+def our_get_env(key: str) -> str:
+    return os.getenv(key)
+
+
+def get_sql_hostname():
+    return our_get_env("RDS_HOSTNAME")
+
+
+def get_sql_username():
+    return our_get_env("RDS_USERNAME")
+
+
+def get_sql_password():
+    return our_get_env("RDS_PASSWORD")

python-sdk-remote-0.0.63/python_sdk_remote/src/valid_json_versions.py

@@ -0,0 +1,4 @@
+# Later we'll generate this file using Sql2Code (from json_version database schema)
+valid_json_versions = {
+    "240109"
+}

python-sdk-remote-0.0.63/python_sdk_remote/src/validate_environment.py

@@ -0,0 +1,32 @@
+from .constants import BRAND_NAME, ENVIRONMENT_NAME, LOGZIO_TOKEN
+
+
+# TODO Align with https://github.com/circles-zone/typescript-sdk-remote-typescript-package/edit/dev/typescript-sdk/src/utils/index.ts validateTenantEnvironmentVariables()  # noqa501
+def validate_enviroment_variables():
+    validate_brand_name()
+    validate_environment_name()
+    # if(os.getenv("PRODUCT_USER_IDENTIFIER") is None):
+    #     raise Exception("logger-local-python-package LoggerLocal.py please add Environment Variable called "
+    #                     "PRODUCT_USER_IDENTIFIER (instead of PRODUCT_USERNAME)")
+    # removed by Idan because it dont has to be in every project
+    # if(os.getenv("PRODUCT_PASSWORD") is None):
+    #     raise Exception("logger-local-python-package LoggerLocal.py please add Environment Variable called PRODUCT_PASSWORD")
+    validate_logzio_token()
+
+
+def validate_environment_name():
+    if ENVIRONMENT_NAME is None:
+        raise Exception("logger-local-python-package LoggerLocal.py please add Environment Variable called "
+                        "ENVIRONMENT_NAME=local or play1 (instead of ENVIRONMENT)")
+
+
+def validate_brand_name():
+    if BRAND_NAME is None:
+        raise Exception(
+            "logger-local-python-package LoggerLocal.py please add Environment Variable called BRAND_NAME=Circlez")
+
+
+def validate_logzio_token():
+    if LOGZIO_TOKEN is None:
+        raise Exception("logger-local-python-package LoggerLocal.py please add Environment Variable called"
+                        " LOGZIO_TOKEN=cXNHuVkkffkilnkKzZlWExECRlSKqopE")

{python-sdk-remote-0.0.60 → python-sdk-remote-0.0.63}/python_sdk_remote.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sdk-remote
-Version: 0.0.60
+Version: 0.0.63
 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.63/python_sdk_remote.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+setup.py
+python_sdk_remote.egg-info/PKG-INFO
+python_sdk_remote.egg-info/SOURCES.txt
+python_sdk_remote.egg-info/dependency_links.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/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-remote-0.0.63/python_sdk_remote.egg-info/top_level.txt

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

{python-sdk-remote-0.0.60 → python-sdk-remote-0.0.63}/setup.py

@@ -1,20 +1,25 @@
 import setuptools
 
+PACKAGE_NAME = "python-sdk-remote"
+package_dir = PACKAGE_NAME.replace("-", "_")
+
 # used by python -m build
 # python -m build needs pyproject.toml or setup.py
 setuptools.setup(
-    name='python-sdk-remote',
-    version='0.0.60',  # https://pypi.org/project/python-sdk-remote/
+    name=PACKAGE_NAME,
+    version='0.0.63',  # https://pypi.org/project/python-sdk-remote/
     author="Circles",
     author_email="info@circles.life",
     description="PyPI Package for Circles Python SDK Local Python",
     long_description="This is a package for sharing common functions used in different repositories",
     long_description_content_type="text/markdown",
     url="https://github.com/circles-zone/python-sdk-remote-python-package",
-    packages=setuptools.find_packages(),
+    packages=[package_dir],
+    package_dir={package_dir: f'{package_dir}/src'},
+    package_data={package_dir: ['*.py']},
     classifiers=[
-         "Programming Language :: Python :: 3",
-         "License :: Other/Proprietary License",
-         "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "License :: Other/Proprietary License",
+        "Operating System :: OS Independent",
     ],
 )

python-sdk-remote-0.0.60/python_sdk_remote.egg-info/SOURCES.txt

@@ -1,7 +0,0 @@
-README.md
-pyproject.toml
-setup.py
-python_sdk_remote.egg-info/PKG-INFO
-python_sdk_remote.egg-info/SOURCES.txt
-python_sdk_remote.egg-info/dependency_links.txt
-python_sdk_remote.egg-info/top_level.txt

python-sdk-remote-0.0.60/python_sdk_remote.egg-info/top_level.txt

@@ -1 +0,0 @@
-