matrice-compute 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

matrice_compute/scaling.py

@@ -3,26 +3,18 @@
 import os
 import logging
 from matrice_common.utils import log_errors
-from kafka import KafkaProducer, KafkaConsumer
-import uuid
-import json
-import time
-import base64
-import threading
-
-# TODO: update /scaling to /compute
 
 class Scaling:
 
     """Class providing scaling functionality for compute instances."""
 
-    def __init__(self, session, instance_id=None, enable_kafka=True):
+    def __init__(self, session, instance_id=None, enable_kafka=False):
         """Initialize Scaling instance.
 
         Args:
             session: Session object for making RPC calls
             instance_id: ID of the compute instance
-            enable_kafka: Enable Kafka communication (default True)
+            enable_kafka: Deprecated parameter, kept for backward compatibility (ignored)
 
         Raises:
             Exception: If instance_id is not provided
@@ -37,92 +29,10 @@ class Scaling:
         used_ports_str = os.environ.get("USED_PORTS", "")
         self.used_ports = set(int(p) for p in used_ports_str.split(",") if p.strip())
 
-        # Kafka configuration and initialization
-        self.enable_kafka = enable_kafka
-        self.kafka_producer = None
-        self.kafka_consumer = None
-        self.kafka_thread = None
-        self.kafka_running = False
-
-        # Maps correlation_id to threading.Event for request/response matching
-        self.pending_requests = {}
-        # Maps correlation_id to response data
-        self.response_map = {}
-        self.response_lock = threading.Lock()
-
-        if self.enable_kafka:
-            try:
-                self.kafka_config = {
-                    "bootstrap_servers": self.get_kafka_bootstrap_servers(),
-                    "action_request_topic": "action_requests",
-                    "action_response_topic": "action_responses",
-                    "compute_request_topic": "compute_requests",
-                    "compute_response_topic": "compute_responses"
-                }
-
-                # Initialize single producer
-                self.kafka_producer = KafkaProducer(
-                    bootstrap_servers=self.kafka_config["bootstrap_servers"],
-                    value_serializer=lambda v: json.dumps(v).encode("utf-8"),
-                    max_block_ms=5000  # Timeout if Kafka is down
-                )
-
-                # Initialize single consumer for both response topics
-                self.kafka_consumer = KafkaConsumer(
-                    self.kafka_config["action_response_topic"],
-                    self.kafka_config["compute_response_topic"],
-                    bootstrap_servers=self.kafka_config["bootstrap_servers"],
-                    group_id=f"py_compute_{instance_id}",
-                    value_deserializer=lambda m: json.loads(m.decode("utf-8")),
-                    auto_offset_reset='latest',
-                    enable_auto_commit=True,
-                    consumer_timeout_ms=1000,  # Poll timeout
-                    session_timeout_ms=60000,  # Increase session timeout to 60s (default 30s)
-                    heartbeat_interval_ms=3000,  # Send heartbeat every 3s
-                    max_poll_interval_ms=300000  # Max time between polls: 5 minutes
-                )
-
-                # Start background thread to handle responses
-                self.kafka_running = True
-                self.kafka_thread = threading.Thread(target=self._kafka_response_listener, daemon=True)
-                self.kafka_thread.start()
-
-                logging.info(f"Kafka enabled with bootstrap servers: {self.kafka_config['bootstrap_servers']}")
-            except Exception as e:
-                logging.warning(f"Failed to initialize Kafka, will use REST API only: {e}")
-                self.enable_kafka = False
-                self.kafka_producer = None
-                self.kafka_consumer = None
-
         logging.info(
-            "Initialized Scaling with instance_id: %s, Kafka enabled: %s",
-            instance_id,
-            self.enable_kafka
+            "Initialized Scaling with instance_id: %s (REST API only)",
+            instance_id
         )
-   
-
-
-    @log_errors(default_return=None, log_error=True)
-    def get_kafka_bootstrap_servers(self):
-        """Get Kafka bootstrap servers from API and decode base64 fields.
-
-        Returns:
-            str: Kafka bootstrap servers in format "ip:port"
-
-        Raises:
-            ValueError: If unable to fetch Kafka configuration
-        """
-        path = "/v1/actions/get_kafka_info"
-        response = self.rpc.get(path=path)
-        if not response or not response.get("success"):
-            raise ValueError(f"Failed to fetch Kafka config: {response.get('message', 'No response')}")
-        encoded_ip = response["data"]["ip"]
-        encoded_port = response["data"]["port"]
-        ip = base64.b64decode(encoded_ip).decode("utf-8")
-        port = base64.b64decode(encoded_port).decode("utf-8")
-        bootstrap_servers = f"{ip}:{port}"
-        # logging.info(f"Retrieved Kafka bootstrap servers: {bootstrap_servers}")
-        return bootstrap_servers
 
     @log_errors(default_return=(None, "Error processing response", "Response processing failed"), log_error=True)
     def handle_response(self, resp, success_message, error_message):
@@ -148,266 +58,52 @@ class Scaling:
             logging.error("%s: %s", message, error)
         return data, error, message
 
-    def _kafka_response_listener(self):
-        """
-        Background thread that continuously polls for Kafka responses.
-
-        This thread runs in the background and listens for responses from both
-        action_responses and compute_responses topics. When a response is received,
-        it matches the correlation ID to pending requests and wakes up the waiting thread.
-        """
-        logging.info("Kafka response listener thread started")
-
-        while self.kafka_running:
-            try:
-                # Poll for messages with 1 second timeout
-                message_batch = self.kafka_consumer.poll(timeout_ms=1000)
-
-                if message_batch:
-                    for topic_partition, messages in message_batch.items():
-                        for message in messages:
-                            try:
-                                msg = message.value
-                                correlation_id = msg.get("correlationId")
-
-                                if correlation_id:
-                                    with self.response_lock:
-                                        if correlation_id in self.pending_requests:
-                                            # Store response and signal waiting thread
-                                            self.response_map[correlation_id] = msg
-                                            self.pending_requests[correlation_id].set()
-                                            logging.debug(f"Received Kafka response for correlation_id: {correlation_id}")
-                                else:
-                                    logging.warning(f"Received Kafka message without correlationId: {msg}")
-                            except Exception as e:
-                                logging.error(f"Error processing Kafka message: {e}")
-
-            except Exception as e:
-                if self.kafka_running:  # Only log if not shutting down
-                    logging.error(f"Error in Kafka response listener: {e}")
-                    time.sleep(1)  # Avoid tight loop on persistent errors
-
-        logging.info("Kafka response listener thread stopped")
-
-    def _send_kafka_request(self, api, payload, request_topic, response_topic, timeout=5):
-        """
-        Send a request via Kafka and wait for response using the persistent consumer.
-
-        Args:
-            api: API name to call
-            payload: Request payload dictionary
-            request_topic: Kafka topic to send request to
-            response_topic: Kafka topic to receive response from (not used, kept for signature)
-            timeout: Timeout in seconds to wait for response
-
-        Returns:
-            Tuple of (data, error, message, kafka_success)
-            kafka_success is True if response received, False if timeout/error
-        """
-        if not self.enable_kafka or not self.kafka_producer:
-            return None, "Kafka not enabled", "Kafka not available", False
-
-        correlation_id = str(uuid.uuid4())
-        request_message = {
-            "correlationId": correlation_id,
-            "api": api,
-            "payload": payload,
-        }
-
-        # Create event for this request
-        event = threading.Event()
-
-        with self.response_lock:
-            self.pending_requests[correlation_id] = event
-
-        try:
-            # Add auth token if available
-            headers = None
-            if hasattr(self.session.rpc, 'AUTH_TOKEN'):
-                self.session.rpc.AUTH_TOKEN.set_bearer_token()
-                auth_token = self.session.rpc.AUTH_TOKEN.bearer_token
-                auth_token = auth_token.replace("Bearer ", "")
-                headers = [("Authorization", bytes(f"{auth_token}", "utf-8"))]
-
-            # Send request
-            self.kafka_producer.send(request_topic, request_message, headers=headers)
-            logging.info(f"Sent Kafka request for {api} with correlation_id: {correlation_id}")
-
-            # Wait for response with timeout
-            if event.wait(timeout=timeout):
-                # Response received
-                with self.response_lock:
-                    response = self.response_map.pop(correlation_id, None)
-                    self.pending_requests.pop(correlation_id, None)
-
-                if response:
-                    if response.get("status") == "success":
-                        data = response.get("data")
-                        logging.info(f"Kafka success for {api}")
-                        return data, None, f"Fetched via Kafka for {api}", True
-                    else:
-                        error = response.get("error", "Unknown error")
-                        logging.error(f"Kafka error response for {api}: {error}")
-                        return None, error, f"Kafka error response for {api}", True
-                else:
-                    logging.warning(f"Kafka response received but missing data for {api}")
-                    return None, "Response missing data", "Kafka response error", False
-            else:
-                # Timeout
-                with self.response_lock:
-                    self.pending_requests.pop(correlation_id, None)
-                logging.warning(f"Kafka response timeout for {api} after {timeout} seconds")
-                return None, "Kafka response timeout", "Kafka response timeout", False
-
-        except Exception as e:
-            # Cleanup on error
-            with self.response_lock:
-                self.pending_requests.pop(correlation_id, None)
-            logging.error(f"Kafka send error for {api}: {e}")
-            return None, f"Kafka error: {e}", "Kafka send failed", False
-
-    def _hybrid_request(self, api, payload, request_topic, response_topic, rest_fallback_func):
-        """
-        Hybrid request method: try Kafka first, fallback to REST, cache if both fail.
-
-        Args:
-            api: API name
-            payload: Request payload
-            request_topic: Kafka request topic
-            response_topic: Kafka response topic
-            rest_fallback_func: Function to call for REST fallback (should return same format as handle_response)
-
-        Returns:
-            Tuple of (data, error, message) matching the API response pattern
-        """
-        # Try Kafka first
-        if self.enable_kafka:
-            data, error, message, kafka_success = self._send_kafka_request(
-                api, payload, request_topic, response_topic, timeout=5
-            )
-
-            if kafka_success and error is None:
-                # Kafka succeeded
-                return data, error, message
-
-            # Kafka returned an error response (not transport error)
-            if kafka_success and error is not None:
-                logging.warning(f"Kafka returned error for {api}, falling back to REST")
-
-        # Kafka failed or disabled, try REST
-        logging.info(f"Using REST API for {api}")
-        try:
-            rest_response = rest_fallback_func()
-
-            # Return REST response (success or failure)
-            if rest_response and len(rest_response) == 3:
-                return rest_response
-            else:
-                # Unexpected REST response format
-                logging.error(f"REST API returned unexpected format for {api}")
-                return None, "Unexpected REST response format", "REST API error"
-
-        except Exception as e:
-            # REST failed
-            logging.error(f"REST API failed for {api}: {e}")
-            return None, str(e), "REST API failed"
-
-    def shutdown(self):
-        """Gracefully shutdown Kafka connections."""
-        if self.kafka_running:
-            logging.info("Shutting down Kafka connections...")
-            self.kafka_running = False
-
-            if self.kafka_thread:
-                self.kafka_thread.join(timeout=5)
-
-            if self.kafka_consumer:
-                self.kafka_consumer.close()
-
-            if self.kafka_producer:
-                self.kafka_producer.close()
-
-            logging.info("Kafka connections closed")
 
     @log_errors(log_error=True)
     def get_downscaled_ids(self):
-        """Get IDs of downscaled instances using Kafka (with REST fallback).
+        """Get IDs of downscaled instances using REST API.
 
         Returns:
             Tuple of (data, error, message) from API response
         """
         logging.info("Getting downscaled ids for instance %s", self.instance_id)
-
-        payload = {"instance_id": self.instance_id}
-
-        def rest_fallback():
-            path = f"/v1/compute/down_scaled_ids/{self.instance_id}"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "Downscaled ids info fetched successfully",
-                "Could not fetch the Downscaled ids info",
-            )
-
-        return self._hybrid_request(
-            api="get_downscaled_ids",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/compute/down_scaled_ids/{self.instance_id}"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "Downscaled ids info fetched successfully",
+            "Could not fetch the Downscaled ids info",
         )
 
     @log_errors(default_return=(None, "API call failed", "Failed to stop instance"), log_error=True)
     def stop_instance(self):
-        """Stop the compute instance using Kafka (with REST fallback).
+        """Stop the compute instance using REST API.
 
         Returns:
             Tuple of (data, error, message) from API response
         """
         logging.info("Stopping instance %s", self.instance_id)
-
         payload = {
             "_idInstance": self.instance_id,
             "isForcedStop": False,
         }
-
-        def rest_fallback():
-            path = "/v1/compute/compute_instance/stop"
-            resp = self.rpc.put(path=path, payload=payload)
-            return self.handle_response(
-                resp,
-                "Instance stopped successfully",
-                "Could not stop the instance",
-            )
-
-        return self._hybrid_request(
-            api="stop_instance",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = "/v1/compute/compute_instance/stop"
+        resp = self.rpc.put(path=path, payload=payload)
+        return self.handle_response(
+            resp,
+            "Instance stopped successfully",
+            "Could not stop the instance",
         )
     
     @log_errors(log_error=True)
     def update_jupyter_token(self, token=""):
-        """Update Jupyter notebook token using Kafka (with REST fallback)."""
-        payload = {"token": token, "instance_id": self.instance_id}
-
-        def rest_fallback():
-            path = f"/v1/scaling/update_jupyter_notebook_token/{self.instance_id}"
-            resp = self.rpc.put(path=path, payload={"token": token})
-            return self.handle_response(
-                resp,
-                "Resources updated successfully",
-                "Could not update the resources",
-            )
-
-        return self._hybrid_request(
-            api="update_jupyter_token",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        """Update Jupyter notebook token using REST API."""
+        path = f"/v1/scaling/update_jupyter_notebook_token/{self.instance_id}"
+        resp = self.rpc.put(path=path, payload={"token": token})
+        return self.handle_response(
+            resp,
+            "Resources updated successfully",
+            "Could not update the resources",
         )
 
     @log_errors(log_error=True)
@@ -426,7 +122,7 @@ class Scaling:
         createdAt=None,
         updatedAt=None,
     ):
-        """Update status of an action using Kafka (with REST fallback).
+        """Update status of an action using REST API.
 
         Args:
             service_provider: Provider of the service
@@ -466,21 +162,12 @@ class Scaling:
             "updatedAt": updatedAt,
         }
 
-        def rest_fallback():
-            path = "/v1/compute/update_action_status"
-            resp = self.rpc.put(path=path, payload=payload)
-            return self.handle_response(
-                resp,
-                "Action status details updated successfully",
-                "Could not update the action status details ",
-            )
-
-        return self._hybrid_request(
-            api="update_action_status",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = "/v1/compute/update_action_status"
+        resp = self.rpc.put(path=path, payload=payload)
+        return self.handle_response(
+            resp,
+            "Action status details updated successfully",
+            "Could not update the action status details ",
         )
 
     @log_errors(log_error=True)
@@ -493,7 +180,7 @@ class Scaling:
         status,
         status_description,
     ):
-        """Update status of an action using Kafka (with REST fallback).
+        """Update status of an action using REST API.
 
         Args:
             action_record_id: ID of the action record
@@ -514,78 +201,45 @@ class Scaling:
             "statusDescription": status_description,
         }
 
-        def rest_fallback():
-            url = "/v1/actions"
-            self.rpc.put(path=url, payload=payload)
-            return None, None, "Status updated"
-
-        return self._hybrid_request(
-            api="update_action",
-            payload=payload,
-            request_topic=self.kafka_config["action_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["action_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
-        )
+        url = "/v1/actions"
+        self.rpc.put(path=url, payload=payload)
+        return None, None, "Status updated"
 
     @log_errors(log_error=True)
     def get_shutdown_details(self):
-        """Get shutdown details for the instance using Kafka (with REST fallback).
+        """Get shutdown details for the instance using REST API.
 
         Returns:
             Tuple of (data, error, message) from API response
         """
         logging.info("Getting shutdown details for instance %s", self.instance_id)
-
-        payload = {"instance_id": self.instance_id}
-
-        def rest_fallback():
-            path = f"/v1/compute/get_shutdown_details/{self.instance_id}"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "Shutdown info fetched successfully",
-                "Could not fetch the shutdown details",
-            )
-
-        return self._hybrid_request(
-            api="get_shutdown_details",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/compute/get_shutdown_details/{self.instance_id}"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "Shutdown info fetched successfully",
+            "Could not fetch the shutdown details",
         )
 
     @log_errors(log_error=True)
     def get_tasks_details(self):
-        """Get task details for the instance using Kafka (with REST fallback).
+        """Get task details for the instance using REST API.
 
         Returns:
             Tuple of (data, error, message) from API response
         """
         logging.info("Getting tasks details for instance %s", self.instance_id)
-
-        payload = {"instance_id": self.instance_id}
-
-        def rest_fallback():
-            path = f"/v1/actions/fetch_instance_action_details/{self.instance_id}/action_details"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "Task details fetched successfully",
-                "Could not fetch the task details",
-            )
-
-        return self._hybrid_request(
-            api="get_tasks_details",
-            payload=payload,
-            request_topic=self.kafka_config["action_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["action_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/actions/fetch_instance_action_details/{self.instance_id}/action_details"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "Task details fetched successfully",
+            "Could not fetch the task details",
         )
 
     @log_errors(log_error=True)
     def get_action_details(self, action_status_id):
-        """Get details for a specific action using Kafka (with REST fallback).
+        """Get details for a specific action using REST API.
 
         Args:
             action_status_id: ID of the action status to fetch
@@ -594,24 +248,12 @@ class Scaling:
             Tuple of (data, error, message) from API response
         """
         logging.info("Getting action details for action %s", action_status_id)
-
-        payload = {"actionRecordId": action_status_id}
-
-        def rest_fallback():
-            path = f"/v1/actions/action/{action_status_id}/details"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "Task details fetched successfully",
-                "Could not fetch the task details",
-            )
-
-        return self._hybrid_request(
-            api="get_action_details",
-            payload=payload,
-            request_topic=self.kafka_config["action_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["action_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/actions/action/{action_status_id}/details"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "Task details fetched successfully",
+            "Could not fetch the task details",
         )
 
     @log_errors(log_error=True)
@@ -626,7 +268,7 @@ class Scaling:
         service="",
         job_params=None,
     ):
-        """Update an action using Kafka (with REST fallback).
+        """Update an action using REST API.
 
         Args:
             id: Action ID
@@ -657,27 +299,18 @@ class Scaling:
             "jobParams": job_params,
         }
 
-        def rest_fallback():
-            path = "/v1/actions"
-            resp = self.rpc.put(path=path, payload=payload)
-            return self.handle_response(
-                resp,
-                "Error logged successfully",
-                "Could not log the errors",
-            )
-
-        return self._hybrid_request(
-            api="update_action",
-            payload=payload,
-            request_topic=self.kafka_config["action_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["action_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = "/v1/actions"
+        resp = self.rpc.put(path=path, payload=payload)
+        return self.handle_response(
+            resp,
+            "Error logged successfully",
+            "Could not log the errors",
         )
            
 
     @log_errors(log_error=True)
     def assign_jobs(self, is_gpu):
-        """Assign jobs to the instance using Kafka (with REST fallback).
+        """Assign jobs to the instance using REST API.
 
         Args:
             is_gpu: Boolean or any value indicating if this is a GPU instance.
@@ -690,29 +323,14 @@ class Scaling:
         is_gpu_bool = bool(is_gpu)
         logging.info("Assigning jobs for instance %s (GPU: %s)", self.instance_id, is_gpu_bool)
 
-        payload = {
-            "instanceID": self.instance_id,
-            "isGPUInstance": is_gpu_bool,
-        }
-
-        # Define REST fallback function
-        def rest_fallback():
-            is_gpu_str = str(is_gpu_bool).lower()
-            path = f"/v1/actions/assign_jobs/{is_gpu_str}/{self.instance_id}"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "Pinged successfully",
-                "Could not ping the scaling jobs",
-            )
-
-        # Use hybrid approach: Kafka first, REST fallback, cache if both fail
-        return self._hybrid_request(
-            api="assign_jobs",
-            payload=payload,
-            request_topic=self.kafka_config["action_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["action_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        # Use REST API directly
+        is_gpu_str = str(is_gpu_bool).lower()
+        path = f"/v1/actions/assign_jobs/{is_gpu_str}/{self.instance_id}"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "Pinged successfully",
+            "Could not ping the scaling jobs",
         )
           
 
@@ -724,7 +342,7 @@ class Scaling:
         availableMemory=0,
         availableGPUMemory=0,
     ):
-        """Update available resources for the instance using Kafka (with REST fallback).
+        """Update available resources for the instance using REST API.
 
         Args:
             availableCPU: Available CPU resources
@@ -744,28 +362,17 @@ class Scaling:
             "availableGPU": availableGPU,
         }
 
-        # Define REST fallback function
-        def rest_fallback():
-            path = f"/v1/compute/update_available_resources/{self.instance_id}"
-            resp = self.rpc.put(path=path, payload=payload)
-            return self.handle_response(
-                resp,
-                "Resources updated successfully",
-                "Could not update the resources",
-            )
-
-        # Use hybrid approach: Kafka first, REST fallback, cache if both fail
-        return self._hybrid_request(
-            api="update_available_resources",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/compute/update_available_resources/{self.instance_id}"
+        resp = self.rpc.put(path=path, payload=payload)
+        return self.handle_response(
+            resp,
+            "Resources updated successfully",
+            "Could not update the resources",
         )
 
     @log_errors(log_error=True)
     def update_action_docker_logs(self, action_record_id, log_content):
-        """Update docker logs for an action using Kafka (with REST fallback).
+        """Update docker logs for an action using REST API.
 
         Args:
             action_record_id: ID of the action record
@@ -781,75 +388,43 @@ class Scaling:
             "logContent": log_content,
         }
 
-        def rest_fallback():
-            path = "/v1/actions/update_action_docker_logs"
-            resp = self.rpc.put(path=path, payload=payload)
-            return self.handle_response(
-                resp,
-                "Docker logs updated successfully",
-                "Could not update the docker logs",
-            )
-
-        return self._hybrid_request(
-            api="update_action_docker_logs",
-            payload=payload,
-            request_topic=self.kafka_config["action_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["action_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = "/v1/actions/update_action_docker_logs"
+        resp = self.rpc.put(path=path, payload=payload)
+        return self.handle_response(
+            resp,
+            "Docker logs updated successfully",
+            "Could not update the docker logs",
         )
 
     @log_errors(log_error=True)
     def get_docker_hub_credentials(self):
-        """Get Docker Hub credentials using Kafka (with REST fallback).
+        """Get Docker Hub credentials using REST API.
 
         Returns:
             Tuple of (data, error, message) from API response
         """
         logging.info("Getting docker credentials")
-
-        payload = {}
-
-        def rest_fallback():
-            path = "/v1/compute/get_docker_hub_credentials"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "Docker credentials fetched successfully",
-                "Could not fetch the docker credentials",
-            )
-
-        return self._hybrid_request(
-            api="get_docker_hub_credentials",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = "/v1/compute/get_docker_hub_credentials"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "Docker credentials fetched successfully",
+            "Could not fetch the docker credentials",
         )
 
     @log_errors(log_error=True)
     def get_open_ports_config(self):
-        """Get open ports configuration using Kafka (with REST fallback).
+        """Get open ports configuration using REST API.
 
         Returns:
             Tuple of (data, error, message) from API response
         """
-        payload = {"instance_id": self.instance_id}
-
-        def rest_fallback():
-            path = f"/v1/compute/get_open_ports/{self.instance_id}"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "Open ports config fetched successfully",
-                "Could not fetch the open ports config",
-            )
-
-        return self._hybrid_request(
-            api="get_open_ports_config",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/compute/get_open_ports/{self.instance_id}"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "Open ports config fetched successfully",
+            "Could not fetch the open ports config",
         )
 
     @log_errors(default_return=None, log_error=True)
@@ -900,7 +475,7 @@ class Scaling:
 
     @log_errors(log_error=True)
     def get_model_secret_keys(self, secret_name):
-        """Get model secret keys using Kafka (with REST fallback).
+        """Get model secret keys using REST API.
 
         Args:
             secret_name: Name of the secret
@@ -908,23 +483,12 @@ class Scaling:
         Returns:
             Tuple of (data, error, message) from API response
         """
-        payload = {"secret_name": secret_name}
-
-        def rest_fallback():
-            path = f"/v1/compute/get_models_secret_keys?secret_name={secret_name}"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "Secret keys fetched successfully",
-                "Could not fetch the secret keys",
-            )
-
-        return self._hybrid_request(
-            api="get_model_secret_keys",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/compute/get_models_secret_keys?secret_name={secret_name}"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "Secret keys fetched successfully",
+            "Could not fetch the secret keys",
         )
 
     @log_errors(log_error=True)
@@ -1025,7 +589,7 @@ class Scaling:
 
     @log_errors(log_error=True)
     def stop_account_compute(self, account_number, alias):
-        """Stop a compute instance for an account using Kafka (with REST fallback).
+        """Stop a compute instance for an account using REST API.
 
         Args:
             account_number: Account number
@@ -1035,32 +599,17 @@ class Scaling:
             Tuple of (data, error, message) from API response
         """
         logging.info("Stopping account compute for %s/%s", account_number, alias)
-
-        payload = {
-            "account_number": account_number,
-            "alias": alias,
-        }
-
-        def rest_fallback():
-            path = f"/v1/compute/stop_account_compute/{account_number}/{alias}"
-            resp = self.rpc.put(path=path)
-            return self.handle_response(
-                resp,
-                "Compute instance stopped successfully",
-                "Could not stop the compute instance",
-            )
-
-        return self._hybrid_request(
-            api="stop_account_compute",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/compute/stop_account_compute/{account_number}/{alias}"
+        resp = self.rpc.put(path=path)
+        return self.handle_response(
+            resp,
+            "Compute instance stopped successfully",
+            "Could not stop the compute instance",
         )
 
     @log_errors(log_error=True)
     def restart_account_compute(self, account_number, alias):
-        """Restart a compute instance for an account using Kafka (with REST fallback).
+        """Restart a compute instance for an account using REST API.
 
         Args:
             account_number: Account number
@@ -1070,27 +619,12 @@ class Scaling:
             Tuple of (data, error, message) from API response
         """
         logging.info("Restarting account compute for %s/%s", account_number, alias)
-
-        payload = {
-            "account_number": account_number,
-            "alias": alias,
-        }
-
-        def rest_fallback():
-            path = f"/v1/compute/restart_account_compute/{account_number}/{alias}"
-            resp = self.rpc.put(path=path)
-            return self.handle_response(
-                resp,
-                "Compute instance restarted successfully",
-                "Could not restart the compute instance",
-            )
-
-        return self._hybrid_request(
-            api="restart_account_compute",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/compute/restart_account_compute/{account_number}/{alias}"
+        resp = self.rpc.put(path=path)
+        return self.handle_response(
+            resp,
+            "Compute instance restarted successfully",
+            "Could not restart the compute instance",
         )
 
     @log_errors(log_error=True)
@@ -1114,59 +648,37 @@ class Scaling:
 
     @log_errors(log_error=True)
     def get_all_instances_type(self):
-        """Get all instance types using Kafka (with REST fallback).
+        """Get all instance types using REST API.
 
         Returns:
             Tuple of (data, error, message) from API response
         """
-        payload = {}
-
-        def rest_fallback():
-            path = "/v1/compute/get_all_instances_type"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "All instance types fetched successfully",
-                "Could not fetch the instance types",
-            )
-
-        return self._hybrid_request(
-            api="get_all_instances_type",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = "/v1/compute/get_all_instances_type"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "All instance types fetched successfully",
+            "Could not fetch the instance types",
         )
 
     @log_errors(log_error=True)
     def get_compute_details(self):
-        """Get compute instance details using Kafka (with REST fallback).
+        """Get compute instance details using REST API.
 
         Returns:
             Tuple of (data, error, message) from API response
         """
-        payload = {"instance_id": self.instance_id}
-
-        def rest_fallback():
-            path = f"/v1/scaling/get_compute_details/{self.instance_id}"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "Compute details fetched successfully",
-                "Could not fetch the compute details",
-            )
-
-        return self._hybrid_request(
-            api="get_compute_details",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/scaling/get_compute_details/{self.instance_id}"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "Compute details fetched successfully",
+            "Could not fetch the compute details",
         )
 
     @log_errors(log_error=True)
     def get_user_access_key_pair(self, user_id):
-        """Get user access key pair using Kafka (with REST fallback).
+        """Get user access key pair using REST API.
 
         Args:
             user_id: ID of the user
@@ -1174,28 +686,17 @@ class Scaling:
         Returns:
             Tuple of (data, error, message) from API response
         """
-        payload = {"user_id": user_id, "instance_id": self.instance_id}
-
-        def rest_fallback():
-            path = f"/v1/compute/get_user_access_key_pair/{user_id}/{self.instance_id}"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "User access key pair fetched successfully",
-                "Could not fetch the user access key pair",
-            )
-
-        return self._hybrid_request(
-            api="get_user_access_key_pair",
-            payload=payload,
-            request_topic=self.kafka_config["compute_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["compute_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/compute/get_user_access_key_pair/{user_id}/{self.instance_id}"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "User access key pair fetched successfully",
+            "Could not fetch the user access key pair",
         )
 
     @log_errors(log_error=True)
     def get_internal_api_key(self, action_id):
-        """Get internal API key using Kafka (with REST fallback).
+        """Get internal API key using REST API.
 
         Args:
             action_id: ID of the action
@@ -1203,22 +704,11 @@ class Scaling:
         Returns:
             Tuple of (data, error, message) from API response
         """
-        payload = {"action_id": action_id, "instance_id": self.instance_id}
-
-        def rest_fallback():
-            path = f"/v1/actions/get_internal_api_key/{action_id}/{self.instance_id}"
-            resp = self.rpc.get(path=path)
-            return self.handle_response(
-                resp,
-                "internal keys fetched successfully",
-                "Could not fetch internal keys",
-            )
-
-        return self._hybrid_request(
-            api="get_internal_api_key",
-            payload=payload,
-            request_topic=self.kafka_config["action_request_topic"] if self.enable_kafka else None,
-            response_topic=self.kafka_config["action_response_topic"] if self.enable_kafka else None,
-            rest_fallback_func=rest_fallback
+        path = f"/v1/actions/get_internal_api_key/{action_id}/{self.instance_id}"
+        resp = self.rpc.get(path=path)
+        return self.handle_response(
+            resp,
+            "internal keys fetched successfully",
+            "Could not fetch internal keys",
         )
 

{matrice_compute-0.1.21.dist-info → matrice_compute-0.1.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_compute
-Version: 0.1.21
+Version: 0.1.23
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_compute-0.1.21.dist-info → matrice_compute-0.1.23.dist-info}/RECORD

@@ -7,11 +7,11 @@ matrice_compute/instance_utils.py,sha256=tCI_A3L5iohw62acmlXuOJns0DjIkvwN4znlUAI
 matrice_compute/prechecks.py,sha256=W9YmNF3RcLhOf4U8WBlExvFqDw1aGWSNTlJtA73lbDQ,17196
 matrice_compute/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 matrice_compute/resources_tracker.py,sha256=pkdt0aVKx_TpY_Sq---73w9INkDffZZe3mZGlp1EftE,22573
-matrice_compute/scaling.py,sha256=RBqfhButiocWueu-OeUbo8KquYs3BpYi2GiksFM9H10,45998
+matrice_compute/scaling.py,sha256=CeT_lxJNkjJamRETG1lWaOtdSr5ySmcaMcqt7-lFRbo,23731
 matrice_compute/shutdown_manager.py,sha256=0MYV_AqygqR9NEntYf7atUC-PbWXyNkm1f-8c2aizgA,13234
 matrice_compute/task_utils.py,sha256=3qIutiQdYPyGRxH9ZwLbqdg8sZcnp6jp08pszWCRFl0,2820
-matrice_compute-0.1.21.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
-matrice_compute-0.1.21.dist-info/METADATA,sha256=_2gHnRw1cg9bwDjtSJ2_Dkb7XzTfrrQyvMWdFNB1RE8,1038
-matrice_compute-0.1.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice_compute-0.1.21.dist-info/top_level.txt,sha256=63Plr3L1GzBUWZO5JZaFkiv8IcB10xUPU-9w3i6ptvE,16
-matrice_compute-0.1.21.dist-info/RECORD,,
+matrice_compute-0.1.23.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
+matrice_compute-0.1.23.dist-info/METADATA,sha256=7FCjLIs4y-5IfN9P8FRdcSbIZhPbeOC8Cg9ZSCUWr6o,1038
+matrice_compute-0.1.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice_compute-0.1.23.dist-info/top_level.txt,sha256=63Plr3L1GzBUWZO5JZaFkiv8IcB10xUPU-9w3i6ptvE,16
+matrice_compute-0.1.23.dist-info/RECORD,,