corva-worker-python 2.0.0__py3-none-any.whl

worker/app/modules/activity_module.py

@@ -0,0 +1,141 @@
+from itertools import groupby
+
+from worker import constants
+from worker.app.modules.__init__ import Module
+from worker.data import operations
+from worker.data.operations import get_config_by_id
+
+
+class ActivityModule(Module):
+    """
+    This is an abstract base module that needs to be extended by an actual module.
+    """
+
+    # module_key is used for redis access and state of this module
+    module_key = "activity_module"
+    collection = "activity_module_collection"
+
+    # override
+    def run(self, wits_stream: list):
+        """
+        :param wits_stream: a wits stream event
+        :return:
+        """
+        super().run(wits_stream)
+
+        dataset = self.load_dataset(wits_stream)
+
+        # this guarantees every group has the same config
+        config_grouped_dataset = self.group_data_stream_based_on_config(dataset)
+
+        for group in config_grouped_dataset:
+            results = self.check_for_string_change(group)
+
+            if self.should_run_processor(group):
+                results = self.run_module(group, results)
+
+            self.save_state()
+            self.store_output(self.global_state["asset_id"], results)
+
+    @staticmethod
+    def group_data_stream_based_on_config(dataset):
+        """Group our datasets by the metadata such as drillstring, and then reflatten to be a list of lists
+        for processing"""
+
+        groups = groupby(dataset, lambda x: x["metadata"])
+        grouped_dataset = [list(dataset) for group, dataset in groups]
+
+        return grouped_dataset
+
+    # override
+    def should_run_processor(self, event):
+        running_string = constants.get("{}.{}.running-string".format(self.app_key, self.module_key))
+        if running_string and self.state.get("active_string_type", "") in running_string:
+            return True
+
+        return False
+
+    def check_for_string_change(self, data):
+        """
+        To check if the active string in the wellbore has been changed and
+        export proper text to the output.
+        Note that the last_exported_timestamp is not set here.
+        Note that all the configs of this data have the same config properties.
+        :param data:
+        :return:
+        """
+
+        previous_string = self.state.get("active_string_id", "")
+        running_string = constants.get("{}.{}.running-string".format(self.app_key, self.module_key))
+        reset_config = constants.get("{}.{}.reset-config".format(self.app_key, self.module_key))
+
+        if not running_string:
+            return []
+
+        if not data:
+            return []
+
+        first_wits = data[0]
+        drillstring_id = first_wits.get("metadata", {}).get("drillstring", None)
+        casing_id = first_wits.get("metadata", {}).get("casing", None)
+
+        if drillstring_id:
+            active_string_type = "drillstring"
+            active_string_id = drillstring_id
+        elif casing_id:
+            active_string_type = "casing"
+            active_string_id = casing_id
+        else:
+            active_string_type = None
+            active_string_id = None
+
+        if previous_string == active_string_id:
+            return []
+
+        main_structure = self.build_empty_output(first_wits)
+
+        warning = None
+
+        if active_string_type in running_string:
+            if active_string_type not in reset_config:
+                return []
+        else:
+            message = "This module does not run while {} is the active string in the well.".format(active_string_type)
+            warning = {"message": message}
+
+        res = self.configure_output_at_config_change(main_structure, active_string_type, active_string_id, warning)
+
+        return [res]
+
+    def configure_output_at_config_change(self, main_structure, active_string_type, active_string_id, warning=None):
+        extra_elements = self.create_output_for_new_config(active_string_type, active_string_id)
+        main_structure["data"] = operations.merge_dicts(main_structure["data"], extra_elements)
+
+        if warning:
+            main_structure["data"] = operations.merge_dicts(main_structure["data"], {"warning": warning})
+
+        return main_structure
+
+    def create_output_for_new_config(self, active_string_type, active_string_id):
+        self.set_state("active_string_type", active_string_type)
+        self.set_state("active_string_id", active_string_id)
+
+        drillstring_number = None
+        if active_string_type == "drillstring":
+            drillstring = get_config_by_id(active_string_id, collection="data.drillstring")
+
+            if drillstring:
+                drillstring_number = drillstring.get("data", {}).get("id", None)
+
+        self.set_state("drillstring_number", drillstring_number)
+
+        return self.get_config_properties()
+
+    def get_config_properties(self):
+        properties = {
+            "active_string_type": self.state.get("active_string_type", ""),
+            "active_string_id": self.state.get("active_string_id", ""),
+            "drillstring_number": self.state.get("drillstring_number", None),
+        }
+
+        return properties

worker/app/modules/connection_module.py

@@ -0,0 +1,21 @@
+from worker.app.modules.activity_module import ActivityModule
+
+
+class ConnectionModule(ActivityModule):
+    """
+    This is an abstract module that needs to be extended by actual modules.
+    An example of this module would be running an app after a connection occur.
+    """
+
+    module_key = "connection_module"
+    collection = "connection_collection"
+
+    # override
+    def process_module_state(self, state):
+        state = super().process_module_state(state)
+
+        if self.global_state.get("reset", False):
+            # todo
+            pass
+
+        return state

worker/app/modules/depth_activity_module.py

@@ -0,0 +1,21 @@
+from worker.app.modules.activity_module import ActivityModule
+
+
+class DepthActivityModule(ActivityModule):
+    """
+    This is an abstract module that needs to be extended by actual modules.
+    An example of this module would be running an app every 1 ft.
+    """
+
+    module_key = "depth_activity_module"
+    collection = "depth_activity_collection"
+
+    # override
+    def process_module_state(self, state):
+        state = super().process_module_state(state)
+
+        if self.global_state.get("reset", False):
+            # todo
+            pass
+
+        return state

worker/app/modules/scheduler.py

@@ -0,0 +1,44 @@
+from worker import constants
+from worker.app.modules.__init__ import Module
+
+
+class Scheduler(Module):
+    """
+    This is an abstract module that needs to be extended by actual modules.
+    An example of this module would be running an app at the frequency of
+    once every X seconds regardless of the activity.
+    """
+
+    module_key = "scheduler_module"
+    collection = "scheduler_collection"
+    module_state_fields = {"last_processed_timestamp": int}
+
+    # override
+    def run(self, wits_stream: list):
+        super().run(wits_stream)
+
+        dataset = self.load_dataset(wits_stream)
+
+        results = []
+        for el in dataset:
+            if self.should_run_processor(el):
+                results = self.run_module(el, results)
+
+        self.save_state()
+        self.store_output(self.global_state["asset_id"], results)
+
+    # override
+    def should_run_processor(self, event: dict):
+        """
+        check one wits event and test against the last processed timestamp
+        :param event:
+        :return:
+        """
+        timestamp = event.get("timestamp", 0)
+        running_frequency = constants.get("{}.{}.running_frequency".format(self.app_key, self.module_key))
+        if self.state.get("last_processed_timestamp", 0) + running_frequency <= timestamp:
+            # update the last_processed_timestamp
+            self.set_state("last_processed_timestamp", timestamp)
+            return True
+
+        return False

worker/app/modules/time_activity_module.py

@@ -0,0 +1,21 @@
+from worker.app.modules.activity_module import ActivityModule
+
+
+class TimeActivityModule(ActivityModule):
+    """
+    This is an abstract time-base module that needs to be extended by actual modules.
+    An example of this module would be running an app every 1 minute.
+    """
+
+    module_key = "time_activity_module"
+    collection = "time_activity_collection"
+
+    # override
+    def process_module_state(self, state):
+        state = super().process_module_state(state)
+
+        if self.global_state.get("reset", False):
+            # todo
+            pass
+
+        return state

worker/app/modules/trigger.py

@@ -0,0 +1,43 @@
+from worker import constants
+from worker.app.modules.__init__ import Module
+
+
+class Trigger(Module):
+    """
+    This is an abstract module that needs to be extended by actual modules.
+    The idea behind this module is that it runs once for a bunch of data
+    only if the the time step is passed.
+    """
+
+    module_key = "trigger_module"
+    collection = "trigger_collection"
+    module_state_fields = {"last_processed_timestamp": int}
+
+    # override
+    def run(self, wits_stream: list):
+        super().run(wits_stream)
+
+        dataset = self.load_dataset(wits_stream)
+        last_wits = dataset[-1]
+        results = []
+        if self.should_run_processor(last_wits):
+            results = self.run_module(last_wits, results)
+
+        self.save_state()
+        self.store_output(self.global_state["asset_id"], results)
+
+    # override
+    def should_run_processor(self, event: dict):
+        """
+        check one wits event and test against the last processed timestamp
+        :param event:
+        :return:
+        """
+        timestamp = event.get("timestamp", 0)
+        running_frequency = constants.get("{}.{}.running_frequency".format(self.app_key, self.module_key))
+        if self.state.get("last_processed_timestamp", 0) + running_frequency < timestamp:
+            # update the last_processed_timestamp
+            self.set_state("last_processed_timestamp", timestamp)
+            return True
+
+        return False

worker/constants.py

@@ -0,0 +1,51 @@
+"""
+this constants module can be overridden by your new constants module by importing
+the this module and updating it like this:
+    from worker import constants
+    constants.update({
+        ...
+    })
+"""
+
+from worker.data.operations import get_data_by_path
+
+parameters = {
+    "global": {
+        "app-name": "my-app",
+        "app-key": "my-app-key",
+        "event-type": "scheduler",
+        "query-limit": 1000,
+    },
+}
+
+
+def get(path, default=None):
+    """
+    Get the value at the specified path in the parameters dictionary.
+
+    Args:
+        path (str): The path to the value to retrieve.
+        default (Any, optional): The default value to return if the path
+            is not found. Defaults to None.
+
+    Returns:
+        Any: The value at the specified path, or the default value
+            if the path is not found.
+    """
+    return get_data_by_path(data=parameters, path=path, default=default)
+
+
+def update(additional_parameters):
+    """
+    The purpose of this method is to update the existing parameters data
+    with the provided additional parameters. Note that the globals will
+    be replaced if the additional parameters contains global node.
+    :param additional_parameters:
+    :return:
+    """
+    _globals = parameters.pop("global")
+    additional_globals = additional_parameters.pop("global", {})
+    _globals.update(additional_globals)
+    parameters.update(additional_parameters)
+    if _globals:
+        parameters["global"] = _globals

worker/data/activity/__init__.py

@@ -0,0 +1,132 @@
+from enum import Enum
+
+from worker.data.serialization import serialization
+
+
+class PipeMovementStatus(Enum):
+    UNCLASSIFIED = -1
+    IN_SLIPS = 0
+    STATIC = 1
+    ON_BOTTOM = 2
+    PULL_OUT_OF_HOLE = 3
+    RUN_IN_HOLE = 4
+    DRILLING = 5
+
+    def is_moving_out(self) -> bool:
+        move_actions = [
+            PipeMovementStatus.PULL_OUT_OF_HOLE,
+        ]
+        return self in move_actions
+
+    def is_moving_in(self) -> bool:
+        move_actions = [PipeMovementStatus.RUN_IN_HOLE, PipeMovementStatus.DRILLING]
+        return self in move_actions
+
+    def is_moving(self) -> bool:
+        return self.is_moving_in() or self.is_moving_out()
+
+
+class PumpStatus(Enum):
+    OFF = 0
+    ON = 1
+
+
+class RotationStatus(Enum):
+    OFF = 0
+    ON = 1
+
+
+@serialization
+class Activity(bytes, Enum):
+    ROTARY_DRILLING = ("Rotary Drilling", PipeMovementStatus.DRILLING, PumpStatus.ON, RotationStatus.ON)
+    SLIDE_DRILLING = ("Slide Drilling", PipeMovementStatus.DRILLING, PumpStatus.ON, RotationStatus.OFF)
+
+    RUN_IN_HOLE = ("Run in Hole", PipeMovementStatus.RUN_IN_HOLE, PumpStatus.OFF, RotationStatus.OFF)
+    WASHING_DOWN = ("Washing Down", PipeMovementStatus.RUN_IN_HOLE, PumpStatus.ON, RotationStatus.OFF)
+    DRY_REAMING_DOWN = ("Dry Reaming Down", PipeMovementStatus.RUN_IN_HOLE, PumpStatus.OFF, RotationStatus.ON)
+    REAMING_DOWN = ("Reaming Down", PipeMovementStatus.RUN_IN_HOLE, PumpStatus.ON, RotationStatus.ON)
+
+    PULL_OUT_OF_HOLE = ("Pull out of Hole", PipeMovementStatus.PULL_OUT_OF_HOLE, PumpStatus.OFF, RotationStatus.OFF)
+    WASHING_UP = ("Washing Up", PipeMovementStatus.PULL_OUT_OF_HOLE, PumpStatus.ON, RotationStatus.OFF)
+    DRY_REAMING_UP = ("Dry Reaming Up", PipeMovementStatus.PULL_OUT_OF_HOLE, PumpStatus.OFF, RotationStatus.ON)
+    REAMING_UP = ("Reaming Up", PipeMovementStatus.PULL_OUT_OF_HOLE, PumpStatus.ON, RotationStatus.ON)
+
+    STATIC_OFF_BOTTOM = ("Static Off Bottom", PipeMovementStatus.STATIC, PumpStatus.OFF, RotationStatus.OFF)
+    CIRCULATING = ("Circulating", PipeMovementStatus.STATIC, PumpStatus.ON, RotationStatus.OFF)
+    DRY_ROTARY_OFF_BOTTOM = ("Dry Rotary Off Bottom", PipeMovementStatus.STATIC, PumpStatus.OFF, RotationStatus.ON)
+    ROTARY_OFF_BOTTOM = ("Rotary Off Bottom", PipeMovementStatus.STATIC, PumpStatus.ON, RotationStatus.ON)
+
+    STATIC_ON_BOTTOM = ("Static On Bottom", PipeMovementStatus.ON_BOTTOM, PumpStatus.OFF, RotationStatus.OFF)
+    CIRCULATING_ON_BOTTOM = ("Circulating On Bottom", PipeMovementStatus.ON_BOTTOM, PumpStatus.ON, RotationStatus.OFF)
+    DRY_ROTARY_ON_BOTTOM = ("Dry Rotary On Bottom", PipeMovementStatus.ON_BOTTOM, PumpStatus.OFF, RotationStatus.ON)
+    CIRCULATING_AND_ROTARY_ON_BOTTOM = (
+        "Circ. & Rot. On Bottom",
+        PipeMovementStatus.ON_BOTTOM,
+        PumpStatus.ON,
+        RotationStatus.ON,
+    )
+
+    IN_SLIPS = ("In Slips", PipeMovementStatus.IN_SLIPS, PumpStatus.OFF, RotationStatus.OFF)
+
+    UNCLASSIFIED = ("Unclassified", PipeMovementStatus.DRILLING, PumpStatus.OFF, RotationStatus.OFF)
+
+    def __new__(cls, activity_name: str, pipe_movement_status, pump_status, rotation_status):
+        obj = bytes.__new__(cls)
+
+        obj._value_ = activity_name  # using the activity name as the main value
+        obj.pipe_movement_status = pipe_movement_status
+        obj.pump_status = pump_status
+        obj.rotation_status = rotation_status
+
+        return obj
+
+    def is_pipe_moving(self) -> bool:
+        return self.pipe_movement_status.is_moving()
+
+    def is_pipe_moving_out(self) -> bool:
+        return self.pipe_movement_status.is_moving_out()
+
+    def is_pipe_moving_in(self) -> bool:
+        return self.pipe_movement_status.is_moving_in()
+
+    def is_pumping(self) -> bool:
+        return self.pump_status == PumpStatus.ON
+
+    def is_rotating(self) -> bool:
+        return self.rotation_status == RotationStatus.ON
+
+    def is_drilling(self) -> bool:
+        return self.pipe_movement_status == PipeMovementStatus.DRILLING
+
+    def is_reaming(self) -> bool:
+        """
+        Pipe moves up and down with rotation
+        :return:
+        """
+        movement_status = self.pipe_movement_status in [
+            PipeMovementStatus.PULL_OUT_OF_HOLE,
+            PipeMovementStatus.RUN_IN_HOLE,
+        ]
+        rotation_status = self.rotation_status == RotationStatus.ON
+        return movement_status and rotation_status
+
+    def is_tripping(self) -> bool:
+        """
+        Pipe moves up and down
+        :return:
+        """
+        if self == self.RUN_IN_HOLE or self == self.PULL_OUT_OF_HOLE:
+            return True
+        return False
+
+    def __eq__(self, other):
+        return self is other
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def __str__(self):
+        return self.value