kubernetes-watch 0.1.5__py3-none-any.whl → 0.1.9__py3-none-any.whl

kube_watch/watch/workflow.py

@@ -1,100 +1,232 @@
-from prefect import flow,  get_run_logger, runtime
-import asyncio
-from typing import List
-import secrets
-import os
-import kube_watch.watch.helpers as helpers
-from kube_watch.models.workflow import WorkflowOutput
-from kube_watch.enums.workflow import TaskRunners, TaskInputsType
-
-
-# @TODO: CONCURRENCY DOES NOT WORK PROPERLY AT FLOW LEVEL
-def create_flow_based_on_config(yaml_file, run_async=True):
-    workflow_config = helpers.load_workflow_config(yaml_file)
-    flow_name       = workflow_config.name
-    runner          = helpers.resolve_runner(workflow_config.runner)
-    random_suffix   = secrets.token_hex(6)
-    flow_run_name   = f"{flow_name} - {random_suffix}"
-
-    @flow(name=flow_name, flow_run_name=flow_run_name, task_runner=runner)
-    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, task_data.plugin_path)
-            task_inputs = helpers.prepare_task_inputs(task_data.inputs.parameters) if task_data.inputs else {}
-
-            condition_result = True
-            if task_data.conditional:
-                condition_result = helpers.resolve_conditional(task_data, tasks)
-
-            if condition_result:
-                # Resolve dependencies only if the task is going to be executed
-                if task_data.dependency:
-                    task_inputs = helpers.prepare_task_inputs_from_dep(task_data, task_inputs, tasks)
-                
-                task_future = helpers.submit_task(task_name, task_data, task_inputs, func)
-                tasks[task_data.name] = task_future
-            
-
-        return tasks
-    return dynamic_workflow
-
-
-# SINGLE
-def single_run_workflow(yaml_file, return_state=True) -> WorkflowOutput:
-    dynamic_flow  = create_flow_based_on_config(yaml_file, run_async=False)
-    flow_run = dynamic_flow(return_state=return_state)
-    return WorkflowOutput(**{'flow_run': flow_run, 'config': dynamic_flow}) 
-
-
-# BATCH
-
-@flow(name="Batch Workflow Runner - Sequential")
-def batch_run_sequential(batch_config, batch_dir) -> List[WorkflowOutput]:
-    # batch_config = helpers.load_batch_config(batch_yaml_file)
-    # batch_dir = os.path.dirname(batch_yaml_file)
-    flows = []
-    for item in batch_config.items:
-        yaml_file_path = os.path.join(batch_dir, item.path)
-        output = single_run_workflow(yaml_file_path, return_state = True)
-        flows.append(output)
-
-    return flows
-
-# @TODO: CONCURRENCY DOES NOT WORK PROPERLY AT FLOW LEVEL
-@flow(name="Batch Workflow Runner - Concurrent")
-async def batch_run_concurrent(batch_config, batch_dir) -> List[WorkflowOutput]:
-    # Asynchronous flow run submissions
-    flow_runs = []
-    for item in batch_config.items:
-        yaml_file_path = os.path.join(batch_dir, item.path)
-        # Here you create flow runs but do not await them yet
-        flow_function = create_flow_based_on_config(yaml_file_path, run_async=True)
-        flow_run_future = flow_function(return_state=True)  # Ensure this is submitted asynchronously
-        flow_runs.append(flow_run_future)
-        is_async = asyncio.iscoroutinefunction(flow_function)
-
-
-    # Await all flow runs to finish concurrently
-    results = await asyncio.gather(*flow_runs)
-    return [WorkflowOutput(**{'flow_run': result, 'config': flow_function}) for result, flow_function in zip(results, flow_runs)]
-
-
-def batch_run_workflow(batch_yaml_file):
-    batch_config = helpers.load_batch_config(batch_yaml_file)
-    batch_dir = os.path.dirname(batch_yaml_file)
-
-    if batch_config.runner == TaskRunners.SEQUENTIAL:
-        return batch_run_sequential(batch_config, batch_dir)
-    
-    if batch_config.runner == TaskRunners.CONCURRENT:
-        return asyncio.run(batch_run_concurrent(batch_config, batch_dir))
-
-    raise ValueError('Invalid flow runner type')
+from prefect import flow,  get_run_logger, runtime
+import asyncio
+from typing import List
+import secrets
+import os
+import kube_watch.watch.helpers as helpers
+from kube_watch.models.workflow import WorkflowOutput
+from kube_watch.enums.workflow import TaskRunners, TaskInputsType
+
+
+# @TODO: CONCURRENCY DOES NOT WORK PROPERLY AT FLOW LEVEL
+def create_flow_based_on_config(yaml_file, run_async=True):
+    workflow_config = helpers.load_workflow_config(yaml_file)
+    flow_name       = workflow_config.name
+    runner          = helpers.resolve_runner(workflow_config.runner)
+    random_suffix   = secrets.token_hex(6)
+    flow_run_name   = f"{flow_name} - {random_suffix}"
+
+    @flow(name=flow_name, flow_run_name=flow_run_name, task_runner=runner)
+    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, task_data.plugin_path)
+            task_inputs = helpers.prepare_task_inputs(task_data.inputs.parameters) if task_data.inputs else {}
+
+            condition_result = True
+            if task_data.conditional:
+                condition_result = helpers.resolve_conditional(task_data, tasks)
+
+            if condition_result:
+                # Resolve dependencies only if the task is going to be executed
+                if task_data.dependency:
+                    task_inputs = helpers.prepare_task_inputs_from_dep(task_data, task_inputs, tasks)
+                
+                task_future = helpers.submit_task(task_name, task_data, task_inputs, func)
+                tasks[task_data.name] = task_future
+            
+
+        return tasks
+    return dynamic_workflow
+
+
+# SINGLE
+def single_run_workflow(yaml_file, return_state=True) -> WorkflowOutput:
+    dynamic_flow  = create_flow_based_on_config(yaml_file, run_async=False)
+    flow_run = dynamic_flow(return_state=return_state)
+    return WorkflowOutput(**{'flow_run': flow_run, 'config': dynamic_flow})
+
+
+async def single_run_workflow_async(yaml_file, return_state=True) -> WorkflowOutput:
+    dynamic_flow  = create_flow_based_on_config(yaml_file, run_async=True)
+    flow_run = await dynamic_flow(return_state=return_state)
+    return WorkflowOutput(**{'flow_run': flow_run, 'config': dynamic_flow}) 
+
+
+# BATCH
+
+@flow(name="Batch Workflow Runner - Sequential")
+async def batch_run_sequential(batch_config, batch_dir) -> List[WorkflowOutput]:
+    # batch_config = helpers.load_batch_config(batch_yaml_file)
+    # batch_dir = os.path.dirname(batch_yaml_file)
+    flows = []
+    for item in batch_config.items:
+        yaml_file_path = os.path.join(batch_dir, item.path)
+        output = await single_run_workflow_async(yaml_file_path, return_state = True)
+        flows.append(output)
+
+    return flows
+
+@flow(name="Batch Workflow Runner - Concurrent")
+async def batch_run_concurrent(batch_config, batch_dir) -> List[WorkflowOutput]:
+    """
+    Run multiple workflows concurrently within a single flow to avoid database conflicts.
+    Instead of creating separate flows, we'll execute the workflow logic directly as tasks.
+    """
+    from prefect import task
+    
+    @task
+    async def execute_workflow_tasks(yaml_file_path):
+        """Execute all tasks from a workflow config as a single unit"""
+        workflow_config = helpers.load_workflow_config(yaml_file_path)
+        logger = get_run_logger()
+        tasks = {}
+        
+        # Set flow parameters
+        for param in workflow_config.parameters:
+            runtime.flow_run.parameters[param.name] = param.value
+        
+        logger.info(f"Processing workflow: {workflow_config.name} from {yaml_file_path}")
+        
+        # Execute tasks sequentially within this task to avoid conflicts
+        for task_data in workflow_config.tasks:
+            task_name = task_data.name
+            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
+            if task_data.conditional:
+                condition_result = helpers.resolve_conditional(task_data, tasks)
+            
+            if condition_result:
+                # Resolve dependencies
+                if task_data.dependency:
+                    task_inputs = helpers.prepare_task_inputs_from_dep(task_data, task_inputs, tasks)
+                
+                # Execute the function directly instead of submitting as a separate task
+                try:
+                    # Handle default inputsArgType if not specified
+                    inputs_arg_type = getattr(task_data, 'inputsArgType', TaskInputsType.ARG)
+                    if inputs_arg_type == TaskInputsType.ARG:
+                        result = func(**task_inputs)
+                    else:  # TaskInputsType.DICT
+                        result = func(task_inputs)
+                    
+                    # Store result for dependencies
+                    class MockTaskResult:
+                        def __init__(self, value):
+                            self._value = value
+                        def result(self):
+                            return self._value
+                    
+                    tasks[task_data.name] = MockTaskResult(result)
+                    logger.info(f"Completed task: {task_name}")
+                
+                except Exception as e:
+                    logger.error(f"Task {task_name} failed: {str(e)}")
+                    raise
+        
+        return {"workflow_name": workflow_config.name, "tasks_completed": len(tasks)}
+    
+    # Submit all workflow executions as concurrent tasks
+    workflow_tasks = []
+    for item in batch_config.items:
+        yaml_file_path = os.path.join(batch_dir, item.path)
+        task_future = execute_workflow_tasks.submit(yaml_file_path)
+        workflow_tasks.append((task_future, yaml_file_path))
+    
+    # Wait for all tasks to complete
+    results = []
+    for task_future, yaml_path in workflow_tasks:
+        try:
+            result = task_future.result()  # .result() is synchronous, don't await it
+            # Create a mock WorkflowOutput for compatibility
+            workflow_output = WorkflowOutput(**{
+                'flow_run': result, 
+                'config': {'name': result['workflow_name'], 'path': yaml_path}
+            })
+            results.append(workflow_output)
+        except Exception as e:
+            logger = get_run_logger()
+            logger.error(f"Workflow {yaml_path} failed: {str(e)}")
+            raise
+    
+    return results
+
+
+@flow(name="Batch Workflow Runner - Concurrent (Original Flow Approach)")
+async def batch_run_concurrent_flows(batch_config, batch_dir) -> List[WorkflowOutput]:
+    """
+    Original approach: Run separate flows with staggered execution to reduce database contention.
+    This preserves the full Prefect flow semantics and task tracking.
+    Use this with PostgreSQL backend for better concurrent performance.
+    
+    Advantages:
+    - Full Prefect flow semantics and UI tracking
+    - Each YAML gets its own flow run with proper task hierarchy
+    - Task names can be the same across YAML files without conflicts
+    
+    Disadvantages:
+    - May cause database locking with SQLite
+    - More database writes due to separate flow runs
+    """
+    from prefect import task
+    
+    @task
+    async def run_flow_with_delay(yaml_file_path, delay_seconds=0):
+        if delay_seconds > 0:
+            await asyncio.sleep(delay_seconds)
+        
+        flow_function = create_flow_based_on_config(yaml_file_path, run_async=True)
+        result = await flow_function(return_state=True)
+        return WorkflowOutput(**{'flow_run': result, 'config': flow_function})
+    
+    # Submit flows with staggered delays to reduce database contention
+    workflow_tasks = []
+    for i, item in enumerate(batch_config.items):
+        yaml_file_path = os.path.join(batch_dir, item.path)
+        # Add small delay between flow starts (0, 2, 4, 6 seconds...)
+        delay = i * 2  
+        task_future = run_flow_with_delay.submit(yaml_file_path, delay)
+        workflow_tasks.append(task_future)
+    
+    # Wait for all flows to complete
+    results = []
+    for task_future in workflow_tasks:
+        result = task_future.result()
+        results.append(result)
+    
+    return results
+
+
+def batch_run_workflow(batch_yaml_file, use_single_flow=True):
+    """
+    Run batch workflows with two different approaches:
+    
+    Args:
+        batch_yaml_file: Path to the batch configuration YAML
+        use_single_flow: If True (default), uses single flow approach (better for SQLite)
+                        If False, uses separate flows with delays (better for PostgreSQL)
+    """
+    batch_config = helpers.load_batch_config(batch_yaml_file)
+    batch_dir = os.path.dirname(batch_yaml_file)
+
+    if batch_config.runner == TaskRunners.SEQUENTIAL:
+        return asyncio.run(batch_run_sequential(batch_config, batch_dir))
+    
+    if batch_config.runner == TaskRunners.CONCURRENT:
+        if use_single_flow:
+            # Single flow approach - better for SQLite, tasks scoped per YAML
+            return asyncio.run(batch_run_concurrent(batch_config, batch_dir))
+        else:
+            # Separate flows approach - better for PostgreSQL, full Prefect semantics
+            return asyncio.run(batch_run_concurrent_flows(batch_config, batch_dir))
+
+    raise ValueError('Invalid flow runner type')

{kubernetes_watch-0.1.5.dist-info → kubernetes_watch-0.1.9.dist-info}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 Benyamin Motevalli
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 Benyamin Motevalli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{kubernetes_watch-0.1.5.dist-info → kubernetes_watch-0.1.9.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: kubernetes-watch
-Version: 0.1.5
+Version: 0.1.9
 Summary: 
 Author: bmotevalli
 Author-email: b.motevalli@gmail.com
-Requires-Python: >=3.10,<4
+Requires-Python: >=3.10,<3.14
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -15,7 +15,9 @@ 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: prefect (>=3.4.17,<4.0.0)
+Requires-Dist: psycopg2 (>=2.9.10,<3.0.0)
+Requires-Dist: pydantic (>=2.11.7,<3.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Description-Content-Type: text/markdown
 

kubernetes_watch-0.1.9.dist-info/RECORD

@@ -0,0 +1,36 @@
+kube_watch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kube_watch/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kube_watch/enums/kube.py,sha256=rVKHMHAMkamsmmba7m4jhKlC131hIjZJW0U-G9MBiQE,89
+kube_watch/enums/logic.py,sha256=JRloXghE-gIUpZF7CT7TvYdxjYwc-KAGwTN0HDWPCA0,146
+kube_watch/enums/providers.py,sha256=wjiwmJe0Ph3My_HirKaK9k8VEPYjtxtlqEEY-wSdNUc,236
+kube_watch/enums/workflow.py,sha256=lobyV34tTS_xAgf6VnzaSIjE9DK0IZUKQyHZ2FPtPNg,328
+kube_watch/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kube_watch/models/common.py,sha256=FQktpX552zSCigMxEzm4S07SvrHv5RA7YwVJHgv7uuI,527
+kube_watch/models/workflow.py,sha256=ZFBMz_LmYgROcbz2amSvms38K770njnyZC6h1bpTXGU,1634
+kube_watch/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kube_watch/modules/clusters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kube_watch/modules/clusters/kube.py,sha256=_skDVeKIQcZ0nC9JLY0oaFmaeEVRHS-Xbrxh1HR2t9Y,7582
+kube_watch/modules/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kube_watch/modules/database/model.py,sha256=MWG9UW6g0KuBzW6MjzPBtknAk7GmuncQrdAq6HHarTo,207
+kube_watch/modules/database/postgre.py,sha256=1Sq2YFwgCJM_FWKabV2S1bFAIl2GBwytTtPCuLfVhu8,8182
+kube_watch/modules/logic/actions.py,sha256=hMvqqzR2EzcZ68_O8GdyLaPSLftA-tWAPaJnKdUMj-k,2416
+kube_watch/modules/logic/checks.py,sha256=2q4iNi3nOtGU_CMPIX_j3XY0krzE12fCZ_lAYifcJcA,150
+kube_watch/modules/logic/load.py,sha256=XC-SsWIChhW-QXJeCGMsLuLsn9v5nRni5Y6utwYLt48,781
+kube_watch/modules/logic/merge.py,sha256=sRKm4aTYfNFZnrXceGRWdGPDyoaMcTp6XhAkazckpPU,895
+kube_watch/modules/logic/scheduler.py,sha256=fwUfj4hnYX3yCj6fdZyLvlJE8RTBWHnHOwJPrpNJ8hw,3443
+kube_watch/modules/logic/trasnform.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kube_watch/modules/mock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kube_watch/modules/mock/mock_generator.py,sha256=BKKQFCxxQgFW_GFgeIbkyIbuNU4328xTTaFfTwFLsS8,1262
+kube_watch/modules/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kube_watch/modules/providers/aws.py,sha256=oly88Bihn-vR0NdOoCT-P1MNgPw8FLNfS1Ha4hc_4bc,8375
+kube_watch/modules/providers/git.py,sha256=BevjDv8czDJOJ9M1x8WYIRcXCxtZKow6ZQYiD6MCtGs,4104
+kube_watch/modules/providers/github.py,sha256=eQY8sLy2U6bOWMpFxA73DFCPVuswhTXSG25KmYSuo5s,5212
+kube_watch/modules/providers/vault.py,sha256=etzzHbTrUDsTUpeUN-xg0Xh8ulqC0-1FA3tHRZinIOo,7193
+kube_watch/standalone/metarecogen/ckan_to_gn.py,sha256=LWd7ikyxRIC1IGt6CtALnDOEoyuG07a8NoDHhgMkX4o,4635
+kube_watch/watch/__init__.py,sha256=9KE0Sf1nLUTNaFvXbiQCgf11vpG8Xgmb5ddeMAmak3Q,88
+kube_watch/watch/helpers.py,sha256=8BQnQ6AeLHs0JEq54iKYDvWURb1F-kROJxwIcl_nv_Y,6276
+kube_watch/watch/workflow.py,sha256=CaXHFuEWVsFjBv5dU4IfVMeTlGJWyKaE1But9-YzVWk,9769
+kubernetes_watch-0.1.9.dist-info/LICENSE,sha256=_H2QdL-2dXbivDmOpJ11DnqJewSFhSJwGpHx_WAE-CA,1075
+kubernetes_watch-0.1.9.dist-info/METADATA,sha256=isBj78h77s8CXFHssio69S4RgLmb_sU0_cfYQUfSO5I,5056
+kubernetes_watch-0.1.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+kubernetes_watch-0.1.9.dist-info/RECORD,,

kubernetes_watch-0.1.5.dist-info/RECORD

@@ -1,33 +0,0 @@
-kube_watch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kube_watch/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kube_watch/enums/kube.py,sha256=z6ceQwHV9-LB1bMitaMeX8kBXt2GCVdVDFAwc6DQffo,94
-kube_watch/enums/logic.py,sha256=Dzh24fZpYahIt0YWpXe1_4FIoJNlwwgYOCnwEAjo8Uk,154
-kube_watch/enums/providers.py,sha256=nMX-hXqhgLJMFmC5nmMy8Ajnr7tiya3B5NWn57EMcxk,248
-kube_watch/enums/workflow.py,sha256=W4EI98Kwh2Ptbzn4KgRMtTnulyKYxICRPgxo4g7wTjU,345
-kube_watch/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kube_watch/models/common.py,sha256=mECTcFVLEitlN38l8tqP-BI1kwYev3Jxq0kDSH5pE0o,543
-kube_watch/models/workflow.py,sha256=WE-ArxyaJfmze6gRvmwHYKQu7TpQBzxy88szqJO4Xxc,1694
-kube_watch/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kube_watch/modules/clusters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kube_watch/modules/clusters/kube.py,sha256=Fje6-vUA1KQ4x8T6cUYJT_eVwUYw-dR71h95ixSLqLM,7767
-kube_watch/modules/logic/actions.py,sha256=lt7OkSw6m2ZQe2SfENUsjZeD8vdpvfoE4laEkv9veEA,2471
-kube_watch/modules/logic/checks.py,sha256=CFIMVURKJP5Y3mByyJkFCrJBlVUjTG2XixiwoRquXN4,157
-kube_watch/modules/logic/load.py,sha256=8b5Y_iRTB6c7LY1-9wQjOrl_oW4JyVp5bjwh169frkU,804
-kube_watch/modules/logic/merge.py,sha256=vwc2TwcGU-vH5W0bFXzAzOMHt36ksdS4if1c4IbTeXs,926
-kube_watch/modules/logic/scheduler.py,sha256=-p5qh3FnEQ1jlkaY0Lrj9U-vau1b07NYAXBP6M09yoU,3517
-kube_watch/modules/logic/trasnform.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kube_watch/modules/mock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kube_watch/modules/mock/mock_generator.py,sha256=j8UfcJeA9giEEyqH9Sf3RGtlMfGO13NbWMZ80dj4UtE,1315
-kube_watch/modules/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kube_watch/modules/providers/aws.py,sha256=yvxVwL7seuvxpGR2ZCrmWEMKh9hesWdPTC6LvW7Bi9E,8585
-kube_watch/modules/providers/git.py,sha256=h3rcn1FhU82nF52Ol9YHyFk4cvPxxaz_AxHnip8OXPY,1183
-kube_watch/modules/providers/github.py,sha256=WCpZIKHr4U0a4El1leXkaCv1jznf9ob5xHVeTNSpNG0,5338
-kube_watch/modules/providers/vault.py,sha256=mPSjI5p1ycwXl6XFQNLohJ1rK_z_iT3QA9RJB1O3cpI,7381
-kube_watch/standalone/metarecogen/ckan_to_gn.py,sha256=FBiv6McWh4hqV6Bz08zGLzEIe4v1-D3FawjBKYbV7Ms,4767
-kube_watch/watch/__init__.py,sha256=6Ay9P_Ws7rP7ZaIrFRZtp_1uwVK4ZDmkkNhFyqPNQIU,61
-kube_watch/watch/helpers.py,sha256=T0xDSCfrW7NrmQzgIzOiojQzu_HesajMb7S_AX-tt98,6431
-kube_watch/watch/workflow.py,sha256=h0b_P_kfiPxqTFHZ6o2HkDkNaUBOwv1DKJnwEMMVXaI,4203
-kubernetes_watch-0.1.5.dist-info/LICENSE,sha256=StyinJRmy--Pc2vQbRToZSN4sjSVg3zccMFrktVcrEw,1096
-kubernetes_watch-0.1.5.dist-info/METADATA,sha256=GiDXVvgzxWV6zfK3VeEgqXTzRKSAKHan0Y4HML37Br0,4969
-kubernetes_watch-0.1.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-kubernetes_watch-0.1.5.dist-info/RECORD,,