genie-python 15.1.0rc1__py3-none-any.whl

genie_python/genie_experimental_data.py

@@ -0,0 +1,186 @@
+"""
+Genie Database Access module.
+"""
+
+from typing import TypedDict
+
+from genie_python.mysql_abstraction_layer import SQLAbstraction
+
+SELECT_FOR_EXP_DETAILS = """
+SELECT e.experimentID, u.name as userName, r.name as roleName,"""
+""" t.startDate, e.duration FROM `experimentteams` t
+JOIN experiment e ON e.experimentID = t.experimentID
+JOIN user u ON u.userID = t.userID
+JOIN role r ON r.roleID = t.roleID
+"""
+
+
+class GetExperimentData:
+    """
+    Class for storing the get_exp_data RB lookup command and related utility methods.
+    """
+
+    def __init__(self, instrument: str) -> None:
+        self.instrument = instrument
+        self._sql = SQLAbstraction(
+            dbid="exp_data", user="report", password="$report", host=self.instrument
+        )
+
+    def get_sql(self) -> SQLAbstraction:
+        """
+        Get the one and only SQL abstraction layer.
+
+        Returns:
+             The SQL abstraction layer
+        """
+        return self._sql
+
+    def _parameter_is_valid(self, value: bool | int | float | str, column: str, table: str) -> bool:
+        """
+        Checks whether the given value exists in the table.
+
+        Args:
+            value: the value to search for
+            column: the column to search in
+            table: the table to search in
+
+        Returns:
+            True if value was found, False otherwise
+
+        """
+        result = self.get_sql().query(
+            command=f"SELECT * FROM `{table}` WHERE {column} = %s", bound_variables=(value,)
+        )
+
+        return True if result else False
+
+    class _GetExpDataReturn(TypedDict):
+        rb_number: int | str
+        user: str
+        role: str
+        start_date: str
+        duration: float
+
+    def get_exp_data(
+        self, rb: int | str = "%", user: str = "%", role: str = "%", verbose: bool = False
+    ) -> list[_GetExpDataReturn]:
+        """
+        Returns the data of experiments that match the given criteria,
+        or all if none is given, from the exp_data
+        database. If verbose is enabled, only pretty-print the data.
+
+        Args:
+            rb (int, optional): The RB number of the experiment to look for, Defaults to Any.
+            user (str, optional): The name of the user who is running/has
+                run the experiment, Defaults to Any.
+            role (str, optional): The user role, Defaults to Any.
+            verbose (bool, optional): Pretty-print the data, Defaults to False.
+
+        Returns:
+            exp_data (list): The experiment(s) data as a list of dicts.
+
+        Raises:
+            NotFoundError: Thrown if a parameter's value was not found in the database.
+
+        """
+        self._validate_parameters(rb, user, role)
+
+        args, sql = self._create_sql_statement_and_args(rb, role, user)
+
+        exp_data = self._query_database_for_data(args, sql)
+
+        if verbose:
+            if exp_data:
+                self._pretty_print(exp_data)
+            else:
+                raise NotFoundError(
+                    f'Found no experiments that match the given criteria '
+                    f'(RB: {rb if rb != "%" else "Any"}, '
+                    f'User: {user if user != "%" else "Any"}, '
+                    f'Role: {role if role != "%" else "Any"}).\n'
+                )
+
+        return exp_data
+
+    def _validate_parameters(self, rb: int | str, user: str, role: str) -> None:
+        if rb != "%" and not self._parameter_is_valid(rb, "experimentID", "experimentteams"):
+            raise NotFoundError(f"Found no experiments with RB number {rb}.")
+        if user != "%" and not self._parameter_is_valid(user, "name", "user"):
+            raise NotFoundError(
+                f'User with name "{user}" was not found. Please make sure the title and name are '
+                f'correct (e.g. "Dr John Smith").'
+            )
+        if role != "%" and not self._parameter_is_valid(role, "name", "role"):
+            roles = ", ".join(
+                [x[0] for x in self.get_sql().query_returning_cursor("SELECT name FROM `role`", ())]
+            )
+            raise NotFoundError(f'Role "{role}" was not found. Existing roles: {roles}')
+
+    def _query_database_for_data(
+        self, args: bool | int | float | str, sql: str
+    ) -> list[_GetExpDataReturn]:
+        exp_data = []
+        for exp_id, user, role, start_date, duration in self.get_sql().query_returning_cursor(
+            sql, args
+        ):
+            start_date = start_date.strftime("%Y-%m-%d %H:%M:%S")
+            experiment_details = {
+                "rb_number": exp_id,
+                "user": user,
+                "role": role,
+                "start_date": start_date,
+                "duration": duration,
+            }
+            exp_data.append(experiment_details)
+        return exp_data
+
+    @staticmethod
+    def _create_sql_statement_and_args(
+        rb: int | str, user: str, role: str
+    ) -> tuple[bool | int | float | str, str]:
+        """
+        Prepare the statement and bound variables
+
+        Args:
+            rb: rb number of the experiment
+            role: role being searched for
+            user: user being searched for
+
+        Returns:
+            args: the bound variables
+            sql: the SQL command
+        """
+        sql = SELECT_FOR_EXP_DETAILS + " WHERE "
+        where_clauses = [
+            "e.experimentID = %s" if rb != "%" else "e.experimentID LIKE '%'",
+            "upper(u.name) = upper(%s)" if user != "%" else "u.name LIKE '%'",
+            "upper(r.name) = upper(%s)" if role != "%" else "r.name LIKE '%'",
+        ]
+        args = [x for x in [rb, user, role] if x != "%"]
+        sql += " AND ".join(where_clauses) + " ORDER BY experimentID DESC"
+        return args, sql
+
+    @staticmethod
+    def _pretty_print(exp_data: list[_GetExpDataReturn]) -> None:
+        # For pretty printing
+        rb_padding = max(len(x) for x in [y["rb_number"] for y in exp_data])
+        user_padding = max(len(x) for x in [y["user"] for y in exp_data])
+        role_padding = max(len(x) for x in [y["role"] for y in exp_data])
+
+        for exp in exp_data:
+            print(
+                f'Experiment RB number: {exp["rb_number"]:{rb_padding}} | '
+                f'User: {exp["user"]:{user_padding}} | '
+                f'Role: {exp["role"]:{role_padding}} | '
+                f'Start date: {exp["start_date"]} | '
+                f'Duration: {exp["duration"]}'
+            )
+
+
+class NotFoundError(IOError):
+    """
+    Exception that is thrown if a value was not found in the database.
+    """
+
+    def __init__(self, message: str) -> None:
+        super(NotFoundError, self).__init__(message)

genie_python/genie_logging.py

@@ -0,0 +1,200 @@
+"""Logging module for genie"""
+
+import getpass
+import logging
+import logging.config
+
+import graypy
+
+
+def send(self, s):
+    """
+    Needed otherwise graypy spits out logs if the DNS alias cannot be resolved.
+    See https://github.com/ISISComputingGroup/IBEX/issues/7059
+    """
+    try:
+        if len(s) < self.gelf_chunker.chunk_size:
+            super(graypy.GELFUDPHandler, self).send(s)
+        else:
+            for chunk in self.gelf_chunker.chunk_message(s):
+                super(graypy.GELFUDPHandler, self).send(chunk)
+    except Exception:
+        # logging to graypy failed, silently fail rather than throwing
+        pass
+
+
+graypy.GELFUDPHandler.send = send
+
+import os
+import socket
+from contextlib import contextmanager
+from time import localtime, strftime
+
+from genie_python.version import VERSION
+
+
+class InstrumentFilter(logging.Filter):
+    """For Graylog fields (https://graypy.readthedocs.io/en/latest/readme.html#adding-custom-logging-fields)"""
+
+    def __init__(self):
+        self.instrument = ""
+        self.sim_mode = False
+        self.genie_version = VERSION
+        self.reset()
+
+    def set_inst_name(self, inst_name):
+        self.instrument = inst_name
+
+    def set_sim_mode(self, sim_mode):
+        self.sim_mode = sim_mode
+
+    def filter(self, record):
+        record.instrument = self.instrument
+        record.command_called = self.command_called
+        record.function_args = self.function_args
+        record.function_kwargs = self.function_kwargs
+        record.time_taken = self.time_taken
+        record.exception_text = self.exception_text
+        record.from_channel_access = str(self.from_channel_access)  # need to cast bool to str
+        record.from_ibex = str(os.getenv("FROM_IBEX"))
+        record.genie_version = self.genie_version
+        record.is_sim_mode = str(self.sim_mode)
+        self.reset()
+        return True
+
+    def reset(self):
+        """
+        Reset filter fields back to blank values.
+        """
+        self.command_called = ""
+        self.function_args = ""
+        self.function_kwargs = ""
+        self.time_taken = 0
+        self.exception_text = ""
+        self.from_channel_access = False
+
+
+filter = InstrumentFilter()
+
+vhd_build_machines = ["NDHSPARE11"]
+
+
+class LoggingConfigurer:
+    @staticmethod
+    def get_file_name():
+        curr_time = localtime()
+        current_date_time = strftime("%Y-%m-%d-%a", curr_time)
+        return f"genie-{current_date_time}.log"
+
+    @staticmethod
+    def get_log_file_dir():
+        if socket.gethostname() in vhd_build_machines:
+            return os.path.join("C:", os.sep, "genie_python_logs")
+        else:
+            if os.name == "nt":
+                return os.path.join("C:", os.sep, "Instrument", "Var", "logs", "genie_python")
+            else:
+                return os.path.join("/tmp/{}/genie_python".format(getpass.getuser()))
+
+    @staticmethod
+    def get_log_file_path():
+        logs_dir = LoggingConfigurer.get_log_file_dir()
+        filename = LoggingConfigurer.get_file_name()
+        return os.path.join(logs_dir, filename)
+
+    @staticmethod
+    def get_logging_config():
+        return {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "verbose": {
+                    "format": "[{asctime}] [{process:d}:{thread:d}] [{levelname}]\t{message}",
+                    "style": "{",
+                    "datefmt": "%Y-%m-%dT%H:%M:%S",
+                }
+            },
+            "handlers": {
+                "graypy": {
+                    "level": "DEBUG",
+                    "class": "graypy.GELFUDPHandler",
+                    "host": "ino.isis.cclrc.ac.uk",
+                    "port": 12201,
+                    "formatter": "verbose",
+                },
+                "file": {
+                    "level": "DEBUG",
+                    "formatter": "verbose",
+                    "class": "logging.FileHandler",
+                    "filename": LoggingConfigurer.get_log_file_path(),
+                    "mode": "a",
+                },
+            },
+            "loggers": {
+                "genie_python_graylogger": {
+                    "handlers": ["graypy", "file"],
+                    "level": "DEBUG",
+                    "propagate": False,
+                    "namer": LoggingConfigurer.get_file_name(),
+                },
+            },
+        }
+
+
+@contextmanager
+def genie_logger():
+    try:
+        logging.config.dictConfig(LoggingConfigurer.get_logging_config())
+        yield logging.getLogger("genie_python_graylogger")
+    finally:
+        logging.shutdown()
+
+
+class GenieLogger:
+    def __init__(self, sim_mode=False):
+        self.sim_mode = sim_mode
+        self.logs_dir = LoggingConfigurer.get_log_file_dir()
+        if not os.path.exists(self.logs_dir):
+            os.makedirs(self.logs_dir)
+
+        filter.set_sim_mode(self.sim_mode)
+        with genie_logger() as logger:
+            logger.addFilter(filter)
+
+    def log_info_msg(self, message):
+        with genie_logger() as logger:
+            logger.info(self._get_message_with_mode(message))
+
+    def log_command(self, function_name, arguments, command_exception, time_taken=None):
+        filter.command_called = function_name
+        filter.function_args = arguments
+        filter.exception_text = command_exception
+        if time_taken is not None:
+            filter.time_taken = time_taken
+        with genie_logger() as logger:
+            logger.debug(self._get_message_with_mode(f"{function_name} {arguments}"))
+
+    def log_command_error_msg(self, function_name, error_msg):
+        error_msg = f"An exception has occurred as a result of the command:\n{error_msg}"
+        filter.command_called = function_name
+        filter.exception_text = error_msg
+        with genie_logger() as logger:
+            logger.error(self._get_message_with_mode(error_msg))
+
+    def log_error_msg(self, error_msg):
+        filter.exception_text = error_msg
+        with genie_logger() as logger:
+            logger.error(self._get_message_with_mode(error_msg))
+
+    def log_ca_msg(self, error_msg):
+        """Log the CA error (from CaChannel)"""
+        filter.exception_text = error_msg
+        with genie_logger() as logger:
+            logger.error(self._get_message_with_mode(error_msg))
+
+    def set_sim_mode(self, sim_mode):
+        self.sim_mode = sim_mode
+        filter.set_sim_mode(sim_mode)
+
+    def _get_message_with_mode(self, msg):
+        return f"(SIMULATION) {msg}" if self.sim_mode is True else msg

genie_python/genie_p4p_wrapper.py

@@ -0,0 +1,203 @@
+"""
+Wrapping of p4p in genie_python
+"""
+
+from __future__ import absolute_import, print_function
+
+import threading
+from builtins import object
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Optional, Tuple
+
+from p4p import Value
+from p4p.client.thread import Context, Subscription
+
+from .channel_access_exceptions import WriteAccessException
+from .utilities import waveform_to_string
+
+if TYPE_CHECKING:
+    from genie_python.genie import PVValue
+
+TIMEOUT = 15  # Default timeout for PV set/get
+EXIST_TIMEOUT = 3  # Separate smaller timeout for pv_exists() and searchw() operations
+CACHE = threading.local()
+CACHE_LOCK = threading.local()
+
+
+class P4PWrapper(object):
+    context: Optional[Context] = None
+    error_log_function: Optional[Callable[[str], None]] = None
+
+    # noinspection PyPep8Naming
+    @staticmethod
+    def _log_error(message: str) -> None:
+        """
+        Log an error
+        Args:
+            message: message to log
+        """
+        if P4PWrapper.error_log_function is not None:
+            try:
+                P4PWrapper.error_log_function(message)
+            except Exception:
+                pass
+        else:
+            print("PVERROR: {}".format(message))
+
+    @staticmethod
+    def set_pv_value(
+        name: str,
+        value: "PVValue",
+        wait: bool = False,
+        timeout: float = TIMEOUT,
+        safe_not_quick: bool = True,
+    ) -> None:
+        if safe_not_quick:
+            P4PWrapper._check_for_disp(name)
+        context = P4PWrapper.get_context()
+        context.put(name, value, timeout=timeout, wait=wait)
+
+    @staticmethod
+    def clear_monitor(name: str, timeout: float) -> None:
+        try:
+            lock = CACHE_LOCK.lock
+        except AttributeError:
+            lock = CACHE_LOCK.lock = threading.RLock()
+        with lock:
+            try:
+                subscriptions = CACHE.subscriptions
+                if name in subscriptions:
+                    subscriptions.pop(name).close()
+            except AttributeError:
+                return
+
+    @staticmethod
+    def get_pv_value(
+        name: str,
+        to_string: bool = False,
+        timeout: float = TIMEOUT,
+        use_numpy: Optional[bool] = None,
+    ) -> "PVValue":
+        context = P4PWrapper.get_context()
+        output = context.get(name, timeout=timeout)
+        if isinstance(output, Exception):
+            raise output
+
+        # Required to convince pyright the type won't be [Exception] which is only a valid response
+        # to a list of names. This should be replaced by proper handling for [Value] and [Exception]
+        # In a non-minimal/equivalent to CaChannel implementation.
+        assert isinstance(output, Value)
+
+        val = output.value
+
+        # If it's still a Value type then it's an Enum, so get the index or choice.
+        if isinstance(val, Value):
+            return val.choices[val.index]
+
+        if to_string:
+            val = str(val)
+        return val
+
+    @staticmethod
+    def get_pv_timestamp(name: str, timeout: float = TIMEOUT) -> Tuple[int, int]:
+        context = P4PWrapper.get_context()
+        output = context.get(name, timeout=timeout)
+        if isinstance(output, Exception):
+            raise output
+
+        # Required to convince pyright the type won't be [Exception] which is only a valid response
+        # to a list of names. This should be replaced by proper handling for [Value] and [Exception]
+        # In a non-minimal/equivalent to CaChannel implementation.
+        assert isinstance(output, Value)
+
+        time = output.timeStamp
+        return time.get("secondsPastEpoch"), time.get("nanoseconds")
+
+    @staticmethod
+    def pv_exists(name: str, timeout: float) -> bool:
+        try:
+            P4PWrapper.get_pv_value(name, timeout=timeout)
+            return True
+        except TimeoutError:
+            return False
+
+    @staticmethod
+    def add_monitor(
+        name: str,
+        call_back_function: "Callable[[PVValue, str, str], None]",
+        link_alarm_on_disconnect: bool = True,
+        to_string: bool = False,
+        use_numpy: Optional[bool] = None,
+    ) -> Subscription:
+        def _process_call_back(response: Value | Exception) -> None:
+            if isinstance(response, Exception):
+                P4PWrapper._log_error(str(response))
+                return
+            value = response.get("value")
+            if isinstance(value, Value):
+                value = value.choices[value.index]
+            if to_string:
+                # Could see if the element count is > 1 instead
+                if isinstance(value, list):
+                    value = waveform_to_string(value)
+                else:
+                    value = str(value)
+            elif isinstance(value, Value):
+                value = value.index
+
+            call_back_function(
+                value,
+                response.get("alarm").get("severity"),
+                response.get("alarm").get("status"),
+            )
+
+        context = P4PWrapper.get_context()
+        subscription = context.monitor(name, _process_call_back, notify_disconnect=True)
+
+        # Add to a dict of subscriptions to reproduce ability to close a monitor by its name.
+        try:
+            lock = CACHE_LOCK.lock
+        except AttributeError:
+            lock = CACHE_LOCK.lock = threading.RLock()
+        with lock:
+            try:
+                subscriptions = CACHE.subscriptions
+                subscriptions.update({name: subscription})
+            except AttributeError:
+                CACHE.subscriptions = {name: Subscription}
+        return subscription
+
+    @staticmethod
+    def get_context(autowrap: bool = False) -> Context:
+        try:
+            lock = CACHE_LOCK.lock
+        except AttributeError:
+            lock = CACHE_LOCK.lock = threading.RLock()
+
+        with lock:
+            try:
+                thread_context = CACHE.context
+            except AttributeError:
+                thread_context = CACHE.context = Context("pva", nt=autowrap)
+            if thread_context is None:
+                thread_context = Context("pva", nt=autowrap)
+        return thread_context
+
+    @staticmethod
+    def _check_for_disp(name: str) -> None:
+        """
+        Check if DISP is set on a PV. If passed a field instead of a PV, do nothing.
+        Only check DISP if it exists.
+        """
+        if (
+            ".DISP" not in name
+        ):  # Do not check for DISP if it's already in the name of the PV to check
+            if "." in name:  # If given a field on a PV, check the PV itself if DISP is set
+                name = name.split(".")[0]
+            _disp_name = "{}.DISP".format(name)
+            if P4PWrapper.pv_exists(_disp_name, 0) and P4PWrapper.get_pv_value(_disp_name) != "0":
+                raise WriteAccessException("{} (DISP is set)".format(name))
+
+    @staticmethod
+    def close_context() -> None:
+        P4PWrapper.get_context().close()

genie_python/genie_plot.py

@@ -0,0 +1,77 @@
+from __future__ import absolute_import, print_function
+
+from builtins import object, str
+from functools import wraps
+
+
+def _plotting_func(func):
+    """
+    Decorator for functions that interact with MPL.
+
+    Specifically, turns off interactive mode while the graphs are being manipulated and turns
+    it back on (and shows the graph) when finished.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        import matplotlib.pyplot as pyplt
+
+        was_interactive = pyplt.isinteractive()
+        pyplt.ioff()
+        result = func(*args, **kwargs)
+        pyplt.interactive(was_interactive)
+        pyplt.show(block=False)
+        return result
+
+    return wrapper
+
+
+class SpectraPlot(object):
+    @_plotting_func
+    def __init__(self, api, spectrum, period, dist):
+        import matplotlib.pyplot as pyplt
+
+        self.api = api
+        self.spectra = []
+        self.fig = pyplt.figure()
+        self.ax = pyplt.subplot(111)
+        self.ax.autoscale_view(True, True, True)
+        self.ax.set_xlabel("Time")
+        self.ax.set_ylabel("Counts")
+        self.ax.set_title("Spectrum {}".format(spectrum))
+        self.add_spectrum(spectrum, period, dist)
+
+    @_plotting_func
+    def add_spectrum(self, spectrum, period=1, dist=True):
+        self.spectra.append((spectrum, period, dist))
+        data = self.api.dae.get_spectrum(spectrum, period, dist)
+        name = "Spect {}".format(spectrum)
+        self.ax.plot(data["time"], data["signal"], label=name)
+        self.__update_legend()
+        return self
+
+    @_plotting_func
+    def refresh(self):
+        for i in range(len(self.ax.lines)):
+            data = self.api.dae.get_spectrum(
+                self.spectra[0][0], self.spectra[0][1], self.spectra[0][2]
+            )
+            line = self.ax.lines[i]
+            line.set_data(data["time"], data["signal"])
+        self.ax.autoscale_view(True, True, True)
+
+    @_plotting_func
+    def delete_plot(self, plotnum):
+        del self.ax.lines[plotnum]
+        del self.spectra[plotnum]
+        self.__update_legend()
+
+    def __update_legend(self):
+        handles, labels = self.ax.get_legend_handles_labels()
+        self.ax.legend(handles, labels)
+
+    def __repr__(self):
+        if len(self.spectra) > 0:
+            return "Spectra plot ({})".format(", ".join([str(x[0]) for x in self.spectra]))
+        else:
+            return "Spectra plot (empty)"

genie_python/genie_pre_post_cmd_manager.py

@@ -0,0 +1,21 @@
+from builtins import object
+
+
+class PrePostCmdManager(object):
+    """
+    A class to manager the precmd and postcmd commands such as used in begin, end, abort, resume, pause.
+    """
+
+    def __init__(self):
+        self.begin_precmd = lambda **pars: None
+        self.begin_postcmd = lambda **pars: None
+        self.abort_precmd = lambda **pars: None
+        self.abort_postcmd = lambda **pars: None
+        self.end_precmd = lambda **pars: None
+        self.end_postcmd = lambda **pars: None
+        self.pause_precmd = lambda **pars: None
+        self.pause_postcmd = lambda **pars: None
+        self.resume_precmd = lambda **pars: None
+        self.resume_postcmd = lambda **pars: None
+        self.cset_precmd = lambda **pars: True
+        self.cset_postcmd = lambda **pars: None