dfsync 0.4.5__tar.gz → 0.4.7__tar.gz

{dfsync-0.4.5 → dfsync-0.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dfsync
-Version: 0.4.5
+Version: 0.4.7
 Summary: 
 Author: Mihai Balint
 Author-email: balint.mihai@gmail.com
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.8
 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: click (>=8,<9)
 Requires-Dist: click-default-group (>=1.2.2,<2.0.0)

{dfsync-0.4.5 → dfsync-0.4.7}/dfsync/backends/kube.py

@@ -1,3 +1,4 @@
+import copy
 import sys
 import os
 import os.path
@@ -11,11 +12,27 @@ 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 = []
 DEFAULT_PULL_POLICY = "Always"
-
+DISABLED_PROBES = {
+    "readiness_probe": {
+        "_exec": {"command": ["true"]},
+        "timeout_seconds": 5,
+        "period_seconds": 15,
+        "initial_delay_seconds": 0,
+        "failure_threshold": 3,
+    },
+    "startup_probe": {
+        "_exec": {"command": ["true"]},
+        "timeout_seconds": 2,
+        "period_seconds": 1,
+        "initial_delay_seconds": 0,
+        "failure_threshold": 60,
+    },
+}
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
 
@@ -147,88 +164,87 @@ class Generic:
         return ["true"]
 
 
+def clean_probe(probe: dict) -> client.V1Probe:
+    if probe is None:
+        return None
+
+    probe_types = ["_exec", "http_get", "tcp_socket", "grpc"]
+    probe = copy.deepcopy(probe)
+    cleaned = {k: v for k, v in probe.items() if k not in probe_types or k is not None}
+    assert any(pt in cleaned for pt in probe_types), f"Probe missing probe type: {probe.keys()}"
+    return client.V1Probe(**cleaned)
+
+
 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
@@ -241,7 +257,16 @@ class KubeReDeployer:
             return
 
         command = self._image_distro.get_supervise_command(self.container_command)
-        deployments = self._edit_deployment(pod, spec, status, command=command, image_pull_policy="Never")
+        deployments = self._edit_deployment(
+            pod,
+            spec,
+            status,
+            command=command,
+            image_pull_policy="Never",
+            startup_probe=None,
+            readiness_probe=None,
+            liveness_probe=None,
+        )
 
         print("Supervisor installing on {}".format(" ".join(deployments)))
 
@@ -303,6 +328,8 @@ class KubeReDeployer:
                     existing_requests = container_spec.resources.requests or {}
                     new_requests = v.get("requests") or {}
                     container_spec.resources.requests = {**existing_requests, **new_requests}
+                elif k in ["readiness_probe", "startup_probe", "liveness_probe"]:
+                    setattr(container_spec, k, clean_probe(v or DISABLED_PROBES.get(k)))
                 else:
                     setattr(container_spec, k, v)
 
@@ -315,7 +342,7 @@ class KubeReDeployer:
                 metadata=deployment.metadata,
                 spec=deployment.spec,
             )
-            self.apps_api.patch_namespaced_deployment(
+            self.apps_api.replace_namespaced_deployment(
                 name=deployment.metadata.name,
                 namespace=namespace,
                 body=patch,

{dfsync-0.4.5 → dfsync-0.4.7}/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.7/dfsync/diffui.py

@@ -0,0 +1,63 @@
+import difflib
+import time
+
+text1 = """
+The project, "micrograd", is currently at version 0.8.0 and was authored by Andrej Karpathy. It is structured into two main directories: "micrograd" and "test". The "micrograd" directory contains the main source code for the project, while the "test" directory contains the test code.
+
+The project uses Python 3.10 and has dependencies on numpy, sklearn, and matplotlib. The build system requires "poetry-core" and uses "poetry.core.masonry.api" as the build backend.
+
+The main files in the project are:
+- `test/test_engine.py`: Contains tests for the engine component of the project.
+- `micrograd/nn.py`: Contains code related to neural networks.
+- `micrograd/__init__.py`: The initialization file for the "micrograd" package.
+- `micrograd/engine.py`: Contains the main engine code for the project. It defines a `Value` class that stores a single scalar value and its gradient. This class is central to the project as it implements methods for basic mathematical operations, and more importantly, methods for automatic differentiation (autograd), which is a key component in training neural networks.
+- `micrograd/demo.py`: Likely contains a demonstration or example usage of the project.
+
+This project appears to be a minimalistic implementation of a deep learning library, focusing on the autograd feature. The `Value` class in `engine.py` is the heart of this library, implementing the forward and backward passes necessary for neural network training.
+"""
+text2 = """
+The project, "micrograd", is currently at version 0.8.0 and was authored by Andrej Karpathy. It is structured into two main directories: "micrograd" and "test". The "micrograd" directory contains the main source code for the project, while the "test" directory contains the test code.
+
+The project uses Python 3.10 and has dependencies on numpy, sklearn, and matplotlib. The build system requires "poetry-core" and uses "poetry.core.masonry.api" as the build backend.
+
+The main files in the project are:
+- `test/test_engine.py`: Contains tests for the engine component of the project.
+- `micrograd/nn.py`: Contains code related to neural networks, including the definition of `Module`, `Neuron`, `Layer`, and `MLP` classes. These classes form the building blocks of the neural network functionality in the project. The `Module` class provides a base for other classes, with methods for zeroing gradients and retrieving parameters. The `Neuron` class represents a single neuron, the `Layer` class represents a layer of neurons, and the `MLP` class represents a multi-layer perceptron.
+- `micrograd/__init__.py`: The initialization file for the "micrograd" package.
+- `micrograd/engine.py`: Contains the main engine code for the project. It defines a `Value` class that stores a single scalar value and its gradient. This class is central to the project as it implements methods for basic mathematical operations, and more importantly, methods for automatic differentiation (autograd), which is a key component in training neural networks.
+- `micrograd/demo.py`: Likely contains a demonstration or example usage of the project.
+
+This project appears to be a minimalistic implementation of a deep learning library, focusing on the autograd feature. The `Value` class in `engine.py` is the heart of this library, implementing the forward and backward passes necessary for neural network training. The `nn.py` file extends this functionality by providing the necessary classes to build and manipulate neural networks.
+"""
+
+
+def colored(diff_line: str) -> str:
+    line = diff_line if diff_line.endswith("\n") else f"{diff_line}\n"
+    red = "\033[38;2;255;0;0m"
+    green = "\033[38;2;0;255;0m"
+    reset_color = "\033[0m"
+
+    if line.startswith("+"):
+        return f"{green}{line[1:]}{reset_color}"
+    elif line.startswith("-"):
+        return f"{red}{line[1:]}{reset_color}"
+    else:
+        return line[1:]
+
+
+def animate_diff(a: str, b: str):
+    a_lines = a.splitlines()
+    b_lines = b.splitlines()
+    diff = difflib.unified_diff(a_lines, b_lines, n=len(a_lines))
+    print("\033[H\033[J", end="")  # Clear the screen
+
+    lines = []
+    for line in diff:
+        if line.startswith("---") or line.startswith("+++") or line.startswith("@@"):
+            continue
+        lines.append(colored(line))
+    print("".join(lines))
+
+
+if __name__ == "__main__":
+    animate_diff(text1, text2)

{dfsync-0.4.5 → dfsync-0.4.7}/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)
@@ -70,7 +71,7 @@ def update_local_kube_config(new_kube_credentials):
         credentials["users"].append(users_entry)
         print(f"Adding entry to users section '{user_name}'")
 
-    if not credentials["current-context"]:
+    if not credentials.get("current-context"):
         credentials["current-context"] = contexts_entry["name"]
 
     credentials_yaml = yaml.dump(credentials)
@@ -132,3 +133,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.5 → dfsync-0.4.7}/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.5 → dfsync-0.4.7}/dfsync/monitor.py

@@ -17,7 +17,7 @@ from dfsync.distribution import get_installed_version, get_latest_version, is_ol
 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)
@@ -271,7 +271,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 +342,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,

dfsync-0.4.7/dfsync/test_dfsync.py

@@ -0,0 +1,39 @@
+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()
+
+    assert emacs.is_filtered("test_dfsync.py") is False
+    assert emacs.is_filtered("./test_dfsync.py") is False
+    assert emacs.is_filtered("./tests/test_dfsync.py") is False
+    assert emacs.is_filtered("tests/test_dfsync.py") is False
+    assert emacs.is_filtered("/tests/test_dfsync.py") is False
+
+    assert emacs.is_filtered("#test_dfsync.py#") is True
+    assert emacs.is_filtered("./#test_dfsync.py#") is True
+    assert emacs.is_filtered("./tests/#test_dfsync.py#") is True
+    assert emacs.is_filtered("tests/#test_dfsync.py#") is True
+    assert emacs.is_filtered("/tests/#test_dfsync.py#") is True
+
+    assert emacs.is_filtered("test_dfsync.py~") is True
+    assert emacs.is_filtered("./test_dfsync.py~") is True
+    assert emacs.is_filtered("./tests/test_dfsync.py~") is True
+    assert emacs.is_filtered("tests/test_dfsync.py~") is True
+    assert emacs.is_filtered("/tests/test_dfsync.py~") is True
+
+
+def test_untracked_git_files_filter():
+    git = UntrackedGitFilesFilter()
+
+    assert git.is_filtered(__name__) is False
+    assert git.is_filtered("does-not-exist.py") is False
+
+    with NamedTemporaryFile(dir=".") as f:
+        assert git.is_filtered(f.name) is True

dfsync-0.4.7/dfsync/test_kube_credentials.py

@@ -0,0 +1,107 @@
+import pytest
+import yaml
+import tempfile
+
+from dfsync.kube_credentials import update_local_kube_config, normalized_k8s_url
+
+
+@pytest.fixture
+def mock_kube_credentials(mocker):
+    with tempfile.NamedTemporaryFile(delete=True) as temp:
+        mocker.patch("dfsync.kube_credentials.LOCAL_CREDENTIALS_FILE", temp.name)
+        return temp.name
+
+
+def test_update_missing_kube_config(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"}],
+        "users": [{"user": {"username": "test_user"}, "name": "test_user"}],
+    }
+    result = update_local_kube_config(new_kube_credentials)
+    assert "test_cluster" in result
+    assert "test_context" in result
+    assert "test_user" in result
+
+
+def test_update_empty_kube_config(mock_kube_credentials):
+    with open(mock_kube_credentials, "wb") as f:
+        empty_config = {
+            "clusters": [],
+            "contexts": [],
+            "users": [],
+        }
+        f.write(yaml.dump(empty_config).encode())
+
+    new_kube_credentials = {
+        "clusters": [{"name": "test_cluster", "cluster": {"server": "test_server"}}],
+        "contexts": [{"name": "test_context", "context": {"cluster": "test_cluster", "user": "test_user"}}],
+        "users": [{"name": "test_user", "user": {"username": "test_username", "password": "test_password"}}],
+    }
+    update_local_kube_config(new_kube_credentials)
+
+    # Verify the results
+    with open(mock_kube_credentials, "r") as f:
+        credentials = yaml.safe_load(f)
+
+        assert credentials["clusters"][0]["name"] == "test_cluster"
+        assert credentials["clusters"][0]["cluster"]["server"] == "test_server"
+        assert credentials["contexts"][0]["name"] == "test_context"
+        assert credentials["contexts"][0]["context"]["cluster"] == "test_cluster"
+        assert credentials["contexts"][0]["context"]["user"] == "test_user"
+        assert credentials["users"][0]["name"] == "test_user"
+        assert credentials["users"][0]["user"]["username"] == "test_username"
+        assert credentials["users"][0]["user"]["password"] == "test_password"
+
+
+def test_update_existing_kube_config(mock_kube_credentials):
+    with open(mock_kube_credentials, "wb") as f:
+        existing_config = {
+            "clusters": [
+                {"name": "existing_cluster", "cluster": {"server": "existing_server"}},
+            ],
+            "contexts": [
+                {"name": "existing_context", "context": {"cluster": "existing_cluster", "user": "existing_user"}}
+            ],
+            "users": [
+                {"name": "existing_user", "user": {"username": "existing_username", "password": "existing_password"}}
+            ],
+        }
+        f.write(yaml.dump(existing_config).encode())
+
+    new_kube_credentials = {
+        "clusters": [{"name": "new_cluster", "cluster": {"server": "new_server"}}],
+        "contexts": [{"name": "new_context", "context": {"cluster": "new_cluster", "user": "new_user"}}],
+        "users": [{"name": "new_user", "user": {"username": "new_username", "password": "new_password"}}],
+    }
+    update_local_kube_config(new_kube_credentials)
+
+    # Verify the results
+    with open(mock_kube_credentials, "r") as f:
+        credentials = yaml.safe_load(f)
+
+        assert len(credentials["clusters"]) == 2
+        assert len(credentials["contexts"]) == 2
+        assert len(credentials["users"]) == 2
+
+        assert credentials["clusters"][1]["name"] == "new_cluster"
+        assert credentials["clusters"][1]["cluster"]["server"] == "new_server"
+        assert credentials["contexts"][1]["name"] == "new_context"
+        assert credentials["contexts"][1]["context"]["cluster"] == "new_cluster"
+        assert credentials["contexts"][1]["context"]["user"] == "new_user"
+        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("")
+    with pytest.raises(ValueError):
+        normalized_k8s_url(None)

dfsync-0.4.7/dfsync/test_lib.py

@@ -0,0 +1,28 @@
+import pytest
+from dfsync.lib import ControlledThreadedOperation, ThreadedOperationsManager
+
+
+def test_threaded_operations_manager():
+    manager = ThreadedOperationsManager()
+    assert len(manager.threads) == 0
+
+    operation = ControlledThreadedOperation()
+    manager.register_threaded_operation(operation)
+    assert len(manager.threads) == 1
+
+    manager.stop()
+    assert operation.is_completed
+
+
+def test_controlled_threaded_operation():
+    operation = ControlledThreadedOperation()
+    assert not operation.is_running
+    assert operation.is_completed
+
+    operation.start()
+    assert operation.is_running
+    assert not operation.is_completed
+
+    operation.stop()
+    assert not operation.is_running
+    assert operation.is_completed

{dfsync-0.4.5 → dfsync-0.4.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dfsync"
-version = "0.4.5"
+version = "0.4.7"
 description = ""
 authors = ["Mihai Balint <balint.mihai@gmail.com>"]
 
@@ -17,12 +17,16 @@ paramiko = {version = "^3.2.0", extras = ["invoke"]}
 black = "23.7.0"
 
 [tool.poetry.dev-dependencies]
-pytest = "^3.0"
+pytest = "^7.4"
+pytest_mock = "^3.12"
 ipython = "^8"
-ipdb = "^0.13.9"
+ipdb = "^0.13"
 flake8 = "^4.0.1"
 pycodestyle = "^2.8.0"
 
+[tool.black]
+line-length = 120
+
 [tool.poetry.scripts]
 dfsync = "dfsync.cli:dfsync"
 [build-system]