pyo3io_macros/
lib.rs

1use std::hash::{DefaultHasher, Hash, Hasher};
2
3use futures::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite};
4use pyo3::prelude::*;
5
6mod utils;
7pub use utils::*;
8
9/// The `Whence` enum represents the reference point for seeking operations in a stream.
10#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
11#[pyclass(frozen)]
12#[repr(u8)]
13pub enum Whence {
14  Start = 0,
15  End = 1,
16  Current = 2,
17}
18
19#[pymethods]
20impl Whence {
21  /// Returns the `Start` variant of `Whence`.
22  #[staticmethod]
23  pub fn start() -> Self {
24    Self::Start
25  }
26
27  /// Returns the `End` variant of `Whence`.
28  #[staticmethod]
29  pub fn end() -> Self {
30    Self::End
31  }
32
33  /// Returns the `Current` variant of `Whence`.
34  #[staticmethod]
35  pub fn current() -> Self {
36    Self::Current
37  }
38
39  pub fn __str__(&self) -> &'static str {
40    match self {
41      Self::Start => "start",
42      Self::End => "end",
43      Self::Current => "current",
44    }
45  }
46
47  pub fn __repr__(&self) -> &'static str {
48    match self {
49      Self::Start => "Whence::Start",
50      Self::End => "Whence::End",
51      Self::Current => "Whence::Current",
52    }
53  }
54
55  pub fn __eq__(&self, other: Self) -> bool {
56    *self == other
57  }
58
59  pub fn __ne__(&self, other: Self) -> bool {
60    *self != other
61  }
62
63  pub fn __hash__(&self) -> u64 {
64    (*self as u8) as u64
65  }
66
67  pub fn __int__(&self) -> u8 {
68    *self as u8
69  }
70}
71
72/// The `SeekFrom` struct is used to specify a position in a stream for seeking operations.
73/// It combines a `Whence` value with an offset.
74#[derive(Copy, Clone, Eq, PartialEq, Hash)]
75#[pyclass]
76pub struct SeekFrom {
77  /// the `Whence` value of the `SeekFrom` instance.
78  #[pyo3(get, set)]
79  whence: Whence,
80  /// the offset of the `SeekFrom` instance.
81  #[pyo3(get, set)]
82  offset: i64,
83}
84
85impl From<std::io::SeekFrom> for SeekFrom {
86  fn from(seek_from: std::io::SeekFrom) -> Self {
87    match seek_from {
88      std::io::SeekFrom::Start(offset) => Self::start(offset),
89      std::io::SeekFrom::End(offset) => Self::end(offset),
90      std::io::SeekFrom::Current(offset) => Self::current(offset),
91    }
92  }
93}
94
95impl From<SeekFrom> for std::io::SeekFrom {
96  fn from(seek_from: SeekFrom) -> Self {
97    match seek_from.whence {
98      Whence::Start => Self::Start(seek_from.offset as u64),
99      Whence::End => Self::End(seek_from.offset),
100      Whence::Current => Self::Current(seek_from.offset),
101    }
102  }
103}
104
105#[pymethods]
106impl SeekFrom {
107  #[new]
108  pub fn new(offset: i64, whence: Whence) -> Self {
109    Self { whence, offset }
110  }
111
112  /// Creates a new `SeekFrom` instance with `Whence::Start` and the specified offset.
113  #[staticmethod]
114  pub fn start(offset: u64) -> Self {
115    Self::new(offset as i64, Whence::Start)
116  }
117
118  /// Creates a new `SeekFrom` instance with `Whence::End` and the specified offset.
119  #[staticmethod]
120  pub fn end(offset: i64) -> Self {
121    Self::new(offset, Whence::End)
122  }
123
124  /// Creates a new `SeekFrom` instance with `Whence::Current` and the specified offset.
125  #[staticmethod]
126  pub fn current(offset: i64) -> Self {
127    Self::new(offset, Whence::Current)
128  }
129
130  pub fn __str__(&self) -> ::std::string::String {
131    match self.whence {
132      Whence::Start => format!("start({})", self.offset),
133      Whence::End => format!("end({})", self.offset),
134      Whence::Current => format!("current({})", self.offset),
135    }
136  }
137
138  pub fn __repr__(&self) -> ::std::string::String {
139    match self.whence {
140      Whence::Start => format!("SeekFrom::Start({})", self.offset),
141      Whence::End => format!("SeekFrom::End({})", self.offset),
142      Whence::Current => format!("SeekFrom::Current({})", self.offset),
143    }
144  }
145
146  pub fn __eq__(&self, other: Self) -> bool {
147    self.whence == other.whence && self.offset == other.offset
148  }
149
150  pub fn __ne__(&self, other: Self) -> bool {
151    self.whence != other.whence || self.offset != other.offset
152  }
153
154  pub fn __hash__(&self) -> u64 {
155    let mut hasher = DefaultHasher::new();
156    self.hash(&mut hasher);
157    hasher.finish()
158  }
159}
160
161#[doc(hidden)]
162pub enum State<T> {
163  Ok(T),
164  Closed,
165}
166
167#[doc(hidden)]
168pub mod __private {
169  pub use super::*;
170  pub use ::smallvec;
171  pub use futures;
172  pub use futures::lock::Mutex;
173  pub use paste;
174  pub use pyo3;
175}
176
177#[doc(hidden)]
178pub trait AsyncReadWrite: AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static {}
179
180impl<T> AsyncReadWrite for T where T: AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static {}
181
182#[doc(hidden)]
183pub trait AsyncBufReadWrite: AsyncBufRead + AsyncWrite + Send + Sync + Unpin + 'static {}
184
185impl<T> AsyncBufReadWrite for T where T: AsyncBufRead + AsyncWrite + Send + Sync + Unpin + 'static {}
186
187#[doc(hidden)]
188pub trait AsyncSeekRead: AsyncRead + AsyncSeek + Send + Sync + Unpin + 'static {}
189
190impl<T> AsyncSeekRead for T where T: AsyncRead + AsyncSeek + Send + Sync + Unpin + 'static {}
191
192#[doc(hidden)]
193pub trait AsyncSeekBufRead: AsyncBufRead + AsyncSeek + Send + Sync + Unpin + 'static {}
194
195impl<T> AsyncSeekBufRead for T where T: AsyncBufRead + AsyncSeek + Send + Sync + Unpin + 'static {}
196
197#[doc(hidden)]
198pub trait AsyncSeekWrite: AsyncWrite + AsyncSeek + Send + Sync + Unpin + 'static {}
199
200impl<T> AsyncSeekWrite for T where T: AsyncWrite + AsyncSeek + Send + Sync + Unpin + 'static {}
201
202#[doc(hidden)]
203pub trait AsyncSeekReadWrite: AsyncReadWrite + AsyncSeek + Send + Sync + Unpin + 'static {}
204
205impl<T> AsyncSeekReadWrite for T where T: AsyncReadWrite + AsyncSeek + Send + Sync + Unpin + 'static {}
206
207#[doc(hidden)]
208pub trait AsyncSeekBufReadWrite:
209  AsyncBufReadWrite + AsyncSeek + Send + Sync + Unpin + 'static
210{
211}
212
213impl<T> AsyncSeekBufReadWrite for T where
214  T: AsyncBufReadWrite + AsyncSeek + Send + Sync + Unpin + 'static
215{
216}
217
218#[doc(hidden)]
219#[macro_export]
220macro_rules! __close {
221  ($this:ident.$future_into_py: ident($py:ident)) => {{
222    let state = $this.0.clone();
223    $future_into_py($py, async move {
224      let mut state = state.lock().await;
225      *state = $crate::__private::State::Closed;
226      ::std::result::Result::Ok(())
227    })
228  }};
229}
230
231#[doc(hidden)]
232#[macro_export]
233macro_rules! __writer_close {
234  ($this:ident.$future_into_py: ident($py:ident)) => {{
235    use $crate::__private::futures::AsyncWriteExt;
236
237    let state = $this.0.clone();
238    $future_into_py($py, async move {
239      let mut state = state.lock().await;
240      match &mut *state {
241        $crate::__private::State::Ok(writer) => {
242          writer.close().await.map_err(|err| {
243            $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())
244          })?;
245          *state = $crate::__private::State::Closed;
246          ::std::result::Result::Ok(())
247        }
248        $crate::__private::State::Closed => ::std::result::Result::Ok(()),
249      }
250    })
251  }};
252}
253
254#[doc(hidden)]
255#[macro_export]
256macro_rules! __read {
257  ($this:ident.$future_into_py: ident($py:ident, $chunk_size: ident)) => {{
258    use $crate::__private::futures::AsyncReadExt;
259
260    let state = $this.0.clone();
261    $future_into_py($py, async move {
262      let mut state = state.lock().await;
263      match &mut *state {
264        $crate::__private::State::Ok(reader) => {
265          let mut buf: $crate::__private::Bytes = $crate::__private::smallvec::smallvec![0; $chunk_size];
266          match reader.read(&mut buf).await {
267            ::std::result::Result::Ok(n) => {
268              buf.truncate(n);
269
270              $crate::__private::pyo3::Python::with_gil(|py| $crate::__private::Buffer::new(buf).into_memory_view(py))
271            }
272            ::std::result::Result::Err(e) => ::std::result::Result::Err($crate::__private::pyo3::exceptions::PyIOError::new_err(e.to_string())),
273          }
274        }
275        $crate::__private::State::Closed => ::std::result::Result::Err($crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed")),
276      }
277    })
278  }};
279}
280
281#[doc(hidden)]
282#[macro_export]
283macro_rules! __read_exact {
284  ($this:ident.$future_into_py: ident($py:ident, $bytes: ident)) => {{
285    use $crate::__private::futures::AsyncReadExt;
286
287    let state = $this.0.clone();
288    $future_into_py($py, async move {
289      let mut state = state.lock().await;
290      match &mut *state {
291        $crate::__private::State::Ok(reader) => {
292          let mut buf: $crate::__private::Bytes = $crate::__private::smallvec::smallvec![0; $bytes];
293          match reader.read_exact(&mut buf).await {
294            Ok(_) => $crate::__private::pyo3::Python::with_gil(|py| $crate::__private::Buffer::new(buf).into_memory_view(py)),
295            ::std::result::Result::Err(e) => ::std::result::Result::Err($crate::__private::pyo3::exceptions::PyIOError::new_err(e.to_string())),
296          }
297        }
298        $crate::__private::State::Closed => ::std::result::Result::Err($crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed")),
299      }
300    })
301  }};
302}
303
304#[doc(hidden)]
305#[macro_export]
306macro_rules! __read_to_end {
307  ($this:ident.$future_into_py: ident($py:ident, $chunk_size: ident)) => {{
308    use $crate::__private::futures::AsyncReadExt;
309
310    let state = $this.0.clone();
311    $future_into_py($py, async move {
312      let mut state = state.lock().await;
313      match &mut *state {
314        $crate::__private::State::Ok(reader) => {
315          let mut buf = $crate::__private::Bytes::new();
316          loop {
317            // Resize buffer to accommodate new chunk
318            let old_len = buf.len();
319            buf.resize(old_len + $chunk_size, 0);
320
321            match reader.read(&mut buf[old_len..]).await {
322              Ok(0) => {
323                buf.truncate(old_len); // Truncate buffer to actual data length
324                break; // End of file
325              }
326              ::std::result::Result::Ok(n) => {
327                buf.truncate(old_len + n); // Truncate buffer to actual data length
328              }
329              ::std::result::Result::Err(e) => {
330                return ::std::result::Result::Err(
331                  $crate::__private::pyo3::exceptions::PyIOError::new_err(e.to_string()),
332                )
333              }
334            }
335          }
336
337          $crate::__private::pyo3::Python::with_gil(|py| {
338            $crate::__private::Buffer::new(buf).into_memory_view(py)
339          })
340        }
341        $crate::__private::State::Closed => ::std::result::Result::Err(
342          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
343        ),
344      }
345    })
346  }};
347}
348
349#[doc(hidden)]
350#[macro_export]
351macro_rules! __read_to_string {
352  ($this:ident.$future_into_py: ident($py:ident)) => {{
353    use $crate::__private::futures::AsyncReadExt;
354
355    let state = $this.0.clone();
356    $future_into_py($py, async move {
357      let mut state = state.lock().await;
358      match &mut *state {
359        $crate::__private::State::Ok(reader) => {
360          let mut buf = ::std::string::String::new();
361          reader
362            .read_to_string(&mut buf)
363            .await
364            .map(|_| buf)
365            .map_err(|e| $crate::__private::pyo3::exceptions::PyIOError::new_err(e.to_string()))
366        }
367        $crate::__private::State::Closed => ::std::result::Result::Err(
368          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
369        ),
370      }
371    })
372  }};
373}
374
375#[doc(hidden)]
376#[macro_export]
377macro_rules! __write {
378  ($this:ident.$future_into_py: ident($py:ident, $bytes: ident)) => {{
379    use $crate::__private::futures::AsyncWriteExt;
380
381    let state = $this.0.clone();
382    let bytes = $crate::__private::Bytes::from($bytes);
383    $future_into_py($py, async move {
384      let mut state = state.lock().await;
385      match &mut *state {
386        $crate::__private::State::Ok(writer) => writer
387          .write(&bytes)
388          .await
389          .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())),
390        $crate::__private::State::Closed => ::std::result::Result::Err(
391          $crate::__private::pyo3::exceptions::PyIOError::new_err("writer is closed"),
392        ),
393      }
394    })
395  }};
396}
397
398#[doc(hidden)]
399#[macro_export]
400macro_rules! __write_all {
401  ($this:ident.$future_into_py: ident($py:ident, $bytes: ident)) => {{
402    use $crate::__private::futures::AsyncWriteExt;
403
404    let state = $this.0.clone();
405    let bytes = $crate::__private::Bytes::from($bytes);
406    $future_into_py($py, async move {
407      let mut state = state.lock().await;
408      match &mut *state {
409        $crate::__private::State::Ok(writer) => writer
410          .write_all(&bytes)
411          .await
412          .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())),
413        $crate::__private::State::Closed => ::std::result::Result::Err(
414          $crate::__private::pyo3::exceptions::PyIOError::new_err("writer is closed"),
415        ),
416      }
417    })
418  }};
419}
420
421#[doc(hidden)]
422#[macro_export]
423macro_rules! __flush {
424  ($this:ident.$future_into_py: ident($py:ident)) => {{
425    use $crate::__private::futures::AsyncWriteExt;
426
427    let state = $this.0.clone();
428    $future_into_py($py, async move {
429      let mut state = state.lock().await;
430      match &mut *state {
431        $crate::__private::State::Ok(writer) => writer
432          .flush()
433          .await
434          .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())),
435        $crate::__private::State::Closed => ::std::result::Result::Err(
436          $crate::__private::pyo3::exceptions::PyIOError::new_err("writer is closed"),
437        ),
438      }
439    })
440  }};
441}
442
443#[doc(hidden)]
444#[macro_export]
445macro_rules! __fill_buf {
446  ($this:ident.$future_into_py: ident($py:ident)) => {{
447    use $crate::__private::futures::AsyncBufReadExt;
448
449    let state = $this.0.clone();
450    $future_into_py($py, async move {
451      let mut state = state.lock().await;
452      match &mut *state {
453        $crate::__private::State::Ok(reader) => {
454          let buf = reader
455            .fill_buf()
456            .await
457            .map(|buf| $crate::__private::Buffer::from(buf))
458            .map_err(|err| {
459              $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())
460            })?;
461
462          $crate::__private::pyo3::Python::with_gil(|py| buf.into_memory_view(py))
463        }
464        $crate::__private::State::Closed => ::std::result::Result::Err(
465          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
466        ),
467      }
468    })
469  }};
470}
471
472#[doc(hidden)]
473#[macro_export]
474macro_rules! __consume {
475  ($this:ident.$future_into_py: ident($py:ident, $amt:ident)) => {{
476    use $crate::__private::futures::AsyncBufReadExt;
477
478    let state = $this.0.clone();
479    $future_into_py($py, async move {
480      let mut state = state.lock().await;
481      match &mut *state {
482        $crate::__private::State::Ok(reader) => Ok(reader.consume_unpin($amt)),
483        $crate::__private::State::Closed => ::std::result::Result::Err(
484          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
485        ),
486      }
487    })
488  }};
489}
490
491#[doc(hidden)]
492#[macro_export]
493macro_rules! __read_until {
494  ($this:ident.$future_into_py: ident($py:ident, $byte:ident)) => {{
495    use $crate::__private::futures::AsyncBufReadExt;
496
497    let state = $this.0.clone();
498    $future_into_py($py, async move {
499      let mut state = state.lock().await;
500      match &mut *state {
501        $crate::__private::State::Ok(reader) => {
502          let mut buf = ::std::vec::Vec::new();
503          let buf = reader
504            .read_until($byte, &mut buf)
505            .await
506            .map(|_| $crate::__private::Buffer::from(buf))
507            .map_err(|err| {
508              $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())
509            })?;
510
511          $crate::__private::pyo3::Python::with_gil(|py| buf.into_memory_view(py))
512        }
513        $crate::__private::State::Closed => ::std::result::Result::Err(
514          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
515        ),
516      }
517    })
518  }};
519}
520
521#[doc(hidden)]
522#[macro_export]
523macro_rules! __read_line {
524  ($this:ident.$future_into_py: ident($py:ident)) => {{
525    use $crate::__private::futures::AsyncBufReadExt;
526
527    let state = $this.0.clone();
528    $future_into_py($py, async move {
529      let mut state = state.lock().await;
530      match &mut *state {
531        $crate::__private::State::Ok(reader) => {
532          let mut buf = ::std::string::String::new();
533          reader
534            .read_line(&mut buf)
535            .await
536            .map(|_| buf)
537            .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string()))
538        }
539        $crate::__private::State::Closed => ::std::result::Result::Err(
540          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
541        ),
542      }
543    })
544  }};
545}
546
547#[doc(hidden)]
548#[macro_export]
549macro_rules! __lines {
550  ($this:ident.$future_into_py: ident($py:ident)) => {{
551    use $crate::__private::futures::{AsyncBufReadExt, StreamExt};
552
553    let state = $this.0.clone();
554    $future_into_py($py, async move {
555      let mut state = state.lock().await;
556      match &mut *state {
557        $crate::__private::State::Ok(reader) => {
558          let mut lines = reader.lines();
559          let mut buf = ::std::vec::Vec::new();
560          while let ::std::option::Option::Some(line) = lines.next().await {
561            buf.push(line.map_err(|err| {
562              $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())
563            })?);
564          }
565          Ok(buf)
566        }
567        $crate::__private::State::Closed => ::std::result::Result::Err(
568          $crate::__private::pyo3::exceptions::PyIOError::new_err("reader is closed"),
569        ),
570      }
571    })
572  }};
573}
574
575#[doc(hidden)]
576#[macro_export]
577macro_rules! __seek {
578  ($this:ident.$future_into_py: ident($py:ident, $seek_from:ident)) => {{
579    use $crate::__private::futures::AsyncSeekExt;
580
581    let state = $this.0.clone();
582    $future_into_py($py, async move {
583      let mut state = state.lock().await;
584      match &mut *state {
585        $crate::__private::State::Ok(reader) => reader
586          .seek($seek_from.into())
587          .await
588          .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())),
589        $crate::__private::State::Closed => ::std::result::Result::Err(
590          $crate::__private::pyo3::exceptions::PyIOError::new_err("seeker is closed"),
591        ),
592      }
593    })
594  }};
595}
596
597#[doc(hidden)]
598#[macro_export]
599macro_rules! __position {
600  ($this:ident.$future_into_py: ident($py:ident)) => {{
601    use $crate::__private::futures::AsyncSeekExt;
602
603    let state = $this.0.clone();
604    $future_into_py($py, async move {
605      let mut state = state.lock().await;
606      match &mut *state {
607        $crate::__private::State::Ok(reader) => reader
608          .stream_position()
609          .await
610          .map_err(|err| $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())),
611        $crate::__private::State::Closed => ::std::result::Result::Err(
612          $crate::__private::pyo3::exceptions::PyIOError::new_err("seeker is closed"),
613        ),
614      }
615    })
616  }};
617}
618
619#[doc(hidden)]
620#[macro_export]
621macro_rules! __aexit {
622  ($this:ident.$future_into_py: ident($py:ident)) => {{
623    use $crate::__private::futures::AsyncSeekExt;
624
625    let state = $this.0.clone();
626    $future_into_py($py, async move {
627      let mut state = state.lock().await;
628      *state = $crate::__private::State::Closed;
629      ::std::result::Result::Ok(())
630    })
631  }};
632}
633
634#[doc(hidden)]
635#[macro_export]
636macro_rules! __writer_aexit {
637  ($this:ident.$future_into_py: ident($py:ident)) => {{
638    use $crate::__private::futures::AsyncWriteExt;
639
640    let state = $this.0.clone();
641    $future_into_py($py, async move {
642      let mut state = state.lock().await;
643      match &mut *state {
644        $crate::__private::State::Ok(writer) => {
645          writer.close().await.map_err(|err| {
646            $crate::__private::pyo3::exceptions::PyIOError::new_err(err.to_string())
647          })?;
648          *state = $crate::__private::State::Closed;
649          ::std::result::Result::Ok(())
650        }
651        $crate::__private::State::Closed => ::std::result::Result::Ok(()),
652      }
653    })
654  }};
655}
656
657#[doc(hidden)]
658#[macro_export]
659macro_rules! __impl_async_read {
660  ($ty:ty) => {
661    impl $crate::__private::futures::AsyncRead for $ty {
662      fn poll_read(
663        self: ::std::pin::Pin<&mut Self>,
664        cx: &mut ::std::task::Context<'_>,
665        buf: &mut [u8],
666      ) -> ::std::task::Poll<std::io::Result<usize>> {
667        let state = self.0.lock();
668        $crate::__private::futures::pin_mut!(state);
669        match state.poll(cx) {
670          ::std::task::Poll::Ready(mut state) => match &mut *state {
671            $crate::__private::State::Ok(reader) => {
672              let reader = ::std::pin::Pin::new(&mut *reader);
673              reader.poll_read(cx, buf)
674            }
675            $crate::__private::State::Closed => {
676              ::std::task::Poll::Ready(::std::result::Result::Err(std::io::Error::new(
677                std::io::ErrorKind::BrokenPipe,
678                "reader is closed",
679              )))
680            }
681          },
682          ::std::task::Poll::Pending => ::std::task::Poll::Pending,
683        }
684      }
685    }
686  };
687}
688
689#[doc(hidden)]
690#[macro_export]
691macro_rules! __impl_async_write {
692  ($ty: ty) => {
693    impl $crate::__private::futures::AsyncWrite for $ty {
694      fn poll_write(
695        self: ::std::pin::Pin<&mut Self>,
696        cx: &mut ::std::task::Context<'_>,
697        buf: &[u8],
698      ) -> ::std::task::Poll<std::io::Result<usize>> {
699        let state = self.0.lock();
700        $crate::__private::futures::pin_mut!(state);
701        match state.poll(cx) {
702          ::std::task::Poll::Ready(mut state) => match &mut *state {
703            $crate::__private::State::Ok(writer) => {
704              let writer = ::std::pin::Pin::new(&mut *writer);
705              writer.poll_write(cx, buf)
706            }
707            $crate::__private::State::Closed => {
708              ::std::task::Poll::Ready(::std::result::Result::Err(std::io::Error::new(
709                std::io::ErrorKind::BrokenPipe,
710                "writer is closed",
711              )))
712            }
713          },
714          ::std::task::Poll::Pending => ::std::task::Poll::Pending,
715        }
716      }
717
718      fn poll_flush(
719        self: ::std::pin::Pin<&mut Self>,
720        cx: &mut ::std::task::Context<'_>,
721      ) -> ::std::task::Poll<std::io::Result<()>> {
722        let state = self.0.lock();
723        $crate::__private::futures::pin_mut!(state);
724        match state.poll(cx) {
725          ::std::task::Poll::Ready(mut state) => match &mut *state {
726            $crate::__private::State::Ok(writer) => {
727              let writer = ::std::pin::Pin::new(&mut *writer);
728              writer.poll_flush(cx)
729            }
730            $crate::__private::State::Closed => {
731              ::std::task::Poll::Ready(::std::result::Result::Err(std::io::Error::new(
732                std::io::ErrorKind::BrokenPipe,
733                "writer is closed",
734              )))
735            }
736          },
737          ::std::task::Poll::Pending => ::std::task::Poll::Pending,
738        }
739      }
740
741      fn poll_close(
742        self: ::std::pin::Pin<&mut Self>,
743        cx: &mut ::std::task::Context<'_>,
744      ) -> ::std::task::Poll<std::io::Result<()>> {
745        let state = self.0.lock();
746        $crate::__private::futures::pin_mut!(state);
747        match state.poll(cx) {
748          ::std::task::Poll::Ready(mut state) => match &mut *state {
749            $crate::__private::State::Ok(writer) => {
750              let writer = ::std::pin::Pin::new(&mut *writer);
751              writer.poll_close(cx)
752            }
753            $crate::__private::State::Closed => {
754              ::std::task::Poll::Ready(::std::result::Result::Err(std::io::Error::new(
755                std::io::ErrorKind::BrokenPipe,
756                "writer is closed",
757              )))
758            }
759          },
760          ::std::task::Poll::Pending => ::std::task::Poll::Pending,
761        }
762      }
763    }
764  };
765}
766
767#[doc(hidden)]
768#[macro_export]
769macro_rules! __impl_async_seek {
770  ($ty:ident) => {
771    impl $crate::__private::futures::AsyncSeek for $ty {
772      fn poll_seek(
773        self: ::std::pin::Pin<&mut Self>,
774        cx: &mut ::std::task::Context<'_>,
775        pos: std::io::SeekFrom,
776      ) -> ::std::task::Poll<std::io::Result<u64>> {
777        let state = self.0.lock();
778        $crate::__private::futures::pin_mut!(state);
779        match state.poll(cx) {
780          ::std::task::Poll::Ready(mut state) => match &mut *state {
781            $crate::__private::State::Ok(reader) => {
782              let reader = ::std::pin::Pin::new(&mut *reader);
783              reader.poll_seek(cx, pos)
784            }
785            $crate::__private::State::Closed => {
786              ::std::task::Poll::Ready(::std::result::Result::Err(std::io::Error::new(
787                std::io::ErrorKind::BrokenPipe,
788                "reader is closed",
789              )))
790            }
791          },
792          ::std::task::Poll::Pending => ::std::task::Poll::Pending,
793        }
794      }
795    }
796  };
797}
798
799#[macro_export]
800macro_rules! async_seekable_writer {
801  ($future_into_py: ident($name:literal: $inner:ty $({
802    $($tt:tt)*
803  })?)) => {
804    $crate::__private::paste::paste! {
805      #[doc = concat!("`", $name, "` implements `AsyncWrite` and `AsyncSeek`.")]
806      #[derive(Clone)]
807      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
808      pub struct [< $name:camel >](::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
809
810      impl [< $name:camel >] {
811        pub fn new(inner: $inner) -> Self {
812          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
813        }
814      }
815
816      $crate::__impl_async_write!([< $name:camel >]);
817
818      $crate::__impl_async_seek!([< $name:camel >]);
819
820      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
821      impl [< $name:camel >] {
822
823        $($($tt)*)?
824
825        pub fn write<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
826          $crate::__write!(self.$future_into_py(py, bytes))
827        }
828
829        pub fn write_all<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
830          $crate::__write_all!(self.$future_into_py(py, bytes))
831        }
832
833        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
834          $crate::__flush!(self.$future_into_py(py))
835        }
836
837        pub fn seek<'a>(&'a self, seek_from: $crate::__private::SeekFrom, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
838          $crate::__seek!(self.$future_into_py(py, seek_from))
839        }
840
841        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
842          $crate::__position!(self.$future_into_py(py))
843        }
844
845        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
846          $crate::__writer_close!(self.$future_into_py(py))
847        }
848
849        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
850          let slf = slf.into_py(py);
851          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
852        }
853
854        fn __aexit__<'a>(
855          &self,
856          py: $crate::__private::pyo3::Python<'a>,
857          _exc_type: &'a $crate::__private::pyo3::PyAny,
858          _exc_value: &'a $crate::__private::pyo3::PyAny,
859          _traceback: &'a $crate::__private::pyo3::PyAny,
860        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
861          $crate::__writer_aexit!(self.$future_into_py(py))
862        }
863      }
864    }
865  };
866}
867
868#[macro_export]
869macro_rules! async_seekable_reader_writer {
870  ($future_into_py: ident($name: literal: $inner:ty $({
871    $($tt:tt)*
872  })?)) => {
873    $crate::__private::paste::paste! {
874      #[doc = concat!("`", $name, "` implements `AsyncRead`, `AsyncWrite` and `AsyncSeek`.")]
875      #[derive(Clone)]
876      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
877      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
878
879      impl [< $name:camel >] {
880        pub fn new(inner: $inner) -> Self {
881          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
882        }
883      }
884
885      $crate::__impl_async_read!([< $name:camel >]);
886
887      $crate::__impl_async_write!([< $name:camel >]);
888
889      $crate::__impl_async_seek!([< $name:camel >]);
890
891      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
892      impl [< $name:camel >] {
893        $($($tt)*)?
894
895        #[pyo3(signature = (chunk_size = 1024))]
896        pub fn read<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
897          $crate::__read!(self.$future_into_py(py, chunk_size))
898        }
899
900        pub fn read_exact<'a>(&'a self, bytes: usize,py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
901          $crate::__read_exact!(self.$future_into_py(py, bytes))
902        }
903
904        #[pyo3(signature = (chunk_size = 1024))]
905        pub fn read_to_end<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
906          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
907        }
908
909        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
910          $crate::__read_to_string!(self.$future_into_py(py))
911        }
912
913        pub fn write<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
914          $crate::__write!(self.$future_into_py(py, bytes))
915        }
916
917        pub fn write_all<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
918          $crate::__write_all!(self.$future_into_py(py, bytes))
919        }
920
921        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
922          $crate::__flush!(self.$future_into_py(py))
923        }
924
925        pub fn seek<'a>(&'a self, seek_from: $crate::__private::SeekFrom, py: $crate::__private::pyo3::Python<'a>)
926          -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
927         $crate::__seek!(self.$future_into_py(py, seek_from))
928        }
929
930        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
931          $crate::__position!(self.$future_into_py(py))
932        }
933
934        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
935          $crate::__writer_close!(self.$future_into_py(py))
936        }
937
938        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
939          let slf = slf.into_py(py);
940          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
941        }
942
943        fn __aexit__<'a>(
944          &self,
945          py: $crate::__private::pyo3::Python<'a>,
946          _exc_type: &'a $crate::__private::pyo3::PyAny,
947          _exc_value: &'a $crate::__private::pyo3::PyAny,
948          _traceback: &'a $crate::__private::pyo3::PyAny,
949        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
950          $crate::__writer_aexit!(self.$future_into_py(py))
951        }
952      }
953    }
954  };
955}
956
957#[macro_export]
958macro_rules! async_seekable_buf_reader_writer {
959  ($future_into_py: ident($name: literal: $inner:ty $({
960    $($tt:tt)*
961  })?)) => {
962    $crate::__private::paste::paste! {
963      #[doc = concat!("`", $name, "` implements `AsyncBufRead`, `AsyncWrite` and `AsyncSeek`.")]
964      #[derive(Clone)]
965      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
966      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
967
968      impl [< $name:camel >] {
969        pub fn new(inner: $inner) -> Self {
970          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
971        }
972      }
973
974      $crate::__impl_async_read!([< $name:camel >]);
975
976      $crate::__impl_async_write!([< $name:camel >]);
977
978      $crate::__impl_async_seek!([< $name:camel >]);
979
980      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
981      impl [< $name:camel >] {
982        $($($tt)*)?
983
984        #[pyo3(signature = (chunk_size = 1024))]
985        pub fn read<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
986          $crate::__read!(self.$future_into_py(py, chunk_size))
987        }
988
989        pub fn read_exact<'a>(&'a self, bytes: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
990          $crate::__read_exact!(self.$future_into_py(py, bytes))
991        }
992
993        #[pyo3(signature = (chunk_size = 1024))]
994        pub fn read_to_end<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
995          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
996        }
997
998        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
999          $crate::__read_to_string!(self.$future_into_py(py))
1000        }
1001
1002        pub fn write<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1003          $crate::__write!(self.$future_into_py(py, bytes))
1004        }
1005
1006        pub fn write_all<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1007          $crate::__write_all!(self.$future_into_py(py, bytes))
1008        }
1009
1010        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1011          $crate::__flush!(self.$future_into_py(py))
1012        }
1013
1014        pub fn seek<'a>(&'a self, seek_from: $crate::__private::SeekFrom, py: $crate::__private::pyo3::Python<'a>)
1015          -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1016         $crate::__seek!(self.$future_into_py(py, seek_from))
1017        }
1018
1019        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1020          $crate::__position!(self.$future_into_py(py))
1021        }
1022
1023        pub fn fill_buf<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1024          $crate::__fill_buf!(self.$future_into_py(py))
1025        }
1026
1027        pub fn consume<'a>(&'a self, amt: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1028          $crate::__consume!(self.$future_into_py(py, amt))
1029        }
1030
1031        pub fn read_until<'a>(&'a self, byte: u8, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1032          $crate::__read_until!(self.$future_into_py(py, byte))
1033        }
1034
1035        pub fn read_line<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1036          $crate::__read_line!(self.$future_into_py(py))
1037        }
1038
1039        pub fn lines<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1040          $crate::__lines!(self.$future_into_py(py))
1041        }
1042
1043        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1044          $crate::__writer_close!(self.$future_into_py(py))
1045        }
1046
1047        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1048          let slf = slf.into_py(py);
1049          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
1050        }
1051
1052        fn __aexit__<'a>(
1053          &self,
1054          py: $crate::__private::pyo3::Python<'a>,
1055          _exc_type: &'a $crate::__private::pyo3::PyAny,
1056          _exc_value: &'a $crate::__private::pyo3::PyAny,
1057          _traceback: &'a $crate::__private::pyo3::PyAny,
1058        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1059          $crate::__writer_aexit!(self.$future_into_py(py))
1060        }
1061      }
1062    }
1063  };
1064}
1065
1066#[macro_export]
1067macro_rules! async_reader {
1068  ($future_into_py: ident($name: literal: $inner:ty $({
1069    $($tt:tt)*
1070  })?)) => {
1071    $crate::__private::paste::paste! {
1072      #[doc = concat!("`", $name, "` implements `AsyncRead`.")]
1073      #[derive(Clone)]
1074      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
1075      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
1076
1077      impl [< $name:camel >] {
1078        pub fn new(inner: $inner) -> Self {
1079          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
1080        }
1081      }
1082
1083      $crate::__impl_async_read!([< $name:camel >]);
1084
1085      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
1086      impl [< $name:camel >] {
1087        $($($tt)*)?
1088
1089        #[pyo3(signature = (chunk_size = 1024))]
1090        pub fn read<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1091          $crate::__read!(self.$future_into_py(py, chunk_size))
1092        }
1093
1094        pub fn read_exact<'a>(&'a self, bytes: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1095          $crate::__read_exact!(self.$future_into_py(py, bytes))
1096        }
1097
1098        #[pyo3(signature = (chunk_size = 1024))]
1099        pub fn read_to_end<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1100          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
1101        }
1102
1103        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1104          $crate::__read_to_string!(self.$future_into_py(py))
1105        }
1106
1107        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1108         $crate::__close!(self.$future_into_py(py))
1109        }
1110
1111        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1112          let slf = slf.into_py(py);
1113          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
1114        }
1115
1116        fn __aexit__<'a>(
1117          &self,
1118          py: $crate::__private::pyo3::Python<'a>,
1119          _exc_type: &'a $crate::__private::pyo3::PyAny,
1120          _exc_value: &'a $crate::__private::pyo3::PyAny,
1121          _traceback: &'a $crate::__private::pyo3::PyAny,
1122        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1123          $crate::__aexit!(self.$future_into_py(py))
1124        }
1125      }
1126    }
1127  };
1128}
1129
1130#[macro_export]
1131macro_rules! async_writer {
1132  ($future_into_py: ident($name: literal: $inner:ty $({
1133    $($tt:tt)*
1134  })?)) => {
1135    $crate::__private::paste::paste! {
1136      #[doc = concat!("`", $name, "` implements `AsyncWrite`.")]
1137      #[derive(Clone)]
1138      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
1139      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
1140
1141      impl [< $name:camel >] {
1142        pub fn new(inner: $inner) -> Self {
1143          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
1144        }
1145      }
1146
1147      $crate::__impl_async_write!([< $name:camel >]);
1148
1149      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
1150      impl [< $name:camel >] {
1151        $($($tt)*)?
1152
1153        pub fn write<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1154          $crate::__write!(self.$future_into_py(py, bytes))
1155        }
1156
1157        pub fn write_all<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1158          $crate::__write_all!(self.$future_into_py(py, bytes))
1159        }
1160
1161        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1162          $crate::__flush!(self.$future_into_py(py))
1163        }
1164
1165        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1166          $crate::__writer_close!(self.$future_into_py(py))
1167        }
1168
1169        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1170          let slf = slf.into_py(py);
1171          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
1172        }
1173
1174        fn __aexit__<'a>(
1175          &self,
1176          py: $crate::__private::pyo3::Python<'a>,
1177          _exc_type: &'a $crate::__private::pyo3::PyAny,
1178          _exc_value: &'a $crate::__private::pyo3::PyAny,
1179          _traceback: &'a $crate::__private::pyo3::PyAny,
1180        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1181          $crate::__writer_aexit!(self.$future_into_py(py))
1182        }
1183      }
1184    }
1185  };
1186}
1187
1188#[macro_export]
1189macro_rules! async_reader_writer {
1190  ($future_into_py: ident($name: literal: $inner:ty $({
1191    $($tt:tt)*
1192  })?)) => {
1193    $crate::__private::paste::paste! {
1194      #[doc = concat!("`", $name, "` implements `AsyncRead` and `AsyncWrite`.")]
1195      #[derive(Clone)]
1196      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
1197      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
1198
1199      impl [< $name:camel >] {
1200        pub fn new(inner: $inner) -> Self {
1201          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
1202        }
1203      }
1204
1205      $crate::__impl_async_read!([< $name:camel >]);
1206
1207      $crate::__impl_async_write!([< $name:camel >]);
1208
1209      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
1210      impl [< $name:camel >] {
1211        $($($tt)*)?
1212
1213        #[pyo3(signature = (chunk_size = 1024))]
1214        pub fn read<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1215          $crate::__read!(self.$future_into_py(py, chunk_size))
1216        }
1217
1218        pub fn read_exact<'a>(&'a self, bytes: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1219          $crate::__read_exact!(self.$future_into_py(py, bytes))
1220        }
1221
1222        #[pyo3(signature = (chunk_size = 1024))]
1223        pub fn read_to_end<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1224          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
1225        }
1226
1227        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1228          $crate::__read_to_string!(self.$future_into_py(py))
1229        }
1230
1231        pub fn write<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1232          $crate::__write!(self.$future_into_py(py, bytes))
1233        }
1234
1235        pub fn write_all<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1236          $crate::__write_all!(self.$future_into_py(py, bytes))
1237        }
1238
1239        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1240          $crate::__flush!(self.$future_into_py(py))
1241        }
1242
1243        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1244          $crate::__writer_close!(self.$future_into_py(py))
1245        }
1246
1247        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1248          let slf = slf.into_py(py);
1249          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
1250        }
1251
1252        fn __aexit__<'a>(
1253          &self,
1254          py: $crate::__private::pyo3::Python<'a>,
1255          _exc_type: &'a $crate::__private::pyo3::PyAny,
1256          _exc_value: &'a $crate::__private::pyo3::PyAny,
1257          _traceback: &'a $crate::__private::pyo3::PyAny,
1258        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1259          $crate::__writer_aexit!(self.$future_into_py(py))
1260        }
1261      }
1262    }
1263  }
1264}
1265
1266#[macro_export]
1267macro_rules! async_buf_reader {
1268  ($future_into_py: ident($name: literal: $inner:ty $({
1269    $($tt:tt)*
1270  })?)) => {
1271    $crate::__private::paste::paste! {
1272      #[doc = concat!("`", $name, "` implements `AsyncBufRead`.")]
1273      #[derive(Clone)]
1274      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
1275      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
1276
1277      impl [< $name:camel >] {
1278        pub fn new(inner: $inner) -> Self {
1279          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
1280        }
1281      }
1282
1283      $crate::__impl_async_read!([< $name:camel >]);
1284
1285      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
1286      impl [< $name:camel >] {
1287        $($($tt)*)?
1288
1289        #[pyo3(signature = (chunk_size = 1024))]
1290        pub fn read<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1291          $crate::__read!(self.$future_into_py(py, chunk_size))
1292        }
1293
1294        pub fn read_exact<'a>(&'a self, bytes: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1295          $crate::__read_exact!(self.$future_into_py(py, bytes))
1296        }
1297
1298        #[pyo3(signature = (chunk_size = 1024))]
1299        pub fn read_to_end<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1300          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
1301        }
1302
1303        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1304          $crate::__read_to_string!(self.$future_into_py(py))
1305        }
1306
1307        pub fn fill_buf<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1308          $crate::__fill_buf!(self.$future_into_py(py))
1309        }
1310
1311        pub fn consume<'a>(&'a self, amt: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1312          $crate::__consume!(self.$future_into_py(py, amt))
1313        }
1314
1315        pub fn read_until<'a>(&'a self, byte: u8, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1316          $crate::__read_until!(self.$future_into_py(py, byte))
1317        }
1318
1319        pub fn read_line<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1320          $crate::__read_line!(self.$future_into_py(py))
1321        }
1322
1323        pub fn lines<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1324          $crate::__lines!(self.$future_into_py(py))
1325        }
1326
1327        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1328         $crate::__close!(self.$future_into_py(py))
1329        }
1330
1331        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1332          let slf = slf.into_py(py);
1333          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
1334        }
1335
1336        fn __aexit__<'a>(
1337          &self,
1338          py: $crate::__private::pyo3::Python<'a>,
1339          _exc_type: &'a $crate::__private::pyo3::PyAny,
1340          _exc_value: &'a $crate::__private::pyo3::PyAny,
1341          _traceback: &'a $crate::__private::pyo3::PyAny,
1342        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1343          $crate::__aexit!(self.$future_into_py(py))
1344        }
1345      }
1346    }
1347  }
1348}
1349
1350#[macro_export]
1351macro_rules! async_buf_reader_writer {
1352  ($future_into_py: ident($name: literal: $inner:ty $({
1353    $($tt:tt)*
1354  })?)) => {
1355    $crate::__private::paste::paste! {
1356      #[doc = concat!("`", $name, "` implements `AsyncBufRead` and `AsyncWrite`.")]
1357      #[derive(Clone)]
1358      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
1359      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
1360
1361      impl [< $name:camel >] {
1362        pub fn new(inner: $inner) -> Self {
1363          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
1364        }
1365      }
1366
1367      $crate::__impl_async_read!([< $name:camel >]);
1368
1369      $crate::__impl_async_write!([< $name:camel >]);
1370
1371      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
1372      impl [< $name:camel >] {
1373        $($($tt)*)?
1374
1375        #[pyo3(signature = (chunk_size = 1024))]
1376        pub fn read<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1377          $crate::__read!(self.$future_into_py(py, chunk_size))
1378        }
1379
1380        pub fn read_exact<'a>(&'a self, bytes: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1381          $crate::__read_exact!(self.$future_into_py(py, bytes))
1382        }
1383
1384        #[pyo3(signature = (chunk_size = 1024))]
1385        pub fn read_to_end<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1386          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
1387        }
1388
1389        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1390          $crate::__read_to_string!(self.$future_into_py(py))
1391        }
1392
1393        pub fn write<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1394          $crate::__write!(self.$future_into_py(py, bytes))
1395        }
1396
1397        pub fn write_all<'a>(&self, bytes: &'a [u8], py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1398          $crate::__write_all!(self.$future_into_py(py, bytes))
1399        }
1400
1401        pub fn flush<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1402          $crate::__flush!(self.$future_into_py(py))
1403        }
1404
1405        pub fn fill_buf<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1406          $crate::__fill_buf!(self.$future_into_py(py))
1407        }
1408
1409        pub fn consume<'a>(&'a self, amt: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1410          $crate::__consume!(self.$future_into_py(py, amt))
1411        }
1412
1413        pub fn read_until<'a>(&'a self, byte: u8, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1414          $crate::__read_until!(self.$future_into_py(py, byte))
1415        }
1416
1417        pub fn read_line<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1418          $crate::__read_line!(self.$future_into_py(py))
1419        }
1420
1421        pub fn lines<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1422          $crate::__lines!(self.$future_into_py(py))
1423        }
1424
1425        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1426          $crate::__writer_close!(self.$future_into_py(py))
1427        }
1428
1429        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1430          let slf = slf.into_py(py);
1431          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
1432        }
1433
1434        fn __aexit__<'a>(
1435          &self,
1436          py: $crate::__private::pyo3::Python<'a>,
1437          _exc_type: &'a $crate::__private::pyo3::PyAny,
1438          _exc_value: &'a $crate::__private::pyo3::PyAny,
1439          _traceback: &'a $crate::__private::pyo3::PyAny,
1440        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1441          $crate::__writer_aexit!(self.$future_into_py(py))
1442        }
1443      }
1444    }
1445  }
1446}
1447
1448#[macro_export]
1449macro_rules! async_seeker {
1450  ($future_into_py: ident($name: literal: $inner:ty $({
1451    $($tt:tt)*
1452  })?)) => {
1453    $crate::__private::paste::paste! {
1454      #[doc = concat!("`", $name, "` implements `AsyncSeek`.")]
1455      #[derive(Clone)]
1456      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
1457      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
1458
1459      impl [< $name:camel >] {
1460        pub fn new(inner: $inner) -> Self {
1461          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
1462        }
1463      }
1464
1465      $crate::__impl_async_seek!([< $name:camel >]);
1466
1467      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
1468      impl [< $name:camel >] {
1469        $($($tt)*)?
1470
1471        pub fn seek<'a>(&'a self, seek_from: $crate::__private::SeekFrom, py: $crate::__private::pyo3::Python<'a>)
1472          -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1473         $crate::__seek!(self.$future_into_py(py, seek_from))
1474        }
1475
1476        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1477          $crate::__position!(self.$future_into_py(py))
1478        }
1479
1480        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1481         $crate::__close!(self.$future_into_py(py))
1482        }
1483
1484        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1485          let slf = slf.into_py(py);
1486          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
1487        }
1488
1489        fn __aexit__<'a>(
1490          &self,
1491          py: $crate::__private::pyo3::Python<'a>,
1492          _exc_type: &'a $crate::__private::pyo3::PyAny,
1493          _exc_value: &'a $crate::__private::pyo3::PyAny,
1494          _traceback: &'a $crate::__private::pyo3::PyAny,
1495        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1496          $crate::__aexit!(self.$future_into_py(py))
1497        }
1498      }
1499    }
1500  }
1501}
1502
1503#[macro_export]
1504macro_rules! async_seekable_reader {
1505  ($future_into_py: ident($name: literal: $inner:ty $({
1506    $($tt:tt)*
1507  })?)) => {
1508    $crate::__private::paste::paste! {
1509      #[doc = concat!("`", $name, "` implements `AsyncRead` and `AsyncSeek`.")]
1510      #[derive(Clone)]
1511      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
1512      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
1513
1514      impl [< $name:camel >] {
1515        pub fn new(inner: $inner) -> Self {
1516          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
1517        }
1518      }
1519
1520      $crate::__impl_async_read!([< $name:camel >]);
1521
1522      $crate::__impl_async_seek!([< $name:camel >]);
1523
1524      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
1525      impl [< $name:camel >] {
1526        $($($tt)*)?
1527
1528        #[pyo3(signature = (chunk_size = 1024))]
1529        pub fn read<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1530          $crate::__read!(self.$future_into_py(py, chunk_size))
1531        }
1532
1533        pub fn read_exact<'a>(&'a self, bytes: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1534          $crate::__read_exact!(self.$future_into_py(py, bytes))
1535        }
1536
1537        #[pyo3(signature = (chunk_size = 1024))]
1538        pub fn read_to_end<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1539          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
1540        }
1541
1542        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1543          $crate::__read_to_string!(self.$future_into_py(py))
1544        }
1545
1546        pub fn seek<'a>(&'a self, seek_from: $crate::__private::SeekFrom, py: $crate::__private::pyo3::Python<'a>)
1547          -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1548         $crate::__seek!(self.$future_into_py(py, seek_from))
1549        }
1550
1551        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1552          $crate::__position!(self.$future_into_py(py))
1553        }
1554
1555        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1556         $crate::__close!(self.$future_into_py(py))
1557        }
1558
1559        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1560          let slf = slf.into_py(py);
1561          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
1562        }
1563
1564        fn __aexit__<'a>(
1565          &self,
1566          py: $crate::__private::pyo3::Python<'a>,
1567          _exc_type: &'a $crate::__private::pyo3::PyAny,
1568          _exc_value: &'a $crate::__private::pyo3::PyAny,
1569          _traceback: &'a $crate::__private::pyo3::PyAny,
1570        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1571          $crate::__aexit!(self.$future_into_py(py))
1572        }
1573      }
1574    }
1575  }
1576}
1577
1578#[macro_export]
1579macro_rules! async_seekable_buf_reader {
1580  ($future_into_py: ident($name: literal: $inner:ty $({
1581    $($tt:tt)*
1582  })?)) => {
1583    $crate::__private::paste::paste! {
1584      #[doc = concat!("`", $name, "` implements `AsyncBufRead` and `AsyncSeek`.")]
1585      #[derive(Clone)]
1586      #[$crate::__private::pyo3::prelude::pyclass(name = $name, crate = "::pyo3io_macros::__private::pyo3")]
1587      pub struct [< $name:camel >] (::std::sync::Arc<$crate::__private::Mutex<$crate::__private::State<$inner>>>);
1588
1589      impl [< $name:camel >] {
1590        pub fn new(inner: $inner) -> Self {
1591          Self(::std::sync::Arc::new($crate::__private::Mutex::new($crate::__private::State::Ok(inner))))
1592        }
1593      }
1594
1595      $crate::__impl_async_read!([< $name:camel >]);
1596
1597      $crate::__impl_async_seek!([< $name:camel >]);
1598
1599      #[$crate::__private::pyo3::prelude::pymethods(crate = "::pyo3io_macros::__private::pyo3")]
1600      impl [< $name:camel >] {
1601        $($($tt)*)?
1602
1603        #[pyo3(signature = (chunk_size = 1024))]
1604        pub fn read<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1605          $crate::__read!(self.$future_into_py(py, chunk_size))
1606        }
1607
1608        pub fn read_exact<'a>(&'a self, bytes: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1609          $crate::__read_exact!(self.$future_into_py(py, bytes))
1610        }
1611
1612        #[pyo3(signature = (chunk_size = 1024))]
1613        pub fn read_to_end<'a>(&'a self, chunk_size: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1614          $crate::__read_to_end!(self.$future_into_py(py, chunk_size))
1615        }
1616
1617        pub fn read_to_string<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1618          $crate::__read_to_string!(self.$future_into_py(py))
1619        }
1620
1621        pub fn seek<'a>(&'a self, seek_from: $crate::__private::SeekFrom, py: $crate::__private::pyo3::Python<'a>)
1622          -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1623         $crate::__seek!(self.$future_into_py(py, seek_from))
1624        }
1625
1626        pub fn position<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1627          $crate::__position!(self.$future_into_py(py))
1628        }
1629
1630        pub fn fill_buf<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1631          $crate::__fill_buf!(self.$future_into_py(py))
1632        }
1633
1634        pub fn consume<'a>(&'a self, amt: usize, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1635          $crate::__consume!(self.$future_into_py(py, amt))
1636        }
1637
1638        pub fn read_until<'a>(&'a self, byte: u8, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1639          $crate::__read_until!(self.$future_into_py(py, byte))
1640        }
1641
1642        pub fn read_line<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1643          $crate::__read_line!(self.$future_into_py(py))
1644        }
1645
1646        pub fn lines<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1647          $crate::__lines!(self.$future_into_py(py))
1648        }
1649
1650        pub fn close<'a>(&'a self, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1651         $crate::__close!(self.$future_into_py(py))
1652        }
1653
1654        fn __aenter__<'a>(slf: $crate::__private::pyo3::PyRef<'a, Self>, py: $crate::__private::pyo3::Python<'a>) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1655          let slf = slf.into_py(py);
1656          $future_into_py(py, async move { ::std::result::Result::Ok(slf) })
1657        }
1658
1659        fn __aexit__<'a>(
1660          &self,
1661          py: $crate::__private::pyo3::Python<'a>,
1662          _exc_type: &'a $crate::__private::pyo3::PyAny,
1663          _exc_value: &'a $crate::__private::pyo3::PyAny,
1664          _traceback: &'a $crate::__private::pyo3::PyAny,
1665        ) -> $crate::__private::pyo3::PyResult<&'a $crate::__private::pyo3::PyAny> {
1666          $crate::__aexit!(self.$future_into_py(py))
1667        }
1668      }
1669    }
1670  };
1671}
1672
1673pub fn register_types(m: &PyModule) -> PyResult<()> {
1674  m.add_class::<Whence>()?;
1675  m.add_class::<SeekFrom>()?;
1676  Ok(())
1677}
1678
1679/// Register an async runtime.
1680///
1681/// # Example
1682///
1683/// ```
1684/// use pyo3io_macros::register_async_runtime;
1685///
1686/// register_async_runtime!(
1687///  #[cfg(feature = "tokio")]
1688///  #[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
1689///  pub mod tokio(use pyo3_asyncio::tokio::future_into_py);
1690/// );
1691///
1692/// ```
1693#[macro_export]
1694macro_rules! register_async_runtime {
1695  (
1696    $(#[$outer:meta])*
1697    $vis:vis mod $name:ident(use $future_into_py: path) $({
1698      $($tt:tt)*
1699    })?
1700    $(;)?
1701  ) => {
1702    $vis mod $name {
1703      use $crate::__private::{futures::*, pyo3::*};
1704      use $future_into_py as future_into_py;
1705      $($($tt)*)?
1706
1707      $crate::async_reader!(future_into_py("AsyncReader": ::std::boxed::Box<dyn $crate::__private::futures::AsyncRead + ::core::marker::Send + ::core::marker::Sync + ::core::marker::Unpin + 'static>));
1708      $crate::async_writer!(future_into_py("AsyncWriter": ::std::boxed::Box<dyn $crate::__private::futures::AsyncWrite + ::core::marker::Send + ::core::marker::Sync + ::core::marker::Unpin + 'static>));
1709      $crate::async_reader_writer!(future_into_py("AsyncReaderWriter": ::std::boxed::Box<dyn $crate::AsyncReadWrite>));
1710      $crate::async_buf_reader!(future_into_py("AsyncBufReader": ::std::boxed::Box<dyn $crate::__private::futures::AsyncBufRead + ::core::marker::Send + ::core::marker::Sync + ::core::marker::Unpin + 'static>));
1711      $crate::async_buf_reader_writer!(future_into_py("AsyncBufReaderWriter": ::std::boxed::Box<dyn $crate::AsyncBufReadWrite>));
1712      $crate::async_seeker!(future_into_py("AsyncSeeker": ::std::boxed::Box<dyn $crate::__private::futures::AsyncSeek + ::core::marker::Send + ::core::marker::Sync + ::core::marker::Unpin + 'static>));
1713      $crate::async_seekable_reader!(future_into_py("AsyncSeekableReader": ::std::boxed::Box<dyn $crate::AsyncSeekRead>));
1714      $crate::async_seekable_buf_reader!(future_into_py("AsyncSeekableBufReader": ::std::boxed::Box<dyn $crate::AsyncSeekBufRead>));
1715      $crate::async_seekable_writer!(future_into_py("AsyncSeekableWriter": ::std::boxed::Box<dyn $crate::AsyncSeekWrite>));
1716      $crate::async_seekable_reader_writer!(future_into_py("AsyncSeekableReaderWriter": ::std::boxed::Box<dyn $crate::AsyncSeekReadWrite>));
1717      $crate::async_seekable_buf_reader_writer!(future_into_py("AsyncSeekableBufReaderWriter": ::std::boxed::Box<dyn $crate::AsyncSeekBufReadWrite>));
1718
1719      /// Register all ffi I/O structs in to Python module.
1720      pub fn register_types(m: &$crate::__private::pyo3::prelude::PyModule) -> $crate::__private::pyo3::PyResult<()> {
1721        m.add_class::<AsyncReader>()?;
1722        m.add_class::<AsyncWriter>()?;
1723        m.add_class::<AsyncReaderWriter>()?;
1724        m.add_class::<AsyncBufReader>()?;
1725        m.add_class::<AsyncBufReaderWriter>()?;
1726        m.add_class::<AsyncSeeker>()?;
1727        m.add_class::<AsyncSeekableReader>()?;
1728        m.add_class::<AsyncSeekableBufReader>()?;
1729        m.add_class::<AsyncSeekableWriter>()?;
1730        m.add_class::<AsyncSeekableReaderWriter>()?;
1731        m.add_class::<AsyncSeekableBufReaderWriter>()?;
1732        ::std::result::Result::Ok(())
1733      }
1734    }
1735  }
1736}
pyo3io_macros/lib.rs

pyo3io_macros/
lib.rs
