def load_avro_schema_string(self, topic_name): if topic_name not in self.config_avro_location: raise ErrorHandler("Error. Application does not have avro schema for requested topic") try: with open(self.directory_avro_schemas + "/" + self.config_avro_location.get(topic_name), 'r') as schema_file: return schema_file.read().replace('\n', '') except Exception as e: raise ErrorHandler("Error. Unable to load schema: " + str(e))
def replace_docx(path, old_str, new_str): doc = open_docx(path) # check none if not isinstance(old_str, str) or not isinstance(new_str, str): e = "the parameter in replace_docx must not be None" return ErrorHandler(path, e) # replace the string try: # paragraph processing for para in doc.paragraphs: # each para call matchIndexs if old_str in para.text: matchedIndices = findMatchedIndices(para.text, 0, old_str) for i_matchIndex, matchIndex in enumerate(matchedIndices): # make the instance of matchedRunObj diff = len(new_str) - len(old_str) updatedMatchedIndex = i_matchIndex * diff + matchIndex matchedObj = MatchedRunObj(para, updatedMatchedIndex, old_str, new_str) matchedObj.findRelatedRunIndex() print("indexOfFirstMatchedChar: ", matchedObj.indexOfFirstMatchedChar) print("indexOfLastMatchedChar: ", matchedObj.indexOfLastMatchedChar) matchedObj.replaceString() # table processing for table in doc.tables: for r in table.rows: for cell in r.cells: for para in cell.paragraphs: if old_str in para.text: matchedIndices = findMatchedIndices( para.text, 0, old_str) for i_matchIndex, matchIndex in enumerate( matchedIndices): # make the instance of matchedRunObj diff = len(new_str) - len(old_str) updatedMatchedIndex = i_matchIndex * diff + matchIndex matchedObj = MatchedRunObj( para, updatedMatchedIndex, old_str, new_str) matchedObj.findRelatedRunIndex() print("indexOfFirstMatchedChar: ", matchedObj.indexOfFirstMatchedChar) print("indexOfLastMatchedChar: ", matchedObj.indexOfLastMatchedChar) matchedObj.replaceString() # heading processing # save file in here doc.save('.\sample\ex2.docx') except AttributeError as e: errorObj = ErrorHandler(path, e) errorObj.showError() return errorObj
def __retrieve_partition_data(self, topic): """ Returns patition data for given topic. :param topic: string, name of topic being searched :return: confluent_kafka.TopicPartition() """ if topic not in self.consumer_topic_list: raise ErrorHandler( "Application does not have access to requested topic: " + topic) try: return self.consumer_topic_list.get(topic).partitions except Exception as e: raise ErrorHandler("Error retrieving partition data: " + str(e))
def convert_avro_msg(self, msg): try: return self.deserializer.__call__(msg.value(), self.serial_context) except Exception as e: raise ErrorHandler( "Error deserializing avro message. Check registry settings: " + str(e))
def __init__(self, file_name): self.file_name = file_name self.stack = Stack() self.stack.push("EOF") self.stack.push("Source") self.parser_table = PARSER_TABLE self.symbol_table = OOPSymbolTable() self.semantic_stack = Stack() self.memory_manager = MemoryManager(1000, 2000) self.scanner = Scanner(file_name, self.symbol_table) self.next_token = self.scanner.get_next_token() self.top_stack = self.stack.top() self.rule_number = None self.rule = "" self.grammar = GRAMMAR self.error_handler = ErrorHandler(self.scanner) self.symbol_table.set_error_handler(self.error_handler) self.semantic_analyzer = SemanticAnalyzer(self.symbol_table, self.memory_manager, self.semantic_stack, self.error_handler) self.code_generator = CodeGenerator(self.symbol_table, self.semantic_stack, self.memory_manager) self.current_identifier = None self.follow = FOLLOW self.non_terminal = 0 self.must_get = False
def __init__(self, environment): self.avro_deserializer = None try: self.consumer = ConsumerConnectionManager.initialize_kafka_consumer( environment) try: # Retrieve list of topics from KafkaConsumer(). timeout is set as float(10). # Timeout errors typically signify a connection error to kafka-broker. self.consumer_topic_list = self.consumer.list_topics( timeout=float(10)).topics except Exception as e: raise ErrorHandler( "Error retrieving list of available topics. Check Kafka connection settings. Error: " + str(e)) except Exception as e: raise ErrorHandler("Error initializing KafkaReader(): " + str(e))
def search(cls, params): response = {} # Start connection to queue manager try: queue_manager = QueueManager() except Exception as e: raise ErrorHandler( "Unable to connect to QueueManager, please try again. Error code: " + str(e)) # Iterate through the search queue list and browse all messages, # returning all messages that match the search param for name in params.get('queue_list'): queue_suffix = params.get('queue_suffix') try: browser = MQReader(queue_manager, name, params.get('base_queues'), queue_suffix) found_msgs = browser.search_for_msgs( params.get('search_string'), params.get('delimiter'), params.get('not_before')) browser.close_browser_connection() except Exception as e: response["QUEUE___" + name + '.' + queue_suffix] = "queue was unresponsive " + str(e) continue response["QUEUE___" + name + '.' + queue_suffix] = found_msgs # Close connection to queue manager try: queue_manager.close_manager_connection() except Exception as e: response[ 'ERROR'] = "ISSUE CLOSING QUEUE MANAGER error code: " + str(e) return response
def __parse_incoming_request(cls, request): """ Parse incoming request convert to dict() :return parsed_request dict() :rtype dict() """ # Merges form(UI calls), args(Postman form-data) params parsed_request = {**request.form.to_dict(), **request.args.to_dict()} # Extract json_topics from splash.html if present json_topics = request.form.getlist( constants.REQUEST_UI_FORM_JSON_TOPICS_KEY) if len(json_topics) > 0: parsed_request[cls.request_json_topics_key] = json_topics parsed_request.pop(constants.REQUEST_UI_FORM_JSON_TOPICS_KEY) # Extract avro_topics from splash.html if present avro_topics = request.form.getlist( constants.REQUEST_UI_FORM_AVRO_TOPICS_KEY) if len(avro_topics) > 0: parsed_request[cls.request_avro_topics_key] = avro_topics parsed_request.pop(constants.REQUEST_UI_FORM_AVRO_TOPICS_KEY) # Support for JAVA JSON body requests if request.json: parsed_request = {**parsed_request, **request.json} # Support for POSTMAN raw JSON body requests if len(parsed_request) == 0: parsed_request = json.loads(request.data.decode()) if len(parsed_request) == 0: raise ErrorHandler("Error parsing params") return parsed_request
def __init__(self, error_callback=None): self.error_handler = ErrorHandler(error_callback) storage_name = Core.storage.abs_path( Core.storage.join_path(Core.bundle_path, 'Contents', 'music.storage')) self.music_queue = PlexStorage(storage_name)
def parse_request(cls, request): params = {} # Merges form(UI calls), args(Postman form-data) params arguments = {**request.form.to_dict(), **request.args.to_dict()} # Extract queue_list[] from splash.html if present queue_list = request.form.getlist("queue_list[]") if len(queue_list) > 0: arguments['queue_list'] = queue_list arguments.pop("queue_list[]") # Support for JAVA JSON body requests if request.json: arguments = {**arguments, **request.json} # Support for POSTMAN raw JSON body requests if len(arguments) == 0: arguments = json.loads(request.data.decode()) if len(arguments) == 0: raise ErrorHandler("Error parsing params") # Extract params from request search_string = arguments.get('searchParam', None) if not search_string: raise ErrorHandler( "Required param 'searchParam' not found .... If you are receiving this error in postman " "and have included the searchParam, " "please uncheck option in Headers Content-type - " "application/x-www-form-urlencoded and try again") params['search_string'] = search_string.strip().lower() params['queue_suffix'] = arguments.get('queueSuffix', 'DEFAULT.QUEUE.SUFFIX').strip() params['delimiter'] = arguments.get('includeDelimiter', 'false').strip().lower() not_before = arguments.get('notBefore', 'false').strip().lower() if not_before != 'false' and not_before != '': not_before = cls.convert_not_before(not_before) params['not_before'] = not_before params['base_queues'] = arguments.get('BASE.QUEUE.PREFIX', 'false').strip().lower() params['queue_list'] = arguments.get('queue_list', []) return params
def __init__(self, environment): try: self.registry_client = RegistryClient(environment).registry_client self.msg_field = MessageField() self.deserializer = None self.serial_context = None except Exception as e: raise ErrorHandler("Unable to initialize AvroClient(): " + str(e))
def __init__(self, file_name, symbol_table): self.symbolTable = symbol_table self.currentIndex = 0 self.startTokenIndex = 0 self.error_handler = ErrorHandler(self) input_file = open(file_name) self.inputCode = input_file.read() self.lastToken = None
def __init__(self, filebase='todos'): self.error_handler = ErrorHandler() self.io_controller = IoController(filebase + '.csv') try: self.todos = self.io_controller.load() except FileNotFoundError: self.todos = [] self.save()
def convert_not_before(cls, not_before): try: # convert notBefore param into 'aware' datetime object return pytz.UTC.localize(datetime.fromisoformat(not_before)) except Exception as e: raise ErrorHandler( "Error parsing DateTime 'notBefore' -> " + not_before + " . Value must be of format " "DateTimeFormatter.ofPattern('yyyy-MM-dd HH:mm:ss') " + str(e))
def load_deserializer(self, topic_name): try: self.deserializer = Deserializer( self.registry_client).create_avro_deserializer(topic_name) self.serial_context = SerializationContext(topic_name, self.msg_field) except Exception as e: raise ErrorHandler( "Unable to load deserializer for topic: " + topic_name + ". Please check avro schema provided in avro schemas directory: " + str(e))
def __stream_comments(self): try: stream = self.reddit.subreddit(self.settings['subreddit']).stream.comments(skip_existing=True) for comment in stream: self.logger.info("Parsing comment {}".format(comment.id)) if self.__parent_is_approvable(comment): self.__approve_parent_submission(comment) except Exception as exception: ErrorHandler(self, self.logger).handle(exception) self.__stream_comments()
def validateMetadataFile(self): # check if metadata exists if not self.checkMetadata(): return # check matadata standard standard = MetaInfoStandard.tryDetermineStandard(self.metaProvider) if standard != MetaInfoStandard.FGDC: QMessageBox.critical( self.iface.mainWindow(), QCoreApplication.translate("Metatools", "Metatools"), QCoreApplication.translate( "Metatools", "Unsupported metadata standard! Only FGDC supported now!")) return from PyQt4.QtXmlPatterns import QXmlSchema, QXmlSchemaValidator # TODO: validate metadata file # setup xml schema schema = QXmlSchema() # setup handler self.handler = ErrorHandler( QCoreApplication.translate("Metatools", "Metadata is invalid")) schema.setMessageHandler(self.handler) # load schema from file xsdFilePath = self.pluginPath + '/xsd/fgdc/fgdc-std-001-1998.xsd' #if standard != MetaInfoStandard.FGDC: # xsdFilePath = 'c:/xsd/gml/basicTypes.xsd' # gmd/gmd.xsd' schemaUrl = QUrl(xsdFilePath) loadResult = schema.load(schemaUrl) if not loadResult or self.handler.errorOccured: QMessageBox.critical( self.iface.mainWindow(), QCoreApplication.translate("Metatools", "Metatools"), QCoreApplication.translate("Metatools", "Schema for validate not loaded!")) return #setup validator validator = QXmlSchemaValidator(schema) validator.setMessageHandler(self.handler) #validate metadata = self.metaProvider.getMetadata().encode('utf-8') if validator.validate(metadata): QMessageBox.information( self.iface.mainWindow(), QCoreApplication.translate("Metatools", "Metatools"), QCoreApplication.translate("Metatools", "Metadata is valid!"))
def __validate_params(cls, params): """ Catch and throw all invalid request exceptions here. Current Validations: - no search_string included in request - no valid topics included in request """ # Validate search_string was included in request if not params.get(cls.param_search_string_key): raise ErrorHandler( "Invalid request. Required param: " + cls.request_search_string_key + " not found .... If you are receiving this error in postman " "and have included the required key, " "please uncheck option in Headers Content-type - " "application/x-www-form-urlencoded and try again") # Validate valid topics was included in request if len(params[cls.param_json_topics_key]) == 0 and len( params.get(cls.param_avro_topics_key)) == 0: raise ErrorHandler( "Invalid request. No valid topics selected for search")
def __stream_submissions(self): try: stream = self.reddit.subreddit( self.settings['subreddit']).stream.submissions( skip_existing=True) for submission in stream: self.logger.info("Parsing submission {}".format(submission.id)) if self.__should_remove_submission(submission): self.logger.info( "Removing submission {} [{}] by /u/{}...".format( submission.id, submission.url, submission.author)) self.__handle_removal(submission) except Exception as exception: ErrorHandler(self, self.logger).handle(exception) self.__stream_submissions()
def file_split(self, input_file, output_dir, lines_per_file, header): smallfile = None try: input_path, input_f = os.path.split(input_file) new_file_name = input_f.split(".")[0] new_file_ext = input_f.split(".")[1] file_types = self.property_reader.file_types() file_type_extn = file_types.split(",") if new_file_ext in file_type_extn: new_output_dir = output_dir + "/" + new_file_name success_dir = self.property_reader.success_dir() success_file = success_dir + "/" + input_f self.futil.create_dir(new_output_dir) self.futil.create_dir(success_dir) filecount = 0 with open(input_file) as bigfile: for line_number, line in enumerate(bigfile): if line_number % lines_per_file == 0: if smallfile: smallfile.close() filecount = filecount + 1 small_filename = (new_file_name + '_{}.' + new_file_ext).format(filecount) smallfile = open( new_output_dir + "/" + small_filename, "w") if line_number % lines_per_file == 0: smallfile.write(header) if line_number > 0: smallfile.write(line) if smallfile: smallfile.close() self.futil.move_file(input_file, success_file) else: print("file extension not supported") except: failure_dir = self.property_reader.failure_dir() failure_file = failure_dir + "/" + input_f eh = ErrorHandler() eh.error_handle(new_output_dir, failure_file, input_file) pass
def __init__(self, file_name): self.symbol_table = Symbol_table() self.scanner = Scanner(file_name, self.symbol_table) self.error_handler = ErrorHandler(self.scanner) self.semantic_stack = Stack() self.last_token = None self.memory_manager = MemoryManager(start= 1000) self.semantic_analyzer = SemanticAnalyzer(semantic_stack=self.semantic_stack , memory_manager= self.memory_manager , symbol_table= self.symbol_table , error_handler= self.error_handler) self.code_generator = Code_generator(symbol_table=self.symbol_table, semantic_stack=self.semantic_stack, memory_manager=self.memory_manager) self.stack = [0] with open('parse_table.csv', 'r') as f: self.parse_table = [{k: v for k, v in row.items()} for row in csv.DictReader(f, skipinitialspace=True)] self.next_token = None self.token_history = []
def __build_consumer_dict(cls, environment): try: config = ConnectionConfig.connection_details return { 'bootstrap.servers': config['bootstrap.servers'][environment], 'group.id': config.get('group.id'), 'client.id': config.get('client.id'), 'enable.auto.commit': True if config.get('enable.auto.commit').lower() == 'true' else False, 'session.timeout.ms': int(config.get('session.timeout.ms')), 'default.topic.config': { 'auto.offset.reset': config['default.topic.config']['auto.offset.reset']}, 'security.protocol': config.get('security.protocol'), 'ssl.key.location': config['ssl'][environment]['ssl.key.location'], 'ssl.key.password': config['ssl'][environment]['ssl.key.password'], 'ssl.certificate.location': config['ssl'][environment]['ssl.certificate.location'], 'ssl.ca.location': config['ssl.ca.location'], 'enable.partition.eof': False if config.get('enable.partition.eof').lower() == 'false' else True, 'api.version.request': False if config.get('api.version.request').lower() == 'false' else True } except KeyError as e: raise ErrorHandler("Missing required key from main config file. Missing key: " + str(e))
def setContent(self, metaProvider, xsltFilePath): # load data xsltFile = QFile(xsltFilePath) xsltFile.open(QIODevice.ReadOnly) xslt = unicode(xsltFile.readAll()) xsltFile.close() src = metaProvider.getMetadata() # translate qry = QXmlQuery(QXmlQuery.XSLT20) self.handler = ErrorHandler(self.tr("Translation error")) qry.setMessageHandler(self.handler) qry.setFocus(src) qry.setQuery(xslt) result = qry.evaluateToString() #workaround, for PyQt < 4.8 #array = "" #buf = QBuffer(array) #buf.open(QIODevice.WriteOnly) #qry.evaluateTo(buf) #result = unicode(array) if result: #QXmlPattern not support CDATA section result = result.replace('&', '&') result = result.replace('>', '>') result = result.replace('<', '<') self.webView.setHtml(result) # QString.fromUtf8(result)) return True else: return False
from error_handler import ErrorHandler from input_reader import InputReader from output_writer import OutputWriter from trace_manager import TraceManager from trace_parser import TraceParser from threading import Thread error_handler = ErrorHandler() writer = OutputWriter(error_handler) trace_manager = TraceManager(writer) parser = TraceParser(error_handler, trace_manager) reader = InputReader(parser) print("Start parsing") clean_thread = Thread(target=trace_manager.clean_traces) clean_thread.start() reader.read()
def validate_params(cls, params): if len(params['queue_list']) == 0: raise ErrorHandler( "No valid queues selected for search, ensure queue names are in ALL CAPS" )
def main(): #keep the following lines close to the begining of main because laser is switched on until pin_out.value(1) pin_out1 = pyb.Pin('Y1', pyb.Pin.OUT_PP, pull=pyb.Pin.PULL_UP) pin_out1.value(not cfg.on_value_out_channel1) pin_out2 = pyb.Pin('Y3', pyb.Pin.OUT_PP, pull=pyb.Pin.PULL_UP) pin_out2.value(not cfg.on_value_out_channel2) #Open drain pins pin_out3 = pyb.Pin('Y12', pyb.Pin.OUT_OD) pin_out3.value(not cfg.on_value_out_channel3) pin_out4 = pyb.Pin('X2', pyb.Pin.OUT_OD) pin_out4.value(not cfg.on_value_out_channel4) #Amplitude modulation pins pin_out5 = pyb.Pin('X5', pyb.Pin.OUT_PP, pull=pyb.Pin.PULL_DOWN) pin_out5.value(not cfg.on_value_out_channel5) dac5 = pyb.DAC(1) dac5.write(not cfg.on_value_out_channel5) pin_out6 = pyb.Pin('X6', pyb.Pin.OUT_PP, pull=pyb.Pin.PULL_DOWN) pin_out6.value(not cfg.on_value_out_channel6) dac6 = pyb.DAC(2) dac6.write(not cfg.on_value_out_channel6) pin_outLED = pyb.LED(4) use_wo_server = False global trigger_received serial_port = USB_Port() pkt = Packet(serial_port) armedLED = pyb.LED(3) #indicates when the system is waiting for a trigger triggerLED = pyb.LED( 2) #indicates when the system is delivering a sequence try: file_paths = [ cfg.library_path + '/' + s for s in ospath.listdir_nohidden(cfg.library_path) ] except OSError: #if path does not exist listdir raises an OSError try: file_paths = [ '/sd/sequence_library/' + s for s in ospath.listdir_nohidden('/sd/sequence_library/') ] except OSError: try: file_paths = [ '/flash/sequence_library/' + s for s in ospath.listdir_nohidden('/flash/sequence_library/') ] except OSError: file_paths = [] sw = pyb.Switch() pyb.LED(2).on() pyb.LED(3).on() pyb.LED(4).on() #try to connect to server answer = None active = 0 debounce_time = 20 double_click_time = 400 send_repetition = 1000 #Generally 1sec should be enough for the computer to answer. reps = 0 first_push_time = 0 while not use_wo_server or pyb.elapsed_millis( first_push_time) < double_click_time: reps += 1 if reps % send_repetition == 0: pkt.send(pkt.INS_check_for_sequences_on_server) answer = pkt.receive(time_out=1) if answer is not None: break if sw() == True: active += 1 else: active = 0 continue if active == debounce_time: if first_push_time == 0: first_push_time = pyb.millis() use_wo_server = True elif pyb.elapsed_millis(first_push_time) < double_click_time: open('/flash/bootincopymode', 'a').close() pyb.hard_reset() pyb.LED(2).off() pyb.LED(3).off() pyb.LED(4).off() if answer == pkt.ANS_yes: answer = pkt.ANS_no if len(file_paths) >= 1: pkt.send(pkt.INS_ask_user) answer = pkt.receive() if answer == pkt.ANS_yes or len(file_paths) == 0: pkt.send(pkt.INS_send_sequences) path = '' if ospath.exists('/sd'): path = '/sd/sequence_library' elif ospath.exists('1:'): path = '1:/sequence_library' #older versions of the pyboard use 0:/ and 1:/ instead of /flash and /sd elif ospath.exists('/flash'): path = '/flash/sequence_library' elif ospath.exists('0:'): path = '0:/sequence_library' if not ospath.exists(path): uos.mkdir(path) for s in uos.listdir(path): uos.remove(path + '/' + s) sequence_idx = 0 rcvd_pkt = pkt.receive() while type(rcvd_pkt) == list: with open(path + '/sequence' + str(sequence_idx) + '.tsv', 'w+') as fp: fp.write(tsv.dumps(rcvd_pkt)) rcvd_pkt = pkt.receive() sequence_idx += 1 file_paths = [path + '/' + s for s in uos.listdir(path)] elif len(file_paths) == 0: pkt.send( 'Error: No sequences found! You can generate sequences using COSgen.' ) raise ValueError( 'No sequences found on pyboard or server. Copy sequences to the sd card and specify the path in "config.py".' ) storage_path = '' #path to folder where delivered sequences are stored if not connected to client software on server delivered_sequence_idx = 0 #index for naming the sequence files in storage_path if use_wo_server: if ospath.exists('/sd'): if not ospath.exists('/sd/delivered_sequences'): uos.mkdir('/sd/delivered_sequences') path = '/sd/delivered_sequences/sequences' elif ospath.exists('1:'): if not ospath.exists('1:/delivered_sequences'): uos.mkdir('1:/delivered_sequences') path = '1:/delivered_sequences/sequences' elif ospath.exists('/flash'): if not ospath.exists('/flash/delivered_sequences'): uos.mkdir('/flash/delivered_sequences') path = '/flash/delivered_sequences/sequences' elif ospath.exists('0:'): if not ospath.exists('0:/delivered_sequences'): uos.mkdir('0:/delivered_sequences') path = '0:/delivered_sequences/sequences' idx = 0 while ospath.exists(path + str(idx)): idx += 1 path = path + str(idx) uos.mkdir(path) storage_path = path eh = ErrorHandler(use_wo_server, pkt, storage_path) if cfg.accuracy == 'us': ticks = utime.ticks_us #Function for utime.measurment sleep = utime.sleep_us #Corresponding sleep function for ticks conversion_factor = 1000000 #converts seconds to the unit specified in cfg.accuracy elif cfg.accuracy == 'ms': ticks = utime.ticks_ms sleep = utime.sleep_ms conversion_factor = 1000 tmax = int(utime.ticks_add(0, -1) / 2) extint = pyb.ExtInt('X1', pyb.ExtInt.IRQ_FALLING, pyb.Pin.PULL_DOWN, callback_trigger) extint.disable() num_seq = len(file_paths) pkt.send('Size of sequence library: {0}'.format(num_seq)) while True: seq_index = random.randrange(num_seq) with open(file_paths[seq_index]) as f: seq = tsv.load(f) pkt.send('Current sequence:\n' + tsv.dumps(seq)) num_of_events = len(seq) - 1 range_of_events = range(num_of_events - 1) onset_column = seq[0].index('onset') frequency_column = seq[0].index('frequency') duration_column = seq[0].index('duration') pulse_width_column = seq[0].index('pulse_width') out_channel_column = seq[0].index('out_channel') amplitude_column = seq[0].index('amplitude') T = [int(1. / seq[1][frequency_column] * conversion_factor)] onset = [int(seq[1][onset_column] * conversion_factor)] onset_sleep = [onset[0] - onset[0] % tmax] num_pulses = [ round(seq[1][duration_column] * conversion_factor / T[0]) ] pulse_width = [int(seq[1][pulse_width_column] * conversion_factor)] pulse_sleep = [pulse_width[0] - pulse_width[0] % tmax] if seq[1][out_channel_column] == 1: pin_out_func = [pin_out1.value] amplitude = [1] on_value = [cfg.on_value_out_channel1] elif seq[1][out_channel_column] == 2: pin_out_func = [pin_out2.value] amplitude = [1] on_value = [cfg.on_value_out_channel2] elif seq[1][out_channel_column] == 3: pin_out_func = [pin_out3.value] amplitude = [1] on_value = [cfg.on_value_out_channel3] elif seq[1][out_channel_column] == 4: pin_out_func = [pin_out4.value] amplitude = [1] on_value = [cfg.on_value_out_channel4] elif seq[1][out_channel_column] == 5: pin_out_func = [dac5.write] amplitude = [int(seq[1][amplitude_column] * 255)] on_value = [cfg.on_value_out_channel5] elif seq[1][out_channel_column] == 6: pin_out_func = [dac6.write] amplitude = [int(seq[1][amplitude_column] * 255)] on_value = [cfg.on_value_out_channel6] else: raise SequenceError( 'Invalide sequence {0}. Unrecognized out channel {1}.\n'. format(file_paths[seq_index], seq[1][out_channel_column])) if T[0] < seq[1][pulse_width_column] * conversion_factor: raise SequenceError( "Invalid sequence {0}. Period is smaller than pulse width.\n". format(file_paths[seq_index])) for i in range(2, num_of_events): T.append(int(1. / seq[i][frequency_column] * conversion_factor)) onset.append(int(seq[i][onset_column] * conversion_factor)) onset_sleep.append(onset[i - 1] - onset[i - 2] - (onset[i - 1] - onset[i - 2]) % tmax) num_pulses.append( round(seq[i][duration_column] * conversion_factor / T[i - 1])) pulse_width.append( int(seq[i][pulse_width_column] * conversion_factor)) pulse_sleep.append(pulse_width[i - 1] - pulse_width[i - 1] % tmax) if seq[i][out_channel_column] == 1: pin_out_func.append(pin_out1.value) amplitude.append(1) on_value.append(cfg.on_value_out_channel1) elif seq[i][out_channel_column] == 2: pin_out_func.append(pin_out2.value) amplitude.append(1) on_value.append(cfg.on_value_out_channel2) elif seq[i][out_channel_column] == 3: pin_out_func.append(pin_out3.value) amplitude.append(1) on_value.append(cfg.on_value_out_channel3) elif seq[i][out_channel_column] == 4: pin_out_func.append(pin_out4.value) amplitude.append(1) on_value.append(cfg.on_value_out_channel4) elif seq[i][out_channel_column] == 5: pin_out_func.append(dac5.write) amplitude.append(int(seq[i][amplitude_column] * 255)) on_value.append(cfg.on_value_out_channel5) elif seq[i][out_channel_column] == 6: pin_out_func.append(dac6.write) amplitude.append(int(seq[i][amplitude_column] * 255)) on_value.append(cfg.on_value_out_channel6) else: raise SequenceError( 'Invalide sequence {0}. Unrecognized out channel {1}.\n'. format(file_paths[seq_index], seq[i][out_channel_column])) if T[i - 1] < seq[i][pulse_width_column] * conversion_factor: raise SequenceError( "Invalid sequence {0}. Period is smaller than pulse width.\n" .format(file_paths[seq_index])) pkt.send('Ready to be armed!') trigger_received = False sw.callback(None) active = 0 while active < 20: if sw() == True: active += 1 else: active = 0 pyb.delay(1) pyb.delay(200) armedLED.on() pkt.send('System armed!') sw.callback(callback_trigger2 ) #for test purposes the switch can be used to trigger extint.enable() while not trigger_received: utime.sleep_us(1) start_ticks = ticks() triggerLED.on() armedLED.off() extint.disable() pkt.send('Trigger received!') for i in range_of_events: sleep(onset_sleep[i]) scheduled_time = utime.ticks_add(start_ticks, onset[i]) pulse = 0 while pulse < num_pulses[i]: if utime.ticks_diff(ticks(), scheduled_time) < 0: sleep(utime.ticks_diff(scheduled_time, ticks())) deliver_pulse(pin_out_func[i], amplitude[i], pulse_width[i], pulse_sleep[i], pin_outLED, eh, ticks, sleep, on_value[i]) elif utime.ticks_diff(ticks(), scheduled_time) == 0: deliver_pulse(pin_out_func[i], amplitude[i], pulse_width[i], pulse_sleep[i], pin_outLED, eh, ticks, sleep, on_value[i]) elif utime.ticks_diff(ticks(), scheduled_time) > 0: now = ticks() deliver_pulse(pin_out_func[i], amplitude[i], pulse_width[i], pulse_sleep[i], pin_outLED, eh, ticks, sleep, on_value[i]) eh.send( "Missed scheduled onset time of pulse in event {0} by {1} {2} " .format(i, utime.ticks_diff(now, scheduled_time), cfg.accuracy)) scheduled_time = utime.ticks_add(scheduled_time, T[i]) pulse += 1 if not use_wo_server: pkt.send(seq) else: eh.save() with open( storage_path + '/sequence' + str(delivered_sequence_idx) + '.tsv', 'w+') as fp: fp.write(tsv.dumps(seq)) delivered_sequence_idx += 1 triggerLED.off()
def search_for_msgs(self, request_params, topic, message_type): """ Method handles browsing of request topic's partitions and passes messages to given message type's parser. Generic parsers (json and avro) and provided below. You may add additional parsers to fit your needs :param request_params: dict() :param topic: string, name of topic being search :param message_type: string, type of messages being polled and parses :return: list() of all messages in given topic that include request search_string """ messages = [] partitions = self.__retrieve_partition_data(topic) for k, partition in partitions.items(): self.consumer.assign([TopicPartition(topic, partition.id)]) while True: try: msg = self.consumer.poll(.5) if msg is None: continue elif not msg.error(): parsed_msg = None # Add more message types here if desired. out of box only provided json and avro types if message_type == 'json': parsed_msg = self.__parse_json_msg( request_params, msg) elif message_type == 'avro': parsed_msg = self.__parse_avro_msg( request_params, msg) if parsed_msg: messages.insert(0, parsed_msg) if request_params.get( self.param_include_delimiter_key ) == 'true': messages.insert( 1, "##############################################################" ) messages.insert( 2, "#################### MESSAGE SEPARATOR #####################" ) messages.insert( 3, "##############################################################" ) elif msg.error(): # If Kafka end of partition error received, # unassign consumer from partition and continue iteration. if msg.error().code() == KafkaError._PARTITION_EOF: self.consumer.unassign() break else: # currently not processing message errors, other than KafkaError.PARTITION_EOF. # If desired, add this logic here. error_msg_received = msg.error() continue except ErrorHandler as e: raise ErrorHandler("Error parsing message. " + str(e)) # Ignore generic exceptions, as there may be malformed messages in topic. # If you would like an exception thrown please add here. except Exception as e: continue return messages
def __init__(self, kp=7.0, Ti=155.0, Td=0.001): self._kp = kp self._Ti = Ti self._Td = Td self.error_handler_inst = ErrorHandler() self._control_signal = 0.0
def initialize_kafka_consumer(cls, environment): try: settings = cls.__build_consumer_dict(environment) return Consumer(settings) except Exception as e: raise ErrorHandler("Error initializing Kafka Consumer: " + str(e))
def _error_handler_default(self): eh = ErrorHandler() eh.logger = self return eh