U
|
Z ±dÊ ã @ s d dl mZ d dlZddlmZ ddlmZ d dlZdddd d
|
d d d dddddddddhZdddddd d d d d d!d"d#d$hZ G d%d& d&eZ
|
d.d*d+Z d,d- Z dS )/é )ÚpartialNé )Ú AsyncResource)Ú async_wrapsÚclosedÚencodingÚerrorsÚfilenoÚisattyÚnewlinesÚreadableÚseekableÚwritableÚbufferÚrawÚline_bufferingÚclosefdÚnameÚmodeÚgetvalueÚ getbufferÚflushÚreadÚread1ÚreadallÚreadintoÚreadlineÚ readlinesÚseekÚtellÚtruncateÚwriteÚ
|
writelinesÚ readinto1Úpeekc s\ e Zd ZdZdd Zedd Zdd Z fdd Zd
|
d Z d d Z
|
dd Z dd Z Z S )ÚAsyncIOWrapperaI A generic :class:`~io.IOBase` wrapper that implements the :term:`asynchronous
|
file object` interface. Wrapped methods that could block are executed in
|
:meth:`trio.to_thread.run_sync`.
|
|
All properties and methods defined in in :mod:`~io` are exposed by this
|
wrapper, if they exist in the wrapped file object.
|
|
c C s
|
|| _ d S ©N©Ú_wrapped)ÚselfÚfile© r+ úDd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\trio/_file_io.pyÚ__init__= s zAsyncIOWrapper.__init__c C s | j S )z.object: A reference to the wrapped file objectr' ©r) r+ r+ r, Úwrapped@ s zAsyncIOWrapper.wrappedc sb |t krt| j|S |tkrVt| j| t| j| jj| fdd}t| || |S t|d S )Nc s" t f| |}tj |¡I d H S r& )r ÚtrioÚ to_threadÚrun_sync)ÚargsÚkwargsÚfunc©Úmethr+ r, ÚwrapperL s z+AsyncIOWrapper.__getattr__.<locals>.wrapper)Ú_FILE_SYNC_ATTRSÚgetattrr( Ú_FILE_ASYNC_METHODSr Ú __class__ÚsetattrÚAttributeError)r) r r8 r+ r6 r, Ú __getattr__F s zAsyncIOWrapper.__getattr__c sB t t ¡ }| fddtD ¡ | fddtD ¡ |S )Nc 3 s | ]}t j|r|V qd S r& ©Úhasattrr/ ©Ú.0Úar. r+ r, Ú <genexpr>Y s z)AsyncIOWrapper.__dir__.<locals>.<genexpr>c 3 s | ]}t j|r|V qd S r& r@ rB r. r+ r, rE Z s )ÚsetÚsuperÚ__dir__Úupdater9 r; )r) Úattrs©r< r. r, rH W s zAsyncIOWrapper.__dir__c C s | S r& r+ r. r+ r+ r, Ú __aiter__] s zAsyncIOWrapper.__aiter__c à s | ¡ I d H }|r|S td S r& )r ÚStopAsyncIteration)r) Úliner+ r+ r, Ú __anext__` s zAsyncIOWrapper.__anext__c à s t j | jj¡I dH }t|S )zLike :meth:`io.BufferedIOBase.detach`, but async.
|
|
This also re-wraps the result in a new :term:`asynchronous file object`
|
wrapper.
|
|
N)r0 r1 r2 r( ÚdetachÚ wrap_file)r) r r+ r+ r, rP g s zAsyncIOWrapper.detachc à sB t jdd t j | jj¡I dH W 5 Q R X t j ¡ I dH dS )zÇLike :meth:`io.IOBase.close`, but async.
|
|
This is also shielded from cancellation; if a cancellation scope is
|
cancelled, the wrapped file object will still be safely closed.
|
|
T)ZshieldN)r0 Z CancelScoper1 r2 r( ÚcloseZlowlevelZcheckpoint_if_cancelledr. r+ r+ r, Úacloser s zAsyncIOWrapper.aclose)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r- Úpropertyr/ r? rH rL rO rP rS Ú __classcell__r+ r+ rK r, r% 3 s
|
r% ÚréÿÿÿÿTc à s, t tj tj| |||||||¡ I dH }|S )a+ Asynchronous version of :func:`io.open`.
|
|
Returns:
|
An :term:`asynchronous file object`
|
|
Example::
|
|
async with await trio.open_file(filename) as f:
|
async for line in f:
|
pass
|
|
assert f.closed
|
|
See also:
|
:func:`trio.Path.open`
|
|
N)rQ r0 r1 r2 ÚioÚopen) r* r Ú bufferingr r Únewliner ÚopenerÚ_filer+ r+ r, Ú open_file s ÿÿrb c s: fdd}|dr$|ds2|ds2t d ¡t S )a[ This wraps any file object in a wrapper that provides an asynchronous
|
file object interface.
|
|
Args:
|
file: a :term:`file object`
|
|
Returns:
|
An :term:`asynchronous file object` that wraps ``file``
|
|
Example::
|
|
async_file = trio.wrap_file(StringIO('asdf'))
|
|
assert await async_file.read() == 'asdf'
|
|
c s t | ott | S r& )rA Úcallabler: )Úattr©r* r+ r, Úhas¶ s zwrap_file.<locals>.hasrR r r! zK{} does not implement required duck-file methods: close and (read or write))Ú TypeErrorÚformatr% )r* rf r+ re r, rQ ¤ s ÿÿrQ )rZ r[ NNNTN) Ú functoolsr r\ Úabcr Z_utilr r0 r9 r; r% rb rQ r+ r+ r+ r, Ú<module> s^ îñP ø
|
#
|
