dfsync 0.4.6__tar.gz → 0.4.8__tar.gz

{dfsync-0.4.6 → dfsync-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dfsync
-Version: 0.4.6
+Version: 0.4.8
 Summary: 
 Author: Mihai Balint
 Author-email: balint.mihai@gmail.com
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: black (==23.7.0)
+Requires-Dist: black (==24.3.0)
 Requires-Dist: click (>=8,<9)
 Requires-Dist: click-default-group (>=1.2.2,<2.0.0)
 Requires-Dist: gitpython (>=3.1.14,<4.0.0)

{dfsync-0.4.6 → dfsync-0.4.8}/dfsync/backends/kube.py

@@ -12,6 +12,7 @@ from kubernetes.client.exceptions import ApiException
 from tenacity import retry, retry_if_exception_type, wait_exponential, stop_after_attempt
 
 from dfsync.filters import GIT_FILTER
+from dfsync.kube_credentials import KubeContextConfig
 from .rsync import rsync_backend
 
 DEFAULT_COMMAND = []
@@ -178,84 +179,72 @@ def please_wait(msg="Please wait"):
     print("⌛  {}...".format(msg))
 
 
-def _get_kube_api_client(context_name):
-    configuration = client.Configuration()
-    config.load_kube_config(
-        context=context_name,
-        client_configuration=configuration,
-    )
-    configuration.verify_ssl = True
-    configuration.assert_hostname = False
-    return client.ApiClient(configuration)
-
+def get_selected_kubernetes(kube_host=None) -> KubeContextConfig:
+    try:
+        config.load_kube_config()
+    except Exception as e:
+        error_message = str(e)
+        print(f"Failed to load default kube config: {error_message}")
 
-def get_selected_kubernetes(kube_host=None):
     contexts, active_context = config.list_kube_config_contexts()
     if not contexts:
         raise ValueError("Cannot find any kubernetes contexts in kube-config file")
 
-    context_apis = []
-    selected_context = None
-    selected_context_api = None
-    active_context_api = None
+    k8sctx_configs = []
+    active_k8ctx = None
+    selected_k8ctx = None
     multiple_matches = False
+
     for c in contexts:
-        ctx_client = client.CoreV1Api(api_client=_get_kube_api_client(c["name"]))
-        context_apis.append([c, ctx_client])
+        k8sctx = KubeContextConfig(c["name"])
+        k8sctx_configs.append(k8sctx)
 
-        ctx_api_host = ctx_client.api_client.configuration.host
-        if c["name"] == active_context["name"]:
-            active_context_api = ctx_client
+        if k8sctx.context_name == active_context["name"]:
+            active_k8ctx = k8sctx
+            k8sctx.is_active = True
 
-        if kube_host is not None and kube_host.lower() == ctx_api_host.lower():
-            if selected_context is None:
-                selected_context = c
-                selected_context_api = ctx_client
+        if kube_host is not None and kube_host.lower() == k8sctx.host.lower():
+            if selected_k8ctx is None:
+                selected_k8ctx = k8sctx
+                k8sctx.is_selected = True
             else:
                 multiple_matches = True
 
-    if len(contexts) > 1 or multiple_matches or (kube_host is not None and selected_context is None):
-        print(f"Multiple kubernetes contexts in kube-config:")
+    if kube_host is None and selected_k8ctx is None and active_k8ctx is not None:
+        # Select the active context if no specific arg is given
+        selected_k8ctx = active_k8ctx
+        selected_k8ctx.is_selected = True
 
-        for c, ctx_client in context_apis:
-            ctx_api_host = ctx_client.api_client.configuration.host
-            tags = []
-            if c == selected_context:
-                tags.append("ACTIVE-SELECTED")
-            elif c["name"] == active_context["name"]:
-                tags.append("ACTIVE")
+    if len(contexts) > 1 or multiple_matches or (kube_host is not None and selected_k8ctx is None):
+        print("Multiple kubernetes contexts in kube-config:")
+
+        for k8sctx in k8sctx_configs:
+            print(f"  {k8sctx.active_glyph} {k8sctx.prettified_str}")
 
-            if len(tags) > 0:
-                tags_str = ",".join(tags)
-                print(f"  * {c['name']} on {ctx_api_host} [{tags_str}]")
-            else:
-                print(f"  * {c['name']} on {ctx_api_host}")
         if kube_host is None:
-            ctx_api_host = active_context_api.api_client.configuration.host
             print(
-                f"Add --kube-host={ctx_api_host} to use a specific kubernetes API host\n"
+                f"Add --kube-host={active_k8ctx.host} to use a specific kubernetes API host\n"
                 f"Alternatively, use 'kubectl config set current-context <name>' to set the current context"
             )
 
-    if kube_host is not None and selected_context is None:
+    if kube_host is not None and selected_k8ctx is None:
         raise ValueError(f"None of the kubernetes contexts match '{kube_host}'")
 
-    if selected_context is None:
-        selected_context = active_context
-        selected_context_api = active_context_api
-    return selected_context, selected_context_api
+    if selected_k8ctx is None:
+        raise ValueError("Failed to select a kubernetes context config")
+
+    return selected_k8ctx
 
 
 class KubeReDeployer:
     def __init__(self, kube_host=None, pod_timeout=30, container_command=None, full_sync=True, **kwargs):
-        config.load_kube_config()
-        selected_context, selected_context_api = get_selected_kubernetes(kube_host)
+        k8sctx = get_selected_kubernetes(kube_host)
 
-        self.context_name = selected_context["name"]
-        self.api = selected_context_api
-        self.apps_api = client.AppsV1Api(api_client=_get_kube_api_client(self.context_name))
+        self.context_name = k8sctx.context_name
+        self.api = k8sctx.core_v1_api()
+        self.apps_api = k8sctx.apps_v1_api()
 
-        print(f"Using cluster: {self.context_name} on {self.api.api_client.configuration.host}")
+        print(f"Using cluster: {k8sctx.prettified_str}")
         self.rsync_backend_instance = rsync_backend()
         self._image_distro = None
         self.pod_timeout = pod_timeout

{dfsync-0.4.6 → dfsync-0.4.8}/dfsync/char_ui.py

@@ -60,7 +60,16 @@ class KeyHandlerException(Exception):
     pass
 
 
-KeyHandler = namedtuple("KeyHandler", "keys description action")
+class KeyHandler:
+    def __init__(self, keys, description, action, strict_case):
+        self.keys = keys
+        self.description = description
+        self.action = action
+
+        self.event_keys = set(keys)
+        if not strict_case:
+            self.event_keys.update([k.lower() for k in self.keys])
+            self.event_keys.update([k.upper() for k in self.keys])
 
 
 class KeyController(ControlledThreadedOperation):
@@ -97,12 +106,12 @@ class KeyController(ControlledThreadedOperation):
             except (Exception, KeyboardInterrupt) as e:
                 self._exception = e
 
-    def on_key(self, *keys, description: str = None, action=None):
+    def on_key(self, *keys, description: str = None, action=None, strict_case=False):
         if action is None:
             raise ValueError("'action' cannot be None")
-        handler = KeyHandler(keys=keys, description=description, action=action)
+        handler = KeyHandler(keys=keys, description=description, action=action, strict_case=strict_case)
         self.handlers.append(handler)
-        for k in keys:
+        for k in handler.event_keys:
             self.key_handlers[k] = handler
 
     def raise_exceptions(self):

{dfsync-0.4.6 → dfsync-0.4.8}/dfsync/distribution.py

@@ -1,5 +1,10 @@
+import click
 import json
+import subprocess
+import sys
 import urllib.request
+from typing import Optional
+
 from dfsync.lib import ControlledThreadedOperation
 
 
@@ -8,14 +13,14 @@ def get_package_version(package_name):
         from importlib.metadata import version
 
         return version(package_name)
-    except:
+    except Exception:
         pass
 
     try:
         import pkg_resources
 
         return pkg_resources.get_distribution(package_name).version
-    except:
+    except Exception:
         pass
 
     return None
@@ -41,7 +46,7 @@ def get_latest_version():
             raise ValueError("No version visible on github")
 
         return versions[0]
-    except Exception as e:
+    except Exception:
         return get_installed_version()
 
 
@@ -52,7 +57,7 @@ def parse_version(version_str):
     for part in version_str.split("."):
         try:
             parsed_version.append(int(part))
-        except:
+        except Exception:
             parsed_version.append(part)
     return parsed_version
 
@@ -80,15 +85,52 @@ class AsyncVersionChecker(ControlledThreadedOperation):
         self.installed = get_installed_version()
         self.latest = get_latest_version()
         self.installed_is_older = is_older_version(self.installed, self.latest)
+        self._is_install_editable = is_installed_in_editable_mode("dfsync")
         self._cta_count = 0
         self.stop()
 
     @property
-    def should_emit_upgrade_warning(self):
+    def should_emit_update_warning(self):
         return self.is_completed and self.installed_is_older and self._cta_count < 1
 
-    def set_emitted_upgrade_warning(self):
+    def set_emitted_update_warning(self):
         self._cta_count += 1
 
-    def get_upgrade_warning(self):
-        return f"dfsync ver. {self.latest} is available, please upgrade! ({self.installed} is installed)"
+    def get_update_warning(self):
+        if self._is_install_editable:
+            return f"dfsync ver. {self.latest} is available, please update! ({self.installed} is installed)"
+        else:
+            return f"dfsync ver. {self.latest} is available ({self.installed} is installed), please update using `dfsync self-update`"
+
+
+def _read_editable_location_from_pip_show_output(out: str) -> Optional[str]:
+    editable_label = "Editable project location: "
+    site_packages_label = "site-packages"
+    site_packages_lines = []
+
+    for line in out.split("\n"):
+        if line.startswith("Location: "):
+            continue
+        if line.startswith(editable_label):
+            return line[len(editable_label) :].strip()
+        if site_packages_label in line:
+            site_packages_lines.append(line)
+
+    return "UNKNOWN-EDITABLE-LOCATION" if len(site_packages_lines) > 0 else None
+
+
+def is_installed_in_editable_mode(package_name: str) -> bool:
+    try:
+        out = subprocess.check_output([sys.executable, "-m", "pip", "show", "-f", package_name]).decode()
+        editable_location = _read_editable_location_from_pip_show_output(out)
+        return editable_location is not None
+    except Exception:
+        return False
+
+
+def update_package(package_name: str):
+    click.echo(f"Running {sys.executable} -m pip install --upgrade {package_name}")
+    try:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", package_name])
+    except Exception as e:
+        click.echo(f"Failed to update {package_name}: {e}")

{dfsync-0.4.6 → dfsync-0.4.8}/dfsync/kube_credentials.py

@@ -2,6 +2,7 @@ import os
 import os.path
 import yaml
 from urllib.parse import urlparse
+from kubernetes import client, config
 
 LOCAL_CREDENTIALS_FILE = os.path.expanduser("~/.kube/config")
 EMPTY_CREDENTIALS = """apiVersion: v1
@@ -18,7 +19,7 @@ def update_local_kube_config(new_kube_credentials):
     try:
         with open(LOCAL_CREDENTIALS_FILE, "r") as f:
             credentials = yaml.safe_load(f)
-    except FileNotFoundError as e:
+    except FileNotFoundError:
         credentials = yaml.safe_load(EMPTY_CREDENTIALS)
         kube_dir, _ = os.path.split(LOCAL_CREDENTIALS_FILE)
         os.makedirs(kube_dir, exist_ok=True)
@@ -76,14 +77,16 @@ def update_local_kube_config(new_kube_credentials):
     credentials_yaml = yaml.dump(credentials)
     with open(f"{LOCAL_CREDENTIALS_FILE}.new", "w") as f:
         f.write(credentials_yaml)
+    os.chmod(f"{LOCAL_CREDENTIALS_FILE}.new", 0o600)
 
     if os.path.isfile(LOCAL_CREDENTIALS_FILE):
         if os.path.isfile(f"{LOCAL_CREDENTIALS_FILE}.old"):
             os.remove(f"{LOCAL_CREDENTIALS_FILE}.old")
         os.rename(f"{LOCAL_CREDENTIALS_FILE}", f"{LOCAL_CREDENTIALS_FILE}.old")
+        os.chmod(f"{LOCAL_CREDENTIALS_FILE}.old", 0o600)
 
     os.rename(f"{LOCAL_CREDENTIALS_FILE}.new", f"{LOCAL_CREDENTIALS_FILE}")
-
+    os.chmod(LOCAL_CREDENTIALS_FILE, 0o600)
     return credentials_yaml
 
 
@@ -132,3 +135,89 @@ def contextualize_kube_credentials(kube_host, credentials_file):
         print(exc)
 
     return {}
+
+
+def normalized_k8s_url(k8s_url: str) -> str:
+    parsed = None
+    result = k8s_url
+    if k8s_url is None:
+        return None
+    elif not k8s_url:
+        raise ValueError(f"Invalid k8s URL: `{k8s_url}`")
+    elif "://" not in k8s_url.lower():
+        result = f"https://{k8s_url}"
+        parsed = urlparse(result)
+    else:
+        parsed = urlparse(k8s_url)
+
+    if all([parsed.scheme, parsed.netloc]):
+        return result
+    else:
+        raise ValueError(f"Invalid k8s URL: `{k8s_url}`")
+
+
+RED = "\033[38;2;255;0;0m"
+GREEN = "\033[38;2;128;255;128m"
+GRAY = "\033[38;2;128;128;128m"
+NEUTRAL = "\033[0m"
+
+
+class KubeContextConfig:
+    def __init__(self, context_name: str) -> None:
+        self._api_client = None
+        self._load_failure = None
+        self._configuration = client.Configuration()
+        self.context_name = context_name
+        self._adjust_ssl()
+        self.is_active = False
+        self.is_selected = False
+
+    def _adjust_ssl(self):
+        self._configuration.verify_ssl = True
+        self._configuration.assert_hostname = False
+
+    def _load(self):
+        if self._api_client is not None:
+            return
+        try:
+            config.load_kube_config(
+                context=self.context_name,
+                client_configuration=self._configuration,
+            )
+            self._adjust_ssl()
+            self._api_client = client.ApiClient(self._configuration)
+            self._load_failure = None
+        except Exception as e:
+            self._load_failure = str(e)
+
+    @property
+    def host(self):
+        self._load()
+        return self._configuration.host
+
+    @property
+    def api_client(self):
+        self._load()
+        return self._api_client
+
+    def apps_v1_api(self):
+        return client.AppsV1Api(api_client=self.api_client)
+
+    def core_v1_api(self):
+        return client.CoreV1Api(api_client=self.api_client)
+
+    @property
+    def active_glyph(self):
+        glyph = "@" if self.is_active else "*"
+        COLOR = GREEN if self.is_selected else GRAY
+        return f"{COLOR}{glyph}{NEUTRAL}"
+
+    @property
+    def prettified_str(self, include_failure=True):
+        fail_text = ""
+        if self._load_failure and include_failure:
+            fail_text = f"{RED}{self._load_failure[:80]}{NEUTRAL}"
+
+        txt = f"{self.context_name} on {self.host}"
+        COLOR = GREEN if self.is_selected else GRAY
+        return f"{COLOR}{txt}{NEUTRAL} {fail_text}"

{dfsync-0.4.6 → dfsync-0.4.8}/dfsync/lib.py

@@ -1,4 +1,5 @@
-import time, threading
+import time
+import threading
 
 
 class ThreadedOperationsManager:
@@ -35,13 +36,13 @@ class ControlledThreadedOperation:
 
     @property
     def is_completed(self):
-        return self._running == False
+        return self._running is False
 
     def run(self):
         while self._running:
             try:
                 self._run_once()
-            except:
+            except Exception:
                 time.sleep(0.001)
 
     def _run_once(self):

{dfsync-0.4.6 → dfsync-0.4.8}/dfsync/monitor.py

@@ -13,11 +13,18 @@ from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 
 from dfsync.backends import rsync_backend, kube_backend
-from dfsync.distribution import get_installed_version, get_latest_version, is_older_version, AsyncVersionChecker
+from dfsync.distribution import (
+    get_installed_version,
+    get_latest_version,
+    is_older_version,
+    AsyncVersionChecker,
+    is_installed_in_editable_mode,
+    update_package,
+)
 from dfsync.filters import add_user_ignored_patterns_filter, ALL_FILTERS
 from dfsync.config import read_config
 from dfsync.char_ui import KeyController
-from dfsync.kube_credentials import contextualize_kube_credentials, update_local_kube_config
+from dfsync.kube_credentials import contextualize_kube_credentials, update_local_kube_config, normalized_k8s_url
 from dfsync.lib import ControlledThreadedOperation, thread_manager
 
 logging.basicConfig(level=logging.WARN)
@@ -253,12 +260,36 @@ def main():
 
 @main.command()
 def version():
+    """
+    Print the currently installed version
+    """
     installed_version = get_installed_version()
     click.echo(f"{installed_version}")
 
     latest_version = get_latest_version()
-    if is_older_version(installed_version, latest_version):
-        click.echo(f"Latest version is {latest_version}, please upgrade!")
+    if not is_older_version(installed_version, latest_version):
+        return
+    elif is_installed_in_editable_mode("dfsync"):
+        click.echo(f"Latest version is {latest_version}, please update!")
+    else:
+        click.echo(f"Latest version is {latest_version}, please update using `dfsync self-update`")
+
+
+@main.command()
+def self_update():
+    """
+    Update dfsync to the latest version published on pypi
+    """
+    latest_version = get_latest_version()
+    installed_version = get_installed_version()
+    if not is_older_version(installed_version, latest_version):
+        click.echo(f"The latest version is already installed: {installed_version}")
+        return
+    elif is_installed_in_editable_mode("dfsync"):
+        click.echo("dfsync is installed in editable mode, please update manually")
+        return
+    else:
+        update_package("dfsync")
 
 
 @main.command()
@@ -271,7 +302,7 @@ def import_kube_host(kube_host=None, credentials=None):
 
     ssh user@kube-host -C "sudo cat /root/.kube/config" | dfsync import-kube-host --kube-host=https://kube-host:6443
     """
-    patch = contextualize_kube_credentials(kube_host, credentials)
+    patch = contextualize_kube_credentials(normalized_k8s_url(kube_host), credentials)
     update_local_kube_config(patch)
 
 
@@ -342,7 +373,7 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync):
         backend_options = dict(
             destination_dir=destination_dir,
             supervisor=supervisor,
-            kube_host=kube_host,
+            kube_host=normalized_k8s_url(kube_host),
             pod_timeout=pod_timeout,
             container_command=config.container_command,
             full_sync=full_sync,
@@ -419,9 +450,9 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync):
                     no_errors = False
                     break
             with controller.getch_lock():
-                if checker.should_emit_upgrade_warning:
-                    checker.set_emitted_upgrade_warning()
-                    click.echo(checker.get_upgrade_warning())
+                if checker.should_emit_update_warning:
+                    checker.set_emitted_update_warning()
+                    click.echo(checker.get_update_warning())
             controller.raise_exceptions()
 
     except KeyboardInterrupt:

{dfsync-0.4.6 → dfsync-0.4.8}/dfsync/test_dfsync.py

@@ -3,10 +3,6 @@ from tempfile import NamedTemporaryFile
 from dfsync.filters import EmacsBufferFilter, UntrackedGitFilesFilter
 
 
-def test_version():
-    assert False, "Test version not implemented"
-
-
 def test_emacs_buffer_filter():
     emacs = EmacsBufferFilter()
 

dfsync-0.4.8/dfsync/test_distribution.py

@@ -0,0 +1,30 @@
+import pytest
+from dfsync.distribution import is_installed_in_editable_mode, get_package_version, update_package
+
+
+def test_is_installed_in_editable_mode():
+    assert is_installed_in_editable_mode("dfsync") is True
+
+
+def test_is_installed_in_editable_mode_missing_package():
+    assert is_installed_in_editable_mode("does-not-exist") is False
+
+
+def test_is_installed_in_editable_mode_required_and_installed_package():
+    assert pytest is not None, "pytest must be installed"
+    assert is_installed_in_editable_mode("pytest") is False
+
+    assert is_installed_in_editable_mode("click") is False
+
+
+def test_update_package():
+    tqdm_version = get_package_version("tqdm")
+
+    update_package("tqdm==4.66.2")
+    assert get_package_version("tqdm") == "4.66.2"
+
+    update_package("tqdm==4.66.0")
+    assert get_package_version("tqdm") == "4.66.0"
+
+    update_package(f"tqdm=={tqdm_version}")
+    assert get_package_version("tqdm") == tqdm_version

{dfsync-0.4.6 → dfsync-0.4.8}/dfsync/test_kube_credentials.py

@@ -1,7 +1,9 @@
-import pytest, yaml, tempfile
+import os
+import pytest
+import tempfile
+import yaml
 
-import dfsync.kube_credentials
-from dfsync.kube_credentials import update_local_kube_config
+from dfsync.kube_credentials import update_local_kube_config, normalized_k8s_url
 
 
 @pytest.fixture
@@ -11,7 +13,7 @@ def mock_kube_credentials(mocker):
         return temp.name
 
 
-def test_update_missing_kube_config(mock_kube_credentials):
+def test_update_missing_kube_config_and_check_permissions(mock_kube_credentials):
     new_kube_credentials = {
         "clusters": [{"cluster": {"server": "test_server"}, "name": "test_cluster"}],
         "contexts": [{"context": {"cluster": "test_cluster", "user": "test_user"}, "name": "test_context"}],
@@ -22,6 +24,9 @@ def test_update_missing_kube_config(mock_kube_credentials):
     assert "test_context" in result
     assert "test_user" in result
 
+    # Check file permissions
+    assert oct(os.stat(mock_kube_credentials).st_mode)[-3:] == "600"
+
 
 def test_update_empty_kube_config(mock_kube_credentials):
     with open(mock_kube_credentials, "wb") as f:
@@ -52,6 +57,15 @@ def test_update_empty_kube_config(mock_kube_credentials):
         assert credentials["users"][0]["user"]["username"] == "test_username"
         assert credentials["users"][0]["user"]["password"] == "test_password"
 
+    # Verify that the old file was saved
+    with open(f"{mock_kube_credentials}.old", "r") as f:
+        credentials = yaml.safe_load(f)
+        assert credentials == empty_config
+
+    # Check file permissions for both old and new config file
+    assert oct(os.stat(mock_kube_credentials).st_mode)[-3:] == "600"
+    assert oct(os.stat(f"{mock_kube_credentials}.old").st_mode)[-3:] == "600"
+
 
 def test_update_existing_kube_config(mock_kube_credentials):
     with open(mock_kube_credentials, "wb") as f:
@@ -91,3 +105,16 @@ def test_update_existing_kube_config(mock_kube_credentials):
         assert credentials["users"][1]["name"] == "new_user"
         assert credentials["users"][1]["user"]["username"] == "new_username"
         assert credentials["users"][1]["user"]["password"] == "new_password"
+
+
+def test_normalized_k8s_url():
+    assert normalized_k8s_url("http://example.com") == "http://example.com"
+    assert normalized_k8s_url("https://example.com") == "https://example.com"
+    assert normalized_k8s_url("example.com") == "https://example.com"
+    assert normalized_k8s_url("http://example.com") == "http://example.com"
+    assert normalized_k8s_url("https://192.168.0.123:443") == "https://192.168.0.123:443"
+    assert normalized_k8s_url("192.168.0.123:6443") == "https://192.168.0.123:6443"
+    with pytest.raises(ValueError):
+        normalized_k8s_url("")
+
+    assert normalized_k8s_url(None) is None

{dfsync-0.4.6 → dfsync-0.4.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dfsync"
-version = "0.4.6"
+version = "0.4.8"
 description = ""
 authors = ["Mihai Balint <balint.mihai@gmail.com>"]
 
@@ -14,7 +14,7 @@ toml = "^0.10.2"
 tenacity = "^8.0.1"
 click-default-group = "^1.2.2"
 paramiko = {version = "^3.2.0", extras = ["invoke"]}
-black = "23.7.0"
+black = "24.3.0"
 
 [tool.poetry.dev-dependencies]
 pytest = "^7.4"
@@ -23,6 +23,7 @@ ipython = "^8"
 ipdb = "^0.13"
 flake8 = "^4.0.1"
 pycodestyle = "^2.8.0"
+tqdm = "4.66.0"
 
 [tool.black]
 line-length = 120