def setUp(self) -> None:
# Here we initialise the server
self.server = MockMinKNOWServer(data_service=DataServicer)
self.port = self.server.port
self.server.start()
ssl_creds = self.server.make_channel_credentials()
self.connection = minknow_api.Connection(self.port,
credentials=ssl_creds)
def setUp(self):
self.test_server = MockMinKNOWServer()
self.test_server.start()
ssl_creds = self.test_server.make_channel_credentials()
self.connection = minknow_api.Connection(
self.test_server.port, credentials=ssl_creds
)
LOGGER.info("Connected on {}".format(self.test_server.port))
def connect(self, use_tls=None):
"""Connect to the position.
Only valid to do if `running` is True.
Returns:
minknow_api.Connection: A connection to the RPC interface.
"""
if not use_tls:
use_tls = self._default_use_tls
if use_tls:
port = self.description.rpc_ports.secure
else:
port = self.description.rpc_ports.insecure
return minknow_api.Connection(host=self.host,
port=port,
use_tls=use_tls)
def connect(self, credentials=None, developer_api_token=None):
"""Connect to the position.
Only valid to do if `running` is True.
Returns:
minknow_api.Connection: A connection to the RPC interface.
"""
port = self.description.rpc_ports.secure
if credentials is None:
credentials = self.credentials
if not developer_api_token:
developer_api_token = self._developer_api_token
return minknow_api.Connection(
host=self.host,
port=port,
credentials=credentials,
developer_api_token=developer_api_token,
)
def setUp(self) -> None:
# Here we initialise the server
self.server = MockMinKNOWServer(data_service=DataServicer,)
self.port = self.server.port
self.server.start()
self.connection = minknow_api.Connection(self.port)
def setUp(self) -> None:
self.connection = minknow_api.Connection(host=HOST,
port=PORT,
use_tls=False)
self.device = self.connection.device
def setUp(self):
self.test_server = MockMinKNOWServer()
self.test_server.start()
self.connection = minknow_api.Connection(self.test_server.port)
LOGGER.info("Connected on {}".format(self.test_server.port))
def __init__(self, mk_host='127.0.0.1', mk_port=8000, cache_size=512, cache_type=ReadCache,
filter_strands=True, one_chunk=True, prefilter_classes={'strand', 'adapter'}):
"""A basic Read Until client. The class handles basic interaction
with the MinKNOW gRPC stream and provides a thread-safe queue
containing the most recent read data on each channel.
:param mk_port: MinKNOW gRPC port for the sequencing device.
:param cache_size: maximum number of read chunks to cache from
gRPC stream. Setting this to the number of device channels
will allow caching of the most recent data per channel.
:param cache_type: a type derived from `ReadCache` for managing
incoming read chunks.
:param filter_strands: pre-filter stream to keep only strand-like reads.
:param one_chunk: attempt to receive only one_chunk per read. When
enabled a request to stop receiving more data for a read is
immediately staged when the first chunk is cached.
:param prefilter_classes: a set of read classes to accept through
prefilter. Ignored if filter_strands is `False`.
To set up and use a client:
>>> read_until_client = ReadUntilClient()
This creates an initial connection to a MinKNOW instance in
preparation for setting up live reads stream. To initiate the stream:
>>> read_until_client.run()
The client is now recieving data and can send s
Calls to methods of `read_until_client` can then be made in a separate
thread. For example an continually running analysis function can be
submitted to the executor as:
>>> def analysis(client, *args, **kwargs):
... while client.is_running:
... for channel, read in client.get_read_chunks():
... raw_data = numpy.fromstring(read.raw_data, client.signal_dtype)
... # do something with raw data... and maybe call:
... # client.stop_receiving_read(channel, read.number)
... # client.unblock_read(channel, read.number)
>>> with ThreadPoolExecutor() as executor:
... executor.submit(analysis_function, read_until_client)
To stop processing the gRPC read stream:
>>> read_until_client.reset()
If an analysis function is set up as above in response to
`client.is_running`, calling the above call will cause the
analysis function to return.
"""
self.logger = logging.getLogger('ReadUntil')
self.mk_host = mk_host
self.mk_grpc_port = mk_port
self.cache_size = cache_size
self.CacheType = cache_type
self.filter_strands = filter_strands
self.one_chunk = one_chunk
self.prefilter_classes = prefilter_classes
client_type = 'single chunk' if self.one_chunk else 'many chunk'
filters = ' '.join(self.prefilter_classes)
filter_to = 'without prefilter'
if self.filter_strands:
if len(self.prefilter_classes) == 0:
raise ValueError('Read filtering set but no filter classes given.')
classes = _format_iter(self.prefilter_classes)
filter_to = 'filtering to {} read chunks'.format(classes)
self.logger.info('Creating {} client with {} data queue {}.'.format(
client_type, self.CacheType.__name__, filter_to))
self.logger.warn("Using pre-defined read classification map.")
class_map = CLASS_MAP
self.read_classes = {
int(k):v for k, v in
class_map['read_classification_map'].items()
}
self.strand_classes = set()
for key, value in self.read_classes.items():
if value in self.prefilter_classes:
self.strand_classes.add(key)
self.logger.debug('Strand-like classes are {}.'.format(self.strand_classes))
self.grpc_port = self.mk_grpc_port
self.logger.info('Creating rpc connection on port {}.'.format(self.grpc_port))
self.connection = minknow_api.Connection(host=self.mk_host, port=self.grpc_port)
self.logger.info('Got rpc connection.')
self.msgs = self.connection.data._pb
self.signal_dtype = minknow_api.data.get_numpy_types(self.connection).calibrated_signal
# setup the queues and running status
self._process_thread = None
self.reset()