def func_wrapper(cls, *args, **kwargs):
logger = get_logger(name=__name__)
logger.info(f'Checking if function {func.__name__} was already triggered')
update = False
if hasattr(cls, 'cache_setters'):
if len(args) >= 1:
for i, arg in enumerate(args[1:]):
old_arg = args[0].cache_setters.get('args')[i]
if arg != old_arg:
update = True
if len(kwargs) > 1:
for key, value in kwargs.items():
old_value = args[0].cache_setters.get('kwargs')[key]
if value != old_value:
update = True
else:
cls.cache_setters = dict()
update = True
if update:
cls.cache_setters.update({'args': args, 'kwargs': kwargs})
logger.info('Updating values')
return func
else:
logger.info('Nothing to update')
return lambda *args, **kwargs: None
def __init__(self, parent=None):
super(DataViewWidget, self).__init__(parent=parent)
self.logger = get_logger()
self._layout = None
self.set_layout()
self.data = None
def __init__(self, parent=None):
super().__init__(parent=parent)
# Settings for the image
self.viewport = GraphicsLayoutWidget()
self.view = self.viewport.addViewBox(lockAspect=False, enableMenu=True)
self.img = pg.ImageItem()
self.view.addItem(self.img)
self.imv = pg.ImageView(view=self.view, imageItem=self.img)
self.scene().sigMouseClicked.connect(self.mouse_clicked)
# Add everything to the widget
layout = self.get_layout()
layout.addWidget(self.imv)
self.show_roi_lines = False # ROI lines are shown or not
self.show_cross_hair = False # Cross hair is shown or not
self.show_cross_cut = False # Cross cut is shown or not
self.cross_hair_setup = False # Cross hair was setup or not
self.cross_cut_setup = False # Cross cut was setup or not
self.rois = []
self.corner_roi = [0, 0] # Initial ROI corner for the camera
self.first_image = True
self.logger = get_logger()
self.last_image = None
self.add_actions_to_menu()
self.setup_mouse_tracking()
def __init__(self, parent: BaseModel, **kwargs):
self._parent = parent
self._properties = dict()
self._links = dict()
self.logger = get_logger()
if kwargs:
for key, value in kwargs.items():
self.__setitem__(key, value)
def __init__(self, camera, initial_config=None):
super().__init__()
self.logger = get_logger(__name__)
self.camera = camera
self.running = False
self.data_type = np.uint16
self.temp_image = None
self.initial_config = initial_config
def __init__(self, camera, initial_config=None):
super().__init__(camera, initial_config=initial_config)
self.logger = get_logger(__name__)
self.friendly_name = ''
self.free_run_running = False
self._stop_free_run = Event()
self.fps = 0
self.keep_reading = False
self.continuous_reads_running = False
self.finalized = False
self._buffer_size = None
self.current_dtype = None
def __init__(self, filename=None):
super().__init__()
self.config = {
} # Dictionary storing the configuration of the experiment
self.logger = get_logger(name=__name__)
self._connections = []
self.subscriber_events = []
self.initialize_threads = [
] # Threads to initialize several devices at the same time
if filename:
self.load_configuration(filename)
atexit.register(self.finalize)
self.is_alive = True
def __init__(self,
func,
topic,
publish_topic=None,
args=None,
kwargs=None):
super(Subscriber, self).__init__()
self.func = func
self.topic = topic
self.publish_topic = publish_topic
self.args = args
self.kwargs = kwargs
self.logger = get_logger()
self.logger.info(
f'Starting subscriber for {func.__name__} on topic {topic}')
def func_wrapper(*args, **kwargs):
logger = get_logger(name=__name__)
logger.info('Starting new thread for {}'.format(func.__name__))
if isinstance(args[0], BaseModel):
args[0].clean_up_threads()
if not hasattr(args[0], '_threads'):
args[0]._threads = []
elif not isinstance(args[0]._threads, list):
raise ValueError('The variable _threads must be a list in order to store a new Thread in it')
args[0]._threads.append([func.__name__, Thread(target=func, args=args, kwargs=kwargs)])
args[0]._threads[-1][1].start()
logger.info('In total there are {} threads'.format(len(args[0]._threads)))
def __init__(self,experiment_model=None, initialize=True, logger=logging.INFO):
self.log = get_logger()
if logger is not None:
handler = log_to_screen(logger=self.log, level=logger)
self.log.info(f'Experiment Model: {settings.EXPERIMENT_MODEL}')
if experiment_model is not None:
exp_model = settings.EXPERIMENT_MODEL.split('.')
experiment_module = importlib.import_module('.'.join(exp_model[:-1]))
experiment_model_class = getattr(experiment_module, exp_model[-1])
else:
experiment_model_class = experiment_model
if settings.EXPERIMENT_MODEL_INIT is not None:
self.experiment_model = experiment_model_class(**settings.EXPERIMENT_MODEL_INIT)
else:
self.experiment_model = experiment_model_class()
if initialize:
self.experiment_model.initialize()
self.gui_thread = Thread(target=start_gui, args=(self.experiment_model, ))
self.gui_thread.start()
from experimentor.lib.log import get_logger
logger = get_logger(__name__)
class Signal:
""" Base signal which implements the common pattern for defining, emitting and connecting a signal
"""
def __init__(self):
self.name = None
def __set_name__(self, owner, name):
model_signals = getattr(owner, '_signals')
if getattr(model_signals, 'model_name', None) != object.__qualname__:
model_signals = model_signals.__class__(*model_signals)
setattr(model_signals, 'model_name', object.__qualname__)
setattr(owner, '_signals', model_signals)
model_signals[name] = self
self.name = name
self.owner = str(owner)
def __get__(self, instance, owner):
self.instance = instance
return self
def emit(self, payload=None, **kwargs):
""" Emitting a signal relies on the owner's publisher or whatever method the owner specifies for broadcasting.
that objects where pickled. There is also a possibility of assuming numpy arrays and using a zero-copy strategy.
:copyright: Aquiles Carattino
:license: MIT, see LICENSE for more details
"""
import atexit
from time import sleep
import zmq
from experimentor.config import settings
from experimentor.core.pusher import Pusher
from experimentor.lib.log import get_logger
from .meta import MetaProcess, ExperimentorProcess
logger = get_logger(name=__name__)
class Publisher(ExperimentorProcess, metaclass=MetaProcess):
""" Publisher class in which the queue for publishing messages is defined and also a separated process is started.
It is important to have a new process, since the serialization/deserialization of messages from the QUEUE may be
a bottleneck for performance.
"""
def __init__(self, event, name=None):
super(Publisher, self).__init__(name=name or 'Publisher')
self._event = event # This event is used to stop the process
self.running = False
atexit.register(self.stop)
def run(self):
acquisition synchronized via an external trigger (which can also be on the board itself).
"""
import ctypes
import sys
from ctypes import byref, c_bool, c_byte, c_double, c_int, c_ubyte, c_uint, cdll, create_string_buffer
import numpy as np
from experimentor.drivers.digilent.dwfconst import AcquisitionMode, AnalogAcquisitionFilter, AnalogChannelNodeType, \
AnalogInTriggerMode, \
AnalogOutNode, AnalogOutSignalType, DigitalOutIdle, DigitalOutOutput, DigitalOutType, InstrumentState, \
TriggerLength, TriggerSlope, TriggerSource, DeviceFilter
from experimentor.drivers.exceptions import DriverException
from experimentor.lib.log import get_logger
logger = get_logger()
try:
if sys.platform.startswith("win"):
dwf = cdll.dwf
elif sys.platform.startswith("darwin"):
dwf = cdll.LoadLibrary("/Library/Frameworks/dwf.framework/dwf")
else:
dwf = cdll.LoadLibrary("libdwf.so")
except:
logger.error("The library for controlling the digilent cards was not found. Please check your own "
"installation before proceeding")
class AnalogDiscovery:
def __init__(self):
def func_wrapper(cls, *args, **kwargs):
logger = get_logger(__name__)
logger.warning(f'{func.__name__} from {cls} not Implemented')
return func(cls, *args, **kwargs)
def __init__(self):
atexit.register(self.finalize)
self._threads = []
self._ctx = self.create_context()
self._publisher = self.create_publisher()
self.logger = get_logger()
def __init__(self, *args, **kwargs):
super(ExperimentorThread, self).__init__(args, kwargs)
self.logger = get_logger()
def __init__(self, *args, **kwargs):
super(ExperimentorProcess, self).__init__()
self.logger = get_logger()
