async def open_file(cls, *args, **kwargs): file_path = args[0] rest = args[1:] if isinstance(file_path, IOBase): return trio.wrap_file(file_path) return await trio.open_file(file_path, *rest, **kwargs)
async def open(self, *args, **kwargs): """Open the file pointed to by the path, like the :func:`trio.open_file` function does. """ func = partial(self._wrapped.open, *args, **kwargs) value = await trio.to_thread.run_sync(func) return trio.wrap_file(value)
def test_wrap_non_iobase(): class FakeFile: def close(self): # pragma: no cover pass def write(self): # pragma: no cover pass wrapped = FakeFile() assert not isinstance(wrapped, io.IOBase) async_file = trio.wrap_file(wrapped) assert isinstance(async_file, AsyncIOWrapper) del FakeFile.write with pytest.raises(TypeError): trio.wrap_file(FakeFile())
async def open(self, *args, **kwargs): """Open the file pointed to by the path, like the :func:`trio.open_file` function does. """ func = partial(self._wrapped.open, *args, **kwargs) value = await trio.run_sync_in_worker_thread(func) return trio.wrap_file(value)
async def test_detach_rewraps_asynciobase(): raw = io.BytesIO() buffered = io.BufferedReader(raw) async_file = trio.wrap_file(buffered) detached = await async_file.detach() assert isinstance(detached, AsyncIOWrapper) assert detached.wrapped is raw
async def test_async_iter(): async_file = trio.wrap_file(io.StringIO('test\nfoo\nbar')) expected = list(async_file.wrapped) result = [] async_file.wrapped.seek(0) async for line in async_file: result.append(line) assert result == expected
def test_unsupported_not_forwarded(): class FakeFile(io.RawIOBase): def unsupported_attr(self): # pragma: no cover pass async_file = trio.wrap_file(FakeFile()) assert hasattr(async_file.wrapped, 'unsupported_attr') with pytest.raises(AttributeError): getattr(async_file, 'unsupported_attr')
async def parent(): async with trio.open_nursery() as nursery: serial_port = serial.Serial("/dev/serial0", 9600, timeout=5.0) serial_io = io.TextIOWrapper( io.BufferedRWPair(serial_port, serial_port)) a_serial = trio.wrap_file(serial_port) print("Starting print loop") nursery.start_soon(aprint_loop) print("Starting GPS async serial loop") a_serial.flushInput() nursery.start_soon(agps_loop, a_serial) print("This should never be reached...")
async def test_upload_trio_wrapped_files(self): """Uploading a file wrapped via 'trio.wrap_file()' should be possible""" with open(__file__, mode="rb") as f: data = f.read() content_length = len(data) headers = { "Content-Length": str(content_length), } url = "%s/echo" % self.base_url with PoolManager(backend="trio") as http: with open(__file__, mode="rb") as f: f = trio.wrap_file(f) resp = await http.urlopen("PUT", url, headers=headers, body=f) assert resp.status == 200 assert resp.data == data
def __init__(self, port, nursery, data=None, notification_callbacks=None, error_callbacks=None): super().__init__(nursery, notification_callbacks, error_callbacks) if port is None: raise ValueError('port cannot be None') try: self._connection = serial.Serial(port, 9600, timeout=5.0) self._a_connection = trio.wrap_file(self._connection) self._data = data if data is not None else {'latitude': None, 'longitude': None, 'altitude': None, 'num_satellites': None} except serial.SerialException: print("ERROR initializing GPS module") raise self.location = None # type: Union[pynmea2.GGA, None] self.visible_satellites = [] # type: List[SatelliteMeasurement] self._new_satellites = [] # New list of satellites being constructed (multiple NMEA sentences are required) self._is_running = False
def test_wrap_invalid(): with pytest.raises(TypeError): trio.wrap_file(str())
def async_file(wrapped): return trio.wrap_file(wrapped)
async def write_data(stream: INetStream) -> None: async_f = trio.wrap_file(sys.stdin) while True: line = await async_f.readline() await stream.write(line.encode())
async def make_named_tempfile(*args: typing.Any, **kwargs: typing.Any) \ -> 'trio._file_io.AsyncIOWrapper': return typing.cast( 'trio._file_io.AsyncIOWrapper', trio.wrap_file(await run_blocking_nointr(tempfile.NamedTemporaryFile, *args, **kwargs)))
async def open(self, *args, **kwargs): func = partial(self._wrapped.open, *args, **kwargs) value = await trio.run_in_worker_thread(func) return trio.wrap_file(value)