flowcept 0.8.10__py3-none-any.whl → 0.8.12__py3-none-any.whl

flowcept/flowcept_api/flowcept_controller.py

@@ -1,6 +1,7 @@
 """Controller module."""
 
-from typing import List
+import os.path
+from typing import List, Dict
 from uuid import uuid4
 
 from flowcept.commons.daos.mq_dao.mq_dao_base import MQDao
@@ -9,7 +10,16 @@ from flowcept.commons.flowcept_dataclasses.workflow_object import (
 )
 from flowcept.commons.flowcept_logger import FlowceptLogger
 from flowcept.commons.utils import ClassProperty
-from flowcept.configs import MQ_INSTANCES, INSTRUMENTATION_ENABLED, MONGO_ENABLED, SETTINGS_PATH
+from flowcept.configs import (
+    MQ_INSTANCES,
+    INSTRUMENTATION_ENABLED,
+    MONGO_ENABLED,
+    SETTINGS_PATH,
+    LMDB_ENABLED,
+    KVDB_ENABLED,
+    MQ_ENABLED,
+    DUMP_BUFFER_PATH,
+)
 from flowcept.flowceptor.adapters.base_interceptor import BaseInterceptor
 
 
@@ -37,8 +47,9 @@ class Flowcept(object):
         campaign_id: str = None,
         workflow_id: str = None,
         workflow_name: str = None,
-        workflow_args: str = None,
+        workflow_args: Dict = None,
         start_persistence=True,
+        check_safe_stops=True,  # TODO add to docstring
         save_workflow=True,
         *args,
         **kwargs,
@@ -86,6 +97,8 @@ class Flowcept(object):
         self.logger.debug(f"Using settings file: {SETTINGS_PATH}")
         self._enable_persistence = start_persistence
         self._db_inserters: List = []
+        self.buffer = None
+        self._check_safe_stops = check_safe_stops
         if bundle_exec_id is None:
             self._bundle_exec_id = id(self)
         else:
@@ -140,9 +153,9 @@ class Flowcept(object):
                 Flowcept.current_workflow_id = self.current_workflow_id
 
                 interceptor_inst = BaseInterceptor.build(interceptor)
-                interceptor_inst.start(bundle_exec_id=self._bundle_exec_id)
+                interceptor_inst.start(bundle_exec_id=self._bundle_exec_id, check_safe_stops=self._check_safe_stops)
                 self._interceptor_instances.append(interceptor_inst)
-
+                self.buffer = interceptor_inst._mq_dao.buffer
                 if self._should_save_workflow and not self._workflow_saved:
                     self.save_workflow(interceptor, interceptor_inst)
 
@@ -152,6 +165,68 @@ class Flowcept(object):
         self.logger.debug("Flowcept started successfully.")
         return self
 
+    def _publish_buffer(self):
+        self._interceptor_instances[0]._mq_dao.bulk_publish(self.buffer)
+
+    @staticmethod
+    def read_messages_file(file_path: str = None) -> List[Dict]:
+        """
+        Read a JSON Lines (JSONL) file containing captured Flowcept messages.
+
+        This function loads a file where each line is a serialized JSON object.
+        It joins the lines into a single JSON array and parses them efficiently
+        with ``orjson``.
+
+        Parameters
+        ----------
+        file_path : str, optional
+            Path to the messages file. If not provided, defaults to the
+            value of ``DUMP_BUFFER_PATH`` from the configuration.
+            If neither is provided, an assertion error is raised.
+
+        Returns
+        -------
+        List[dict]
+            A list of message objects (dictionaries) parsed from the file.
+
+        Raises
+        ------
+        AssertionError
+            If no ``file_path`` is provided and ``DUMP_BUFFER_PATH`` is not set.
+        FileNotFoundError
+            If the specified file does not exist.
+        orjson.JSONDecodeError
+            If the file contents cannot be parsed as valid JSON.
+
+        Examples
+        --------
+        Read messages from a file explicitly:
+
+        >>> msgs = read_messages_file("offline_buffer.jsonl")
+        >>> print(len(msgs))
+        128
+
+        Use the default dump buffer path from config:
+
+        >>> msgs = read_messages_file()
+        >>> for m in msgs[:2]:
+        ...     print(m["type"], m.get("workflow_id"))
+        task_start wf_123
+        task_end wf_123
+        """
+        import orjson
+
+        _buffer = []
+        if file_path is None:
+            file_path = DUMP_BUFFER_PATH
+        assert file_path is not None, "Please indicate file_path either in the argument or in the config file."
+        if not os.path.exists(file_path):
+            raise f"File {file_path} has not been created. It will only be created if you run in fully offline mode."
+        with open(file_path, "rb") as f:
+            lines = [ln for ln in f.read().splitlines() if ln]
+        _buffer = orjson.loads(b"[" + b",".join(lines) + b"]")
+        return _buffer
+
     def save_workflow(self, interceptor: str, interceptor_instance: BaseInterceptor):
         """
         Save the current workflow and send its metadata using the provided interceptor.
@@ -190,19 +265,20 @@ class Flowcept(object):
             else:
                 raise Exception("You must provide the argument `dask_client` so we can correctly link the workflow.")
 
-        interceptor_instance._mq_dao.set_campaign_id(Flowcept.campaign_id)
+        if KVDB_ENABLED:
+            interceptor_instance._mq_dao.set_campaign_id(Flowcept.campaign_id)
         interceptor_instance.send_workflow_message(wf_obj)
         self._workflow_saved = True
 
     def _init_persistence(self, mq_host=None, mq_port=None):
+        if not LMDB_ENABLED and not MONGO_ENABLED:
+            return
+
         from flowcept.flowceptor.consumers.document_inserter import DocumentInserter
 
-        self._db_inserters.append(
-            DocumentInserter(
-                check_safe_stops=True,
-                bundle_exec_id=self._bundle_exec_id,
-            ).start()
-        )
+        doc_inserter = DocumentInserter(check_safe_stops=self._check_safe_stops, bundle_exec_id=self._bundle_exec_id)
+        doc_inserter.start()
+        self._db_inserters.append(doc_inserter)
 
     def stop(self):
         """Stop it."""
@@ -214,7 +290,7 @@ class Flowcept(object):
             for interceptor in self._interceptor_instances:
                 if interceptor is None:
                     continue
-                interceptor.stop()
+                interceptor.stop(check_safe_stops=self._check_safe_stops)
 
         if len(self._db_inserters):
             self.logger.info("Stopping DB Inserters...")
@@ -259,17 +335,25 @@ class Flowcept(object):
         ...     print("One or more services are not ready.")
         """
         logger = FlowceptLogger()
-        if not MQDao.build().liveness_test():
-            logger.error("MQ Not Ready!")
-            return False
+        mq = MQDao.build()
+        if MQ_ENABLED:
+            if not mq.liveness_test():
+                logger.error("MQ Not Ready!")
+                return False
+
+        if KVDB_ENABLED:
+            if not mq._keyvalue_dao.liveness_test():
+                logger.error("KVBD is enabled but is not ready!")
+                return False
 
+        logger.info("MQ is alive!")
         if MONGO_ENABLED:
             from flowcept.commons.daos.docdb_dao.mongodb_dao import MongoDBDAO
 
             if not MongoDBDAO(create_indices=False).liveness_test():
-                logger.error("DocDB Not Ready!")
+                logger.error("MongoDB is enabled but DocDB is not Ready!")
                 return False
-        logger.info("MQ and DocDB are alive!")
+            logger.info("DocDB is alive!")
         return True
 
     @staticmethod

flowcept/flowceptor/adapters/base_interceptor.py

@@ -9,14 +9,13 @@ from flowcept.commons.flowcept_dataclasses.workflow_object import (
 )
 from flowcept.configs import (
     ENRICH_MESSAGES,
+    TELEMETRY_ENABLED,
 )
 from flowcept.commons.flowcept_logger import FlowceptLogger
 from flowcept.commons.daos.mq_dao.mq_dao_base import MQDao
 from flowcept.commons.flowcept_dataclasses.task_object import TaskObject
 from flowcept.commons.settings_factory import get_settings
 
-from flowcept.flowceptor.telemetry_capture import TelemetryCapture
-
 
 # TODO :base-interceptor-refactor: :ml-refactor: :code-reorg: :usability:
 #  Consider creating a new concept for instrumentation-based 'interception'.
@@ -28,8 +27,6 @@ from flowcept.flowceptor.telemetry_capture import TelemetryCapture
 class BaseInterceptor(object):
     """Base interceptor class."""
 
-    # KINDS_TO_NOT_EXPLICITLY_CONTROL = {"dask"}
-
     @staticmethod
     def build(kind: str) -> "BaseInterceptor":
         """Build the Interceptor."""
@@ -42,6 +39,11 @@ class BaseInterceptor(object):
             from flowcept.flowceptor.adapters.tensorboard.tensorboard_interceptor import TensorboardInterceptor
 
             return TensorboardInterceptor()
+
+        elif kind == "broker_mqtt":
+            from flowcept.flowceptor.adapters.brokers.mqtt_interceptor import MQTTBrokerInterceptor
+
+            return MQTTBrokerInterceptor()
         elif kind == "dask_worker":
             from flowcept.flowceptor.adapters.dask.dask_interceptor import DaskWorkerInterceptor
 
@@ -71,7 +73,14 @@ class BaseInterceptor(object):
         self._bundle_exec_id = None
         self.started = False
         self._interceptor_instance_id = str(id(self))
-        self.telemetry_capture = TelemetryCapture()
+
+        if TELEMETRY_ENABLED:
+            from flowcept.flowceptor.telemetry_capture import TelemetryCapture
+
+            self.telemetry_capture = TelemetryCapture()
+        else:
+            self.telemetry_capture = None
+
         self._saved_workflows = set()
         self._generated_workflow_id = False
         self.kind = kind
@@ -80,17 +89,21 @@ class BaseInterceptor(object):
         """Prepare a task."""
         raise NotImplementedError()
 
-    def start(self, bundle_exec_id) -> "BaseInterceptor":
+    def start(self, bundle_exec_id, check_safe_stops: bool = True) -> "BaseInterceptor":
         """Start an interceptor."""
         if not self.started:
             self._bundle_exec_id = bundle_exec_id
-            self._mq_dao.init_buffer(self._interceptor_instance_id, bundle_exec_id)
+            self._mq_dao.init_buffer(self._interceptor_instance_id, bundle_exec_id, check_safe_stops)
             self.started = True
         return self
 
-    def stop(self):
+    def stop(self, check_safe_stops: bool = True):
         """Stop an interceptor."""
-        self._mq_dao.stop(self._interceptor_instance_id, self._bundle_exec_id)
+        self._mq_dao.stop(
+            interceptor_instance_id=self._interceptor_instance_id,
+            check_safe_stops=check_safe_stops,
+            bundle_exec_id=self._bundle_exec_id,
+        )
         self.started = False
 
     def observe(self, *args, **kwargs):
@@ -122,8 +135,8 @@ class BaseInterceptor(object):
             # TODO :base-interceptor-refactor: :code-reorg: :usability:
             raise Exception(f"This interceptor {id(self)} has never been started!")
         workflow_obj.interceptor_ids = [self._interceptor_instance_id]
-        machine_info = self.telemetry_capture.capture_machine_info()
-        if machine_info is not None:
+        if self.telemetry_capture:
+            machine_info = self.telemetry_capture.capture_machine_info()
             if workflow_obj.machine_info is None:
                 workflow_obj.machine_info = dict()
             # TODO :refactor-base-interceptor: we might want to register

flowcept/flowceptor/adapters/brokers/__init__.py

@@ -0,0 +1 @@
+"""Brokers' adapters subpackage."""

flowcept/flowceptor/adapters/brokers/mqtt_interceptor.py

@@ -0,0 +1,132 @@
+"""Zambeze interceptor module."""
+
+import uuid
+from threading import Thread
+from time import sleep
+import paho.mqtt.client as mqtt
+import json
+from typing import Dict
+from flowcept.commons.flowcept_dataclasses.task_object import TaskObject
+from flowcept.flowcept_api.flowcept_controller import Flowcept
+from flowcept.flowceptor.adapters.base_interceptor import (
+    BaseInterceptor,
+)
+
+
+class MQTTBrokerInterceptor(BaseInterceptor):
+    """Zambeze interceptor."""
+
+    def __init__(self, plugin_key="broker_mqtt"):
+        super().__init__(plugin_key)
+
+        assert self.settings.get("protocol") == "mqtt3.1.1", "We only support mqtt3.1.1 for this interceptor."
+        self._host = self.settings.get("host", "localhost")
+        self._port = self.settings.get("port", 1883)
+        self._username = self.settings.get("username", "username")
+        self._password = self.settings.get("password", None)
+        self._queues = self.settings.get("queues")
+        self._qos = self.settings.get("qos", 2)
+        self._id = str(id(self))
+
+        self._tracked_keys = self.settings.get("tracked_keys")
+        self._task_subtype = self.settings.get("task_subtype", None)
+        self._client: mqtt.Client = None
+
+        self._observer_thread: Thread = None
+
+    def _connect(self):
+        """Establish a connection to the MQTT broker."""
+        try:
+            self._client = mqtt.Client(client_id=self._id, clean_session=False, protocol=mqtt.MQTTv311)
+            self._client.username_pw_set(self._username, self._password)
+
+            self._client.on_message = self.callback
+            self._client.on_connect = self._on_connect
+            self._client.on_disconnect = self._on_disconnect
+
+            self.logger.debug("Connecting to MQTT broker...")
+            self._client.connect(self._host, self._port, 60)
+            self.logger.debug("Connected.")
+        except Exception as e:
+            self.logger.error(f"Connection failed: {e}")
+            raise e
+
+    def _on_connect(self, *_):
+        """Handle connection events and subscribe to the topic."""
+        for q in self._queues:
+            self.logger.debug(f"Client {self._id} connected to MQTT queue {q}. Waiting for messages...")
+            self._client.subscribe(q, qos=self._qos)
+
+    def callback(self, _, __, msg):
+        """Implement the callback."""
+        msg_str = msg.payload.decode()
+        topic = msg.topic
+        self.logger.debug(f"Received message: '{msg_str}' on topic '{topic}'")
+
+        msg_dict = json.loads(msg_str)
+        msg_dict["topic"] = topic
+
+        task_msg = self.prepare_task_msg(msg_dict)
+        self.intercept(task_msg.to_dict())
+
+    def _on_disconnect(self, *_):
+        """Handle disconnections and attempt reconnection."""
+        self.logger.warning("MQTT Observer Client Disconnected.")
+
+    def start(self, bundle_exec_id) -> "MQTTBrokerInterceptor":
+        """Start it."""
+        super().start(bundle_exec_id)
+        self._observer_thread = Thread(target=self.observe, daemon=True)
+        self._observer_thread.start()
+        return self
+
+    def observe(self):
+        """Start the MQTT loop."""
+        self._connect()
+        self._client.loop_forever()
+
+    def prepare_task_msg(self, msg: Dict) -> TaskObject:
+        """Prepare a task."""
+        task_dict = {}
+        custom_metadata = {"topic": msg.get("topic", None)}
+        for key in self._tracked_keys:
+            if key != "custom_metadata":
+                if self._tracked_keys.get(key):
+                    task_dict[key] = msg.get(self._tracked_keys.get(key), None)
+            else:
+                cm = self._tracked_keys.get("custom_metadata", None)
+                if cm and len(cm):
+                    for k in cm:
+                        custom_metadata[k] = msg[k]
+                    task_dict["custom_metadata"] = custom_metadata
+
+        if isinstance(task_dict.get("used"), str):
+            task_dict["used"] = {"payload": task_dict.get("used")}
+
+        if "task_id" not in task_dict:
+            task_dict["task_id"] = str(uuid.uuid4())
+
+        task_obj = TaskObject.from_dict(task_dict)
+        task_obj.subtype = self._task_subtype
+
+        if task_obj.campaign_id is None:
+            task_obj.campaign_id = Flowcept.campaign_id
+
+        if task_obj.workflow_id is None:
+            task_obj.workflow_id = Flowcept.current_workflow_id
+
+        print(task_obj)
+        return task_obj
+
+    def stop(self) -> bool:
+        """Stop it."""
+        self.logger.debug("Interceptor stopping...")
+        super().stop()
+        try:
+            self._client.disconnect()
+        except Exception as e:
+            self.logger.warning(f"This exception is expected to occur after channel.basic_cancel: {e}")
+        sleep(2)
+        self._observer_thread.join()
+        self.logger.debug("Interceptor stopped.")
+        return True

flowcept/flowceptor/adapters/mlflow/mlflow_interceptor.py

@@ -64,17 +64,17 @@ class MLFlowInterceptor(BaseInterceptor):
                 task_msg = self.prepare_task_msg(run_data).to_dict()
                 self.intercept(task_msg)
 
-    def start(self, bundle_exec_id) -> "MLFlowInterceptor":
+    def start(self, bundle_exec_id, check_safe_stops) -> "MLFlowInterceptor":
         """Start it."""
         super().start(bundle_exec_id)
         self._observer_thread = Thread(target=self.observe, daemon=True)
         self._observer_thread.start()
         return self
 
-    def stop(self) -> bool:
+    def stop(self, check_safe_stops: bool = True) -> bool:
         """Stop it."""
         sleep(1)
-        super().stop()
+        super().stop(check_safe_stops)
         self.logger.debug("Interceptor stopping...")
         self._observer.stop()
         self._observer_thread.join()

flowcept/flowceptor/adapters/tensorboard/tensorboard_interceptor.py

@@ -91,17 +91,17 @@ class TensorboardInterceptor(BaseInterceptor):
                 self.intercept(task_msg.to_dict())
                 self.state_manager.add_element_id(child_event.log_path)
 
-    def start(self, bundle_exec_id) -> "TensorboardInterceptor":
+    def start(self, bundle_exec_id, check_safe_stops: bool = True) -> "TensorboardInterceptor":
         """Start it."""
         super().start(bundle_exec_id)
         self.observe()
         return self
 
-    def stop(self) -> bool:
+    def stop(self, check_safe_stops: bool = True) -> bool:
         """Stop it."""
         sleep(1)
         self.logger.debug("Interceptor stopping...")
-        super().stop()
+        super().stop(check_safe_stops)
         self._observer.stop()
         self.logger.debug("Interceptor stopped.")
         return True

flowcept/flowceptor/consumers/agent/__init__.py

@@ -0,0 +1 @@
+"""Flowcept agent and Flowcept-enabled agent module."""

flowcept/flowceptor/consumers/agent/base_agent_context_manager.py

@@ -0,0 +1,125 @@
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Dict, List
+from uuid import uuid4
+
+from flowcept.flowcept_api.flowcept_controller import Flowcept
+from flowcept.flowceptor.consumers.base_consumer import BaseConsumer
+
+
+@dataclass
+class BaseAppContext:
+    """
+    Container for storing agent context data during the lifespan of an application session.
+
+    Attributes
+    ----------
+    tasks : list of dict
+        A list of task messages received from the message queue. Each task message is stored as a dictionary.
+    """
+
+    tasks: List[Dict]
+
+
+class BaseAgentContextManager(BaseConsumer):
+    """
+    Base class for any MCP Agent that wants to participate in the Flowcept ecosystem.
+
+    Agents inheriting from this class can:
+    - Subscribe to and consume messages from the Flowcept-compatible message queue (MQ)
+    - Handle task-related messages and accumulate them in context
+    - Gracefully manage their lifecycle using an async context manager
+    - Interact with Flowcept’s provenance system to read/write messages, query databases, and store chat history
+
+    To integrate with Flowcept:
+    - Inherit from `BaseAgentContextManager`
+    - Override `message_handler()` if custom message handling is needed
+    - Access shared state via `self.context` during execution
+    """
+
+    agent_id = None
+
+    def __init__(self):
+        """
+        Initializes the agent and resets its context state.
+        """
+        self._started = False
+        super().__init__()
+        self.context = None
+        self.reset_context()
+        self.agent_id = BaseAgentContextManager.agent_id
+
+    def message_handler(self, msg_obj: Dict) -> bool:
+        """
+        Handles a single message received from the message queue.
+
+        Parameters
+        ----------
+        msg_obj : dict
+            The message received, typically structured with a "type" field.
+
+        Returns
+        -------
+        bool
+            Return True to continue listening for messages, or False to stop the loop.
+
+        Notes
+        -----
+        This default implementation stores messages of type 'task' in the internal context.
+        Override this method in a subclass to handle other message types or implement custom logic.
+        """
+        msg_type = msg_obj.get("type", None)
+        msg_subtype = msg_obj.get("subtype", "")
+        if msg_type == "task":
+            self.logger.debug("Received task msg!")
+            if msg_subtype not in {"llm_query"}:
+                self.context.tasks.append(msg_obj)
+
+        return True
+
+    def reset_context(self):
+        """
+        Resets the internal context, clearing all stored task data.
+        """
+        self.context = BaseAppContext(tasks=[])
+
+    @asynccontextmanager
+    async def lifespan(self, app):
+        """
+        Async context manager to handle the agent’s lifecycle within an application.
+
+        Starts the message consumption when the context is entered and stops it when exited.
+
+        Parameters
+        ----------
+        app : Any
+            The application instance using this context (typically unused but included for compatibility).
+
+        Yields
+        ------
+        BaseAppContext
+            The current application context, including collected tasks.
+        """
+        if not self._started:
+            self.agent_id = BaseAgentContextManager.agent_id = str(uuid4())
+            self.logger.info(f"Starting lifespan for agent {BaseAgentContextManager.agent_id}.")
+            self._started = True
+
+            f = Flowcept(
+                start_persistence=False,
+                save_workflow=True,
+                check_safe_stops=False,
+                workflow_name="agent_workflow",
+                workflow_args={"agent_id": self.agent_id},
+            )
+            self.agent_workflow_id = f.current_workflow_id
+            f.start()
+            f.logger.info(
+                f"This section's workflow_id={Flowcept.current_workflow_id}, campaign_id={Flowcept.campaign_id}"
+            )
+            self.start()
+
+        try:
+            yield self.context
+        finally:
+            self.stop_consumption()

flowcept/flowceptor/consumers/base_consumer.py

@@ -0,0 +1,94 @@
+from abc import abstractmethod
+from threading import Thread
+from typing import Callable, Dict, Tuple, Optional
+
+from flowcept.commons.daos.mq_dao.mq_dao_base import MQDao
+from flowcept.commons.flowcept_logger import FlowceptLogger
+
+
+class BaseConsumer(object):
+    """
+    Abstract base class for message consumers in a pub-sub architecture.
+
+    This class provides a standard interface and shared logic for subscribing to
+    message queues and dispatching messages to a handler.
+    """
+
+    def __init__(self):
+        """Initialize the message queue DAO and logger."""
+        self._mq_dao = MQDao.build()
+        self.logger = FlowceptLogger()
+        self._main_thread: Optional[Thread] = None
+
+    @abstractmethod
+    def message_handler(self, msg_obj: Dict) -> bool:
+        """
+        Handle a single incoming message.
+
+        Parameters
+        ----------
+        msg_obj : dict
+            The parsed message object received from the queue.
+
+        Returns
+        -------
+        bool
+            Return False to break the message listener loop.
+            Return True to continue listening.
+        """
+        pass
+
+    def start(self, target: Callable = None, args: Tuple = (), threaded: bool = True, daemon=False):
+        """
+        Start the consumer by subscribing and launching the message handler.
+
+        Parameters
+        ----------
+        target : Callable
+            The function to run for listening to messages (usually the message loop).
+        args : tuple, optional
+            Arguments to pass to the target function.
+        threaded : bool, default=True
+            Whether to run the target function in a background thread.
+        daemon: bool
+
+        Returns
+        -------
+        BaseConsumer
+            The current instance (to allow chaining).
+        """
+        if target is None:
+            target = self.default_thread_target
+        self._mq_dao.subscribe()
+        if threaded:
+            self._main_thread = Thread(target=target, args=args, daemon=daemon)
+            self._main_thread.start()
+        else:
+            target(*args)
+        return self
+
+    def default_thread_target(self):
+        """
+        The default message consumption loop.
+
+        This method is used as the default thread target when starting the consumer. It listens for
+        messages from the message queue and passes them to the consumer's `message_handler`.
+
+        Typically run in a background thread when `start()` is called without a custom target.
+
+        See Also
+        --------
+        start : Starts the consumer and optionally spawns a background thread to run this method.
+        """
+        self.logger.debug("Going to wait for new messages!")
+        self._mq_dao.message_listener(self.message_handler)
+        self.logger.debug("Broke main message listening loop!")
+        # self._mq_dao.stop(check_safe_stops=False) # TODO Do we need to stop mq_dao here?
+        self.stop_consumption()
+        self.logger.debug("MQ stopped.")
+
+    def stop_consumption(self):
+        """
+        Stop consuming messages by unsubscribing from the message queue.
+        """
+        self._mq_dao.unsubscribe()