diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index f5b9620..7d76572 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -13,44 +13,20 @@ variables: - apt-get update > /dev/null - apt-get install -y python3-pip > /dev/null - apt-get install -y --no-install-recommends ./guppy.deb > /dev/null - - python3 -m pip install -q -r requirements.txt -r development.txt + - python3 -m pip install ${PIP_OPTIONS} -q -r requirements.txt -r development.txt - python3 setup.py develop script: - guppy_basecall_server -p 5555 -c ${CONFIG}.cfg --post_out -l /tmp/log ${GUPPY_ARGS} & - sleep 15 - make test - - guppy_basecaller -c ${CONFIG}.cfg -p 5555 -s . -i tests/reads/testdata/ + - guppy_basecaller -r -c ${CONFIG}.cfg -p 5555 -s . -i tests/reads/testdata/ tags: - nvidia-docker -cpu:guppy:3.4.1: +cpu:guppy:4.0.11: <<: *test -cpu:guppy:3.4.5: - <<: *test - -cpu:guppy:3.5.2: - <<: *test - -cpu:guppy:3.6.0: - <<: *test - -gpu:guppy:3.4.1: - <<: *test - variables: - GUPPY_ARGS: "-x cuda:0" - -gpu:guppy:3.4.5: - <<: *test - variables: - GUPPY_ARGS: "-x cuda:0" - -gpu:guppy:3.5.2: - <<: *test - variables: - GUPPY_ARGS: "-x cuda:0" - -gpu:guppy:3.6.0: +gpu:guppy:4.0.11: <<: *test variables: GUPPY_ARGS: "-x cuda:0" diff --git a/examples/pyguppyclient b/examples/pyguppyclient index 02fa33b..91a8a66 100755 --- a/examples/pyguppyclient +++ b/examples/pyguppyclient @@ -16,7 +16,7 @@ def process(read, called, lock): Example callback function for the Caller that writes fastq files """ with lock: - write_fastq(read.read_id, called.seq, called.qual, sys.stdout) + write_fastq(read['metadata']['read_id'], called.seq, called.qual, sys.stdout) def main(args): diff --git a/pyguppyclient/caller.py b/pyguppyclient/caller.py index afca105..c27b148 100644 --- a/pyguppyclient/caller.py +++ b/pyguppyclient/caller.py @@ -86,7 +86,7 @@ def basecall_batch(self, files): done += 1 read, called = res - samples += read.total_samples - called.trimmed_samples + samples += called.trimmed_samples if self.callback: self.callback(read, called, self.lock) diff --git a/pyguppyclient/client.py b/pyguppyclient/client.py index f2b2dcb..aa40355 100644 --- a/pyguppyclient/client.py +++ b/pyguppyclient/client.py @@ -2,6 +2,7 @@ Guppy Client """ +from collections import deque import time import asyncio import logging @@ -14,7 +15,8 @@ from pyguppyclient.utils import parse_config from pyguppyclient.ipc import simple_request, simple_response from pyguppyclient.ipc import SimpleRequestType, SimpleReplyType -from pyguppyclient.decode import Config, raw_read_message +from pyguppyclient.decode import Config, PROTO_VERSION, pcl_called_read +from pyguppy_client_lib.client_lib import GuppyClient as PCLClient logger = logging.getLogger("pyguppyclient") @@ -34,6 +36,8 @@ def __init__(self, config_name, host="localhost", port=5555, timeout=0.1, retrie self.socket.set(RCVTIMEO, 100) self.socket.connect("tcp://%s:%s" % (host, port)) self.client_id = 0 + self.pcl_client = PCLClient("%s:%s" % (host, port), self.config_name) + _init_pcl_client(self.pcl_client) def __enter__(self): self.connect() @@ -66,23 +70,19 @@ def recv(self): return message def connect(self): - attempts = 0 - while attempts < self.retries: - attempts += 1 - try: - config = self._load_config(self.config_name) - res = self.send(SimpleRequestType.CONNECT, data=0, text=config.name) - self.client_id = res.Data() - return res - except ConnectionError: - time.sleep(self.timeout) - - raise ConnectionError( - "Connect with '{}' failed after {} attempts".format(self.config_name, attempts) - ) + result = self.pcl_client.result + self.pcl_client.clear_error_state() + ret = self.pcl_client.connect() + if ret == result.already_connected: + pass + elif ret != result.success: + raise ConnectionError( + "Connect with '{}' failed: {}".format(self.config_name, + self.pcl_client.get_error_message()) + ) def disconnect(self): - return self.send(SimpleRequestType.DISCONNECT) + return self.pcl_client.disconnect() def shut_down(self): return self.send(SimpleRequestType.TERMINATE) @@ -91,42 +91,29 @@ def get_configs(self): res = self.send(SimpleRequestType.GET_CONFIGS) return [res.Configs(i) for i in range(res.ConfigsLength())] - def _load_config(self, config_name): - loaded_configs = {Config(c).name: Config(c) for c in self.get_configs()} - if config_name not in loaded_configs: - response = self.send(SimpleRequestType.LOAD_CONFIG, text=config_name) - if response.Type() == SimpleReplyType.INVALID_CONFIG: - raise ValueError("'%s' could not be loaded by the server" % config_name) - n = 0 - while n <= self.retries: - n += 1 - loaded_configs = {Config(c).name: Config(c) for c in self.get_configs()} - if config_name in loaded_configs: - break - time.sleep(self.timeout) - else: - raise TimeoutError("Failed to load config '{}' after {} attempts".format(config_name, n)) - - return loaded_configs[config_name] - def get_statistics(self): return self.send(SimpleRequestType.GET_STATISTICS) def pass_read(self, read): - return self.send(raw_read_message( - self.client_id, - read.read_tag, - read.read_id, - read.daq_offset, - read.daq_scaling, - read.signal, - ), simple=False) + read_dict = { + "read_tag": int(read.read_tag), + "read_id": str(read.read_id), + "daq_offset": float(read.daq_offset), + "daq_scaling": float(read.daq_scaling), + "raw_data": read.signal, + } + return self.pcl_client.pass_read(read_dict) class GuppyBasecallerClient(GuppyClientBase): """ Blocking Guppy Basecall Client """ + + def __init__(self, **kwargs): + super().__init__(**kwargs) + self.read_cache = deque() + def basecall(self, read, state=False, trace=False): """ Basecall a `ReadData` object and get a `CalledReadData` object @@ -140,7 +127,7 @@ def basecall(self, read, state=False, trace=False): n += 1 result = self._get_called_read(state=state, trace=trace) if result is not None: - return result[1] + return result time.sleep(self.timeout) raise TimeoutError( @@ -151,17 +138,15 @@ def _get_called_read(self, state=False, trace=False): """ Get the `CalledReadData` object back from the server """ - flag = (not trace) ^ state << 1 - res = self.send(SimpleRequestType.GET_FIRST_CALLED_BLOCK, data=flag) - if res is None: - return - - read, called = res - while not called.complete: - _, block = self.send(SimpleRequestType.GET_NEXT_CALLED_BLOCK, data=read.read_tag) - called += block + if len(self.read_cache) == 0: + reads, _ = self.pcl_client.get_completed_reads() + self.read_cache.extend(reads) - return read, called + try: + read = self.read_cache.pop() + return read, pcl_called_read(read) + except IndexError: + return class GuppyAsyncClientBase: @@ -178,9 +163,11 @@ def __init__(self, config=None, host='localhost', port=5555, sleep=0): self.socket.set(zmq.LINGER, 0) self.socket.set(zmq.RCVTIMEO, 500) self.client_id = 0 + self.pcl_client = PCLClient("%s:%s" % (host, port), self.config_name) + _init_pcl_client(self.pcl_client) async def __aenter__(self): - await self.connect(self.config) + await self.connect() return self async def __aexit__(self, exception_type, exception_value, traceback): @@ -202,12 +189,19 @@ async def send(self, message, data=None, text=None, simple=True): return response async def connect(self, config): - response = await self.send(SimpleRequestType.CONNECT, data=0, text=config) - await asyncio.sleep(self.sleep) - self.client_id = response.Data() + result = self.pcl_client.result + await self.pcl_client.clear_error_state() + ret = await self.pcl_client.connect() + if ret == result.already_connected: + pass + elif ret != result.success: + raise ConnectionError( + "Connect with '{}' failed: {}".format(self.config_name, + self.pcl_client.get_error_message()) + ) async def disconnect(self): - await self.send(SimpleRequestType.DISCONNECT) + await self.pcl_client.disconnect() async def get_configs(self): res = await self.send(SimpleRequestType.GET_CONFIGS) @@ -218,25 +212,42 @@ async def get_statistics(self): return stats async def pass_read(self, read): - return await self.send(raw_read_message( - self.client_id, - read.read_tag, - read.read_id, - read.daq_offset, - read.daq_scaling, - read.signal, - ), simple=False - ) + read_dict = { + "read_tag": int(read.read_tag), + "read_id": str(read.read_id), + "daq_offset": float(read.daq_offset), + "daq_scaling": float(read.daq_scaling), + "raw_data": read.signal, + } + return await self.pcl_client.pass_read(read_dict) async def get_called_read(self, trace=False, state=False): - flag = (not trace) ^ state << 1 - res = await self.send(SimpleRequestType.GET_FIRST_CALLED_BLOCK, data=flag) + """ + Get the `CalledReadData` object back from the server + """ + if len(self.read_cache) == 0: + reads, _ = await self.pcl_client.get_completed_reads() + self.read_cache.extend(reads) - if not res: return + try: + read = self.read_cache.pop() + return read, pcl_called_read(read) + except IndexError: + return - read, called = res - while not called.complete: - _, block = await self.send(SimpleRequestType.GET_NEXT_CALLED_BLOCK, data=read.read_tag) - called += block - return res +def _init_pcl_client(pcl_client): + """ + Perform basic initialisation of a pyguppy_client_lib client. + """ + pcl_proto_major_version = pcl_client.get_protocol_version()[0] + if pcl_proto_major_version != PROTO_VERSION[0]: + raise Exception("pyguppy_client_lib IPC major version {} does not " + "match pyguppyclient IPC major version {} -- " + "install correct version of " + "pyguppy_client_lib.".format(pcl_proto_major_version, + PROTO_VERSION[0])) + params = { + "max_reads_queued": 10000 # Number of reads the pcl_client can hold + } + pcl_client.set_params(params) diff --git a/pyguppyclient/decode.py b/pyguppyclient/decode.py index 5b1c20c..577f717 100644 --- a/pyguppyclient/decode.py +++ b/pyguppyclient/decode.py @@ -14,7 +14,7 @@ from pyguppyclient.guppy_ipc.ProtocolVersion import CreateProtocolVersion -PROTO_VERSION = (1, 0, 0) +PROTO_VERSION = (2, 1, 0) class Config: @@ -120,248 +120,109 @@ def __iadd__(self, other): return self -def set_file_identifier(buff): +def pcl_called_read(pcl_read): """ - https://github.com/google/flatbuffers/issues/4814 + Converts a read returned by pyguppy_client_lib into a CalledRead """ - buff[4:8] = b'%04x' % PROTO_VERSION[0] - return buff - - -def raw_read_message(client_id, read_tag, read_id, daq_offset, daq_scaling, raw): - builder = Builder(raw.size * 2 + 200) - read_id_offset = builder.CreateString(read_id) - raw_offset = builder.CreateNumpyVector(raw) - - # Create the ReadBlockData object. - ReadBlockData.ReadBlockDataStart(builder) - ReadBlockData.ReadBlockDataAddType( - builder, - ReadBlockType.ReadBlockType.PASS_FIRST_RAW_BLOCK - ) - ReadBlockData.ReadBlockDataAddReadTag( - builder, - read_tag - ) - ReadBlockData.ReadBlockDataAddBlockIndex( - builder, - 0 - ) - ReadBlockData.ReadBlockDataAddTotalBlocks( - builder, - 1 - ) - ReadBlockData.ReadBlockDataAddTotalSamples( - builder, - raw.size - ) - ReadBlockData.ReadBlockDataAddDaqOffset( - builder, - daq_offset - ) - ReadBlockData.ReadBlockDataAddDaqScaling( - builder, - daq_scaling - ) - ReadBlockData.ReadBlockDataAddReadId( - builder, - read_id_offset - ) - ReadBlockData.ReadBlockDataAddRawData( - builder, - raw_offset - ) - - content_offset = ReadBlockData.ReadBlockDataEnd(builder) - - # Create Message Data - MessageData.MessageDataStart(builder) - - MessageData.MessageDataAddVersion( - builder, - CreateProtocolVersion(builder, *PROTO_VERSION) - ) - - MessageData.MessageDataAddSenderId( - builder, - client_id - ) - - MessageData.MessageDataAddContentType( - builder, - Content.ReadBlockData - ) - - MessageData.MessageDataAddContent( - builder, - content_offset - ) - - end = MessageData.MessageDataEnd(builder) - builder.Finish(end) - - return set_file_identifier(builder.Output()) - - -def called_read_block(res): - - if res.ContentType() != Content.ReadBlockData: - raise Exception("Unhandled Response %s" % res.ContentType()) - - read_block = ReadBlockData.ReadBlockData() - read_block.Init(res.Content().Bytes, res.Content().Pos) - - read_obj = ReadData([], read_block.ReadId().decode()) - read_obj.read_tag = read_block.ReadTag() - read_obj.block_index = read_block.BlockIndex() - read_obj.total_blocks = read_block.TotalBlocks() - read_obj.total_samples = read_block.TotalSamples() - read_obj.daq_offset = read_block.DaqOffset() - read_obj.daq_scaling = read_block.DaqScaling() - read_obj.signal = read_block.RawDataAsNumpy() - - called_read = None - called_data = read_block.CalledData() - - if called_data is not None: - - called_read = CalledReadData( - called_data.Sequence().decode(), - called_data.Qstring().decode(), - called_data.TotalEvents(), - called_data.TotalSequenceLength(), - called_data.StateSize(), - called_data.ModelType().decode(), - called_data.TrimmedSamples(), - called_data.ModelStride(), - called_data.MeanQscore(), - ) - - if called_data.StateDataLength() > 0: - state_data = called_data.StateDataAsNumpy() - state_size = called_data.StateSize() - called_read.state = format_state_data(state_data, state_size) - - trace_data = called_data.TraceResults() - - if trace_data is not None: - if called_data.TraceResultsType() == TraceData.TraceData.FlipflopTraceData: - trace_obj = FlipflopTraceData.FlipflopTraceData() - trace_obj.Init(called_data.TraceResults().Bytes, called_data.TraceResults().Pos) - called_read.move, called_read.trace = format_flipflop_trace(trace_obj) - if called_data.TraceResultsType() == TraceData.TraceData.RunlengthTraceData: - trace_obj = RunlengthTraceData.RunlengthTraceData() - trace_obj.Init(called_data.TraceResults().Bytes, called_data.TraceResults().Pos) - called_read.trace = format_runlength_trace(trace_obj) - - barcode_data = called_data.BarcodeResults() - if barcode_data is not None: - called_read.barcode = format_barcode_data(barcode_data) - - mod_data = called_data.BaseModResults() - if mod_data is not None: - called_read.mod_alphabet = mod_data.Alphabet().decode() - called_read.mod_long_names = mod_data.LongNames().decode().split(' ') - called_read.mod_probs = format_mod_data(mod_data, len(called_read.mod_alphabet)) - - scaling_data = called_data.ScalingResults() - if scaling_data is not None: - called_read.scaling = format_scaling_data(scaling_data) - called_read.complete = (read_block.TotalBlocks() == read_block.BlockIndex() + 1) - - return read_obj, called_read - - -def format_state_data(state_data, state_size): - n = int(state_data.size / state_size) - return state_data.reshape(n, state_size) - - -def format_flipflop_trace(trace_data): - if trace_data.MoveDataLength() > 0: - move = trace_data.MoveDataAsNumpy() - else: - move = None - - if trace_data.TraceDataLength() > 0: - scaled_trace = trace_data.TraceDataAsNumpy() - trace = scaled_trace * (1.0 / 255.0) - n = int(trace.size / 8) - trace = trace.reshape(n, 8) - else: - trace = None - return move, trace - - -def format_mod_data(mod_data, alphabet_size): - scaled_probs = mod_data.ModProbsAsNumpy() - mod_probs = scaled_probs * (1.0 / 255.0) - return mod_probs.reshape(-1, alphabet_size) - + datasets = pcl_read['datasets'] + metadata = pcl_read['metadata'] + + seq = datasets['sequence'] + qual = datasets['qstring'] + events = int(metadata['duration'] / metadata['model_stride']) + seqlen = metadata['sequence_length'] + state_size = metadata['state_size'] + model_type = metadata['basecall_type'] + trimmed_samples = metadata['duration'] - metadata['trimmed_samples'] + model_stride = metadata['model_stride'] + qscore = metadata['mean_qscore'] + + state = datasets.get('state_data') + move = datasets.get('movement') + + trace = None + weight = None + if 'flipflop_trace' in datasets: + trace = datasets['flipflop_trace'] * (1.0 / 255.0) + elif 'rle_runlength' in datasets: + trace = { + 'base': datasets.get('rle_base'), + 'shape': datasets.get('rle_shape'), + 'scale': datasets.get('rle_scale'), + 'weight': datasets.get('rle_weight'), + 'index': datasets.get('rle_index'), + 'runlength': datasets.get('rle_runlength'), + } -def format_runlength_trace(trace_data): - return { - 'base': trace_data.BaseAsNumpy(), - 'shape': trace_data.ShapeAsNumpy(), - 'scale': trace_data.ScaleAsNumpy(), - 'weight': trace_data.WeightAsNumpy(), - 'index': trace_data.IndexAsNumpy(), - 'runlength': trace_data.RunlengthAsNumpy() + mod_probs = datasets.get('base_mod_probs') + mod_alpha = None + long_names = None + if mod_probs: + mod_probs = mod_probs * (1.0 / 255.0) + mod_alpha = metadata.get('base_mod_alphabet') + long_names = metadata.get('base_mod_long_names') + + barcode = None + if 'barcode_front_id' in metadata: + barcode = { + 'trim_front': metadata.get('barcode_trim_front'), + 'trim_rear': metadata.get('barcode_trim_rear'), + 'id': metadata.get('barcode_full_arrangement'), + 'normalized_id': metadata.get('barcode_arrangement'), + 'kit': metadata.get('barcode_kit'), + 'variant': metadata.get('barcode_variant'), + 'score': metadata.get('barcode_score'), + } + if metadata['barcode_front_id']: + barcode['front'] = { + 'id': metadata.get('barcode_front_id'), + 'barcode_sequence': metadata.get('barcode_front_refseq'), + 'aligned_sequence': metadata.get('barcode_front_foundseq'), + 'score': metadata.get('barcode_front_score'), + 'begin': metadata.get('barcode_front_begin_index'), + } + if metadata['barcode_rear_id']: + barcode['rear'] = { + 'id': metadata.get('barcode_rear_id'), + 'barcode_sequence': metadata.get('barcode_rear_refseq'), + 'aligned_sequence': metadata.get('barcode_rear_foundseq'), + 'score': metadata.get('barcode_rear_score'), + 'begin': metadata.get('barcode_rear_end_index'), + } + if metadata['barcode_mid_front_id']: + barcode['mid_front'] = { + 'id': metadata.get('barcode_mid_front_id'), + 'score': metadata.get('barcode_mid_front_score'), + 'end': metadata.get('barcode_mid_front_end_index'), + } + if metadata['barcode_mid_rear_id']: + barcode['mid_rear'] = { + 'id': metadata.get('barcode_mid_rear_id'), + 'score': metadata.get('barcode_mid_rear_score'), + 'end': metadata.get('barcode_mid_rear_end_index'), + } + + scaling = { + 'median': metadata.get('median'), + 'med_abs_dev': metadata.get('med_abs_dev'), + 'pt_median': metadata.get('pt_median'), + 'ptsd': metadata.get('ptsd'), + 'adapter_max': metadata.get('adapter_max'), + 'pt_detect_success': metadata.get('pt_detect_success'), } + complete = True -def format_barcode_data(barcode_data): - barcode_results = { - 'trim_front': barcode_data.BarcodeTrimFront(), - 'trim_rear': barcode_data.BarcodeTrimRear(), - 'id': barcode_data.Id(), - 'normalized_id': barcode_data.NormalisedId(), - 'kit': barcode_data.Kit(), - 'variant': barcode_data.Variant(), - 'score': barcode_data.Score() - } - front = barcode_data.Front() - if front: - barcode_results['front'] = { - 'id': front.Id(), - 'barcode_sequence': front.BarcodeSequence(), - 'aligned_sequence': front.AlignedSequence(), - 'score': front.Score(), - 'begin': front.Begin() - } - back = barcode_data.Back() - if back: - barcode_results['back'] = { - 'id': back.Id(), - 'barcode_sequence': back.BarcodeSequence(), - 'aligned_sequence': back.AlignedSequence(), - 'score': back.Score(), - 'begin': back.Begin() - } - mid_front = barcode_data.MidFront() - if mid_front: - barcode_results['mid_front'] = { - 'id': mid_front.Id(), - 'score': mid_front.Score(), - 'end': mid_front.End() - } - mid_rear = barcode_data.MidRear() - if mid_rear: - barcode_results['mid_rear'] = { - 'id': mid_rear.Id(), - 'score': mid_rear.Score(), - 'end': mid_rear.End() - } - return barcode_results - + return CalledReadData(seq, qual, events, seqlen, state_size, model_type, + trimmed_samples, model_stride, qscore, state, move, + weight, trace, mod_alpha, mod_probs, + long_names, barcode, scaling, complete) -def format_scaling_data(scaling_data): - return { - 'median': scaling_data.Median(), - 'med_abs_dev': scaling_data.MedAbsDev(), - 'pt_median': scaling_data.PtMedian(), - 'ptsd': scaling_data.Ptsd(), - 'adapter_max': scaling_data.AdapterMax(), - 'pt_detect_success': scaling_data.PtDetectSuccess() - } +def set_file_identifier(buff): + """ + https://github.com/google/flatbuffers/issues/4814 + """ + buff[4:8] = b'%04x' % PROTO_VERSION[0] + return buff + diff --git a/pyguppyclient/guppy_ipc/AlignmentIndex.py b/pyguppyclient/guppy_ipc/AlignmentIndex.py new file mode 100644 index 0000000..ff7847c --- /dev/null +++ b/pyguppyclient/guppy_ipc/AlignmentIndex.py @@ -0,0 +1,44 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: guppy_ipc + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class AlignmentIndex(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsAlignmentIndex(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = AlignmentIndex() + x.Init(buf, n + offset) + return x + + @classmethod + def AlignmentIndexBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) + + # AlignmentIndex + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # AlignmentIndex + def IndexName(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # AlignmentIndex + def Header(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def AlignmentIndexStart(builder): builder.StartObject(2) +def AlignmentIndexAddIndexName(builder, indexName): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(indexName), 0) +def AlignmentIndexAddHeader(builder, header): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(header), 0) +def AlignmentIndexEnd(builder): return builder.EndObject() diff --git a/pyguppyclient/guppy_ipc/AlignmentResults.py b/pyguppyclient/guppy_ipc/AlignmentResults.py new file mode 100644 index 0000000..130b5b6 --- /dev/null +++ b/pyguppyclient/guppy_ipc/AlignmentResults.py @@ -0,0 +1,172 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: guppy_ipc + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class AlignmentResults(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsAlignmentResults(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = AlignmentResults() + x.Init(buf, n + offset) + return x + + @classmethod + def AlignmentResultsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) + + # AlignmentResults + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # AlignmentResults + def Genome(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # AlignmentResults + def GenomeStart(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def GenomeEnd(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def StrandStart(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def StrandEnd(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def NumEvents(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def NumInsertions(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def NumDeletions(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def NumAligned(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def NumCorrect(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def Coverage(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + + # AlignmentResults + def Identity(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + + # AlignmentResults + def Accuracy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + + # AlignmentResults + def StrandScore(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def Sam(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # AlignmentResults + def BedHits(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # AlignmentResults + def BedLines(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # AlignmentResults + def Direction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def AlignmentResultsStart(builder): builder.StartObject(18) +def AlignmentResultsAddGenome(builder, genome): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(genome), 0) +def AlignmentResultsAddGenomeStart(builder, genomeStart): builder.PrependInt32Slot(1, genomeStart, 0) +def AlignmentResultsAddGenomeEnd(builder, genomeEnd): builder.PrependInt32Slot(2, genomeEnd, 0) +def AlignmentResultsAddStrandStart(builder, strandStart): builder.PrependInt32Slot(3, strandStart, 0) +def AlignmentResultsAddStrandEnd(builder, strandEnd): builder.PrependInt32Slot(4, strandEnd, 0) +def AlignmentResultsAddNumEvents(builder, numEvents): builder.PrependInt32Slot(5, numEvents, 0) +def AlignmentResultsAddNumInsertions(builder, numInsertions): builder.PrependInt32Slot(6, numInsertions, 0) +def AlignmentResultsAddNumDeletions(builder, numDeletions): builder.PrependInt32Slot(7, numDeletions, 0) +def AlignmentResultsAddNumAligned(builder, numAligned): builder.PrependInt32Slot(8, numAligned, 0) +def AlignmentResultsAddNumCorrect(builder, numCorrect): builder.PrependInt32Slot(9, numCorrect, 0) +def AlignmentResultsAddCoverage(builder, coverage): builder.PrependFloat32Slot(10, coverage, 0.0) +def AlignmentResultsAddIdentity(builder, identity): builder.PrependFloat32Slot(11, identity, 0.0) +def AlignmentResultsAddAccuracy(builder, accuracy): builder.PrependFloat32Slot(12, accuracy, 0.0) +def AlignmentResultsAddStrandScore(builder, strandScore): builder.PrependInt32Slot(13, strandScore, 0) +def AlignmentResultsAddSam(builder, sam): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(sam), 0) +def AlignmentResultsAddBedHits(builder, bedHits): builder.PrependInt32Slot(15, bedHits, 0) +def AlignmentResultsAddBedLines(builder, bedLines): builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(bedLines), 0) +def AlignmentResultsAddDirection(builder, direction): builder.PrependInt8Slot(17, direction, 0) +def AlignmentResultsEnd(builder): return builder.EndObject() diff --git a/pyguppyclient/guppy_ipc/BarcodeArrangementResults.py b/pyguppyclient/guppy_ipc/BarcodeArrangementResults.py index 0393840..b4541c8 100644 --- a/pyguppyclient/guppy_ipc/BarcodeArrangementResults.py +++ b/pyguppyclient/guppy_ipc/BarcodeArrangementResults.py @@ -18,7 +18,7 @@ def GetRootAsBarcodeArrangementResults(cls, buf, offset): @classmethod def BarcodeArrangementResultsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # BarcodeArrangementResults def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/BarcodeKitDefinition.py b/pyguppyclient/guppy_ipc/BarcodeKitDefinition.py new file mode 100644 index 0000000..e10774e --- /dev/null +++ b/pyguppyclient/guppy_ipc/BarcodeKitDefinition.py @@ -0,0 +1,100 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: guppy_ipc + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class BarcodeKitDefinition(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsBarcodeKitDefinition(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = BarcodeKitDefinition() + x.Init(buf, n + offset) + return x + + @classmethod + def BarcodeKitDefinitionBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) + + # BarcodeKitDefinition + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # BarcodeKitDefinition + def Name(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # BarcodeKitDefinition + def IsDual(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # BarcodeKitDefinition + def IsBothEnds(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # BarcodeKitDefinition + def Use12a(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # BarcodeKitDefinition + def FirstIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # BarcodeKitDefinition + def LastIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # BarcodeKitDefinition + def FirstIndexInner(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # BarcodeKitDefinition + def LastIndexInner(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # BarcodeKitDefinition + def NormalisedId(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def BarcodeKitDefinitionStart(builder): builder.StartObject(9) +def BarcodeKitDefinitionAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def BarcodeKitDefinitionAddIsDual(builder, isDual): builder.PrependBoolSlot(1, isDual, 0) +def BarcodeKitDefinitionAddIsBothEnds(builder, isBothEnds): builder.PrependBoolSlot(2, isBothEnds, 0) +def BarcodeKitDefinitionAddUse12a(builder, use12a): builder.PrependBoolSlot(3, use12a, 0) +def BarcodeKitDefinitionAddFirstIndex(builder, firstIndex): builder.PrependInt32Slot(4, firstIndex, 0) +def BarcodeKitDefinitionAddLastIndex(builder, lastIndex): builder.PrependInt32Slot(5, lastIndex, 0) +def BarcodeKitDefinitionAddFirstIndexInner(builder, firstIndexInner): builder.PrependInt32Slot(6, firstIndexInner, 0) +def BarcodeKitDefinitionAddLastIndexInner(builder, lastIndexInner): builder.PrependInt32Slot(7, lastIndexInner, 0) +def BarcodeKitDefinitionAddNormalisedId(builder, normalisedId): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(normalisedId), 0) +def BarcodeKitDefinitionEnd(builder): return builder.EndObject() diff --git a/pyguppyclient/guppy_ipc/BarcodeMidDetectResults.py b/pyguppyclient/guppy_ipc/BarcodeMidDetectResults.py index 3eccff8..8d7ee0a 100644 --- a/pyguppyclient/guppy_ipc/BarcodeMidDetectResults.py +++ b/pyguppyclient/guppy_ipc/BarcodeMidDetectResults.py @@ -18,7 +18,7 @@ def GetRootAsBarcodeMidDetectResults(cls, buf, offset): @classmethod def BarcodeMidDetectResultsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # BarcodeMidDetectResults def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/BarcodeResults.py b/pyguppyclient/guppy_ipc/BarcodeResults.py index 2718d5e..3e4d671 100644 --- a/pyguppyclient/guppy_ipc/BarcodeResults.py +++ b/pyguppyclient/guppy_ipc/BarcodeResults.py @@ -18,7 +18,7 @@ def GetRootAsBarcodeResults(cls, buf, offset): @classmethod def BarcodeResultsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # BarcodeResults def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/BaseModData.py b/pyguppyclient/guppy_ipc/BaseModData.py index 51f3de5..2bda267 100644 --- a/pyguppyclient/guppy_ipc/BaseModData.py +++ b/pyguppyclient/guppy_ipc/BaseModData.py @@ -18,7 +18,7 @@ def GetRootAsBaseModData(cls, buf, offset): @classmethod def BaseModDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # BaseModData def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/CalledBlockData.py b/pyguppyclient/guppy_ipc/CalledBlockData.py index 7d7048b..a5913ba 100644 --- a/pyguppyclient/guppy_ipc/CalledBlockData.py +++ b/pyguppyclient/guppy_ipc/CalledBlockData.py @@ -18,7 +18,7 @@ def GetRootAsCalledBlockData(cls, buf, offset): @classmethod def CalledBlockDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # CalledBlockData def Init(self, buf, pos): @@ -220,7 +220,32 @@ def BarcodeResults(self): return obj return None -def CalledBlockDataStart(builder): builder.StartObject(23) + # CalledBlockData + def AlignmentResults(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from pyguppyclient.guppy_ipc.AlignmentResults import AlignmentResults + obj = AlignmentResults() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # CalledBlockData + def AlignmentResultsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # CalledBlockData + def AlignmentResultsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50)) + return o == 0 + +def CalledBlockDataStart(builder): builder.StartObject(24) def CalledBlockDataAddTotalEvents(builder, totalEvents): builder.PrependUint32Slot(0, totalEvents, 0) def CalledBlockDataAddBlockEvents(builder, blockEvents): builder.PrependUint32Slot(1, blockEvents, 0) def CalledBlockDataAddTotalSequenceLength(builder, totalSequenceLength): builder.PrependUint32Slot(2, totalSequenceLength, 0) @@ -245,4 +270,6 @@ def CalledBlockDataAddBaseModResults(builder, baseModResults): builder.PrependUO def CalledBlockDataAddStateData(builder, stateData): builder.PrependUOffsetTRelativeSlot(21, flatbuffers.number_types.UOffsetTFlags.py_type(stateData), 0) def CalledBlockDataStartStateDataVector(builder, numElems): return builder.StartVector(4, numElems, 4) def CalledBlockDataAddBarcodeResults(builder, barcodeResults): builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(barcodeResults), 0) +def CalledBlockDataAddAlignmentResults(builder, alignmentResults): builder.PrependUOffsetTRelativeSlot(23, flatbuffers.number_types.UOffsetTFlags.py_type(alignmentResults), 0) +def CalledBlockDataStartAlignmentResultsVector(builder, numElems): return builder.StartVector(4, numElems, 4) def CalledBlockDataEnd(builder): return builder.EndObject() diff --git a/pyguppyclient/guppy_ipc/ClientStats.py b/pyguppyclient/guppy_ipc/ClientStats.py index 6c85cec..b7ba758 100644 --- a/pyguppyclient/guppy_ipc/ClientStats.py +++ b/pyguppyclient/guppy_ipc/ClientStats.py @@ -18,7 +18,7 @@ def GetRootAsClientStats(cls, buf, offset): @classmethod def ClientStatsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # ClientStats def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/ConfigData.py b/pyguppyclient/guppy_ipc/ConfigData.py index ee4d968..fcca92d 100644 --- a/pyguppyclient/guppy_ipc/ConfigData.py +++ b/pyguppyclient/guppy_ipc/ConfigData.py @@ -18,7 +18,7 @@ def GetRootAsConfigData(cls, buf, offset): @classmethod def ConfigDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # ConfigData def Init(self, buf, pos): @@ -49,7 +49,83 @@ def ConfigsIsNone(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) return o == 0 -def ConfigDataStart(builder): builder.StartObject(1) + # ConfigData + def AlignIndices(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from pyguppyclient.guppy_ipc.AlignmentIndex import AlignmentIndex + obj = AlignmentIndex() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # ConfigData + def AlignIndicesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # ConfigData + def AlignIndicesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # ConfigData + def BedFiles(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return "" + + # ConfigData + def BedFilesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # ConfigData + def BedFilesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # ConfigData + def BarcodeKits(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from pyguppyclient.guppy_ipc.BarcodeKitDefinition import BarcodeKitDefinition + obj = BarcodeKitDefinition() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # ConfigData + def BarcodeKitsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # ConfigData + def BarcodeKitsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + +def ConfigDataStart(builder): builder.StartObject(4) def ConfigDataAddConfigs(builder, configs): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(configs), 0) def ConfigDataStartConfigsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def ConfigDataAddAlignIndices(builder, alignIndices): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(alignIndices), 0) +def ConfigDataStartAlignIndicesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def ConfigDataAddBedFiles(builder, bedFiles): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(bedFiles), 0) +def ConfigDataStartBedFilesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def ConfigDataAddBarcodeKits(builder, barcodeKits): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(barcodeKits), 0) +def ConfigDataStartBarcodeKitsVector(builder, numElems): return builder.StartVector(4, numElems, 4) def ConfigDataEnd(builder): return builder.EndObject() diff --git a/pyguppyclient/guppy_ipc/Configuration.py b/pyguppyclient/guppy_ipc/Configuration.py index c5ca698..60b976f 100644 --- a/pyguppyclient/guppy_ipc/Configuration.py +++ b/pyguppyclient/guppy_ipc/Configuration.py @@ -18,7 +18,7 @@ def GetRootAsConfiguration(cls, buf, offset): @classmethod def ConfigurationBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # Configuration def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/FlipflopTraceData.py b/pyguppyclient/guppy_ipc/FlipflopTraceData.py index ae508e9..2636bf9 100644 --- a/pyguppyclient/guppy_ipc/FlipflopTraceData.py +++ b/pyguppyclient/guppy_ipc/FlipflopTraceData.py @@ -18,7 +18,7 @@ def GetRootAsFlipflopTraceData(cls, buf, offset): @classmethod def FlipflopTraceDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # FlipflopTraceData def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/MessageData.py b/pyguppyclient/guppy_ipc/MessageData.py index 6efccac..88800fe 100644 --- a/pyguppyclient/guppy_ipc/MessageData.py +++ b/pyguppyclient/guppy_ipc/MessageData.py @@ -18,7 +18,7 @@ def GetRootAsMessageData(cls, buf, offset): @classmethod def MessageDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # MessageData def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/ReadBlockData.py b/pyguppyclient/guppy_ipc/ReadBlockData.py index f7d27fd..9d59a21 100644 --- a/pyguppyclient/guppy_ipc/ReadBlockData.py +++ b/pyguppyclient/guppy_ipc/ReadBlockData.py @@ -18,7 +18,7 @@ def GetRootAsReadBlockData(cls, buf, offset): @classmethod def ReadBlockDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # ReadBlockData def Init(self, buf, pos): @@ -118,7 +118,18 @@ def CalledData(self): return obj return None -def ReadBlockDataStart(builder): builder.StartObject(10) + # ReadBlockData + def ScalingOverride(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + if o != 0: + x = self._tab.Indirect(o + self._tab.Pos) + from pyguppyclient.guppy_ipc.ScalingOverrideData import ScalingOverrideData + obj = ScalingOverrideData() + obj.Init(self._tab.Bytes, x) + return obj + return None + +def ReadBlockDataStart(builder): builder.StartObject(11) def ReadBlockDataAddType(builder, type): builder.PrependUint32Slot(0, type, 0) def ReadBlockDataAddReadTag(builder, readTag): builder.PrependUint32Slot(1, readTag, 0) def ReadBlockDataAddBlockIndex(builder, blockIndex): builder.PrependUint32Slot(2, blockIndex, 0) @@ -130,4 +141,5 @@ def ReadBlockDataAddReadId(builder, readId): builder.PrependUOffsetTRelativeSlot def ReadBlockDataAddRawData(builder, rawData): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(rawData), 0) def ReadBlockDataStartRawDataVector(builder, numElems): return builder.StartVector(2, numElems, 2) def ReadBlockDataAddCalledData(builder, calledData): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(calledData), 0) +def ReadBlockDataAddScalingOverride(builder, scalingOverride): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(scalingOverride), 0) def ReadBlockDataEnd(builder): return builder.EndObject() diff --git a/pyguppyclient/guppy_ipc/RunlengthTraceData.py b/pyguppyclient/guppy_ipc/RunlengthTraceData.py index da16dc4..95fb73e 100644 --- a/pyguppyclient/guppy_ipc/RunlengthTraceData.py +++ b/pyguppyclient/guppy_ipc/RunlengthTraceData.py @@ -18,7 +18,7 @@ def GetRootAsRunlengthTraceData(cls, buf, offset): @classmethod def RunlengthTraceDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # RunlengthTraceData def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/ScalingData.py b/pyguppyclient/guppy_ipc/ScalingData.py index 1861e42..704e052 100644 --- a/pyguppyclient/guppy_ipc/ScalingData.py +++ b/pyguppyclient/guppy_ipc/ScalingData.py @@ -18,7 +18,7 @@ def GetRootAsScalingData(cls, buf, offset): @classmethod def ScalingDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # ScalingData def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/ScalingOverrideData.py b/pyguppyclient/guppy_ipc/ScalingOverrideData.py new file mode 100644 index 0000000..4d03125 --- /dev/null +++ b/pyguppyclient/guppy_ipc/ScalingOverrideData.py @@ -0,0 +1,44 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: guppy_ipc + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ScalingOverrideData(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsScalingOverrideData(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ScalingOverrideData() + x.Init(buf, n + offset) + return x + + @classmethod + def ScalingOverrideDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) + + # ScalingOverrideData + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ScalingOverrideData + def ScalingOverrideMedian(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + + # ScalingOverrideData + def ScalingOverrideMedAbsDev(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + +def ScalingOverrideDataStart(builder): builder.StartObject(2) +def ScalingOverrideDataAddScalingOverrideMedian(builder, scalingOverrideMedian): builder.PrependFloat32Slot(0, scalingOverrideMedian, 0.0) +def ScalingOverrideDataAddScalingOverrideMedAbsDev(builder, scalingOverrideMedAbsDev): builder.PrependFloat32Slot(1, scalingOverrideMedAbsDev, 0.0) +def ScalingOverrideDataEnd(builder): return builder.EndObject() diff --git a/pyguppyclient/guppy_ipc/ServerStats.py b/pyguppyclient/guppy_ipc/ServerStats.py index 30cff46..9d19109 100644 --- a/pyguppyclient/guppy_ipc/ServerStats.py +++ b/pyguppyclient/guppy_ipc/ServerStats.py @@ -18,7 +18,7 @@ def GetRootAsServerStats(cls, buf, offset): @classmethod def ServerStatsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # ServerStats def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/SimpleReplyData.py b/pyguppyclient/guppy_ipc/SimpleReplyData.py index ca1c268..40848af 100644 --- a/pyguppyclient/guppy_ipc/SimpleReplyData.py +++ b/pyguppyclient/guppy_ipc/SimpleReplyData.py @@ -18,7 +18,7 @@ def GetRootAsSimpleReplyData(cls, buf, offset): @classmethod def SimpleReplyDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # SimpleReplyData def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/SimpleReplyType.py b/pyguppyclient/guppy_ipc/SimpleReplyType.py index 6dad9b1..d18e4d5 100644 --- a/pyguppyclient/guppy_ipc/SimpleReplyType.py +++ b/pyguppyclient/guppy_ipc/SimpleReplyType.py @@ -15,4 +15,8 @@ class SimpleReplyType(object): NONE_PENDING = 9 BAD_REQUEST = 10 BAD_REPLY = 11 + INVALID_INDEX = 12 + LOADING_INDEX = 13 + INVALID_BED = 14 + LOADING_BED = 15 diff --git a/pyguppyclient/guppy_ipc/SimpleRequestData.py b/pyguppyclient/guppy_ipc/SimpleRequestData.py index 83735e8..075d82f 100644 --- a/pyguppyclient/guppy_ipc/SimpleRequestData.py +++ b/pyguppyclient/guppy_ipc/SimpleRequestData.py @@ -18,7 +18,7 @@ def GetRootAsSimpleRequestData(cls, buf, offset): @classmethod def SimpleRequestDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x31", size_prefixed=size_prefixed) + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x30\x30\x30\x32", size_prefixed=size_prefixed) # SimpleRequestData def Init(self, buf, pos): diff --git a/pyguppyclient/guppy_ipc/SimpleRequestType.py b/pyguppyclient/guppy_ipc/SimpleRequestType.py index 856aab6..7c84e93 100644 --- a/pyguppyclient/guppy_ipc/SimpleRequestType.py +++ b/pyguppyclient/guppy_ipc/SimpleRequestType.py @@ -11,4 +11,9 @@ class SimpleRequestType(object): GET_CONFIGS = 5 GET_FIRST_CALLED_BLOCK = 6 GET_NEXT_CALLED_BLOCK = 7 + LOAD_INDEX = 8 + GET_INDICES = 9 + LOAD_BED = 10 + GET_BEDS = 11 + GET_BARCODE_KITS = 12 diff --git a/pyguppyclient/ipc.py b/pyguppyclient/ipc.py index 231da50..5cbb279 100644 --- a/pyguppyclient/ipc.py +++ b/pyguppyclient/ipc.py @@ -2,7 +2,6 @@ from flatbuffers import Builder -from pyguppyclient.decode import called_read_block from pyguppyclient.decode import PROTO_VERSION, set_file_identifier from pyguppyclient.guppy_ipc.Content import Content @@ -90,6 +89,12 @@ def simple_request(request_type, client_id=0, text=None, data=None): def simple_response(buff): req = MessageData.MessageData.GetRootAsMessageData(buff, 0) + if req.Version().MajorVersion() != PROTO_VERSION[0]: + raise Exception("Server IPC major version {} does not match " + "pyguppyclient IPC major version {} -- cannot decode " + "message.".format(req.Version().MajorVersion(), + PROTO_VERSION[0])) + if req.ContentType() == Content.SimpleReplyData: cls = SimpleReplyData.SimpleReplyData() cls.Init(req.Content().Bytes, req.Content().Pos) @@ -100,7 +105,7 @@ def simple_response(buff): if cls.Type() == SimpleReplyType.INVALID_CONFIG: raise ValueError("Invalid Config") if cls.Type() == SimpleReplyType.BAD_REQUEST: - raise Exception("Bad request") + raise Exception("Bad request:", cls.Text()) if cls.Type() == SimpleReplyType.BAD_REPLY: raise Exception(cls.Text().decode()) if cls.Type() == SimpleReplyType.NONE_PENDING: diff --git a/requirements.txt b/requirements.txt index 9f60d11..f6ab2bf 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,3 +2,4 @@ pyzmq==17.1.2 numpy>=1.13.3 flatbuffers==1.11 ont-fast5-api>=3.0.1 +ont-pyguppy-client-lib==4.0.11 diff --git a/tests/client_tests.py b/tests/client_tests.py index c759626..b24884d 100644 --- a/tests/client_tests.py +++ b/tests/client_tests.py @@ -30,7 +30,6 @@ def test_without_read(self): """ test the client api without sending a read """ self.client.get_statistics() self.client.get_configs() - self.client._load_config(self.config_hac) def test_read_without_state(self): """ test a read without state """ @@ -40,15 +39,16 @@ def test_read_without_state(self): def test_read_with_state(self): """ test a read with state """ - self.client._load_config(self.config_fast) self.client.pass_read(next(self.read_loader)) time.sleep(1) self.client._get_called_read(state=True) def test_invalid_config(self): """ try and load in invalid config """ - with self.assertRaises(ValueError): - self.client._load_config("not_a_config") + bad_client = GuppyBasecallerClient(config_name="not_a_config", + port=self.port) + with self.assertRaises(ConnectionError): + bad_client.connect() if __name__ == "__main__":