kubernetes-watch 0.1.1__tar.gz → 0.1.3__tar.gz

{kubernetes_watch-0.1.1 → kubernetes_watch-0.1.3}/PKG-INFO

@@ -1,25 +1,22 @@
 Metadata-Version: 2.1
 Name: kubernetes-watch
-Version: 0.1.1
+Version: 0.1.3
 Summary: 
-License: MIT
 Author: bmotevalli
 Author-email: b.motevalli@gmail.com
 Requires-Python: >=3.10,<4
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: boto3 (==1.34.68)
-Requires-Dist: cryptography (==42.0.5)
-Requires-Dist: gitpython (==3.1.43)
-Requires-Dist: humps (==0.2.2)
-Requires-Dist: hvac (==2.1.0)
-Requires-Dist: kubernetes (==29.0.0)
-Requires-Dist: prefect (==2.18.0)
-Requires-Dist: pyyaml (==6.0.1)
-Requires-Dist: requests (==2.31.0)
+Requires-Dist: GitPython (>=3.1.43,<4.0.0)
+Requires-Dist: PyYAML (>=6.0.1,<7.0.0)
+Requires-Dist: boto3 (>=1.34.68,<2.0.0)
+Requires-Dist: humps (>=0.2.2,<0.3.0)
+Requires-Dist: hvac (>=2.1.0,<3.0.0)
+Requires-Dist: kubernetes (>=29.0.0,<30.0.0)
+Requires-Dist: prefect (>=2.18.0,<3.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
 Description-Content-Type: text/markdown
 
 # kube_watch
@@ -29,10 +26,16 @@ Description-Content-Type: text/markdown
 - `poetry install`
 - `poetry shell`
 
-# To install package to your environment:
+# To install package to your environment locally:
 
 python setup.py install
 
+# To publish
+
+`poetry config pypi-token.pypi your-api-token`
+`poetry build`
+`poetry publish`
+
 
 # Description
 The kube_watch library is build on top of <a href='https://docs.prefect.io/latest/'>Prefect</a>. The library is designed to define workflows in a declaritive and flexible fashion. Originally, workflows in Prefect are defined via decorators such as @flow and @task. In kube_watch, workflows can be defined in a declaritive form via yaml files. The library is mainly focused on running scheduled workflows in kubernetes environment. However, it can easily be extended to be used for any purpose requiring a workflow. The workflow manifest has the following generic structure:

{kubernetes_watch-0.1.1 → kubernetes_watch-0.1.3}/README.md

@@ -1,111 +1,117 @@
-# kube_watch
-
-# To setup the project:
-
-- `poetry install`
-- `poetry shell`
-
-# To install package to your environment:
-
-python setup.py install
-
-
-# Description
-The kube_watch library is build on top of <a href='https://docs.prefect.io/latest/'>Prefect</a>. The library is designed to define workflows in a declaritive and flexible fashion. Originally, workflows in Prefect are defined via decorators such as @flow and @task. In kube_watch, workflows can be defined in a declaritive form via yaml files. The library is mainly focused on running scheduled workflows in kubernetes environment. However, it can easily be extended to be used for any purpose requiring a workflow. The workflow manifest has the following generic structure:
-
-```
-workflow:
-  name: Dummy Workflow
-  runner: concurrent
-  tasks:
-    - name: Task_A
-      module: <module_path>
-      task: <func_name>
-      inputsArgType: arg
-      inputs:
-        parameters:
-          - name: x1
-            value: y1
-          - name: x2
-            value: y2
-          - name: x3
-            type: env
-            value: Y3
-
-    - name: Task_B
-      module: <module_path>
-      task: <func_name>
-      inputsArgType: arg
-      inputs:
-        parameters:
-          - name: xx1
-            value: yy1
-          - name: xx2
-            value: yy2
-      dependency:
-        - taskName: Task_A
-          inputParamName: xx3
-
-    - name: Task_C
-      module: <module_path>
-      task: <func_name>
-      inputsArgType: arg
-      conditional:
-        tasks: ["Task_B"]
-```
-
-
-**runner**: concurrent | sequential: if concurrent selected, tasks will be run concurrently.
-
-**module**: all modules are located in 'modules' directory in kube_watch. This is where you can extend the library and add new tasks / modules. Below modules, there are submodules such as providers, clusters, and logic. Within each of this submodules, specific modules are defined. For example: providers.aws contains a series of tasks related to AWS. In this case, <module_path> = providers.aws. To add new tasks, add a new module with a similar pattern and refer the path in your task block. 
-
-**task**: task is simply the name function that you put in the <module_path>. i.e. as you define a function in a module, you can simply start to use it in your manifests.
-
-**inputArgType**: arg | dict | list: if the task functions accept known-fixed number of parameters, then use arg. 
-
-**dependency**: this block defines dependency of a child task to its parent. If **inputParamName** is defined, then OUTPUT of the parent task is passed to the child with an argument name defined by inputParamName.
-
-**IMPORTATN NOTE**: A strict assumption is that task functions return a single output. If there are cases with multiple output, wrap them into a dictionary and unwrap them in the child task.
-
-**conditional**: These are blocks where you can define when a task runs depending on the outcome of its parent. The parent task should return True or False.
-
-
-Parameters have also a type entry: env | static. static is default value. If type is defined as env, the parameter value is loaded from Environment Variables. In this case, value should be the name of the corresponding env var. 
-
-In above examples:
-
-```
-def Task_A(x1, x2, x3):
-    # do something
-    return output_A
-
-def Task_B(xx1, xx2, xx3):
-    # do something else
-    return output_B
-
-def Task_C():
-    # do another thing
-    return output_C
-```
-
-
-
-# Batch workflows
-kube_watch also enables to run workflows in batch. A separate manifest with following form is required:
-
-batchFlows:
-  runner: sequential
-  items:
-    - path: path_to_flow_A.yaml
-    - path: path_to_flow_B.yaml
-    - path: path_to_flow_C.yaml
-
-
-# cron_app
-The cron_app folder contains an example use case of kube_watch library. The cron_app can be used to deploy a CronJob in a kubernetes environment. The app assumes the manifests are located in a separate repository. It will clone the repo and read the manifests and runs the workflows.
-
-# Connect to a server
-## Start Server
-`prefect server start`
-## To Connect
-To connect to a server, simply set the following environment variable: `PREFECT_API_URL`
+# kube_watch
+
+# To setup the project:
+
+- `poetry install`
+- `poetry shell`
+
+# To install package to your environment locally:
+
+python setup.py install
+
+# To publish
+
+`poetry config pypi-token.pypi your-api-token`
+`poetry build`
+`poetry publish`
+
+
+# Description
+The kube_watch library is build on top of <a href='https://docs.prefect.io/latest/'>Prefect</a>. The library is designed to define workflows in a declaritive and flexible fashion. Originally, workflows in Prefect are defined via decorators such as @flow and @task. In kube_watch, workflows can be defined in a declaritive form via yaml files. The library is mainly focused on running scheduled workflows in kubernetes environment. However, it can easily be extended to be used for any purpose requiring a workflow. The workflow manifest has the following generic structure:
+
+```
+workflow:
+  name: Dummy Workflow
+  runner: concurrent
+  tasks:
+    - name: Task_A
+      module: <module_path>
+      task: <func_name>
+      inputsArgType: arg
+      inputs:
+        parameters:
+          - name: x1
+            value: y1
+          - name: x2
+            value: y2
+          - name: x3
+            type: env
+            value: Y3
+
+    - name: Task_B
+      module: <module_path>
+      task: <func_name>
+      inputsArgType: arg
+      inputs:
+        parameters:
+          - name: xx1
+            value: yy1
+          - name: xx2
+            value: yy2
+      dependency:
+        - taskName: Task_A
+          inputParamName: xx3
+
+    - name: Task_C
+      module: <module_path>
+      task: <func_name>
+      inputsArgType: arg
+      conditional:
+        tasks: ["Task_B"]
+```
+
+
+**runner**: concurrent | sequential: if concurrent selected, tasks will be run concurrently.
+
+**module**: all modules are located in 'modules' directory in kube_watch. This is where you can extend the library and add new tasks / modules. Below modules, there are submodules such as providers, clusters, and logic. Within each of this submodules, specific modules are defined. For example: providers.aws contains a series of tasks related to AWS. In this case, <module_path> = providers.aws. To add new tasks, add a new module with a similar pattern and refer the path in your task block. 
+
+**task**: task is simply the name function that you put in the <module_path>. i.e. as you define a function in a module, you can simply start to use it in your manifests.
+
+**inputArgType**: arg | dict | list: if the task functions accept known-fixed number of parameters, then use arg. 
+
+**dependency**: this block defines dependency of a child task to its parent. If **inputParamName** is defined, then OUTPUT of the parent task is passed to the child with an argument name defined by inputParamName.
+
+**IMPORTATN NOTE**: A strict assumption is that task functions return a single output. If there are cases with multiple output, wrap them into a dictionary and unwrap them in the child task.
+
+**conditional**: These are blocks where you can define when a task runs depending on the outcome of its parent. The parent task should return True or False.
+
+
+Parameters have also a type entry: env | static. static is default value. If type is defined as env, the parameter value is loaded from Environment Variables. In this case, value should be the name of the corresponding env var. 
+
+In above examples:
+
+```
+def Task_A(x1, x2, x3):
+    # do something
+    return output_A
+
+def Task_B(xx1, xx2, xx3):
+    # do something else
+    return output_B
+
+def Task_C():
+    # do another thing
+    return output_C
+```
+
+
+
+# Batch workflows
+kube_watch also enables to run workflows in batch. A separate manifest with following form is required:
+
+batchFlows:
+  runner: sequential
+  items:
+    - path: path_to_flow_A.yaml
+    - path: path_to_flow_B.yaml
+    - path: path_to_flow_C.yaml
+
+
+# cron_app
+The cron_app folder contains an example use case of kube_watch library. The cron_app can be used to deploy a CronJob in a kubernetes environment. The app assumes the manifests are located in a separate repository. It will clone the repo and read the manifests and runs the workflows.
+
+# Connect to a server
+## Start Server
+`prefect server start`
+## To Connect
+To connect to a server, simply set the following environment variable: `PREFECT_API_URL`

{kubernetes_watch-0.1.1 → kubernetes_watch-0.1.3}/kube_watch/enums/workflow.py

@@ -3,6 +3,7 @@ from enum import Enum
 class ParameterType(str, Enum):
     STATIC = 'static'
     FROM_ENV = 'env'
+    FROM_FLOW = 'flow'
 
 
 class TaskRunners(str, Enum):

{kubernetes_watch-0.1.1 → kubernetes_watch-0.1.3}/kube_watch/models/workflow.py

@@ -25,10 +25,14 @@ class Condition(CamelModel):
     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
-    inputsArgType: Optional[TaskInputsType] = TaskInputsType.ARG
+    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
@@ -37,6 +41,7 @@ class Task(CamelModel):
 class WorkflowConfig(CamelModel):
     name: str
     runner: TaskRunners = TaskRunners.CONCURRENT
+    parameters: Optional[List[Parameter]] = []
     tasks: List[Task]
 
 class WorkflowOutput(CamelModel):

kubernetes_watch-0.1.3/kube_watch/modules/logic/actions.py

@@ -0,0 +1,56 @@
+import subprocess
+import os
+from typing import List
+from prefect import get_run_logger
+logger = get_run_logger()
+
+def run_standalone_script(package_name, package_run, package_exec):
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    # script_path = os.path.join(script_dir, package_name.replace('.', os.sep))
+    target_dir = os.path.join(script_dir, os.pardir, os.pardir, *package_name.split('.'))
+
+    full_command = f"{package_run} {os.path.join(target_dir, package_exec)}"
+
+    # Execute the command
+    try:
+        result = subprocess.run(full_command, shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        if result.stdout:
+            logger.info(result.stdout)
+        if result.stderr:
+            logger.error(result.stderr)
+        # logger.info(f"Output: {result.stdout}")
+        result.check_returncode()
+    except subprocess.CalledProcessError as e:
+        # All logs should have already been handled above, now just raise an exception
+        logger.error("The subprocess encountered an error: %s", e)
+        raise Exception("Subprocess failed with exit code {}".format(e.returncode))
+    
+
+def run_standalone_script_modified(base_path: str, package_name: str, package_run_cmds: List[str]):
+    # Construct the absolute path to the target directory
+    target_dir = os.path.join(base_path, *package_name.split('.'))
+
+    commands = [f"cd {target_dir}"] + package_run_cmds
+    full_command = " && ".join(commands)
+
+    # full_command = f"cd {target_dir} && {package_run_cmd}"
+
+    # Build the full command to execute
+    # full_command = f"{package_run} {os.path.join(target_dir, package_exec)}"
+
+    # print(full_command)
+
+    # Execute the command
+    try:
+        result = subprocess.run(full_command, shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        if result.stdout:
+            logger.info(result.stdout)
+        if result.stderr:
+            logger.error(result.stderr)
+        result.check_returncode()
+    except subprocess.CalledProcessError as e:
+        logger.error("Command failed with exit code %s", e.returncode)
+        logger.error("Output:\n%s", e.stdout)
+        logger.error("Errors:\n%s", e.stderr)
+        raise Exception(f"Subprocess failed with exit code {e.returncode}. Check logs for more details.")
+        # raise Exception(f"Subprocess failed with exit code {e.returncode}")

kubernetes_watch-0.1.3/kube_watch/modules/mock/mock_generator.py

@@ -0,0 +1,53 @@
+import time
+import random
+from prefect import runtime
+    
+def generate_number():
+    return 42
+
+
+def mock_dict_data():
+    return {
+        "key1": "value1",
+        "key2": "value2",
+        "key3": {
+            "k1": 1, "k2": 2, "k3": [1, 3, "ali"]
+        }
+    }
+
+def print_input(params):
+    print(params)
+
+def print_number(number, dummy_param, env_var_name):
+    print(f"The generated number is: {number} and the dummy_value is: {dummy_param}")
+    return number, dummy_param, env_var_name
+
+
+def print_flow_parameters():
+    assert runtime.flow_run.parameters.get("WORK_DIR") is not None
+    assert runtime.flow_run.parameters.get("MODULE_PATH") is not None
+    print(runtime.flow_run.parameters.get("WORK_DIR"))
+    print(runtime.flow_run.parameters.get("MODULE_PATH"))
+
+def print_from_flow_parameters(work_dir):
+    """
+    work_dir is provided via flow parameters
+    """
+    assert work_dir != ''
+    print(work_dir)
+
+
+def delay(seconds):
+    time.sleep(seconds)
+
+
+def random_boolean():
+    return random.choice([True, False])
+
+def merge_bools(inp_dict):
+    list_bools = [v for k,v in inp_dict.items()]
+    return any(list_bools)
+
+def print_result(task_name, result):
+    print(f'=========== {task_name} RESULT =================')
+    print(result)

{kubernetes_watch-0.1.1 → kubernetes_watch-0.1.3}/kube_watch/modules/providers/aws.py

@@ -4,7 +4,6 @@
 import boto3
 import base64
 import json
-
 from datetime            import datetime   , timezone, timedelta
 from botocore.exceptions import ClientError
 from prefect             import get_run_logger
@@ -77,7 +76,17 @@ def task_get_latest_image_digest(session, resource, region, repository_name, tag
 #========================================================================================
 # IAM Cred update
 #========================================================================================
-def task_rotate_iam_creds(session, user_name, old_access_key_id, old_access_key_secret, access_key_id_var_name, access_secret_key_var_name, rotate_interval):
+def task_rotate_iam_creds(
+        session,
+        user_name,
+        old_access_key_id,
+        old_access_key_secret,
+        access_key_id_var_name,
+        access_secret_key_var_name,
+        rotate_interval,
+        require_smtp_conversion = False,
+        ses_region = "ap-southeast-2"
+    ):
     iam = session.client('iam')
     creation_date              = None
 
@@ -102,14 +111,15 @@ def task_rotate_iam_creds(session, user_name, old_access_key_id, old_access_key_
    
     curr_date = datetime.now(timezone.utc)
     # Check if the key needs rotation
-    if (curr_date.weekday() == 5 and 
-        curr_date - creation_date > timedelta(days=dd,hours=hh,minutes=mm)):
+    if (curr_date - creation_date > timedelta(days=dd,hours=hh,minutes=mm)):
         logger.info("Key is older than rotation period, rotating now.")
         # Delete the old key
         delete_iam_user_key(session, user_name, old_access_key_id)
 
         # Create a new access key
         access_key_id, secret_access_key = create_iam_user_key(session, user_name)
+        if require_smtp_conversion:
+            secret_access_key = convert_to_smtp_password(secret_access_key, ses_region)
         return {access_key_id_var_name: access_key_id, access_secret_key_var_name: secret_access_key}
         
     else:
@@ -117,9 +127,9 @@ def task_rotate_iam_creds(session, user_name, old_access_key_id, old_access_key_
         return {access_key_id_var_name: old_access_key_id, access_secret_key_var_name: old_access_key_secret}
 
 
+
 def create_iam_user_key(session, user_name):
     iam       = session.client('iam')
-
     # Check if the user exists
     try:
         iam.get_user(UserName=user_name)
@@ -152,3 +162,50 @@ def delete_iam_user_key(session, user_name, access_key_id):
     except Exception as e:
         raise Exception(f"Failed to delete old key: {e}")
 
+    
+
+def convert_to_smtp_password(secret_access_key, region):
+    """Convert IAM Secret Key to SMTP Password."""
+    import hmac
+    import hashlib
+    import base64
+
+    SMTP_REGIONS = [
+        'us-east-2',       # US East (Ohio)
+        'us-east-1',       # US East (N. Virginia)
+        'us-west-2',       # US West (Oregon)
+        'ap-south-1',      # Asia Pacific (Mumbai)
+        'ap-northeast-2',  # Asia Pacific (Seoul)
+        'ap-southeast-1',  # Asia Pacific (Singapore)
+        'ap-southeast-2',  # Asia Pacific (Sydney)
+        'ap-northeast-1',  # Asia Pacific (Tokyo)
+        'ca-central-1',    # Canada (Central)
+        'eu-central-1',    # Europe (Frankfurt)
+        'eu-west-1',       # Europe (Ireland)
+        'eu-west-2',       # Europe (London)
+        'sa-east-1',       # South America (Sao Paulo)
+        'us-gov-west-1',   # AWS GovCloud (US)
+    ]
+
+    # These values are required to calculate the signature. Do not change them.
+    DATE = "11111111"
+    SERVICE = "ses"
+    MESSAGE = "SendRawEmail"
+    TERMINAL = "aws4_request"
+    VERSION = 0x04
+
+
+    def sign(key, msg):
+        return hmac.new(key, msg.encode('utf-8'), hashlib.sha256).digest()
+    
+    if region not in SMTP_REGIONS:
+        raise ValueError(f"The {region} Region doesn't have an SMTP endpoint.")
+
+    signature = sign(("AWS4" + secret_access_key).encode('utf-8'), DATE)
+    signature = sign(signature, region)
+    signature = sign(signature, SERVICE)
+    signature = sign(signature, TERMINAL)
+    signature = sign(signature, MESSAGE)
+    signature_and_version = bytes([VERSION]) + signature
+    smtp_password = base64.b64encode(signature_and_version)
+    return smtp_password.decode('utf-8')

{kubernetes_watch-0.1.1 → kubernetes_watch-0.1.3}/kube_watch/watch/helpers.py

@@ -1,7 +1,7 @@
 from prefect import task
-import functools
-import asyncio
+import sys
 from prefect.task_runners import ConcurrentTaskRunner, SequentialTaskRunner
+from prefect import runtime
 # from prefect_dask.task_runners import DaskTaskRunner
 from typing import Dict, List
 import yaml
@@ -51,28 +51,46 @@ def func_task(name="default_task_name", task_input_type: TaskInputsType = TaskIn
 
 
 
-def get_task_function(module_name, task_name):
-    # module = importlib.import_module(f"sparrow_watch.modules.{module_name}")
-    # klass = getattr(module, class_name)
-    # return getattr(klass, task_name)
+def get_task_function(module_name, task_name, plugin_path=None):
     """
     Fetch a function directly from a specified module.
     
     Args:
         module_name (str): The name of the module to import the function from. e.g. providers.aws
         task_name (str): The name of the function to fetch from the module.
+        plugin_path (ster): define for external modules
         
     Returns:
         function: The function object fetched from the module.
     """
-    module = importlib.import_module(f"kube_watch.modules.{module_name}")
-    return getattr(module, task_name)
+    try:
+        if plugin_path:
+            # Temporarily prepend the plugin path to sys.path to find the module
+            module_path = os.path.join(plugin_path, *module_name.split('.')) + '.py'
+            module_spec = importlib.util.spec_from_file_location(module_name, module_path)
+            module = importlib.util.module_from_spec(module_spec)
+            module_spec.loader.exec_module(module)
+        else:
+            # Standard import from the internal library path
+            module = importlib.import_module(f"kube_watch.modules.{module_name}")
+        
+        return getattr(module, task_name)
+    except ImportError as e:
+        raise ImportError(f"Unable to import module '{module_name}': {e}")
+    except AttributeError as e:
+        raise AttributeError(f"The module '{module_name}' does not have a function named '{task_name}': {e}")
+    finally:
+        if plugin_path:
+            # Remove the plugin path from sys.path after importing
+            sys.path.pop(0)  # Using pop(0) is safer in the context of insert(0, plugin_path)
 
 
 
 def resolve_parameter_value(param):
     if param.type == ParameterType.FROM_ENV:
         return os.getenv(param.value, '')  # Default to empty string if env var is not set
+    if param.type == ParameterType.FROM_FLOW:
+        return runtime.flow_run.parameters.get(param.value, '')
     return param.value
 
 def prepare_task_inputs(parameters):

{kubernetes_watch-0.1.1 → kubernetes_watch-0.1.3}/kube_watch/watch/workflow.py

@@ -1,4 +1,4 @@
-from prefect import flow,  get_run_logger
+from prefect import flow,  get_run_logger, runtime
 import asyncio
 from typing import List
 import secrets
@@ -20,10 +20,14 @@ def create_flow_based_on_config(yaml_file, run_async=True):
     async def dynamic_workflow():
         logger = get_run_logger()
         tasks = {}
+
+        for param in workflow_config.parameters:      
+            runtime.flow_run.parameters[param.name] = param.value
+
         logger.info(f"Starting flow: {flow_name}")
         for task_data in workflow_config.tasks:
             task_name   = task_data.name
-            func        = helpers.get_task_function(task_data.module, task_data.task)
+            func        = helpers.get_task_function(task_data.module, task_data.task, task_data.plugin_path)
             task_inputs = helpers.prepare_task_inputs(task_data.inputs.parameters) if task_data.inputs else {}
 
             condition_result = True
@@ -38,17 +42,6 @@ def create_flow_based_on_config(yaml_file, run_async=True):
                 task_future = helpers.submit_task(task_name, task_data, task_inputs, func)
                 tasks[task_data.name] = task_future
             
-            # if task_data.dependency:
-            #     task_inputs = helpers.prepare_task_inputs_from_dep(task_data, task_inputs, tasks)
-        
-            # if task_data.conditional:
-            #     condition_result  = helpers.resolve_conditional(task_data, tasks)
-            #     if condition_result:
-            #         task_future = helpers.submit_task(task_name, task_data, task_inputs, func)
-            #         tasks[task_data.name] = task_future
-            # else:
-            #     task_future = helpers.submit_task(task_name, task_data, task_inputs, func)
-            #     tasks[task_data.name] = task_future
 
         return tasks
     return dynamic_workflow

{kubernetes_watch-0.1.1 → kubernetes_watch-0.1.3}/pyproject.toml

@@ -1,23 +1,21 @@
 [tool.poetry]
 name = "kubernetes-watch"
-version = "0.1.1"
+version = "0.1.3"
 description = ""
 authors = ["bmotevalli <b.motevalli@gmail.com>"]
-readme = "README.md"
 packages = [{include = "kube_watch"}]
-license = "MIT"
+readme = "README.md"
 
 [tool.poetry.dependencies]
 python = ">=3.10,<4"
-prefect = "2.18.0"
-boto3 = "1.34.68"
-hvac = "2.1.0"
-humps = "0.2.2"
-requests = "2.31.0"
-kubernetes = "29.0.0"
-pyyaml = "6.0.1"
-gitpython = "3.1.43"
-cryptography = "42.0.5"
+prefect = "^2.18.0"
+boto3 = "^1.34.68"
+hvac = "^2.1.0"
+humps = "^0.2.2"
+requests = "^2.32.3"
+kubernetes = "^29.0.0"
+PyYAML = "^6.0.1"
+GitPython = "^3.1.43"
 
 
 [build-system]

kubernetes_watch-0.1.1/kube_watch/modules/logic/actions.py

@@ -1,26 +0,0 @@
-import subprocess
-import os
-from prefect import get_run_logger
-logger = get_run_logger()
-
-def run_standalone_script(package_name, package_run, package_exec):
-    script_dir = os.path.dirname(os.path.realpath(__file__))
-    # script_path = os.path.join(script_dir, package_name.replace('.', os.sep))
-    target_dir = os.path.join(script_dir, os.pardir, os.pardir, *package_name.split('.'))
-
-    # Change the current working directory to the script directory
-    full_command = f"{package_run} {os.path.join(target_dir, package_exec)}"
-
-    # Execute the command
-    try:
-        result = subprocess.run(full_command, shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-        if result.stdout:
-            logger.info(result.stdout)
-        if result.stderr:
-            logger.error(result.stderr)
-        # logger.info(f"Output: {result.stdout}")
-        result.check_returncode()
-    except subprocess.CalledProcessError as e:
-        # All logs should have already been handled above, now just raise an exception
-        logger.error("The subprocess encountered an error: %s", e)
-        raise Exception("Subprocess failed with exit code {}".format(e.returncode))

kubernetes_watch-0.1.1/kube_watch/modules/mock/mock_generator.py

@@ -1,24 +0,0 @@
-import time
-import random
-    
-def generate_number():
-    return 42
-
-def print_number(number, dummy_param, env_var_name):
-    print(f"The generated number is: {number} and the dummy_value is: {dummy_param}")
-    return number, dummy_param, env_var_name
-
-def delay(seconds):
-    time.sleep(seconds)
-
-
-def random_boolean():
-    return random.choice([True, False])
-
-def merge_bools(inp_dict):
-    list_bools = [v for k,v in inp_dict.items()]
-    return any(list_bools)
-
-def print_result(task_name, result):
-    print(f'=========== {task_name} RESULT =================')
-    print(result)