Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

7.11 kB

use std::{
    fmt,
    pin::Pin,
    sync::{Arc, Mutex},
    task::{Context as TaskContext, Poll},
};

use anyhow::Result;
use futures::{Stream as StreamTrait, StreamExt, TryStreamExt};
use serde::{Deserialize, Deserializer, Serialize, Serializer};

/// Streams allow for streaming values from source to sink.
///
/// A Stream implements both a reader (which implements the Stream trait), and a
/// writer (which can be sent to another thread). As new values are written, any
/// pending readers will be woken up to receive the new value.
#[derive(Clone, Debug)]
pub struct Stream<T: Clone + Send> {
    inner: Arc<Mutex<StreamState<T>>>,
}

/// The StreamState actually holds the data of a Stream.
struct StreamState<T> {
    source: Option<Pin<Box<dyn StreamTrait<Item = T> + Send>>>,
    pulled: Vec<T>,
}

impl<T: Clone + Send> Stream<T> {
    /// Constructs a new Stream, and immediately closes it with only the passed
    /// values.
    pub fn new_closed(pulled: Vec<T>) -> Self {
        Self {
            inner: Arc::new(Mutex::new(StreamState {
                source: None,
                pulled,
            })),
        }
    }

    /// Creates a new Stream, which will lazily pull from the source stream.
    pub fn new_open(
        pulled: Vec<T>,
        source: Box<dyn StreamTrait<Item = T> + Send + 'static>,
    ) -> Self {
        Self {
            inner: Arc::new(Mutex::new(StreamState {
                source: Some(Box::into_pin(source)),
                pulled,
            })),
        }
    }

    /// Returns a [StreamTrait] implementation to poll values out of our Stream.
    pub fn read(&self) -> StreamRead<T> {
        StreamRead {
            source: self.clone(),
            index: 0,
        }
    }

    pub async fn into_single(&self) -> SingleValue<T> {
        let mut stream = self.read();
        let Some(first) = stream.next().await else {
            return SingleValue::None;
        };

        if stream.next().await.is_some() {
            return SingleValue::Multiple;
        }

        SingleValue::Single(first)
    }
}

impl<T: Clone + Send, E: Clone + Send> Stream<Result<T, E>> {
    /// Converts a TryStream into a single value when possible.
    pub async fn try_into_single(&self) -> Result<SingleValue<T>, E> {
        let mut stream = self.read();
        let Some(first) = stream.try_next().await? else {
            return Ok(SingleValue::None);
        };

        if stream.try_next().await?.is_some() {
            return Ok(SingleValue::Multiple);
        }

        Ok(SingleValue::Single(first))
    }
}

pub enum SingleValue<T> {
    /// The Stream did not hold a value.
    None,

    /// The Stream held multiple values.
    Multiple,

    /// The held only a single value.
    Single(T),
}

impl<T: fmt::Debug> fmt::Debug for SingleValue<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SingleValue::None => f.debug_struct("SingleValue::None").finish(),
            SingleValue::Multiple => f.debug_struct("SingleValue::Multiple").finish(),
            SingleValue::Single(v) => f.debug_tuple("SingleValue::Single").field(v).finish(),
        }
    }
}

impl<T: Clone + Send, S: StreamTrait<Item = T> + Send + Unpin + 'static> From<S> for Stream<T> {
    fn from(source: S) -> Self {
        Self::new_open(vec![], Box::new(source))
    }
}

impl<T: Clone + Send> Default for Stream<T> {
    fn default() -> Self {
        Self::new_closed(vec![])
    }
}

impl<T: Clone + PartialEq + Send> PartialEq for Stream<T> {
    // A Stream is equal if it's the same internal pointer, or both streams are
    // closed with equivalent values.
    fn eq(&self, other: &Self) -> bool {
        Arc::ptr_eq(&self.inner, &other.inner) || {
            let left = self.inner.lock().unwrap();
            let right = other.inner.lock().unwrap();

            match (&*left, &*right) {
                (
                    StreamState {
                        pulled: a,
                        source: None,
                    },
                    StreamState {
                        pulled: b,
                        source: None,
                    },
                ) => a == b,
                _ => false,
            }
        }
    }
}
impl<T: Clone + Eq + Send> Eq for Stream<T> {}

impl<T: Clone + Serialize + Send> Serialize for Stream<T> {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        use serde::ser::Error;
        let lock = self.inner.lock().map_err(Error::custom)?;
        match &*lock {
            StreamState {
                pulled,
                source: None,
            } => pulled.serialize(serializer),
            _ => Err(Error::custom("cannot serialize open stream")),
        }
    }
}

impl<'de, T: Clone + Send + Deserialize<'de>> Deserialize<'de> for Stream<T> {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let data = <Vec<T>>::deserialize(deserializer)?;
        Ok(Stream::new_closed(data))
    }
}

impl<T: Clone + fmt::Debug> fmt::Debug for StreamState<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("StreamState")
            .field("pulled", &self.pulled)
            .finish()
    }
}

/// Implements [StreamTrait] over our Stream.
#[derive(Debug)]
pub struct StreamRead<T: Clone + Send> {
    index: usize,
    source: Stream<T>,
}

impl<T: Clone + Send> StreamTrait for StreamRead<T> {
    type Item = T;

    fn poll_next(self: Pin<&mut Self>, cx: &mut TaskContext<'_>) -> Poll<Option<Self::Item>> {
        let this = self.get_mut();
        let index = this.index;
        let mut inner = this.source.inner.lock().unwrap();

        if let Some(v) = inner.pulled.get(index) {
            // If the current reader can be satisfied by a value we've already pulled, then
            // just do that.
            this.index += 1;
            return Poll::Ready(Some(v.clone()));
        };

        let Some(source) = &mut inner.source else {
            // If the source has been closed, there's nothing left to pull.
            return Poll::Ready(None);
        };

        match source.poll_next_unpin(cx) {
            // If the source stream is ready to give us a new value, we can immediately store that
            // and return it to the caller. Any other readers will be able to read the value from
            // the already-pulled data.
            Poll::Ready(Some(v)) => {
                this.index += 1;
                inner.pulled.push(v.clone());
                Poll::Ready(Some(v))
            }
            // If the source stream is finished, then we can transition to the closed state
            // to drop the source stream.
            Poll::Ready(None) => {
                inner.source.take();
                Poll::Ready(None)
            }
            // Else, we need to wait for the source stream to give us a new value. The
            // source stream will be responsible for waking the TaskContext.
            Poll::Pending => Poll::Pending,
        }
    }
}

	use std::{
	fmt,
	pin::Pin,
	sync::{Arc, Mutex},
	task::{Context as TaskContext, Poll},
	};

	use anyhow::Result;
	use futures::{Stream as StreamTrait, StreamExt, TryStreamExt};
	use serde::{Deserialize, Deserializer, Serialize, Serializer};

	/// Streams allow for streaming values from source to sink.
	///
	/// A Stream implements both a reader (which implements the Stream trait), and a
	/// writer (which can be sent to another thread). As new values are written, any
	/// pending readers will be woken up to receive the new value.
	#[derive(Clone, Debug)]
	pub struct Stream<T: Clone + Send> {
	inner: Arc<Mutex<StreamState<T>>>,
	}

	/// The StreamState actually holds the data of a Stream.
	struct StreamState<T> {
	source: Option<Pin<Box<dyn StreamTrait<Item = T> + Send>>>,
	pulled: Vec<T>,
	}

	impl<T: Clone + Send> Stream<T> {
	/// Constructs a new Stream, and immediately closes it with only the passed
	/// values.
	pub fn new_closed(pulled: Vec<T>) -> Self {
	Self {
	inner: Arc::new(Mutex::new(StreamState {
	source: None,
	pulled,
	})),
	}
	}

	/// Creates a new Stream, which will lazily pull from the source stream.
	pub fn new_open(
	pulled: Vec<T>,
	source: Box<dyn StreamTrait<Item = T> + Send + 'static>,
	) -> Self {
	Self {
	inner: Arc::new(Mutex::new(StreamState {
	source: Some(Box::into_pin(source)),
	pulled,
	})),
	}
	}

	/// Returns a [StreamTrait] implementation to poll values out of our Stream.
	pub fn read(&self) -> StreamRead<T> {
	StreamRead {
	source: self.clone(),
	index: 0,
	}
	}

	pub async fn into_single(&self) -> SingleValue<T> {
	let mut stream = self.read();
	let Some(first) = stream.next().await else {
	return SingleValue::None;
	};

	if stream.next().await.is_some() {
	return SingleValue::Multiple;
	}

	SingleValue::Single(first)
	}
	}

	impl<T: Clone + Send, E: Clone + Send> Stream<Result<T, E>> {
	/// Converts a TryStream into a single value when possible.
	pub async fn try_into_single(&self) -> Result<SingleValue<T>, E> {
	let mut stream = self.read();
	let Some(first) = stream.try_next().await? else {
	return Ok(SingleValue::None);
	};

	if stream.try_next().await?.is_some() {
	return Ok(SingleValue::Multiple);
	}

	Ok(SingleValue::Single(first))
	}
	}

	pub enum SingleValue<T> {
	/// The Stream did not hold a value.
	None,

	/// The Stream held multiple values.
	Multiple,

	/// The held only a single value.
	Single(T),
	}

	impl<T: fmt::Debug> fmt::Debug for SingleValue<T> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	match self {
	SingleValue::None => f.debug_struct("SingleValue::None").finish(),
	SingleValue::Multiple => f.debug_struct("SingleValue::Multiple").finish(),
	SingleValue::Single(v) => f.debug_tuple("SingleValue::Single").field(v).finish(),
	}
	}
	}

	impl<T: Clone + Send, S: StreamTrait<Item = T> + Send + Unpin + 'static> From<S> for Stream<T> {
	fn from(source: S) -> Self {
	Self::new_open(vec![], Box::new(source))
	}
	}

	impl<T: Clone + Send> Default for Stream<T> {
	fn default() -> Self {
	Self::new_closed(vec![])
	}
	}

	impl<T: Clone + PartialEq + Send> PartialEq for Stream<T> {
	// A Stream is equal if it's the same internal pointer, or both streams are
	// closed with equivalent values.
	fn eq(&self, other: &Self) -> bool {
	Arc::ptr_eq(&self.inner, &other.inner) \|\| {
	let left = self.inner.lock().unwrap();
	let right = other.inner.lock().unwrap();

	match (&left, &right) {
	(
	StreamState {
	pulled: a,
	source: None,
	},
	StreamState {
	pulled: b,
	source: None,
	},
	) => a == b,
	_ => false,
	}
	}
	}
	}
	impl<T: Clone + Eq + Send> Eq for Stream<T> {}

	impl<T: Clone + Serialize + Send> Serialize for Stream<T> {
	fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
	use serde::ser::Error;
	let lock = self.inner.lock().map_err(Error::custom)?;
	match &*lock {
	StreamState {
	pulled,
	source: None,
	} => pulled.serialize(serializer),
	_ => Err(Error::custom("cannot serialize open stream")),
	}
	}
	}

	impl<'de, T: Clone + Send + Deserialize<'de>> Deserialize<'de> for Stream<T> {
	fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
	let data = <Vec<T>>::deserialize(deserializer)?;
	Ok(Stream::new_closed(data))
	}
	}

	impl<T: Clone + fmt::Debug> fmt::Debug for StreamState<T> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.debug_struct("StreamState")
	.field("pulled", &self.pulled)
	.finish()
	}
	}

	/// Implements [StreamTrait] over our Stream.
	#[derive(Debug)]
	pub struct StreamRead<T: Clone + Send> {
	index: usize,
	source: Stream<T>,
	}

	impl<T: Clone + Send> StreamTrait for StreamRead<T> {
	type Item = T;

	fn poll_next(self: Pin<&mut Self>, cx: &mut TaskContext<'_>) -> Poll<Option<Self::Item>> {
	let this = self.get_mut();
	let index = this.index;
	let mut inner = this.source.inner.lock().unwrap();

	if let Some(v) = inner.pulled.get(index) {
	// If the current reader can be satisfied by a value we've already pulled, then
	// just do that.
	this.index += 1;
	return Poll::Ready(Some(v.clone()));
	};

	let Some(source) = &mut inner.source else {
	// If the source has been closed, there's nothing left to pull.
	return Poll::Ready(None);
	};

	match source.poll_next_unpin(cx) {
	// If the source stream is ready to give us a new value, we can immediately store that
	// and return it to the caller. Any other readers will be able to read the value from
	// the already-pulled data.
	Poll::Ready(Some(v)) => {
	this.index += 1;
	inner.pulled.push(v.clone());
	Poll::Ready(Some(v))
	}
	// If the source stream is finished, then we can transition to the closed state
	// to drop the source stream.
	Poll::Ready(None) => {
	inner.source.take();
	Poll::Ready(None)
	}
	// Else, we need to wait for the source stream to give us a new value. The
	// source stream will be responsible for waking the TaskContext.
	Poll::Pending => Poll::Pending,
	}
	}
	}