k8s-helper-cli 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

k8s_helper/__init__.py

@@ -20,7 +20,7 @@ from .utils import (
     create_service_manifest
 )
 
-__version__ = "0.4.2"
+__version__ = "0.5.0"
 __author__ = "Harshit Chatterjee"
 __email__ = "harshitchatterjee50@gmail.com"
 

k8s_helper/cli.py

@@ -1359,6 +1359,7 @@ def setup_monitoring(
     namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Namespace for monitoring stack"),
     grafana_service_type: str = typer.Option("NodePort", "--service-type", "-t", help="Grafana service type: NodePort, LoadBalancer, ClusterIP"),
     import_dashboard: bool = typer.Option(True, "--import-dashboard/--no-dashboard", help="Import default Kubernetes dashboard"),
+    install_kube_state_metrics: bool = typer.Option(True, "--install-kube-state-metrics/--no-kube-state-metrics", help="Install kube-state-metrics for cluster metrics"),
     wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for deployments to be ready"),
     show_info: bool = typer.Option(True, "--show-info/--no-show-info", help="Show monitoring stack information after setup")
 ):
@@ -1377,12 +1378,17 @@ def setup_monitoring(
     if import_dashboard:
         console.print("📊 Will import default Kubernetes dashboard")
     
+    if install_kube_state_metrics:
+        console.print("📈 Will install kube-state-metrics for cluster metrics")
+    
     # Show what will be deployed
     console.print("\n📋 Components to deploy:")
     console.print("   • Prometheus server with cluster monitoring configuration")
     console.print("   • Grafana with admin credentials (admin/admin123)")
     console.print("   • ServiceAccount and RBAC for Prometheus")
     console.print("   • ConfigMaps for Prometheus configuration")
+    if install_kube_state_metrics:
+        console.print("   • kube-state-metrics for cluster metrics (via Helm or manual)")
     if import_dashboard:
         console.print("   • Default Kubernetes metrics dashboard")
     
@@ -1394,12 +1400,21 @@ def setup_monitoring(
                 namespace=namespace,
                 grafana_service_type=grafana_service_type,
                 import_dashboard=import_dashboard,
-                wait_for_ready=wait
+                wait_for_ready=wait,
+                install_kube_state_metrics=install_kube_state_metrics
             )
         
         if result['success']:
             console.print("✅ Monitoring stack deployed successfully!")
             
+            # Show warning if Grafana configuration failed
+            if result.get('warning'):
+                console.print(f"⚠️  {result['warning']}")
+                console.print("💡 You can manually configure Grafana by:")
+                console.print("   1. Accessing Grafana with admin/admin123")
+                console.print("   2. Adding Prometheus as a data source")
+                console.print(f"   3. Use URL: http://prometheus-service.{result['namespace']}.svc.cluster.local:9090")
+            
             # Show deployment summary
             console.print(f"\n📋 Deployment Summary:")
             console.print(f"📍 Namespace: {result['namespace']}")
@@ -1412,9 +1427,31 @@ def setup_monitoring(
             if result['grafana']['deployed']:
                 console.print("✅ Grafana: Deployed")
                 console.print(f"🔑 Admin credentials: {result['grafana']['admin_user']}/{result['grafana']['admin_password']}")
+                
+                # Show Grafana configuration status
+                if result.get('grafana_configured', True):
+                    console.print("✅ Grafana: Automatically configured with Prometheus")
+                else:
+                    console.print("⚠️  Grafana: Manual configuration required")
             else:
                 console.print("❌ Grafana: Failed to deploy")
             
+            # Show kube-state-metrics status
+            if install_kube_state_metrics and 'kube_state_metrics' in result:
+                ksm = result['kube_state_metrics']
+                if ksm.get('installed'):
+                    method = ksm.get('method', 'unknown')
+                    if method == 'helm':
+                        console.print("✅ kube-state-metrics: Deployed via Helm")
+                    elif method == 'manual':
+                        console.print("✅ kube-state-metrics: Deployed via manual YAML")
+                    elif method == 'existing':
+                        console.print("✅ kube-state-metrics: Already deployed")
+                else:
+                    console.print(f"❌ kube-state-metrics: Failed to deploy")
+                    if ksm.get('error'):
+                        console.print(f"   Error: {ksm['error']}")
+            
             if show_info:
                 # Get and display monitoring information
                 with console.status("Retrieving monitoring stack information..."):

k8s_helper/core.py

@@ -1683,10 +1683,346 @@ class K8sClient:
     # ======================
     # MONITORING OPERATIONS
     # ======================
+    
+    def _check_helm_available(self) -> bool:
+        """Check if Helm is available in the system"""
+        import subprocess
+        try:
+            result = subprocess.run(['helm', 'version', '--short'], 
+                                  capture_output=True, text=True, timeout=10)
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            return False
+    
+    def _install_kube_state_metrics(self, namespace: str) -> Dict[str, Any]:
+        """Install kube-state-metrics using Helm if available, or manual YAML if not"""
+        import subprocess
+        
+        result = {
+            'installed': False,
+            'method': None,
+            'error': None
+        }
+        
+        # Check if kube-state-metrics is already running
+        try:
+            deployments = self.apps_v1.list_deployment_for_all_namespaces()
+            for deployment in deployments.items:
+                if 'kube-state-metrics' in deployment.metadata.name:
+                    print(f"✅ kube-state-metrics already deployed in namespace: {deployment.metadata.namespace}")
+                    result['installed'] = True
+                    result['method'] = 'existing'
+                    return result
+        except Exception as e:
+            print(f"⚠️  Warning: Could not check existing deployments: {e}")
+        
+        # Try Helm installation first
+        if self._check_helm_available():
+            try:
+                print("📦 Installing kube-state-metrics using Helm...")
+                
+                # Add prometheus-community repo if not exists
+                subprocess.run(['helm', 'repo', 'add', 'prometheus-community', 
+                              'https://prometheus-community.github.io/helm-charts'], 
+                              capture_output=True, text=True, timeout=30)
+                
+                # Update repo
+                subprocess.run(['helm', 'repo', 'update'], 
+                              capture_output=True, text=True, timeout=30)
+                
+                # Install kube-state-metrics
+                helm_cmd = [
+                    'helm', 'install', 'kube-state-metrics',
+                    'prometheus-community/kube-state-metrics',
+                    '--namespace', namespace,
+                    '--create-namespace',
+                    '--set', 'service.port=8080',
+                    '--set', 'service.targetPort=8080'
+                ]
+                
+                helm_result = subprocess.run(helm_cmd, capture_output=True, text=True, timeout=120)
+                
+                if helm_result.returncode == 0:
+                    print("✅ kube-state-metrics installed successfully via Helm")
+                    result['installed'] = True
+                    result['method'] = 'helm'
+                    return result
+                else:
+                    print(f"⚠️  Helm installation failed: {helm_result.stderr}")
+                    
+            except subprocess.TimeoutExpired:
+                print("⚠️  Helm installation timed out, falling back to manual installation")
+            except Exception as e:
+                print(f"⚠️  Helm installation failed: {e}, falling back to manual installation")
+        
+        # Fallback to manual YAML installation
+        try:
+            print("📦 Installing kube-state-metrics using manual YAML...")
+            
+            # Create ServiceAccount
+            service_account = client.V1ServiceAccount(
+                metadata=client.V1ObjectMeta(
+                    name="kube-state-metrics",
+                    namespace=namespace
+                )
+            )
+            
+            try:
+                self.core_v1.create_namespaced_service_account(namespace=namespace, body=service_account)
+                print("✅ Created ServiceAccount for kube-state-metrics")
+            except ApiException as e:
+                if e.status == 409:
+                    print("⚠️  ServiceAccount already exists")
+                else:
+                    raise e
+            
+            # Create ClusterRole
+            cluster_role = client.V1ClusterRole(
+                metadata=client.V1ObjectMeta(name="kube-state-metrics"),
+                rules=[
+                    client.V1PolicyRule(
+                        api_groups=[""],
+                        resources=["configmaps", "secrets", "nodes", "pods", "services", 
+                                 "resourcequotas", "replicationcontrollers", "limitranges", 
+                                 "persistentvolumeclaims", "persistentvolumes", "namespaces", "endpoints"],
+                        verbs=["list", "watch"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["apps"],
+                        resources=["statefulsets", "daemonsets", "deployments", "replicasets"],
+                        verbs=["list", "watch"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["batch"],
+                        resources=["cronjobs", "jobs"],
+                        verbs=["list", "watch"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["autoscaling"],
+                        resources=["horizontalpodautoscalers"],
+                        verbs=["list", "watch"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["authentication.k8s.io"],
+                        resources=["tokenreviews"],
+                        verbs=["create"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["authorization.k8s.io"],
+                        resources=["subjectaccessreviews"],
+                        verbs=["create"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["policy"],
+                        resources=["poddisruptionbudgets"],
+                        verbs=["list", "watch"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["certificates.k8s.io"],
+                        resources=["certificatesigningrequests"],
+                        verbs=["list", "watch"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["storage.k8s.io"],
+                        resources=["storageclasses", "volumeattachments"],
+                        verbs=["list", "watch"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["admissionregistration.k8s.io"],
+                        resources=["mutatingwebhookconfigurations", "validatingwebhookconfigurations"],
+                        verbs=["list", "watch"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["networking.k8s.io"],
+                        resources=["networkpolicies", "ingresses"],
+                        verbs=["list", "watch"]
+                    ),
+                    client.V1PolicyRule(
+                        api_groups=["coordination.k8s.io"],
+                        resources=["leases"],
+                        verbs=["list", "watch"]
+                    )
+                ]
+            )
+            
+            # Create ClusterRole
+            rbac_v1 = client.RbacAuthorizationV1Api()
+            try:
+                rbac_v1.create_cluster_role(body=cluster_role)
+                print("✅ Created ClusterRole for kube-state-metrics")
+            except ApiException as e:
+                if e.status == 409:
+                    print("⚠️  ClusterRole already exists")
+                else:
+                    raise e
+            
+            # Create ClusterRoleBinding
+            # Create subject with version compatibility
+            try:
+                # Try V1Subject first (older versions)
+                subject = client.V1Subject(
+                    kind="ServiceAccount",
+                    name="kube-state-metrics",
+                    namespace=namespace
+                )
+            except AttributeError:
+                # Try RbacV1Subject (newer versions)
+                try:
+                    subject = client.RbacV1Subject(
+                        kind="ServiceAccount",
+                        name="kube-state-metrics",
+                        namespace=namespace
+                    )
+                except AttributeError:
+                    # Manual construction as fallback
+                    subject = {
+                        'kind': 'ServiceAccount',
+                        'name': 'kube-state-metrics',
+                        'namespace': namespace
+                    }
+            
+            cluster_role_binding = client.V1ClusterRoleBinding(
+                metadata=client.V1ObjectMeta(name="kube-state-metrics"),
+                subjects=[subject],
+                role_ref=client.V1RoleRef(
+                    kind="ClusterRole",
+                    name="kube-state-metrics",
+                    api_group="rbac.authorization.k8s.io"
+                )
+            )
+            
+            try:
+                rbac_v1.create_cluster_role_binding(body=cluster_role_binding)
+                print("✅ Created ClusterRoleBinding for kube-state-metrics")
+            except ApiException as e:
+                if e.status == 409:
+                    print("⚠️  ClusterRoleBinding already exists")
+                else:
+                    raise e
+            
+            # Create Deployment
+            deployment = client.V1Deployment(
+                metadata=client.V1ObjectMeta(
+                    name="kube-state-metrics",
+                    namespace=namespace,
+                    labels={"app": "kube-state-metrics"}
+                ),
+                spec=client.V1DeploymentSpec(
+                    replicas=1,
+                    selector=client.V1LabelSelector(
+                        match_labels={"app": "kube-state-metrics"}
+                    ),
+                    template=client.V1PodTemplateSpec(
+                        metadata=client.V1ObjectMeta(
+                            labels={"app": "kube-state-metrics"}
+                        ),
+                        spec=client.V1PodSpec(
+                            service_account_name="kube-state-metrics",
+                            containers=[
+                                client.V1Container(
+                                    name="kube-state-metrics",
+                                    image="registry.k8s.io/kube-state-metrics/kube-state-metrics:v2.10.1",
+                                    ports=[
+                                        client.V1ContainerPort(
+                                            name="http-metrics",
+                                            container_port=8080,
+                                            protocol="TCP"
+                                        ),
+                                        client.V1ContainerPort(
+                                            name="telemetry",
+                                            container_port=8081,
+                                            protocol="TCP"
+                                        )
+                                    ],
+                                    liveness_probe=client.V1Probe(
+                                        http_get=client.V1HTTPGetAction(
+                                            path="/healthz",
+                                            port=8080
+                                        ),
+                                        initial_delay_seconds=5,
+                                        timeout_seconds=5
+                                    ),
+                                    readiness_probe=client.V1Probe(
+                                        http_get=client.V1HTTPGetAction(
+                                            path="/",
+                                            port=8081
+                                        ),
+                                        initial_delay_seconds=5,
+                                        timeout_seconds=5
+                                    ),
+                                    security_context=client.V1SecurityContext(
+                                        allow_privilege_escalation=False,
+                                        read_only_root_filesystem=True,
+                                        run_as_non_root=True,
+                                        run_as_user=65534
+                                    )
+                                )
+                            ]
+                        )
+                    )
+                )
+            )
+            
+            try:
+                self.apps_v1.create_namespaced_deployment(namespace=namespace, body=deployment)
+                print("✅ Created Deployment for kube-state-metrics")
+            except ApiException as e:
+                if e.status == 409:
+                    print("⚠️  Deployment already exists")
+                else:
+                    raise e
+            
+            # Create Service
+            service = client.V1Service(
+                metadata=client.V1ObjectMeta(
+                    name="kube-state-metrics",
+                    namespace=namespace,
+                    labels={"app": "kube-state-metrics"}
+                ),
+                spec=client.V1ServiceSpec(
+                    selector={"app": "kube-state-metrics"},
+                    ports=[
+                        client.V1ServicePort(
+                            name="http-metrics",
+                            port=8080,
+                            target_port=8080,
+                            protocol="TCP"
+                        ),
+                        client.V1ServicePort(
+                            name="telemetry",
+                            port=8081,
+                            target_port=8081,
+                            protocol="TCP"
+                        )
+                    ],
+                    type="ClusterIP"
+                )
+            )
+            
+            try:
+                self.core_v1.create_namespaced_service(namespace=namespace, body=service)
+                print("✅ Created Service for kube-state-metrics")
+            except ApiException as e:
+                if e.status == 409:
+                    print("⚠️  Service already exists")
+                else:
+                    raise e
+            
+            result['installed'] = True
+            result['method'] = 'manual'
+            print("✅ kube-state-metrics installed successfully via manual YAML")
+            
+        except Exception as e:
+            result['error'] = str(e)
+            print(f"❌ Failed to install kube-state-metrics: {e}")
+        
+        return result
+    
     def setup_monitoring(self, namespace: str = "monitoring", 
                         grafana_service_type: str = "NodePort",
                         import_dashboard: bool = True,
-                        wait_for_ready: bool = True) -> Dict[str, Any]:
+                        wait_for_ready: bool = True,
+                        install_kube_state_metrics: bool = True) -> Dict[str, Any]:
         """Setup complete monitoring stack with Prometheus and Grafana
         
         Args:
@@ -1694,6 +2030,7 @@ class K8sClient:
             grafana_service_type: Service type for Grafana (NodePort, LoadBalancer, ClusterIP)
             import_dashboard: Whether to import default Kubernetes dashboard
             wait_for_ready: Whether to wait for deployments to be ready
+            install_kube_state_metrics: Whether to install kube-state-metrics for cluster metrics
             
         Returns:
             Dictionary with deployment info, URLs, and credentials
@@ -1702,6 +2039,7 @@ class K8sClient:
             'namespace': namespace,
             'prometheus': {},
             'grafana': {},
+            'kube_state_metrics': {},
             'success': False,
             'error': None
         }
@@ -1710,6 +2048,12 @@ class K8sClient:
             # Create monitoring namespace
             self._create_monitoring_namespace(namespace)
             
+            # Install kube-state-metrics if requested
+            if install_kube_state_metrics:
+                print("📊 Installing kube-state-metrics for cluster metrics...")
+                ksm_result = self._install_kube_state_metrics(namespace)
+                result['kube_state_metrics'] = ksm_result
+            
             # Deploy Prometheus
             prometheus_result = self._deploy_prometheus(namespace)
             result['prometheus'] = prometheus_result
@@ -1724,8 +2068,11 @@ class K8sClient:
                     # Configure Grafana data source and dashboard
                     if self._configure_grafana(namespace, import_dashboard):
                         result['success'] = True
+                        result['grafana_configured'] = True
                     else:
-                        result['error'] = "Failed to configure Grafana"
+                        result['success'] = True  # Still successful even if config fails
+                        result['grafana_configured'] = False
+                        result['warning'] = "Grafana deployed but automatic configuration failed"
                 else:
                     result['error'] = "Monitoring deployments failed to become ready"
             else:
@@ -1759,7 +2106,7 @@ class K8sClient:
         """Deploy Prometheus to the cluster"""
         result = {'deployed': False, 'service_name': 'prometheus-service'}
         
-        # Prometheus ConfigMap
+        # Prometheus ConfigMap with kube-state-metrics support
         prometheus_config = """
 global:
   scrape_interval: 15s
@@ -1787,6 +2134,29 @@ scrape_configs:
     - action: labelmap
       regex: __meta_kubernetes_node_label_(.+)
 
+  - job_name: 'kubernetes-cadvisor'
+    kubernetes_sd_configs:
+    - role: node
+    scheme: https
+    tls_config:
+      ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
+    bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
+    relabel_configs:
+    - action: labelmap
+      regex: __meta_kubernetes_node_label_(.+)
+    - target_label: __address__
+      replacement: kubernetes.default.svc:443
+    - source_labels: [__meta_kubernetes_node_name]
+      regex: (.+)
+      target_label: __metrics_path__
+      replacement: /api/v1/nodes/$1/proxy/metrics/cadvisor
+
+  - job_name: 'kube-state-metrics'
+    static_configs:
+    - targets: ['kube-state-metrics.{}:8080']
+    metrics_path: /metrics
+    scrape_interval: 30s
+
   - job_name: 'kubernetes-pods'
     kubernetes_sd_configs:
     - role: pod
@@ -1811,7 +2181,36 @@ scrape_configs:
     - source_labels: [__meta_kubernetes_pod_name]
       action: replace
       target_label: kubernetes_pod_name
-"""
+
+  - job_name: 'kubernetes-service-endpoints'
+    kubernetes_sd_configs:
+    - role: endpoints
+    relabel_configs:
+    - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scrape]
+      action: keep
+      regex: true
+    - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scheme]
+      action: replace
+      target_label: __scheme__
+      regex: (https?)
+    - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_path]
+      action: replace
+      target_label: __metrics_path__
+      regex: (.+)
+    - source_labels: [__address__, __meta_kubernetes_service_annotation_prometheus_io_port]
+      action: replace
+      target_label: __address__
+      regex: ([^:]+)(?::\\d+)?;(\\d+)
+      replacement: $1:$2
+    - action: labelmap
+      regex: __meta_kubernetes_service_label_(.+)
+    - source_labels: [__meta_kubernetes_namespace]
+      action: replace
+      target_label: kubernetes_namespace
+    - source_labels: [__meta_kubernetes_service_name]
+      action: replace
+      target_label: kubernetes_name
+""".format(namespace)
         
         # Create ConfigMap
         configmap = client.V1ConfigMap(
@@ -2124,9 +2523,6 @@ scrape_configs:
     def _configure_grafana(self, namespace: str, import_dashboard: bool = True) -> bool:
         """Configure Grafana with Prometheus data source and dashboard"""
         try:
-            # Wait a bit for Grafana to fully start
-            time.sleep(10)
-            
             import requests
             import json
             
@@ -2138,6 +2534,32 @@ scrape_configs:
             
             print(f"🔧 Configuring Grafana at {grafana_url}")
             
+            # Wait for Grafana to be accessible with retry logic
+            max_retries = 12  # 2 minutes total (12 * 10 seconds)
+            retry_count = 0
+            auth = ('admin', 'admin123')
+            
+            while retry_count < max_retries:
+                try:
+                    # Test connection to Grafana
+                    health_response = requests.get(
+                        f"{grafana_url}/api/health",
+                        auth=auth,
+                        timeout=10
+                    )
+                    if health_response.status_code == 200:
+                        print("✅ Grafana is accessible")
+                        break
+                except Exception as e:
+                    retry_count += 1
+                    if retry_count < max_retries:
+                        print(f"⏳ Waiting for Grafana to be accessible... (attempt {retry_count}/{max_retries})")
+                        time.sleep(10)
+                    else:
+                        print(f"❌ Grafana not accessible after {max_retries} attempts")
+                        print("💡 You can manually add Prometheus as a data source in Grafana")
+                        return False
+            
             # Add Prometheus data source
             datasource_payload = {
                 "name": "Prometheus",
@@ -2147,20 +2569,27 @@ scrape_configs:
                 "isDefault": True
             }
             
-            auth = ('admin', 'admin123')
-            
-            # Add data source
-            response = requests.post(
-                f"{grafana_url}/api/datasources",
-                json=datasource_payload,
-                auth=auth,
-                timeout=30
-            )
-            
-            if response.status_code in [200, 409]:  # Success or already exists
-                print("✅ Prometheus data source configured")
-            else:
-                print(f"⚠️  Warning: Could not add Prometheus data source: {response.text}")
+            # Try to add data source with retry
+            for attempt in range(3):
+                try:
+                    response = requests.post(
+                        f"{grafana_url}/api/datasources",
+                        json=datasource_payload,
+                        auth=auth,
+                        timeout=30
+                    )
+                    
+                    if response.status_code in [200, 409]:  # Success or already exists
+                        print("✅ Prometheus data source configured")
+                        break
+                    else:
+                        print(f"⚠️  Attempt {attempt + 1}: Could not add Prometheus data source: {response.text}")
+                        if attempt < 2:
+                            time.sleep(5)
+                except Exception as e:
+                    print(f"⚠️  Attempt {attempt + 1}: Error adding data source: {e}")
+                    if attempt < 2:
+                        time.sleep(5)
             
             # Import default dashboard if requested
             if import_dashboard:

{k8s_helper_cli-0.4.2.dist-info → k8s_helper_cli-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: k8s-helper-cli
-Version: 0.4.2
+Version: 0.5.0
 Summary: A simplified Python wrapper for common Kubernetes operations
 Author-email: Harshit Chatterjee <harshitchatterjee50@gmail.com>
 License-Expression: MIT

k8s_helper_cli-0.5.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+k8s_helper/__init__.py,sha256=wtG9p8ZbOO4WDPZxf3acQ_pNu4x92MJBnwI9l8G7LCc,2666
+k8s_helper/cli.py,sha256=dBqPBfSNoh3NAFq5qiyERD0uV6Entf-rEwpuBhuYHGk,81655
+k8s_helper/config.py,sha256=P7YdfyvCHprrNs2J9DRb3RrClylfTTh5hfTtDzLug0A,6867
+k8s_helper/core.py,sha256=rf4dwcrV9fTyRZrWTucslOHJDTKhlnMXKqV_OWTIYQ8,130172
+k8s_helper/utils.py,sha256=wYgTd5ktyuI-EiVcfW7FrxA7MzXY5odrEKQgmMVdueY,9496
+k8s_helper_cli-0.5.0.dist-info/licenses/LICENSE,sha256=tXPvVl3gLVc6e0qCEoLH9KjeA7z4JVL78UybpvGtBCw,1096
+k8s_helper_cli-0.5.0.dist-info/METADATA,sha256=dHNcGQ7c-7KH9Z98yj4DFcXphLjDtQtoAt0cYaxEsSc,30789
+k8s_helper_cli-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+k8s_helper_cli-0.5.0.dist-info/entry_points.txt,sha256=IoCMWUZ6mn90LwzQzEy5YkWOwvogDdZ6ycqUWAzCFTQ,50
+k8s_helper_cli-0.5.0.dist-info/top_level.txt,sha256=x9A1jflyer-z2cFnkqk5B42juoH2q0fy5hkT9upsTG8,11
+k8s_helper_cli-0.5.0.dist-info/RECORD,,

k8s_helper_cli-0.4.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-k8s_helper/__init__.py,sha256=YuM-ES4NKCK-M1VusIhUSIsO8vigHDWGPyAS6bvShgw,2666
-k8s_helper/cli.py,sha256=ngXnZ-6EaTm9hCViLPOLZya4HtFDsqpPbLYnOBEfQmA,79400
-k8s_helper/config.py,sha256=P7YdfyvCHprrNs2J9DRb3RrClylfTTh5hfTtDzLug0A,6867
-k8s_helper/core.py,sha256=HCsDx8xApBvgDooR3XqaW2ZeIzQU35oGm6rfjTBzYVc,110654
-k8s_helper/utils.py,sha256=wYgTd5ktyuI-EiVcfW7FrxA7MzXY5odrEKQgmMVdueY,9496
-k8s_helper_cli-0.4.2.dist-info/licenses/LICENSE,sha256=tXPvVl3gLVc6e0qCEoLH9KjeA7z4JVL78UybpvGtBCw,1096
-k8s_helper_cli-0.4.2.dist-info/METADATA,sha256=p6tE1EFVcCIGx5vwv-L-EDB-K5VRbOtAXcc5z2K5dXM,30789
-k8s_helper_cli-0.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-k8s_helper_cli-0.4.2.dist-info/entry_points.txt,sha256=IoCMWUZ6mn90LwzQzEy5YkWOwvogDdZ6ycqUWAzCFTQ,50
-k8s_helper_cli-0.4.2.dist-info/top_level.txt,sha256=x9A1jflyer-z2cFnkqk5B42juoH2q0fy5hkT9upsTG8,11
-k8s_helper_cli-0.4.2.dist-info/RECORD,,