qalita 2.3.1__py3-none-any.whl → 2.5.2__py3-none-any.whl

qalita/commands/{agent.py → worker.py}

@@ -33,30 +33,30 @@ ROUTINE_LAST_SCHEDULED_UTC = {}
     "-n",
     "--name",
     help="The name of the agent, it will be used to identify the agent in the qalita platform",
-    envvar="QALITA_AGENT_NAME",
+    envvar="QALITA_WORKER_NAME",
 )
 @click.option(
     "-m",
     "--mode",
     type=click.Choice(["job", "worker"], case_sensitive=False),
     help="The mode of the agent, <worker/job> if you run the agent in worker mode, the agent will loop until it gets a job to do, in job mode it will immediately do a job",
-    envvar="QALITA_AGENT_MODE",
+    envvar="QALITA_WORKER_MODE",
 )
 @click.option(
     "-t",
     "--token",
-    help="The API token from the qalita platform, it is user scoped. Make sure you have at least the Data Engineer role to have the ability to register agents.",
-    envvar="QALITA_AGENT_TOKEN",
+    help="The API token from the qalita platform, it is user scoped. Make sure you have at least the Data Engineer role to have the ability to register workers.",
+    envvar="QALITA_WORKER_TOKEN",
 )
 @click.option(
     "-u",
     "--url",
     help="The URL to the qalita backend the agent have to register exemple : http://backend:3080",
-    envvar="QALITA_AGENT_ENDPOINT",
+    envvar="QALITA_WORKER_ENDPOINT",
 )
 @pass_config
-def agent(config, name, mode, token, url):
-    """Manage QALITA Platform Agents"""
+def worker(config, name, mode, token, url):
+    """Manage QALITA Platform Workers"""
 
     all_check_pass = True
 
@@ -76,13 +76,13 @@ def agent(config, name, mode, token, url):
         # Read the first found file
         env_file = env_files[0]
         abs_env_file = os.path.abspath(env_file)
-        logger.info(f"Using agent configuration file: [{abs_env_file}]")
+        logger.info(f"Using worker configuration file: [{abs_env_file}]")
 
         # Load values from the file only if the corresponding command-line option is not provided
         with open(abs_env_file, "r") as file:
             for line in file:
                 key, value = line.strip().split("=")
-                key = key.lower().replace("qalita_agent_", "")
+                key = key.lower().replace("qalita_worker_", "")
                 if key == "name" and not name:
                     name = value
                 elif key == "mode" and not mode:
@@ -94,54 +94,54 @@ def agent(config, name, mode, token, url):
 
     # Validation of required options
     if not name:
-        logger.error("Error: Agent name is required!")
+        logger.error("Error: Worker name is required!")
         logger.info("\tTo do so, you can set an Environment Variable : ")
-        logger.info("\t\texport QALITA_AGENT_NAME='agent-1'")
+        logger.info("\t\texport QALITA_WORKER_NAME='agent-1'")
         logger.info("\tor add the name as a commandline argument : ")
-        logger.info("\t\tqalita agent --name 'agent-1'")
+        logger.info("\t\tqalita worker --name 'agent-1'")
         logger.info(
             "\tthe prefered way is to create a file '.env-file' with the values : "
         )
-        logger.info("\t\tQALITA_AGENT_NAME=agent-1")
+        logger.info("\t\tQALITA_WORKER_NAME=agent-1")
         logger.info("\tand source it : ")
         logger.info("\t\texport $(xargs < .env-file)")
         all_check_pass = False
     if not mode:
-        logger.error("Error: Agent Mode is required!")
+        logger.error("Error: Worker Mode is required!")
         logger.info("\tTo do so, you can set an Environment Variable : ")
-        logger.info("\t\texport QALITA_AGENT_MODE='job'")
+        logger.info("\t\texport QALITA_WORKER_MODE='job'")
         logger.info("\tor add the mode as a commandline argument : ")
-        logger.info("\t\tqalita agent --mode 'job'")
+        logger.info("\t\tqalita worker --mode 'job'")
         logger.info(
             "\tthe prefered way is to create a file '.env-file' with the values : "
         )
-        logger.info("\t\tQALITA_AGENT_MODE=job")
+        logger.info("\t\tQALITA_WORKER_MODE=job")
         logger.info("\tand source it : ")
         logger.info("\t\texport $(xargs < .env-file)")
         all_check_pass = False
     if not token:
-        logger.error("Error: AGENT_TOKEN is required!")
+        logger.error("Error: WORKER_TOKEN is required!")
         logger.info("\tTo do so, you can set an Environment Variable : ")
-        logger.info("\t\texport QALITA_AGENT_TOKEN='<your_api_token>'")
+        logger.info("\t\texport QALITA_WORKER_TOKEN='<your_api_token>'")
         logger.info("\tor add the token as a commandline argument : ")
-        logger.info("\t\tqalita agent --token '<your_api_token>'")
+        logger.info("\t\tqalita worker --token '<your_api_token>'")
         logger.info(
             "\tthe prefered way is to create a file '.env-file' with the values : "
         )
-        logger.info("\t\tQALITA_AGENT_TOKEN=<your_api_token>")
+        logger.info("\t\tQALITA_WORKER_TOKEN=<your_api_token>")
         logger.info("\tand source it : ")
         logger.info("\t\texport $(xargs < .env-file)")
         all_check_pass = False
     if not url:
-        logger.error("Error: AGENT_ENDPOINT is required!")
+        logger.error("Error: WORKER_ENDPOINT is required!")
         logger.info("\tTo do so, you can set an Environment Variable : ")
-        logger.info("\t\texport QALITA_AGENT_ENDPOINT='http://localhost:3080'")
+        logger.info("\t\texport QALITA_WORKER_ENDPOINT='http://localhost:3080'")
         logger.info("\tor add the url as a commandline argument : ")
-        logger.info("\t\tqalita agent --url 'agent-1'")
+        logger.info("\t\tqalita worker --url 'agent-1'")
         logger.info(
             "\tthe prefered way is to create a file '.env-file' with the values : "
         )
-        logger.info("\t\tQALITA_AGENT_ENDPOINT=http://localhost:3080")
+        logger.info("\t\tQALITA_WORKER_ENDPOINT=http://localhost:3080")
         logger.info("\tand source it : ")
         logger.info("\t\texport $(xargs < .env-file)")
         all_check_pass = False
@@ -154,17 +154,17 @@ def agent(config, name, mode, token, url):
         return
 
 
-@agent.command()
+@worker.command()
 @pass_config
 def info(config):
-    """Display Information about the agent"""
-    data = config.load_agent_config()
+    """Display Information about the worker"""
+    data = config.load_worker_config()
 
-    print("------------- Agent information -------------")
+    print("------------- Worker information -------------")
     print(f"Name : {config.name}")
     print(f"Mode : {config.mode}")
     print(f"Backend URL : {config.url}")
-    print(f"Registered Agent Id : {data['context']['remote']['id']}")
+    print(f"Registered Worker Id : {data['context']['remote']['id']}")
 
 
 @pass_config
@@ -176,31 +176,31 @@ def send_alive(config, config_file, mode="", status="online"):
     remote_agent = config_file["context"]["remote"]
 
     if not remote_agent:
-        logger.error(f"No remote agent found with name '{config.name}'")
+        logger.error(f"No remote worker found with name '{config.name}'")
         return
 
     """Send a keep-alive to the backend"""
     try:
         r = send_api_request.__wrapped__(
             config,
-            request=f"/api/v2/agents/{remote_agent['id']}",
+            request=f"/api/v2/workers/{remote_agent['id']}",
             mode="put",
             data={"status": status},
         )  # type: ignore[attr-defined]
     except Exception:
         r = send_api_request(
-            request=f"/api/v2/agents/{remote_agent['id']}",
+            request=f"/api/v2/workers/{remote_agent['id']}",
             mode="put",
             data={"status": status},
         )
 
     if r.status_code != 200:
-        logger.warning(f"Agent failed to send alive {r.status_code} - {r.text}")
+        logger.warning(f"Worker failed to send alive {r.status_code} - {r.text}")
 
 
 @pass_config
 def authenticate(config, user_id):
-    """Authenticate the agent to the QALITA Platform"""
+    """Authenticate the worker to the QALITA Platform"""
     try:
         r = send_request.__wrapped__(
             config,
@@ -210,7 +210,7 @@ def authenticate(config, user_id):
     except Exception:
         r = send_request(request=f"{config.url}/api/v2/users/{user_id}", mode="get")
     if r.status_code == 200:
-        logger.success(f"Agent Authenticated to the platform at {config.url}")
+        logger.success(f"Worker Authenticated to the platform at {config.url}")
         config_json = {}
         config_json["user"] = r.json()
         try:
@@ -218,10 +218,10 @@ def authenticate(config, user_id):
         except KeyError:
             config_json["context"] = {}
             config_json["context"]["local"] = config.json()
-        config.save_agent_config(config_json)
+        config.save_worker_config(config_json)
     else:
         logger.error(
-            f"Agent can't authenticate - HTTP Code : {r.status_code} - {r.text}"
+            f"Worker can't authenticate - HTTP Code : {r.status_code} - {r.text}"
         )
         logger.error(
             "Make sure you have generated an API TOKEN from the qalita platform backend or web app"
@@ -231,13 +231,13 @@ def authenticate(config, user_id):
     try:
         # Récupération de la liste des agents existants
         try:
-            r = send_api_request.__wrapped__(config, request="/api/v2/agents", mode="get")  # type: ignore[attr-defined]
+            r = send_api_request.__wrapped__(config, request="/api/v2/workers", mode="get")  # type: ignore[attr-defined]
         except Exception:
-            r = send_api_request(request="/api/v2/agents", mode="get")
+            r = send_api_request(request="/api/v2/workers", mode="get")
 
         if r.status_code != 200:
             logger.error(
-                f"Agent can't authenticate - HTTP Code: {r.status_code} - {r.text}"
+                f"Worker can't authenticate - HTTP Code: {r.status_code} - {r.text}"
             )
             logger.error(
                 "Make sure you have generated an API TOKEN from the qalita platform backend or web app"
@@ -258,7 +258,7 @@ def authenticate(config, user_id):
             try:
                 r = send_api_request.__wrapped__(
                     config,
-                    request="/api/v2/agents/create",
+                    request="/api/v2/workers/create",
                     mode="post",
                     data={
                         "name": config.name,
@@ -269,7 +269,7 @@ def authenticate(config, user_id):
                 )  # type: ignore[attr-defined]
             except Exception:
                 r = send_api_request(
-                    request="/api/v2/agents/create",
+                    request="/api/v2/workers/create",
                     mode="post",
                     data={
                         "name": config.name,
@@ -284,9 +284,9 @@ def authenticate(config, user_id):
 
                 # Fetch the full list again
                 try:
-                    r = send_api_request.__wrapped__(config, request="/api/v2/agents", mode="get")  # type: ignore[attr-defined]
+                    r = send_api_request.__wrapped__(config, request="/api/v2/workers", mode="get")  # type: ignore[attr-defined]
                 except Exception:
-                    r = send_api_request(request="/api/v2/agents", mode="get")
+                    r = send_api_request(request="/api/v2/workers", mode="get")
 
                 if r.status_code != 200:
                     logger.error(
@@ -300,10 +300,10 @@ def authenticate(config, user_id):
                 sys.exit(1)
 
     except Exception as exception:
-        logger.error(f"Agent can't communicate with backend: {exception}")
+        logger.error(f"Worker can't communicate with backend: {exception}")
         sys.exit(1)
 
-    config_json = config.load_agent_config()
+    config_json = config.load_worker_config()
 
     # Remove 'jobs' from each agent in the API response before updating the config
     cleaned_agents = [
@@ -317,7 +317,7 @@ def authenticate(config, user_id):
     config_json["context"]["remote"] = agent_exists
 
     # Save the updated config
-    config.save_agent_config(config_json)
+    config.save_worker_config(config_json)
 
     r = send_api_request(request=f"/api/v2/registries", mode="get")
 
@@ -328,7 +328,7 @@ def authenticate(config, user_id):
         pass
     else:
         logger.error(
-            f"Agent can't fetch registry - HTTP Code : {r.status_code} - {r.text}"
+            f"Worker can't fetch registry - HTTP Code : {r.status_code} - {r.text}"
         )
         logger.error(
             "Make sure you have generated an API TOKEN from the qalita platform backend or web app"
@@ -336,16 +336,16 @@ def authenticate(config, user_id):
         sys.exit(1)
 
     registry_data = r.json()
-    config_json = config.load_agent_config()
+    config_json = config.load_worker_config()
     config_json["registries"] = registry_data
-    config.save_agent_config(config_json)
+    config.save_worker_config(config_json)
 
 
-@agent.command()
+@worker.command()
 @pass_config
 def login(config):
     """
-    Register the agent to the QALITA Platform
+    Register the worker to the QALITA Platform
     """
     if config.verbose:
         logger.info("Verbose mode enabled")
@@ -362,47 +362,47 @@ def login(config):
                 "Make sure you are using compatible versions for the platform and the cli,\n\t> check compatibility matrix on the documentation <"
             )
     authenticate(validated_info["user_id"])
-    agent_conf = config.load_agent_config()
+    agent_conf = config.load_worker_config()
     send_alive(config_file=agent_conf)
 
 
-@agent.command()
+@worker.command()
 @pass_config
 @click.option(
     "-s",
     "--source-id",
     help="The source ID to run the job against, to get the source ID, run qalita source list",
-    envvar="QALITA_AGENT_JOB_SOURCE",
+    envvar="QALITA_WORKER_JOB_SOURCE",
 )
 @click.option(
     "-sv",
     "--source-version",
     help="The source Version to run the job against, to get the source version, run qalita source -s <source_id> versions, default to latest",
-    envvar="QALITA_AGENT_JOB_SOURCE_VERSION",
+    envvar="QALITA_WORKER_JOB_SOURCE_VERSION",
 )
 @click.option(
     "-t",
     "--target-id",
     help="The target ID to run the job against, to get the target ID, run qalita source list",
-    envvar="QALITA_AGENT_JOB_SOURCE",
+    envvar="QALITA_WORKER_JOB_SOURCE",
 )
 @click.option(
     "-tv",
     "--target-version",
     help="The target Version to run the job against, to get the target version, run qalita source -s <target_id> versions, default to latest",
-    envvar="QALITA_AGENT_JOB_SOURCE_VERSION",
+    envvar="QALITA_WORKER_JOB_SOURCE_VERSION",
 )
 @click.option(
     "-p",
     "--pack-id",
     help="The pack ID to run the job against, to get the pack ID, run qalita pack list",
-    envvar="QALITA_AGENT_JOB_PACK",
+    envvar="QALITA_WORKER_JOB_PACK",
 )
 @click.option(
     "-pv",
     "--pack-version",
     help="The pack Version to run the job against, to get the pack version, run qalita pack -p <pack_id> versions, default to latest",
-    envvar="QALITA_AGENT_JOB_PACK_VERSION",
+    envvar="QALITA_WORKER_JOB_PACK_VERSION",
 )
 def run(
     config, source_id, source_version, target_id, target_version, pack_id, pack_version
@@ -411,31 +411,31 @@ def run(
     # Pre-checks
     if config.mode == "job":
         if source_id is None:
-            logger.error("Agent can't run job without source")
+            logger.error("Worker can't run job without source")
             logger.error(
-                "Please configure a source with --source or -s or QALITA_AGENT_JOB_SOURCE"
+                "Please configure a source with --source or -s or QALITA_WORKER_JOB_SOURCE"
             )
             logger.error("To get the source ID, run qalita source list")
             sys.exit(1)
         if pack_id is None:
-            logger.error("Agent can't run job without pack")
+            logger.error("Worker can't run job without pack")
             logger.error(
-                "Please configure a pack with --pack or -p or QALITA_AGENT_JOB_PACK"
+                "Please configure a pack with --pack or -p or QALITA_WORKER_JOB_PACK"
             )
             logger.error("To get the pack ID, run qalita pack list")
             sys.exit(1)
-    logger.info("------------- Agent Authenticate -------------")
+    logger.info("------------- Worker Authenticate -------------")
     validated_info = validate_token(config.token)
     authenticate(validated_info["user_id"])
-    logger.info("------------- Agent Run -------------")
-    agent_conf = config.load_agent_config()
-    logger.info(f"Agent ID : {agent_conf['context']['remote']['id']}")
-    logger.info(f"Agent Mode : {config.mode}")
+    logger.info("------------- Worker Run -------------")
+    agent_conf = config.load_worker_config()
+    logger.info(f"Worker ID : {agent_conf['context']['remote']['id']}")
+    logger.info(f"Worker Mode : {config.mode}")
 
-    # Create a temp folder named "agent_run_temp" if it doesn't already exist
-    agent_run_temp_path = config.get_agent_run_path()
-    if not os.path.exists(agent_run_temp_path):
-        os.makedirs(agent_run_temp_path)
+    # Create a temp folder named "jobs" if it doesn't already exist
+    jobs_path = config.get_worker_run_path()
+    if not os.path.exists(jobs_path):
+        os.makedirs(jobs_path)
 
     last_alive_time = time.time()
 
@@ -469,7 +469,7 @@ def run(
                 claim_unassigned_jobs(config)
 
                 check_job = send_api_request(
-                    request=f'/api/v1/agents/{agent_conf["context"]["remote"]["id"]}/jobs/next',
+                    request=f'/api/v1/workers/{agent_conf["context"]["remote"]["id"]}/jobs/next',
                     mode="get",
                 )
                 if check_job.status_code == 200:
@@ -568,18 +568,18 @@ def pull_pack(config, pack_id, pack_version=None):
     else:
         logger.error(f"Failed to fetch pack asset: {r.text}")
 
-    agent_run_temp_path = config.get_agent_run_path()
+    jobs_path = config.get_worker_run_path()
     # Système de caching, on regarde si le pack est déjà présent dans le cache sinon on le télécharge
     file_name = pack_url.split("/")[-1]
     bucket_name = pack_url.split("/")[3]
     s3_folder = "/".join(pack_url.split("/")[4:-1])
-    local_path = f"{agent_run_temp_path}/{bucket_name}/{s3_folder}/{file_name}"
+    local_path = f"{jobs_path}/{bucket_name}/{s3_folder}/{file_name}"
 
     if os.path.exists(local_path):
         logger.info(f"Using CACHED Pack at : {local_path}")
         return local_path, pack_version
-    if not os.path.exists(f"{agent_run_temp_path}/{bucket_name}/{s3_folder}"):
-        os.makedirs(f"{agent_run_temp_path}/{bucket_name}/{s3_folder}")
+    if not os.path.exists(f"{jobs_path}/{bucket_name}/{s3_folder}"):
+        os.makedirs(f"{jobs_path}/{bucket_name}/{s3_folder}")
 
     # Fetch the pack from api
     response = send_api_request(f"/api/v1/assets/{pack_asset_id}/fetch", "get")
@@ -615,7 +615,7 @@ def job_run(
     logger.info(f"Pack {pack_id}:{pack_version_id}")
 
     """Runs a job"""
-    agent_conf = config.load_agent_config()
+    agent_conf = config.load_worker_config()
     send_alive(config_file=agent_conf, mode="job", status="starting")
 
     # Get Source Version & Version ID
@@ -668,8 +668,8 @@ def job_run(
         random.choice(string.ascii_lowercase + string.digits) for _ in range(5)
     )
 
-    agent_run_temp_path = config.get_agent_run_path()
-    temp_folder_name = f"{agent_run_temp_path}/{datetime_string}_{random_seed}"
+    jobs_path = config.get_worker_run_path()
+    temp_folder_name = f"{jobs_path}/{datetime_string}_{random_seed}"
     os.makedirs(temp_folder_name)
 
     # Copy the downloaded pack to the temp folder
@@ -871,7 +871,7 @@ def post_run(
 ):
     logger.info("------------- Job Post Run -------------")
 
-    agent_conf = config.load_agent_config()
+    agent_conf = config.load_worker_config()
 
     #########################################################
     ## LOGS
@@ -1016,12 +1016,12 @@ def post_run(
     return logs_id
 
 
-@agent.command()
+@worker.command()
 @pass_config
 def joblist(config):
     """Jobs are the tasks that the agent will execute"""
     tab_jobs = []
-    agent_conf = config.load_agent_config()
+    agent_conf = config.load_worker_config()
     headers = [
         "ID",
         "Name",
@@ -1035,7 +1035,7 @@ def joblist(config):
     ]
 
     r = send_request(
-        request=f"{agent_conf['context']['local']['url']}/api/v2/agents/{agent_conf['context']['remote']['id']}",
+        request=f"{agent_conf['context']['local']['url']}/api/v2/workers/{agent_conf['context']['remote']['id']}",
         mode="get",
     )
     if r.status_code == 200:
@@ -1057,7 +1057,7 @@ def joblist(config):
 
     else:
         logger.error(
-            f"Error cannot fetch job list, make sure you are logged in with > qalita agent login : {r.status_code} - {r.reason}"
+            f"Error cannot fetch job list, make sure you are logged in with > qalita worker login : {r.status_code} - {r.reason}"
         )
         return
 
@@ -1146,7 +1146,7 @@ def check_routines(config, agent_start_datetime):
     7. Continue ....
     """
     source_conf = config.load_source_config(verbose=False)
-    agent_conf = config.load_agent_config()
+    agent_conf = config.load_worker_config()
     extract_ids = lambda x: [
         source["id"] for source in x["sources"] if "id" in source
     ]  # Skip if no ID
@@ -1254,7 +1254,7 @@ def claim_unassigned_jobs(config):
     """
     try:
         source_conf = config.load_source_config(verbose=False)
-        agent_conf = config.load_agent_config()
+        agent_conf = config.load_worker_config()
         local_source_ids = [s["id"] for s in source_conf["sources"] if "id" in s]
 
         r = send_api_request(

qalita/internal/config.py

@@ -19,7 +19,7 @@ class Config(object):
         self.token = ""
         self.url = ""
         self.verbose = False
-        self.agent_id = None
+        self.worker_id = None
         self.config = None
         self._qalita_home = os.path.expanduser("~/.qalita")
 
@@ -67,42 +67,49 @@ class Config(object):
             self.save_source_config()
             return self.config
 
-    def get_agent_file_path(self):
-        """Get the path for the agent file based on QALITA_HOME env or default."""
-        return os.path.join(self._qalita_home, ".agent")
+    def get_worker_file_path(self):
+        """Get the path for the worker file based on QALITA_HOME env or default."""
+        return os.path.join(self._qalita_home, ".worker")
 
-    def get_agent_run_path(self):
-        """Get the path for the agent run folder based on QALITA_HOME env or default."""
-        return os.path.join(self._qalita_home, "agent_run_temp")
+    def get_worker_run_path(self):
+        """Get the path for the worker run folder based on QALITA_HOME env or default."""
+        return os.path.join(self._qalita_home, "jobs")
 
-    def save_agent_config(self, data):
-        """Save the agent config in file to persist between context."""
-        agent_file_path = self.get_agent_file_path()
+    def save_worker_config(self, data):
+        """Save the worker config in file to persist between context."""
+        worker_file_path = self.get_worker_file_path()
 
         # Ensure the directory exists before saving the file
-        os.makedirs(os.path.dirname(agent_file_path), exist_ok=True)
+        os.makedirs(os.path.dirname(worker_file_path), exist_ok=True)
 
-        with open(agent_file_path, "wb") as file:  # open in binary mode
+        with open(worker_file_path, "wb") as file:  # open in binary mode
             json_str = json.dumps(data, indent=4)  # convert to json string
             json_bytes = json_str.encode("utf-8")  # convert to bytes
             base64_bytes = base64.b64encode(json_bytes)  # encode to base64
             file.write(base64_bytes)
 
-    def load_agent_config(self):
-        agent_file_path = self.get_agent_file_path()
+    def load_worker_config(self):
+        worker_file_path = self.get_worker_file_path()
         try:
-            with open(agent_file_path, "rb") as file:  # open in binary mode
+            with open(worker_file_path, "rb") as file:  # open in binary mode
                 base64_bytes = file.read()  # read base64
                 json_bytes = base64.b64decode(base64_bytes)  # decode from base64
                 json_str = json_bytes.decode("utf-8")  # convert to string
                 return json.loads(json_str)  # parse json
         except FileNotFoundError as exception:
-            logger.error(f"Agent can't load data file : {exception}")
-            logger.error("Make sure you have logged in before > qalita agent login")
+            logger.error(f"Worker can't load data file : {exception}")
+            logger.error("Make sure you have logged in before > qalita worker login")
             sys.exit(1)
 
-    def set_agent_id(self, agent_id):
-        self.agent_id = agent_id
+    # Alias for backward compatibility (agent -> worker refactoring)
+    def load_agent_config(self):
+        return self.load_worker_config()
+
+    def get_agent_run_path(self):
+        return self.get_worker_run_path()
+
+    def set_worker_id(self, worker_id):
+        self.worker_id = worker_id
 
     def json(self):
         data = {

qalita/internal/utils.py

@@ -14,7 +14,7 @@ logger = init_logging()
 
 
 def get_version():
-    return "2.3.1"
+    return "2.5.2"
 
 
 def make_tarfile(output_filename, source_dir):