kubernetes-watch 0.1.4__py3-none-any.whl → 0.1.8__py3-none-any.whl

kube_watch/enums/kube.py

@@ -1,6 +1,6 @@
-from enum import Enum
-
-
-class Hosts(str, Enum):
-    LOCAL = 'local'
+from enum import Enum
+
+
+class Hosts(str, Enum):
+    LOCAL = 'local'
     REMOTE = 'remote'

kube_watch/enums/logic.py

@@ -1,9 +1,9 @@
-from enum import Enum
-
-class Operations(str, Enum):
-    OR  = 'or'
-    AND = 'and'
-    SUM = 'sum'
-    AVG = 'avg'
-    MAX = 'max'
+from enum import Enum
+
+class Operations(str, Enum):
+    OR  = 'or'
+    AND = 'and'
+    SUM = 'sum'
+    AVG = 'avg'
+    MAX = 'max'
     MIN = 'min'

kube_watch/enums/providers.py

@@ -1,13 +1,13 @@
-from enum import Enum
-
-class Providers(str, Enum):
-    AWS   = "aws"
-    AZURE = "azure"
-    GCP   = "gcp"
-    VAULT = "vault"
-
-
-class AwsResources(str, Enum):
-    ECR = "ecr" # elastic container registry
-    S3  = "s3"
+from enum import Enum
+
+class Providers(str, Enum):
+    AWS   = "aws"
+    AZURE = "azure"
+    GCP   = "gcp"
+    VAULT = "vault"
+
+
+class AwsResources(str, Enum):
+    ECR = "ecr" # elastic container registry
+    S3  = "s3"
     IAM = "iam" 

kube_watch/enums/workflow.py

@@ -1,18 +1,18 @@
-from enum import Enum
-
-class ParameterType(str, Enum):
-    STATIC = 'static'
-    FROM_ENV = 'env'
-    FROM_FLOW = 'flow'
-
-
-class TaskRunners(str, Enum):
-    SEQUENTIAL = 'sequential'
-    CONCURRENT = 'concurrent'
-    DASK       = 'dask'
-    RAY        = 'ray'
-
-
-class TaskInputsType(str, Enum):
-    ARG = 'arg'
+from enum import Enum
+
+class ParameterType(str, Enum):
+    STATIC = 'static'
+    FROM_ENV = 'env'
+    FROM_FLOW = 'flow'
+
+
+class TaskRunners(str, Enum):
+    SEQUENTIAL = 'sequential'
+    CONCURRENT = 'concurrent'
+    DASK       = 'dask'
+    RAY        = 'ray'
+
+
+class TaskInputsType(str, Enum):
+    ARG = 'arg'
     DICT = 'dict'

kube_watch/models/common.py

@@ -1,17 +1,17 @@
-from pydantic import BaseModel, ConfigDict
-from humps.camel import case
-
-def to_camel(string):
-    if string == "id":
-        return "_id"
-    if string.startswith("_"):  # "_id"
-        return string
-    return case(string)
-
-class CamelModel(BaseModel):
-    """
-    Replacement for pydanitc BaseModel which simply adds a camel case alias to every field
-    NOTE: This has been updated for Pydantic 2 to remove some common encoding helpers
-    """
-
+from pydantic import BaseModel, ConfigDict
+from humps.camel import case
+
+def to_camel(string):
+    if string == "id":
+        return "_id"
+    if string.startswith("_"):  # "_id"
+        return string
+    return case(string)
+
+class CamelModel(BaseModel):
+    """
+    Replacement for pydanitc BaseModel which simply adds a camel case alias to every field
+    NOTE: This has been updated for Pydantic 2 to remove some common encoding helpers
+    """
+
     model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)

kube_watch/models/workflow.py

@@ -1,60 +1,60 @@
-from typing import List, Optional, Dict, Any
-from kube_watch.enums.workflow import ParameterType, TaskRunners, TaskInputsType
-from kube_watch.enums.logic import Operations
-
-from .common import CamelModel
-
-class Parameter(CamelModel):
-    name: str
-    value: Any
-    type: Optional[ParameterType] = ParameterType.STATIC
-
-class Artifact(CamelModel):
-    path: str
-
-class Inputs(CamelModel):
-    parameters: Optional[List[Parameter]] = []
-    artifacts: Optional[List[Artifact]] = []
-
-class Dependency(CamelModel):
-    taskName: str
-    inputParamName: Optional[str] = None
-
-class Condition(CamelModel):
-    tasks: List[str]
-    operation: Optional[Operations] = Operations.AND
-
-class Task(CamelModel):
-    """
-    :param plugin_path: define if referring to an external module outside the library.
-    """
-    module: str
-    task: str
-    name: str
-    plugin_path: Optional[str] = ""
-    inputsArgType: Optional[TaskInputsType] = TaskInputsType.ARG  # @TODO refactor inputsArgType to inputs_arg_type
-    inputs: Optional[Inputs] = None
-    dependency: Optional[List[Dependency]]  = None
-    conditional: Optional[Condition]  = None
-    outputs: Optional[List[str]]  = None
-
-class WorkflowConfig(CamelModel):
-    name: str
-    runner: TaskRunners = TaskRunners.CONCURRENT
-    parameters: Optional[List[Parameter]] = []
-    tasks: List[Task]
-
-class WorkflowOutput(CamelModel):
-    flow_run: Any
-    config: Any
-
-class BatchFlowItem(CamelModel):
-    path: str
-
-class BatchFlowConfig(CamelModel):
-    # Only possible runners are concurrent and sequential
-    runner: TaskRunners = TaskRunners.CONCURRENT
-    items: List[BatchFlowItem]
-
-
-
+from typing import List, Optional, Dict, Any
+from kube_watch.enums.workflow import ParameterType, TaskRunners, TaskInputsType
+from kube_watch.enums.logic import Operations
+
+from .common import CamelModel
+
+class Parameter(CamelModel):
+    name: str
+    value: Any
+    type: Optional[ParameterType] = ParameterType.STATIC
+
+class Artifact(CamelModel):
+    path: str
+
+class Inputs(CamelModel):
+    parameters: Optional[List[Parameter]] = []
+    artifacts: Optional[List[Artifact]] = []
+
+class Dependency(CamelModel):
+    taskName: str
+    inputParamName: Optional[str] = None
+
+class Condition(CamelModel):
+    tasks: List[str]
+    operation: Optional[Operations] = Operations.AND
+
+class Task(CamelModel):
+    """
+    :param plugin_path: define if referring to an external module outside the library.
+    """
+    module: str
+    task: str
+    name: str
+    plugin_path: Optional[str] = ""
+    inputsArgType: Optional[TaskInputsType] = TaskInputsType.ARG  # @TODO refactor inputsArgType to inputs_arg_type
+    inputs: Optional[Inputs] = None
+    dependency: Optional[List[Dependency]]  = None
+    conditional: Optional[Condition]  = None
+    outputs: Optional[List[str]]  = None
+
+class WorkflowConfig(CamelModel):
+    name: str
+    runner: TaskRunners = TaskRunners.CONCURRENT
+    parameters: Optional[List[Parameter]] = []
+    tasks: List[Task]
+
+class WorkflowOutput(CamelModel):
+    flow_run: Any
+    config: Any
+
+class BatchFlowItem(CamelModel):
+    path: str
+
+class BatchFlowConfig(CamelModel):
+    # Only possible runners are concurrent and sequential
+    runner: TaskRunners = TaskRunners.CONCURRENT
+    items: List[BatchFlowItem]
+
+
+

kube_watch/modules/clusters/kube.py

@@ -1,186 +1,186 @@
-from prefect import get_run_logger
-from typing import List
-from kubernetes import config
-from kubernetes import client
-from kubernetes.client.rest import ApiException
-import base64
-import datetime
-
-from kube_watch.enums.kube import Hosts
-
-logger = get_run_logger()
-
-    
-def setup(host=Hosts.REMOTE, context=None):
-    if host == Hosts.LOCAL:
-        # Running outside a Kubernetes cluster (e.g., local development)
-        config.load_kube_config(context=context)  # You can specify the context here if necessary   
-    else:
-        # Running inside a Kubernetes cluster
-        config.load_incluster_config()
-
-
-
-def create_or_update_configmap(config_name, namespace, data):
-    """
-    Create or update a ConfigMap in a specified namespace if the data is different.
-    
-    :param config_name: The name of the ConfigMap.
-    :param namespace: The namespace of the ConfigMap.
-    :param data: A dictionary containing the data for the ConfigMap.
-    :return: True if the ConfigMap was created or updated, False otherwise.
-    """
-    v1 = client.CoreV1Api()
-    configmap_metadata = client.V1ObjectMeta(name=config_name, namespace=namespace)
-    configmap = client.V1ConfigMap(api_version="v1", kind="ConfigMap", metadata=configmap_metadata, data=data)
-    
-    try:
-        existing_configmap = v1.read_namespaced_config_map(name=config_name, namespace=namespace)
-        # Compare the existing ConfigMap's data with the new data
-        if existing_configmap.data == data:
-            logger.info("No update needed for ConfigMap: {}".format(config_name))
-            return False
-        else:
-            # Data is different, update the ConfigMap
-            api_response = v1.replace_namespaced_config_map(name=config_name, namespace=namespace, body=configmap)
-            logger.info("ConfigMap updated. Name: {}".format(api_response.metadata.name))
-            return True
-    except ApiException as e:
-        if e.status == 404:  # ConfigMap not found, create it
-            try:
-                api_response = v1.create_namespaced_config_map(namespace=namespace, body=configmap)
-                logger.info("ConfigMap created. Name: {}".format(api_response.metadata.name))
-                return {'trigger_restart': True}
-            except ApiException as e:
-                logger.error("Exception when creating ConfigMap: {}".format(e))
-                raise ValueError
-        else:
-            logger.error("Failed to get or create ConfigMap: {}".format(e))
-            raise ValueError
-        
-
-def create_or_update_secret(secret_name, namespace, data, secret_type = None):
-    """
-    Create or update a Secret in a specified namespace if the data is different.
-    
-    :param name: The name of the Secret.
-    :param namespace: The namespace of the Secret.
-    :param data: A dictionary containing the data for the Secret. Values must be strings (not Base64 encoded).
-    :return: True if the secret was created or updated, False otherwise.
-    """
-    if secret_type == None:
-        secret_type = "Opaque"
-
-    v1 = client.CoreV1Api()
-    secret_metadata = client.V1ObjectMeta(name=secret_name, namespace=namespace)
-    secret = client.V1Secret(
-        api_version="v1", 
-        kind="Secret", 
-        metadata=secret_metadata, 
-        string_data=data,
-        type=secret_type
-    )
-    
-    try:
-        existing_secret = v1.read_namespaced_secret(name=secret_name, namespace=namespace)
-        # Encode the new data to compare with the existing Secret
-        encoded_data = {k: base64.b64encode(v.encode()).decode() for k, v in data.items()}
-        
-        # Check if the existing secret's data matches the new data
-        if existing_secret.data == encoded_data:
-            logger.info("No update needed for Secret: {}".format(secret_name))
-            return False
-        else:
-            # Data is different, update the Secret
-            api_response = v1.replace_namespaced_secret(name=secret_name, namespace=namespace, body=secret)
-            logger.info("Secret updated. Name: {}".format(api_response.metadata.name))
-            return True
-
-    except ApiException as e:
-        if e.status == 404:  # Secret not found, create it
-            try:
-                api_response = v1.create_namespaced_secret(namespace=namespace, body=secret)
-                logger.info("Secret created. Name: {}".format(api_response.metadata.name))
-                return {'trigger_restart':  True}
-            except ApiException as e:
-                logger.error("Exception when creating Secret: {}".format(e))
-                raise ValueError
-        else:
-            logger.error("Failed to get or create Secret: {}".format(e))
-            raise ValueError
-        
-
-def get_kubernetes_secret(secret_name, namespace):
-    # Assuming that the Kubernetes configuration is already set
-    v1 = client.CoreV1Api()
-    try:
-        secret = v1.read_namespaced_secret(secret_name, namespace)
-        # Decoding the base64 encoded data
-        decoded_data = {key: base64.b64decode(value).decode('utf-8') for key, value in secret.data.items()}
-        return decoded_data
-    except ApiException as e:
-        logger.error(f"Failed to get secret: {e}")
-        return None
-    
-
-def restart_deployment(deployment, namespace):
-    """
-    Trigger a rollout restart of a deployment in a specified namespace.
-
-    :param name: The name of the deployment.
-    :param namespace: The namespace of the deployment.
-    """ 
-
-    v1 = client.AppsV1Api()
-    body = {
-        'spec': {
-            'template': {
-                'metadata': {
-                    'annotations': {
-                        'kubectl.kubernetes.io/restartedAt': datetime.datetime.utcnow().isoformat()
-                    }
-                }
-            }
-        }
-    }
-    try:
-        api_response = v1.patch_namespaced_deployment(name=deployment, namespace=namespace, body=body)
-        logger.info(f"Deployment restarted. Name: {api_response.metadata.name}")
-    except ApiException as e:
-        logger.error(f"Exception when restarting deployment: {e}")
-
-
-def has_mismatch_image_digest(repo_digest, label_selector, namespace):
-    """
-    Check all pods in the given namespace and matching the label selector for any
-    mismatch between the latest image digest and the current image digest.
-    
-    parameters:
-    - namespace: The namespace to search for pods.
-    - label_selector: The label selector to identify the relevant pods.
-    - repo_digest: The latest image digest to compare against.
-    
-    Returns:
-    - True if any pod is found with an image digest mismatch.
-    - False if all pods match the latest image digest.
-    """
-    core_v1_api         = client.CoreV1Api()
-
-    # Fetch pods based on namespace and label selector
-    pods = core_v1_api.list_namespaced_pod(namespace, label_selector=label_selector)
-    
-    # Iterate over pods and their containers
-    for pod in pods.items:
-        for container_status in pod.status.container_statuses:
-            current_image_id = container_status.image_id
-            # Check for digest mismatch
-            if current_image_id.split('@')[-1] != repo_digest:
-                logger.info(f"Mismatch found in pod: {pod.metadata.name}, container: {container_status.name}")
-                logger.info(f"Repo digest: {repo_digest}")
-                logger.info(f"Curr digest: {current_image_id.split('@')[-1]}")
-                return True
-    
-    logger.info("Images are in-sync.")
-    logger.info(f"Repo digest: {repo_digest}")
-    logger.info(f"Curr digest: {current_image_id.split('@')[-1]}")
+from prefect import get_run_logger
+from typing import List
+from kubernetes import config
+from kubernetes import client
+from kubernetes.client.rest import ApiException
+import base64
+import datetime
+
+from kube_watch.enums.kube import Hosts
+
+logger = get_run_logger()
+
+    
+def setup(host=Hosts.REMOTE, context=None):
+    if host == Hosts.LOCAL:
+        # Running outside a Kubernetes cluster (e.g., local development)
+        config.load_kube_config(context=context)  # You can specify the context here if necessary   
+    else:
+        # Running inside a Kubernetes cluster
+        config.load_incluster_config()
+
+
+
+def create_or_update_configmap(config_name, namespace, data):
+    """
+    Create or update a ConfigMap in a specified namespace if the data is different.
+    
+    :param config_name: The name of the ConfigMap.
+    :param namespace: The namespace of the ConfigMap.
+    :param data: A dictionary containing the data for the ConfigMap.
+    :return: True if the ConfigMap was created or updated, False otherwise.
+    """
+    v1 = client.CoreV1Api()
+    configmap_metadata = client.V1ObjectMeta(name=config_name, namespace=namespace)
+    configmap = client.V1ConfigMap(api_version="v1", kind="ConfigMap", metadata=configmap_metadata, data=data)
+    
+    try:
+        existing_configmap = v1.read_namespaced_config_map(name=config_name, namespace=namespace)
+        # Compare the existing ConfigMap's data with the new data
+        if existing_configmap.data == data:
+            logger.info("No update needed for ConfigMap: {}".format(config_name))
+            return False
+        else:
+            # Data is different, update the ConfigMap
+            api_response = v1.replace_namespaced_config_map(name=config_name, namespace=namespace, body=configmap)
+            logger.info("ConfigMap updated. Name: {}".format(api_response.metadata.name))
+            return True
+    except ApiException as e:
+        if e.status == 404:  # ConfigMap not found, create it
+            try:
+                api_response = v1.create_namespaced_config_map(namespace=namespace, body=configmap)
+                logger.info("ConfigMap created. Name: {}".format(api_response.metadata.name))
+                return {'trigger_restart': True}
+            except ApiException as e:
+                logger.error("Exception when creating ConfigMap: {}".format(e))
+                raise ValueError
+        else:
+            logger.error("Failed to get or create ConfigMap: {}".format(e))
+            raise ValueError
+        
+
+def create_or_update_secret(secret_name, namespace, data, secret_type = None):
+    """
+    Create or update a Secret in a specified namespace if the data is different.
+    
+    :param name: The name of the Secret.
+    :param namespace: The namespace of the Secret.
+    :param data: A dictionary containing the data for the Secret. Values must be strings (not Base64 encoded).
+    :return: True if the secret was created or updated, False otherwise.
+    """
+    if secret_type == None:
+        secret_type = "Opaque"
+
+    v1 = client.CoreV1Api()
+    secret_metadata = client.V1ObjectMeta(name=secret_name, namespace=namespace)
+    secret = client.V1Secret(
+        api_version="v1", 
+        kind="Secret", 
+        metadata=secret_metadata, 
+        string_data=data,
+        type=secret_type
+    )
+    
+    try:
+        existing_secret = v1.read_namespaced_secret(name=secret_name, namespace=namespace)
+        # Encode the new data to compare with the existing Secret
+        encoded_data = {k: base64.b64encode(v.encode()).decode() for k, v in data.items()}
+        
+        # Check if the existing secret's data matches the new data
+        if existing_secret.data == encoded_data:
+            logger.info("No update needed for Secret: {}".format(secret_name))
+            return False
+        else:
+            # Data is different, update the Secret
+            api_response = v1.replace_namespaced_secret(name=secret_name, namespace=namespace, body=secret)
+            logger.info("Secret updated. Name: {}".format(api_response.metadata.name))
+            return True
+
+    except ApiException as e:
+        if e.status == 404:  # Secret not found, create it
+            try:
+                api_response = v1.create_namespaced_secret(namespace=namespace, body=secret)
+                logger.info("Secret created. Name: {}".format(api_response.metadata.name))
+                return {'trigger_restart':  True}
+            except ApiException as e:
+                logger.error("Exception when creating Secret: {}".format(e))
+                raise ValueError
+        else:
+            logger.error("Failed to get or create Secret: {}".format(e))
+            raise ValueError
+        
+
+def get_kubernetes_secret(secret_name, namespace):
+    # Assuming that the Kubernetes configuration is already set
+    v1 = client.CoreV1Api()
+    try:
+        secret = v1.read_namespaced_secret(secret_name, namespace)
+        # Decoding the base64 encoded data
+        decoded_data = {key: base64.b64decode(value).decode('utf-8') for key, value in secret.data.items()}
+        return decoded_data
+    except ApiException as e:
+        logger.error(f"Failed to get secret: {e}")
+        return None
+    
+
+def restart_deployment(deployment, namespace):
+    """
+    Trigger a rollout restart of a deployment in a specified namespace.
+
+    :param name: The name of the deployment.
+    :param namespace: The namespace of the deployment.
+    """ 
+
+    v1 = client.AppsV1Api()
+    body = {
+        'spec': {
+            'template': {
+                'metadata': {
+                    'annotations': {
+                        'kubectl.kubernetes.io/restartedAt': datetime.datetime.utcnow().isoformat()
+                    }
+                }
+            }
+        }
+    }
+    try:
+        api_response = v1.patch_namespaced_deployment(name=deployment, namespace=namespace, body=body)
+        logger.info(f"Deployment restarted. Name: {api_response.metadata.name}")
+    except ApiException as e:
+        logger.error(f"Exception when restarting deployment: {e}")
+
+
+def has_mismatch_image_digest(repo_digest, label_selector, namespace):
+    """
+    Check all pods in the given namespace and matching the label selector for any
+    mismatch between the latest image digest and the current image digest.
+    
+    parameters:
+    - namespace: The namespace to search for pods.
+    - label_selector: The label selector to identify the relevant pods.
+    - repo_digest: The latest image digest to compare against.
+    
+    Returns:
+    - True if any pod is found with an image digest mismatch.
+    - False if all pods match the latest image digest.
+    """
+    core_v1_api         = client.CoreV1Api()
+
+    # Fetch pods based on namespace and label selector
+    pods = core_v1_api.list_namespaced_pod(namespace, label_selector=label_selector)
+    
+    # Iterate over pods and their containers
+    for pod in pods.items:
+        for container_status in pod.status.container_statuses:
+            current_image_id = container_status.image_id
+            # Check for digest mismatch
+            if current_image_id.split('@')[-1] != repo_digest:
+                logger.info(f"Mismatch found in pod: {pod.metadata.name}, container: {container_status.name}")
+                logger.info(f"Repo digest: {repo_digest}")
+                logger.info(f"Curr digest: {current_image_id.split('@')[-1]}")
+                return True
+    
+    logger.info("Images are in-sync.")
+    logger.info(f"Repo digest: {repo_digest}")
+    logger.info(f"Curr digest: {current_image_id.split('@')[-1]}")
     return False

kube_watch/modules/database/model.py

@@ -0,0 +1,12 @@
+from typing import Union
+from pydantic import BaseModel
+
+class TableQuery(BaseModel):
+    name: str
+    column_name: str
+    db_host: str
+    db_port: int
+    db_name: str
+    db_user: str
+    db_pass: str
+