def _add_writer(self): for pa_device in self.pa_devices: self.ptv["name"] = pa_device self.config = self.ptv.to_config() writer = self._create_writer( self.stitcher.project_manager.panorama, self.stitcher.project_manager.controller, self.config, pa_device) self.shared_writer = vs.writerSharedPtr(writer.release()) self.connect_writer_events(self.shared_writer) self.shared_video = vs.videoWriterSharedPtr(self.shared_writer) shared_audio = vs.audioWriterSharedPtr(self.shared_writer) self.has_audio = True if self.shared_video is not None and not self.stitcher.stitch_output.addWriter( self.shared_video): raise errors.InternalError( "Cannot add video writer to stitcher") if shared_audio is not None and not self.stitcher.project_manager.controller.addAudioOutput( shared_audio): raise errors.InternalError( "Cannot add audio writer to stitcher") self.timer.start() gc.collect()
def _add_writer(self): if "filename" not in self.ptv: raise errors.OutputError( 'Configuration preset has no filename field') self.writer_name = str(self.ptv["filename"]) self.config = self.ptv.to_config() writer = self._create_writer(self.stitcher.project_manager.panorama, self.stitcher.project_manager.controller, self.config, self.writer_name) self.shared_writer = vs.writerSharedPtr(writer.release()) self.connect_writer_events(self.shared_writer) self.shared_video = vs.videoWriterSharedPtr(self.shared_writer) shared_audio = vs.audioWriterSharedPtr(self.shared_writer) self.has_audio = shared_audio is not None if self.shared_video is not None and not self.stitcher.stitch_output.addWriter( self.shared_video): raise errors.InternalError("Cannot add video writer to stitcher") if shared_audio is not None and not self.stitcher.project_manager.controller.addAudioOutput( shared_audio): raise errors.InternalError("Cannot add audio writer to stitcher") self.timer.start() gc.collect()
def executemany(self, operation, seq_params): """Execute the given operation multiple times The executemany() method will execute the operation iterating over the list of parameters in seq_params. Example: Inserting 3 new employees and their phone number data = [ ('Jane','555-001'), ('Joe', '555-001'), ('John', '555-003') ] stmt = "INSERT INTO employees (name, phone) VALUES ('%s','%s')" cursor.executemany(stmt, data) INSERT statements are optimized by batching the data, that is using the MySQL multiple rows syntax. Results are discarded. If they are needed, consider looping over data using the execute() method. """ if not operation: return if self._have_unread_result(): raise errors.InternalError("Unread result found.") elif len(RE_SQL_SPLIT_STMTS.split(operation)) > 1: raise errors.InternalError( "executemany() does not support multiple statements") # Optimize INSERTs by batching them if re.match(RE_SQL_INSERT_STMT, operation): opnocom = re.sub(RE_SQL_COMMENT, '', operation) m = re.search(RE_SQL_INSERT_VALUES, opnocom) fmt = m.group(1) values = [] for params in seq_params: values.append(fmt % self._process_params(params)) operation = operation.replace(m.group(1), ','.join(values), 1) return self.execute(operation) rowcnt = 0 try: for params in seq_params: self.execute(operation, params) if self.with_rows and self._have_unread_result(): self.fetchall() rowcnt += self._rowcount except (ValueError, TypeError) as err: raise errors.InterfaceError("Failed executing the operation; %s" % err) except: # Raise whatever execute() raises raise self._rowcount = rowcnt
def index(event, context): """ taskListの一覧を返す """ try: logger.info(event) try: task_lists = TaskListModel.scan(TaskListModel.deleteFlag == False) except ScanError as e: logger.exception(e) raise errors.InternalError('Internal server error') return { 'statusCode': 200, 'headers': { 'Access-Control-Allow-Origin': '*', 'Content-Type': 'application/json' }, 'body': json.dumps({ 'statusCode': 200, 'taskLists': [dict(task_list) for task_list in task_lists] }) } except errors.InternalError as e: logger.exception(e) return build_response(e, 500)
def executemany(self, operation, seq_params): """Loops over seq_params and calls execute() INSERT statements are optimized by batching the data, that is using the MySQL multiple rows syntax. """ if not operation: return 0 if self.db().unread_result is True: raise errors.InternalError("Unread result found.") # Optimize INSERTs by batching them if re.match(RE_SQL_INSERT_STMT,operation): opnocom = re.sub(RE_SQL_COMMENT,'',operation) m = re.search(RE_SQL_INSERT_VALUES,opnocom) fmt = m.group(1) values = [] for params in seq_params: values.append(fmt % self._process_params(params)) operation = operation.replace(m.group(1),','.join(values),1) self.execute(operation) else: rowcnt = 0 try: for params in seq_params: self.execute(operation, params) if self._have_result: self.fetchall() rowcnt += self.rowcount except (ValueError,TypeError), e: raise errors.InterfaceError( "Failed executing the operation; %s" % e) except:
def cmd_query_iter(self, statements): """Send one or more statements to the MySQL server Similar to the cmd_query method, but instead returns a generator object to iterate through results. It sends the statements to the MySQL server and through the iterator you can get the results. statement = 'SELECT 1; INSERT INTO t1 VALUES (); SELECT 2' for result in cnx.cmd_query(statement, iterate=True): if 'columns' in result: columns = result['columns'] rows = cnx.get_rows() else: # do something useful with INSERT result Returns a generator. """ # Handle the first query result yield self._handle_result(self._send_cmd(ServerCmd.QUERY, statements)) # Handle next results, if any while self._have_next_result: if self.unread_result: raise errors.InternalError("Unread result found.") else: result = self._handle_result(self._socket.recv()) yield result
def _send_data(self, fp, send_empty_packet=False): """Send data to the MySQL server This method accepts a file-like object and sends its data as is to the MySQL server. If the send_empty_packet is True, it will send an extra empty package (for example when using LOAD LOCAL DATA INFILE). Returns a MySQL packet. """ if self.unread_result: raise errors.InternalError("Unread result found.") if not hasattr(fp, 'read'): raise ValueError("expecting a file-like object") try: buf = fp.read(4096) while buf: self._socket.send(buf) buf = fp.read(4096) except AttributeError: raise errors.OperationalError("MySQL Connection not available.") if send_empty_packet: try: self._socket.send('') except AttributeError: raise errors.OperationalError( "MySQL Connection not available.") return self._socket.recv()
def execute(self, operation, params=None, multi=False): """Executes the given operation Executes the given operation substituting any markers with the given parameters. For example, getting all rows where id is 5: cursor.execute("SELECT * FROM t1 WHERE id = %s", (5,)) The multi argument should be set to True when executing multiple statements in one operation. If not set and multiple results are found, an InterfaceError will be raised. If warnings where generated, and connection.get_warnings is True, then self._warnings will be a list containing these warnings. Returns an iterator when multi is True, otherwise None. """ if not operation: return if self._have_unread_result(): raise errors.InternalError("Unread result found.") self._reset_result() stmt = '' try: if isinstance(operation, unicode): operation = operation.encode(self._connection.charset) except (UnicodeDecodeError, UnicodeEncodeError), e: raise errors.ProgrammingError(str(e))
def get_drive_info(self, parameters): """Returns the storage drive information Returns: - ``InternalError`` - Structure:: { 'results': { 'used': string, 'percent': float, 'free': string, 'label': string, 'fs': string, 'device': string, 'mountpoint': string, 'total': string } } Note: Calling this function can create some overhead """ try: drive = parameters['drive'] except: raise errors.InvalidParameter('No specified drive') mp_stats = self.monitor.drive_info(drive) if mp_stats is None: raise errors.InternalError( 'No information found for drive {}'.format(parameters))
def _remove_writer(self, writer_name): """Stops the stream """ if self.has_audio: success = self.stitcher.project_manager.controller.removeAudioOutput( writer_name) if not success: raise errors.InternalError( "Cannot remove audio writer {}".format(writer_name)) success = self.stitcher.stitch_output.removeWriterNoGIL(writer_name) if not success: raise errors.InternalError("Cannot remove video writer") self.shared_writer = None self.shared_video = None self.timer.reset() gc.collect() self.flush_writer_events()
def _validateTable(self): """ Checks that the table is internally consistent Verify that there is at least one column """ if len(self.getColumns()) < 1: raise er.InternalError("Table %s has no columns." % self._name) # Verify that all columns have the same number of cells try: name_column = [c for c in self.getChildren() if c.getName(is_global_name=False) == NAME_COLUMN_STR][0] except Exception as e: import pdb; pdb.set_trace() if name_column is None: import pdb; pdb.set_trace() num_rows = self.numRows() for column in self.getColumns(): if column.numCells() != num_rows: import pdb; pdb.set_trace() msg = "In Table %s, Column %s differs in its number of rows." \ % (self.getName(), column.getName()) raise er.InternalError(msg) # Verify that the first Column is the Name Column if self.getChildAtPosition(0).getName(is_global_name=False) != NAME_COLUMN_STR: msg = "In Table %s, first column is not 'row' column" % self.getName() raise er.InternalError(msg) # Verify that names are unique if self.validateTree() is not None: raise RuntimeError(self.validateTree()) # Verify the sequence of row names for nrow in range(self.numRows()): expected_row_name = Table._rowNameFromIndex(nrow) actual_row_name = \ self.getChildAtPosition(NAME_COLUMN_IDX).getCells()[nrow] if actual_row_name != expected_row_name: import pdb; pdb.set_trace() msg = "In Table %s, invalid row name at index %d: %s" % \ (self.getName(), nrow, actual_row_name) raise er.InternalError(msg) # Verify that the name columns are identical for column in self.getColumns(): if Table.isNameColumn(column): if not column.getCells() == name_column.getCells(): raise RuntimeError("%s is not a consistent name column" % column.getName())
def execute(self, operation, params=None, multi=False): """Executes the given operation Executes the given operation substituting any markers with the given parameters. For example, getting all rows where id is 5: cursor.execute("SELECT * FROM t1 WHERE id = %s", (5,)) The multi argument should be set to True when executing multiple statements in one operation. If not set and multiple results are found, an InterfaceError will be raised. If warnings where generated, and connection.get_warnings is True, then self._warnings will be a list containing these warnings. Returns an iterator when multi is True, otherwise None. """ if not operation: return if self._have_unread_result(): raise errors.InternalError("Unread result found.") self._reset_result() stmt = '' try: if isinstance(operation, unicode): operation = operation.encode(self._connection.charset) except (UnicodeDecodeError, UnicodeEncodeError) as e: raise errors.ProgrammingError(str(e)) if params is not None: try: stmt = operation % self._process_params(params) except TypeError: raise errors.ProgrammingError( "Wrong number of arguments during string formatting") else: stmt = operation if multi: self._executed = stmt self._executed_list = [] return self._execute_iter(self._connection.cmd_query_iter(stmt)) else: self._executed = stmt try: self._handle_result(self._connection.cmd_query(stmt)) except errors.InterfaceError as err: if self._connection._have_next_result: raise errors.InterfaceError( "Use multi=True when executing multiple statements") raise return None
def tasks(event, context): """ taskListに紐づくtask一覧の取得 """ logger.info(event) logger.info(context) try: logger.info(event) if not event['pathParameters']: raise errors.BadRequest('Bad request') task_list_id = event['pathParameters']['id'] # taskListが存在するか try: task_list = TaskListModel.get(task_list_id) except TaskListModel.DoesNotExist as e: logger.exception(e) raise errors.NotFound('The taskList does not exist') # tasksの取得 try: tasks = TaskModel.tasks_gsi_taskListId.query( task_list_id, TaskModel.deleteFlag == False ) except QueryError as e: logger.exception(e) raise errors.InternalError('Internal server error') return { 'statusCode': 200, 'headers': { 'Access-Control-Allow-Origin': '*', 'Content-Type': 'application/json' }, 'body': json.dumps( { 'statusCode': 200, 'taskList': task_list_id, 'tasks': [dict(task) for task in tasks] } ) } except errors.BadRequest as e: logger.exception(e) return build_response(e, 400) except errors.NotFound as e: logger.exception(e) return build_response(e, 404) except errors.InternalError as e: logger.exception(e) return build_response(e, 500)
def _start(self, profiling_time=0, preserve=False): # Todo I don't like that it's created differently from other outputs here, but for now I left it like this panorama = self.stitcher.project_manager.panorama self.writer = vs.Output_profiling(self.name, panorama.width, panorama.height, self.stitcher.project_manager.controller.getFrameRateFromInputController(), PROFILING_STITCH_FORMAT) if self.writer is None: raise errors.InternalError() self.shared_writer = vs.writerSharedPtr(self.writer.object()) self.shared_video = vs.videoWriterSharedPtr(self.shared_writer) self.has_audio = False if self.shared_video is not None and not self.stitcher.stitch_output.addWriter(self.shared_video): raise errors.InternalError("Cannot add profiling writer to stitcher") if profiling_time > 0: threading.Timer(profiling_time, self.t_stop).start() self.pid.cpu_percent(interval=None) #jump automatically from starting state to started state self.t_writer_ok()
def _execute_query(self, query): """Execute a query This method simply calles cmd_query() after checking for unread result. If there are still unread result, an errors.InterfaceError is raised. Otherwise whatever cmd_query() returns is returned. Returns a dict() """ if self._unread_result is True: raise errors.InternalError("Unread result found.") self.cmd_query(query)
def users(event, context): """ taskに所属するuser一覧を返す """ try: logger.info(event) if not event['pathParameters']: raise errors.BadRequest('Bad request') task_id = event['pathParameters']['id'] # taskの取得 try: task = TaskModel.get(task_id) except TaskModel.DoesNotExist: raise errors.NotFound('The task does not exist') if not task.userIds: task.userIds = [] # usersの取得 try: users = task.get_users() except UserModel.DoesNotExist as e: logger.exception(e) raise errors.InternalError('Internal server error') return { 'statusCode': 200, 'headers': { 'Access-Control-Allow-Origin': '*', 'Content-Type': 'application/json' }, 'body': json.dumps( { 'statusCode': 200, 'taskId': task_id, 'users': [dict(user) for user in users] } ) } except errors.BadRequest as e: logger.exception(e) return build_response(e, 400) except errors.NotFound as e: logger.exception(e) return build_response(e, 404) except errors.InternalError as e: logger.exception(e) return build_response(e, 500)
def cmd_statistics(self): """Send the statistics command to the MySQL Server This method sends the STATISTICS command to the MySQL server. The result is a dictionary with various statistical information. Returns a dict() """ if self.unread_result: raise errors.InternalError("Unread result found.") packet = self._protocol.make_command(ServerCmd.STATISTICS) self._socket.send(packet, 0) return self._protocol.parse_statistics(self._socket.recv())
def done_undone(event, context): try: logger.info(event) if not event['pathParameters']: raise errors.BadRequest('Bad request') task_id = event['pathParameters']['id'] # done or undone で ture or false if re.match('.*/done$', event['resource']): flag = True else: flag = False # taskを取得 try: task = TaskModel.get(task_id) except TaskModel.DoesNotExist: raise errors.NotFound('The task does not exist') # taskを更新 try: task.status_update(flag) except UpdateError as e: logger.exception(e) raise errors.InternalError('Internal server error') return { 'statusCode': 200, 'headers': { 'Access-Control-Allow-Origin': '*', 'Content-Type': 'application/json' }, 'body': json.dumps({ 'statusCode': 200, 'task': dict(task) }) } except errors.BadRequest as e: logger.exception(e) return build_response(e, 400) except errors.NotFound as e: logger.exception(e) return build_response(e, 404) except errors.InternalError as e: logger.exception(e) return build_response(e, 500)
def condition_to_tags(cond: Condition) -> List[str]: if cond is conditions.ALWAYS: return [] assert not isinstance(cond, conditions.BaseCondition) if isinstance(cond, conditions.Terminal): return [conditions.get_term(cond.name).expectations_info.tag] op, args = cond if op == 'or': return [tag for arg in args for tag in condition_to_tags(arg)] raise errors.InternalError( f"Unable to express condition in test expectations format: {cond}")
def cmd_quit(self): """Close the current connection with the server This method sends the QUIT command to the MySQL server, closing the current connection. Since the no response can be returned to the client, cmd_quit() will return the packet it send. Returns a str() """ if self.unread_result: raise errors.InternalError("Unread result found.") packet = self._protocol.make_command(ServerCmd.QUIT) self._socket.send(packet, 0) return packet
def create(event, context): """ taskListを作成 削除済みレコードは復活させない """ try: logger.info(event) # validation if not event['body']: raise errors.BadRequest('Bad request') body = json.loads(event['body']) validate_attributes(body) task_list = TaskListModel(str(uuid.uuid1()), name=body['name'], description=body['description']) # taskListの保存 try: task_list.save() except InvalidNameError as e: logger.exception(e) raise errors.BadRequest(str(e.with_traceback(sys.exc_info()[2]))) except InvalidDescriptionError as e: logger.exception(e) raise errors.BadRequest(str(e.with_traceback(sys.exc_info()[2]))) except PutError as e: logger.exception(e) raise errors.InternalError('Internal server error') return { 'statusCode': 200, 'headers': { 'Access-Control-Allow-Origin': '*', 'Content-Type': 'application/json' }, 'body': json.dumps({ 'statusCode': 200, 'taskList': dict(task_list) }) } except errors.BadRequest as e: logger.exception(e) return build_response(e, 400) except errors.InternalError as e: logger.exception(e) return build_response(e, 500)
def search_for_expectations(filename: str, test_name: str) -> str: # TODO: Is this ever not the case? If so we might need to just keep searching # upwards, directory by directory until we find a test expectations file # referencing this test. assert filename.endswith(test_name) expectations_dir = filename[:-len(test_name)] # TODO: I think ASan and some other conditions are handled via different # files. expectations_path = os.path.join(expectations_dir, 'TestExpectations') if os.path.exists(expectations_path): return expectations_path raise errors.InternalError( "Couldn't find TestExpectations file for test " + f"{test_name} " + f"(expected to find it at {expectations_path})")
def _stop(self): self.fps = vs.Output_getFps(self.writer.release()) self.writer = None logging.info("fps is %f:" % self.fps) logging.info("cpu_util is %d" % self.pid.cpu_percent(interval=None)) cuda = performance.getCudaInfo() logging.info("gpu_util is %d" % int(cuda['utilization.gpu'])) logging.info("enc_util is %s" % cuda['utilization.enc']) success = self.stitcher.stitch_output.removeWriterNoGIL(self.name) signal("profiling_stopping").send() if not success: raise errors.InternalError("Cannot remove writer") self.shared_video = None self.shared_writer = None gc.collect() #jump automatically from stopping state to stopped state self.t_writer_completed()
def _send_cmd(self, command, argument=None, packet_number=0): """Send a command to the MySQL server This method sends a command with an optional argument. Returns a MySQL packet """ if self.unread_result: raise errors.InternalError("Unread result found.") try: self._socket.send(self._protocol.make_command(command, argument), packet_number) except AttributeError: raise errors.OperationalError("MySQL Connection not available.") return self._socket.recv()
def get_rows(self, count=None): """Get all rows returned by the MySQL server This method gets all rows returned by the MySQL server after sending, for example, the query command. The result is a tuple consisting of a list of rows and the EOF packet. Returns a tuple() """ if not self.unread_result: raise errors.InternalError("No result set available.") rows = self._protocol.read_text_result(self._socket, count) if rows[-1] is not None: self._toggle_have_next_result(rows[-1]['status_flag']) self.unread_result = False return rows
def delete(event, context): """ delteFlagをfalseに変更 """ try: logger.info(event) if not event['pathParameters']: raise errors.BadRequest('Bad request') task_id = event['pathParameters']['id'] # taskの取得 try: task = TaskModel.get(task_id) except TaskModel.DoesNotExist: raise errors.NotFound('The task does not exist') # taskの削除 try: task.logic_delete() except UpdateError as e: logger.exception(e) raise errors.InternalError('Internal server error') return { 'statusCode': 200, 'headers': { 'Access-Control-Allow-Origin': '*', 'Content-Type': 'application/json' }, 'body': json.dumps({'statusCode': 200}) } except errors.BadRequest as e: logger.exception(e) return build_response(e, 400) except errors.NotFound as e: logger.exception(e) return build_response(e, 404) except errors.InternalError as e: logger.exception(e) return build_response(e, 500)
def _create_writer(self, panorama, controller, config, writer_name): """Creates an output writer to register to the stitcher """ sampling_rate = self.ptv.get("sampling_rate", 0) sample_format = str(self.ptv.get("sample_format", "")) channel_layout = str(self.ptv.get("channel_layout", "")) writer = vs.Output_createNoGIL( config, writer_name, panorama.width, panorama.height, controller.getFrameRateFromInputController(), sampling_rate, sample_format, channel_layout) if not writer.status().ok(): raise errors.InternalError( "Cannot create writer for output {}: {}, {}".format( self.writer_name, str(writer.status().getOrigin()), writer.status().getErrorMessage())) return writer
def execute(self, operation, params=None): """ Executes the given operation. The parameters given through params are used to substitute %%s in the operation string. For example, getting all rows where id is 5: cursor.execute("SELECT * FROM t1 WHERE id = %s", (5,)) If warnings where generated, and db.get_warnings is True, then self._warnings will be a list containing these warnings. Raises exceptions when any error happens. """ if not operation: return 0 if self.db().unread_result is True: raise errors.InternalError("Unread result found.") self._reset_result() stmt = '' try: if isinstance(operation, unicode): operation = operation.encode(self.db().charset_name) if params is not None: try: stmt = operation % self._process_params(params) except TypeError: raise errors.ProgrammingError( "Wrong number of arguments during string formatting") else: stmt = operation res = self.db().protocol.cmd_query(stmt) self._handle_result(res) except (UnicodeDecodeError,UnicodeEncodeError), e: raise errors.ProgrammingError(str(e))
def cmd_change_user(self, username='', password='', database='', charset=33): """Change the current logged in user This method allows to change the current logged in user information. The result is a dictionary with OK packet information. Returns a dict() """ if self.unread_result: raise errors.InternalError("Unread result found.") packet = self._protocol.make_change_user( seed=self._handshake['scramble'], username=username, password=password, database=database, charset=charset, client_flags=self._client_flags) self._socket.send(packet, 0) return self._handle_ok(self._socket.recv())
def _execute_query(self, query): if self.unread_result is True: raise errors.InternalError("Unread result found.") self.protocol.cmd_query(query)