slumber-python 5.2.4__tar.gz → 5.2.5__tar.gz

{slumber_python-5.2.4 → slumber_python-5.2.5}/Cargo.lock

@@ -809,7 +809,7 @@ dependencies = [
 
 [[package]]
 name = "doc_utils"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "anyhow",
  "clap",
@@ -3280,7 +3280,7 @@ checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "slumber"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "anyhow",
  "slumber_cli",
@@ -3292,7 +3292,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_cli"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -3300,7 +3300,6 @@ dependencies = [
  "chrono",
  "clap",
  "clap_complete",
- "dialoguer",
  "env-lock",
  "indexmap",
  "itertools",
@@ -3314,6 +3313,7 @@ dependencies = [
  "serde_urlencoded",
  "serde_yaml",
  "slumber_config",
+ "slumber_console",
  "slumber_core",
  "slumber_import",
  "slumber_template",
@@ -3327,7 +3327,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_config"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "derive_more",
  "dirs",
@@ -3350,9 +3350,23 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "slumber_console"
+version = "5.2.5"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "dialoguer",
+ "slumber_core",
+ "slumber_template",
+ "slumber_util",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "slumber_core"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "async-trait",
  "base64 0.22.1",
@@ -3400,7 +3414,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_import"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "anyhow",
  "base64 0.22.1",
@@ -3432,7 +3446,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_macros"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3441,13 +3455,13 @@ dependencies = [
 
 [[package]]
 name = "slumber_python"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "async-trait",
- "dialoguer",
  "indexmap",
  "pyo3",
  "slumber_config",
+ "slumber_console",
  "slumber_core",
  "slumber_template",
  "tokio",
@@ -3455,7 +3469,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_template"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "bytes",
  "derive_more",
@@ -3482,7 +3496,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_tui"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3524,7 +3538,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_util"
-version = "5.2.4"
+version = "5.2.5"
 dependencies = [
  "console-subscriber",
  "derive_more",

{slumber_python-5.2.4 → slumber_python-5.2.5}/Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://slumber.lucaspickering.me"
 keywords = ["rest", "http", "terminal", "tui"]
 license = "MIT"
 repository = "https://github.com/LucasPickering/slumber"
-version = "5.2.4"
+version = "5.2.5"
 # Keep in sync w/ rust-toolchain.toml
 rust-version = "1.90.0"
 
@@ -43,14 +43,15 @@ serde_json = {version = "1.0.120", default-features = false, features = ["preser
 serde_json_path = "0.7.1"
 serde_test = "1.0.176"
 serde_yaml = {version = "0.9.0", default-features = false}
-slumber_cli = {path = "./crates/cli", version = "5.2.4" }
-slumber_config = {path = "./crates/config", version = "5.2.4", default-features = false }
-slumber_core = {path = "./crates/core", version = "5.2.4" }
-slumber_import = {path = "./crates/import", version = "5.2.4" }
-slumber_macros = {path = "./crates/macros", version = "5.2.4" }
-slumber_template = {path = "./crates/template", version = "5.2.4" }
-slumber_tui = {path = "./crates/tui", version = "5.2.4" }
-slumber_util = {path = "./crates/util", version = "5.2.4" }
+slumber_cli = {path = "./crates/cli", version = "5.2.5" }
+slumber_config = {path = "./crates/config", version = "5.2.5", default-features = false }
+slumber_console = {path = "./crates/console", version = "5.2.5" }
+slumber_core = {path = "./crates/core", version = "5.2.5" }
+slumber_import = {path = "./crates/import", version = "5.2.5" }
+slumber_macros = {path = "./crates/macros", version = "5.2.5" }
+slumber_template = {path = "./crates/template", version = "5.2.5" }
+slumber_tui = {path = "./crates/tui", version = "5.2.5" }
+slumber_util = {path = "./crates/util", version = "5.2.5" }
 strum = {version = "0.27.0", default-features = false}
 syn = "2.0.101"
 terminput = "0.5.3"

{slumber_python-5.2.4 → slumber_python-5.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slumber-python
-Version: 5.2.4
+Version: 5.2.5
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

slumber_python-5.2.5/crates/console/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+authors = {workspace = true}
+description = "Utitilies for console-based Slumber frontends. Not intended for external use."
+edition = {workspace = true}
+homepage = {workspace = true}
+keywords = {workspace = true}
+license = {workspace = true}
+name = "slumber_console"
+repository = {workspace = true}
+rust-version = {workspace = true}
+version = {workspace = true}
+
+[package.metadata.release]
+tag = false
+
+[dependencies]
+anyhow = {workspace = true}
+async-trait = {workspace = true}
+dialoguer = {workspace = true, features = ["password"]}
+slumber_core = {workspace = true}
+slumber_template = {workspace = true}
+slumber_util = {workspace = true}
+tokio = {workspace = true, features = ["sync"]}
+tracing = {workspace = true}

slumber_python-5.2.5/crates/console/src/lib.rs

@@ -0,0 +1,100 @@
+//! Utilities for console-based Slumber frontends
+
+use anyhow::Context as _;
+use async_trait::async_trait;
+use dialoguer::{Input, Password, Select};
+use slumber_core::render::{Prompter, SelectOption};
+use slumber_template::Value;
+use slumber_util::ResultTracedAnyhow;
+use tokio::sync::Mutex;
+use tracing::warn;
+
+/// A proxy for a lock on stdout
+///
+/// Forces prompts to run one at a time, so they don't fight over the console.
+/// This is a static instead of being in [ConsolePrompter] because there could
+/// theoretically be multiple prompters running simultaneously.
+static CONSOLE_LOCK: Mutex<()> = Mutex::const_new(());
+
+/// Prompt the user for input on the console
+///
+/// This uses [dialoguer] to generate the prompts. Since its API is blocking,
+/// this runs each prompt in a tokio blocking thread.
+#[derive(Debug)]
+pub struct ConsolePrompter;
+
+impl ConsolePrompter {
+    /// Spawn a blocking prompt in a background task
+    async fn spawn_prompt<T, F>(&self, f: F) -> Option<T>
+    where
+        T: 'static + Send,
+        F: 'static + FnOnce() -> anyhow::Result<T> + Send,
+    {
+        let guard = CONSOLE_LOCK.lock().await;
+        let result = tokio::task::spawn_blocking(f)
+            .await
+            .context("Prompt panicked")
+            .flatten()
+            .traced();
+        // Make sure the guard is held while the task is running. Since the lock
+        // doesn't actually contain the locked resource, I wanna be careful.
+        drop(guard);
+        result.ok()
+    }
+}
+
+#[async_trait(?Send)]
+impl Prompter for ConsolePrompter {
+    async fn prompt_text(
+        &self,
+        message: String,
+        default: Option<String>,
+        sensitive: bool,
+    ) -> Option<String> {
+        self.spawn_prompt(move || {
+            if sensitive {
+                // Dialoguer doesn't support default values here so there's
+                // nothing we can do
+                if default.is_some() {
+                    warn!(
+                        "Default value not supported for sensitive CLI prompts"
+                    );
+                }
+
+                Password::new()
+                    .with_prompt(message)
+                    .allow_empty_password(true)
+                    .interact()
+            } else {
+                let mut input =
+                    Input::new().with_prompt(message).allow_empty(true);
+                if let Some(default) = default {
+                    input = input.default(default);
+                }
+                input.interact()
+            }
+            // If we failed to read the value, print an error and report nothing
+            .context("Error reading value from prompt")
+        })
+        .await
+    }
+
+    async fn prompt_select(
+        &self,
+        message: String,
+        mut options: Vec<SelectOption>,
+    ) -> Option<Value> {
+        self.spawn_prompt(move || {
+            let index = Select::new()
+                .with_prompt(message)
+                .items(&options)
+                .default(0)
+                .interact()
+                // If we failed to read the value, print an error and report
+                // nothing
+                .context("Error reading value from select")?;
+            Ok(options.swap_remove(index).value)
+        })
+        .await
+    }
+}

{slumber_python-5.2.4 → slumber_python-5.2.5}/crates/core/src/collection/cereal.rs

@@ -409,10 +409,11 @@ impl DeserializeYaml for ValueTemplate {
             YamlData::Value(Scalar::FloatingPoint(f)) => Ok(Self::Float(f.0)),
             // Parse string as a template
             YamlData::Value(Scalar::String(s)) => {
-                let template = s.parse::<Template>().map_err(|error| {
+                // Template will be unpacked here if appropriate
+                let template = s.parse::<Self>().map_err(|error| {
                     LocatedError::other(error, yaml.location)
                 })?;
-                Ok(Self::String(template))
+                Ok(template)
             }
             YamlData::Sequence(sequence) => {
                 let values = sequence

slumber_python-5.2.5/crates/core/src/collection/value_template.rs

@@ -0,0 +1,307 @@
+use crate::render::TemplateContext;
+use bytes::BytesMut;
+use futures::{FutureExt, TryStreamExt, future};
+use serde::{Serialize, Serializer};
+use slumber_template::{
+    Context, Expression, RenderError, RenderValue, RenderedChunk,
+    RenderedChunks, Template, TemplateChunk, TemplateParseError, Value,
+    ValueStream,
+};
+use std::str::FromStr;
+
+/// A templated [Value]
+///
+/// This is a [Value], except the strings are templates. That means this can be
+/// dynamically rendered to a [Value]. This is used for structured bodies (e.g.
+/// JSON) as well as profile fields.
+#[derive(Clone, Debug, derive_more::From, PartialEq, Serialize)]
+#[serde(untagged)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+pub enum ValueTemplate {
+    Null,
+    Boolean(bool),
+    Integer(i64),
+    Float(f64),
+    /// An unpacked single-chunk template
+    #[serde(serialize_with = "serialize_expression")]
+    #[cfg_attr(feature = "schema", schemars(with = "String"))]
+    Expression(Expression),
+    /// A template that has not been unpacked
+    ///
+    /// This is either a single raw chunk or a multi-chunk template
+    #[from(ignore)]
+    String(Template),
+    #[from(ignore)]
+    Array(Vec<Self>),
+    // A key-value mapping. Stored as a `Vec` instead of `IndexMap` because
+    // the keys are templates, which aren't hashable. We never do key lookups
+    // on this so there's no need for a map anyway.
+    #[from(ignore)]
+    #[serde(serialize_with = "slumber_util::serialize_mapping")]
+    #[cfg_attr(
+        feature = "schema",
+        schemars(with = "std::collections::HashMap<Template, Self>")
+    )]
+    Object(Vec<(Template, Self)>),
+}
+
+impl ValueTemplate {
+    /// Create a new string template from a raw string, without parsing it at
+    /// all
+    ///
+    /// Useful when importing from external formats where the string isn't
+    /// expected to be a valid Slumber template
+    pub fn raw(template: String) -> Self {
+        Self::String(Template::raw(template))
+    }
+
+    /// Does the template have at least one dynamic chunk? If this returns
+    /// `false`, the template will always render to its source text
+    pub fn is_dynamic(&self) -> bool {
+        match self {
+            Self::Null
+            | Self::Boolean(_)
+            | Self::Integer(_)
+            | Self::Float(_) => false,
+            Self::Expression(_) => true,
+            Self::String(template) => template.is_dynamic(),
+            Self::Array(array) => array.iter().any(Self::is_dynamic),
+            Self::Object(object) => object
+                .iter()
+                .any(|(key, value)| key.is_dynamic() || value.is_dynamic()),
+        }
+    }
+
+    /// Render to a value or chunks with eager values
+    ///
+    /// The return value is *usually* a single value, but if `self` is a
+    /// multi-chunk template string, then its multi-chunk output will be the
+    /// output for this.
+    ///
+    /// Use this for cases where streaming is *not* allowed.
+    pub async fn render_value(
+        &self,
+        context: &TemplateContext,
+    ) -> RenderedValue<Value> {
+        self.render_chunks_inner(context, Template::render_chunks)
+            .boxed_local() // Box for recursion
+            .await
+    }
+
+    /// Render to a value or chunks with stream values
+    ///
+    /// The return value is *usually* a single value, but if `self` is a
+    /// multi-chunk template string, then its multi-chunk output will be the
+    /// output for this.
+    ///
+    /// Use this for cases where streaming is allowed.
+    pub async fn render_value_stream(
+        &self,
+        context: &TemplateContext,
+    ) -> RenderedValue<ValueStream> {
+        self.render_chunks_inner(context, Template::render_chunks_stream)
+            .boxed_local() // Box for recursion
+            .await
+    }
+
+    /// Render to chunks with dynamic output type
+    async fn render_chunks_inner<V>(
+        &self,
+        context: &TemplateContext,
+        render_string: impl AsyncFn(
+            &Template,
+            &TemplateContext,
+        ) -> RenderedChunks<V>,
+    ) -> RenderedValue<V>
+    where
+        V: RenderValue,
+        TemplateContext: Context<V>,
+    {
+        match self {
+            Self::Null => Value::Null.into(),
+            Self::Boolean(b) => Value::Boolean(*b).into(),
+            Self::Integer(i) => Value::Integer(*i).into(),
+            Self::Float(f) => Value::Float(*f).into(),
+            Self::Expression(expression) => {
+                let result = expression.render(context).await;
+                RenderedValue::Value(result)
+            }
+            Self::String(template) => {
+                RenderedValue::Chunks(render_string(template, context).await)
+            }
+            Self::Array(array) => {
+                // Render each value and collection into an Array
+                future::try_join_all(array.iter().map(|value| {
+                    value
+                        .render_value(context)
+                        .map(RenderedValue::try_into_value)
+                }))
+                .await
+                .map(Value::Array)
+                .into() // Wrap into RenderedValue
+            }
+            Self::Object(map) => {
+                // Render each key/value and collect into an Object
+                future::try_join_all(map.iter().map(|(key, value)| async {
+                    let key = key.render_string(context).await?;
+                    let value =
+                        value.render_value(context).await.try_into_value()?;
+                    Ok::<_, RenderError>((key, value))
+                }))
+                .await
+                .map(Value::from)
+                .into() // Wrap into RenderedValue
+            }
+        }
+    }
+}
+
+/// Parse template from a string literal. Panic if invalid
+#[cfg(any(test, feature = "test"))]
+impl From<&str> for ValueTemplate {
+    fn from(value: &str) -> Self {
+        value.parse().unwrap()
+    }
+}
+
+#[cfg(any(test, feature = "test"))]
+impl<T: Into<ValueTemplate>> From<Vec<T>> for ValueTemplate {
+    fn from(value: Vec<T>) -> Self {
+        Self::Array(value.into_iter().map(T::into).collect())
+    }
+}
+
+#[cfg(any(test, feature = "test"))]
+impl<T: Into<ValueTemplate>> From<Vec<(&str, T)>> for ValueTemplate {
+    fn from(value: Vec<(&str, T)>) -> Self {
+        Self::Object(
+            value
+                .into_iter()
+                .map(|(k, v)| (k.parse().unwrap(), v.into()))
+                .collect(),
+        )
+    }
+}
+
+/// A value rendered from a [ValueTemplate]
+#[derive(Debug)]
+pub enum RenderedValue<V> {
+    /// A single-chunk dynamic template unpacked to a single value (or error)
+    Value(Result<V, RenderError>),
+    /// A raw or multi-chunk template that can be stitched into a string
+    Chunks(RenderedChunks<V>),
+}
+
+impl RenderedValue<Value> {
+    /// Collect the rendered value into a [Value] by these rules:
+    /// - If the value is a [RenderedValue::Value], return that value directly
+    /// - Any other template will be rendered to a string by stringifying each
+    ///   dynamic chunk and concatenating them all together
+    /// - If rendering to a string fails because the bytes are not valid UTF-8,
+    ///   concatenate into a bytes object instead
+    pub fn try_into_value(self) -> Result<Value, RenderError> {
+        let value = match self {
+            RenderedValue::Value(result) => result?,
+            RenderedValue::Chunks(chunks) => {
+                // Render to bytes
+                let bytes = chunks.try_into_bytes()?;
+                Value::Bytes(bytes)
+            }
+        };
+        Ok(value.decode_bytes())
+    }
+}
+
+impl RenderedValue<ValueStream> {
+    /// Does this output contain *any* stream chunks?
+    pub fn has_stream(&self) -> bool {
+        match self {
+            Self::Value(Ok(ValueStream::Stream { .. })) => true,
+            Self::Value(Ok(ValueStream::Value(_)) | Err(_)) => false,
+            Self::Chunks(chunks) => chunks.iter().any(|chunk| match chunk {
+                RenderedChunk::Raw(_)
+                | RenderedChunk::Dynamic(ValueStream::Value(_))
+                | RenderedChunk::Error(_) => false,
+                RenderedChunk::Dynamic(ValueStream::Stream { .. }) => true,
+            }),
+        }
+    }
+
+    /// Collect the rendered chunks into a [Value] by these rules:
+    /// - If the value is a [RenderedValue::Value], return that value directly
+    /// - If there are any streams, resolve them to bytes
+    /// - Any other template will be rendered to a string by stringifying each
+    ///   dynamic chunk and concatenating them all together
+    /// - If rendering to a string fails because the bytes are not valid UTF-8,
+    ///   concatenate into a bytes object instead
+    pub async fn try_collect_value(self) -> Result<Value, RenderError> {
+        // If we only have one chunk, unpack it into a value
+        let value = match self {
+            Self::Value(Ok(ValueStream::Value(value))) => value,
+            Self::Value(Ok(stream @ ValueStream::Stream { .. })) => {
+                stream.resolve().await?
+            }
+            Self::Value(Err(error)) => return Err(error),
+            Self::Chunks(chunks) => {
+                // Render to bytes
+                let bytes = chunks
+                    .try_into_stream()?
+                    .try_collect::<BytesMut>()
+                    .await?
+                    .into();
+                Value::Bytes(bytes)
+            }
+        };
+
+        // Try to convert bytes to string, because that's generally more
+        // useful to the consumer
+        Ok(value.decode_bytes())
+    }
+}
+
+/// Create render output of a single chunk with a value
+impl<V: RenderValue> From<Value> for RenderedValue<V> {
+    fn from(value: Value) -> Self {
+        Self::Value(Ok(V::from_value(value)))
+    }
+}
+
+/// Create render output of a single chunk that may have failed
+impl<V: RenderValue> From<Result<Value, RenderError>> for RenderedValue<V> {
+    fn from(result: Result<Value, RenderError>) -> Self {
+        Self::Value(result.map(V::from_value))
+    }
+}
+
+impl From<Template> for ValueTemplate {
+    fn from(template: Template) -> Self {
+        // Single dynamic chunk is unpacked
+        match <[_; 1]>::try_from(template.into_chunks()) {
+            Ok([TemplateChunk::Expression(expression)]) => {
+                Self::Expression(expression)
+            }
+            Ok(chunks) => Self::String(Template::from_chunks(chunks.into())),
+            Err(chunks) => Self::String(Template::from_chunks(chunks)),
+        }
+    }
+}
+
+/// Parse a template string to [ValueTemplate]
+///
+/// This will unpack the template to an expression if possible.
+impl FromStr for ValueTemplate {
+    type Err = TemplateParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let template: Template = s.parse()?;
+        Ok(template.into())
+    }
+}
+
+/// Serialize an expression as `{{ expression }}`
+fn serialize_expression<S: Serializer>(
+    expression: &Expression,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    serializer.serialize_str(&Template::display_expression(expression))
+}

{slumber_python-5.2.4 → slumber_python-5.2.5}/crates/core/src/collection.rs

@@ -11,7 +11,7 @@ mod value_template;
 pub use cereal::HasId;
 pub use models::*;
 pub use recipe_tree::*;
-pub use value_template::ValueTemplate;
+pub use value_template::{RenderedValue, ValueTemplate};
 
 use itertools::Itertools;
 use std::{

{slumber_python-5.2.4 → slumber_python-5.2.5}/crates/core/src/http/models.rs

@@ -30,7 +30,6 @@ use std::{
 };
 use strum::{EnumDiscriminants, EnumIter, IntoEnumIterator};
 use thiserror::Error;
-use tracing::error;
 use uuid::Uuid;
 
 /// Unique ID for a single request. Can also be used to refer to the

{slumber_python-5.2.4 → slumber_python-5.2.5}/crates/core/src/http.rs

@@ -766,7 +766,7 @@ impl Recipe {
             | (Some(RecipeBody::Json(_)), Some(BodyOverride::Json(json))) => {
                 // Render the value
                 let rendered_value = json
-                    .render_chunks(context)
+                    .render_value(context)
                     .await
                     .try_into_value()
                     .map_err(RequestBuildErrorKind::BodyRender)?;