brynq-sdk-task-scheduler 3.0.10__tar.gz → 4.0.0__tar.gz

{brynq_sdk_task_scheduler-3.0.10 → brynq_sdk_task_scheduler-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq_sdk_task_scheduler
-Version: 3.0.10
+Version: 4.0.0
 Summary: Code to execute tasks in BrynQ.com with the task scheduler
 Home-page: UNKNOWN
 Author: BrynQ

{brynq_sdk_task_scheduler-3.0.10 → brynq_sdk_task_scheduler-4.0.0}/brynq_sdk_task_scheduler/task_scheduler.py

@@ -16,104 +16,76 @@ from brynq_sdk_elastic import Elastic
 from brynq_sdk_brynq import BrynQ
 import warnings
 import re
-LOGGING_OPTIONS = Literal['MYSQL', 'ELASTIC']
 
 
-class TaskScheduler(BrynQ):
+class TaskScheduler:
 
-    def __init__(self, task_id: int = None, loglevel: str = 'INFO', email_after_errors: bool = False, logging: List[LOGGING_OPTIONS] | None = ["MYSQL", "ELASTIC"]):
+    def __init__(self, data_interface_id: int = None, loglevel: str = 'INFO', email_after_errors: bool = False):
         """
         The TaskScheduler is responsible for the logging to the database. Based on this logging, the next reload will
         start or not and warning will be given or not
-        :param task_id: The ID from the task as saved in the task_scheduler table in the customer database
+        :param data_interface_id: The ID from the task as saved in the task_scheduler table in the customer database
         :param email_after_errors: a True or False value. When True, there will be send an email to a contactperson of the customer (as given in the database) with the number of errors
         :param loglevel: Chose on which level you want to store the logs. Default is INFO. that means that a logline
         :param disable_logging: If the interface is started from a local instance, logs will not be stored by default. If this is set to True, the logs will be stored in the database
         with level DEBUG not is stored
         """
-        super().__init__()
-        try:
-            self.mysql_enabled = 'MYSQL' in logging
-            self.elastic_enabled = 'ELASTIC' in logging
-        except Exception as e:
-            print("Error parsing logging options, disabling logging. Error is: " + str(e))
+        # If the task is started via the task_scheduler, the following parameters will be passed by the scheduler.
+        # The distinction between local and non local is made because the scheduler usually sets the scheduler_log table entry and run_id. When running locally, the tasks will not log anything by default.
+        if any(flag in sys.argv[0].split('/') for flag in ['opt', 'home']):
+            self.started_local = True
+            self.run_id = int(round(time.time() * 100000))
+            self.task_id = None
+            self.data_interface_id = data_interface_id
+            # set it into environment variables for reuse in source and target systems
+            os.environ['DATA_INTERFACE_ID'] = str(self.data_interface_id)
             self.mysql_enabled = False
             self.elastic_enabled = False
-
-        # Initialize MySQL
-        self.mysql_unreachable = False
-        # if self.mysql_enabled:
-        try:
-            self.mysql = MySQL()
-            self.mysql.ping()
-        except Exception as e:
-            self.mysql_unreachable = True
-            self.mysql = None
-            print("MySQL is enabled but not reachable, logs will be saved locally if needed.")
-        # else:
-        #     self.mysql = None
-
-        # Initialize ElasticSearch
-        self.elastic_unreachable = False
-        if self.elastic_enabled:
-            try:
-                self.es = Elastic()
-                self.es.get_health()
-            except Exception as e:
-                self.elastic_unreachable = True
-                self.es = Elastic(disabled=True)
-                print("ElasticSearch is enabled but not reachable, logs will be saved locally if needed.")
+            print("You're running locally, so your task won't be started in the platform and logs won't be saved")
         else:
-            self.es = Elastic(disabled=True)
-
+            self.started_local = False
+            self.customer_db, self.task_id, self.run_id, self.data_interface_id = sys.argv[1:5]
+            self.mysql_enabled = True
+            self.elastic_enabled = True
+        # If the task is started locally, the parameters should be set locally
+
+        print(f"Run ID: {self.run_id}, Data Interface ID: {self.data_interface_id}, Task ID: {self.task_id}, Started Locally: {self.started_local}")
+        self.brynq = BrynQ()
+        self.email_after_errors = email_after_errors
         # Set up local log directory
         self.local_log_dir = 'local_logs'
         os.makedirs(self.local_log_dir, exist_ok=True)
 
         # Process local logs if services are now reachable
-        if self.mysql_enabled and not self.mysql_unreachable:
+        if self.mysql_enabled and self.mysql_reachable:
             self._process_local_mysql_logs()
-        if self.elastic_enabled and not self.elastic_unreachable:
-            self._process_local_elastic_logs()
 
         try:
-            self.email_after_errors = email_after_errors
             self.customer_db = os.getenv("MYSQL_DATABASE")
             self.customer = os.getenv('BRYNQ_SUBDOMAIN').lower().replace(' ', '_')
             self.partner_id = os.getenv('PARTNER_ID').lower().replace(' ', '_') if os.getenv('PARTNER_ID') else 'brynq'
             self.loglevel = loglevel
             self.started_at = datetime.datetime.now()
-            # If the task is started via the task_scheduler, the following 3 parameters will be passed by the scheduler.
-            # The distinction between local and non local is made because the scheduler usually sets the scheduler_log table entry and run_id. When running locally, the tasks should do this itself.
-            if len(sys.argv[1:4]) > 0:
-                self.started_local = False
-                self.customer_db, self.task_id, self.run_id = sys.argv[1:4]
-            # If the task is started locally, the parameters should be set locally
-            else:
-                self.started_local = True
-                self.run_id = int(round(time.time() * 100000))
-                self.task_id = task_id
-            print(self.task_id, self.run_id)
             self.error_count = 0
 
             # Check if the log tables exists in the customer database1. If not, create them
             # Mysql throws a warning when a table already exists. We don't care so we ignore warnings. (not exceptions!)
             warnings.filterwarnings('ignore')
 
-            # Creates Elasticsearch index and data view if not exists
-            if self.elastic_enabled:
-                self.es_index = f"task_execution_log_{self.customer_db}"
-                self.es.create_index(index_name=self.es_index)
-                self.es.create_data_view(space_name='interfaces', view_name=f'task_execution_log_{self.customer_db}', name=f'Task execution log {self.customer_db}', time_field='started_at')
+            # Initialize MySQL
+            self.mysql_reachable = True
+            try:
+                self.mysql = MySQL()
+                self.mysql.ping()
+            except Exception as e:
+                self.mysql_reachable = False
+                self.mysql = None
+                print("MySQL is enabled but not reachable, logs will be saved locally if needed.")
 
             # Start the task and setup the data in the database
-            if self.mysql_enabled:
+            if self.mysql_enabled and self.mysql_reachable:
                 self.customer_id = self.mysql.raw_query(f'SELECT id FROM sc.customers WHERE dbname = \'{self.customer_db}\'')[0][0]
-                # Check if the task is started on schedule or manual. store in a variable to use later in the script
-                self.task_manual_started = self._check_if_task_manual_started()
                 self._start_task()
-            else:
-                self.task_manual_started = True
         except Exception as e:
             self.error_handling(e)
 
@@ -147,22 +119,6 @@ class TaskScheduler(BrynQ):
         :return: error (str) or response of mysql
         """
         warnings.warn("Execution steps are deprecated, please stop calling this method. It does nothing anymore", DeprecationWarning)
-        return
-
-    def _check_if_task_manual_started(self):
-        """
-        Check if the task manual is started of on schedule. If it's manual started, that's important for the variables in the db_variables function.
-        In that case the dynamic variables should be used instead of the static ones
-        :return: True of False
-        """
-        # without logging is only possible during dev, so this is always manual
-        response = self.mysql.select('task_scheduler', 'run_instant', f'WHERE id = {self.task_id}')[0][0]
-        if response == 1:
-            # Reset the 1 back to 0 before sending the result
-            self.mysql.update('task_scheduler', ['run_instant'], [0], 'WHERE `id` = {}'.format(self.task_id))
-            return True
-        else:
-            return False
 
     def _start_task(self):
         """
@@ -173,34 +129,21 @@ class TaskScheduler(BrynQ):
         if self.started_local:
             self.mysql.raw_query(f"INSERT INTO `task_scheduler_log` (reload_id, task_id, reload_status, started_at, finished_at) VALUES ({self.run_id}, {self.task_id}, 'Running', '{self.started_at}', null)", insert=True)
 
-        self.mysql.update('task_scheduler', ['status', 'step_nr'], ['RUNNING', 1], 'WHERE `id` = {}'.format(self.task_id))
+        self.mysql.update('task_scheduler', ['status', 'step_nr'], ['RUNNING', 1], f'WHERE `id` = {self.task_id}')
 
-    def db_variable(self, variable_name: str, default_value_if_temp_is_empty: bool = False):
+    def db_variable(self, variable_name: str):
         """
-        Get a value from the task_variables table corresponding with the given name. If the task is manually started
+        Get a value from the task_variables table corresponding with the given name. If temp value is filled, it will
         (run_instant = 1), then the temp_value will be returned. This is to give the possibility for users in the frontend to run
         a task once manual with other values then normal without overwriting the normal values.
         :param variable_name: the name of the variable
-        :param default_value_if_temp_is_empty: bool to determine whether default value should be used if temp value is empty when manually started
         :return: the value of the given variable.
         """
-        if self.mysql_enabled:
-            if self.task_manual_started or self.started_local:
-                response = self.mysql.select('task_variables', 'temp_value, value',
-                                             f'WHERE name = \'{variable_name}\' AND task_id = {self.task_id}')
-            else:
-                response = self.mysql.select('task_variables', 'value',
-                                             f'WHERE name = \'{variable_name}\' AND task_id = {self.task_id}')
-            if len(response) == 0:
-                raise Exception(f'Variable with name \'{variable_name}\' does not exist')
-            else:
-                value = response[0][0]
-                if value is None and default_value_if_temp_is_empty is True and len(response[0]) > 0:
-                    value = response[0][1]
-                return value
-        else:
-            value: str = input(f'Your MYSQL connection is not defined, enter the value for the variable {variable_name}: ')
-            return value
+        warnings.deprecated("Use self.brynq.interfaces.get_variables() instead")
+
+        variable = self.brynq.interfaces.get_variables(variable_name=variable_name)
+
+        return variable
 
     def write_execution_log(self, message: str, data, loglevel: str = 'INFO', full_extract: bool = False):
         """
@@ -214,101 +157,16 @@ class TaskScheduler(BrynQ):
         # Validate if the provided loglevel is valid
         allowed_loglevels = ['DEBUG', 'INFO', 'ERROR', 'CRITICAL']
         if loglevel not in allowed_loglevels:
-            raise Exception('You\'ve entered a not allowed loglevel. Choose one of: {}'.format(allowed_loglevels))
+            raise ValueError(f"You\'ve entered a not allowed loglevel. Choose one of: {','.join(allowed_loglevels)}")
 
         # Get the linenumber from where the logline is executed.
         file_name, line_number, function_name = self.__get_caller_info()
-
         print('{} at line: {}'.format(message, line_number))
 
         # Count the errors for relevant log levels
         if loglevel == 'ERROR' or loglevel == 'CRITICAL':
             self.error_count += 1
 
-        if self.elastic_enabled:
-            # For Elastic, we need to have the data in JSON format. Handling different data types and preparing extra payload information based on the data type
-            # If the data is just a series, count rows, columns and cells
-            # Put everything together in the payload for ElasticSearch and send it
-            payload = {
-                'task_id': self.task_id,
-                'reload_id': self.run_id,
-                'started_at': datetime.datetime.now().isoformat(),
-                'partner_id': self.partner_id,
-                'customer': self.customer,
-                'file_name': file_name,
-                'function_name': function_name,
-                'line_number': line_number,
-                'task_loglevel': self.loglevel,
-                'line_loglevel': loglevel,
-                'message': message
-            }
-
-            if isinstance(data, pd.Series):
-                dataframe = pd.DataFrame(data).T
-                extra_payload = {
-                    'rows': len(dataframe),
-                    'columns': len(dataframe.columns),
-                    'cells': len(dataframe) * len(dataframe.columns),
-                }
-                if not full_extract:
-                    extra_payload['payload'] = dataframe.to_json(orient='records')
-            # If the data is a list, count rows, columns and cells
-            elif isinstance(data, dict):
-                records = self.__count_keys(data)
-                extra_payload = {
-                    'rows': 1,
-                    'columns': records,
-                    'cells': records,
-                }
-                if not full_extract:
-                    extra_payload['payload'] = data
-            elif isinstance(data, pd.DataFrame):
-                extra_payload = {
-                    'rows': len(data),
-                    'columns': len(data.columns),
-                    'cells': len(data) * len(data.columns),
-                }
-                if not full_extract:
-                    extra_payload['payload'] = data.to_json(orient='records')
-            # If the data is a response from an URL request, also store all the information about the URL request.
-            elif isinstance(data, requests.Response):
-                records = 1
-                if data.request.body is not None:
-                    records = self.__count_keys(json.loads(data.request.body))
-                if isinstance(data.request.body, bytes):
-                    data.request.body = data.request.body.decode('utf-8')
-                extra_payload = {
-                    'response': data.text,
-                    'status_code': data.status_code,
-                    'url': data.url,
-                    'method': data.request.method,
-                    'rows': 1,
-                    'columns': records,
-                    'cells': records,
-                }
-                if not full_extract:
-                    extra_payload['payload'] = data.request.body
-            elif data is None:
-                extra_payload = {}
-            else:
-                extra_payload = {
-                    'data_type': str(type(data)),
-                }
-                if not full_extract:
-                    extra_payload['payload'] = data
-
-            # Modify payload based on 'full_load' flag
-            if data is not None and full_extract is True:
-                extra_payload['full_load'] = True
-            elif data is not None and full_extract is False:
-                extra_payload['full_load'] = False
-
-            payload.update(extra_payload)
-            if not self.elastic_unreachable:
-                self.es.post_document(index_name=self.es_index, document=payload)
-            else:
-                self._save_log_locally(payload, 'elastic')
-
         # Write the logline to the MYSQL database, depends on the chosen loglevel in the task
         if self.mysql_enabled:
             mysql_log_data = {
@@ -319,18 +177,14 @@ class TaskScheduler(BrynQ):
                 'line_number': line_number,
                 'message': re.sub("[']", '', message)
             }
-            if not self.mysql_unreachable:
+            if self.mysql_reachable:
                 try:
                     query = f"INSERT INTO `task_execution_log` (reload_id, task_id, log_level, created_at, line_number, message) VALUES ({mysql_log_data['reload_id']}, {mysql_log_data['task_id']}, '{mysql_log_data['log_level']}', '{mysql_log_data['created_at']}', {mysql_log_data['line_number']}, '{mysql_log_data['message']}')"
                     if self.loglevel == 'DEBUG' or (self.loglevel == 'INFO' and loglevel != 'DEBUG') or (self.loglevel == 'ERROR' and loglevel in ['ERROR', 'CRITICAL']) or (self.loglevel == 'CRITICAL' and loglevel == 'CRITICAL'):
                         self.mysql.raw_query(query, insert=True)
-                except pymysql.err.OperationalError as e:
-                    print(f"MySQL connection lost during logging: {e}")
-                    self.mysql_unreachable = True
-                    self._save_log_locally(mysql_log_data, 'mysql')
-                except pymysql.err.InterfaceError as e:
-                    print(f"MySQL connection closed: {e}")
-                    self.mysql_unreachable = True
+                except (pymysql.err.OperationalError, pymysql.err.InterfaceError) as e:
+                    print(f"MySQL connection lost or closed during logging: {e}")
+                    self.mysql_reachable = False
                     self._save_log_locally(mysql_log_data, 'mysql')
                 except Exception as e:
                     print(f"Error during logging to MySQL: {e}")
@@ -346,7 +200,6 @@ class TaskScheduler(BrynQ):
         """
         # Update the step number in the task_scheduler table
         warnings.warn("Execution steps are deprecated, please stop calling this method. It does nothing anymore", DeprecationWarning)
-        return
 
     def error_handling(self, e: Exception, breaking=True, send_to_teams=False):
         """
@@ -366,58 +219,60 @@ class TaskScheduler(BrynQ):
         exc_type, exc_obj, exc_tb = sys.exc_info()
         error = str(e)[:400].replace('\'', '').replace('\"', '') + ' | Line: {}'.format(exc_tb.tb_lineno)
 
-        if self.elastic_enabled:
-            # Preparing the primary payload with error details for upload to elastic and send it
-            payload = {
-                'task_id': self.task_id,
-                'reload_id': self.run_id,
-                'started_at': datetime.datetime.now().isoformat(),
-                'partner_id': self.partner_id,
-                'customer': self.customer,
-                'file_name': file_name,
-                'function_name': function_name,
-                'line_number': line_number,
-                'task_loglevel': self.loglevel,
-                'line_loglevel': 'CRITICAL',
-                'message': str(e),
-                'traceback': traceback.format_exc()
-            }
-            self.es.post_document(index_name=self.es_index, document=payload)
-
         if self.mysql_enabled:
-            self.error_count += 1
-            # Get scheduler task details for logging
-            task_details = \
-                self.mysql.select('task_scheduler, data_interfaces', 'data_interfaces.docker_image, data_interfaces.runfile_path', 'WHERE task_scheduler.data_interface_id = data_interfaces.id AND task_scheduler.id = {}'.format(self.task_id))[0]
-            taskname = task_details[0]
-            customer = task_details[1].split('/')[-1].split('.')[0]
-            now = datetime.datetime.now()
-
-            # Log to log table in the database
-            if self.mysql_enabled:
-                query = "INSERT INTO `task_execution_log` (reload_id, task_id, log_level, created_at, line_number, message) VALUES ({}, {}, 'CRITICAL', '{}', {}, '{}')".format(self.run_id, self.task_id, now, exc_tb.tb_lineno, error)
+            try:
+                now = datetime.datetime.now()
+                # Log to log table in the database
+                mysql_log_data = {
+                    'reload_id': self.run_id,
+                    'task_id': self.task_id,
+                    'log_level': 'CRITICAL',
+                    'created_at': now,
+                    'line_number': exc_tb.tb_lineno,
+                    'message': error
+                }
+                self.error_count += 1
+                # Get scheduler task details for logging
+                task_details = \
+                    self.mysql.select('task_scheduler, data_interfaces', 'data_interfaces.docker_image, data_interfaces.runfile_path', 'WHERE task_scheduler.data_interface_id = data_interfaces.id AND task_scheduler.id = {}'.format(self.task_id))[0]
+                taskname = task_details[0]
+                customer = task_details[1].split('/')[-1].split('.')[0]
+
+                query = f"INSERT INTO `task_execution_log` (reload_id, task_id, log_level, created_at, line_number, message) VALUES ({mysql_log_data['reload_id']}, {mysql_log_data['task_id']}, '{mysql_log_data['log_level']}', '{mysql_log_data['created_at']}', {mysql_log_data['line_number']}, '{mysql_log_data['message']}')"
                 self.mysql.raw_query(query, insert=True)
-            if send_to_teams:
-                Functions.send_error_to_teams(database=customer, task_number=self.task_id, task_title=taskname)
-            if breaking:
-                # Set scheduler status to failed
-                self.mysql.update('task_scheduler', ['status', 'last_reload', 'last_error_message', 'step_nr'],
-                                  ['IDLE', now, 'Failed', 0],
-                                  'WHERE `id` = {}'.format(self.task_id))
-
-                self.mysql.update(table='task_scheduler_log',
-                                  columns=['reload_status', 'finished_at'],
-                                  values=['Failed', f'{now}'],
-                                  filter=f'WHERE `reload_id` = {self.run_id}')
-                if self.email_after_errors:
-                    self.email_errors(failed=True)
-                # Remove the temp values from the variables table
-                self.mysql.raw_query(f'UPDATE `task_variables` SET temp_value = null WHERE task_id = {self.task_id}', insert=True)
 
-                # Start the chained tasks if it there are tasks which should start if this one is failed
-                self.start_chained_tasks(finished_task_status='FAILED')
+                if send_to_teams:
+                    Functions.send_error_to_teams(database=customer, task_number=self.task_id, task_title=taskname)
+                if breaking:
+                    # Set scheduler status to failed
+                    self.mysql.update('task_scheduler', ['status', 'last_reload', 'last_error_message', 'step_nr'],
+                                      ['IDLE', now, 'Failed', 0],
+                                      f'WHERE `id` = {self.task_id}')
+
+                    self.mysql.update(table='task_scheduler_log',
+                                      columns=['reload_status', 'finished_at'],
+                                      values=['Failed', f'{now}'],
+                                      filter=f'WHERE `reload_id` = {self.run_id}')
+                    if self.email_after_errors:
+                        self.email_errors(failed=True)
+                    # Remove the temp values from the variables table
+                    self.mysql.raw_query(f'UPDATE `task_variables` SET temp_value = null WHERE task_id = {self.task_id}', insert=True)
+
+                    # Start the chained tasks if it there are tasks which should start if this one is failed
+                    self.start_chained_tasks(finished_task_status='FAILED')
+            except (pymysql.err.OperationalError, pymysql.err.InterfaceError) as e:
+                print(f"MySQL connection lost or closed during logging: {e}")
+                self.mysql_reachable = False
+                self._save_log_locally(mysql_log_data, 'mysql')
+            except Exception as e:
+                print(f"Error during logging to MySQL: {e}")
+                self._save_log_locally(mysql_log_data, 'mysql')
 
-        raise Exception(error)
+        # if breaking, reraise for clear traceback (local development) or just print if not breaking
+        if breaking:
+            raise e
+        else:
+            print(error)
 
     def finish_task(self, reload_instant=False, log_limit: Optional[int] = 10000, log_date_limit: datetime.date = None):
         """
@@ -475,7 +330,8 @@ class TaskScheduler(BrynQ):
 
     def start_chained_tasks(self, finished_task_status: str):
         if self.mysql_enabled:
-            filter = f'WHERE start_after_task_id = \'{self.task_id}\' AND start_after_preceding_task = \'{finished_task_status}\''
+            # only start chained tasks when trigger is on other task, otherwise this has changed in the db
+            filter = f'WHERE start_after_task_id = \'{self.task_id}\' AND start_after_preceding_task = \'{finished_task_status}\' AND task_type = \'OTHER_TASK\''
             response = self.mysql.select(table='task_scheduler', selection='id', filter=filter)
             if len(response) > 0:
                 tasks_to_run = [str(task[0]) for task in response]
@@ -485,7 +341,7 @@ class TaskScheduler(BrynQ):
 
     def email_errors(self, failed):
         # The mails to email to should be stored in the task_variables table with the variable email_errors_to
-        email_variable = self.db_variable('email_errors_to')
+        email_variable = self.brynq.interfaces.get_variables(variable_name='email_errors_to')
         if email_variable is not None:
             email_to = email_variable.split(',')
             if isinstance(email_to, list):
@@ -546,17 +402,24 @@ class TaskScheduler(BrynQ):
             except Exception as e:
                 print(f"Error processing MySQL log file {log_file}: {e}")
 
-    def _process_local_elastic_logs(self):
-        elastic_log_files = [f for f in os.listdir(self.local_log_dir) if f.startswith('elastic_log_')]
-        for log_file in elastic_log_files:
-            log_file_path = os.path.join(self.local_log_dir, log_file)
-            try:
-                with open(log_file_path, 'r') as f:
-                    logs = json.load(f)
-                # Process logs
-                for log_entry in logs:
-                    self.es.post_document(index_name=self.es_index, document=log_entry)
-                # Remove the log file after processing
-                os.remove(log_file_path)
-            except Exception as e:
-                print(f"Error processing ElasticSearch log file {log_file}: {e}")
+    def _write_log_to_mysql(self, log_entry):
+        """
+        Insert a log entry dictionary into the task_execution_log table in MySQL.
+        :param log_entry: dict with keys matching the columns of task_execution_log
+        """
+        try:
+            query = (
+                "INSERT INTO `task_execution_log` "
+                "(reload_id, task_id, log_level, created_at, line_number, message) "
+                "VALUES ({reload_id}, {task_id}, '{log_level}', '{created_at}', {line_number}, '{message}')"
+            ).format(
+                reload_id=log_entry['reload_id'],
+                task_id=log_entry['task_id'],
+                log_level=log_entry['log_level'],
+                created_at=log_entry['created_at'],
+                line_number=log_entry['line_number'],
+                message=str(log_entry['message']).replace("'", "")
+            )
+            self.mysql.raw_query(query, insert=True)
+        except Exception as e:
+            print(f"Error writing log entry to MySQL: {e}")

{brynq_sdk_task_scheduler-3.0.10 → brynq_sdk_task_scheduler-4.0.0}/brynq_sdk_task_scheduler.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq-sdk-task-scheduler
-Version: 3.0.10
+Version: 4.0.0
 Summary: Code to execute tasks in BrynQ.com with the task scheduler
 Home-page: UNKNOWN
 Author: BrynQ

{brynq_sdk_task_scheduler-3.0.10 → brynq_sdk_task_scheduler-4.0.0}/brynq_sdk_task_scheduler.egg-info/requires.txt

@@ -1,5 +1,5 @@
-brynq-sdk-brynq<4,>=2
+brynq-sdk-brynq<5,>=4
 brynq-sdk-functions<3,>=2
-brynq-sdk-mysql<3,>=2
+brynq-sdk-mysql<4,>=3
 brynq-sdk-mandrill<3,>=2
 brynq-sdk-elastic<4,>=3

{brynq_sdk_task_scheduler-3.0.10 → brynq_sdk_task_scheduler-4.0.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_namespace_packages
 
 setup(
     name='brynq_sdk_task_scheduler',
-    version='3.0.10',
+    version='4.0.0',
     description='Code to execute tasks in BrynQ.com with the task scheduler',
     long_description='Code to execute tasks in the BrynQ.com platform with the task scheduler',
     author='BrynQ',
@@ -10,9 +10,9 @@ setup(
     packages=find_namespace_packages(include=['brynq_sdk*']),
     license='BrynQ License',
     install_requires=[
-        'brynq-sdk-brynq>=2,<4',
+        'brynq-sdk-brynq>=4,<5',
         'brynq-sdk-functions>=2,<3',
-        'brynq-sdk-mysql>=2,<3',
+        'brynq-sdk-mysql>=3,<4',
         'brynq-sdk-mandrill>=2,<3',
         'brynq-sdk-elastic>=3,<4'
     ],