event-local 0.0.1__tar.gz

event_local-0.0.1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: event-local
+Version: 0.0.1
+Summary: PyPI Package for Circles event-local Python
+Home-page: https://github.com/circles-zone/event-local-python-package
+Author: Circles
+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: logger-local
+Requires-Dist: database-sql-local
+Requires-Dist: python-sdk-remote
+
+PyPI Package for Circles event-local Python

event_local-0.0.1/event_local/src/constants_event_local.py

@@ -0,0 +1,15 @@
+from logger_local.LoggerComponentEnum import LoggerComponentEnum
+
+# TODO We should bring this value from entity_type_view
+EVENT_ENTITY_TYPE_ID = 14
+
+EVENT_LOCAL_PYTHON_COMPONENT_ID = 247
+EVENT_LOCAL_PYTHON_COMPONENT_NAME = 'event-local-restapi-python-serverless'
+DEVELOPER_EMAIL = 'akiva.s@circ.zone'
+
+EVENTS_LOCAL_CODE_LOGGER_OBJECT = {
+    'component_id': EVENT_LOCAL_PYTHON_COMPONENT_ID,
+    'component_name': EVENT_LOCAL_PYTHON_COMPONENT_NAME,
+    'component_category': LoggerComponentEnum.ComponentCategory.Code.value,
+    'developer_email': DEVELOPER_EMAIL
+}

event_local-0.0.1/event_local/src/event_local.py

@@ -0,0 +1,159 @@
+from database_mysql_local.generic_crud import GenericCRUD, DEFAULT_SQL_SELECT_LIMIT
+from location_local.locations_local_crud import LocationsLocal
+from logger_local.MetaLogger import MetaLogger
+from .constants_event_local import EVENTS_LOCAL_CODE_LOGGER_OBJECT, EVENT_ENTITY_TYPE_ID
+from .validate_inputs import ValidateInputs
+
+
+
+
+class EventsLocal(GenericCRUD, metaclass=MetaLogger, object=EVENTS_LOCAL_CODE_LOGGER_OBJECT):
+    def __init__(self, is_test_data: bool = False) -> None:
+        super().__init__(default_schema_name="event", default_column_name="event_id",
+                         default_table_name="event_table", default_view_table_name="event_view",
+                         is_test_data=is_test_data)
+        self.validate_inputs = ValidateInputs(is_test_data=is_test_data)
+
+    # TODO: test
+    def select_all_events(self, lang_code_str: str, limit: int = None) -> list:
+        """Returns all the rows in the event_table"""
+        limit = limit or DEFAULT_SQL_SELECT_LIMIT
+        # TODO If we don't have result int the profile preferred language, we should bring the English version
+        # TODO If event has multiple names we should bring the one which is_main = TRUE
+        sql_query = f"""
+            SELECT event.event_id         AS 'event_id',
+                   {EVENT_ENTITY_TYPE_ID} AS 'item_type_id',
+                   event.location_id,
+                   event.organizers_profile_id,
+                   event.website_url,
+                   event.facebook_event_url,
+                   event.meetup_event_url,
+                   event_ml.title
+            FROM event.event_view AS event
+                     LEFT JOIN event.event_ml_view AS event_ml ON event.event_id = event_ml.event_id
+                AND event_ml.lang_code = %s
+            LIMIT {limit}"""
+        self.cursor.execute(sql_query, (lang_code_str,))
+        columns = ("event_id, item_type_id, location_id, organizers_profile_id, website_url, "
+                   "facebook_event_url, meetup_event_url, title")
+        events_dict = self.convert_multi_to_dict(self.cursor.fetchall(), columns)
+        return events_dict
+
+    def select_events_by_title(self, title: str, limit: int = None) -> list:
+        """Returns all the events that have the given title"""
+        limit = limit or DEFAULT_SQL_SELECT_LIMIT
+        events_list = self.select_multi_dict_by_column_and_value(
+            view_table_name="event_ml_view", column_name="title", column_value=title, limit=limit)
+        return events_list
+
+    # TODO: test
+    def select_events_by_profile_id(self, profile_id: int, limit: int = None) -> list:
+        """Returns all the events that are related to the given profile_id"""
+        self.validate_inputs.validate_id(profile_id, schema="profile")
+        limit = limit or DEFAULT_SQL_SELECT_LIMIT
+        # TODO: should we move this to a view?
+        sql_query = f"""
+        WITH EventCommonGroups AS (
+            SELECT event.event_id,
+                   event_ml.title,
+                   {EVENT_ENTITY_TYPE_ID}        AS item_type,
+                   COUNT(group_profile.group_id) AS common_group_count
+            FROM event.event_view AS event
+                     LEFT JOIN
+                 event.event_ml_view AS event_ml ON event.event_id = event_ml.event_id
+                     LEFT JOIN
+                 event_group.event_group_view AS event_group ON event.event_id = event_group.event_id
+                     LEFT JOIN
+                 group_profile.group_profile_view AS group_profile
+                 ON event_group.group_id = group_profile.group_id AND
+                    group_profile.profile_id = %s
+            GROUP BY event.event_id, event_ml.title
+        )
+
+        SELECT event.event_id,
+               event.location_id,
+               event.organizers_profile_id,
+               event.website_url,
+               event.facebook_event_url,
+               event.meetup_event_url,
+               event.registration_url,
+               EventCommonGroups.title,
+               EventCommonGroups.item_type,
+               EventCommonGroups.common_group_count,
+               event_location.location_id AS event_location_id,
+               (COALESCE(1 / ST_Distance(
+                       event_location.coordinate, COALESCE(location_profile.coordinate, event_location.coordinate)), 0)) AS distance_rank,
+               (COALESCE(1 / ST_Distance(
+                       event_location.coordinate, COALESCE(location_profile.coordinate, event_location.coordinate)), 0)) +
+                        COALESCE(EventCommonGroups.common_group_count / 5, 0)               AS final_rank
+        FROM EventCommonGroups
+                 LEFT JOIN
+             event.event_view AS event ON EventCommonGroups.event_id = event.event_id
+                 LEFT JOIN
+             (SELECT event_location.event_id,
+                     event_location.location_id,
+                     location.coordinate
+              FROM event_location.event_location_view AS event_location
+                       LEFT JOIN location.location_view AS location ON event_location.location_id = location.location_id) AS event_location
+             ON event.event_id = event_location.event_id
+                 LEFT JOIN
+             (SELECT location_profile.location_id,
+                     location.coordinate,
+                     location_profile.profile_id
+              FROM location_profile.location_profile_view AS location_profile
+                       LEFT JOIN location.location_view AS location ON location_profile.location_id = location.location_id
+              ORDER BY location_profile.start_timestamp DESC
+              LIMIT 1) AS location_profile ON location_profile.profile_id = %s
+                 LEFT JOIN
+             location.location_view AS location ON location.location_id = location_profile.location_id
+        ORDER BY final_rank DESC
+        LIMIT {limit};
+        """
+
+        self.cursor.execute(sql_query, (profile_id, profile_id))
+        columns = ("event.event_id, eventlocation_id, eventorganizers_profile_id, eventwebsite_url, "
+                   "eventfacebook_event_url, eventmeetup_event_url, eventregistration_url, title, item_type, "
+                   "common_group_count, event_location_id, distance_rank, final_rank")
+        events_dict = self.convert_multi_to_dict(self.cursor.fetchall(), columns)
+
+        return events_dict
+
+    def select_by_event_id(self, event_id: int) -> dict:
+        """Returns the event row with the given event_id"""
+        self.validate_inputs.validate_id(event_id)
+        # TODO add support to event-external
+        select_clause = "event_id, location_id, organizers_profile_id, website_url, facebook_event_url, meetup_event_url, registration_url"
+        event = self.select_one_dict_by_column_and_value(column_value=event_id, select_clause_value=select_clause)
+        return event
+
+    def insert_event_data(self, event_data: dict) -> int:
+        """Inserts a row into the event_table and returns the id of the inserted row"""
+        self.validate_inputs.validate_input_dict(input_dict=event_data)
+        event_id = self.insert(data_dict=event_data)
+        return event_id
+
+    def update_by_event_id(self, event_id: int, event_data: dict) -> int:
+        """Updates the event row with the given event_id"""
+        self.validate_inputs.validate_id(event_id)
+        self.validate_inputs.validate_input_dict(input_dict=event_data)
+        amount_of_events_updated = self.update_by_column_and_value(column_value=event_id, data_dict=event_data)
+        return amount_of_events_updated
+
+    def delete_by_event_id(self, event_id: int) -> int:
+        """Deletes the event row with the given event_id"""
+        self.validate_inputs.validate_id(event_id)
+        amount_of_events_deleted = self.delete_by_column_and_value(column_value=event_id)
+        return amount_of_events_deleted
+
+    def get_test_event_id(self) -> int:
+        location_id = LocationsLocal().get_test_location_id()
+        test_event_id = super().get_test_entity_id(
+            entity_name="event", insert_function=self.insert,
+            view_name="event_view", insert_kwargs={'location_id': location_id})
+        return test_event_id
+    
+    def get_number_of_events(self) -> int:
+        sql_statement = "SELECT COUNT(*) FROM event.event_view"
+        self.cursor.execute(sql_statement=sql_statement)
+        number_of_events = self.cursor.fetchone()[0]
+        return number_of_events

event_local-0.0.1/event_local/src/handler.py

@@ -0,0 +1,101 @@
+from logger_local.LoggerLocal import Logger
+from python_sdk_local.http_response import handler_decorator
+from python_sdk_local.utilities import DEFAULT_LANG_CODE_STR
+
+from .constants_event_local import EVENTS_LOCAL_CODE_LOGGER_OBJECT
+from .event_local import EventsLocal
+
+logger = Logger.create_logger(object=EVENTS_LOCAL_CODE_LOGGER_OBJECT)
+
+
+@handler_decorator(logger)
+def createHandler(request_parameters: dict) -> dict:
+    # In all serverless-com handlers' logger.start()- Add optional parameter
+    # to logger.start() which called api_call, so logger.start will call
+    # api_management to insert into api_call_table all fields including
+    # session_id.
+    """Read parameters from the payload and insert them"""
+
+    is_test_data = request_parameters.get("isTestData", False)
+    event_id = EventsLocal(is_test_data=is_test_data).insert_event_data(request_parameters)
+    message = {"message": "Event created successfully", "event_id": event_id}
+    return message
+
+
+# TODO: except ValueError as exception, BAD_REQUEST / INTERNAL_SERVER_ERROR...
+
+
+@handler_decorator(logger)
+def deleteHandler(request_parameters: dict) -> dict:
+    """url/5   (5 is the eventId)"""
+
+    event_id = request_parameters.get('eventId')
+    is_test_data = request_parameters.get("isTestData", False)
+    EventsLocal(is_test_data=is_test_data).delete_by_event_id(event_id=event_id)
+    message = {"message": "Event deleted successfully"}
+    return message
+
+
+# TODO This should be imported from entity-type-python-package (this file will be generated by Sql2Code)
+@handler_decorator(logger)
+def getAllHandler(request_parameters: dict) -> list:
+    """url?langCode=en&limit=10"""
+
+    lang_code_str = request_parameters.get("langCode") or DEFAULT_LANG_CODE_STR
+    limit = request_parameters.get("limit")
+    is_test_data = request_parameters.get("isTestData", False)
+    events_list = EventsLocal(is_test_data=is_test_data).select_all_events(lang_code_str, limit=limit)
+    return events_list
+
+
+@handler_decorator(logger)
+def getEventByProfileIdHandler(request_parameters: dict) -> list:
+    """url/5?limit=10   (5 is the profileId)"""
+
+    request_parameters = request_parameters
+    profile_id = request_parameters.get("profileId")
+    limit = request_parameters.get("limit")
+
+    is_test_data = request_parameters.get("isTestData", False)
+    events_list = EventsLocal(is_test_data=is_test_data).select_events_by_profile_id(profile_id, limit=limit)
+    return events_list
+
+
+@handler_decorator(logger)
+def getEventByEventIdHandler(request_parameters: dict) -> dict:
+    """url/5?isTestData=true   (eventId)"""
+
+    event_id = request_parameters.get("eventId")
+
+    is_test_data = request_parameters.get("isTestData", False)
+    event = EventsLocal(is_test_data=is_test_data).select_by_event_id(event_id)
+    if not event:
+        raise Exception(f"Event not found with event_id: {event_id}")
+    return event
+
+
+@handler_decorator(logger)
+def updateHandler(request_parameters: dict) -> dict:
+    """url/5  (eventId)
+    Read parameters from the payload and update them"""
+
+    event_id = request_parameters.get('eventId')
+    is_test_data = request_parameters.get("isTestData", False)
+    if not event_id:
+        raise Exception("event_id is required")
+
+    EventsLocal(is_test_data=is_test_data).update_by_event_id(event_id, request_parameters)
+    message = {"message": "Event updated successfully"}
+    return message
+
+
+@handler_decorator(logger)
+def getEventByEventTitleHandler(request_parameters: dict) -> list:  # TODO: test
+    """url/SomeTitle?limit=10"""
+
+    title = request_parameters.get("title")
+
+    limit = request_parameters.get("limit")
+    is_test_data = request_parameters.get("isTestData", False)
+    events_list = EventsLocal(is_test_data=is_test_data).select_events_by_title(title, limit=limit)
+    return events_list

event_local-0.0.1/event_local/src/holiday_local.py

@@ -0,0 +1,78 @@
+from typing import Dict
+
+import holidays
+from database_mysql_local.generic_crud import GenericCRUD
+from logger_local.MetaLogger import MetaLogger
+
+# from location_local.locations_local_crud import LocationsLocal
+from .constants_event_local import EVENT_CODE_LOGGER_OBJECT
+
+
+# TODO: test
+class HolidayLocal(GenericCRUD, metaclass=MetaLogger, object=EVENT_CODE_LOGGER_OBJECT):
+    """HolidayLocal"""
+
+    def __init__(self, is_test_data: bool = False) -> None:
+        super().__init__(default_schema_name="event",
+                         default_table_name="event_table",
+                         default_view_table_name="event_view",
+                         default_column_name="event_id",
+                         is_test_data=is_test_data)
+
+    def insert_holiday(self, *, date: str, holiday: str,
+                       country: str, state: str = None) -> int:
+        """Inserts a new holiday and returns the new holiday_id"""
+
+        # location_obj = LocationsLocal()
+        # lang_code = "en"
+        # all_details = {"coordinate": {"latitude": None, "longitude": None}, "address_local_language": None,
+        #                "address_english": None, "neighborhood": None, "county": None, "region": None, "state": state,
+        #                "country": country, "postal_code": None, "plus_code": None, "is_approved": False}
+        # location_id = location_obj.get_location_ids(all_details, lang_code, True)
+        location_id = 3  # TODO
+        if self.holiday_exists(date=date, holiday=holiday, country=country, state=state):
+            event_table_data = {
+                "start_timestamp": date,
+                "location_id": location_id,
+                "website_url": "test for holiday"
+            }
+            holiday_id = super().insert(data_dict=event_table_data)
+            return holiday_id
+
+    def update_holiday(self, *, holiday_id: int, holiday_data: Dict[str, any]) -> None:
+        """Updates an existing holiday"""
+        event_table_data = {
+            "date": holiday_data.get('date'),
+            "holiday": holiday_data.get('holiday'),
+            "country": holiday_data.get('country'),
+            "state": holiday_data.get('state')
+        }
+        super().update_by_column_and_value(column_value=holiday_id, data_dict=event_table_data)
+
+    def get_holiday_by_id(self, holiday_id: int) -> Dict[str, any]:
+        """Gets holiday information by holiday_id"""
+        holiday_dict = self.select_one_dict_by_column_and_value(column_value=holiday_id)
+        return holiday_dict
+
+    def delete_holiday_by_id(self, holiday_id: int) -> None:
+        """Deletes a holiday by holiday_id"""
+        self.delete_by_column_and_value(column_value=holiday_id)
+
+    def holiday_exists(self, *, date: str, holiday: str, country: str, state: str = None) -> bool:
+        """Checks if a holiday with the given details already exists in the database"""
+        # TODO: fix
+        # conditions = {
+        #     "date": date,
+        #     "holiday": holiday,
+        #     "country": country,
+        #     "state": state
+        # }
+        existing_holiday = self.select_one_dict_by_column_and_value(
+            view_table_name="event_view", column_name="event_id", column_value="2")
+        return existing_holiday is not None
+
+    @staticmethod
+    def fetch_holidays(country: str, year: int) -> list:
+        """fetch us holidays"""
+        holidays_list = sorted(holidays.country_holidays(country, years=year).keys())
+        return holidays_list

event_local-0.0.1/event_local/src/validate_inputs.py

@@ -0,0 +1,73 @@
+from database_mysql_local.generic_crud import GenericCRUD
+from database_mysql_local.table_columns import table_columns
+from python_sdk_remote.utilities import validate_url
+
+event_table_columns = table_columns["event_table"]
+
+
+# Note: if you shange those messages, update the tests accordingly
+class ValidateInputs(GenericCRUD):
+    def __init__(self, is_test_data: bool = False) -> None:
+        super().__init__(default_schema_name="event", default_column_name="event_id",
+                         default_table_name="event_table", default_view_table_name="event_view",
+                         is_test_data=is_test_data)
+
+    def validate_location_id(self, location_id: int) -> None:
+        if location_id is None or not isinstance(location_id, int) or location_id < 0:
+            raise ValueError(f"Invalid location_id: {location_id} (type: {type(location_id)})")
+        _location_id = self.select_one_value_by_column_and_value(
+            schema_name="location", view_table_name="location_view", select_clause_value="location_id",
+            column_name="location_id", column_value=location_id)
+        if _location_id is None:
+            raise ValueError(f"Invalid location_id: {location_id} (not found in location.location_view)")
+
+    def validate_organizers_profile_id(self, organizers_profile_id: int) -> None:
+        if not organizers_profile_id or not isinstance(organizers_profile_id, int) or organizers_profile_id <= 0:
+            raise ValueError(
+                f"Invalid organizers_profile_id: {organizers_profile_id} (type: {type(organizers_profile_id)})")
+        _organizers_profile_id = self.select_one_value_by_column_and_value(
+            schema_name="profile", view_table_name="profile_view", select_clause_value="profile_id",
+            column_name="profile_id", column_value=organizers_profile_id)
+        if _organizers_profile_id is None:
+            raise ValueError(
+                f"Invalid organizers_profile_id: {organizers_profile_id} (not found in profile.profile_view)")
+
+    def validate_input_dict(self, input_dict: dict) -> None:
+        location_id = input_dict.get('location_id')
+        organizers_profile_id = input_dict.get('organizers_profile_id')
+        website_url = input_dict.get('website_url')
+        facebook_event_url = input_dict.get('facebook_event_url')
+        meetup_event_url = input_dict.get('meetup_event_url')
+        registration_url = input_dict.get('registration_url')
+        # TODO: allowed_keys = [...] and set(input_dict.keys()) == set(allowed_keys)
+        self.validate_location_id(location_id)
+        self.validate_organizers_profile_id(organizers_profile_id)
+
+        if website_url and not validate_url(website_url):
+            raise ValueError(f"Invalid input: website_url - {website_url}")
+        if facebook_event_url and not validate_url(facebook_event_url):
+            raise ValueError(f"Invalid input: facebook_event_url - {facebook_event_url}")
+        if meetup_event_url and not validate_url(meetup_event_url):
+            raise ValueError(f"Invalid input: meetup_event_url - {meetup_event_url}")
+        if registration_url and not validate_url(registration_url):
+            raise ValueError(f"Invalid input: registration_url - {registration_url}")
+
+        for key in list(input_dict):
+            if key not in event_table_columns:
+                input_dict.pop(key)
+
+    # TODO Move this function to database-mysql-python-package and make it generic for all tables using Entity enum
+    def validate_id(self, entity_id: int, schema: str = "event") -> None:
+        try:
+            entity_id = int(entity_id)
+            if entity_id < 0:
+                raise ValueError
+        except ValueError:
+            raise ValueError(f"Invalid {schema}_id: {entity_id}")
+        assert ";" not in schema  # Prevent SQL Injection
+        value = self.select_one_value_by_column_and_value(schema_name=schema, view_table_name=schema + "_view",
+                                                          select_clause_value=schema + "_id",
+                                                          column_name=schema + "_id",
+                                                          column_value=entity_id)
+        if value is None:
+            raise ValueError(f"Invalid {schema}_id: {entity_id} (not found in {schema}.{schema}_view)")

event_local-0.0.1/event_local.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: event-local
+Version: 0.0.1
+Summary: PyPI Package for Circles event-local Python
+Home-page: https://github.com/circles-zone/event-local-python-package
+Author: Circles
+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: logger-local
+Requires-Dist: database-sql-local
+Requires-Dist: python-sdk-remote
+
+PyPI Package for Circles event-local Python

event_local-0.0.1/event_local.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+pyproject.toml
+setup.py
+event_local.egg-info/PKG-INFO
+event_local.egg-info/SOURCES.txt
+event_local.egg-info/dependency_links.txt
+event_local.egg-info/requires.txt
+event_local.egg-info/top_level.txt
+event_local/src/__init__.py
+event_local/src/constants_event_local.py
+event_local/src/event_local.py
+event_local/src/handler.py
+event_local/src/holiday_local.py
+event_local/src/validate_inputs.py

event_local-0.0.1/event_local.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

event_local-0.0.1/event_local.egg-info/requires.txt

@@ -0,0 +1,3 @@
+logger-local
+database-sql-local
+python-sdk-remote

event_local-0.0.1/event_local.egg-info/top_level.txt

@@ -0,0 +1 @@
+event_local

event_local-0.0.1/pyproject.toml

@@ -0,0 +1,21 @@
+# This file should be in the future instead of setup.py
+# https://python-poetry.org/docs/pyproject
+
+# This file is mandatory for the `poetry version patch`
+
+# It seems we need to copy this file also to serverless-com repo, as required by dialog-workflow-python-package
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.poetry]
+# TODO: Please update the name, similar to storage-local (suffix -local)
+name = "event-local"
+# I believe we are still using the version from setup.py and not from here until Potery will work
+version = "0.0.2" # https://pypi.org/project/<project-name> i.e. https://pypi.org/project/storage-local/
+description = "Event Local Python Package"
+readme = "README.md"
+authors = [
+    "Circlez.ai <info@circlez.ai>",
+]

event_local-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

event_local-0.0.1/setup.py

@@ -0,0 +1,42 @@
+# Trying to create a package from a repo that includes both local and serverless.com 
+
+import setuptools
+
+# TODO: Change the PACKAGE_NAME to the package's name - Either xxx-local or xxx-remote (without the -python-package suffix). Only lowercase, no underlines.
+# Used by pypa/gh-action-pypi-publish
+# Package Name should be identical to the inner directory name
+# Changing the package name here, will cause changing the package directory name as well
+# PACKAGE_NAME should be singular if handling only one instance
+# PACKAGE_NAME should not include the word "main"
+PACKAGE_NAME = "event-local"  # e.g.: queue-local, without python-package suffix
+
+package_dir = PACKAGE_NAME.replace("-", "_")
+# If we need backward-compatible:
+# old_package_dir = "old_package_name"
+    
+setuptools.setup(
+    name=PACKAGE_NAME,
+    version='0.0.1',  # increase this number every time you make a change you want to publish. After 0.0.9 switch to 0.0.10 and not 0.1.0
+    author="Circles",
+    author_email="info@circlez.ai",
+    description=f"PyPI Package for Circles {PACKAGE_NAME} Python",
+    long_description=f"PyPI Package for Circles {PACKAGE_NAME} Python",
+    long_description_content_type='text/markdown',
+    url=f"https://github.com/circles-zone/{PACKAGE_NAME}-python-package",
+    packages=[package_dir],
+    # packages=[package_dir, old_package_dir],
+    package_dir={package_dir: f'{package_dir}/src'},
+    # package_dir={package_dir: f'{package_dir}/src', old_package_dir: f'{package_dir}/src'},
+    package_data={package_dir: ['*.py']},
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: Other/Proprietary License",
+        "Operating System :: OS Independent",
+    ],
+    # TODO: Update which packages to include with this package in production (dependencies) - Not for development/testing
+    install_requires=[
+        'logger-local',  # TODO: in -remote package please use logger-remote instead.
+        'database-sql-local',  # TODO: In -remote package please delete this line.
+        'python-sdk-remote'
+    ]
+)