Apply automated fixes from Ruff linter

Author: IgorChvyrov-sm

setup.py

@@ -1,9 +1,9 @@
 import setuptools
 import os
 
-version = os.environ['CONDUCTOR_PYTHON_VERSION']
+version = os.environ["CONDUCTOR_PYTHON_VERSION"]
 if version is None:
-    version = '0.0.0-SNAPSHOT'
+    version = "0.0.0-SNAPSHOT"
 
 setuptools.setup(
     version=version,

src/conductor/__init__.py

@@ -1 +1 @@
-__version__ = "1.1.10"
+__version__ = "1.1.10"

src/conductor/client/ai/integrations.py

@@ -22,21 +22,21 @@ def __init__(self, api_key: str, endpoint: str, classname: str) -> None:
 
     def to_dict(self) -> dict:
         return {
-            'api_key': self.api_key,
-            'endpoint': self.endpoint
+            "api_key": self.api_key,
+            "endpoint": self.endpoint
         }
 
 
 class OpenAIConfig(IntegrationConfig):
 
     def __init__(self, api_key: str = None) -> None:
         if api_key is None:
-            api_key = os.getenv('OPENAI_API_KEY')
+            api_key = os.getenv("OPENAI_API_KEY")
         self.api_key = api_key
 
     def to_dict(self) -> dict:
         return {
-            'api_key': self.api_key
+            "api_key": self.api_key
         }
 
 
@@ -48,38 +48,38 @@ def __init__(self, api_key: str, endpoint: str) -> None:
 
     def to_dict(self) -> dict:
         return {
-            'api_key': self.api_key,
-            'endpoint': self.endpoint
+            "api_key": self.api_key,
+            "endpoint": self.endpoint
         }
 
 
 class PineconeConfig(IntegrationConfig):
 
     def __init__(self, api_key: str = None, endpoint: str = None, environment: str = None, project_name: str = None) -> None:
         if api_key is None:
-            self.api_key = os.getenv('PINECONE_API_KEY')
+            self.api_key = os.getenv("PINECONE_API_KEY")
         else:
             self.api_key = api_key
 
         if endpoint is None:
-            self.endpoint = os.getenv('PINECONE_ENDPOINT')
+            self.endpoint = os.getenv("PINECONE_ENDPOINT")
         else:
             self.endpoint = endpoint
 
         if environment is None:
-            self.environment = os.getenv('PINECONE_ENV')
+            self.environment = os.getenv("PINECONE_ENV")
         else:
             self.environment = environment
 
         if project_name is None:
-            self.project_name = os.getenv('PINECONE_PROJECT')
+            self.project_name = os.getenv("PINECONE_PROJECT")
         else:
             self.project_name = project_name
 
     def to_dict(self) -> dict:
         return {
-            'api_key': self.api_key,
-            'endpoint': self.endpoint,
-            'projectName': self.project_name,
-            'environment': self.environment
+            "api_key": self.api_key,
+            "endpoint": self.endpoint,
+            "projectName": self.project_name,
+            "environment": self.environment
         }

src/conductor/client/ai/orchestrator.py

@@ -16,7 +16,7 @@
 
 
 class AIOrchestrator:
-    def __init__(self, api_configuration: Configuration, prompt_test_workflow_name: str = '') -> Self:
+    def __init__(self, api_configuration: Configuration, prompt_test_workflow_name: str = "") -> Self:
         orkes_clients = OrkesClients(api_configuration)
 
         self.integration_client = orkes_clients.get_integration_client()
@@ -25,8 +25,8 @@ def __init__(self, api_configuration: Configuration, prompt_test_workflow_name:
         self.prompt_client = orkes_clients.get_prompt_client()
 
         self.prompt_test_workflow_name = prompt_test_workflow_name
-        if self.prompt_test_workflow_name == '':
-            self.prompt_test_workflow_name = 'prompt_test_' + str(uuid4())
+        if self.prompt_test_workflow_name == "":
+            self.prompt_test_workflow_name = "prompt_test_" + str(uuid4())
 
     def add_prompt_template(self, name: str, prompt_template: str, description: str):
         self.prompt_client.save_prompt(name, description, prompt_template)
@@ -59,7 +59,7 @@ def add_ai_integration(self, ai_integration_name: str, provider: LLMProvider, mo
         details = IntegrationUpdate()
         details.configuration = config.to_dict()
         details.type = provider.value
-        details.category = 'AI_MODEL'
+        details.category = "AI_MODEL"
         details.enabled = True
         details.description = description
         existing_integration = self.integration_client.get_integration(integration_name=ai_integration_name)
@@ -78,7 +78,7 @@ def add_vector_store(self, db_integration_name: str, provider: VectorDB, indices
         vector_db = IntegrationUpdate()
         vector_db.configuration = config.to_dict()
         vector_db.type = provider.value
-        vector_db.category = 'VECTOR_DB'
+        vector_db.category = "VECTOR_DB"
         vector_db.enabled = True
         if description is None:
             description = db_integration_name
@@ -93,7 +93,6 @@ def add_vector_store(self, db_integration_name: str, provider: VectorDB, indices
             existing_integration_api = self.integration_client.get_integration_api(db_integration_name, index)
             if existing_integration_api is None or overwrite:
                 self.integration_client.save_integration_api(db_integration_name, index, api_details)
-        pass
 
     def get_token_used(self, ai_integration: str) -> dict:
         return self.integration_client.get_token_usage_for_integration_provider(ai_integration)

src/conductor/client/automator/task_handler.py

@@ -1,7 +1,7 @@
 import importlib
 import logging
 import os
-from multiprocessing import Process, freeze_support, Queue, set_start_method, get_context
+from multiprocessing import Process, freeze_support, Queue, set_start_method
 from sys import platform
 from typing import List
 
@@ -22,23 +22,23 @@
 _mp_fork_set = False
 if not _mp_fork_set:
     try:
-        if platform == 'win32':
-            set_start_method('spawn')
+        if platform == "win32":
+            set_start_method("spawn")
         else:
-            set_start_method('fork')
+            set_start_method("fork")
         _mp_fork_set = True
     except Exception as e:
-        logger.info(f'error when setting multiprocessing.set_start_method - maybe the context is set {e.args}')
+        logger.info(f"error when setting multiprocessing.set_start_method - maybe the context is set {e.args}")
     if platform == "darwin":
-        os.environ['no_proxy'] = '*'
+        os.environ["no_proxy"] = "*"
 
 def register_decorated_fn(name: str, poll_interval: int, domain: str, worker_id: str, func):
-    logger.info(f'decorated {name}')
+    logger.info(f"decorated {name}")
     _decorated_functions[(name, domain)] = {
-        'func': func,
-        'poll_interval': poll_interval,
-        'domain': domain,
-        'worker_id': worker_id
+        "func": func,
+        "poll_interval": poll_interval,
+        "domain": domain,
+        "worker_id": worker_id
     }
 
 
@@ -54,11 +54,11 @@ def __init__(
         self.logger_process, self.queue = _setup_logging_queue(configuration)
 
         # imports
-        importlib.import_module('conductor.client.http.models.task')
-        importlib.import_module('conductor.client.worker.worker_task')
+        importlib.import_module("conductor.client.http.models.task")
+        importlib.import_module("conductor.client.worker.worker_task")
         if import_modules is not None:
             for module in import_modules:
-                logger.info(f'loading module {module}')
+                logger.info(f"loading module {module}")
                 importlib.import_module(module)
 
         if workers is None:
@@ -68,22 +68,22 @@ def __init__(
         if scan_for_annotated_workers is True:
             for (task_def_name, domain) in _decorated_functions:
                 record = _decorated_functions[(task_def_name, domain)]
-                fn = record['func']
-                worker_id = record['worker_id']
-                poll_interval = record['poll_interval']
+                fn = record["func"]
+                worker_id = record["worker_id"]
+                poll_interval = record["poll_interval"]
 
                 worker = Worker(
                     task_definition_name=task_def_name,
                     execute_function=fn,
                     worker_id=worker_id,
                     domain=domain,
                     poll_interval=poll_interval)
-                logger.info(f'created worker with name={task_def_name} and domain={domain}')
+                logger.info(f"created worker with name={task_def_name} and domain={domain}")
                 workers.append(worker)
 
         self.__create_task_runner_processes(workers, configuration, metrics_settings)
         self.__create_metrics_provider_process(metrics_settings)
-        logger.info('TaskHandler initialized')
+        logger.info("TaskHandler initialized")
 
     def __enter__(self):
         return self
@@ -94,24 +94,24 @@ def __exit__(self, exc_type, exc_value, traceback):
     def stop_processes(self) -> None:
         self.__stop_task_runner_processes()
         self.__stop_metrics_provider_process()
-        logger.info('Stopped worker processes...')
+        logger.info("Stopped worker processes...")
         self.queue.put(None)
         self.logger_process.terminate()
 
     def start_processes(self) -> None:
-        logger.info('Starting worker processes...')
+        logger.info("Starting worker processes...")
         freeze_support()
         self.__start_task_runner_processes()
         self.__start_metrics_provider_process()
-        logger.info('Started all processes')
+        logger.info("Started all processes")
 
     def join_processes(self) -> None:
         try:
             self.__join_task_runner_processes()
             self.__join_metrics_provider_process()
-            logger.info('Joined all processes')
+            logger.info("Joined all processes")
         except KeyboardInterrupt:
-            logger.info('KeyboardInterrupt: Stopping all processes')
+            logger.info("KeyboardInterrupt: Stopping all processes")
             self.stop_processes()
 
     def __create_metrics_provider_process(self, metrics_settings: MetricsSettings) -> None:
@@ -122,7 +122,7 @@ def __create_metrics_provider_process(self, metrics_settings: MetricsSettings) -
             target=MetricsCollector.provide_metrics,
             args=(metrics_settings,)
         )
-        logger.info('Created MetricsProvider process')
+        logger.info("Created MetricsProvider process")
 
     def __create_task_runner_processes(
             self,
@@ -150,25 +150,25 @@ def __start_metrics_provider_process(self):
         if self.metrics_provider_process is None:
             return
         self.metrics_provider_process.start()
-        logger.info('Started MetricsProvider process')
+        logger.info("Started MetricsProvider process")
 
     def __start_task_runner_processes(self):
         n = 0
         for task_runner_process in self.task_runner_processes:
             task_runner_process.start()
             n = n + 1
-        logger.info(f'Started {n} TaskRunner process')
+        logger.info(f"Started {n} TaskRunner process")
 
     def __join_metrics_provider_process(self):
         if self.metrics_provider_process is None:
             return
         self.metrics_provider_process.join()
-        logger.info('Joined MetricsProvider processes')
+        logger.info("Joined MetricsProvider processes")
 
     def __join_task_runner_processes(self):
         for task_runner_process in self.task_runner_processes:
             task_runner_process.join()
-        logger.info('Joined TaskRunner processes')
+        logger.info("Joined TaskRunner processes")
 
     def __stop_metrics_provider_process(self):
         self.__stop_process(self.metrics_provider_process)
@@ -181,12 +181,12 @@ def __stop_process(self, process: Process):
         if process is None:
             return
         try:
-            logger.debug(f'Terminating process: {process.pid}')
+            logger.debug(f"Terminating process: {process.pid}")
             process.terminate()
         except Exception as e:
-            logger.debug(f'Failed to terminate process: {process.pid}, reason: {e}')
+            logger.debug(f"Failed to terminate process: {process.pid}, reason: {e}")
             process.kill()
-            logger.debug(f'Killed process: {process.pid}')
+            logger.debug(f"Killed process: {process.pid}")
 
 
 # Setup centralized logging queue