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

qalita/web/blueprints/{agents.py → workers.py}

@@ -10,40 +10,40 @@ from flask import Blueprint, jsonify, current_app
 from qalita.internal.utils import logger, validate_token
 from qalita.internal.request import send_request
 from .helpers import (
-    agent_status_payload,
+    worker_status_payload,
     read_selected_env,
     parse_env_file,
-    agent_log_file_path,
-    agent_pid_file_path,
+    worker_log_file_path,
+    worker_pid_file_path,
     open_path_in_file_explorer,
-    compute_agent_summary,
+    compute_worker_summary,
 )
 
 
-bp = Blueprint("agents", __name__)
+bp = Blueprint("workers", __name__)
 
 
-@bp.get("/agent/status")
-def agent_status():
-    return jsonify(agent_status_payload())
+@bp.get("/worker/status")
+def worker_status():
+    return jsonify(worker_status_payload())
 
 
-@bp.post("/agent/start")
-def agent_start():
+@bp.post("/worker/start")
+def worker_start():
     cfg = current_app.config["QALITA_CONFIG_OBJ"]
-    agent_name = None
+    worker_name = None
 
-    st = agent_status_payload()
+    st = worker_status_payload()
     if st.get("running"):
         return jsonify({"ok": True, "already_running": True, **st})
 
     try:
         sel_path = read_selected_env()
         if sel_path and os.path.isfile(sel_path):
-            logger.info(f"agent_start: applying selected env at [{sel_path}]")
+            logger.info(f"worker_start: applying selected env at [{sel_path}]")
             _login_with_env(sel_path)
     except Exception as exc:
-        logger.error(f"agent_start: failed applying selected env: {exc}")
+        logger.error(f"worker_start: failed applying selected env: {exc}")
         return (
             jsonify({"ok": False, "error": f"Failed to apply selected context: {exc}"}),
             400,
@@ -53,32 +53,32 @@ def agent_start():
         sel_path = read_selected_env()
         if sel_path and os.path.isfile(sel_path):
             data = parse_env_file(sel_path)
-            agent_name = (
-                data.get("QALITA_AGENT_NAME")
+            worker_name = (
+                data.get("QALITA_WORKER_NAME")
                 or data.get("AGENT_NAME")
                 or data.get("NAME")
                 or None
             )
     except Exception:
-        agent_name = None
-    if not agent_name:
+        worker_name = None
+    if not worker_name:
         try:
-            agent_name = getattr(cfg, "name", None) or None
+            worker_name = getattr(cfg, "name", None) or None
         except Exception:
-            agent_name = None
-    if not agent_name:
+            worker_name = None
+    if not worker_name:
         try:
-            raw = cfg.load_agent_config()
+            raw = cfg.load_worker_config()
             if isinstance(raw, dict) and raw:
-                agent_name = (
+                worker_name = (
                     (raw.get("context", {}).get("remote", {}) or {}).get("name")
                     or raw.get("name")
                     or None
                 )
         except Exception:
-            agent_name = None
-    if not agent_name:
-        agent_name = "agent"
+            worker_name = None
+    if not worker_name:
+        worker_name = "agent"
 
     # Ensure we have minimum credentials before preflight
     if not getattr(cfg, "token", None) or not getattr(cfg, "url", None):
@@ -144,7 +144,7 @@ def agent_start():
             env["QALITA_HOME"] = cfg.qalita_home  # type: ignore[attr-defined]
         except Exception:
             env["QALITA_HOME"] = os.path.expanduser("~/.qalita")
-        logger.info(f"agent_start: QALITA_HOME resolved to [{env.get('QALITA_HOME')}]")
+        logger.info(f"worker_start: QALITA_HOME resolved to [{env.get('QALITA_HOME')}]")
         try:
             sel_path = read_selected_env()
             if sel_path and os.path.isfile(sel_path):
@@ -161,12 +161,12 @@ def agent_start():
         except Exception:
             pass
         try:
-            if not any(env.get(k) for k in ("QALITA_AGENT_MODE", "AGENT_MODE", "MODE")):
-                env["QALITA_AGENT_MODE"] = "worker"
+            if not any(env.get(k) for k in ("QALITA_WORKER_MODE", "AGENT_MODE", "MODE")):
+                env["QALITA_WORKER_MODE"] = "worker"
         except Exception:
-            env["QALITA_AGENT_MODE"] = "worker"
+            env["QALITA_WORKER_MODE"] = "worker"
         logger.info(
-            f"agent_start: effective agent mode is [{env.get('QALITA_AGENT_MODE') or env.get('AGENT_MODE') or env.get('MODE')}]"
+            f"worker_start: effective agent mode is [{env.get('QALITA_WORKER_MODE') or env.get('AGENT_MODE') or env.get('MODE')}]"
         )
         if os.name == "nt":
             python_bin = sys.executable or "python"
@@ -174,23 +174,23 @@ def agent_start():
                 python_bin,
                 "-m",
                 "qalita",
-                "agent",
+                "worker",
                 "-n",
-                str(agent_name),
+                str(worker_name),
                 "-m",
                 "worker",
                 "run",
             ]
-            logger.info(f"agent_start: using python interpreter [{python_bin}]")
+            logger.info(f"worker_start: using python interpreter [{python_bin}]")
         else:
-            cmd = ["qalita", "agent", "-n", str(agent_name), "-m", "worker", "run"]
-        logger.info(f"agent_start: executing command: {' '.join(cmd)}")
-        log_path = agent_log_file_path()
+            cmd = ["qalita", "worker", "-n", str(worker_name), "-m", "worker", "run"]
+        logger.info(f"worker_start: executing command: {' '.join(cmd)}")
+        log_path = worker_log_file_path()
         try:
             os.makedirs(os.path.dirname(log_path), exist_ok=True)
         except Exception:
             pass
-        logger.info(f"agent_start: logging to [{log_path}]")
+        logger.info(f"worker_start: logging to [{log_path}]")
         log_file = open(log_path, "a", encoding="utf-8", buffering=1)
         popen_kwargs = {"stdout": log_file, "stderr": log_file, "env": env}
         if os.name == "nt":
@@ -202,23 +202,23 @@ def agent_start():
                     DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW
                 )
                 logger.info(
-                    "agent_start: using Windows creation flags DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW"
+                    "worker_start: using Windows creation flags DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW"
                 )
             except Exception:
                 pass
         else:
             popen_kwargs["start_new_session"] = True
-            logger.info("agent_start: using POSIX start_new_session=True")
+            logger.info("worker_start: using POSIX start_new_session=True")
         proc = subprocess.Popen(cmd, **popen_kwargs)
         try:
-            with open(agent_pid_file_path(), "w", encoding="utf-8") as f:
+            with open(worker_pid_file_path(), "w", encoding="utf-8") as f:
                 f.write(str(proc.pid))
         except Exception:
             pass
-        logger.info(f"agent_start: started process with PID [{proc.pid}]")
+        logger.info(f"worker_start: started process with PID [{proc.pid}]")
         return jsonify({"ok": True, "pid": proc.pid, "login_ok": True})
     except Exception as exc:
-        logger.error(f"agent_start: primary launch failed: {exc}")
+        logger.error(f"worker_start: primary launch failed: {exc}")
         try:
             env = dict(os.environ)
             try:
@@ -226,7 +226,7 @@ def agent_start():
             except Exception:
                 env["QALITA_HOME"] = os.path.expanduser("~/.qalita")
             logger.info(
-                f"agent_start(fallback): QALITA_HOME resolved to [{env.get('QALITA_HOME')}]"
+                f"worker_start(fallback): QALITA_HOME resolved to [{env.get('QALITA_HOME')}]"
             )
             sel_path = read_selected_env()
             if sel_path and os.path.isfile(sel_path):
@@ -242,33 +242,33 @@ def agent_start():
                             env[k] = v
             try:
                 if not any(
-                    env.get(k) for k in ("QALITA_AGENT_MODE", "AGENT_MODE", "MODE")
+                    env.get(k) for k in ("QALITA_WORKER_MODE", "AGENT_MODE", "MODE")
                 ):
-                    env["QALITA_AGENT_MODE"] = "worker"
+                    env["QALITA_WORKER_MODE"] = "worker"
             except Exception:
-                env["QALITA_AGENT_MODE"] = "worker"
+                env["QALITA_WORKER_MODE"] = "worker"
             logger.info(
-                f"agent_start(fallback): effective agent mode is [{env.get('QALITA_AGENT_MODE') or env.get('AGENT_MODE') or env.get('MODE')}]"
+                f"worker_start(fallback): effective agent mode is [{env.get('QALITA_WORKER_MODE') or env.get('AGENT_MODE') or env.get('MODE')}]"
             )
             python_bin = sys.executable or "python3"
             cmd = [
                 python_bin,
                 "-m",
                 "qalita",
-                "agent",
+                "worker",
                 "-n",
-                str(agent_name),
+                str(worker_name),
                 "-m",
                 "worker",
                 "run",
             ]
-            logger.info(f"agent_start(fallback): executing command: {' '.join(cmd)}")
-            log_path = agent_log_file_path()
+            logger.info(f"worker_start(fallback): executing command: {' '.join(cmd)}")
+            log_path = worker_log_file_path()
             try:
                 os.makedirs(os.path.dirname(log_path), exist_ok=True)
             except Exception:
                 pass
-            logger.info(f"agent_start(fallback): logging to [{log_path}]")
+            logger.info(f"worker_start(fallback): logging to [{log_path}]")
             log_file = open(log_path, "a", encoding="utf-8", buffering=1)
             popen_kwargs = {"stdout": log_file, "stderr": log_file, "env": env}
             if os.name == "nt":
@@ -280,31 +280,31 @@ def agent_start():
                         DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW
                     )
                     logger.info(
-                        "agent_start(fallback): using Windows creation flags DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW"
+                        "worker_start(fallback): using Windows creation flags DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW"
                     )
                 except Exception:
                     pass
             else:
                 popen_kwargs["start_new_session"] = True
-                logger.info("agent_start(fallback): using POSIX start_new_session=True")
+                logger.info("worker_start(fallback): using POSIX start_new_session=True")
             proc = subprocess.Popen(cmd, **popen_kwargs)
-            with open(agent_pid_file_path(), "w", encoding="utf-8") as f:
+            with open(worker_pid_file_path(), "w", encoding="utf-8") as f:
                 f.write(str(proc.pid))
-            logger.info(f"agent_start(fallback): started process with PID [{proc.pid}]")
+            logger.info(f"worker_start(fallback): started process with PID [{proc.pid}]")
             return jsonify(
                 {"ok": True, "pid": proc.pid, "fallback": True, "login_ok": True}
             )
         except Exception as exc2:
-            logger.error(f"agent_start(fallback): launch failed: {exc2}")
+            logger.error(f"worker_start(fallback): launch failed: {exc2}")
             return (
                 jsonify({"ok": False, "error": f"{exc}", "fallback_error": f"{exc2}"}),
                 500,
             )
 
 
-@bp.post("/agent/stop")
-def agent_stop():
-    pid = _read_agent_pid()
+@bp.post("/worker/stop")
+def worker_stop():
+    pid = _read_worker_pid()
     if not pid:
         return jsonify({"ok": True, "already_stopped": True})
     if os.name == "nt":
@@ -328,7 +328,7 @@ def agent_stop():
             except Exception:
                 pass
     try:
-        p = agent_pid_file_path()
+        p = worker_pid_file_path()
         if os.path.exists(p):
             os.remove(p)
     except Exception:
@@ -336,138 +336,61 @@ def agent_stop():
     return jsonify({"ok": True})
 
 
-@bp.get("/agent/summary")
-def agent_summary():
+@bp.get("/worker/summary")
+def worker_summary():
     cfg = current_app.config["QALITA_CONFIG_OBJ"]
-    agent_conf, agent_runs = compute_agent_summary(cfg)
-    return jsonify({"agent_conf": agent_conf or {}, "agent_runs": agent_runs})
+    worker_conf, worker_runs = compute_worker_summary(cfg)
+    return jsonify({"worker_conf": worker_conf or {}, "worker_runs": worker_runs})
 
 
-@bp.get("/agent/run/<run_name>")
-def open_agent_run(run_name: str):
+@bp.get("/worker/run/<run_name>")
+def open_worker_run(run_name: str):
     cfg = current_app.config["QALITA_CONFIG_OBJ"]
-    run_root = cfg.get_agent_run_path()
-    import os
+    run_root = cfg.get_worker_run_path()
 
     candidate = os.path.normpath(os.path.join(run_root, run_name))
     if not candidate.startswith(os.path.normpath(run_root) + os.sep):
-        return (
-            f"""
-            <!doctype html><html>
-<head><meta charset='utf-8'><title>QALITA CLI - Agent Run</title>
-<link rel="icon" href="/static/favicon.ico" />
-<link rel="stylesheet" href="/static/styles.css" />
-</head>
-<body style='background-repeat: no-repeat;'>
-<div class="container">
-  <h2>Agent Run - {candidate}</h2>
-  <div class="card">
-  <h1>Invalid path</h1>
-  <p><a href='/'>Back to Dashboard</a></p>
-  <hr/>
-    <p>If the path is invalid it means :</p>
-    <ul>
-      <li>Your local agent is not the one that ran the analysis you are trying to get files from</li>
-      <li>The job failed or was cancelled</li>
-    </ul>
-  </div>
-  </div>
-  <div class="footer">
-    <div class="inner">
-      <div>
-        <span>&copy; QALITA</span> — QALITA CLI
-      </div>
-      <div>
-        <span id="cli_version"></span>
-      </div>
-    </div>
-  </div>
-</body></html>
-""",
-            400,
-        )
+        return jsonify({
+            "ok": False,
+            "error": "Invalid path",
+            "path": candidate,
+            "message": "If the path is invalid it means: Your local agent is not the one that ran the analysis you are trying to get files from, or the job failed or was cancelled.",
+        }), 400
+
     if not os.path.isdir(candidate):
-        return (
-            f"""
-            <!doctype html><html>
-<head><meta charset='utf-8'><title>QALITA CLI - Agent Run</title>
-<link rel="icon" href="/static/favicon.ico" />
-<link rel="stylesheet" href="/static/styles.css" />
-</head>
-<body style='background-repeat: no-repeat;'>
-<div class="container">
-  <h2>Agent Run - {candidate}</h2>
-  <div class="card">
-  <h1>Run folder not found</h1>
-  <p><a href='/'>Back to Dashboard</a></p>
-  <hr/>
-    <p>If the run folder does not exist it means :</p>
-    <ul>
-      <li>Your local agent is not the one that ran the analysis you are trying to get files from</li>
-      <li>The job failed or was cancelled</li>
-    </ul>
-  </div>
-  </div>
-  <div class="footer">
-    <div class="inner">
-      <div>
-        <span>&copy; QALITA</span> — QALITA CLI
-      </div>
-      <div>
-        <span id="cli_version"></span>
-      </div>
-    </div>
-  </div>
-</body></html>
-""",
-            404,
-        )
+        return jsonify({
+            "ok": False,
+            "error": "Run folder not found",
+            "path": candidate,
+            "message": "If the run folder does not exist it means: Your local agent is not the one that ran the analysis you are trying to get files from, or the job failed or was cancelled.",
+        }), 404
+
     ok, method_used = open_path_in_file_explorer(candidate)
     status = "Opened" if ok else "Could not open automatically"
-    return (
-        f"""
-<!doctype html><html>
-<head><meta charset='utf-8'><title>QALITA CLI - Agent Run</title>
-<link rel="icon" href="/static/favicon.ico" />
-<link rel="stylesheet" href="/static/styles.css" />
-</head>
-<body style='background-repeat: no-repeat;'>
-<div class="container">
-  <h2>Agent Run - {candidate}</h2>
-  <div class="card">
-{status} file explorer
-  <p>Path: <code>{candidate}</code></p>
-  <p>Method: <code>{method_used}</code></p>
-  <p><a href='/'>Back to Dashboard</a></p>
-  <hr/>
-  <p>If the explorer did not open, you can navigate to this folder manually.</p>
-  <ul>
-    <li>macOS: open Finder and Go to Folder…</li>
-    <li>Linux: use your file manager or run: <code>xdg-open {candidate}</code></li>
-    <li>Windows/WSL: use Explorer at <code>\\\\wsl$\\{os.environ.get('WSL_DISTRO_NAME','<distro>')}\\{candidate}</code></li>
-  </ul>
-  </div>
-  </div>
-  <div class="footer">
-    <div class="inner">
-      <div>
-        <span>&copy; QALITA</span> — QALITA CLI
-      </div>
-      <div>
-        <span id="cli_version"></span>
-      </div>
-    </div>
-  </div>
-</body></html>
-""",
-        200,
-        {"Content-Type": "text/html; charset=utf-8"},
-    )
+
+    # Build instructions for manual navigation
+    instructions = []
+    if sys.platform == "darwin":
+        instructions.append("macOS: open Finder and Go to Folder…")
+    elif sys.platform.startswith("linux"):
+        instructions.append(f"Linux: use your file manager or run: xdg-open {candidate}")
+    elif sys.platform.startswith("win") or "WSL" in os.environ:
+        wsl_distro = os.environ.get('WSL_DISTRO_NAME', '<distro>')
+        instructions.append(f"Windows/WSL: use Explorer at \\\\wsl$\\{wsl_distro}\\{candidate}")
+
+    return jsonify({
+        "ok": True,
+        "status": status,
+        "path": candidate,
+        "method": method_used,
+        "instructions": instructions,
+        "message": f"{status} file explorer. If the explorer did not open, you can navigate to this folder manually.",
+    })
 
 
-def _read_agent_pid():
+def _read_worker_pid():
     try:
-        with open(agent_pid_file_path(), "r", encoding="utf-8") as f:
+        with open(worker_pid_file_path(), "r", encoding="utf-8") as f:
             raw = f.read().strip()
             return int(raw) if raw else None
     except Exception:
@@ -485,19 +408,19 @@ def _login_with_env(env_path: str) -> None:
         return default
 
     name = (
-        pick("QALITA_AGENT_NAME", "AGENT_NAME", "NAME")
+        pick("QALITA_WORKER_NAME", "AGENT_NAME", "NAME")
         or getattr(cfg, "name", None)
         or "agent"
     )
     mode = (
-        pick("QALITA_AGENT_MODE", "AGENT_MODE", "MODE")
+        pick("QALITA_WORKER_MODE", "AGENT_MODE", "MODE")
         or getattr(cfg, "mode", None)
         or "job"
     )
-    token = pick("QALITA_AGENT_TOKEN", "QALITA_TOKEN", "TOKEN") or getattr(
+    token = pick("QALITA_WORKER_TOKEN", "QALITA_TOKEN", "TOKEN") or getattr(
         cfg, "token", None
     )
-    url = pick("QALITA_AGENT_ENDPOINT", "QALITA_URL", "URL") or getattr(
+    url = pick("QALITA_WORKER_ENDPOINT", "QALITA_URL", "URL") or getattr(
         cfg, "url", None
     )
 

qalita-2.5.2.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: qalita
+Version: 2.5.2
+Summary: QALITA Platform Command Line Interface
+Author-email: QALITA SAS <contact@qalita.io>
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: azure-storage-blob>=12.19.1
+Requires-Dist: boto3>=1.34.81
+Requires-Dist: click>=8.1.3
+Requires-Dist: croniter>=1.4.1
+Requires-Dist: cryptography>=44.0.1
+Requires-Dist: flask-socketio>=5.3.0
+Requires-Dist: flask>=3.0.3
+Requires-Dist: gevent-websocket>=0.10.1
+Requires-Dist: gevent>=24.2.0
+Requires-Dist: google-cloud-storage>=2.16.0
+Requires-Dist: hdfs>=2.7.3
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: oracledb>=2.5.0
+Requires-Dist: paramiko>=3.4.0
+Requires-Dist: psycopg2-binary>=2.9.9
+Requires-Dist: pymongo>=4.6.3
+Requires-Dist: pymysql>=1.1.0
+Requires-Dist: python-socketio>=5.10.0
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: requests>=2.31.0
+Requires-Dist: semver>=3.0.1
+Requires-Dist: setuptools-rust>=1.8.1
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: waitress==3.0.2
+Provides-Extra: dev
+Requires-Dist: black>=25.1.0; extra == 'dev'
+Requires-Dist: flake8<4.0,>=3.8.1; extra == 'dev'
+Requires-Dist: pre-commit>=3.3.3; extra == 'dev'
+Requires-Dist: pylint>=2.17.4; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Provides-Extra: studio
+Requires-Dist: qalita-studio>=0.1.0; extra == 'studio'
+Description-Content-Type: text/markdown
+
+# QALITA Command Line Interface (CLI)
+
+<div style="text-align:center;">
+<img width="250px" height="auto" src="https://cloud.platform.qalita.io/logo.svg" style="max-width:250px;"/>
+</div>
+
+QALITA Command Line Interface (CLI) is a tool intended to be used by Data Engineers who setup's QALITA Platform's agents, sources and assets.
+
+It gives easy to use command to help them make an up & running qalita platform's environment in no time.
+
+Find the full documentation [in the online documentation](https://doc.qalita.io/docs/cli)

qalita-2.5.2.dist-info/RECORD

@@ -0,0 +1,24 @@
+qalita/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qalita/__main__.py,sha256=BIPwbMoOfE3trGx_lMut9L0G0vzrxXFsEwOF4sxCPYI,12654
+qalita/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qalita/commands/pack.py,sha256=Eu1h-JJEtUBqr6OKPnwE8EuJOQcHpJtZBvKe0XFQaDg,37224
+qalita/commands/source.py,sha256=ObRD2CcDynGbMrmj__FhWvPvR0H6HEn5QSLNR8awQUQ,30945
+qalita/commands/worker.py,sha256=wDIaljpPpvKikbgC1L4IBTVmSradlWkHu0AeKSIrqXw,50642
+qalita/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qalita/internal/config.py,sha256=FVooOC7T-IXOdzl3Q4TPr9ErhqP03QXmRSUo6OhIqIo,4314
+qalita/internal/error_patterns.py,sha256=QDFNZEoTmqVOHkiGFljstY6VOhux7d4p8FIL3pKzwtQ,1447
+qalita/internal/logger.py,sha256=4xWy2BZII89nUw4tKrLXFPOlVGONm8KUBgzX2XZ3u7g,1868
+qalita/internal/request.py,sha256=s-rE9kKRhV9IEveclB2YjAY8FRevKb6qjblM8-PbV20,6209
+qalita/internal/utils.py,sha256=Ph_OffznffqQn5_JuFz2RmKjtcEIhjAVSLB8CzbacxQ,5746
+qalita/web/__init__.py,sha256=NRcQjZSizkqN0a-LutsN7X9LBQ8MhyazXBSuqzUEmXE,62
+qalita/web/app.py,sha256=UvAzP7HcwE7E48ZEQViHHgVPE4Xw4TcIgdC7D_4xW4A,4973
+qalita/web/blueprints/context.py,sha256=Ji0D3yjDF1VeKsqL8rv8PlNNpLSbxPx7GBKEWnrgnlk,4689
+qalita/web/blueprints/dashboard.py,sha256=Zai5bMn50WWOzWRkkeWzKBnshMOZ7CK5tL7_jnTuXcA,5986
+qalita/web/blueprints/helpers.py,sha256=4lSqT01IaWTFkFQB7J2-R5XKKsc4iDAxzeprPhhQIxI,17788
+qalita/web/blueprints/sources.py,sha256=gjQqQMCkmJEh69Y2EJto-wyVDhk4VV9-9_o115W1O7g,33905
+qalita/web/blueprints/workers.py,sha256=fsjLnJHrPmytxpJIrNaScmlgJ6qvYeMaXlBGYpMvFro,15868
+qalita-2.5.2.dist-info/METADATA,sha256=mavlHXU1320kYk0rL40xZC6OqKek0T7pVqx8wo7RzKo,2524
+qalita-2.5.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+qalita-2.5.2.dist-info/entry_points.txt,sha256=h_4bMcWq-LKrSLca7IAPQnqlZkxz7BBH8eio4nqZCVU,48
+qalita-2.5.2.dist-info/licenses/LICENSE,sha256=cZt92dnxw87-VK4HB6KnmYV7mpf4JUdBkAHzFn1kQxM,22458
+qalita-2.5.2.dist-info/RECORD,,

{qalita-2.3.2.dist-info → qalita-2.5.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

qalita-2.5.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qalita = qalita.__main__:main