Enum FileSource 

#[non_exhaustive]
pub enum FileSource {
    #[non_exhaustive]
    Bytes {
        filename: String,
        bytes: Vec<u8>,
        content_type: String,
    },
    #[non_exhaustive]
    Path(PathBuf),
    #[non_exhaustive]
    Stream {
        filename: String,
        reader: Pin<Box<dyn AsyncRead + Send>>,
        content_type: String,
    },
}

A source for file data that will be uploaded.

Construct with FileSource::bytes, FileSource::path, or FileSource::stream, or convert from PathBuf/std::path::Path via the From impls.

The API currently accepts text/plain, application/pdf, and application/json; other MIME types may be rejected by the server.

This enum is #[non_exhaustive]: new variants may be added in future versions without a breaking change, and each data-carrying variant is likewise #[non_exhaustive] so that new fields can be added to it non-breakingly. Out-of-crate code must construct values through the provided constructors (FileSource::bytes, FileSource::path, FileSource::stream, or the From impls) rather than variant literals, and cannot exhaustively match on the variants or their fields.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

#[non_exhaustive]

Bytes

Raw bytes with explicit filename and content type.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

filename: String

File name to send.

bytes: Vec<u8>

Raw file data.

content_type: String

MIME content type.

#[non_exhaustive]

Path(PathBuf)

A filesystem path. Resolved at upload time.

#[non_exhaustive]

Stream

A streaming reader — fully buffered into memory before uploading.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

filename: String

File name to send.

reader: Pin<Box<dyn AsyncRead + Send>>

Async reader producing the file data.

content_type: String

MIME content type.

Implementations

impl FileSource

pub fn bytes( filename: impl Into<String>, data: impl Into<Vec<u8>>, content_type: impl Into<String>, ) -> Self

Create a Bytes variant from explicit parts.

data accepts anything convertible into Vec<u8> (e.g. Vec<u8>, &[u8], &str) and is stored as a Vec<u8>.

The content type is validated when the upload is sent (during multipart form construction), not here, to keep this constructor infallible.

The API currently accepts text/plain, application/pdf, and application/json; other MIME types may be rejected by the server.

pub fn path(path: impl Into<PathBuf>) -> Self

Create a Path variant.

pub fn stream( filename: impl Into<String>, reader: impl AsyncRead + Send + 'static, content_type: impl Into<String>, ) -> Self

Create a Stream variant from an AsyncRead source.

The reader is fully consumed with tokio::io::AsyncReadExt::read_to_end and buffered into memory before the upload begins. This is not true streaming — the entire payload resides in memory during the request.

For files on disk, prefer FileSource::path.

The API currently accepts text/plain, application/pdf, and application/json; other MIME types may be rejected by the server.

Examples

use honcho_ai::FileSource;

let cursor = std::io::Cursor::new(b"hello".to_vec());
let src = FileSource::stream("out.txt", cursor, "text/plain");

Trait Implementations

impl Debug for FileSource

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&Path> for FileSource

fn from(p: &Path) -> Self

Converts to this type from the input type.

impl From<PathBuf> for FileSource

fn from(p: PathBuf) -> Self

Converts to this type from the input type.