def __init__(self,
cfg,
web_api,
filename,
ss_client,
tracker=None,
parent=None,
network_speed_calculator=None,
db=None):
"""
Constructor
@param web_api Client_API class instance [Client_API]
@param ss_client Instance of signalling.SignalServerClient
@param tracker Instance of stat_tracking.Tracker
"""
QObject.__init__(self, parent=parent)
self._cfg = cfg
# Client_API class instance
self._web_api = web_api
# Signalling server client instance
self._ss_client = ss_client
self._tracker = tracker
self._network_speed_calculator = network_speed_calculator
self._db = db
self._filename = ensure_unicode(filename)
self.task_to_report = {}
self._downloader = HttpDownloader(
network_speed_calculator=self._network_speed_calculator)
self._set_callbacks()
# Download tasks info as task_id: info
self.download_tasks_info = {}
self._last_progress_report_time = 0
self._last_length = 0.0
self._was_stopped = False
self._empty_progress = (None, 0, 0)
self._open_uploads_file()
self._uploads_deleted = \
self._uploads_excluded = \
self._uploads_not_synced = set()
self._on_server_connect_signal.connect(self._on_server_connect)
self._upload_task_completed_signal.connect(
self._on_upload_task_completed)
self._upload_task_error_signal.connect(self._on_upload_task_error)
self._upload_task_progress_signal.connect(
self._on_upload_task_progress)
self._on_upload_added_signal.connect(self._on_upload_added)
self._on_upload_cancel_signal.connect(self._on_upload_cancel)
self._check_upload_path_timer = QTimer(self)
self._check_upload_path_timer.setInterval(10 * 1000)
self._check_upload_path_timer.timeout.connect(self._check_upload_paths)
def __init__(self, obj=None, event_type=None, *args):
#Creates a new filter object
QObject.__init__(self, *args)
self.obj = obj
self.event_type = event_type
self.events_handled = 0
self.events_bypassed = 0
def __init__(self, parent=None):
QObject.__init__(self, parent)
self._filename = "../res/alarm.mp3"
# 音声を読み込んで再生するためのmixer初期化
pygame.mixer.init()
# デフォルト音声ファイルのload
pygame.mixer.music.load(self._filename)
def __init__(self, feature_detector, source_dir="label", parent=None):
QObject.__init__(self, parent)
self.input_img_xy = 256
self.model = models.Sequential()
self.model.add(
layers.Conv2D(32, (3, 3),
activation='relu',
input_shape=(self.input_img_xy, self.input_img_xy,
3)))
self.model.add(layers.MaxPooling2D((2, 2)))
self.model.add(layers.Conv2D(64, (3, 3), activation='relu'))
self.model.add(layers.MaxPooling2D((2, 2)))
self.model.add(layers.Conv2D(64, (3, 3), activation='relu'))
self.model.add(layers.MaxPooling2D((2, 2)))
self.model.add(layers.Conv2D(64, (3, 3), activation='relu'))
self.model.add(layers.MaxPooling2D((2, 2)))
self.model.add(layers.Conv2D(64, (3, 3), activation='relu'))
self.model.add(layers.MaxPooling2D((2, 2)))
self.model.add(layers.Conv2D(64, (3, 3), activation='relu'))
self.model.add(layers.Flatten())
self.model.add(layers.Dense(64, activation='relu'))
self.model.add(layers.Dense(6, activation='softmax'))
print(self.model.summary())
self.model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
self.source_dir = source_dir
self.feature_detector = feature_detector
# create output dir for posturequalitynetmodel
if os.path.isdir("posturequalitynetmodel") == False:
os.mkdir("posturequalitynetmodel")
def __init__(self, location_model, item_model, order_model, update_signal):
"""Initialize PluginManager holding all plugins from plugins folder.
Args:
location_model (UniversalListModel): list model representing location tab
item_model (UniversalListModel): list model representing item tab
order_model (UniversalListModel): list model representing order tab
update_signal (Signal): signal to emit on plugin update (drawModeChanged)
"""
QObject.__init__(self)
self.plugin_modules = PluginManager.load_plugins()
self.plugins = {}
self.active_plugin = None
self._is_active = False
self._location_model = location_model
self._item_model = item_model
self._order_model = order_model
self.update_signal = update_signal
self._location_model.checkChanged.connect(
self._locations_update, Qt.DirectConnection
)
self._item_model.checkChanged.connect(self._items_update, Qt.DirectConnection)
self._order_model.checkChanged.connect(self._orders_update, Qt.DirectConnection)
def __init__(self, db_name, root='', address=None):
QObject.__init__(self)
self._connect_slots()
self._started = False
self._db_name = db_name
self.tracking = None
self.session_params = dict()
self._app_start_ts = self._now()
self._session_login_start_ts = None
self._session_signup_start_ts = None
self._license_type = UNKNOWN_LICENSE
self._db_file = ''
self._session_info = {
"_rx_ws": 0,
"_rx_wd": 0,
"_rx_wr": 0,
"_tx_ws": 0,
"_tx_wd": 0,
"_tx_wr": 0
}
self._address = address
self._root = root
self._user_agent = get_user_agent()
logger.debug("User agent %s", self._user_agent)
self._exiting = False
def __init__(self):
"""Initialize agent manager."""
QObject.__init__(self)
self.agents = {}
self.keys = set()
self._max_time = 0
self._active = False
def __init__(self):
QObject.__init__(self)
# Start VCU Code
self.m_vcuLeftMotorValue = 0.0
self.vcuLeftMotorValueChanged.connect(self.on_vcuLeftMotorValueChanged)
self.m_vcuRightMotorValue = 0.0
self.vcuRightMotorValueChanged.connect(self.on_vcuRightMotorValueChanged)
self.m_vcuSweeperMotorValue = 0.0
self.vcuSweeperMotorValueChanged.connect(self.on_vcuSweeperMotorValueChanged)
self.m_vcuActuatorValue = 0.0
self.vcuActuatorValueChanged.connect(self.on_vcuActuatorValueChanged)
self._signaller_sensor_1 = False
self._signaller_sensor_2 = False
self._signaller_sensor_3 = False
self._signaller_sensor_4 = False
self._signaller_sensor_5 = False
self._signaller_sensor_6 = False
self._signaller_left_bumper = False
self._signaller_right_bumper = False
self._signaller_e_stop = False
self._signaller_blue_button = False
self._signaller_connection_indicator = False
self._signaller_version = 'Version'
# End VCU CODE
self._signaller_log_box = ' '
# Debug remove
self.logger = Logger()
def __init__(self):
QObject.__init__(self)
self.current_bp = ""
self.current_glucose = ""
self.current_weight = ""
self.current_osat = ""
def __init__(self,
spindle_pitch_microns=4000,
steps_per_revolution=6400,
axis_orientation=1):
QObject.__init__(self)
try:
self.pywrapper = __import__(
'external_libraries.clearpath.clearpathPyWrapper',
fromlist='ClearpathTeknicDriver')
except ImportError:
print("ImportError")
return None
self.scskTeknic = self.pywrapper.ClearpathTeknicDriver()
self.is_connected = False
self.ports_count = 0
self.nodes = []
self.nodes_id = []
self.motor_parameters = []
self.default_parameters = {
"spindle_pitch_microns": spindle_pitch_microns,
"steps_per_revolution": steps_per_revolution,
"step_length_microns":
spindle_pitch_microns / steps_per_revolution,
"axis_orientation": axis_orientation
}
def __init__(self):
QObject.__init__(self, None)
self._mainthread = QThread.currentThread()
self._signalthread = SignalThread()
QObject.connect(self._signalthread, SIGNAL("triggerSignal()"),
self.sensorQueueChanged)
self._idletimer = QTimer()
self._delaytimer = QTimer()
self._timerqueuetimer = QTimer()
self._idletimer.setSingleShot(True)
self._delaytimer.setSingleShot(True)
self._timerqueuetimer.setSingleShot(True)
self.connect(self._idletimer, SIGNAL("timeout()"), self.idleTimeout)
self.connect(self._delaytimer, SIGNAL("timeout()"), self.delayTimeout)
self.connect(self._timerqueuetimer, SIGNAL("timeout()"),
self.timerQueueTimeout)
SoDB.getSensorManager().setChangedCallback(self.sensorQueueChangedCB,
self)
SoDB.setRealTimeInterval(1.0 / 25.0)
SoRenderManager.enableRealTimeUpdate(False)
def __init__(self, parent, parent_window, config, dp=1, selected_index=0):
QObject.__init__(self, parent)
self._parent = parent
self._parent_window = parent_window
self._config = config
self._dp = dp
self._selected_index = selected_index
self._dialog = QDialog(parent_window)
self._dialog.setWindowFlags(Qt.Dialog)
self._dialog.setAttribute(Qt.WA_MacFrameworkScaled)
self._is_opened = False
self._pipe = None
self._feedback_mode = False
self._ui = Ui_Dialog()
self._ui.setupUi(self._dialog)
self._init_ui()
self._old_close_event = self._dialog.closeEvent
self._feedback_timer = QTimer(self)
self._feedback_timer.setSingleShot(True)
self._feedback_timer.timeout.connect(self._show_feedback_form)
self._parent.service_started.connect(self._check_feedback_needed)
self._parent.exit_request.connect(self._on_exit_request)
def __init__(self, plumbing_bridge):
QObject.__init__(self)
plumbing_bridge.dataUpdated.connect(self.update)
plumbing_bridge.engineLoaded.connect(self.clear)
self.data_values = {} # {channel_name: np.ndarray}
self.times = np.array([])
self.window_size_s = 10 # TODO(jacob): Add a UI field for this.
def __init__(self):
QObject.__init__(self)
## QTimer - Run Timer
self.timer = QTimer()
self.timer.timeout.connect(lambda: self.setTime())
self.timer.start(1000)
def __init__(self, app):
QObject.__init__(self, app)
self._sys_except_hook = sys.excepthook
self.app = app
self.allow_dialog = True
self.current_dialog = None
self.got_exception.connect(self.display_dialog, Qt.QueuedConnection)
def __init__(self):
QObject.__init__(self)
self.__motor = ClearpathSCSK()
self.__motor_nodes_count_list = [2]
self.__motor_nodes_id_list = ["Disconnected 0", "Disconnected 1"]
self.__motor_ports_connected = len(self.__motor_nodes_count_list)
self.__building_plate_port = 0
self.__wiper_port = 0
self.__building_plate_node = 0
self.__wiper_node = 1
self.__wiper_recoat_offset_mm = 245
self.__wiper_recoat_feedrate_mm_min = 1800
self.__building_plate_recoat_offset_mm = 1
self.__building_plate_recoat_feedrate_mm_min = 300
self.__pause_toggle = False
self.__ser = serial.Serial(timeout=5, write_timeout=0)
self.__loaded_gcode = []
self.__number_of_lines = 0
self.__baudrates_list = (115200, 57600, 38400, 28800, 19200, 14400,
9600, 4800, 2400, 1200, 600, 300)
self.__baudrate = self.__baudrates_list[0]
self.__com_port = ''
self.__available_ports = serial.tools.list_ports.comports()
ports = ()
for p in self.__available_ports:
ports = ports + (str(p.device), )
self.__available_ports = ports
if len(self.__available_ports) > 0:
self.__com_port = self.__available_ports[0]
self.__threadpool = QThreadPool()
def __init__(self,
parent=None,
camera_id=0,
resolution_x=640,
resolution_y=480,
time_in_ms=200):
QObject.__init__(self, parent)
# cv2.CAP_DSHOW to ensure compatibility with Windows and DirectShow
if platform.system() == "Windows":
self.cap = cv2.VideoCapture(cv2.CAP_DSHOW + camera_id)
else:
self.cap = cv2.VideoCapture(camera_id)
self.img_timer = QTimer(self)
self.img_timer.setSingleShot(False)
self.img_timer.timeout.connect(self.read_frame)
self.img_timer.start(time_in_ms)
self._x = resolution_x
self._y = resolution_y
self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, self._x)
self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self._y)
if ImageAcquisition.__instance is not None:
raise Exception("This class is a singleton!")
else:
ImageAcquisition.__instance = self
def __init__(self, destdir, persist_limit, **kwargs):
QObject.__init__(self)
BuildDownloadManager.__init__(self,
destdir,
session=get_http_session(),
persist_limit=persist_limit,
**kwargs)
def __init__(self, parent, service, config, dp):
QObject.__init__(self, parent=parent)
self._parent = parent
self._service = service
self._config = config
self._dp = dp
self._file_list_changing = False
self._mime_icons = self._build_mime_icons()
self._ui = self._parent.get_ui()
self._files = dict()
self._shared_files = set()
self._ui.file_list.setFocusPolicy(Qt.NoFocus)
self._ui.file_list.setAcceptDrops(True)
self._ui.file_list.setFont(QFont('Nano', 10 * self._dp))
self._ui.file_list.setGridSize(QSize(
self.FILE_LIST_ITEM_SIZE, self.FILE_LIST_ITEM_SIZE))
self._ui.file_list.setAutoScroll(False)
self._ui.file_list.setUniformItemSizes(True)
self._ui.file_list.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self._ui.file_list.dropEvent = self._file_list_drop_event
self._ui.file_list.dragEnterEvent = self._file_list_drag_enter_event
self._ui.file_list.dragMoveEvent = self._file_list_drag_enter_event
self._ui.welcome_label.setAcceptDrops(True)
self._ui.welcome_label.dropEvent = self._file_list_drop_event
self._ui.welcome_label.dragEnterEvent = self._file_list_drag_enter_event
self._ui.welcome_label.dragMoveEvent = self._file_list_drag_enter_event
self._icons_info_ready.connect(self._on_icons_info_ready)
self._init_timers()
def __init__(self, obj=None, event_type=None, *args):
#Creates a new filter object
QObject.__init__(self, *args)
self.obj = obj
self.event_type = event_type
self.events_handled = 0
self.events_bypassed = 0
def __init__(self, input, query, log, callback=None, rampage_type=None, conf=None, **kwargs):
QObject.__init__(self)
threading.Thread.__init__(self)
self._input = input
self._query = query
self.log = log
self._callback = callback
self._rampage_type = rampage_type
if 'captcha_answer' in kwargs:
self._captcha_answer = kwargs['captcha_answer']
if conf:
self._conf = conf
else:
self._conf = Configuration('SciHubEVA.conf')
self._sess = requests.Session()
self._sess.headers = json.loads(self._conf.get('network', 'session_header'))
retry_times = self._conf.getint('network', 'retry_times')
retry = Retry(total=retry_times, read=retry_times, connect=retry_times)
adapter = HTTPAdapter(max_retries=retry)
self._sess.mount('http://', adapter)
self._sess.mount('https://', adapter)
self._set_http_proxy()
self._doi_pattern = re.compile(r'\b(10[.][0-9]{4,}(?:[.][0-9]+)*/(?:(?!["&\'])\S)+)\b')
self._illegal_filename_pattern = re.compile(r'[\/\\\:\*\?\"\<\>\|]')
def __init__(self,
cfg,
tracker=None,
server_addr=None,
events_server_addr=None,
sharing_server_addr=None,
upload_server_addr=None,
parent=None):
logger.debug("Initializing API server client...")
QObject.__init__(self, parent=parent)
self._sessions = dict()
self.server_addr = server_addr if server_addr \
else API_URI.format(cfg.host)
self.events_server_addr = events_server_addr if events_server_addr \
else API_EVENTS_URI.format(cfg.host)
self.sharing_server_addr = sharing_server_addr if sharing_server_addr \
else API_SHARING_URI.format(cfg.host)
self.upload_server_addr = upload_server_addr if upload_server_addr \
else API_UPLOAD_URI.format(cfg.host)
self._tracker = tracker
self.ip_addr = None
self.cfg = cfg
self.node_sign = None
self._ip_lock = QMutex(parent=self)
self._os_name, self._is_server = get_os_name_and_is_server()
def __init__(self, mid, order, mjson, metadata, parent=None):
QObject.__init__(self, parent)
self.setObjectName(str(mid))
self.m_id = mid
self.m_order = order
self.m_json = QJsonValue(mjson) # or self.m_json = mjson #
self.m_metadata = metadata
def __init__(self, cache_dir, access_url, default_image, http_session):
QObject.__init__(self)
self._cache_dir = os.path.realpath(cache_dir.path)
self._default_image = os.path.realpath(default_image.path)
self._access_url = access_url
self._images = {}
self._http_session = http_session
def __init__(self, port, api):
QObject.__init__(self)
self.api = api
HandlerClass = self.requestHandlerFactory(self.api.getState,
self.actionCallback)
ThreadingHTTPServer.__init__(self, ('localhost', port), HandlerClass)
self.action.connect(self.api.action)
def __init__(self):
QObject.__init__(self)
self.list_path = list()
self.list_value_path = list()
self.project_name = ""
self.info = list()
self.sfreq = list()
def __init__(self):
QObject.__init__(self)
# AUTO REFRESH / DYNAMIC INFOS
timer = QTimer(self)
timer.start(1000)
timer.timeout.connect(lambda: self.setDynamicInfo())
def __init__(self, width: int, height: int, leds: int, parent=None):
QObject.__init__(self, parent)
self._width = width
self._height = height
self._leds = leds
self._pixels = [[False for y in range(height)] for x in range(width)]
self._tx_worker = FlipdotTxWorker(self)
def __init__(self, fetch_config, test_runner, download_manager):
QObject.__init__(self)
self.fetch_config = fetch_config
self.test_runner = test_runner
self.download_manager = download_manager
self.launch_arg = None
self._build_info = None
def __init__(self, parent, parent_window, dp):
QObject.__init__(self, parent)
self._downloads_info = dict()
self._uploads_info = dict()
self._init_speed_size()
self._parent_window = parent_window
self._dp = dp
self._transfers_dialog = None
self._time_delta_timer = QTimer(self)
self._time_delta_timer.setInterval(1 * 60 * 1000) # 1 minute
self._speed_charts_timer = QTimer(self)
self._speed_charts_timer.setInterval(1000) # 1 second
self._speed_charts_timer.timeout.connect(
self._update_speed_charts, Qt.QueuedConnection)
self._speed_charts_timer.start()
self._all_disconnected_timer = QTimer(self)
self._all_disconnected_timer.setInterval(5 * 1000)
self._all_disconnected_timer.setSingleShot(True)
self._all_disconnected_timer.timeout.connect(
self._on_all_disconnected)
self._paused = False
self._resuming = False
self._transfers_dialog_calls = 0
self._init_changed_statuses()
self.transfers_ready.connect(
self._on_transfers_ready, Qt.QueuedConnection)
self._nodes_num = 0
self._signalserver_address = ''
def __init__(self):
"""
Constructs a ConfigVars (configuration variables) object.
"""
QObject.__init__(self)
self.showBehaviors = True
self.showTokenTags = True
def __init__(self, widget, eventType, key):
QObject.__init__(self)
self.widget = widget
self.eventType = eventType
self.key = key
self.processed = False
def __init__(self):
# "foobar" will become a object attribute that will not be
# listed on the among the type attributes. Thus for bug
# condition be correctly triggered the "foobar" attribute
# must not previously exist in the parent class.
self.foobar = None
# The parent __init__ method must be called after the
# definition of "self.foobar".
QObject.__init__(self)
def __init__(self):
QObject.__init__(self)
self.events = []
self.t = MyThread(self)
self.t.start()
def __init__(self, parent=None):
QObject.__init__(self, parent)
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.setObjectName("PySide")
def __init__(self):
QObject.__init__(self)
def __init__(self, eventloop):
QObject.__init__(self)
self.eventloop = eventloop
def __init__(self, *args):
QObject.__init__(self, *args)
self.called = False
def __init__(self, watched):
QObject.__init__(self)
self.times_called = 0
self.watched = watched
def __init__(self):
QObject.__init__(self)
self.counter = 0
def __init__(self):
QObject.__init__(self)
self._value = None
def __init__(self, text, parent=None):
QObject.__init__(self, parent)
self._text = text
def __init__(self, number):
self.myMember = 'myMember' + number
QObject.__init__(self)
def __init__(self):
QObject.__init__(self)
self.called = False
def __init__(self):
QObject.__init__(self)
self.child_event_received = False
def __init__(self, parent=None):
QObject.__init__(self, parent)
self._mySlotcalled = False
self._mySlot2called = False
def __init__(self):
QObject.__init__(self)
self.received = None
def __init__(self, parent=None):
QObject.__init__(self, parent)
self._slotCalledCount = 0
def __init__(self, app, *args):
QObject.__init__(self, *args)
self.app = app
self.times_called = 0
def __init__(self):
QObject.__init__(self)
self.__number = 42
self.__max_number = 99
def __init__(self, *args):
QObject.__init__(self, *args)
def __init__(self):
QObject.__init__(self)
self._current_value = 0
self.propertyChanged.connect(self.on_property_changed)
def __init__(self):
self.member = 'member'
QObject.__init__(self)
