diff --git a/.vscode/settings.json b/.vscode/settings.json index a5de681e96..f313226875 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -45,5 +45,8 @@ }, "[baml]": { "editor.defaultFormatter": "Boundary.baml-extension" + }, + "[python]": { + "editor.defaultFormatter": "charliermarsh.ruff" } } diff --git a/engine/Cargo.lock b/engine/Cargo.lock index a2537f403f..dd5c842666 100644 --- a/engine/Cargo.lock +++ b/engine/Cargo.lock @@ -1114,6 +1114,7 @@ dependencies = [ "baml-ids", "baml-log", "baml-runtime", + "baml-type-builder", "baml-types", "ctrlc", "dashmap 5.5.3", @@ -1210,6 +1211,7 @@ dependencies = [ "baml-ids", "baml-log", "baml-rpc", + "baml-type-builder", "baml-types", "baml-vm", "base64 0.22.1", @@ -1360,6 +1362,21 @@ dependencies = [ "web-time", ] +[[package]] +name = "baml-type-builder" +version = "0.1.0" +dependencies = [ + "anyhow", + "baml-types", + "indexmap 2.9.0", + "internal-baml-core", + "internal-baml-diagnostics", + "internal-baml-parser-database", + "log", + "serde", + "thiserror 1.0.69", +] + [[package]] name = "baml-types" version = "0.207.0" @@ -1395,6 +1412,7 @@ dependencies = [ "baml-ids", "baml-log", "baml-runtime", + "baml-type-builder", "baml-types", "dashmap 5.5.3", "env_logger", @@ -1438,6 +1456,7 @@ dependencies = [ "baml-ids", "baml-log", "baml-runtime", + "baml-type-builder", "baml-types", "baml_cffi_macros", "cbindgen", diff --git a/engine/baml-lib/baml/tests/validation_files/expr/expr_full.baml b/engine/baml-lib/baml/tests/validation_files/expr/expr_full.baml index 2bcf1d013f..359ce72f6e 100644 --- a/engine/baml-lib/baml/tests/validation_files/expr/expr_full.baml +++ b/engine/baml-lib/baml/tests/validation_files/expr/expr_full.baml @@ -67,4 +67,29 @@ client GPT4o { test TestMakePoem() { functions [MakePoem] args { length 4 } +} + +function Search(search_term: string) -> string[] { + client GPT4o + prompt #" + Search for {{ search_term }} + "# +} + +function AgentLoop(search_term: string) -> string[] { + let all_terms = []; + let max_terms = 10; + while (all_terms.length < 10 && max_terms > 0) { + let search_results = Search(search_term); + let terms = search_results.filter((result) => { + // ensure each result is a high qualty result and related to the search term + let quality = EnsureQuality(search_term, result); + if (quality.score > 0.5) { + return true; + } + }) + all_terms.extend(terms); + max_terms -= 1; + } + all_terms } \ No newline at end of file diff --git a/engine/baml-lib/baml/tests/validation_files/expr/extra_dot.baml b/engine/baml-lib/baml/tests/validation_files/expr/extra_dot.baml index 67a0a33ee2..d7104bae4e 100644 --- a/engine/baml-lib/baml/tests/validation_files/expr/extra_dot.baml +++ b/engine/baml-lib/baml/tests/validation_files/expr/extra_dot.baml @@ -18,9 +18,9 @@ function ModernFunction(x: int) -> int { }; // Method call - .let result = receipt.calculate(); + let result = receipt.calculate(); - ^if (true) { + if (true) { return 1; } diff --git a/engine/baml-lib/type-builder/Cargo.toml b/engine/baml-lib/type-builder/Cargo.toml new file mode 100644 index 0000000000..b3923d0036 --- /dev/null +++ b/engine/baml-lib/type-builder/Cargo.toml @@ -0,0 +1,18 @@ +[package] +name = "baml-type-builder" +version = "0.1.0" +edition = "2021" + +[dependencies] +anyhow = "1.0" +baml-types = { path = "../baml-types" } +internal-baml-core = { path = "../baml-core" } +internal-baml-parser-database = { path = "../parser-database" } +internal-baml-diagnostics = { path = "../diagnostics" } +indexmap = { version = "2.0", features = ["serde"] } +log = "0.4" +serde = { version = "1.0", features = ["derive"] } +thiserror = "1.0" + +[dev-dependencies] +# Test dependencies \ No newline at end of file diff --git a/engine/baml-lib/type-builder/src/core/mod.rs b/engine/baml-lib/type-builder/src/core/mod.rs new file mode 100644 index 0000000000..ba66e4d624 --- /dev/null +++ b/engine/baml-lib/type-builder/src/core/mod.rs @@ -0,0 +1,470 @@ +use std::{ + fmt, + ops::Deref, + sync::{Arc, Mutex}, +}; + +use baml_types::{BamlValue, TypeIR}; +use indexmap::{IndexMap, IndexSet}; + +// Meta system for storing metadata on builders +type MetaData = Arc>>; + +pub trait Meta { + fn meta(&self) -> MetaData; +} + +pub trait WithMeta { + fn with_meta(&self, key: &str, value: BamlValue) -> &Self; + fn get_meta(&self, key: &str) -> Option; + fn remove_meta(&self, key: &str) -> &Self; +} + +macro_rules! impl_meta { + ($type:ty) => { + impl Meta for $type { + fn meta(&self) -> MetaData { + self.meta.clone() + } + } + }; +} + +impl WithMeta for T +where + T: Meta, +{ + fn with_meta(&self, key: &str, value: BamlValue) -> &T { + let meta = self.meta(); + let mut meta = meta.lock().unwrap(); + meta.insert(key.to_string(), value); + self + } + + fn remove_meta(&self, key: &str) -> &T { + let meta = self.meta(); + let mut meta = meta.lock().unwrap(); + meta.shift_remove(key); + self + } + + fn get_meta(&self, key: &str) -> Option { + let meta = self.meta(); + let meta = meta.lock().unwrap(); + meta.get(key).cloned() + } +} + +// Core TypeBuilder without IR dependencies +#[derive(Clone)] +pub struct TypeBuilder { + classes: Arc>>>>, + enums: Arc>>>>, + type_aliases: Arc>>>>, + recursive_type_aliases: Arc>>>, + recursive_classes: Arc>>>, +} + +impl Default for TypeBuilder { + fn default() -> Self { + Self::new() + } +} + +impl TypeBuilder { + pub fn new() -> Self { + Self { + classes: Default::default(), + enums: Default::default(), + type_aliases: Default::default(), + recursive_type_aliases: Default::default(), + recursive_classes: Default::default(), + } + } + + pub fn reset(&self) { + self.classes.lock().unwrap().clear(); + self.enums.lock().unwrap().clear(); + self.type_aliases.lock().unwrap().clear(); + self.recursive_type_aliases.lock().unwrap().clear(); + self.recursive_classes.lock().unwrap().clear(); + } + + pub fn upsert_class(&self, name: &str) -> Arc> { + Arc::clone( + self.classes + .lock() + .unwrap() + .entry(name.to_string()) + .or_insert_with(|| Arc::new(Mutex::new(ClassBuilder::new(name.to_string())))), + ) + } + + pub fn maybe_get_class(&self, name: &str) -> Option>> { + self.classes.lock().unwrap().get(name).cloned() + } + + pub fn upsert_enum(&self, name: &str) -> Arc> { + Arc::clone( + self.enums + .lock() + .unwrap() + .entry(name.to_string()) + .or_insert_with(|| Arc::new(Mutex::new(EnumBuilder::new(name.to_string())))), + ) + } + + pub fn list_enums(&self) -> Vec { + self.enums.lock().unwrap().keys().cloned().collect() + } + + pub fn list_classes(&self) -> Vec { + self.classes.lock().unwrap().keys().cloned().collect() + } + + pub fn maybe_get_enum(&self, name: &str) -> Option>> { + self.enums.lock().unwrap().get(name).cloned() + } + + pub fn upsert_type_alias(&self, name: &str) -> Arc> { + Arc::clone( + self.type_aliases + .lock() + .unwrap() + .entry(name.to_string()) + .or_insert_with(|| Arc::new(Mutex::new(TypeAliasBuilder::new()))), + ) + } + + pub fn maybe_get_type_alias(&self, name: &str) -> Option>> { + self.type_aliases.lock().unwrap().get(name).cloned() + } + + pub fn recursive_type_aliases(&self) -> Arc>>> { + Arc::clone(&self.recursive_type_aliases) + } + + pub fn recursive_classes(&self) -> Arc>>> { + Arc::clone(&self.recursive_classes) + } +} + +// ClassBuilder +#[derive(Debug, Clone)] +pub struct ClassBuilder { + pub name: String, + properties: Arc>>>>, + meta: MetaData, +} +impl_meta!(ClassBuilder); + +impl ClassBuilder { + pub fn new(name: String) -> Self { + Self { + name, + properties: Default::default(), + meta: Arc::new(Mutex::new(Default::default())), + } + } + + pub fn list_properties_key_value(&self) -> Vec<(String, ClassPropertyBuilder)> { + self.properties + .lock() + .unwrap() + .iter() + .map(|(name, prop)| (name.clone(), prop.lock().unwrap().deref().to_owned())) + .collect() + } + + pub fn list_properties(&self) -> Vec { + let properties = self.properties.lock().unwrap(); + properties.keys().cloned().collect() + } + + pub fn maybe_get_property(&self, name: &str) -> Option>> { + let properties = self.properties.lock().unwrap(); + properties.get(name).cloned() + } + + pub fn upsert_property(&self, name: &str) -> Arc> { + let mut properties = self.properties.lock().unwrap(); + Arc::clone(properties.entry(name.to_string()).or_insert_with(|| { + Arc::new(Mutex::new(ClassPropertyBuilder { + r#type: Default::default(), + meta: Default::default(), + })) + })) + } + + pub fn remove_property(&self, name: &str) { + let mut properties = self.properties.lock().unwrap(); + properties.shift_remove(name); + } + + pub fn reset(&self) { + self.properties.lock().unwrap().clear(); + } +} + +// ClassPropertyBuilder +#[derive(Debug, Clone)] +pub struct ClassPropertyBuilder { + r#type: Arc>>, + meta: MetaData, +} +impl_meta!(ClassPropertyBuilder); + +impl ClassPropertyBuilder { + pub fn set_type(&self, r#type: TypeIR) -> &Self { + *self.r#type.lock().unwrap() = Some(r#type); + self + } + + pub fn r#type(&self) -> Option { + self.r#type.lock().unwrap().clone() + } +} + +// EnumBuilder +#[derive(Debug, Clone)] +pub struct EnumBuilder { + pub name: String, + values: Arc>>>>, + meta: MetaData, +} +impl_meta!(EnumBuilder); + +impl EnumBuilder { + pub fn new(name: String) -> Self { + Self { + name, + values: Default::default(), + meta: Arc::new(Mutex::new(Default::default())), + } + } + + pub fn maybe_get_value(&self, name: &str) -> Option>> { + let values = self.values.lock().unwrap(); + values.get(name).cloned() + } + + pub fn upsert_value(&self, name: &str) -> Arc> { + let mut values = self.values.lock().unwrap(); + Arc::clone(values.entry(name.to_string()).or_insert_with(|| { + Arc::new(Mutex::new(EnumValueBuilder { + meta: Default::default(), + })) + })) + } + + pub fn list_values(&self) -> Vec { + let values = self.values.lock().unwrap(); + values.keys().cloned().collect() + } + + pub fn remove_value(&self, name: &str) { + let mut values = self.values.lock().unwrap(); + values.shift_remove(name); + } +} + +// EnumValueBuilder +#[derive(Debug, Clone)] +pub struct EnumValueBuilder { + meta: MetaData, +} +impl_meta!(EnumValueBuilder); + +// TypeAliasBuilder +pub struct TypeAliasBuilder { + target: Arc>>, + meta: MetaData, +} +impl_meta!(TypeAliasBuilder); + +impl TypeAliasBuilder { + pub fn new() -> Self { + Self { + target: Default::default(), + meta: Arc::new(Mutex::new(Default::default())), + } + } + + pub fn target(&self, target: TypeIR) -> &Self { + *self.target.lock().unwrap() = Some(target); + self + } +} + +impl Default for TypeAliasBuilder { + fn default() -> Self { + Self::new() + } +} + +// Display implementations +impl fmt::Display for ClassPropertyBuilder { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let meta = self.meta.lock().unwrap(); + let type_str = self + .r#type + .lock() + .unwrap() + .as_ref() + .map_or("(unknown-type)".to_string(), |t| format!("{}", t.clone())); + + write!(f, "{type_str}")?; + + if !meta.is_empty() { + write!(f, " (")?; + for (i, (key, value)) in meta.iter().enumerate() { + if i > 0 { + write!(f, ", ")?; + } + write!(f, "{key}={value}")?; + } + write!(f, ")")?; + } + Ok(()) + } +} + +impl fmt::Display for EnumValueBuilder { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let meta = self.meta.lock().unwrap(); + + if !meta.is_empty() { + write!(f, " (")?; + for (i, (key, value)) in meta.iter().enumerate() { + if i > 0 { + write!(f, ", ")?; + } + write!(f, "{key}={value}")?; + } + write!(f, ")")?; + } + Ok(()) + } +} + +impl fmt::Display for ClassBuilder { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let properties = self.properties.lock().unwrap(); + write!(f, "{{")?; + if !properties.is_empty() { + for (i, (name, prop)) in properties.iter().enumerate() { + if i > 0 { + write!(f, ",")?; + } + write!(f, "\n {} {}", name, prop.lock().unwrap())?; + } + write!(f, "\n ")?; + } + write!(f, "}}") + } +} + +impl fmt::Display for EnumBuilder { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let values = self.values.lock().unwrap(); + write!(f, "{{")?; + if !values.is_empty() { + for (i, (name, value)) in values.iter().enumerate() { + if i > 0 { + write!(f, ",")?; + } + write!(f, "\n {}{}", name, value.lock().unwrap())?; + } + write!(f, "\n ")?; + } + write!(f, "}}") + } +} + +impl fmt::Display for TypeBuilder { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let classes = self.classes.lock().unwrap(); + let enums = self.enums.lock().unwrap(); + let type_aliases = self.type_aliases.lock().unwrap(); + let recursive_type_aliases = self.recursive_type_aliases.lock().unwrap(); + + write!(f, "TypeBuilder(")?; + + if !classes.is_empty() { + write!(f, "\n Classes: [")?; + for (i, (name, cls)) in classes.iter().enumerate() { + if i > 0 { + write!(f, ",")?; + } + write!(f, "\n {} {}", name, cls.lock().unwrap())?; + } + write!(f, "\n ]")?; + } + + if !type_aliases.is_empty() { + write!(f, "\n type_aliases: ")?; + + match self.type_aliases.lock() { + Ok(type_aliases) => { + let keys: Vec<_> = type_aliases.keys().collect(); + writeln!(f, "{keys:?}")? + } + Err(_) => writeln!(f, "Cannot acquire lock,")?, + } + } + + if !recursive_type_aliases.is_empty() { + write!(f, "\n recursive_type_aliases: ")?; + + match self.recursive_type_aliases.lock() { + Ok(recursive_type_aliases) => { + let keys: Vec<_> = recursive_type_aliases.iter().map(|v| v.keys()).collect(); + writeln!(f, "{keys:?}")? + } + Err(_) => writeln!(f, "Cannot acquire lock,")?, + } + } + + if !enums.is_empty() { + if !classes.is_empty() { + write!(f, ",")?; + } + write!(f, "\n Enums: [")?; + for (i, (name, e)) in enums.iter().enumerate() { + if i > 0 { + write!(f, ",")?; + } + write!(f, "\n {} {}", name, e.lock().unwrap())?; + } + write!(f, "\n ]")?; + } + + write!(f, "\n)") + } +} + +impl std::fmt::Debug for TypeBuilder { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + writeln!(f, "TypeBuilder {{")?; + + write!(f, " classes: ")?; + match self.classes.lock() { + Ok(classes) => { + let keys: Vec<_> = classes.keys().collect(); + writeln!(f, "{keys:?},")? + } + Err(_) => writeln!(f, "Cannot acquire lock,")?, + } + + write!(f, " enums: ")?; + match self.enums.lock() { + Ok(enums) => { + let keys: Vec<_> = enums.keys().collect(); + writeln!(f, "{keys:?}")? + } + Err(_) => writeln!(f, "Cannot acquire lock,")?, + } + + write!(f, "}}") + } +} diff --git a/engine/baml-lib/type-builder/src/ir_aware/mod.rs b/engine/baml-lib/type-builder/src/ir_aware/mod.rs new file mode 100644 index 0000000000..1cf2cb2a6e --- /dev/null +++ b/engine/baml-lib/type-builder/src/ir_aware/mod.rs @@ -0,0 +1,5 @@ +mod type_builder; + +pub use type_builder::{ + ClassBuilder, ClassPropertyBuilder, EnumBuilder, EnumValueBuilder, NodeRW, TypeBuilder, +}; diff --git a/engine/baml-lib/type-builder/src/ir_aware/type_builder.rs b/engine/baml-lib/type-builder/src/ir_aware/type_builder.rs new file mode 100644 index 0000000000..c518772a3c --- /dev/null +++ b/engine/baml-lib/type-builder/src/ir_aware/type_builder.rs @@ -0,0 +1,1274 @@ +use crate::{ + core::{self, TypeBuilder as CoreTypeBuilder, WithMeta}, + traits::{IRProvider, RuntimeProvider}, +}; +use baml_types::{BamlValue, EvaluationContext, TypeIR}; +use indexmap::{IndexMap, IndexSet}; +use internal_baml_core::ir::{repr::TypeBuilderEntry, IRHelper}; +use std::sync::{Arc, Mutex}; + +type RuntimeTypeBuilder = Arc; + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] +pub enum NodeRW { + // Only view the data (no modifications allowed) + ReadOnly, + // View data, but can modify attributes like alias / description + LLMOnly, + // Go wild + ReadWrite, +} + +impl NodeRW { + fn at_least(&self, other: NodeRW) -> anyhow::Result<()> { + if self < &other { + anyhow::bail!( + "Insufficient permissions to perform this operation: {:?} < {:?}", + self, + other + ); + } + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_node_rw_at_least() { + assert!(NodeRW::ReadOnly.at_least(NodeRW::ReadOnly).is_ok()); + assert!(NodeRW::ReadOnly.at_least(NodeRW::LLMOnly).is_err()); + assert!(NodeRW::ReadOnly.at_least(NodeRW::ReadWrite).is_err()); + + assert!(NodeRW::LLMOnly.at_least(NodeRW::ReadOnly).is_ok()); + assert!(NodeRW::LLMOnly.at_least(NodeRW::LLMOnly).is_ok()); + assert!(NodeRW::LLMOnly.at_least(NodeRW::ReadWrite).is_err()); + + assert!(NodeRW::ReadWrite.at_least(NodeRW::ReadOnly).is_ok()); + assert!(NodeRW::ReadWrite.at_least(NodeRW::LLMOnly).is_ok()); + assert!(NodeRW::ReadWrite.at_least(NodeRW::ReadWrite).is_ok()); + } +} + +#[derive(Clone)] +pub struct TypeBuilder { + type_builder: RuntimeTypeBuilder, + ir_provider: Arc, +} + +impl std::fmt::Debug for TypeBuilder { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.type_builder) + } +} + +impl std::fmt::Display for TypeBuilder { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.type_builder) + } +} + +impl TypeBuilder { + pub fn new(ir_provider: Arc) -> Self { + Self { + type_builder: Arc::new(CoreTypeBuilder::new()), + ir_provider, + } + } + + pub fn add_enum(&self, name: &str) -> anyhow::Result> { + let ir = self.ir_provider.get_ir(); + match ir.find_enum(name) { + Ok(_) => { + anyhow::bail!("Enum with name {name} already exists"); + } + Err(_) => { + let _ = self.type_builder.upsert_enum(name); + let builder = EnumBuilder::new( + self.type_builder.clone(), + self.ir_provider.clone(), + name.to_string(), + ); + Ok(builder.mode(NodeRW::ReadWrite)) + } + } + } + + pub fn add_class(&self, name: &str) -> anyhow::Result> { + let ir = self.ir_provider.get_ir(); + match ir.find_class(name) { + Ok(_) => { + anyhow::bail!("Class with name {name} already exists"); + } + Err(_) => { + let _ = self.type_builder.upsert_class(name); + let builder = ClassBuilder::new( + self.type_builder.clone(), + self.ir_provider.clone(), + name.to_string(), + ); + Ok(builder.mode(NodeRW::ReadWrite)) + } + } + } + + pub fn class(&self, name: &str) -> anyhow::Result> { + let ir = self.ir_provider.get_ir(); + match ir.find_class(name) { + Ok(cls) => { + let _ = self.type_builder.upsert_class(name); + let builder = ClassBuilder::new( + self.type_builder.clone(), + self.ir_provider.clone(), + name.to_string(), + ); + if !cls.item.attributes.dynamic() { + Ok(builder.mode(NodeRW::ReadOnly)) + } else { + Ok(builder.mode(NodeRW::ReadWrite)) + } + } + Err(_) => match self.type_builder.maybe_get_class(name) { + Some(_) => Ok(ClassBuilder::new( + self.type_builder.clone(), + self.ir_provider.clone(), + name.to_string(), + )), + None => { + anyhow::bail!("Class with name {name} does not exist"); + } + }, + } + } + + pub fn r#enum(&self, name: &str) -> anyhow::Result> { + let ir = self.ir_provider.get_ir(); + match ir.find_enum(name) { + Ok(enm) => { + let _ = self.type_builder.upsert_enum(name); + let builder = EnumBuilder::new( + self.type_builder.clone(), + self.ir_provider.clone(), + name.to_string(), + ); + if !enm.item.attributes.dynamic() { + return Ok(builder.mode(NodeRW::ReadOnly)); + } + Ok(builder.mode(NodeRW::ReadWrite)) + } + Err(_) => match self.type_builder.maybe_get_enum(name) { + Some(_) => Ok(EnumBuilder::new( + self.type_builder.clone(), + self.ir_provider.clone(), + name.to_string(), + )), + None => { + anyhow::bail!("Enum with name {name} does not exist"); + } + }, + } + } + + /// Get the underlying core type builder + pub fn core(&self) -> &Arc { + &self.type_builder + } + + pub fn list_enums(&self) -> Vec> { + let ir = self.ir_provider.get_ir(); + let enums = ir.walk_enums(); + enums + .map(|enm| enm.name().to_string()) + .chain(self.type_builder.list_enums()) + .collect::>() + .into_iter() + .map(|name| EnumBuilder::new(self.type_builder.clone(), self.ir_provider.clone(), name)) + .collect() + } + + pub fn list_classes(&self) -> Vec> { + let ir = self.ir_provider.get_ir(); + let classes = ir.walk_classes(); + classes + .map(|cls| cls.name().to_string()) + .chain(self.type_builder.list_classes()) + .collect::>() + .into_iter() + .map(|name| { + ClassBuilder::new(self.type_builder.clone(), self.ir_provider.clone(), name) + }) + .collect() + } + + pub fn maybe_get_enum(&self, name: &str) -> Option>> { + self.type_builder.maybe_get_enum(name) + } + + pub fn recursive_type_aliases(&self) -> Arc>>> { + self.type_builder.recursive_type_aliases() + } + + pub fn recursive_classes(&self) -> Arc>>> { + self.type_builder.recursive_classes() + } + + pub fn reset(&self) { + self.type_builder.reset(); + } +} + +#[derive(Clone)] +pub struct ClassBuilder { + type_builder: RuntimeTypeBuilder, + ir_provider: Arc, + pub class_name: String, + mode: NodeRW, +} + +impl std::fmt::Debug for ClassBuilder { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "ClassBuilder({})", self.class_name) + } +} + +impl ClassBuilder { + fn new(type_builder: RuntimeTypeBuilder, ir_provider: Arc, class_name: String) -> Self { + Self { + type_builder, + ir_provider, + class_name, + mode: NodeRW::ReadOnly, + } + } + + fn mode(self, mode: NodeRW) -> Self { + Self { mode, ..self } + } + + fn create_property(&self, name: &str) -> ClassPropertyBuilder { + let builder = ClassPropertyBuilder::new( + self.type_builder.clone(), + self.ir_provider.clone(), + self.class_name.clone(), + name.to_string(), + ); + + let target_mode = match self.mode { + NodeRW::ReadOnly => NodeRW::ReadOnly, + NodeRW::LLMOnly => NodeRW::LLMOnly, + NodeRW::ReadWrite => { + let ir = self.ir_provider.get_ir(); + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + if cls.find_field(name).is_some() { + NodeRW::LLMOnly + } else { + NodeRW::ReadWrite + } + } else { + NodeRW::ReadWrite + } + } + }; + + builder.mode(target_mode) + } + + fn cls(&self) -> anyhow::Result>> { + let ir = self.ir_provider.get_ir(); + // if the IR defines the class, then its always valid + if ir.find_class(self.class_name.as_str()).is_ok() { + let cls = self.type_builder.upsert_class(self.class_name.as_str()); + return Ok(cls); + } + + let Some(cls) = self.type_builder.maybe_get_class(self.class_name.as_str()) else { + anyhow::bail!("Class not found: {}", self.class_name); + }; + Ok(cls) + } + + pub fn r#type(&self) -> anyhow::Result { + self.mode.at_least(NodeRW::ReadOnly)?; + let _ = self.cls()?; + + Ok(TypeIR::class(self.class_name.as_str())) + } + + pub fn list_properties(&self) -> anyhow::Result>> { + self.mode.at_least(NodeRW::ReadOnly)?; + + let lock = self.cls()?; + let builder = lock.lock().unwrap(); + + let ir = self.ir_provider.get_ir(); + let ir_properties = match ir.find_class(self.class_name.as_str()) { + Ok(ir_cls) => ir_cls + .item + .elem + .static_fields + .iter() + .map(|field| field.elem.name.to_string()) + .collect(), + Err(_) => vec![], + }; + + let dynamic_properties = builder + .list_properties() + .into_iter() + .filter(|name| !ir_properties.contains(name)) + .collect::>(); + + let properties = ir_properties.into_iter().chain(dynamic_properties); + Ok(properties + .into_iter() + .map(|name| self.create_property(name.as_str())) + .collect()) + } + + pub fn set_alias(&self, alias: Option<&str>) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::LLMOnly)?; + + let cls = self.cls()?; + let builder = cls.lock().unwrap(); + match alias { + Some(alias) => { + builder.with_meta("alias", BamlValue::String(alias.to_string())); + } + None => { + builder.remove_meta("alias"); + } + } + Ok(()) + } + + pub fn set_description(&self, description: Option<&str>) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::LLMOnly)?; + + let cls = self.cls()?; + let builder = cls.lock().unwrap(); + match description { + Some(description) => { + builder.with_meta("description", BamlValue::String(description.to_string())); + } + None => { + builder.remove_meta("description"); + } + } + Ok(()) + } + + pub fn alias(&self) -> Result, anyhow::Error> { + self.mode.at_least(NodeRW::ReadOnly)?; + + let ast_alias = || { + let ir = self.ir_provider.get_ir(); + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + cls.alias(&Default::default()).ok().flatten() + } else { + None + } + }; + + let cls = self.cls()?; + let builder = cls.lock().unwrap(); + let result = builder + .get_meta("alias") + .and_then(|value| value.as_str().map(|s| s.to_string())) + .or_else(ast_alias); + Ok(result) + } + + pub fn description(&self) -> Result, anyhow::Error> { + self.mode.at_least(NodeRW::ReadOnly)?; + + // ast does not support description + let ast_description = || { + let ir = self.ir_provider.get_ir(); + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + cls.description(&Default::default()).ok().flatten() + } else { + None + } + }; + + let cls = self.cls()?; + let builder = cls.lock().unwrap(); + let result = builder + .get_meta("description") + .and_then(|value| value.as_str().map(|s| s.to_string())) + .or_else(ast_description); + Ok(result) + } + + pub fn add_property( + &self, + name: &str, + field_type: TypeIR, + allow_existing: bool, + ) -> anyhow::Result> { + self.mode.at_least(NodeRW::ReadWrite)?; + let cls = self.cls()?; + + // if the IR already has the property, then its not valid to add it again + let ir = self.ir_provider.get_ir(); + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + if cls.find_field(name).is_some() { + if !allow_existing { + anyhow::bail!( + "Property already exists: {} in class {}", + name, + self.class_name + ); + } + } + } + + let builder = cls.lock().unwrap(); + let prop = builder.upsert_property(name); + prop.lock().unwrap().set_type(field_type); + Ok(self.create_property(name)) + } + + pub fn remove_property(&self, name: &str) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::ReadWrite)?; + // if the IR already has the property, then its not valid to remove it + let ir = self.ir_provider.get_ir(); + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + if cls.find_field(name).is_some() { + anyhow::bail!( + "Property is statically defined: {} in class {}. Cannot remove it.", + name, + self.class_name + ); + } + } + + let cls = self.cls()?; + let builder = cls.lock().unwrap(); + builder.remove_property(name); + Ok(()) + } + + pub fn property(&self, name: &str) -> anyhow::Result> { + self.mode.at_least(NodeRW::ReadOnly)?; + let cls = self.cls()?; + + let builder = cls.lock().unwrap(); + match builder.maybe_get_property(name) { + Some(_) => Ok(self.create_property(name)), + None => { + // if the IR has the property, then its valid to add it again + let ir = self.ir_provider.get_ir(); + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + if cls.find_field(name).is_some() { + let _ = builder.upsert_property(name); + Ok(self.create_property(name)) + } else { + anyhow::bail!("Property not found: {} in class {}", name, self.class_name) + } + } else { + anyhow::bail!("Property not found: {} in class {}", name, self.class_name) + } + } + } + } + + pub fn is_from_ast(&self) -> anyhow::Result { + self.mode.at_least(NodeRW::ReadOnly)?; + let ir = self.ir_provider.get_ir(); + Ok(ir.find_class(self.class_name.as_str()).is_ok()) + } + + pub fn reset(&self) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::ReadWrite)?; + let cls = self.cls()?; + let builder = cls.lock().unwrap(); + builder.reset(); + Ok(()) + } +} + +#[derive(Clone)] +pub struct ClassPropertyBuilder { + type_builder: RuntimeTypeBuilder, + ir_provider: Arc, + class_name: String, + pub property_name: String, + mode: NodeRW, +} + +impl std::fmt::Debug for ClassPropertyBuilder { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "ClassPropertyBuilder({})", self.property_name) + } +} + +impl ClassPropertyBuilder { + fn new( + type_builder: RuntimeTypeBuilder, + ir_provider: Arc, + class_name: String, + property_name: String, + ) -> Self { + Self { + type_builder, + ir_provider, + class_name, + property_name, + mode: NodeRW::ReadOnly, + } + } + + fn mode(self, mode: NodeRW) -> Self { + Self { mode, ..self } + } + + fn prop(&self) -> anyhow::Result>> { + let ir = self.ir_provider.get_ir(); + // if the class is defined in the IR, then its always valid + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + if cls.find_field(&self.property_name).is_some() { + let cls = self.type_builder.upsert_class(self.class_name.as_str()); + let builder = cls.lock().unwrap(); + let prop = builder.upsert_property(&self.property_name); + return Ok(prop); + } + } + + let Some(cls) = self.type_builder.maybe_get_class(self.class_name.as_str()) else { + return Err(anyhow::anyhow!("Class not found: {}", self.class_name)); + }; + let builder = cls.lock().unwrap(); + match builder.maybe_get_property(&self.property_name) { + Some(prop) => Ok(prop), + None => { + anyhow::bail!( + "Property not found: {} in class {}", + self.property_name, + self.class_name + ) + } + } + } + + pub fn description(&self) -> Result, anyhow::Error> { + self.mode.at_least(NodeRW::ReadOnly)?; + + let prop = self.prop()?; + + let ast_description = || { + let ir = self.ir_provider.get_ir(); + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + if let Some(field) = cls.find_field(&self.property_name) { + field.description(&Default::default()).ok().flatten() + } else { + None + } + } else { + None + } + }; + let builder = prop.lock().unwrap(); + let result = builder + .get_meta("description") + .and_then(|value| value.as_str().map(|s| s.to_string())) + .or_else(ast_description); + Ok(result) + } + + pub fn alias(&self) -> Result, anyhow::Error> { + self.mode.at_least(NodeRW::ReadOnly)?; + + let prop = self.prop()?; + + let ast_alias = || { + let ir = self.ir_provider.get_ir(); + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + if let Some(field) = cls.find_field(&self.property_name) { + field.description(&Default::default()).ok().flatten() + } else { + None + } + } else { + None + } + }; + let builder = prop.lock().unwrap(); + let result = builder + .get_meta("alias") + .and_then(|value| value.as_str().map(|s| s.to_string())) + .or_else(ast_alias); + Ok(result) + } + + pub fn type_(&self) -> Result { + self.mode.at_least(NodeRW::ReadOnly)?; + + let ast_type = || { + let ir = self.ir_provider.get_ir(); + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + cls.find_field(&self.property_name) + .map(|field| field.r#type().clone()) + } else { + None + } + }; + + let prop = self.prop()?; + let builder = prop.lock().unwrap(); + let result = builder.r#type().or_else(ast_type).ok_or_else(|| { + anyhow::anyhow!( + "Type not found for property {} in class {}", + self.property_name, + self.class_name + ) + }); + result + } + + pub fn set_description(&self, description: Option<&str>) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::LLMOnly)?; + + let prop = self.prop()?; + let builder = prop.lock().unwrap(); + match description { + Some(description) => { + builder.with_meta("description", BamlValue::String(description.to_string())); + } + None => { + builder.remove_meta("description"); + } + } + Ok(()) + } + + pub fn set_alias(&self, alias: Option<&str>) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::LLMOnly)?; + + let prop = self.prop()?; + let builder = prop.lock().unwrap(); + match alias { + Some(alias) => { + builder.with_meta("alias", BamlValue::String(alias.to_string())); + } + None => { + builder.remove_meta("alias"); + } + } + Ok(()) + } + + pub fn set_type(&self, field_type: TypeIR) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::ReadWrite)?; + + let prop = self.prop()?; + let builder = prop.lock().unwrap(); + builder.set_type(field_type); + Ok(()) + } + + pub fn is_from_ast(&self) -> anyhow::Result { + self.mode.at_least(NodeRW::ReadOnly)?; + let ir = self.ir_provider.get_ir(); + if let Ok(cls) = ir.find_class(self.class_name.as_str()) { + if cls.find_field(&self.property_name).is_some() { + return Ok(true); + } + } + Ok(false) + } +} + +#[derive(Clone)] +pub struct EnumBuilder { + type_builder: RuntimeTypeBuilder, + ir_provider: Arc, + pub enum_name: String, + mode: NodeRW, +} + +impl std::fmt::Debug for EnumBuilder { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "EnumBuilder({})", self.enum_name) + } +} + +impl EnumBuilder { + fn new(type_builder: RuntimeTypeBuilder, ir_provider: Arc, enum_name: String) -> Self { + Self { + type_builder, + ir_provider, + enum_name, + mode: NodeRW::ReadOnly, + } + } + + fn mode(self, mode: NodeRW) -> Self { + Self { mode, ..self } + } + + fn enm(&self) -> anyhow::Result>> { + let ir = self.ir_provider.get_ir(); + // if the IR defines the enum, then its always valid + if ir.find_enum(self.enum_name.as_str()).is_ok() { + return Ok(self.type_builder.upsert_enum(self.enum_name.as_str())); + } + + let Some(enm) = self.type_builder.maybe_get_enum(self.enum_name.as_str()) else { + anyhow::bail!("Enum not found: {}", self.enum_name); + }; + Ok(enm) + } + + fn create_value(&self, name: &str) -> EnumValueBuilder { + let target_mode = match self.mode { + NodeRW::ReadOnly => NodeRW::ReadOnly, + NodeRW::LLMOnly => NodeRW::LLMOnly, + NodeRW::ReadWrite => { + let ir = self.ir_provider.get_ir(); + if let Ok(enm) = ir.find_enum(self.enum_name.as_str()) { + if enm.find_value(name).is_some() { + NodeRW::LLMOnly + } else { + NodeRW::ReadWrite + } + } else { + NodeRW::ReadWrite + } + } + }; + + EnumValueBuilder::new( + self.type_builder.clone(), + self.ir_provider.clone(), + self.enum_name.clone(), + name.to_string(), + ) + .mode(target_mode) + } + + pub fn add_value(&self, value: &str) -> anyhow::Result> { + self.mode.at_least(NodeRW::ReadWrite)?; + let enm = self.enm()?; + + // if the IR already has the value, then its not valid to add it again + let ir = self.ir_provider.get_ir(); + if let Ok(enm_ir) = ir.find_enum(self.enum_name.as_str()) { + if enm_ir.find_value(value).is_some() { + anyhow::bail!( + "Enum value already exists: {} in enum {}", + value, + self.enum_name + ); + } + } + + let builder = enm.lock().unwrap(); + let _ = builder.upsert_value(value); + Ok(self.create_value(value)) + } + + pub fn set_description(&self, description: Option<&str>) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::LLMOnly)?; + + let enm = self.enm()?; + let builder = enm.lock().unwrap(); + match description { + Some(description) => { + builder.with_meta("description", BamlValue::String(description.to_string())); + } + None => { + builder.remove_meta("description"); + } + } + Ok(()) + } + + pub fn set_alias(&self, alias: Option<&str>) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::LLMOnly)?; + + let enm = self.enm()?; + let builder = enm.lock().unwrap(); + match alias { + Some(alias) => { + builder.with_meta("alias", BamlValue::String(alias.to_string())); + } + None => { + builder.remove_meta("alias"); + } + } + Ok(()) + } + + pub fn alias(&self) -> Result, anyhow::Error> { + let ast_alias = || { + let ir = self.ir_provider.get_ir(); + if let Ok(enm) = ir.find_enum(self.enum_name.as_str()) { + enm.alias(&Default::default()).ok().flatten() + } else { + None + } + }; + + let enm = self.enm()?; + let builder = enm.lock().unwrap(); + let result = builder + .get_meta("alias") + .and_then(|value| value.as_str().map(|s| s.to_string())) + .or_else(ast_alias); + Ok(result) + } + + pub fn description(&self) -> Result, anyhow::Error> { + let ast_description = || { + let ir = self.ir_provider.get_ir(); + if let Ok(enm) = ir.find_enum(self.enum_name.as_str()) { + enm.description(&Default::default()).ok().flatten() + } else { + None + } + }; + + let enm = self.enm()?; + let builder = enm.lock().unwrap(); + let result = builder + .get_meta("description") + .and_then(|value| value.as_str().map(|s| s.to_string())) + .or_else(ast_description); + Ok(result) + } + + pub fn r#type(&self) -> anyhow::Result { + self.mode.at_least(NodeRW::ReadOnly)?; + let _ = self.enm()?; + + Ok(TypeIR::r#enum(self.enum_name.as_str())) + } + + pub fn list_values(&self) -> anyhow::Result>> { + self.mode.at_least(NodeRW::ReadOnly)?; + + let enm = self.enm()?; + + let ir = self.ir_provider.get_ir(); + let ir_values = match ir.find_enum(self.enum_name.as_str()) { + Ok(ir_enm) => ir_enm + .item + .elem + .values + .iter() + .map(|value| value.0.elem.0.to_string()) + .collect(), + Err(_) => vec![], + }; + + let builder = enm.lock().unwrap(); + let dynamic_values = builder + .list_values() + .into_iter() + .filter(|name| !ir_values.contains(name)) + .collect::>(); + + let values = ir_values.into_iter().chain(dynamic_values); + Ok(values + .into_iter() + .map(|name| self.create_value(name.as_str())) + .collect()) + } + + pub fn value(&self, name: &str) -> anyhow::Result> { + self.mode.at_least(NodeRW::ReadOnly)?; + let enm = self.enm()?; + + let builder = enm.lock().unwrap(); + let values = builder.list_values(); + if values.contains(&name.to_string()) { + Ok(self.create_value(name)) + } else { + // if the IR has the value, then its valid to add it again + let ir = self.ir_provider.get_ir(); + if let Ok(enm_ir) = ir.find_enum(self.enum_name.as_str()) { + if enm_ir.find_value(name).is_some() { + let _ = builder.upsert_value(name); + Ok(self.create_value(name)) + } else { + anyhow::bail!("Enum value not found: {} in enum {}", name, self.enum_name) + } + } else { + anyhow::bail!("Enum value not found: {} in enum {}", name, self.enum_name) + } + } + } + + pub fn remove_value(&self, name: &str) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::ReadWrite)?; + // if the IR already has the value, then its not valid to remove it + let ir = self.ir_provider.get_ir(); + if let Ok(enm) = ir.find_enum(self.enum_name.as_str()) { + if enm.find_value(name).is_some() { + anyhow::bail!( + "Enum value is statically defined: {} in enum {}. Try skipping it instead.", + name, + self.enum_name + ); + } + } + + let enm = self.enm()?; + let builder = enm.lock().unwrap(); + builder.remove_value(name); + Ok(()) + } + + pub fn is_from_ast(&self) -> anyhow::Result { + self.mode.at_least(NodeRW::ReadOnly)?; + let ir = self.ir_provider.get_ir(); + Ok(ir.find_enum(self.enum_name.as_str()).is_ok()) + } +} + +#[derive(Clone)] +pub struct EnumValueBuilder { + type_builder: RuntimeTypeBuilder, + ir_provider: Arc, + enum_name: String, + pub value_name: String, + mode: NodeRW, +} + +impl std::fmt::Debug for EnumValueBuilder { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "EnumValueBuilder({})", self.value_name) + } +} + +impl EnumValueBuilder { + fn new( + type_builder: RuntimeTypeBuilder, + ir_provider: Arc, + enum_name: String, + value_name: String, + ) -> Self { + Self { + type_builder, + ir_provider, + enum_name, + value_name, + mode: NodeRW::ReadOnly, + } + } + + fn mode(self, mode: NodeRW) -> Self { + Self { mode, ..self } + } + + fn value(&self) -> anyhow::Result>> { + let ir = self.ir_provider.get_ir(); + // if the enum is defined in the IR, then its always valid + if let Ok(enm) = ir.find_enum(self.enum_name.as_str()) { + if enm.find_value(self.value_name.as_str()).is_some() { + let enm = self.type_builder.upsert_enum(self.enum_name.as_str()); + let builder = enm.lock().unwrap(); + let value = builder.upsert_value(&self.value_name); + return Ok(value); + } + } + + let Some(enm) = self.type_builder.maybe_get_enum(self.enum_name.as_str()) else { + return Err(anyhow::anyhow!("Enum not found: {}", self.enum_name)); + }; + let builder = enm.lock().unwrap(); + match builder.maybe_get_value(&self.value_name) { + Some(value) => Ok(value), + None => { + anyhow::bail!( + "Enum value not found: {} in enum {}", + self.value_name, + self.enum_name + ) + } + } + } + + pub fn set_description(&self, description: Option<&str>) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::LLMOnly)?; + + let value = self.value()?; + let builder = value.lock().unwrap(); + match description { + Some(description) => { + builder.with_meta("description", BamlValue::String(description.to_string())); + } + None => { + builder.remove_meta("description"); + } + } + Ok(()) + } + + pub fn set_alias(&self, alias: Option<&str>) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::LLMOnly)?; + + let value = self.value()?; + let builder = value.lock().unwrap(); + match alias { + Some(alias) => { + builder.with_meta("alias", BamlValue::String(alias.to_string())); + } + None => { + builder.remove_meta("alias"); + } + } + Ok(()) + } + + pub fn description(&self) -> Result, anyhow::Error> { + let ast_description = || { + let ir = self.ir_provider.get_ir(); + if let Ok(enm) = ir.find_enum(self.enum_name.as_str()) { + if let Some(value) = enm.find_value(&self.value_name) { + value.description(&Default::default()).ok().flatten() + } else { + None + } + } else { + None + } + }; + + let value = self.value()?; + let builder = value.lock().unwrap(); + let result = builder + .get_meta("description") + .and_then(|value| value.as_str().map(|s| s.to_string())) + .or_else(ast_description); + Ok(result) + } + + pub fn alias(&self) -> Result, anyhow::Error> { + let ast_alias = || { + let ir = self.ir_provider.get_ir(); + if let Ok(enm) = ir.find_enum(self.enum_name.as_str()) { + if let Some(value) = enm.find_value(&self.value_name) { + value.alias(&Default::default()).ok().flatten() + } else { + None + } + } else { + None + } + }; + + let value = self.value()?; + let builder = value.lock().unwrap(); + let result = builder + .get_meta("alias") + .and_then(|value| value.as_str().map(|s| s.to_string())) + .or_else(ast_alias); + Ok(result) + } + + pub fn set_skip(&self, skip: Option) -> anyhow::Result<()> { + self.mode.at_least(NodeRW::LLMOnly)?; + + let value = self.value()?; + let builder = value.lock().unwrap(); + match skip { + Some(skip) => { + builder.with_meta("skip", BamlValue::Bool(skip)); + } + None => { + builder.remove_meta("skip"); + } + } + Ok(()) + } + + pub fn skip(&self) -> anyhow::Result { + self.mode.at_least(NodeRW::ReadOnly)?; + + let ast_skip = || { + let ir = self.ir_provider.get_ir(); + if let Ok(enm) = ir.find_enum(self.enum_name.as_str()) { + if let Some(value) = enm.find_value(&self.value_name) { + value.skip(&Default::default()).ok() + } else { + None + } + } else { + None + } + }; + + let value = self.value()?; + let builder = value.lock().unwrap(); + let skip = builder + .get_meta("skip") + .and_then(|value| value.as_bool()) + .or_else(ast_skip) + .unwrap_or(false); + Ok(skip) + } + + pub fn is_from_ast(&self) -> anyhow::Result { + self.mode.at_least(NodeRW::ReadOnly)?; + let ir = self.ir_provider.get_ir(); + if let Ok(enm) = ir.find_enum(self.enum_name.as_str()) { + if enm.find_value(&self.value_name).is_some() { + return Ok(true); + } + } + Ok(false) + } +} + +// Runtime-specific extensions for TypeBuilder +impl TypeBuilder { + /// Add entries from parsed BAML to the type builder + pub fn add_entries(&self, entries: &[TypeBuilderEntry]) { + for entry in entries { + match entry { + TypeBuilderEntry::Class(cls) => { + let mutex = self.type_builder.upsert_class(&cls.elem.name); + let class_builder = mutex.lock().unwrap(); + for f in &cls.elem.static_fields { + class_builder + .upsert_property(&f.elem.name) + .lock() + .unwrap() + .set_type(f.elem.r#type.elem.to_owned()) + .with_meta( + "alias", + f.attributes.alias().map_or(BamlValue::Null, |v| { + v.resolve(&EvaluationContext::default()) + .map_or(BamlValue::Null, BamlValue::String) + }), + ) + .with_meta( + "description", + f.attributes.description().map_or(BamlValue::Null, |v| { + v.resolve(&EvaluationContext::default()) + .map_or(BamlValue::Null, BamlValue::String) + }), + ); + } + } + + TypeBuilderEntry::Enum(enm) => { + let mutex = self.type_builder.upsert_enum(&enm.elem.name); + let enum_builder = mutex.lock().unwrap(); + for (variant, _) in &enm.elem.values { + enum_builder + .upsert_value(&variant.elem.0) + .lock() + .unwrap() + .with_meta( + "alias", + variant.attributes.alias().map_or(BamlValue::Null, |v| { + v.resolve(&EvaluationContext::default()) + .map_or(BamlValue::Null, BamlValue::String) + }), + ) + .with_meta( + "description", + variant + .attributes + .description() + .map_or(BamlValue::Null, |v| { + v.resolve(&EvaluationContext::default()) + .map_or(BamlValue::Null, BamlValue::String) + }), + ) + .with_meta( + "skip", + if variant.attributes.skip() { + BamlValue::Bool(true) + } else { + BamlValue::Bool(false) + }, + ); + } + } + + TypeBuilderEntry::TypeAlias(alias) => { + let mutex = self.type_builder.upsert_type_alias(&alias.elem.name); + let alias_builder = mutex.lock().unwrap(); + alias_builder.target(alias.elem.r#type.elem.to_owned()); + } + } + } + } + + /// Parse and add BAML code to the type builder + pub fn add_baml(&self, baml: &str) -> anyhow::Result<()> { + use internal_baml_core::{ + internal_baml_ast::parse_type_builder_contents_from_str, + internal_baml_diagnostics::{Diagnostics, SourceFile}, + ir::repr::IntermediateRepr, + run_validation_pipeline_on_db, validate_type_builder_entries, + }; + + let path = std::path::PathBuf::from("TypeBuilder::add_baml"); + let source = SourceFile::from((path.clone(), baml)); + + let mut diagnostics = Diagnostics::new(path); + diagnostics.set_source(&source); + + let type_builder_entries = parse_type_builder_contents_from_str(baml, &mut diagnostics)?; + + if diagnostics.has_errors() { + anyhow::bail!("{}", diagnostics.to_pretty_string()); + } + + // TODO: A bunch of mem usage here but at least we drop this one at the + // end of the function, unlike scoped DBs for type builders. + let mut scoped_db = self.ir_provider.clone_db(); + + let local_ast = + validate_type_builder_entries(&mut diagnostics, &scoped_db, &type_builder_entries); + scoped_db.add_ast(local_ast); + + if let Err(d) = scoped_db.validate(&mut diagnostics) { + diagnostics.push(d); + anyhow::bail!("{}", diagnostics.to_pretty_string()); + } + + run_validation_pipeline_on_db(&mut scoped_db, &mut diagnostics); + + if diagnostics.has_errors() { + anyhow::bail!("{}", diagnostics.to_pretty_string()); + } + + let (classes, enums, type_aliases, recursive_classes, recursive_aliases) = + IntermediateRepr::type_builder_entries_from_scoped_db( + &scoped_db, + &self.ir_provider.get_db(), + ) + .map_err(|e| anyhow::anyhow!("{:?}", e))?; + + self.add_entries( + &classes + .into_iter() + .map(TypeBuilderEntry::Class) + .chain(enums.into_iter().map(TypeBuilderEntry::Enum)) + .chain(type_aliases.into_iter().map(TypeBuilderEntry::TypeAlias)) + .collect::>(), + ); + + self.type_builder + .recursive_type_aliases() + .lock() + .unwrap() + .extend(recursive_aliases); + + self.type_builder + .recursive_classes() + .lock() + .unwrap() + .extend(recursive_classes); + + Ok(()) + } +} diff --git a/engine/baml-lib/type-builder/src/lib.rs b/engine/baml-lib/type-builder/src/lib.rs new file mode 100644 index 0000000000..86439a4125 --- /dev/null +++ b/engine/baml-lib/type-builder/src/lib.rs @@ -0,0 +1,9 @@ +mod core; +mod ir_aware; +pub mod traits; + +// Re-export commonly used types at the crate root +pub use core::{Meta, WithMeta}; +pub use ir_aware::{ + ClassBuilder, ClassPropertyBuilder, EnumBuilder, EnumValueBuilder, TypeBuilder, +}; diff --git a/engine/baml-lib/type-builder/src/traits/ir_provider.rs b/engine/baml-lib/type-builder/src/traits/ir_provider.rs new file mode 100644 index 0000000000..5854bf0724 --- /dev/null +++ b/engine/baml-lib/type-builder/src/traits/ir_provider.rs @@ -0,0 +1,5 @@ +use internal_baml_core::ir::repr::IntermediateRepr; + +pub trait IRProvider: Send + Sync { + fn get_ir(&self) -> &IntermediateRepr; +} diff --git a/engine/baml-lib/type-builder/src/traits/mod.rs b/engine/baml-lib/type-builder/src/traits/mod.rs new file mode 100644 index 0000000000..038ffbd1ea --- /dev/null +++ b/engine/baml-lib/type-builder/src/traits/mod.rs @@ -0,0 +1,5 @@ +mod ir_provider; +mod runtime_provider; + +pub use ir_provider::IRProvider; +pub use runtime_provider::RuntimeProvider; diff --git a/engine/baml-lib/type-builder/src/traits/runtime_provider.rs b/engine/baml-lib/type-builder/src/traits/runtime_provider.rs new file mode 100644 index 0000000000..7fe7c66091 --- /dev/null +++ b/engine/baml-lib/type-builder/src/traits/runtime_provider.rs @@ -0,0 +1,12 @@ +use super::IRProvider; +use internal_baml_parser_database::ParserDatabase; + +/// Extended trait for IR providers that also have runtime capabilities +/// This is implemented by InternalBamlRuntime to provide full type builder functionality +pub trait RuntimeProvider: IRProvider { + /// Get access to the parser database for BAML validation + fn get_db(&self) -> &ParserDatabase; + + /// Clone the parser database for scoped modifications + fn clone_db(&self) -> ParserDatabase; +} diff --git a/engine/baml-runtime/Cargo.toml b/engine/baml-runtime/Cargo.toml index 0bb57a9c7e..427dc6a72b 100644 --- a/engine/baml-runtime/Cargo.toml +++ b/engine/baml-runtime/Cargo.toml @@ -33,6 +33,7 @@ baml-ids.workspace = true internal-baml-ast = { path = "../baml-lib/ast" } internal-baml-diagnostics = { path = "../baml-lib/diagnostics" } baml-log.workspace = true +baml-type-builder = { path = "../baml-lib/type-builder" } baml-types.workspace = true baml-rpc.workspace = true baml-vm = { path = "../baml-vm" } diff --git a/engine/baml-runtime/src/async_vm_runtime.rs b/engine/baml-runtime/src/async_vm_runtime.rs index 042a3a9098..07e1de089c 100644 --- a/engine/baml-runtime/src/async_vm_runtime.rs +++ b/engine/baml-runtime/src/async_vm_runtime.rs @@ -25,11 +25,10 @@ use crate::on_log_event::LogEventCallbackSync; use crate::{ client_registry::ClientRegistry, internal::llm_client::{orchestrator::OrchestrationScope, LLMResponse}, - runtime::InternalBamlRuntime, + runtime::{runtime_interface::TypeBuilder, InternalBamlRuntime}, runtime_interface::ExperimentalTracingInterface, tracing::TracingCall, tracingv2::storage::storage::Collector, - type_builder::TypeBuilder, BamlRuntime as LlmRuntime, BamlSrcReader, FunctionResult, FunctionResultStream, InnerTraceStats, InternalRuntimeInterface, RuntimeContextManager, TripWire, }; diff --git a/engine/baml-runtime/src/internal/prompt_renderer/render_output_format.rs b/engine/baml-runtime/src/internal/prompt_renderer/render_output_format.rs index 03ea9df632..cf3832c370 100644 --- a/engine/baml-runtime/src/internal/prompt_renderer/render_output_format.rs +++ b/engine/baml-runtime/src/internal/prompt_renderer/render_output_format.rs @@ -96,8 +96,22 @@ fn find_new_class_field( } } - let alias = OverridableValue::::from(field_overrides.1.alias.as_ref()); - let desc = OverridableValue::::from(field_overrides.1.meta.get("description")); + let alias = OverridableValue::::from( + field_overrides + .1 + .alias + .as_ref() + .map(|s| BamlValue::String(s.clone())) + .as_ref(), + ); + let desc = OverridableValue::::from( + field_overrides + .1 + .description + .as_ref() + .map(|s| BamlValue::String(s.clone())) + .as_ref(), + ); let name = Name::new_with_alias(field_name.to_string(), alias.value()); let desc = desc.value(); @@ -127,9 +141,22 @@ fn find_existing_class_field( let mut needed = OverridableValue::Unset; if let Some(attrs) = field_overrides { - alias = OverridableValue::::from(attrs.alias.as_ref()); - desc = OverridableValue::::from(attrs.meta.get("description")); - needed = OverridableValue::::from(attrs.meta.get("stream.not_null")); + alias = OverridableValue::::from( + attrs + .alias + .as_ref() + .map(|s| BamlValue::String(s.clone())) + .as_ref(), + ); + desc = OverridableValue::::from( + attrs + .description + .as_ref() + .map(|s| BamlValue::String(s.clone())) + .as_ref(), + ); + // TODO: stream.not_null is not available in PropertyAttributes + // needed = OverridableValue::::from(attrs.meta.get("stream.not_null")); } let eval_ctx = ctx.eval_ctx(false); @@ -179,14 +206,27 @@ fn find_enum_value( let mut alias = OverridableValue::Unset; let mut desc = OverridableValue::Unset; if let Some(attrs) = value_overrides { - match attrs.skip { - Some(true) => return Ok(None), - Some(false) => skip = OverridableValue::Set(false), - None => {} - } - - alias = OverridableValue::::from(attrs.alias.as_ref()); - desc = OverridableValue::::from(attrs.meta.get("description")); + // TODO: skip field is not available in PropertyAttributes + // match attrs.skip { + // Some(true) => return Ok(None), + // Some(false) => skip = OverridableValue::Set(false), + // None => {} + // } + + alias = OverridableValue::::from( + attrs + .alias + .as_ref() + .map(|s| BamlValue::String(s.clone())) + .as_ref(), + ); + desc = OverridableValue::::from( + attrs + .description + .as_ref() + .map(|s| BamlValue::String(s.clone())) + .as_ref(), + ); } let eval_ctx = ctx.eval_ctx(false); diff --git a/engine/baml-runtime/src/lib.rs b/engine/baml-runtime/src/lib.rs index 9367b1641b..7988239f41 100644 --- a/engine/baml-runtime/src/lib.rs +++ b/engine/baml-runtime/src/lib.rs @@ -93,10 +93,10 @@ use tracingv2::{ publisher::flush, storage::storage::{Collector, BAML_TRACER}, }; -use type_builder::TypeBuilder; pub use types::*; use web_time::{Duration, SystemTime}; +use crate::runtime::runtime_interface::TypeBuilder; use crate::{ errors::IntoBamlError, internal::llm_client::{LLMCompleteResponse, LLMCompleteResponseMetadata, LLMResponse}, @@ -330,7 +330,6 @@ impl BamlRuntime { ) } - #[cfg(feature = "internal")] pub fn internal(&self) -> &Arc { &self.inner } diff --git a/engine/baml-runtime/src/runtime/runtime_interface.rs b/engine/baml-runtime/src/runtime/runtime_interface.rs index aaceacb973..7d59922664 100644 --- a/engine/baml-runtime/src/runtime/runtime_interface.rs +++ b/engine/baml-runtime/src/runtime/runtime_interface.rs @@ -1,6 +1,10 @@ use std::{collections::HashMap, path::PathBuf, sync::Arc}; use anyhow::{Context, Result}; + +use baml_type_builder::TypeBuilder as GenericTypeBuilder; +pub type TypeBuilder = GenericTypeBuilder; + use baml_types::{ tracing::events::{FunctionEnd, FunctionStart, TraceData, TraceEvent}, BamlMap, BamlValue, Constraint, EvaluationContext, @@ -37,7 +41,6 @@ use crate::{ runtime_interface::{InternalClientLookup, RuntimeConstructor}, tracing::BamlTracer, tracingv2::storage::storage::{Collector, BAML_TRACER}, - type_builder::TypeBuilder, FunctionResult, FunctionResultStream, InternalBamlRuntime, InternalRuntimeInterface, RenderCurlSettings, RuntimeContext, RuntimeContextManager, }; @@ -369,23 +372,23 @@ impl InternalRuntimeInterface for InternalBamlRuntime { return Ok(None); } - let type_builder = TypeBuilder::new(); - - type_builder.add_entries(test.type_builder_contents()); + // Create an IR-aware type builder for this test + // DO NOT CHECK IN THIS CHANGE: We should not clone this. + let ir_type_builder = TypeBuilder::new(Arc::new(self.clone())); + ir_type_builder.add_entries(test.type_builder_contents()); - type_builder - .recursive_type_aliases() + let core = ir_type_builder.core(); + core.recursive_type_aliases() .lock() .unwrap() .extend(test.type_builder_recursive_aliases().iter().cloned()); - type_builder - .recursive_classes() + core.recursive_classes() .lock() .unwrap() .extend(test.type_builder_recursive_classes().iter().cloned()); - Ok(Some(type_builder)) + Ok(Some(ir_type_builder)) } } @@ -434,3 +437,35 @@ impl RuntimeConstructor for InternalBamlRuntime { ) } } + +impl baml_type_builder::traits::IRProvider for InternalBamlRuntime { + fn get_ir(&self) -> &IntermediateRepr { + self.ir() + } +} + +impl baml_type_builder::traits::IRProvider for crate::BamlRuntime { + fn get_ir(&self) -> &IntermediateRepr { + self.inner.get_ir() + } +} + +impl baml_type_builder::traits::RuntimeProvider for InternalBamlRuntime { + fn get_db(&self) -> &internal_baml_core::internal_baml_parser_database::ParserDatabase { + &self.db + } + + fn clone_db(&self) -> internal_baml_core::internal_baml_parser_database::ParserDatabase { + self.db.clone() + } +} + +impl baml_type_builder::traits::RuntimeProvider for crate::BamlRuntime { + fn get_db(&self) -> &internal_baml_core::internal_baml_parser_database::ParserDatabase { + &self.inner.get_db() + } + + fn clone_db(&self) -> internal_baml_core::internal_baml_parser_database::ParserDatabase { + self.inner.clone_db() + } +} diff --git a/engine/baml-runtime/src/runtime_interface.rs b/engine/baml-runtime/src/runtime_interface.rs index 03b11e4cd5..1d2604c0ec 100644 --- a/engine/baml-runtime/src/runtime_interface.rs +++ b/engine/baml-runtime/src/runtime_interface.rs @@ -18,10 +18,9 @@ use crate::{ retry_policy::CallablePolicy, }, }, - runtime::InternalBamlRuntime, + runtime::{runtime_interface::TypeBuilder, InternalBamlRuntime}, tracing::{BamlTracer, TracingCall}, tracingv2::storage::storage::Collector, - type_builder::TypeBuilder, types::{on_log_event::LogEventCallbackSync, FunctionResultStream}, FunctionResult, RenderCurlSettings, RuntimeContext, RuntimeContextManager, }; diff --git a/engine/baml-runtime/src/runtime_methods/call_function.rs b/engine/baml-runtime/src/runtime_methods/call_function.rs index 1bc2cebac7..30877f1d64 100644 --- a/engine/baml-runtime/src/runtime_methods/call_function.rs +++ b/engine/baml-runtime/src/runtime_methods/call_function.rs @@ -37,7 +37,6 @@ use crate::{ runtime_interface::{InternalClientLookup, RuntimeConstructor}, tracing::BamlTracer, tracingv2::storage::storage::{Collector, BAML_TRACER}, - type_builder::TypeBuilder, FunctionResult, FunctionResultStream, InternalRuntimeInterface, RenderCurlSettings, RuntimeContext, RuntimeContextManager, TripWire, }; diff --git a/engine/baml-runtime/src/runtime_methods/prepare_function.rs b/engine/baml-runtime/src/runtime_methods/prepare_function.rs index 72639d0c12..b49ea92cb1 100644 --- a/engine/baml-runtime/src/runtime_methods/prepare_function.rs +++ b/engine/baml-runtime/src/runtime_methods/prepare_function.rs @@ -37,7 +37,6 @@ use crate::{ runtime_interface::{InternalClientLookup, RuntimeConstructor}, tracing::BamlTracer, tracingv2::storage::storage::{Collector, BAML_TRACER}, - type_builder::TypeBuilder, FunctionResult, FunctionResultStream, InternalRuntimeInterface, RenderCurlSettings, RuntimeContext, RuntimeContextManager, }; diff --git a/engine/baml-runtime/src/runtime_methods/stream_function.rs b/engine/baml-runtime/src/runtime_methods/stream_function.rs index b9f7b605d9..8e72c26ea7 100644 --- a/engine/baml-runtime/src/runtime_methods/stream_function.rs +++ b/engine/baml-runtime/src/runtime_methods/stream_function.rs @@ -36,7 +36,6 @@ use crate::{ runtime_interface::{InternalClientLookup, RuntimeConstructor}, tracing::BamlTracer, tracingv2::storage::storage::{Collector, BAML_TRACER}, - type_builder::TypeBuilder, FunctionResult, FunctionResultStream, InternalBamlRuntime, InternalRuntimeInterface, RenderCurlSettings, RuntimeContext, RuntimeContextManager, TripWire, }; diff --git a/engine/baml-runtime/src/tracing/mod.rs b/engine/baml-runtime/src/tracing/mod.rs index 8ce16cd4d1..86653b169a 100644 --- a/engine/baml-runtime/src/tracing/mod.rs +++ b/engine/baml-runtime/src/tracing/mod.rs @@ -36,7 +36,6 @@ use crate::{ on_log_event::LogEventCallbackSync, tracing::api_wrapper::core_types::Role, tracingv2::storage::storage::{Collector, BAML_TRACER}, - type_builder::TypeBuilder, CallCtx, FunctionResult, InnerTraceStats, RuntimeContext, RuntimeContextManager, TestResponse, TraceStats, }; diff --git a/engine/baml-runtime/src/type_builder/mod.rs b/engine/baml-runtime/src/type_builder/mod.rs index b7025759a3..747251c5d4 100644 --- a/engine/baml-runtime/src/type_builder/mod.rs +++ b/engine/baml-runtime/src/type_builder/mod.rs @@ -1,1229 +1,126 @@ -use std::{ - fmt, - ops::Deref, - sync::{Arc, Mutex}, -}; +use std::sync::{Arc, Mutex}; -use baml_types::{BamlValue, EvaluationContext, TypeIR}; -use indexmap::{IndexMap, IndexSet}; -use internal_baml_core::{ - internal_baml_parser_database::ParserDatabase, ir::repr::TypeBuilderEntry, +use baml_type_builder::{ + ClassPropertyBuilder, EnumBuilder as EnumBuilderTrait, EnumValueBuilder, Meta, }; +use baml_types::BamlValue; +use indexmap::IndexMap; use crate::{ - runtime::InternalBamlRuntime, runtime_context::{PropertyAttributes, RuntimeClassOverride, RuntimeEnumOverride}, + InternalBamlRuntime, }; -type MetaData = Arc>>; - -trait Meta { - fn meta(&self) -> MetaData; -} - -pub trait WithMeta { - fn with_meta(&self, key: &str, value: BamlValue) -> &Self; - fn get_meta(&self, key: &str) -> Option; -} - -macro_rules! impl_meta { - ($type:ty) => { - impl Meta for $type { - fn meta(&self) -> MetaData { - self.meta.clone() - } - } - }; -} - -impl WithMeta for T -where - T: Meta, -{ - fn with_meta(&self, key: &str, value: BamlValue) -> &T { - let meta = self.meta(); - let mut meta = meta.lock().unwrap(); - meta.insert(key.to_string(), value); - self - } - - fn get_meta(&self, key: &str) -> Option { - let meta = self.meta(); - let meta = meta.lock().unwrap(); - meta.get(key).cloned() - } -} +// Re-export types for external use +pub use crate::runtime::runtime_interface::TypeBuilder; +pub use baml_type_builder::ClassBuilder; -impl From<&Arc>> for PropertyAttributes { - fn from(value: &Arc>) -> Self { - let value = value.lock().unwrap(); - let meta = value.meta(); - let meta = meta.lock().unwrap(); - let properties = meta.clone(); - let alias = properties.get("alias").cloned(); - let skip = properties.get("skip").and_then(|v| v.as_bool()); +// Conversion impl for ClassPropertyBuilder and EnumValueBuilder +impl PropertyAttributes { + fn from_class_property_builder(value: &ClassPropertyBuilder) -> Self { + let alias = value.alias().unwrap_or_default(); + let description = value.description().unwrap_or_default(); Self { alias, - skip, - meta: properties, + description, constraints: Vec::new(), streaming_behavior: Default::default(), } } -} - -#[derive(Debug, Clone)] -pub struct ClassBuilder { - pub name: String, - properties: Arc>>>>, - meta: MetaData, -} -impl_meta!(ClassBuilder); - -#[derive(Debug, Clone)] -pub struct ClassPropertyBuilder { - r#type: Arc>>, - meta: MetaData, -} -impl_meta!(ClassPropertyBuilder); - -impl ClassPropertyBuilder { - pub fn set_type(&self, r#type: TypeIR) -> &Self { - *self.r#type.lock().unwrap() = Some(r#type); - self - } - pub fn r#type(&self) -> Option { - self.r#type.lock().unwrap().clone() - } -} + fn from_enum_value_builder(value: &EnumValueBuilder) -> Self { + let alias = value.alias().unwrap_or_default(); + let description = value.description().unwrap_or_default(); -impl ClassBuilder { - pub fn new(name: String) -> Self { Self { - name, - properties: Default::default(), - meta: Arc::new(Mutex::new(Default::default())), - } - } - - // TODO: Figure out captured lifetime issue and return Iterator. - // Iterator that holds mutex lock seems tricky. - pub fn list_properties_key_value(&self) -> Vec<(String, ClassPropertyBuilder)> { - self.properties - .lock() - .unwrap() - .iter() - .map(|(name, prop)| (name.clone(), prop.lock().unwrap().deref().to_owned())) - .collect() - } - - // TODO: Unify function above and this one (split because of CFFI). - pub fn list_properties(&self) -> Vec { - let properties = self.properties.lock().unwrap(); - properties.keys().cloned().collect() - } - - pub fn maybe_get_property(&self, name: &str) -> Option>> { - let properties = self.properties.lock().unwrap(); - properties.get(name).cloned() - } - - pub fn upsert_property(&self, name: &str) -> Arc> { - let mut properties = self.properties.lock().unwrap(); - Arc::clone(properties.entry(name.to_string()).or_insert_with(|| { - Arc::new(Mutex::new(ClassPropertyBuilder { - r#type: Default::default(), - meta: Default::default(), - })) - })) - } - - pub fn remove_property(&self, name: &str) { - let mut properties = self.properties.lock().unwrap(); - properties.shift_remove(name); - } - - pub fn reset(&self) { - self.properties.lock().unwrap().clear(); - } -} - -#[derive(Debug, Clone)] -pub struct EnumBuilder { - pub name: String, - values: Arc>>>>, - meta: MetaData, -} -impl_meta!(EnumBuilder); - -#[derive(Debug, Clone)] -pub struct EnumValueBuilder { - meta: MetaData, -} -impl_meta!(EnumValueBuilder); - -impl EnumBuilder { - pub fn new(name: String) -> Self { - Self { - name, - values: Default::default(), - meta: Arc::new(Mutex::new(Default::default())), - } - } - - pub fn maybe_get_value(&self, name: &str) -> Option>> { - let values = self.values.lock().unwrap(); - values.get(name).cloned() - } - - pub fn upsert_value(&self, name: &str) -> Arc> { - let mut values = self.values.lock().unwrap(); - Arc::clone(values.entry(name.to_string()).or_insert_with(|| { - Arc::new(Mutex::new(EnumValueBuilder { - meta: Default::default(), - })) - })) - } - - pub fn list_values(&self) -> Vec { - let values = self.values.lock().unwrap(); - values.keys().cloned().collect() - } -} - -// displays a class property along with its current state and metadata -// the format shows two key pieces of information: -// 1. the property name as defined in the class -// 2. any metadata attached to the property in parentheses -// -// metadata is shown in key=value format, with values formatted according to their type -// multiple metadata entries are separated by commas for readability -// -// examples of the output format: -// name string (alias='username', description='full name') -// - shows a property with both alias and description metadata -// age unset -// - shows a property without a defined type or metadata -// email string (required=true, format='email') -// - shows a property with multiple metadata values of different types -impl fmt::Display for ClassPropertyBuilder { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let meta = self.meta.lock().unwrap(); - let type_str = self - .r#type - .lock() - .unwrap() - .as_ref() - .map_or("(unknown-type)".to_string(), |t| format!("{}", t.clone())); - - write!(f, "{type_str}")?; - - if !meta.is_empty() { - write!(f, " (")?; - for (i, (key, value)) in meta.iter().enumerate() { - if i > 0 { - write!(f, ", ")?; - } - write!(f, "{key}={value}")?; - } - write!(f, ")")?; - } - Ok(()) - } -} - -// displays an enum value and its associated metadata -// the format focuses on clarity and completeness: -// 1. the enum value name in uppercase (following enum conventions) -// 2. any metadata in parentheses, showing all attached information -// -// metadata is displayed in a consistent key=value format: -// - each piece of metadata is separated by commas -// - values are formatted based on their type (quotes for strings, etc.) -// - all metadata is shown, not just common fields like alias -// -// examples of the output format: -// ACTIVE (alias='active', priority=1, enabled=true) -// - shows an enum value with multiple metadata types -// PENDING -// - shows a simple enum value with no metadata -// INACTIVE (description='not currently in use', status=null) -// - shows how null values and longer descriptions are formatted -impl fmt::Display for EnumValueBuilder { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let meta = self.meta.lock().unwrap(); - - if !meta.is_empty() { - write!(f, " (")?; - for (i, (key, value)) in meta.iter().enumerate() { - if i > 0 { - write!(f, ", ")?; - } - write!(f, "{key}={value}")?; - } - write!(f, ")")?; - } - Ok(()) - } -} - -// displays a complete class definition with all its properties -// the format provides a clear hierarchical structure: -// 1. class name followed by an opening brace -// 2. indented list of properties, each on its own line -// 3. closing brace aligned with the class name -// -// properties are displayed with consistent indentation and formatting: -// - each property starts on a new line with proper indentation -// - properties are separated by commas for valid syntax -// - the last property doesn't have a trailing comma -// -// example of the complete format: -// User { -// name string (alias='username', description='user\'s full name'), -// age int -// email string -// status unset -// } -impl fmt::Display for ClassBuilder { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let properties = self.properties.lock().unwrap(); - write!(f, "{{")?; - if !properties.is_empty() { - for (i, (name, prop)) in properties.iter().enumerate() { - if i > 0 { - write!(f, ",")?; - } - write!(f, "\n {} {}", name, prop.lock().unwrap())?; - } - write!(f, "\n ")?; - } - write!(f, "}}") - } -} - -// displays a complete enum definition with all its values -// the format creates a clear and readable structure: -// 1. enum name followed by an opening brace -// 2. indented list of enum values, each on its own line -// 3. closing brace aligned with the enum name -// -// values are displayed with consistent formatting: -// - each value starts on a new line with proper indentation -// - values are separated by commas for valid syntax -// - metadata is shown in parentheses when present -// - empty enums are shown with empty braces -// -// example of the complete format: -// Status { -// ACTIVE (alias='active', weight=1.0), -// PENDING (description='awaiting processing'), -// INACTIVE (enabled=false), -// ARCHIVED -// } -impl fmt::Display for EnumBuilder { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let values = self.values.lock().unwrap(); - write!(f, "{{")?; - if !values.is_empty() { - for (i, (name, value)) in values.iter().enumerate() { - if i > 0 { - write!(f, ",")?; - } - write!(f, "\n {}{}", name, value.lock().unwrap())?; - } - write!(f, "\n ")?; - } - write!(f, "}}") - } -} - -// displays the complete type builder state in a clear, hierarchical format -// this is the top-level representation that shows all defined types -// -// -// 1. starts with "TypeBuilder(" to identify the structure -// 2. contains two main sections: Classes and Enums -// 3. each section is properly indented and bracketed -// 4. empty sections are omitted for conciseness -// -// the structure maintains consistent formatting: -// - each class and enum starts on a new line -// - proper indentation shows the hierarchy -// - commas separate multiple items -// - empty classes/enums are shown with empty braces -// -// example of the complete format: -// TypeBuilder( -// Classes: [ -// User { -// name string (alias='username'), -// email string (required=true) -// }, -// Address { } -// ], -// Enums: [ -// Status { -// ACTIVE (alias='active'), -// PENDING, -// INACTIVE (enabled=false) -// } -// ] -// ) -// -// this format makes it easy to: -// - understand the overall structure of defined types -// - see relationships between classes and their properties -// - identify enum values and their metadata -// - spot any missing or incomplete definitions -impl fmt::Display for TypeBuilder { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let classes = self.classes.lock().unwrap(); - let enums = self.enums.lock().unwrap(); - let type_aliases = self.type_aliases.lock().unwrap(); - let recursive_type_aliases = self.recursive_type_aliases.lock().unwrap(); - - write!(f, "TypeBuilder(")?; - - if !classes.is_empty() { - write!(f, "\n Classes: [")?; - for (i, (name, cls)) in classes.iter().enumerate() { - if i > 0 { - write!(f, ",")?; - } - write!(f, "\n {} {}", name, cls.lock().unwrap())?; - } - write!(f, "\n ]")?; - } - - if !type_aliases.is_empty() { - write!(f, "\n type_aliases: ")?; - - match self.type_aliases.lock() { - Ok(type_aliases) => { - let keys: Vec<_> = type_aliases.keys().collect(); - writeln!(f, "{keys:?}")? - } - Err(_) => writeln!(f, "Cannot acquire lock,")?, - } - } - - if !recursive_type_aliases.is_empty() { - write!(f, "\n recursive_type_aliases: ")?; - - match self.recursive_type_aliases.lock() { - Ok(recursive_type_aliases) => { - let keys: Vec<_> = recursive_type_aliases.iter().map(|v| v.keys()).collect(); - writeln!(f, "{keys:?}")? - } - Err(_) => writeln!(f, "Cannot acquire lock,")?, - } - } - - if !enums.is_empty() { - if !classes.is_empty() { - write!(f, ",")?; - } - write!(f, "\n Enums: [")?; - for (i, (name, e)) in enums.iter().enumerate() { - if i > 0 { - write!(f, ",")?; - } - write!(f, "\n {} {}", name, e.lock().unwrap())?; - } - write!(f, "\n ]")?; - } - - write!(f, "\n)") - } -} - -pub struct TypeAliasBuilder { - target: Arc>>, - meta: MetaData, -} -impl_meta!(TypeAliasBuilder); - -impl TypeAliasBuilder { - pub fn new() -> Self { - Self { - target: Default::default(), - meta: Arc::new(Mutex::new(Default::default())), - } - } - - pub fn target(&self, target: TypeIR) -> &Self { - *self.target.lock().unwrap() = Some(target); - self - } -} - -impl Default for TypeAliasBuilder { - fn default() -> Self { - Self::new() - } -} - -impl std::fmt::Debug for TypeBuilder { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - // Start the debug printout with the struct name - writeln!(f, "TypeBuilder {{")?; - - // Safely attempt to acquire the lock and print classes - write!(f, " classes: ")?; - match self.classes.lock() { - Ok(classes) => { - // We iterate through the keys only to avoid deadlocks and because we might not be able to print the values - // safely without deep control over locking mechanisms - let keys: Vec<_> = classes.keys().collect(); - writeln!(f, "{keys:?},")? - } - Err(_) => writeln!(f, "Cannot acquire lock,")?, - } - - // Safely attempt to acquire the lock and print enums - write!(f, " enums: ")?; - match self.enums.lock() { - Ok(enums) => { - // Similarly, print only the keys - let keys: Vec<_> = enums.keys().collect(); - writeln!(f, "{keys:?}")? - } - Err(_) => writeln!(f, "Cannot acquire lock,")?, + alias, + description, + constraints: Vec::new(), + streaming_behavior: Default::default(), } - - // Close the struct printout - write!(f, "}}") } } -#[derive(Clone)] -pub struct TypeBuilder { - classes: Arc>>>>, - enums: Arc>>>>, - type_aliases: Arc>>>>, - recursive_type_aliases: Arc>>>, - recursive_classes: Arc>>>, -} - -impl Default for TypeBuilder { - fn default() -> Self { - Self::new() - } -} - -impl TypeBuilder { - pub fn new() -> Self { - Self { - classes: Default::default(), - enums: Default::default(), - type_aliases: Default::default(), - recursive_type_aliases: Default::default(), - recursive_classes: Default::default(), - } - } - - pub fn reset(&self) { - self.classes.lock().unwrap().clear(); - self.enums.lock().unwrap().clear(); - self.type_aliases.lock().unwrap().clear(); - self.recursive_type_aliases.lock().unwrap().clear(); - self.recursive_classes.lock().unwrap().clear(); - } - - pub fn upsert_class(&self, name: &str) -> Arc> { - Arc::clone( - self.classes - .lock() - .unwrap() - .entry(name.to_string()) - .or_insert_with(|| Arc::new(Mutex::new(ClassBuilder::new(name.to_string())))), - ) - } - - pub fn maybe_get_class(&self, name: &str) -> Option>> { - self.classes.lock().unwrap().get(name).cloned() - } - - pub fn upsert_enum(&self, name: &str) -> Arc> { - Arc::clone( - self.enums - .lock() - .unwrap() - .entry(name.to_string()) - .or_insert_with(|| Arc::new(Mutex::new(EnumBuilder::new(name.to_string())))), - ) - } - - pub fn list_enums(&self) -> Vec { - self.enums.lock().unwrap().keys().cloned().collect() - } - - pub fn list_classes(&self) -> Vec { - self.classes.lock().unwrap().keys().cloned().collect() - } - - pub fn maybe_get_enum(&self, name: &str) -> Option>> { - self.enums.lock().unwrap().get(name).cloned() - } - - pub fn upsert_type_alias(&self, name: &str) -> Arc> { - Arc::clone( - self.type_aliases - .lock() - .unwrap() - .entry(name.to_string()) - .or_insert_with(|| Arc::new(Mutex::new(TypeAliasBuilder::new()))), - ) - } - - pub fn maybe_get_type_alias(&self, name: &str) -> Option>> { - self.type_aliases.lock().unwrap().get(name).cloned() - } - - pub fn recursive_type_aliases(&self) -> Arc>>> { - Arc::clone(&self.recursive_type_aliases) - } - - pub fn recursive_classes(&self) -> Arc>>> { - Arc::clone(&self.recursive_classes) - } - - pub fn add_entries(&self, entries: &[TypeBuilderEntry]) { - for entry in entries { - match entry { - TypeBuilderEntry::Class(cls) => { - let mutex = self.upsert_class(&cls.elem.name); - let class_builder = mutex.lock().unwrap(); - for f in &cls.elem.static_fields { - class_builder - .upsert_property(&f.elem.name) - .lock() - .unwrap() - .set_type(f.elem.r#type.elem.to_owned()) - .with_meta( - "alias", - f.attributes.alias().map_or(BamlValue::Null, |v| { - v.resolve(&EvaluationContext::default()) - .map_or(BamlValue::Null, BamlValue::String) - }), - ) - .with_meta( - "description", - f.attributes.description().map_or(BamlValue::Null, |v| { - v.resolve(&EvaluationContext::default()) - .map_or(BamlValue::Null, BamlValue::String) - }), - ); - } - } - - TypeBuilderEntry::Enum(enm) => { - let mutex = self.upsert_enum(&enm.elem.name); - let enum_builder = mutex.lock().unwrap(); - for (variant, _) in &enm.elem.values { - enum_builder - .upsert_value(&variant.elem.0) - .lock() - .unwrap() - .with_meta( - "alias", - variant.attributes.alias().map_or(BamlValue::Null, |v| { - v.resolve(&EvaluationContext::default()) - .map_or(BamlValue::Null, BamlValue::String) - }), - ) - .with_meta( - "description", - variant - .attributes - .description() - .map_or(BamlValue::Null, |v| { - v.resolve(&EvaluationContext::default()) - .map_or(BamlValue::Null, BamlValue::String) - }), - ) - .with_meta( - "skip", - if variant.attributes.skip() { - BamlValue::Bool(true) - } else { - BamlValue::Bool(false) - }, - ); +// Helper function to convert core TypeBuilder to runtime overrides +pub fn to_overrides( + type_builder: &crate::runtime::runtime_interface::TypeBuilder, +) -> ( + IndexMap, + IndexMap, + IndexMap, + Vec>, + Vec>, +) { + log::debug!("Converting types to overrides"); + let cls = type_builder + .list_classes() + .into_iter() + .filter_map(|cls| { + log::debug!("Converting class: {}", cls.class_name); + let mut overrides = RuntimeClassOverride { + alias: None, + new_fields: Default::default(), + update_fields: Default::default(), + }; + + cls.list_properties() + .map(|properties| { + for property in properties { + let name = property.property_name.clone(); + let attrs = PropertyAttributes::from_class_property_builder(&property); + if property + .is_from_ast() + .expect("Should be able to check if property is from ast") + { + overrides.update_fields.insert(name, attrs); + } else { + overrides + .new_fields + .insert(name, (property.type_().unwrap(), attrs)); + } } - } - - TypeBuilderEntry::TypeAlias(alias) => { - let mutex = self.upsert_type_alias(&alias.elem.name); - let alias_builder = mutex.lock().unwrap(); - alias_builder.target(alias.elem.r#type.elem.to_owned()); - } - } - } - } - - /// Internal API of `TypeBuilder::add_baml`. - /// - /// Python, TS and Ruby wrappers will call this function when the user runs - /// `type_builder.add_baml("BAML CODE")` - pub fn add_baml(&self, baml: &str, rt: &InternalBamlRuntime) -> anyhow::Result<()> { - use internal_baml_core::{ - internal_baml_ast::parse_type_builder_contents_from_str, - internal_baml_diagnostics::{Diagnostics, SourceFile}, - ir::repr::IntermediateRepr, - run_validation_pipeline_on_db, validate_type_builder_entries, - }; - - let path = std::path::PathBuf::from("TypeBuilder::add_baml"); - let source = SourceFile::from((path.clone(), baml)); - - let mut diagnostics = Diagnostics::new(path); - diagnostics.set_source(&source); - - let type_builder_entries = parse_type_builder_contents_from_str(baml, &mut diagnostics)?; - - if diagnostics.has_errors() { - anyhow::bail!("{}", diagnostics.to_pretty_string()); - } - - // TODO: A bunch of mem usage here but at least we drop this one at the - // end of the function, unlike scoped DBs for type builders. - let mut scoped_db = rt.db.clone(); - - let local_ast = - validate_type_builder_entries(&mut diagnostics, &scoped_db, &type_builder_entries); - scoped_db.add_ast(local_ast); - - if let Err(d) = scoped_db.validate(&mut diagnostics) { - diagnostics.push(d); - anyhow::bail!("{}", diagnostics.to_pretty_string()); - } - - run_validation_pipeline_on_db(&mut scoped_db, &mut diagnostics); - - if diagnostics.has_errors() { - anyhow::bail!("{}", diagnostics.to_pretty_string()); - } - - let (classes, enums, type_aliases, recursive_classes, recursive_aliases) = - IntermediateRepr::type_builder_entries_from_scoped_db(&scoped_db, &rt.db) - .map_err(|e| anyhow::anyhow!("{:?}", e))?; - - self.add_entries( - &classes - .into_iter() - .map(TypeBuilderEntry::Class) - .chain(enums.into_iter().map(TypeBuilderEntry::Enum)) - .chain(type_aliases.into_iter().map(TypeBuilderEntry::TypeAlias)) - .collect::>(), - ); - - self.recursive_type_aliases() - .lock() - .unwrap() - .extend(recursive_aliases); - - self.recursive_classes() - .lock() - .unwrap() - .extend(recursive_classes); - - Ok(()) - } - - pub fn to_overrides( - &self, - ) -> ( - IndexMap, - IndexMap, - IndexMap, - Vec>, - Vec>, - ) { - log::debug!("Converting types to overrides"); - let cls = self - .classes - .lock() - .unwrap() - .iter() - .map(|(name, cls)| { - log::debug!("Converting class: {name}"); - let mut overrides = RuntimeClassOverride { + (cls.class_name.clone(), overrides) + }) + .ok() + }) + .collect::>(); + + let enm = type_builder + .list_enums() + .into_iter() + .filter_map(|enm: EnumBuilderTrait<_>| { + enm.list_values().ok().map(|values| { + let mut overrides = RuntimeEnumOverride { alias: None, - new_fields: Default::default(), - update_fields: Default::default(), + values: Default::default(), }; - cls.lock() - .unwrap() - .properties - .lock() - .unwrap() - .iter() - .for_each(|(property_name, f)| { - let attrs = PropertyAttributes::from(f); - let t = { - let property = f.lock().unwrap(); - let t = property.r#type.lock().unwrap(); - t.clone() - }; - match t.as_ref() { - Some(r#type) => { - overrides - .new_fields - .insert(property_name.to_string(), (r#type.clone(), attrs)); - } - None => { - overrides - .update_fields - .insert(property_name.to_string(), attrs); - } - } - }); - (name.clone(), overrides) - }) - .collect(); - - let enm = self - .enums - .lock() - .unwrap() - .iter() - .map(|(name, enm)| { - let attributes = PropertyAttributes::from(enm); - let values = enm - .lock() - .unwrap() - .values - .lock() - .unwrap() - .iter() - .map(|(value_name, value)| { - (value_name.clone(), PropertyAttributes::from(value)) - }) - .collect(); - ( - name.clone(), - RuntimeEnumOverride { - values, - alias: attributes.alias, - }, - ) - }) - .collect(); - - let aliases = self - .type_aliases - .lock() - .unwrap() - .iter() - .map(|(name, builder)| { - let mutex = builder.lock().unwrap(); - let target = mutex.target.lock().unwrap(); - // TODO: target.unwrap() might not be guaranteed here. - (name.clone(), target.to_owned().unwrap()) + for value in values { + let value_name = value.value_name.clone(); + let attrs = PropertyAttributes::from_enum_value_builder(&value); + overrides.values.insert(value_name, attrs); + } + (enm.enum_name.clone(), overrides) }) - .collect(); - - log::debug!("Dynamic types: \n {cls:#?} \n Dynamic enums\n {enm:#?} enums"); - - let recursive_aliases = self.recursive_type_aliases.lock().unwrap().clone(); - let recursive_classes = self.recursive_classes.lock().unwrap().clone(); - - (cls, enm, aliases, recursive_classes, recursive_aliases) - } -} - -#[cfg(test)] -mod tests { - use std::collections::HashMap; - - use internal_baml_core::feature_flags::FeatureFlags; - - use super::*; - - #[test] - fn test_type_builder() { - let builder = TypeBuilder::new(); - - // Add a class with properties and metadata - let cls = builder.upsert_class("User"); - { - let cls = cls.lock().unwrap(); - // Add name property with alias and description - cls.upsert_property("name") - .lock() - .unwrap() - .set_type(TypeIR::string()) - .with_meta("alias", BamlValue::String("username".to_string())) - .with_meta( - "description", - BamlValue::String("The user's full name".to_string()), - ); - - // Add age property with description only - cls.upsert_property("age") - .lock() - .unwrap() - .set_type(TypeIR::int()) - .with_meta( - "description", - BamlValue::String("User's age in years".to_string()), - ); - - // Add email property with no metadata - cls.upsert_property("email") - .lock() - .unwrap() - .set_type(TypeIR::string()); - } - - // Add an enum with values and metadata - let enm = builder.upsert_enum("Status"); - { - let enm = enm.lock().unwrap(); - // Add ACTIVE value with alias and description - enm.upsert_value("ACTIVE") - .lock() - .unwrap() - .with_meta("alias", BamlValue::String("active".to_string())) - .with_meta( - "description", - BamlValue::String("User is active".to_string()), - ); - - // Add INACTIVE value with alias only - enm.upsert_value("INACTIVE") - .lock() - .unwrap() - .with_meta("alias", BamlValue::String("inactive".to_string())); - - // Add PENDING value with no metadata - enm.upsert_value("PENDING"); - } - - // Convert to string and verify the format - let output = builder.to_string(); - assert_eq!( - output, - r#"TypeBuilder( - Classes: [ - User { - name string (alias=String("username"), description=String("The user's full name")), - age int (description=String("User's age in years")), - email string - } - ], - Enums: [ - Status { - ACTIVE (alias=String("active"), description=String("User is active")), - INACTIVE (alias=String("inactive")), - PENDING - } - ] -)"# - ); - } - - // this test is to ensure that the string representation is correct - // and that the to_overrides method is working as expected - - #[test] - fn test_type_builder_advanced() { - let builder = TypeBuilder::new(); - - // 1. Complex class with nested types and all field types - let address = builder.upsert_class("Address"); - { - let address = address.lock().unwrap(); - // String with all metadata - address - .upsert_property("street") - .lock() - .unwrap() - .set_type(TypeIR::string()) - .with_meta("alias", BamlValue::String("streetAddress".to_string())) - .with_meta( - "description", - BamlValue::String("Street address including number".to_string()), - ); - - // Optional int with description - address - .upsert_property("unit") - .lock() - .unwrap() - .set_type(TypeIR::int().as_optional()) - .with_meta( - "description", - BamlValue::String("Apartment/unit number if applicable".to_string()), - ); - - // List of strings with alias - address - .upsert_property("tags") - .lock() - .unwrap() - .set_type(TypeIR::string().as_list()) - .with_meta("alias", BamlValue::String("labels".to_string())); - - // Boolean with no metadata - address - .upsert_property("is_primary") - .lock() - .unwrap() - .set_type(TypeIR::bool()); - - // Float with skip metadata - address - .upsert_property("coordinates") - .lock() - .unwrap() - .set_type(TypeIR::float()) - .with_meta("skip", BamlValue::Bool(true)); - } - - // 2. Empty class - builder.upsert_class("EmptyClass"); - - // 3. Complex enum with various metadata combinations - let priority = builder.upsert_enum("Priority"); - { - let priority = priority.lock().unwrap(); - // All metadata - priority - .upsert_value("HIGH") - .lock() - .unwrap() - .with_meta("alias", BamlValue::String("urgent".to_string())) - .with_meta( - "description", - BamlValue::String("Needs immediate attention".to_string()), - ) - .with_meta("skip", BamlValue::Bool(false)); - - // Only description - priority.upsert_value("MEDIUM").lock().unwrap().with_meta( - "description", - BamlValue::String("Standard priority".to_string()), - ); - - // Only skip - priority - .upsert_value("LOW") - .lock() - .unwrap() - .with_meta("skip", BamlValue::Bool(true)); - - // No metadata - priority.upsert_value("NONE"); - } - - // 4. Empty enum - builder.upsert_enum("EmptyEnum"); - - // Test string representation - let output = builder.to_string(); - assert_eq!( - output, - r#"TypeBuilder( - Classes: [ - Address { - street string (alias=String("streetAddress"), description=String("Street address including number")), - unit (int | null) (description=String("Apartment/unit number if applicable")), - tags string[] (alias=String("labels")), - is_primary bool, - coordinates float (skip=Bool(true)) - }, - EmptyClass {} - ], - Enums: [ - Priority { - HIGH (alias=String("urgent"), description=String("Needs immediate attention"), skip=Bool(false)), - MEDIUM (description=String("Standard priority")), - LOW (skip=Bool(true)), - NONE - }, - EmptyEnum {} - ] -)"# - ); - - // Test to_overrides() - let (classes, enums, aliases, recursive_classes, recursive_aliases) = - builder.to_overrides(); - - // Verify class overrides - assert_eq!(classes.len(), 2); - let address_override = classes.get("Address").unwrap(); - assert_eq!(address_override.new_fields.len(), 5); // All fields are new - assert!(address_override - .new_fields - .get("street") - .unwrap() - .1 - .alias - .is_some()); - assert!(address_override - .new_fields - .get("coordinates") - .unwrap() - .1 - .skip - .unwrap()); - - // Verify enum overrides - assert_eq!(enums.len(), 2); - let priority_override = enums.get("Priority").unwrap(); - assert_eq!(priority_override.values.len(), 4); - assert!(priority_override - .values - .get("HIGH") - .unwrap() - .alias - .is_some()); - assert!(priority_override.values.get("LOW").unwrap().skip.unwrap()); - } - - #[test] - fn test_recursive_property() { - let builder = TypeBuilder::new(); - - // Create a 'Node' class where the 'child' property recursively refers to 'Node' - let node = builder.upsert_class("Node"); - { - let node = node.lock().unwrap(); - node.upsert_property("child") - .lock() - .unwrap() - .set_type(TypeIR::class("Node")) - .with_meta( - "description", - BamlValue::String("recursive self reference".to_string()), - ); - } - - // Optionally, print the builder's string representation. - let output = builder.to_string(); - // println!("{}", output); - - // Verify that the output string contains the recursive property information. - assert!( - output.contains( - r#"TypeBuilder( - Classes: [ - Node { - child Node (description=String("recursive self reference")) - } - ] -)"# - ), - "Output did not contain the expected recursive property format: {output}", - ); - - // Verify via to_overrides() that the recursive field is set correctly. - let (class_overrides, _enum_overrides, _aliases, _recursive_classes, _recursive_aliases) = - builder.to_overrides(); - let node_override = class_overrides - .get("Node") - .expect("Expected override for Node"); - let (child_field_type, _child_attrs) = node_override - .new_fields - .get("child") - .expect("Expected a 'child' property in Node"); - - // The child's field type should exactly be a recursive reference to 'Node' - assert_eq!( - child_field_type, - &TypeIR::class("Node"), - "The 'child' field is not correctly set as a recursive reference to 'Node'" - ); - } - - use crate::BamlRuntime; - - #[test] - fn test_type_builder_recursive_2() -> anyhow::Result<()> { - let builder = TypeBuilder::new(); - - let mut files = HashMap::new(); - files.insert( - "main.baml", - r##" - - class Output { - hello string - @@dynamic - } - - - client GPT4Turbo { - provider baml-openai-chat - options { - model gpt-4-1106-preview - api_key env.OPENAI_API_KEY - } - } - - - function Extract(input: string) -> Output { - client GPT4Turbo - prompt #" - - {{ ctx.output_format }} - "# - } - - test Test { - functions [Extract] - args { - input "hi" - } - } - "##, - ); - - let function_name = "Extract"; - let test_name = "Test"; - - let runtime = BamlRuntime::from_file_content( - "baml_src", - &files, - [("OPENAI_API_KEY", "OPENAI_API_KEY")].into(), - FeatureFlags::new(), - ) - .unwrap(); - - let baml = r##" - - class Two { - three string - dynamicField Output - } - - dynamic class Output { - two Node - three string - - } - - class C { - hello string - } - class D { - hello string - } - class Node { - child C | D | Node - } - "##; - - builder.add_baml(baml, runtime.inner.as_ref())?; - println!("{builder}"); - builder.to_overrides(); - Ok(()) - } + }) + .collect(); + + let alias = type_builder + .recursive_type_aliases() + .lock() + .unwrap() + .iter() + .flat_map(|map| map.iter()) + .map(|(name, ty)| (name.clone(), ty.clone())) + .collect(); + + let recursive_classes = type_builder.recursive_classes().lock().unwrap().clone(); + let recursive_type_aliases = type_builder + .recursive_type_aliases() + .lock() + .unwrap() + .clone(); + + (cls, enm, alias, recursive_classes, recursive_type_aliases) } diff --git a/engine/baml-runtime/src/types/context_manager.rs b/engine/baml-runtime/src/types/context_manager.rs index 5faf7aa202..1aff26d81a 100644 --- a/engine/baml-runtime/src/types/context_manager.rs +++ b/engine/baml-runtime/src/types/context_manager.rs @@ -10,8 +10,8 @@ use baml_types::{tracing::events::TraceEvent, BamlValue}; use super::runtime_context::BamlSrcReader; use crate::{ - client_registry::ClientRegistry, tracing::BamlTracer, tracingv2::storage::storage::BAML_TRACER, - type_builder::TypeBuilder, CallCtx, RuntimeContext, + client_registry::ClientRegistry, runtime::runtime_interface::TypeBuilder, tracing::BamlTracer, + tracingv2::storage::storage::BAML_TRACER, type_builder, CallCtx, RuntimeContext, }; pub type BamlContext = ( uuid::Uuid, @@ -225,7 +225,7 @@ impl RuntimeContextManager { }; let (cls, enm, als, rec_cls, rec_als) = type_builder - .map(TypeBuilder::to_overrides) + .map(type_builder::to_overrides) .unwrap_or_default(); let mut ctx = RuntimeContext::new( diff --git a/engine/baml-runtime/src/types/runtime_context.rs b/engine/baml-runtime/src/types/runtime_context.rs index 7b6462c308..d338d493ce 100644 --- a/engine/baml-runtime/src/types/runtime_context.rs +++ b/engine/baml-runtime/src/types/runtime_context.rs @@ -18,9 +18,9 @@ pub struct CallCtx { #[derive(Debug)] pub struct PropertyAttributes { - pub(crate) alias: Option, - pub(crate) skip: Option, - pub(crate) meta: IndexMap, + pub(crate) alias: Option, + pub(crate) description: Option, + // pub(crate) skip: Option, pub(crate) constraints: Vec, pub(crate) streaming_behavior: baml_types::type_meta::base::StreamingBehavior, } diff --git a/engine/baml-runtime/src/types/stream.rs b/engine/baml-runtime/src/types/stream.rs index fc0e4dcbb9..57b5e0e610 100644 --- a/engine/baml-runtime/src/types/stream.rs +++ b/engine/baml-runtime/src/types/stream.rs @@ -10,6 +10,7 @@ use internal_baml_core::ir::repr::IntermediateRepr; use serde_json::json; use stream_cancel::Tripwire; +use crate::runtime::runtime_interface::TypeBuilder; use crate::{ client_registry::ClientRegistry, internal::{ @@ -18,7 +19,6 @@ use crate::{ }, tracing::BamlTracer, tracingv2::storage::storage::{Collector, BAML_TRACER}, - type_builder::TypeBuilder, FunctionResult, IntoBamlError, PreparedFunctionArgs, RuntimeContextManager, TripWire, }; diff --git a/engine/generators/languages/python/src/_templates/type_builder.py.j2 b/engine/generators/languages/python/src/_templates/type_builder.py.j2 index 70ec5df4c4..2390b31d36 100644 --- a/engine/generators/languages/python/src/_templates/type_builder.py.j2 +++ b/engine/generators/languages/python/src/_templates/type_builder.py.j2 @@ -7,11 +7,7 @@ from .globals import DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIM class TypeBuilder(type_builder.TypeBuilder): def __init__(self): - super().__init__(classes=set( - [{% for cls in classes %}"{{cls.name}}",{% endfor %}] - ), enums=set( - [{% for enum_ in enums %}"{{enum_.name}}",{% endfor %}] - ), runtime=DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME) + super().__init__(runtime=DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME) # ######################################################################### # Generated enums {{ enums.len() }} diff --git a/engine/generators/languages/python/src/generated_types.rs b/engine/generators/languages/python/src/generated_types.rs index 96eb04459f..20f24b39f2 100644 --- a/engine/generators/languages/python/src/generated_types.rs +++ b/engine/generators/languages/python/src/generated_types.rs @@ -124,11 +124,7 @@ mod type_builder { &self.name } fn type_builder_name(&self) -> String { - format!( - "{}{}", - self.name, - if self.dynamic { "Builder" } else { "Viewer" } - ) + format!("{}{}", self.name, "Builder") } } @@ -143,11 +139,7 @@ mod type_builder { &self.name } fn type_builder_name(&self) -> String { - format!( - "{}{}", - self.name, - if self.dynamic { "Builder" } else { "Viewer" } - ) + format!("{}{}", self.name, "Builder") } } @@ -157,9 +149,8 @@ mod type_builder { /// class {{ class.name }}Ast: /// def __init__(self, tb: type_builder.TypeBuilder): /// _tb = tb._tb # type: ignore (we know how to use this private attribute) - /// self._bldr = _tb.class_("{{ class.name }}") - /// self._properties: typing.Set[str] = set([ {% for field in class.fields %} "{{ field.name }}", {% endfor %} ]) - /// self._props = {{ class.name }}Properties(self._bldr, self._properties) + /// self._bldr = _tb.get_class("{{ class.name }}") + /// self._props = {{ class.name }}Properties(self._bldr) /// /// def type(self) -> baml_py.FieldType: /// return self._bldr.field() @@ -175,9 +166,7 @@ mod type_builder { /// /// {% if class.dynamic %} /// def add_property(self, name: str, type: baml_py.FieldType) -> {{ class.class_property_type() }}: - /// if name in self._properties: - /// raise ValueError(f"Property {name} already exists.") - /// return self._bldr.property(name).type(type) + /// return self._bldr.add_property(name, type) /// /// def list_properties(self) -> typing.List[typing.Tuple[str, {{ class.class_property_type() }}]]: /// return self._bldr.list_properties() @@ -195,26 +184,23 @@ mod type_builder { /// /// /// class {{ class.name }}Properties: - /// def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + /// def __init__(self, bldr: baml_py.ClassBuilder): /// self.__bldr = bldr - /// self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 /// /// {% if class.dynamic %} /// def __getattr__(self, name: str) -> {{ class.class_property_type() }}: - /// if name not in self.__properties: - /// raise AttributeError(f"Property {name} not found.") - /// return self.__bldr.property(name) + /// return self.__bldr.get_property(name) /// /// {% for field in class.fields %} /// @property /// def {{ field.name }}(self) -> {{ class.class_property_type() }}: - /// return self.__bldr.property("{{ field.name }}") + /// return self.__bldr.get_property("{{ field.name }}") /// {% endfor %} /// {% else %} /// {% for field in class.fields %} /// @property /// def {{ field.name }}(self) -> {{ class.class_property_type() }}: - /// return {{ class.class_property_type() }}(self.__bldr.property("{{ field.name }}")) + /// return {{ class.class_property_type() }}(self.__bldr.get_property("{{ field.name }}")) /// {% endfor %} /// {% endif %} /// @@ -235,19 +221,11 @@ mod type_builder { } fn type_builder_object_name(&self) -> String { - format!("{}{}", self.name, self.type_builder_object_type()) + format!("{}Builder", self.name) } fn class_property_type(&self) -> String { - format!( - "{}.ClassProperty{}", - if self.dynamic { - "baml_py" - } else { - "type_builder" - }, - self.type_builder_object_type() - ) + format!("{}.ClassProperty{}", "type_builder", "Builder") } pub fn to_type_builder_object(&'a self) -> TypeBuilderClassObject<'a> { @@ -261,9 +239,8 @@ mod type_builder { /// class {{ enum_.name }}Ast: /// def __init__(self, tb: type_builder.TypeBuilder): /// _tb = tb._tb # type: ignore (we know how to use this private attribute) - /// self._bldr = _tb.enum("{{ enum_.name }}") - /// self._values: typing.Set[str] = set([ {% for (value, _) in enum_.values %} "{{ value }}", {% endfor %} ]) - /// self._vals = {{ enum_.name }}Values(self._bldr, self._values) + /// self._bldr = _tb.get_enum("{{ enum_.name }}") + /// self._vals = {{ enum_.name }}Values(self._bldr) /// /// def type(self) -> baml_py.FieldType: /// return self._bldr.field() @@ -279,38 +256,33 @@ mod type_builder { /// /// {% if enum_.dynamic %} /// def list_values(self) -> typing.List[typing.Tuple[str, {{ enum_.enum_value_type() }}]]: - /// return [(name, self._bldr.value(name)) for name in self._values] + /// return self._bldr.list_values() /// /// def add_value(self, name: str) -> {{ enum_.enum_value_type() }}: - /// if name in self._values: - /// raise ValueError(f"Value {name} already exists.") - /// return self._bldr.value(name) + /// return self._bldr.add_value(name) /// {% else %} /// def list_values(self) -> typing.List[typing.Tuple[str, {{ enum_.enum_value_type() }}]]: /// return [(name, {{ enum_.enum_value_type() }}(self._bldr.value(name))) for name in self._values] /// {% endif %} /// /// class {{ enum_.name }}Values: - /// def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + /// def __init__(self, enum_bldr: baml_py.EnumBuilder): /// self.__bldr = enum_bldr - /// self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 /// /// {% if enum_.dynamic %} /// def __getattr__(self, name: str) -> {{ enum_.enum_value_type() }}: - /// if name not in self.__values: - /// raise AttributeError(f"Value {name} not found.") - /// return self.__bldr.value(name) + /// return self.__bldr.get_value(name) /// /// {% for (value, _) in enum_.values %} /// @property /// def {{ value }}(self) -> {{ enum_.enum_value_type() }}: - /// return self.__bldr.value("{{ value }}") + /// return self.__bldr.get_value("{{ value }}") /// {% endfor %} /// {% else %} /// {% for (value, _) in enum_.values %} /// @property /// def {{ value }}(self) -> {{ enum_.enum_value_type() }}: - /// return {{ enum_.enum_value_type() }}(self.__bldr.value("{{ value }}")) + /// return {{ enum_.enum_value_type() }}(self.__bldr.get_value("{{ value }}")) /// {% endfor %} /// {% endif %} /// @@ -331,19 +303,11 @@ mod type_builder { } fn type_builder_object_name(&self) -> String { - format!("{}{}", self.name, self.type_builder_object_type()) + format!("{}Builder", self.name) } fn enum_value_type(&self) -> String { - format!( - "{}.EnumValue{}", - if self.dynamic { - "baml_py" - } else { - "type_builder" - }, - self.type_builder_object_type() - ) + format!("type_builder.EnumValueBuilder") } pub fn to_type_builder_object(&'a self) -> TypeBuilderEnumObject<'a> { diff --git a/engine/generators/languages/typescript/src/_templates/type_builder.ts.j2 b/engine/generators/languages/typescript/src/_templates/type_builder.ts.j2 index 2ab80959e9..67a54ec88c 100644 --- a/engine/generators/languages/typescript/src/_templates/type_builder.ts.j2 +++ b/engine/generators/languages/typescript/src/_templates/type_builder.ts.j2 @@ -1,52 +1,56 @@ import { FieldType } from '@boundaryml/baml/native' -import { TypeBuilder as _TypeBuilder, EnumBuilder, EnumViewer, ClassBuilder, ClassViewer } from '@boundaryml/baml/type_builder' +import { TypeBuilder as _TypeBuilder, EnumBuilder, ClassBuilder } from '@boundaryml/baml/type_builder' import { DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME } from "./globals" export { FieldType, EnumBuilder, ClassBuilder } +type ClassProperties = { + {% for cls in classes %} + "{{cls.name}}": [{% for field in cls.fields %}"{{field.name}}", {% endfor %}], + {% endfor %} +} +type EnumValues = { + {% for e in enums %} + "{{e.name}}": [{% for (value, _) in e.values %}"{{value}}", {% endfor %}], + {% endfor %} +} +type ClassNames = keyof ClassProperties; +type EnumNames = keyof EnumValues; + +type _ClassBuilder = ClassBuilder; +type _EnumBuilder = EnumBuilder; + +function _getEnum(tb: _TypeBuilder, name: Name): _EnumBuilder { + return tb.getEnum(name); +} + +function _getClass(tb: _TypeBuilder, name: Name): _ClassBuilder { + return tb.getClass(name); +} + export default class TypeBuilder { private tb: _TypeBuilder; {% for cls in classes %} - {{cls.name}}: {% if cls.dynamic %}ClassBuilder{% else %}ClassViewer{% endif %}<'{{cls.name}}' - {%- for field in cls.fields %}{% if loop.first %}, {%endif%}"{{field.name}}"{% if !loop.last %} | {% endif %}{% endfor -%} - >; + {{cls.name}}: _ClassBuilder<'{{cls.name}}', {{ cls.dynamic }}>; {% endfor %} {% for e in enums %} - {{e.name}}: {% if e.dynamic %}EnumBuilder{% else %}EnumViewer{% endif %}<'{{e.name}}'{%- for (value, _) in e.values %}{% if loop.first %}, {%endif%}"{{value}}"{% if !loop.last %} | {% endif %}{% endfor -%}>; + {{e.name}}: _EnumBuilder<'{{e.name}}', {{ e.dynamic }}>; {% endfor %} constructor() { this.tb = new _TypeBuilder({ - classes: new Set([ - {% for cls in classes %}"{{cls.name}}",{% endfor %} - ]), - enums: new Set([ - {% for e in enums %}"{{e.name}}",{% endfor %} - ]), runtime: DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME }); {% for cls in classes %} - this.{{cls.name}} = this.tb.{% if cls.dynamic %}classBuilder{% else %}classViewer{% endif %}("{{cls.name}}", [ - {% for field in cls.fields %}"{{field.name}}",{% endfor %} - ]); + this.{{cls.name}} = _getClass<{{ cls.dynamic }}>(this.tb, "{{cls.name}}"); {% endfor %} {% for e in enums %} - this.{{e.name}} = this.tb.{% if e.dynamic %}enumBuilder{% else %}enumViewer{% endif %}("{{e.name}}", [ - {% for (value, _) in e.values %}"{{value}}",{% endfor %} - ]); + this.{{e.name}} = _getEnum<{{ e.dynamic }}>(this.tb, "{{e.name}}"); {% endfor %} } reset(): void { this.tb.reset(); - // TODO: This should happen in Rust. Problem is, when we construct the - // typebuilder we instantiate class builders once and it seems to make - // a JS copy, bypassing the Rust side? In Python however, every time we - // access a class builder with @property, we get a new instance that - // wraps over the Rust type builder, so we only need to call tb.reset(). - // In JS it's not possible unless we refactor the way class builders are - // accessed. - {% for cls in classes %}{% if cls.dynamic %} this.{{cls.name}}.reset(); {% endif %}{% endfor %} } __tb() { @@ -97,11 +101,11 @@ export default class TypeBuilder { return this.tb.union(types) } - addClass(name: Name): ClassBuilder { + addClass(name: string): ClassBuilder { return this.tb.addClass(name); } - addEnum(name: Name): EnumBuilder { + addEnum(name: string): EnumBuilder { return this.tb.addEnum(name); } diff --git a/engine/language_client_cffi/Cargo.toml b/engine/language_client_cffi/Cargo.toml index 8a749f95d7..667d22b355 100644 --- a/engine/language_client_cffi/Cargo.toml +++ b/engine/language_client_cffi/Cargo.toml @@ -21,6 +21,7 @@ baml-types.workspace = true baml-runtime = { path = "../baml-runtime", default-features = false, features = [ "internal", ] } +baml-type-builder = { path = "../baml-lib/type-builder" } internal-baml-codegen.workspace = true internal-baml-core.workspace = true serde.workspace = true diff --git a/engine/language_client_cffi/cbindgen.toml b/engine/language_client_cffi/cbindgen.toml index 63c3be7200..b07c739eeb 100644 --- a/engine/language_client_cffi/cbindgen.toml +++ b/engine/language_client_cffi/cbindgen.toml @@ -14,6 +14,6 @@ namespaces = ["baml"] [parse] parse_deps = false # include = [] -# exclude = [] +exclude = ["TypeBuilder", "TypeBuilderWrapper", "EnumBuilder", "EnumBuilderWrapper", "EnumValueBuilder", "EnumValueBuilderWrapper", "ClassBuilder", "ClassBuilderWrapper", "ClassPropertyBuilder", "ClassPropertyBuilderWrapper", "RawPtrType"] clean = false extra_bindings = [] diff --git a/engine/language_client_cffi/src/ffi/functions.rs b/engine/language_client_cffi/src/ffi/functions.rs index 27f1582ca3..bccff1f347 100644 --- a/engine/language_client_cffi/src/ffi/functions.rs +++ b/engine/language_client_cffi/src/ffi/functions.rs @@ -79,21 +79,36 @@ fn call_function_from_c_inner( // Ensure that a Tokio runtime is running in your application. let rt = RUNTIME.clone(); rt.spawn(async move { - // Create a future for the call_function - // TODO: There's a race condition bug here. Technically we should COPY the type builder, not just clone it. - let type_builder = type_builder.map(|t| t.type_builder.as_ref().clone()); - let result = runtime - .call_function( - func_name, - &kwargs, - &ctx, - type_builder.as_ref(), - client_registry.as_ref(), - collectors.map(|c| c.iter().map(|c| c.deref().clone()).collect()), - env_vars, - tripwire.clone(), - ) - .await; + let result = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| async { + // TODO: There's a race condition bug here. Technically we should COPY the type builder, not just clone it. + let type_builder = type_builder.map(|t| t.as_ref().clone()); + runtime + .call_function( + func_name, + &kwargs, + &ctx, + type_builder.as_ref(), + client_registry.as_ref(), + collectors.map(|c| c.iter().map(|c| c.deref().clone()).collect()), + env_vars, + tripwire.clone(), + ) + .await + })) { + Ok(future) => future.await, + Err(panic_info) => { + // Handle the panic case - create an error result + let error_msg = if let Some(s) = panic_info.downcast_ref::<&str>() { + format!("Function panicked: {s}") + } else if let Some(s) = panic_info.downcast_ref::() { + format!("Function panicked: {s}") + } else { + "Function panicked with unknown error".to_string() + }; + + (Err(anyhow::anyhow!(error_msg)), Default::default()) + } + }; let (final_result, _) = result; // This drop seems to be required due to timing issues accross ffi-boundaries @@ -162,7 +177,7 @@ fn call_function_parse_from_c_inner( rt.spawn(async move { let result = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| async { // TODO: There's a race condition bug here. Technically we should COPY the type builder, not just clone it. - let type_builder = type_builder.map(|t| t.type_builder.as_ref().clone()); + let type_builder = type_builder.map(|t| t.as_ref().clone()); runtime.parse_llm_response( func_name, text, @@ -245,7 +260,7 @@ fn call_function_stream_from_c_inner( let tripwire = trip_wire::make_trip_wire(id); let ctx = runtime.create_ctx_manager(BamlValue::String("cffi".to_string()), None); // TODO: There's a race condition bug here. Technically we should COPY the type builder, not just clone it. - let type_builder = type_builder.map(|t| t.type_builder.as_ref().clone()); + let type_builder = type_builder.map(|t| t.as_ref().clone()); let mut stream = match runtime.stream_function( func_name, &kwargs, diff --git a/engine/language_client_cffi/src/raw_ptr_wrapper.rs b/engine/language_client_cffi/src/raw_ptr_wrapper.rs index c1c933f2da..c42aa7cd32 100644 --- a/engine/language_client_cffi/src/raw_ptr_wrapper.rs +++ b/engine/language_client_cffi/src/raw_ptr_wrapper.rs @@ -9,6 +9,7 @@ use std::{ use baml_cffi_macros::{define_raw_ptr_types, export_baml_new_fn}; use baml_runtime::{ + runtime::InternalBamlRuntime, tracingv2::storage::storage::{ Collector, FunctionLog, LLMCall, LLMStreamCall, StreamTiming, Timing, Usage, }, @@ -18,15 +19,26 @@ use baml_types::{ tracing::events::{HTTPBody, HTTPRequest, HTTPResponse, SSEEvent}, BamlMedia, TypeIR, }; -use type_builder::objects::{ - ClassBuilder, ClassPropertyBuilder, EnumBuilder, EnumValueBuilder, TypeBuilder, -}; use crate::{ baml::cffi::{self, CffiPointerType}, ctypes::object_response_encode::{BamlObjectResponse, BamlObjectResponseSuccess}, }; +// use baml_type_builder::{ +// ClassBuilder, ClassPropertyBuilder, EnumBuilder, EnumValueBuilder, TypeBuilder, +// }; +/// cbindgen:ignore +type TypeBuilder = baml_type_builder::TypeBuilder; +/// cbindgen:ignore +type EnumBuilder = baml_type_builder::EnumBuilder; +/// cbindgen:ignore +type EnumValueBuilder = baml_type_builder::EnumValueBuilder; +/// cbindgen:ignore +type ClassBuilder = baml_type_builder::ClassBuilder; +/// cbindgen:ignore +type ClassPropertyBuilder = baml_type_builder::ClassPropertyBuilder; + pub struct RawPtrWrapper { inner: Arc, persist: AtomicBool, @@ -187,7 +199,7 @@ impl RawPtrType { #[export_baml_new_fn(ObjectTypeBuilder)] fn new_type_builder() -> Result { - let type_builder = TypeBuilder::default(); + let type_builder = TypeBuilder::new(todo!("Fix this")); Ok(TypeBuilderWrapper::from_object(type_builder)) } } diff --git a/engine/language_client_cffi/src/raw_ptr_wrapper/type_builder.rs b/engine/language_client_cffi/src/raw_ptr_wrapper/type_builder.rs index 4f2697090e..80feec70d1 100644 --- a/engine/language_client_cffi/src/raw_ptr_wrapper/type_builder.rs +++ b/engine/language_client_cffi/src/raw_ptr_wrapper/type_builder.rs @@ -1,12 +1,11 @@ -pub mod objects; - use baml_cffi_macros::export_baml_fn; use baml_types::{ir_type::UnionConstructor, BamlValue, TypeIR}; use super::{BamlObjectResponse, BamlObjectResponseSuccess, CallMethod}; use crate::raw_ptr_wrapper::{ - ClassBuilderWrapper, ClassPropertyBuilderWrapper, EnumBuilderWrapper, EnumValueBuilderWrapper, - TypeBuilderWrapper, TypeWrapper, + ClassBuilder, ClassBuilderWrapper, ClassPropertyBuilder, ClassPropertyBuilderWrapper, + EnumBuilder, EnumBuilderWrapper, EnumValueBuilder, EnumValueBuilderWrapper, TypeBuilderWrapper, + TypeWrapper, }; #[export_baml_fn] @@ -73,69 +72,55 @@ impl TypeBuilderWrapper { } #[export_baml_fn] - fn add_baml(&self, runtime: &baml_runtime::BamlRuntime, baml: &str) -> Result<(), String> { - self.inner - .add_baml(baml, runtime) - .map_err(|e| e.to_string()) + fn add_baml(&self, baml: &str) -> Result<(), String> { + self.inner.add_baml(baml).map_err(|e| e.to_string()) } #[export_baml_fn] - fn add_enum( - &self, - runtime: &baml_runtime::BamlRuntime, - name: &str, - ) -> Result { + fn add_enum(&self, name: &str) -> Result { self.inner - .add_enum(runtime, name) + .add_enum(name) + .map(EnumBuilderWrapper::from_object) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn add_class( - &self, - runtime: &baml_runtime::BamlRuntime, - name: &str, - ) -> Result { + fn add_class(&self, name: &str) -> Result { self.inner - .add_class(runtime, name) + .add_class(name) .map(ClassBuilderWrapper::from_object) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn class( - &self, - runtime: &baml_runtime::BamlRuntime, - name: &str, - ) -> Result { + fn class(&self, name: &str) -> Result { self.inner - .class(runtime, name) + .class(name) .map(ClassBuilderWrapper::from_object) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn enum_( - &self, - runtime: &baml_runtime::BamlRuntime, - name: &str, - ) -> Result { - self.inner.r#enum(runtime, name).map_err(|e| e.to_string()) + fn enum_(&self, name: &str) -> Result { + self.inner + .r#enum(name) + .map(EnumBuilderWrapper::from_object) + .map_err(|e| e.to_string()) } #[export_baml_fn] - fn list_enums(&self, runtime: &baml_runtime::BamlRuntime) -> Vec { - self.inner.list_enums(runtime) + fn list_enums(&self) -> Vec { + self.inner.list_enums() } #[export_baml_fn] - fn list_classes(&self, runtime: &baml_runtime::BamlRuntime) -> Vec { - self.inner.list_classes(runtime) + fn list_classes(&self) -> Vec { + self.inner.list_classes() } #[export_baml_fn] fn __display__(&self) -> String { - self.type_builder.to_string() + todo!("implement this") } } @@ -165,75 +150,59 @@ impl EnumBuilderWrapper { } #[export_baml_fn] - fn add_value( - &self, - runtime: &baml_runtime::BamlRuntime, - value: &str, - ) -> Result { + fn add_value(&self, value: &str) -> Result { self.inner - .add_value(runtime, value) + .add_value(value) + .map(EnumValueBuilderWrapper::from_object) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn set_description( - &self, - runtime: &baml_runtime::BamlRuntime, - description: &str, - ) -> Result<(), String> { + fn set_description(&self, description: &str) -> Result<(), String> { self.inner - .set_description(runtime, description) + .set_description(Some(description)) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn set_alias(&self, runtime: &baml_runtime::BamlRuntime, alias: &str) -> Result<(), String> { - self.inner - .set_alias(runtime, alias) - .map_err(|e| e.to_string()) + fn set_alias(&self, alias: &str) -> Result<(), String> { + self.inner.set_alias(Some(alias)).map_err(|e| e.to_string()) } #[export_baml_fn] - fn description(&self, runtime: &baml_runtime::BamlRuntime) -> Result, String> { - self.inner.description(runtime).map_err(|e| e.to_string()) + fn description(&self) -> Result, String> { + self.inner.description().map_err(|e| e.to_string()) } #[export_baml_fn] - fn alias(&self, runtime: &baml_runtime::BamlRuntime) -> Result, String> { - self.inner.alias(runtime).map_err(|e| e.to_string()) + fn alias(&self) -> Result, String> { + self.inner.alias().map_err(|e| e.to_string()) } #[export_baml_fn] - fn type_(&self, runtime: &baml_runtime::BamlRuntime) -> Result { - self.inner.r#type(runtime).map_err(|e| e.to_string()) + fn type_(&self) -> Result { + self.inner.r#type().map_err(|e| e.to_string()) } #[export_baml_fn] - fn list_values( - &self, - runtime: &baml_runtime::BamlRuntime, - ) -> Result, String> { + fn list_values(&self) -> Result, String> { self.inner - .list_values(runtime) + .list_values() .map(|builders| builders.into_iter().collect()) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn value( - &self, - runtime: &baml_runtime::BamlRuntime, - name: &str, - ) -> Result { + fn value(&self, name: &str) -> Result { self.inner - .value(runtime, name) + .value(name) .map(EnumValueBuilderWrapper::from_object) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn is_from_ast(&self, runtime: &baml_runtime::BamlRuntime) -> Result { - self.inner.is_from_ast(runtime).map_err(|e| e.to_string()) + fn is_from_ast(&self) -> Result { + self.inner.is_from_ast().map_err(|e| e.to_string()) } } @@ -245,48 +214,40 @@ impl EnumValueBuilderWrapper { } #[export_baml_fn] - fn set_description( - &self, - runtime: &baml_runtime::BamlRuntime, - description: &str, - ) -> Result<(), String> { + fn set_description(&self, description: &str) -> Result<(), String> { self.inner - .set_description(runtime, description) + .set_description(Some(description)) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn set_alias(&self, runtime: &baml_runtime::BamlRuntime, alias: &str) -> Result<(), String> { - self.inner - .set_alias(runtime, alias) - .map_err(|e| e.to_string()) + fn set_alias(&self, alias: &str) -> Result<(), String> { + self.inner.set_alias(Some(alias)).map_err(|e| e.to_string()) } #[export_baml_fn] - fn description(&self, runtime: &baml_runtime::BamlRuntime) -> Result, String> { - self.inner.description(runtime).map_err(|e| e.to_string()) + fn description(&self) -> Result, String> { + self.inner.description().map_err(|e| e.to_string()) } #[export_baml_fn] - fn alias(&self, runtime: &baml_runtime::BamlRuntime) -> Result, String> { - self.inner.alias(runtime).map_err(|e| e.to_string()) + fn alias(&self) -> Result, String> { + self.inner.alias().map_err(|e| e.to_string()) } #[export_baml_fn] - fn set_skip(&self, runtime: &baml_runtime::BamlRuntime, skip: bool) -> Result<(), String> { - self.inner - .set_skip(runtime, skip) - .map_err(|e| e.to_string()) + fn set_skip(&self, skip: bool) -> Result<(), String> { + self.inner.set_skip(Some(skip)).map_err(|e| e.to_string()) } #[export_baml_fn] - fn skip(&self, runtime: &baml_runtime::BamlRuntime) -> Result { - self.inner.skip(runtime).map_err(|e| e.to_string()) + fn skip(&self) -> Result { + self.inner.skip().map_err(|e| e.to_string()) } #[export_baml_fn] - fn is_from_ast(&self, runtime: &baml_runtime::BamlRuntime) -> Result { - self.inner.is_from_ast(runtime).map_err(|e| e.to_string()) + fn is_from_ast(&self) -> Result { + self.inner.is_from_ast().map_err(|e| e.to_string()) } } @@ -298,74 +259,60 @@ impl ClassBuilderWrapper { } #[export_baml_fn] - fn type_(&self, runtime: &baml_runtime::BamlRuntime) -> Result { - self.inner.r#type(runtime).map_err(|e| e.to_string()) + fn type_(&self) -> Result { + self.inner.r#type().map_err(|e| e.to_string()) } #[export_baml_fn] - fn list_properties( - &self, - runtime: &baml_runtime::BamlRuntime, - ) -> Result, String> { - self.inner - .list_properties(runtime) - .map_err(|e| e.to_string()) + fn list_properties(&self) -> Result, String> { + self.inner.list_properties().map_err(|e| e.to_string()) } #[export_baml_fn] - fn set_alias(&self, runtime: &baml_runtime::BamlRuntime, alias: &str) -> Result<(), String> { - self.inner - .set_alias(runtime, alias) - .map_err(|e| e.to_string()) + fn set_alias(&self, alias: &str) -> Result<(), String> { + self.inner.set_alias(alias).map_err(|e| e.to_string()) } #[export_baml_fn] - fn set_description( - &self, - runtime: &baml_runtime::BamlRuntime, - description: &str, - ) -> Result<(), String> { + fn set_description(&self, description: &str) -> Result<(), String> { self.inner - .set_description(runtime, description) + .set_description(description) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn alias(&self, runtime: &baml_runtime::BamlRuntime) -> Result, String> { - self.inner.alias(runtime).map_err(|e| e.to_string()) + fn alias(&self) -> Result, String> { + self.inner.alias().map_err(|e| e.to_string()) } #[export_baml_fn] - fn description(&self, runtime: &baml_runtime::BamlRuntime) -> Result, String> { - self.inner.description(runtime).map_err(|e| e.to_string()) + fn description(&self) -> Result, String> { + self.inner.description().map_err(|e| e.to_string()) } #[export_baml_fn] fn add_property( &self, - runtime: &baml_runtime::BamlRuntime, name: &str, field_type: &TypeWrapper, - ) -> Result { + ) -> Result { self.inner - .add_property(runtime, name, field_type.as_ref().clone()) + .add_property(name, field_type.as_ref().clone(), false) + .map(ClassPropertyBuilderWrapper::from_object) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn property( - &self, - runtime: &baml_runtime::BamlRuntime, - name: &str, - ) -> Result { + fn property(&self, name: &str) -> Result { self.inner - .property(runtime, name) + .property(name) + .map(ClassPropertyBuilderWrapper::from_object) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn is_from_ast(&self, runtime: &baml_runtime::BamlRuntime) -> Result { - self.inner.is_from_ast(runtime).map_err(|e| e.to_string()) + fn is_from_ast(&self) -> Result { + self.inner.is_from_ast().map_err(|e| e.to_string()) } } @@ -377,51 +324,41 @@ impl ClassPropertyBuilderWrapper { } #[export_baml_fn] - fn set_description( - &self, - runtime: &baml_runtime::BamlRuntime, - description: &str, - ) -> Result<(), String> { + fn set_description(&self, description: &str) -> Result<(), String> { self.inner - .set_description(runtime, description) + .set_description(Some(description)) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn set_alias(&self, runtime: &baml_runtime::BamlRuntime, alias: &str) -> Result<(), String> { - self.inner - .set_alias(runtime, alias) - .map_err(|e| e.to_string()) + fn set_alias(&self, alias: &str) -> Result<(), String> { + self.inner.set_alias(Some(alias)).map_err(|e| e.to_string()) } #[export_baml_fn] - fn set_type( - &self, - runtime: &baml_runtime::BamlRuntime, - field_type: &TypeWrapper, - ) -> Result<(), String> { + fn set_type(&self, field_type: &TypeWrapper) -> Result<(), String> { self.inner - .set_type(runtime, field_type.as_ref().clone()) + .set_type(field_type.as_ref().clone()) .map_err(|e| e.to_string()) } #[export_baml_fn] - fn description(&self, runtime: &baml_runtime::BamlRuntime) -> Result, String> { - self.inner.description(runtime).map_err(|e| e.to_string()) + fn description(&self) -> Result, String> { + self.inner.description().map_err(|e| e.to_string()) } #[export_baml_fn] - fn alias(&self, runtime: &baml_runtime::BamlRuntime) -> Result, String> { - self.inner.alias(runtime).map_err(|e| e.to_string()) + fn alias(&self) -> Result, String> { + self.inner.alias().map_err(|e| e.to_string()) } #[export_baml_fn] - fn type_(&self, runtime: &baml_runtime::BamlRuntime) -> Result { - self.inner.type_(runtime).map_err(|e| e.to_string()) + fn type_(&self) -> Result { + self.inner.type_().map_err(|e| e.to_string()) } #[export_baml_fn] - fn is_from_ast(&self, runtime: &baml_runtime::BamlRuntime) -> Result { - self.inner.is_from_ast(runtime).map_err(|e| e.to_string()) + fn is_from_ast(&self) -> Result { + self.inner.is_from_ast().map_err(|e| e.to_string()) } } diff --git a/engine/language_client_cffi/src/raw_ptr_wrapper/type_builder/objects.rs b/engine/language_client_cffi/src/raw_ptr_wrapper/type_builder/objects.rs deleted file mode 100644 index a4cd2c4da5..0000000000 --- a/engine/language_client_cffi/src/raw_ptr_wrapper/type_builder/objects.rs +++ /dev/null @@ -1,908 +0,0 @@ -use baml_runtime::{ - type_builder::{self, TypeBuilder as _RuntimeTypeBuilder, WithMeta}, - BamlRuntime, IRHelper, InternalRuntimeInterface, -}; -use baml_types::{BamlValue, TypeIR}; - -type RuntimeTypeBuilder = std::sync::Arc<_RuntimeTypeBuilder>; - -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] -enum NodeRW { - // Only view the data (no modifications allowed) - ReadOnly, - // View data, but can modify attributes like alias / description - LLMOnly, - // Go wild - ReadWrite, -} - -impl NodeRW { - fn at_least(&self, other: NodeRW) -> anyhow::Result<()> { - if self < &other { - anyhow::bail!( - "Insufficient permissions to perform this operation: {:?} < {:?}", - self, - other - ); - } - Ok(()) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_node_rw_at_least() { - assert!(NodeRW::ReadOnly.at_least(NodeRW::ReadOnly).is_ok()); - assert!(NodeRW::ReadOnly.at_least(NodeRW::LLMOnly).is_err()); - assert!(NodeRW::ReadOnly.at_least(NodeRW::ReadWrite).is_err()); - - assert!(NodeRW::LLMOnly.at_least(NodeRW::ReadOnly).is_ok()); - assert!(NodeRW::LLMOnly.at_least(NodeRW::LLMOnly).is_ok()); - assert!(NodeRW::LLMOnly.at_least(NodeRW::ReadWrite).is_err()); - - assert!(NodeRW::ReadWrite.at_least(NodeRW::ReadOnly).is_ok()); - assert!(NodeRW::ReadWrite.at_least(NodeRW::LLMOnly).is_ok()); - assert!(NodeRW::ReadWrite.at_least(NodeRW::ReadWrite).is_ok()); - } -} - -#[derive(Debug, Clone, Default)] -pub struct TypeBuilder { - pub type_builder: RuntimeTypeBuilder, -} - -impl TypeBuilder { - pub fn add_enum(&self, rt: &BamlRuntime, name: &str) -> anyhow::Result { - match rt.internal().ir().find_enum(name) { - Ok(_) => { - anyhow::bail!("Enum with name {name} already exists"); - } - Err(_) => { - let _ = self.type_builder.upsert_enum(name); - let builder = EnumBuilder::new(self.type_builder.clone(), name.to_string()); - Ok(builder.mode(NodeRW::ReadWrite)) - } - } - } - - pub fn add_class(&self, rt: &BamlRuntime, name: &str) -> anyhow::Result { - match rt.internal().ir().find_class(name) { - Ok(_) => { - anyhow::bail!("Class with name {name} already exists"); - } - Err(_) => { - let _ = self.type_builder.upsert_class(name); - let builder = ClassBuilder::new(self.type_builder.clone(), name.to_string()); - Ok(builder.mode(NodeRW::ReadWrite)) - } - } - } - - pub fn class(&self, rt: &BamlRuntime, name: &str) -> anyhow::Result { - match rt.internal().ir().find_class(name) { - Ok(cls) => { - let _ = self.type_builder.upsert_class(name); - let builder = ClassBuilder::new(self.type_builder.clone(), name.to_string()); - if !cls.item.attributes.dynamic() { - Ok(builder.mode(NodeRW::ReadOnly)) - } else { - Ok(builder.mode(NodeRW::ReadWrite)) - } - } - Err(_) => match self.type_builder.maybe_get_class(name) { - Some(_) => Ok(ClassBuilder::new( - self.type_builder.clone(), - name.to_string(), - )), - None => { - anyhow::bail!("Class with name {name} does not exist"); - } - }, - } - } - - pub fn r#enum(&self, rt: &BamlRuntime, name: &str) -> anyhow::Result { - match rt.internal().ir().find_enum(name) { - Ok(enm) => { - let _ = self.type_builder.upsert_enum(name); - let builder = EnumBuilder::new(self.type_builder.clone(), name.to_string()); - if !enm.item.attributes.dynamic() { - return Ok(builder.mode(NodeRW::ReadOnly)); - } - Ok(builder.mode(NodeRW::ReadWrite)) - } - Err(_) => match self.type_builder.maybe_get_enum(name) { - Some(_) => Ok(EnumBuilder::new( - self.type_builder.clone(), - name.to_string(), - )), - None => { - anyhow::bail!("Enum with name {name} does not exist"); - } - }, - } - } - - pub fn add_baml(&self, baml: &str, rt: &BamlRuntime) -> anyhow::Result<()> { - self.type_builder.add_baml(baml, &rt.inner) - } - - pub fn list_enums(&self, rt: &BamlRuntime) -> Vec { - let ir = rt.internal().ir(); - let enums = ir.walk_enums(); - enums - .map(|enm| enm.name().to_string()) - .chain(self.type_builder.list_enums()) - .collect::>() - .into_iter() - .map(|name| EnumBuilder::new(self.type_builder.clone(), name)) - .collect() - } - - pub fn list_classes(&self, rt: &BamlRuntime) -> Vec { - let ir = rt.internal().ir(); - let classes = ir.walk_classes(); - classes - .map(|cls| cls.name().to_string()) - .chain(self.type_builder.list_classes()) - .collect::>() - .into_iter() - .map(|name| ClassBuilder::new(self.type_builder.clone(), name)) - .collect() - } -} - -#[derive(Debug, Clone)] -pub struct ClassBuilder { - type_builder: RuntimeTypeBuilder, - pub class_name: String, - mode: NodeRW, -} - -impl ClassBuilder { - fn new(type_builder: RuntimeTypeBuilder, class_name: String) -> Self { - Self { - type_builder, - class_name, - mode: NodeRW::ReadOnly, - } - } - - fn mode(self, mode: NodeRW) -> Self { - Self { mode, ..self } - } - - fn create_property(&self, name: &str, rt: &BamlRuntime) -> ClassPropertyBuilder { - let builder = ClassPropertyBuilder::new( - self.type_builder.clone(), - self.class_name.clone(), - name.to_string(), - ); - - let target_mode = match self.mode { - NodeRW::ReadOnly => NodeRW::ReadOnly, - NodeRW::LLMOnly => NodeRW::LLMOnly, - NodeRW::ReadWrite => { - if let Ok(cls) = rt.internal().ir().find_class(self.class_name.as_str()) { - if cls.find_field(name).is_some() { - NodeRW::LLMOnly - } else { - NodeRW::ReadWrite - } - } else { - NodeRW::ReadWrite - } - } - }; - - builder.mode(target_mode) - } - - fn cls( - &self, - rt: &BamlRuntime, - ) -> anyhow::Result>> { - // if the IR defines the class, then its always valid - if rt - .internal() - .ir() - .find_class(self.class_name.as_str()) - .is_ok() - { - let cls = self.type_builder.upsert_class(self.class_name.as_str()); - return Ok(cls); - } - - let Some(cls) = self.type_builder.maybe_get_class(self.class_name.as_str()) else { - anyhow::bail!("Class not found: {}", self.class_name); - }; - Ok(cls) - } - - pub fn r#type(&self, rt: &BamlRuntime) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadOnly)?; - let _ = self.cls(rt)?; - - Ok(TypeIR::class(self.class_name.as_str())) - } - - pub fn list_properties(&self, rt: &BamlRuntime) -> anyhow::Result> { - self.mode.at_least(NodeRW::ReadOnly)?; - - let lock = self.cls(rt)?; - let builder = lock.lock().unwrap(); - - let ir_properties = match rt.internal().ir().find_class(self.class_name.as_str()) { - Ok(ir_cls) => ir_cls - .item - .elem - .static_fields - .iter() - .map(|field| field.elem.name.to_string()) - .collect(), - Err(_) => vec![], - }; - - let dynamic_properties = builder - .list_properties() - .into_iter() - .filter(|name| !ir_properties.contains(name)) - .collect::>(); - - let properties = ir_properties.into_iter().chain(dynamic_properties); - Ok(properties - .into_iter() - .map(|name| self.create_property(name.as_str(), rt)) - .collect()) - } - - pub fn set_alias(&self, rt: &BamlRuntime, alias: &str) -> anyhow::Result<()> { - self.mode.at_least(NodeRW::LLMOnly)?; - - let cls = self.cls(rt)?; - let builder = cls.lock().unwrap(); - builder.with_meta("alias", BamlValue::String(alias.to_string())); - Ok(()) - } - - pub fn set_description(&self, rt: &BamlRuntime, description: &str) -> anyhow::Result<()> { - self.mode.at_least(NodeRW::LLMOnly)?; - - let cls = self.cls(rt)?; - let builder = cls.lock().unwrap(); - builder.with_meta("description", BamlValue::String(description.to_string())); - Ok(()) - } - - pub fn alias(&self, rt: &BamlRuntime) -> Result, anyhow::Error> { - self.mode.at_least(NodeRW::ReadOnly)?; - - let ast_alias = || { - if let Ok(cls) = rt.internal().ir().find_class(self.class_name.as_str()) { - cls.alias(&Default::default()).ok().flatten() - } else { - None - } - }; - - let cls = self.cls(rt)?; - let builder = cls.lock().unwrap(); - let result = builder - .get_meta("alias") - .and_then(|value| value.as_str().map(|s| s.to_string())) - .or_else(ast_alias); - Ok(result) - } - - pub fn description(&self, rt: &BamlRuntime) -> Result, anyhow::Error> { - self.mode.at_least(NodeRW::ReadOnly)?; - - // ast does not support description - let ast_description = || { - if let Ok(cls) = rt.internal().ir().find_class(self.class_name.as_str()) { - cls.description(&Default::default()).ok().flatten() - } else { - None - } - }; - - let cls = self.cls(rt)?; - let builder = cls.lock().unwrap(); - let result = builder - .get_meta("description") - .and_then(|value| value.as_str().map(|s| s.to_string())) - .or_else(ast_description); - Ok(result) - } - - pub fn add_property( - &self, - rt: &BamlRuntime, - name: &str, - field_type: TypeIR, - ) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadWrite)?; - let cls = self.cls(rt)?; - - // if the IR already has the property, then its not valid to add it again - if let Ok(cls) = rt.internal().ir().find_class(self.class_name.as_str()) { - if cls.find_field(name).is_some() { - anyhow::bail!( - "Property already exists: {} in class {}", - name, - self.class_name - ); - } - } - - let builder = cls.lock().unwrap(); - let prop = builder.upsert_property(name); - prop.lock().unwrap().set_type(field_type); - Ok(self.create_property(name, rt)) - } - - pub fn property(&self, rt: &BamlRuntime, name: &str) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadOnly)?; - let cls = self.cls(rt)?; - - let builder = cls.lock().unwrap(); - match builder.maybe_get_property(name) { - Some(_) => Ok(self.create_property(name, rt)), - None => { - // if the IR has the property, then its valid to add it again - if let Ok(cls) = rt.internal().ir().find_class(self.class_name.as_str()) { - if cls.find_field(name).is_some() { - let _ = builder.upsert_property(name); - Ok(self.create_property(name, rt)) - } else { - anyhow::bail!("Property not found: {} in class {}", name, self.class_name) - } - } else { - anyhow::bail!("Property not found: {} in class {}", name, self.class_name) - } - } - } - } - - pub fn is_from_ast(&self, rt: &BamlRuntime) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadOnly)?; - Ok(rt - .internal() - .ir() - .find_class(self.class_name.as_str()) - .is_ok()) - } -} - -#[derive(Debug, Clone)] -pub struct ClassPropertyBuilder { - type_builder: RuntimeTypeBuilder, - class_name: String, - pub property_name: String, - mode: NodeRW, -} - -impl ClassPropertyBuilder { - fn new(type_builder: RuntimeTypeBuilder, class_name: String, property_name: String) -> Self { - Self { - type_builder, - class_name, - property_name, - mode: NodeRW::ReadOnly, - } - } - - fn mode(self, mode: NodeRW) -> Self { - Self { mode, ..self } - } - - fn prop( - &self, - rt: &BamlRuntime, - ) -> anyhow::Result>> { - // if the class is defined in the IR, then its always valid - if let Ok(cls) = rt.internal().ir().find_class(self.class_name.as_str()) { - if cls.find_field(&self.property_name).is_some() { - let cls = self.type_builder.upsert_class(self.class_name.as_str()); - let builder = cls.lock().unwrap(); - let prop = builder.upsert_property(&self.property_name); - return Ok(prop); - } - } - - let Some(cls) = self.type_builder.maybe_get_class(self.class_name.as_str()) else { - return Err(anyhow::anyhow!("Class not found: {}", self.class_name)); - }; - let builder = cls.lock().unwrap(); - match builder.maybe_get_property(&self.property_name) { - Some(prop) => Ok(prop), - None => { - anyhow::bail!( - "Property not found: {} in class {}", - self.property_name, - self.class_name - ) - } - } - } - - pub fn description(&self, rt: &BamlRuntime) -> Result, anyhow::Error> { - self.mode.at_least(NodeRW::ReadOnly)?; - - let prop = self.prop(rt)?; - - let ast_description = || { - if let Ok(cls) = rt.internal().ir().find_class(self.class_name.as_str()) { - if let Some(field) = cls.find_field(&self.property_name) { - field.description(&Default::default()).ok().flatten() - } else { - None - } - } else { - None - } - }; - let builder = prop.lock().unwrap(); - let result = builder - .get_meta("description") - .and_then(|value| value.as_str().map(|s| s.to_string())) - .or_else(ast_description); - Ok(result) - } - - pub fn alias(&self, rt: &BamlRuntime) -> Result, anyhow::Error> { - self.mode.at_least(NodeRW::ReadOnly)?; - - let prop = self.prop(rt)?; - - let ast_alias = || { - if let Ok(cls) = rt.internal().ir().find_class(self.class_name.as_str()) { - if let Some(field) = cls.find_field(&self.property_name) { - field.description(&Default::default()).ok().flatten() - } else { - None - } - } else { - None - } - }; - let builder = prop.lock().unwrap(); - let result = builder - .get_meta("alias") - .and_then(|value| value.as_str().map(|s| s.to_string())) - .or_else(ast_alias); - Ok(result) - } - - pub fn type_(&self, rt: &BamlRuntime) -> Result { - self.mode.at_least(NodeRW::ReadOnly)?; - - let ast_type = || { - if let Ok(cls) = rt.internal().ir().find_class(self.class_name.as_str()) { - cls.find_field(&self.property_name) - .map(|field| field.r#type().clone()) - } else { - None - } - }; - - let prop = self.prop(rt)?; - let builder = prop.lock().unwrap(); - let result = builder.r#type().or_else(ast_type).ok_or_else(|| { - anyhow::anyhow!( - "Type not found for property {} in class {}", - self.property_name, - self.class_name - ) - }); - result - } - - pub fn set_description(&self, rt: &BamlRuntime, description: &str) -> anyhow::Result<()> { - self.mode.at_least(NodeRW::LLMOnly)?; - - let prop = self.prop(rt)?; - let builder = prop.lock().unwrap(); - builder.with_meta("description", BamlValue::String(description.to_string())); - Ok(()) - } - - pub fn set_alias(&self, rt: &BamlRuntime, alias: &str) -> anyhow::Result<()> { - self.mode.at_least(NodeRW::LLMOnly)?; - - let prop = self.prop(rt)?; - let builder = prop.lock().unwrap(); - builder.with_meta("alias", BamlValue::String(alias.to_string())); - Ok(()) - } - - pub fn set_type(&self, rt: &BamlRuntime, field_type: TypeIR) -> anyhow::Result<()> { - self.mode.at_least(NodeRW::ReadWrite)?; - - let prop = self.prop(rt)?; - let builder = prop.lock().unwrap(); - builder.set_type(field_type); - Ok(()) - } - - pub fn is_from_ast(&self, rt: &BamlRuntime) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadOnly)?; - if let Ok(cls) = rt.internal().ir().find_class(self.class_name.as_str()) { - if cls.find_field(&self.property_name).is_some() { - return Ok(true); - } - } - Ok(false) - } -} - -#[derive(Debug, Clone)] -pub struct EnumBuilder { - type_builder: RuntimeTypeBuilder, - pub enum_name: String, - mode: NodeRW, -} - -impl EnumBuilder { - fn new(type_builder: RuntimeTypeBuilder, enum_name: String) -> Self { - Self { - type_builder, - enum_name, - mode: NodeRW::ReadOnly, - } - } - - fn mode(self, mode: NodeRW) -> Self { - Self { mode, ..self } - } - - fn enm( - &self, - rt: &BamlRuntime, - ) -> anyhow::Result>> { - // if the IR defines the enum, then its always valid - if rt - .internal() - .ir() - .find_enum(self.enum_name.as_str()) - .is_ok() - { - return Ok(self.type_builder.upsert_enum(self.enum_name.as_str())); - } - - let Some(enm) = self.type_builder.maybe_get_enum(self.enum_name.as_str()) else { - anyhow::bail!("Enum not found: {}", self.enum_name); - }; - Ok(enm) - } - - fn create_value(&self, name: &str, rt: &BamlRuntime) -> EnumValueBuilder { - let target_mode = match self.mode { - NodeRW::ReadOnly => NodeRW::ReadOnly, - NodeRW::LLMOnly => NodeRW::LLMOnly, - NodeRW::ReadWrite => { - if let Ok(enm) = rt.internal().ir().find_enum(self.enum_name.as_str()) { - if enm.find_value(name).is_some() { - NodeRW::LLMOnly - } else { - NodeRW::ReadWrite - } - } else { - NodeRW::ReadWrite - } - } - }; - - EnumValueBuilder::new( - self.type_builder.clone(), - self.enum_name.clone(), - name.to_string(), - ) - .mode(target_mode) - } - - pub fn add_value(&self, rt: &BamlRuntime, value: &str) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadWrite)?; - let enm = self.enm(rt)?; - - // if the IR already has the value, then its not valid to add it again - if let Ok(enm_ir) = rt.internal().ir().find_enum(self.enum_name.as_str()) { - if enm_ir.find_value(value).is_some() { - anyhow::bail!( - "Enum value already exists: {} in enum {}", - value, - self.enum_name - ); - } - } - - let builder = enm.lock().unwrap(); - let _ = builder.upsert_value(value); - Ok(self.create_value(value, rt)) - } - - pub fn set_description(&self, rt: &BamlRuntime, description: &str) -> anyhow::Result<()> { - self.mode.at_least(NodeRW::LLMOnly)?; - - let enm = self.enm(rt)?; - let builder = enm.lock().unwrap(); - builder.with_meta("description", BamlValue::String(description.to_string())); - Ok(()) - } - - pub fn set_alias(&self, rt: &BamlRuntime, alias: &str) -> anyhow::Result<()> { - self.mode.at_least(NodeRW::LLMOnly)?; - - let enm = self.enm(rt)?; - let builder = enm.lock().unwrap(); - builder.with_meta("alias", BamlValue::String(alias.to_string())); - Ok(()) - } - - pub fn alias(&self, rt: &BamlRuntime) -> Result, anyhow::Error> { - let ast_alias = || { - if let Ok(enm) = rt.internal().ir().find_enum(self.enum_name.as_str()) { - enm.alias(&Default::default()).ok().flatten() - } else { - None - } - }; - - let enm = self.enm(rt)?; - let builder = enm.lock().unwrap(); - let result = builder - .get_meta("alias") - .and_then(|value| value.as_str().map(|s| s.to_string())) - .or_else(ast_alias); - Ok(result) - } - - pub fn description(&self, rt: &BamlRuntime) -> Result, anyhow::Error> { - let ast_description = || { - if let Ok(enm) = rt.internal().ir().find_enum(self.enum_name.as_str()) { - enm.description(&Default::default()).ok().flatten() - } else { - None - } - }; - - let enm = self.enm(rt)?; - let builder = enm.lock().unwrap(); - let result = builder - .get_meta("description") - .and_then(|value| value.as_str().map(|s| s.to_string())) - .or_else(ast_description); - Ok(result) - } - - pub fn r#type(&self, rt: &BamlRuntime) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadOnly)?; - let _ = self.enm(rt)?; - - Ok(TypeIR::r#enum(self.enum_name.as_str())) - } - - pub fn list_values(&self, rt: &BamlRuntime) -> anyhow::Result> { - self.mode.at_least(NodeRW::ReadOnly)?; - - let enm = self.enm(rt)?; - - let ir_values = match rt.internal().ir().find_enum(self.enum_name.as_str()) { - Ok(ir_enm) => ir_enm - .item - .elem - .values - .iter() - .map(|value| value.0.elem.0.to_string()) - .collect(), - Err(_) => vec![], - }; - - let builder = enm.lock().unwrap(); - let dynamic_values = builder - .list_values() - .into_iter() - .filter(|name| !ir_values.contains(name)) - .collect::>(); - - let values = ir_values.into_iter().chain(dynamic_values); - Ok(values - .into_iter() - .map(|name| self.create_value(name.as_str(), rt)) - .collect()) - } - - pub fn value(&self, rt: &BamlRuntime, name: &str) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadOnly)?; - let enm = self.enm(rt)?; - - let builder = enm.lock().unwrap(); - let values = builder.list_values(); - if values.contains(&name.to_string()) { - Ok(self.create_value(name, rt)) - } else { - // if the IR has the value, then its valid to add it again - if let Ok(enm_ir) = rt.internal().ir().find_enum(self.enum_name.as_str()) { - if enm_ir.find_value(name).is_some() { - let _ = builder.upsert_value(name); - Ok(self.create_value(name, rt)) - } else { - anyhow::bail!("Enum value not found: {} in enum {}", name, self.enum_name) - } - } else { - anyhow::bail!("Enum value not found: {} in enum {}", name, self.enum_name) - } - } - } - - pub fn is_from_ast(&self, rt: &BamlRuntime) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadOnly)?; - Ok(rt - .internal() - .ir() - .find_enum(self.enum_name.as_str()) - .is_ok()) - } -} - -#[derive(Debug, Clone)] -pub struct EnumValueBuilder { - type_builder: RuntimeTypeBuilder, - enum_name: String, - pub value_name: String, - mode: NodeRW, -} - -impl EnumValueBuilder { - fn new(type_builder: RuntimeTypeBuilder, enum_name: String, value_name: String) -> Self { - Self { - type_builder, - enum_name, - value_name, - mode: NodeRW::ReadOnly, - } - } - - fn mode(self, mode: NodeRW) -> Self { - Self { mode, ..self } - } - - fn value( - &self, - rt: &BamlRuntime, - ) -> anyhow::Result>> { - // if the enum is defined in the IR, then its always valid - if let Ok(enm) = rt.internal().ir().find_enum(self.enum_name.as_str()) { - if enm.find_value(self.value_name.as_str()).is_some() { - let enm = self.type_builder.upsert_enum(self.enum_name.as_str()); - let builder = enm.lock().unwrap(); - let value = builder.upsert_value(&self.value_name); - return Ok(value); - } - } - - let Some(enm) = self.type_builder.maybe_get_enum(self.enum_name.as_str()) else { - return Err(anyhow::anyhow!("Enum not found: {}", self.enum_name)); - }; - let builder = enm.lock().unwrap(); - match builder.maybe_get_value(&self.value_name) { - Some(value) => Ok(value), - None => { - anyhow::bail!( - "Enum value not found: {} in enum {}", - self.value_name, - self.enum_name - ) - } - } - } - - pub fn set_description(&self, rt: &BamlRuntime, description: &str) -> anyhow::Result<()> { - self.mode.at_least(NodeRW::LLMOnly)?; - - let value = self.value(rt)?; - let builder = value.lock().unwrap(); - builder.with_meta("description", BamlValue::String(description.to_string())); - Ok(()) - } - - pub fn set_alias(&self, rt: &BamlRuntime, alias: &str) -> anyhow::Result<()> { - self.mode.at_least(NodeRW::LLMOnly)?; - - let value = self.value(rt)?; - let builder = value.lock().unwrap(); - builder.with_meta("alias", BamlValue::String(alias.to_string())); - Ok(()) - } - - pub fn description(&self, rt: &BamlRuntime) -> Result, anyhow::Error> { - let ast_description = || { - if let Ok(enm) = rt.internal().ir().find_enum(self.enum_name.as_str()) { - if let Some(value) = enm.find_value(&self.value_name) { - value.description(&Default::default()).ok().flatten() - } else { - None - } - } else { - None - } - }; - - let value = self.value(rt)?; - let builder = value.lock().unwrap(); - let result = builder - .get_meta("description") - .and_then(|value| value.as_str().map(|s| s.to_string())) - .or_else(ast_description); - Ok(result) - } - - pub fn alias(&self, rt: &BamlRuntime) -> Result, anyhow::Error> { - let ast_alias = || { - if let Ok(enm) = rt.internal().ir().find_enum(self.enum_name.as_str()) { - if let Some(value) = enm.find_value(&self.value_name) { - value.alias(&Default::default()).ok().flatten() - } else { - None - } - } else { - None - } - }; - - let value = self.value(rt)?; - let builder = value.lock().unwrap(); - let result = builder - .get_meta("alias") - .and_then(|value| value.as_str().map(|s| s.to_string())) - .or_else(ast_alias); - Ok(result) - } - - pub fn set_skip(&self, rt: &BamlRuntime, skip: bool) -> anyhow::Result<()> { - self.mode.at_least(NodeRW::LLMOnly)?; - - let value = self.value(rt)?; - let builder = value.lock().unwrap(); - builder.with_meta("skip", BamlValue::Bool(skip)); - Ok(()) - } - - pub fn skip(&self, rt: &BamlRuntime) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadOnly)?; - - let ast_skip = || { - if let Ok(enm) = rt.internal().ir().find_enum(self.enum_name.as_str()) { - if let Some(value) = enm.find_value(&self.value_name) { - value.skip(&Default::default()).ok() - } else { - None - } - } else { - None - } - }; - - let value = self.value(rt)?; - let builder = value.lock().unwrap(); - let skip = builder - .get_meta("skip") - .and_then(|value| value.as_bool()) - .or_else(ast_skip) - .unwrap_or(false); - Ok(skip) - } - - pub fn is_from_ast(&self, rt: &BamlRuntime) -> anyhow::Result { - self.mode.at_least(NodeRW::ReadOnly)?; - if let Ok(enm) = rt.internal().ir().find_enum(self.enum_name.as_str()) { - if enm.find_value(&self.value_name).is_some() { - return Ok(true); - } - } - Ok(false) - } -} diff --git a/engine/language_client_python/Cargo.toml b/engine/language_client_python/Cargo.toml index fe9792fd80..6b8924bac7 100644 --- a/engine/language_client_python/Cargo.toml +++ b/engine/language_client_python/Cargo.toml @@ -39,6 +39,7 @@ libc = "0.2" once_cell = "1.19" jsonish = { path = "../baml-lib/jsonish" } log.workspace = true +baml-type-builder = { path = "../baml-lib/type-builder" } # Consult https://pyo3.rs/main/migration for migration instructions pyo3 = { version = "0.23.3", default-features = false, features = [ "abi3-py38", diff --git a/engine/language_client_python/python_src/baml_py/baml_py.pyi b/engine/language_client_python/python_src/baml_py/baml_py.pyi index 3826d7162d..ffca29a647 100644 --- a/engine/language_client_python/python_src/baml_py/baml_py.pyi +++ b/engine/language_client_python/python_src/baml_py/baml_py.pyi @@ -310,8 +310,10 @@ class BamlSpan: class TypeBuilder: def __init__(self) -> None: ... def reset(self) -> None: ... - def enum(self, name: str) -> EnumBuilder: ... - def class_(self, name: str) -> ClassBuilder: ... + def add_enum(self, name: str) -> EnumBuilder: ... + def get_enum(self, name: str) -> EnumBuilder: ... + def add_class(self, name: str) -> ClassBuilder: ... + def get_class(self, name: str) -> ClassBuilder: ... def string(self) -> FieldType: ... def literal_string(self, value: str) -> FieldType: ... def literal_int(self, value: int) -> FieldType: ... @@ -324,7 +326,7 @@ class TypeBuilder: def optional(self, inner_type: FieldType) -> FieldType: ... def map(self, key_type: FieldType, value_type: FieldType) -> FieldType: ... def union(self, *types: FieldType) -> FieldType: ... - def add_baml(self, baml: str, rt: BamlRuntime) -> None: ... + def add_baml(self, baml: str) -> None: ... class Collector: def __init__(self, name: Optional[str] = None) -> None: ... @@ -510,27 +512,46 @@ class FieldType: def __eq__(self, other: object) -> bool: ... class EnumBuilder: - def value(self, name: str) -> EnumValueBuilder: ... - def alias(self, alias: Optional[str]) -> EnumBuilder: ... + def list_values(self) -> List[Tuple[str, EnumValueBuilder]]: ... + def get_value(self, name: str) -> EnumValueBuilder: ... + def add_value(self, name: str) -> EnumValueBuilder: ... + def remove_value(self, name: str) -> None: ... + def set_alias(self, alias: Optional[str]) -> EnumBuilder: ... + def alias(self) -> Optional[str]: ... + def set_description(self, description: Optional[str]) -> EnumBuilder: ... + def description(self) -> Optional[str]: ... def field(self) -> FieldType: ... + def source(self) -> Literal["baml", "dynamic"]: ... class EnumValueBuilder: - def alias(self, alias: Optional[str]) -> EnumValueBuilder: ... - def skip(self, skip: Optional[bool] = True) -> EnumValueBuilder: ... - def description(self, description: Optional[str]) -> EnumValueBuilder: ... + def set_alias(self, alias: Optional[str]) -> EnumValueBuilder: ... + def alias(self) -> Optional[str]: ... + def set_skip(self, skip: Optional[bool] = True) -> EnumValueBuilder: ... + def skip(self) -> bool: ... + def set_description(self, description: Optional[str]) -> EnumValueBuilder: ... + def description(self) -> Optional[str]: ... + def source(self) -> Literal["baml", "dynamic"]: ... class ClassBuilder: def field(self) -> FieldType: ... def list_properties(self) -> List[Tuple[str, ClassPropertyBuilder]]: ... - def property(self, name: str) -> ClassPropertyBuilder: ... + def add_property(self, name: str, type: FieldType) -> ClassPropertyBuilder: ... + def get_property(self, name: str) -> ClassPropertyBuilder: ... def remove_property(self, name: str) -> None: ... def reset(self) -> None: ... + def source(self) -> Literal["baml", "dynamic"]: ... + def alias(self) -> Optional[str]: ... + def set_alias(self, alias: Optional[str]) -> ClassBuilder: ... class ClassPropertyBuilder: - def type(self, field_type: FieldType) -> ClassPropertyBuilder: ... - def get_type(self) -> FieldType: ... - def alias(self, alias: Optional[str]) -> ClassPropertyBuilder: ... - def description(self, description: Optional[str]) -> ClassPropertyBuilder: ... + def type(self) -> FieldType: ... + def set_type(self, field_type: FieldType) -> ClassPropertyBuilder: ... + def alias(self) -> Optional[str]: ... + def set_alias(self, alias: Optional[str]) -> ClassPropertyBuilder: ... + def description(self) -> Optional[str]: ... + def set_description(self, description: Optional[str]) -> ClassPropertyBuilder: ... + @property + def source(self) -> Literal["baml", "dynamic"]: ... def invoke_runtime_cli() -> int: ... diff --git a/engine/language_client_python/python_src/baml_py/type_builder.py b/engine/language_client_python/python_src/baml_py/type_builder.py index 75f060e998..dfef440b68 100644 --- a/engine/language_client_python/python_src/baml_py/type_builder.py +++ b/engine/language_client_python/python_src/baml_py/type_builder.py @@ -3,7 +3,7 @@ ClassBuilder, EnumBuilder, FieldType, - ClassPropertyBuilder as _ClassPropertyBuilder, + ClassPropertyBuilder, EnumValueBuilder, TypeBuilder as _TypeBuilder, BamlRuntime, @@ -11,14 +11,14 @@ class TypeBuilder: - def __init__( - self, classes: typing.Set[str], enums: typing.Set[str], runtime: BamlRuntime - ): - self.__classes = classes - self.__enums = enums - self.__tb = _TypeBuilder() + def __init__(self, runtime: BamlRuntime): + self.__tb = _TypeBuilder(runtime) self.__runtime = runtime + @property + def _tb(self) -> _TypeBuilder: + return self.__tb + def reset(self): self.__tb.reset() @@ -54,10 +54,6 @@ def __str__(self) -> str: """ return str(self._tb) - @property - def _tb(self) -> _TypeBuilder: - return self.__tb - def string(self): return self._tb.string() @@ -91,99 +87,11 @@ def map(self, key: FieldType, value: FieldType): def union(self, types: typing.List[FieldType]): return self._tb.union(*types) - def add_class(self, name: str) -> "NewClassBuilder": - if name in self.__classes: - raise ValueError(f"Class with name {name} already exists.") - if name in self.__enums: - raise ValueError(f"Enum with name {name} already exists.") - self.__classes.add(name) - return NewClassBuilder(self._tb, name) - - def add_enum(self, name: str) -> "NewEnumBuilder": - if name in self.__classes: - raise ValueError(f"Class with name {name} already exists.") - if name in self.__enums: - raise ValueError(f"Enum with name {name} already exists.") - self.__enums.add(name) - return NewEnumBuilder(self._tb, name) - - def add_baml(self, baml: str): - return self._tb.add_baml(baml, self.__runtime) - - -class NewClassBuilder: - def __init__(self, tb: _TypeBuilder, name: str): - self.__bldr = tb.class_(name) - - def type(self) -> FieldType: - return self.__bldr.field() - - def list_properties(self) -> typing.List[typing.Tuple[str, "ClassPropertyBuilder"]]: - return self.__bldr.list_properties() - - def reset(self): - self.__bldr.reset() - - def remove_property(self, name: str): - self.__bldr.remove_property(name) - - def add_property(self, name: str, type: FieldType) -> "ClassPropertyBuilder": - return ClassPropertyBuilder(self.__bldr.property(name).type(type)) + def add_class(self, name: str) -> ClassBuilder: + return self._tb.add_class(name) + def add_enum(self, name: str) -> EnumBuilder: + return self._tb.add_enum(name) -class ClassPropertyBuilder: - def __init__(self, bldr: _ClassPropertyBuilder): - self.__bldr = bldr - - def alias(self, alias: typing.Optional[str]): - self.__bldr.alias(alias) - return self - - def description(self, description: typing.Optional[str]): - self.__bldr.description(description) - return self - - -class ClassPropertyViewer: - def __init__(self, bldr: _ClassPropertyBuilder): - self.__bldr = bldr - - -class NewEnumBuilder: - def __init__(self, tb: _TypeBuilder, name: str): - self.__bldr = tb.enum(name) - self.__values: typing.Set[str] = set() - self.__vals = NewEnumValues(self.__bldr, self.__values) - - def type(self) -> FieldType: - return self.__bldr.field() - - @property - def values(self) -> "NewEnumValues": - return self.__vals - - def list_values(self) -> typing.List[typing.Tuple[str, EnumValueBuilder]]: - return [(name, self.__bldr.value(name)) for name in self.__values] - - def add_value(self, name: str) -> "EnumValueBuilder": - if name in self.__values: - raise ValueError(f"Value {name} already exists.") - self.__values.add(name) - # NOTE(sam): why is this inconsistent between classes and enums? - return self.__bldr.value(name) - - -class NewEnumValues: - def __init__(self, enum_bldr: EnumBuilder, values: typing.Set[str]): - self.__bldr = enum_bldr - self.__values = values - - def __getattr__(self, name: str) -> "EnumValueBuilder": - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) - - -class EnumValueViewer: - def __init__(self, bldr: "EnumValueBuilder"): - self.__bldr = bldr + def add_baml(self, baml: str): + return self._tb.add_baml(baml) diff --git a/engine/language_client_python/src/types/type_builder.rs b/engine/language_client_python/src/types/type_builder.rs index e73bf084f2..5ee98f24bc 100644 --- a/engine/language_client_python/src/types/type_builder.rs +++ b/engine/language_client_python/src/types/type_builder.rs @@ -1,7 +1,4 @@ -use std::ops::Deref; - -use baml_runtime::type_builder::{self, WithMeta}; -use baml_types::{ir_type::UnionConstructor, BamlValue}; +use baml_types::ir_type::UnionConstructor; use pyo3::{ prelude::PyAnyMethods, pymethods, @@ -9,38 +6,39 @@ use pyo3::{ Bound, PyResult, }; -use crate::errors::BamlError; +use crate::{errors::BamlError, runtime::BamlRuntime}; -crate::lang_wrapper!(TypeBuilder, type_builder::TypeBuilder); -crate::lang_wrapper!(EnumBuilder, type_builder::EnumBuilder, sync_thread_safe, name: String); -crate::lang_wrapper!(ClassBuilder, type_builder::ClassBuilder, sync_thread_safe, name: String); +crate::lang_wrapper!( + TypeBuilder, + baml_type_builder::TypeBuilder +); +crate::lang_wrapper!( + EnumBuilder, + baml_type_builder::EnumBuilder +); +crate::lang_wrapper!( + ClassBuilder, + baml_type_builder::ClassBuilder +); crate::lang_wrapper!( EnumValueBuilder, - type_builder::EnumValueBuilder, - sync_thread_safe + baml_type_builder::EnumValueBuilder ); crate::lang_wrapper!( ClassPropertyBuilder, - type_builder::ClassPropertyBuilder, - sync_thread_safe + baml_type_builder::ClassPropertyBuilder ); -crate::lang_wrapper!(FieldType, baml_types::TypeIR, sync_thread_safe); - -impl Default for TypeBuilder { - fn default() -> Self { - Self::new() - } -} +crate::lang_wrapper!(FieldType, baml_types::TypeIR); #[pymethods] impl TypeBuilder { #[new] - pub fn new() -> Self { - type_builder::TypeBuilder::new().into() + pub fn new(runtime: &BamlRuntime) -> Self { + baml_type_builder::TypeBuilder::new(runtime.inner.internal().clone()).into() } pub fn reset(&self) { - self.inner.reset(); + self.inner.reset() } /// provides a detailed string representation of the typebuilder for python users. @@ -60,20 +58,24 @@ impl TypeBuilder { self.inner.to_string() } - pub fn r#enum(&self, name: &str) -> EnumBuilder { - EnumBuilder { - inner: self.inner.upsert_enum(name), - name: name.to_string(), - } + pub fn add_enum(&self, name: &str) -> PyResult { + let result = self.inner.add_enum(name).map_err(BamlError::from_anyhow)?; + Ok(EnumBuilder { inner: result }) } - // Rename to "class_" - #[pyo3(name = "class_")] - pub fn class(&self, name: &str) -> ClassBuilder { - ClassBuilder { - inner: self.inner.upsert_class(name), - name: name.to_string(), - } + pub fn get_enum(&self, name: &str) -> PyResult { + let result = self.inner.r#enum(name).map_err(BamlError::from_anyhow)?; + Ok(EnumBuilder { inner: result }) + } + + pub fn add_class(&self, name: &str) -> PyResult { + let result = self.inner.add_class(name).map_err(BamlError::from_anyhow)?; + Ok(ClassBuilder { inner: result }) + } + + pub fn get_class(&self, name: &str) -> PyResult { + let result = self.inner.class(name).map_err(BamlError::from_anyhow)?; + Ok(ClassBuilder { inner: result }) } pub fn literal_string(&self, value: &str) -> FieldType { @@ -89,11 +91,11 @@ impl TypeBuilder { } pub fn list(&self, inner: &FieldType) -> FieldType { - inner.inner.lock().unwrap().clone().as_list().into() + inner.inner.clone().as_list().into() } pub fn optional(&self, inner: &FieldType) -> FieldType { - inner.inner.lock().unwrap().clone().as_optional().into() + inner.inner.clone().as_optional().into() } pub fn string(&self) -> FieldType { @@ -117,11 +119,7 @@ impl TypeBuilder { } pub fn map(&self, key: &FieldType, value: &FieldType) -> FieldType { - baml_types::TypeIR::map( - key.inner.lock().unwrap().clone(), - value.inner.lock().unwrap().clone(), - ) - .into() + baml_types::TypeIR::map(key.inner.clone(), value.inner.clone()).into() } #[pyo3(signature = (*types))] @@ -130,162 +128,271 @@ impl TypeBuilder { for idx in 0..types.len() { let item = types.get_item(idx)?; let item = item.downcast::()?; - rs_types.push(item.borrow().inner.lock().unwrap().clone()); + rs_types.push(item.borrow().inner.clone()); } Ok(baml_types::TypeIR::union(rs_types).into()) } - pub fn add_baml( - &self, - baml: &str, - rt: &crate::runtime::BamlRuntime, - ) -> Result<(), pyo3::PyErr> { - self.inner - .add_baml(baml, rt.inner.internal()) - .map_err(BamlError::from_anyhow) + pub fn add_baml(&self, baml: &str) -> PyResult<()> { + self.inner.add_baml(baml).map_err(BamlError::from_anyhow) } } #[pymethods] impl FieldType { pub fn list(&self) -> FieldType { - self.inner.lock().unwrap().clone().as_list().into() + self.inner.clone().as_list().into() } pub fn optional(&self) -> FieldType { - self.inner.lock().unwrap().clone().as_optional().into() + self.inner.clone().as_optional().into() } pub fn __eq__(&self, other: &FieldType) -> bool { - self.inner.lock().unwrap().deref() == other.inner.lock().unwrap().deref() + self.inner == other.inner + } + + pub fn __str__(&self) -> String { + self.inner.to_string() + } + + pub fn __repr__(&self) -> String { + format!("Type[{}]", self.inner.to_string()) } } #[pymethods] impl EnumBuilder { - pub fn value(&self, name: &str) -> EnumValueBuilder { - self.inner.lock().unwrap().upsert_value(name).into() + pub fn add_value(&self, value: &str) -> PyResult { + let result = self + .inner + .add_value(value) + .map_err(BamlError::from_anyhow)?; + Ok(EnumValueBuilder { inner: result }) + } + + pub fn get_value(&self, value: &str) -> PyResult { + let result = self.inner.value(value).map_err(BamlError::from_anyhow)?; + Ok(EnumValueBuilder { inner: result }) + } + + pub fn remove_value(&self, value: &str) -> PyResult<()> { + self.inner + .remove_value(value) + .map_err(BamlError::from_anyhow) } #[pyo3(signature = (alias = None))] - pub fn alias(&self, alias: Option<&str>) -> Self { - self.inner.lock().unwrap().with_meta( - "alias", - alias.map_or(baml_types::BamlValue::Null, |s| { - BamlValue::String(s.to_string()) - }), - ); - self.inner.clone().into() + pub fn set_alias(&self, alias: Option<&str>) -> PyResult { + self.inner + .set_alias(alias) + .map_err(BamlError::from_anyhow)?; + Ok(self.inner.clone().into()) + } + + #[pyo3(signature = (description = None))] + pub fn set_description(&self, description: Option<&str>) -> PyResult { + self.inner + .set_description(description) + .map_err(BamlError::from_anyhow)?; + Ok(self.inner.clone().into()) + } + + pub fn alias(&self) -> PyResult> { + self.inner.alias().map_err(BamlError::from_anyhow) + } + + pub fn description(&self) -> PyResult> { + self.inner.description().map_err(BamlError::from_anyhow) } pub fn field(&self) -> FieldType { - baml_types::TypeIR::r#enum(&self.name).into() + baml_types::TypeIR::r#enum(&self.inner.enum_name).into() + } + + pub fn list_values(&self) -> PyResult> { + Ok(self + .inner + .list_values() + .map_err(BamlError::from_anyhow)? + .into_iter() + .map(|value| (value.value_name.clone(), EnumValueBuilder { inner: value })) + .collect()) + } + + #[getter] + pub fn source(&self) -> PyResult { + if self.inner.is_from_ast().map_err(BamlError::from_anyhow)? { + Ok("baml".to_string()) + } else { + Ok("dynamic".to_string()) + } } } #[pymethods] impl EnumValueBuilder { #[pyo3(signature = (alias = None))] - pub fn alias(&self, alias: Option<&str>) -> Self { - self.inner.lock().unwrap().with_meta( - "alias", - alias.map_or(baml_types::BamlValue::Null, |s| { - BamlValue::String(s.to_string()) - }), - ); - self.inner.clone().into() + pub fn set_alias(&self, alias: Option<&str>) -> PyResult { + self.inner + .set_alias(alias) + .map_err(BamlError::from_anyhow)?; + Ok(self.inner.clone().into()) } #[pyo3(signature = (skip = true))] - pub fn skip(&self, skip: Option) -> Self { - self.inner - .lock() - .unwrap() - .with_meta("skip", skip.map_or(BamlValue::Null, BamlValue::Bool)); - self.inner.clone().into() + pub fn set_skip(&self, skip: Option) -> PyResult { + self.inner.set_skip(skip).map_err(BamlError::from_anyhow)?; + Ok(self.inner.clone().into()) } #[pyo3(signature = (description = None))] - pub fn description(&self, description: Option<&str>) -> Self { - self.inner.lock().unwrap().with_meta( - "description", - description.map_or(baml_types::BamlValue::Null, |s| { - BamlValue::String(s.to_string()) - }), - ); - self.inner.clone().into() + pub fn set_description(&self, description: Option<&str>) -> PyResult { + self.inner + .set_description(description) + .map_err(BamlError::from_anyhow)?; + Ok(self.inner.clone().into()) + } + + pub fn alias(&self) -> PyResult> { + self.inner.alias().map_err(BamlError::from_anyhow) + } + + pub fn description(&self) -> PyResult> { + self.inner.description().map_err(BamlError::from_anyhow) + } + + pub fn skip(&self) -> PyResult { + self.inner.skip().map_err(BamlError::from_anyhow) + } + + #[getter] + pub fn source(&self) -> PyResult { + if self.inner.is_from_ast().map_err(BamlError::from_anyhow)? { + Ok("baml".to_string()) + } else { + Ok("dynamic".to_string()) + } } } #[pymethods] impl ClassBuilder { pub fn field(&self) -> FieldType { - baml_types::TypeIR::class(&self.name).into() + baml_types::TypeIR::class(&self.inner.class_name).into() } - pub fn list_properties(&self) -> Vec<(String, ClassPropertyBuilder)> { - self.inner - .lock() - .unwrap() - .list_properties_key_value() + pub fn list_properties(&self) -> PyResult> { + Ok(self + .inner + .list_properties() + .map_err(BamlError::from_anyhow)? .into_iter() - .map(|(name, prop_builder)| (name, prop_builder.into())) - .collect() + .map(|prop| { + ( + prop.property_name.clone(), + ClassPropertyBuilder { inner: prop }, + ) + }) + .collect()) } - pub fn remove_property(&self, name: &str) { - self.inner.lock().unwrap().remove_property(name); + pub fn remove_property(&self, name: &str) -> PyResult<()> { + self.inner + .remove_property(name) + .map_err(BamlError::from_anyhow) } - pub fn reset(&self) { - self.inner.lock().unwrap().reset(); + pub fn reset(&self) -> PyResult<()> { + self.inner.reset().map_err(BamlError::from_anyhow) } - pub fn property(&self, name: &str) -> ClassPropertyBuilder { - self.inner.lock().unwrap().upsert_property(name).into() + pub fn add_property(&self, name: &str, r#type: &FieldType) -> PyResult { + let result = self + .inner + .add_property(name, r#type.inner.clone(), true) + .map_err(BamlError::from_anyhow)?; + Ok(ClassPropertyBuilder { inner: result }) + } + + pub fn get_property(&self, name: &str) -> PyResult { + let result = self.inner.property(name).map_err(BamlError::from_anyhow)?; + Ok(ClassPropertyBuilder { inner: result }) + } + + #[getter] + pub fn source(&self) -> PyResult { + if self.inner.is_from_ast().map_err(BamlError::from_anyhow)? { + Ok("baml".to_string()) + } else { + Ok("dynamic".to_string()) + } + } + + #[pyo3(signature = (alias = None))] + pub fn set_alias(&self, alias: Option) -> PyResult { + self.inner + .set_alias(alias.as_deref()) + .map_err(BamlError::from_anyhow)?; + Ok(self.inner.clone().into()) + } + + pub fn alias(&self) -> PyResult> { + self.inner.alias().map_err(BamlError::from_anyhow) } } #[pymethods] impl ClassPropertyBuilder { - pub fn r#type(&self, r#type: &FieldType) -> Self { + pub fn set_type(&self, r#type: &FieldType) -> PyResult { self.inner - .lock() - .unwrap() - .set_type(r#type.inner.lock().unwrap().clone()); - self.inner.clone().into() + .set_type(r#type.inner.clone()) + .map_err(BamlError::from_anyhow)?; + Ok(Self { + inner: self.inner.clone(), + }) } - pub fn get_type(&self) -> PyResult { - self.inner - .lock() - .unwrap() - .r#type() - .map(FieldType::from) - .ok_or_else(|| BamlError::from_anyhow(anyhow::anyhow!( - "attempted to read a property that has no defined type, this is likely an internal bug" - ))) + pub fn r#type(&self) -> PyResult { + Ok(FieldType { + inner: self.inner.type_().map_err(BamlError::from_anyhow)?, + }) } #[pyo3(signature = (alias = None))] - pub fn alias(&self, alias: Option<&str>) -> Self { - self.inner.lock().unwrap().with_meta( - "alias", - alias.map_or(baml_types::BamlValue::Null, |s| { - BamlValue::String(s.to_string()) - }), - ); - self.inner.clone().into() + pub fn set_alias(&self, alias: Option<&str>) -> PyResult { + self.inner + .set_alias(alias) + .map_err(BamlError::from_anyhow)?; + Ok(Self { + inner: self.inner.clone(), + }) } #[pyo3(signature = (description = None))] - pub fn description(&self, description: Option<&str>) -> Self { - self.inner.lock().unwrap().with_meta( - "description", - description.map_or(baml_types::BamlValue::Null, |s| { - BamlValue::String(s.to_string()) - }), - ); - self.inner.clone().into() + pub fn set_description(&self, description: Option<&str>) -> PyResult { + self.inner + .set_description(description) + .map_err(BamlError::from_anyhow)?; + Ok(Self { + inner: self.inner.clone(), + }) + } + + pub fn alias(&self) -> PyResult> { + self.inner.alias().map_err(BamlError::from_anyhow) + } + + pub fn description(&self) -> PyResult> { + self.inner.description().map_err(BamlError::from_anyhow) + } + + #[getter] + pub fn source(&self) -> PyResult { + if self.inner.is_from_ast().map_err(BamlError::from_anyhow)? { + Ok("baml".to_string()) + } else { + Ok("dynamic".to_string()) + } } } diff --git a/engine/language_client_ruby/ext/ruby_ffi/src/types/type_builder.rs b/engine/language_client_ruby/ext/ruby_ffi/src/types/type_builder.rs index 4f3bd2d781..90fc45bfe3 100644 --- a/engine/language_client_ruby/ext/ruby_ffi/src/types/type_builder.rs +++ b/engine/language_client_ruby/ext/ruby_ffi/src/types/type_builder.rs @@ -124,9 +124,10 @@ impl TypeBuilder { baml: String, runtime: &crate::BamlRuntimeFfi, ) -> Result<()> { - rb_self - .inner - .add_baml(&baml, runtime.inner.internal()) + // Create an IR-aware type builder and use its add_baml method + let ir_type_builder = runtime.inner.internal().create_type_builder(); + ir_type_builder + .add_baml(&baml) .map_err(|e| magnus::Error::new(ruby.exception_runtime_error(), e.to_string())) } diff --git a/engine/language_client_typescript/Cargo.toml b/engine/language_client_typescript/Cargo.toml index ed17ed3fd9..61aba6d064 100644 --- a/engine/language_client_typescript/Cargo.toml +++ b/engine/language_client_typescript/Cargo.toml @@ -25,6 +25,7 @@ baml-ids.workspace = true baml-types.workspace = true baml-log.workspace = true baml-runtime = { path = "../baml-runtime", features = ["internal"] } +baml-type-builder = { path = "../baml-lib/type-builder" } dashmap.workspace = true env_logger.workspace = true futures.workspace = true diff --git a/engine/language_client_typescript/native.d.ts b/engine/language_client_typescript/native.d.ts index 328c8c4c06..f56fbeebc0 100644 --- a/engine/language_client_typescript/native.d.ts +++ b/engine/language_client_typescript/native.d.ts @@ -61,18 +61,27 @@ export declare class BamlVideo { } export declare class ClassBuilder { - listProperties(): unknown[] + field(): FieldType + listProperties(): Array<[string, ClassPropertyBuilder]> removeProperty(name: string): void reset(): void - field(): FieldType - property(name: string): ClassPropertyBuilder + getProperty(name: string): ClassPropertyBuilder + addProperty(name: string, fieldType: FieldType): ClassPropertyBuilder + setAlias(alias?: string | undefined | null): ClassBuilder + setDescription(description?: string | undefined | null): ClassBuilder + alias(): string | null + description(): string | null + source(): 'baml' | 'dynamic' } export declare class ClassPropertyBuilder { setType(fieldType: FieldType): ClassPropertyBuilder getType(): FieldType - alias(alias?: string | undefined | null): ClassPropertyBuilder - description(description?: string | undefined | null): ClassPropertyBuilder + setAlias(alias?: string | undefined | null): ClassPropertyBuilder + setDescription(description?: string | undefined | null): ClassPropertyBuilder + alias(): string | null + description(): string | null + source(): 'baml' | 'dynamic' } export declare class ClientRegistry { @@ -93,15 +102,26 @@ export declare class Collector { } export declare class EnumBuilder { - value(name: string): EnumValueBuilder - alias(alias?: string | undefined | null): EnumBuilder + addValue(name: string): EnumValueBuilder + getValue(name: string): EnumValueBuilder + removeValue(name: string): void + setAlias(alias?: string | undefined | null): EnumBuilder + setDescription(description?: string | undefined | null): EnumBuilder + alias(): string | null + description(): string | null field(): FieldType + listValues(): Array<[string, EnumValueBuilder]> + source(): 'baml' | 'dynamic' } export declare class EnumValueBuilder { - alias(alias?: string | undefined | null): EnumValueBuilder - skip(skip?: boolean | undefined | null): EnumValueBuilder - description(description?: string | undefined | null): EnumValueBuilder + setAlias(alias?: string | undefined | null): EnumValueBuilder + setSkip(skip?: boolean | undefined | null): EnumValueBuilder + setDescription(description?: string | undefined | null): EnumValueBuilder + alias(): string | null + description(): string | null + skip(): boolean + source(): 'baml' | 'dynamic' } export declare class FieldType { @@ -119,7 +139,7 @@ export declare class FunctionLog { get usage(): Usage get calls(): (LLMCall | LLMStreamCall)[] get rawLlmResponse(): string | null - get selectedCall(): unknown + get selectedCall(): LLMCall | LLMStreamCall | null } export declare class FunctionResult { @@ -219,9 +239,11 @@ export declare class TraceStats { } export declare class TypeBuilder { - constructor() + static new(runtime: BamlRuntime): TypeBuilder reset(): void + addEnum(name: string): EnumBuilder getEnum(name: string): EnumBuilder + addClass(name: string): ClassBuilder getClass(name: string): ClassBuilder list(inner: FieldType): FieldType optional(inner: FieldType): FieldType @@ -235,7 +257,7 @@ export declare class TypeBuilder { null(): FieldType map(key: FieldType, value: FieldType): FieldType union(types: Array): FieldType - addBaml(baml: string, rt: BamlRuntime): void + addBaml(baml: string): void toString(): string } diff --git a/engine/language_client_typescript/src/types/log_collector.rs b/engine/language_client_typescript/src/types/log_collector.rs index 1edc964008..094fda3bff 100644 --- a/engine/language_client_typescript/src/types/log_collector.rs +++ b/engine/language_client_typescript/src/types/log_collector.rs @@ -200,7 +200,7 @@ impl FunctionLog { guarded.raw_llm_response() } - #[napi(getter)] + #[napi(getter, ts_return_type = "LLMCall | LLMStreamCall | null")] pub fn selected_call<'e>(&self, env: &'e Env) -> Result> { let calls = self.inner.lock().unwrap().calls(); let found = calls.into_iter().find_map(|call| match call { diff --git a/engine/language_client_typescript/src/types/type_builder.rs b/engine/language_client_typescript/src/types/type_builder.rs index c0411c9b21..7aec15141e 100644 --- a/engine/language_client_typescript/src/types/type_builder.rs +++ b/engine/language_client_typescript/src/types/type_builder.rs @@ -2,7 +2,11 @@ use std::{collections::BTreeMap, ops::Deref}; // This file provides the native bindings between our Rust implementation and TypeScript // We use NAPI-RS to expose Rust functionality to JavaScript/TypeScript -use baml_runtime::type_builder::{self, WithMeta}; +use baml_type_builder::{ + ClassBuilder as BamlClassBuilder, ClassPropertyBuilder as BamlClassPropertyBuilder, + EnumBuilder as BamlEnumBuilder, EnumValueBuilder as BamlEnumValueBuilder, + TypeBuilder as BamlTypeBuilder, +}; use baml_types::{ir_type::UnionConstructor, BamlValue}; use napi::{ bindgen_prelude::{Array, JavaScriptClassExt}, @@ -12,44 +16,39 @@ use napi_derive::napi; // Create TypeScript-compatible wrappers for our Rust types // These macros generate the necessary code for TypeScript interop -crate::lang_wrapper!(TypeBuilder, type_builder::TypeBuilder); +crate::lang_wrapper!( + TypeBuilder, + BamlTypeBuilder +); -// Thread-safe wrapper for EnumBuilder with name tracking -// The sync_thread_safe attribute ensures safe concurrent access from TypeScript -crate::lang_wrapper!(EnumBuilder, type_builder::EnumBuilder, sync_thread_safe, name: String); +// Thread-safe wrapper for EnumBuilder +crate::lang_wrapper!( + EnumBuilder, + BamlEnumBuilder +); -// Thread-safe wrapper for ClassBuilder with name tracking -// Enables safe TypeScript interop with class definitions -crate::lang_wrapper!(ClassBuilder, type_builder::ClassBuilder, sync_thread_safe, name: String); +// Thread-safe wrapper for ClassBuilder +crate::lang_wrapper!( + ClassBuilder, + BamlClassBuilder +); // Thread-safe wrapper for EnumValueBuilder -// Ensures enum value definitions can be safely accessed across threads crate::lang_wrapper!( EnumValueBuilder, - type_builder::EnumValueBuilder, - sync_thread_safe + BamlEnumValueBuilder ); // Thread-safe wrapper for ClassPropertyBuilder -// Enables concurrent access to class property definitions crate::lang_wrapper!( ClassPropertyBuilder, - type_builder::ClassPropertyBuilder, - sync_thread_safe + BamlClassPropertyBuilder ); // Thread-safe wrapper for FieldType // Core type system representation with thread-safety guarantees crate::lang_wrapper!(FieldType, baml_types::TypeIR, sync_thread_safe); -// Implement Default for TypeBuilder to allow easy instantiation -// This enables idiomatic Rust usage while maintaining TypeScript compatibility -impl Default for TypeBuilder { - fn default() -> Self { - Self::new() - } -} - // note: you may notice a rust-analyzer warning in vs code when working with this file. // the warning "did not find struct napitypebuilder parsed before expand #[napi] for impl" // is a known false positive that occurs due to how rust-analyzer processes macro state. @@ -61,12 +60,12 @@ impl Default for TypeBuilder { // // ref: // https://github.com/napi-rs/napi-rs/issues/1630 - +// A complex struct that cannot be exposed to JavaScript directly. #[napi] impl TypeBuilder { - #[napi(constructor)] - pub fn new() -> Self { - let tb = type_builder::TypeBuilder::new(); + #[napi(factory)] + pub fn new(runtime: &crate::BamlRuntime) -> Self { + let tb = BamlTypeBuilder::new(runtime.inner.internal().clone()); tb.into() } @@ -76,19 +75,39 @@ impl TypeBuilder { } #[napi] - pub fn get_enum(&self, name: String) -> EnumBuilder { - EnumBuilder { - inner: self.inner.upsert_enum(&name), - name, - } + pub fn add_enum(&self, name: String) -> napi::Result { + let result = self + .inner + .add_enum(&name) + .map_err(crate::errors::from_anyhow_error)?; + Ok(EnumBuilder { inner: result }) } #[napi] - pub fn get_class(&self, name: String) -> ClassBuilder { - ClassBuilder { - inner: self.inner.upsert_class(&name), - name, - } + pub fn get_enum(&self, name: String) -> napi::Result { + let result = self + .inner + .r#enum(&name) + .map_err(crate::errors::from_anyhow_error)?; + Ok(EnumBuilder { inner: result }) + } + + #[napi] + pub fn add_class(&self, name: String) -> napi::Result { + let result = self + .inner + .add_class(&name) + .map_err(crate::errors::from_anyhow_error)?; + Ok(ClassBuilder { inner: result }) + } + + #[napi] + pub fn get_class(&self, name: String) -> napi::Result { + let result = self + .inner + .class(&name) + .map_err(crate::errors::from_anyhow_error)?; + Ok(ClassBuilder { inner: result }) } #[napi] @@ -162,9 +181,9 @@ impl TypeBuilder { } #[napi] - pub fn add_baml(&self, baml: String, rt: &crate::BamlRuntime) -> napi::Result<()> { + pub fn add_baml(&self, baml: String) -> napi::Result<()> { self.inner - .add_baml(&baml, rt.inner.internal()) + .add_baml(&baml) .map_err(crate::errors::from_anyhow_error) } @@ -195,73 +214,180 @@ impl FieldType { #[napi] impl EnumBuilder { #[napi] - pub fn value(&self, name: String) -> EnumValueBuilder { - self.inner.lock().unwrap().upsert_value(&name).into() + pub fn add_value(&self, name: String) -> napi::Result { + let result = self + .inner + .add_value(&name) + .map_err(crate::errors::from_anyhow_error)?; + Ok(EnumValueBuilder { inner: result }) + } + + #[napi] + pub fn get_value(&self, name: String) -> napi::Result { + let result = self + .inner + .value(&name) + .map_err(crate::errors::from_anyhow_error)?; + Ok(EnumValueBuilder { inner: result }) + } + + #[napi] + pub fn remove_value(&self, name: String) -> napi::Result<()> { + self.inner + .remove_value(&name) + .map_err(crate::errors::from_anyhow_error) } #[napi] - pub fn alias(&self, alias: Option) -> Self { - self.inner.lock().unwrap().with_meta( - "alias", - alias.map_or(baml_types::BamlValue::Null, BamlValue::String), - ); - self.inner.clone().into() + pub fn set_alias(&self, alias: Option) -> napi::Result { + self.inner + .set_alias(alias.as_deref()) + .map_err(crate::errors::from_anyhow_error)?; + Ok(self.inner.clone().into()) + } + + #[napi] + pub fn set_description(&self, description: Option) -> napi::Result { + self.inner + .set_description(description.as_deref()) + .map_err(crate::errors::from_anyhow_error)?; + Ok(self.inner.clone().into()) + } + + #[napi] + pub fn alias(&self) -> napi::Result> { + self.inner.alias().map_err(crate::errors::from_anyhow_error) + } + + #[napi] + pub fn description(&self) -> napi::Result> { + self.inner + .description() + .map_err(crate::errors::from_anyhow_error) } #[napi] pub fn field(&self) -> FieldType { - baml_types::TypeIR::r#enum(&self.name).into() + baml_types::TypeIR::r#enum(&self.inner.enum_name).into() + } + + #[napi(ts_return_type = "Array<[string, EnumValueBuilder]>")] + pub fn list_values<'e>(&self, env: &'e Env) -> napi::Result> { + let values = self + .inner + .list_values() + .map_err(crate::errors::from_anyhow_error)? + .into_iter() + .map(|v| (v.value_name.clone(), EnumValueBuilder { inner: v })); + + let mut js_array = env.create_array(values.len() as u32)?; + for (i, (name, val_builder)) in values.enumerate() { + let mut tuple = env.create_array(2)?; + tuple.set(0, env.create_string(&name)?)?; + tuple.set(1, val_builder.into_instance(env)?)?; + js_array.set(i as u32, tuple)?; + } + Ok(js_array) + } + + #[napi(ts_return_type = "'baml' | 'dynamic'")] + pub fn source(&self) -> napi::Result { + let from_ast = self + .inner + .is_from_ast() + .map_err(crate::errors::from_anyhow_error)?; + Ok(if from_ast { + "baml".to_string() + } else { + "dynamic".to_string() + }) } } #[napi] impl EnumValueBuilder { #[napi] - pub fn alias(&self, alias: Option) -> Self { - self.inner.lock().unwrap().with_meta( - "alias", - alias.map_or(baml_types::BamlValue::Null, BamlValue::String), - ); - self.inner.clone().into() + pub fn set_alias(&self, alias: Option) -> napi::Result { + self.inner + .set_alias(alias.as_deref()) + .map_err(crate::errors::from_anyhow_error)?; + Ok(self.inner.clone().into()) + } + + #[napi] + pub fn set_skip(&self, skip: Option) -> napi::Result { + self.inner + .set_skip(skip) + .map_err(crate::errors::from_anyhow_error)?; + Ok(self.inner.clone().into()) } #[napi] - pub fn skip(&self, skip: Option) -> Self { + pub fn set_description(&self, description: Option) -> napi::Result { self.inner - .lock() - .unwrap() - .with_meta("skip", skip.map_or(BamlValue::Null, BamlValue::Bool)); - self.inner.clone().into() + .set_description(description.as_deref()) + .map_err(crate::errors::from_anyhow_error)?; + Ok(self.inner.clone().into()) } #[napi] - pub fn description(&self, description: Option) -> Self { - self.inner.lock().unwrap().with_meta( - "description", - description.map_or(baml_types::BamlValue::Null, BamlValue::String), - ); - self.inner.clone().into() + pub fn alias(&self) -> napi::Result> { + self.inner.alias().map_err(crate::errors::from_anyhow_error) + } + + #[napi] + pub fn description(&self) -> napi::Result> { + self.inner + .description() + .map_err(crate::errors::from_anyhow_error) + } + + #[napi] + pub fn skip(&self) -> napi::Result { + self.inner.skip().map_err(crate::errors::from_anyhow_error) + } + + #[napi(ts_return_type = "'baml' | 'dynamic'")] + pub fn source(&self) -> napi::Result { + let from_ast = self + .inner + .is_from_ast() + .map_err(crate::errors::from_anyhow_error)?; + Ok(if from_ast { + "baml".to_string() + } else { + "dynamic".to_string() + }) } } #[napi] impl ClassBuilder { #[napi] + pub fn field(&self) -> FieldType { + baml_types::TypeIR::class(&self.inner.class_name).into() + } + + #[napi(ts_return_type = "Array<[string, ClassPropertyBuilder]>")] pub fn list_properties<'e>(&self, env: &'e Env) -> napi::Result> { let properties = self .inner - .lock() - .unwrap() - .list_properties_key_value() + .list_properties() + .map_err(crate::errors::from_anyhow_error)? .into_iter() - .map(|(name, prop)| (name, ClassPropertyBuilder::from(prop))); + .map(|prop| { + ( + prop.property_name.clone(), + ClassPropertyBuilder { inner: prop }, + ) + }); let mut js_array = env.create_array(properties.len() as u32)?; for (i, (name, prop_builder)) in properties.enumerate() { let mut tuple = env.create_array(2)?; tuple.set(0, env.create_string(&name)?)?; - tuple.set(1, prop_builder.into_instance(env)?)?; + tuple.set(1, prop_builder.into_instance(&env)?)?; js_array.set(i as u32, tuple)?; } @@ -269,64 +395,146 @@ impl ClassBuilder { } #[napi] - pub fn remove_property(&self, name: String) { - self.inner.lock().unwrap().remove_property(&name); + pub fn remove_property(&self, name: String) -> napi::Result<()> { + self.inner + .remove_property(&name) + .map_err(crate::errors::from_anyhow_error) } #[napi] - pub fn reset(&self) { - self.inner.lock().unwrap().reset(); + pub fn reset(&self) -> napi::Result<()> { + self.inner.reset().map_err(crate::errors::from_anyhow_error) } #[napi] - pub fn field(&self) -> FieldType { - baml_types::TypeIR::class(&self.name).into() + pub fn get_property(&self, name: String) -> napi::Result { + let result = self + .inner + .property(&name) + .map_err(crate::errors::from_anyhow_error)?; + Ok(ClassPropertyBuilder { inner: result }) } #[napi] - pub fn property(&self, name: String) -> ClassPropertyBuilder { - self.inner.lock().unwrap().upsert_property(&name).into() + pub fn add_property( + &self, + name: String, + field_type: &FieldType, + ) -> napi::Result { + let result = self + .inner + .add_property(&name, field_type.inner.lock().unwrap().clone(), true) + .map_err(crate::errors::from_anyhow_error)?; + Ok(ClassPropertyBuilder { inner: result }) + } + + #[napi] + pub fn set_alias(&self, alias: Option) -> napi::Result { + self.inner + .set_alias(alias.as_deref()) + .map_err(crate::errors::from_anyhow_error)?; + Ok(self.inner.clone().into()) + } + + #[napi] + pub fn set_description(&self, description: Option) -> napi::Result { + self.inner + .set_description(description.as_deref()) + .map_err(crate::errors::from_anyhow_error)?; + Ok(self.inner.clone().into()) + } + + #[napi] + pub fn alias(&self) -> napi::Result> { + self.inner.alias().map_err(crate::errors::from_anyhow_error) + } + + #[napi] + pub fn description(&self) -> napi::Result> { + self.inner + .description() + .map_err(crate::errors::from_anyhow_error) + } + + #[napi(ts_return_type = "'baml' | 'dynamic'")] + pub fn source(&self) -> napi::Result { + let from_ast = self + .inner + .is_from_ast() + .map_err(crate::errors::from_anyhow_error)?; + Ok(if from_ast { + "baml".to_string() + } else { + "dynamic".to_string() + }) } } #[napi] impl ClassPropertyBuilder { #[napi] - pub fn set_type(&self, field_type: &FieldType) -> Self { + pub fn set_type(&self, field_type: &FieldType) -> napi::Result { self.inner - .lock() - .unwrap() - .set_type(field_type.inner.lock().unwrap().clone()); - self.inner.clone().into() + .set_type(field_type.inner.lock().unwrap().clone()) + .map_err(crate::errors::from_anyhow_error)?; + Ok(Self { + inner: self.inner.clone(), + }) } #[napi] pub fn get_type(&self) -> napi::Result { + Ok(FieldType { + inner: std::sync::Arc::new(std::sync::Mutex::new( + self.inner + .type_() + .map_err(crate::errors::from_anyhow_error)?, + )), + }) + } + + #[napi] + pub fn set_alias(&self, alias: Option) -> napi::Result { + self.inner + .set_alias(alias.as_deref()) + .map_err(crate::errors::from_anyhow_error)?; + Ok(Self { + inner: self.inner.clone(), + }) + } + + #[napi] + pub fn set_description(&self, description: Option) -> napi::Result { self.inner - .lock() - .unwrap() - .r#type() - .map(FieldType::from) - .ok_or_else(|| crate::errors::from_anyhow_error(anyhow::anyhow!( - "attempted to read a property that has no defined type, this is likely an internal bug" - ))) + .set_description(description.as_deref()) + .map_err(crate::errors::from_anyhow_error)?; + Ok(Self { + inner: self.inner.clone(), + }) } #[napi] - pub fn alias(&self, alias: Option) -> Self { - self.inner.lock().unwrap().with_meta( - "alias", - alias.map_or(baml_types::BamlValue::Null, BamlValue::String), - ); - self.inner.clone().into() + pub fn alias(&self) -> napi::Result> { + self.inner.alias().map_err(crate::errors::from_anyhow_error) } #[napi] - pub fn description(&self, description: Option) -> Self { - self.inner.lock().unwrap().with_meta( - "description", - description.map_or(baml_types::BamlValue::Null, BamlValue::String), - ); - self.inner.clone().into() + pub fn description(&self) -> napi::Result> { + self.inner + .description() + .map_err(crate::errors::from_anyhow_error) + } + + #[napi(ts_return_type = "'baml' | 'dynamic'")] + pub fn source(&self) -> napi::Result { + let from_ast = self + .inner + .is_from_ast() + .map_err(crate::errors::from_anyhow_error)?; + Ok(if from_ast { + "baml".to_string() + } else { + "dynamic".to_string() + }) } } diff --git a/engine/language_client_typescript/type_builder.d.ts b/engine/language_client_typescript/type_builder.d.ts index 015bb3d8e4..2ab30224a3 100644 --- a/engine/language_client_typescript/type_builder.d.ts +++ b/engine/language_client_typescript/type_builder.d.ts @@ -1,22 +1,14 @@ -import { ClassBuilder as _ClassBuilder, EnumBuilder as _EnumBuilder, ClassPropertyBuilder as _ClassPropertyBuilder, EnumValueBuilder, FieldType, TypeBuilder as _TypeBuilder, BamlRuntime } from './native'; -type IsLiteral = string extends T ? false : true; -type NameOf = IsLiteral extends true ? T : 'DynamicType'; -type CheckNever = [T] extends [never] ? `Error: Attempt to add value '${Value}' which is already a part of '${NameOf}'.` : T; -type ExcludeFrom = T extends U ? never : T; -type RestrictNot = IsLiteral extends true ? CheckNever, Name, Value> : Value; +import { ClassBuilder as _ClassBuilder, EnumBuilder as _EnumBuilder, ClassPropertyBuilder as _ClassPropertyBuilder, EnumValueBuilder as _EnumValueBuilder, FieldType, TypeBuilder as _TypeBuilder, BamlRuntime } from "../native"; +type IfDynamic = D extends true ? T : F; +type MustBeDynamic = `'${Name}.${Method}' is only allowed when ${Name} is marked @@dynamic.`; export declare class TypeBuilder { private tb; - protected classes: Set; - protected enums: Set; - protected runtime: BamlRuntime; - constructor({ classes, enums, runtime }: { - classes: Set; - enums: Set; + constructor({ runtime }: { runtime: BamlRuntime; }); - reset(): void; _tb(): _TypeBuilder; - null(): FieldType; + reset(): void; + toString(): string; string(): FieldType; literalString(value: string): FieldType; literalInt(value: number): FieldType; @@ -25,66 +17,102 @@ export declare class TypeBuilder { float(): FieldType; bool(): FieldType; list(type: FieldType): FieldType; + null(): FieldType; map(keyType: FieldType, valueType: FieldType): FieldType; union(types: FieldType[]): FieldType; - classViewer(name: Name, properties: Properties[]): ClassViewer; - classBuilder(name: Name, properties: Properties[]): ClassBuilder; - enumViewer(name: Name, values: Values[]): EnumViewer; - enumBuilder(name: Name, values: Values[]): EnumBuilder; - addClass(name: Name): ClassBuilder; - addEnum(name: Name): EnumBuilder; + addClass(name: string): ClassBuilder; + getClass(name: Name): ClassBuilder; + addEnum(name: string): EnumBuilder; + getEnum(name: Name): EnumBuilder; addBaml(baml: string): void; } -export declare class ClassAst { - protected properties: Set; - protected bldr: _ClassBuilder; - constructor(tb: _TypeBuilder, name: ClassName, properties?: Set); - listProperties(): Record; +export declare class ClassBuilder { + private readonly cb; + constructor(cb: _ClassBuilder); type(): FieldType; -} -export declare class ClassViewer extends ClassAst { - constructor(tb: _TypeBuilder, name: ClassName, properties?: Set); - listProperties(): Array<[string, ClassPropertyViewer]>; - property(name: string): ClassPropertyViewer; -} -export declare class ClassBuilder extends ClassAst { - constructor(tb: _TypeBuilder, name: ClassName, properties?: Set); - addProperty(name: RestrictNot, type: FieldType): ClassPropertyBuilder; - listProperties(): Array<[string, ClassPropertyBuilder]>; - removeProperty(name: string): void; + listProperties(): Array<[ + IfDynamic, + ClassPropertyBuilder, Dynamic> + ]>; reset(): void; - property(name: string): ClassPropertyBuilder; -} -declare class ClassPropertyViewer { - constructor(); -} -declare class ClassPropertyBuilder { - private bldr; - constructor(bldr: _ClassPropertyBuilder); - getType(): FieldType; - setType(type: FieldType): ClassPropertyBuilder; - alias(alias: string | null): ClassPropertyBuilder; - description(description: string | null): ClassPropertyBuilder; + getProperty(name: PropertyName): ClassPropertyBuilder; + getProperty(name: IfDynamic): ClassPropertyBuilder; + /** + * addProperty: + * - only allowed if Class marked with @@dynamic + */ + addProperty(this: Dynamic extends true ? ClassBuilder : MustBeDynamic, name: string, fieldType: FieldType): ClassPropertyBuilder; + /** + * removeProperty: + * - only allowed if Class marked with @@dynamic + */ + removeProperty(this: Dynamic extends true ? ClassBuilder : MustBeDynamic, name: IfDynamic): void; + /** + * setAlias: + * - only allowed if Class marked with @@dynamic + */ + setAlias(this: Dynamic extends true ? ClassBuilder : MustBeDynamic, alias: string | null): ClassBuilder; + /** + * setDescription: + * - only allowed if Class marked with @@dynamic + */ + setDescription(this: Dynamic extends true ? ClassBuilder : MustBeDynamic, description: string | null): ClassBuilder; + alias(): string | null; + description(): string | null; + source(): "baml" | "dynamic"; } -export declare class EnumAst { - protected values: Set; - protected bldr: _EnumBuilder; - constructor(tb: _TypeBuilder, name: EnumName, values?: Set); +export declare class EnumBuilder { + private readonly eb; + constructor(eb: _EnumBuilder); type(): FieldType; + listValues(): Array<[ + IfDynamic, + EnumValueBuilder, Dynamic> + ]>; + /** + * addValue: + * - only allowed if Enum marked with @@dynamic + */ + addValue(this: Dynamic extends true ? EnumBuilder : MustBeDynamic, name: string): EnumValueBuilder; + getValue(name: ValueName): EnumValueBuilder; + getValue(name: IfDynamic): EnumValueBuilder; + /** + * removeValue: + * - only allowed if Enum marked with @@dynamic + */ + removeValue(this: Dynamic extends true ? EnumBuilder : MustBeDynamic, name: IfDynamic): EnumBuilder; + /** + * setAlias: + * - only allowed if Enum marked with @@dynamic + */ + setAlias(this: Dynamic extends true ? EnumBuilder : MustBeDynamic, alias: IfDynamic): EnumBuilder; + /** + * setDescription: + * - only allowed if Enum marked with @@dynamic + */ + setDescription(this: Dynamic extends true ? EnumBuilder : MustBeDynamic, description: IfDynamic): EnumBuilder; + alias(): string | null; + description(): string | null; } -export declare class EnumViewer extends EnumAst { - constructor(tb: _TypeBuilder, name: EnumName, values?: Set); - listValues(): Array<[string, EnumValueViewer]>; - value(name: string): EnumValueViewer; -} -export declare class EnumValueViewer { - constructor(); +declare class ClassPropertyBuilder { + private readonly cpb; + constructor(cpb: _ClassPropertyBuilder); + type(): FieldType; + setType(this: Dynamic extends true ? ClassPropertyBuilder : MustBeDynamic<`${ClassName}.${PropertyName}`, "setType">, fieldType: FieldType): ClassPropertyBuilder; + setAlias(this: Dynamic extends true ? ClassPropertyBuilder : MustBeDynamic<`${ClassName}.${PropertyName}`, "setAlias">, alias: string | null): ClassPropertyBuilder; + setDescription(this: Dynamic extends true ? ClassPropertyBuilder : MustBeDynamic<`${ClassName}.${PropertyName}`, "setDescription">, description: string | null): ClassPropertyBuilder; + alias(): string | null; + description(): string | null; + source(): "baml" | "dynamic"; } -export declare class EnumBuilder extends EnumAst { - constructor(tb: _TypeBuilder, name: EnumName, values?: Set); - addValue(name: RestrictNot): EnumValueBuilder; - listValues(): Array<[string, EnumValueBuilder]>; - value(name: string): EnumValueBuilder; +export declare class EnumValueBuilder { + private readonly evb; + constructor(evb: _EnumValueBuilder); + setAlias(this: Dynamic extends true ? EnumValueBuilder : MustBeDynamic<`${EnumName}.${ValueName}`, "setAlias">, alias: string | null): EnumValueBuilder; + setDescription(this: Dynamic extends true ? EnumValueBuilder : MustBeDynamic<`${EnumName}.${ValueName}`, "setDescription">, description: string | null): EnumValueBuilder; + alias(): string | null; + description(): string | null; + source(): "baml" | "dynamic"; } export {}; //# sourceMappingURL=type_builder.d.ts.map \ No newline at end of file diff --git a/engine/language_client_typescript/type_builder.d.ts.map b/engine/language_client_typescript/type_builder.d.ts.map index 7741558e30..c5a60fa205 100644 --- a/engine/language_client_typescript/type_builder.d.ts.map +++ b/engine/language_client_typescript/type_builder.d.ts.map @@ -1 +1 @@ -{"version":3,"file":"type_builder.d.ts","sourceRoot":"","sources":["typescript_src/type_builder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,IAAI,aAAa,EAC7B,WAAW,IAAI,YAAY,EAC3B,oBAAoB,IAAI,qBAAqB,EAC7C,gBAAgB,EAChB,SAAS,EACT,WAAW,IAAI,YAAY,EAC3B,WAAW,EACZ,MAAM,UAAU,CAAA;AAEjB,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,IAAI,MAAM,SAAS,CAAC,GAAG,KAAK,GAAG,IAAI,CAAA;AAClE,KAAK,MAAM,CAAC,CAAC,SAAS,MAAM,IAAI,SAAS,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,aAAa,CAAA;AAC7E,KAAK,UAAU,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,EAAE,KAAK,SAAS,MAAM,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACnF,gCAAgC,KAAK,iCAAiC,MAAM,CAAC,QAAQ,CAAC,IAAI,GAC1F,CAAC,CAAA;AACL,KAAK,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,GAAG,CAAC,CAAA;AAChD,KAAK,WAAW,CAAC,IAAI,SAAS,MAAM,EAAE,KAAK,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,SAAS,CAAC,CAAC,CAAC,SAAS,IAAI,GACrG,UAAU,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,GAC9C,KAAK,CAAA;AAET,qBAAa,WAAW;IACtB,OAAO,CAAC,EAAE,CAAc;IACxB,SAAS,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC9B,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC5B,SAAS,CAAC,OAAO,EAAE,WAAW,CAAA;gBAElB,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;QAAE,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAAC,OAAO,EAAE,WAAW,CAAA;KAAE;IAO3G,KAAK,IAAI,IAAI;IAIb,GAAG,IAAI,YAAY;IAInB,IAAI,IAAI,SAAS;IAIjB,MAAM,IAAI,SAAS;IAInB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS;IAIvC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS;IAIpC,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS;IAItC,GAAG,IAAI,SAAS;IAIhB,KAAK,IAAI,SAAS;IAIlB,IAAI,IAAI,SAAS;IAIjB,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS;IAIhC,GAAG,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS;IAIxD,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,SAAS;IAIpC,WAAW,CAAC,IAAI,SAAS,MAAM,EAAE,UAAU,SAAS,MAAM,EACxD,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,UAAU,EAAE,GACvB,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC;IAIhC,YAAY,CAAC,IAAI,SAAS,MAAM,EAAE,UAAU,SAAS,MAAM,EACzD,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,UAAU,EAAE,GACvB,YAAY,CAAC,IAAI,EAAE,UAAU,CAAC;IAIjC,UAAU,CAAC,IAAI,SAAS,MAAM,EAAE,MAAM,SAAS,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC;IAI9G,WAAW,CAAC,IAAI,SAAS,MAAM,EAAE,MAAM,SAAS,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC;IAIhH,QAAQ,CAAC,IAAI,SAAS,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC;IAW7D,OAAO,CAAC,IAAI,SAAS,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC;IAW3D,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAG5B;AAED,qBAAa,QAAQ,CAAC,SAAS,SAAS,MAAM,EAAE,UAAU,SAAS,MAAM,GAAG,MAAM;IAM9E,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,GAAG,MAAM,CAAC;IALhD,SAAS,CAAC,IAAI,EAAE,aAAa,CAAA;gBAG3B,EAAE,EAAE,YAAY,EAChB,IAAI,EAAE,SAAS,EACL,UAAU,GAAE,GAAG,CAAC,UAAU,GAAG,MAAM,CAAa;IAK5D,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAIlD,IAAI,IAAI,SAAS;CAGlB;AAED,qBAAa,WAAW,CAAC,SAAS,SAAS,MAAM,EAAE,UAAU,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,QAAQ,CACrG,SAAS,EACT,UAAU,CACX;gBACa,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,GAAE,GAAG,CAAC,UAAU,GAAG,MAAM,CAAa;IAI/F,cAAc,IAAI,KAAK,CAAC,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAItD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB;CAM5C;AAED,qBAAa,YAAY,CAAC,SAAS,SAAS,MAAM,EAAE,UAAU,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,QAAQ,CACtG,SAAS,EACT,UAAU,CACX;gBACa,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,GAAE,GAAG,CAAC,UAAU,GAAG,MAAM,CAAa;IAI/F,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,SAAS,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,IAAI,EAAE,SAAS,GAAG,oBAAoB;IAQjH,cAAc,IAAI,KAAK,CAAC,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAIvD,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKlC,KAAK,IAAI,IAAI;IAIb,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB;CAM7C;AAED,cAAM,mBAAmB;;CAExB;AAED,cAAM,oBAAoB;IACxB,OAAO,CAAC,IAAI,CAAuB;gBAEvB,IAAI,EAAE,qBAAqB;IAIvC,OAAO,IAAI,SAAS;IAIpB,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,oBAAoB;IAK9C,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,oBAAoB;IAKjD,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,oBAAoB;CAI9D;AAED,qBAAa,OAAO,CAAC,QAAQ,SAAS,MAAM,EAAE,MAAM,SAAS,MAAM,GAAG,MAAM;IAMxE,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC;IALxC,SAAS,CAAC,IAAI,EAAE,YAAY,CAAA;gBAG1B,EAAE,EAAE,YAAY,EAChB,IAAI,EAAE,QAAQ,EACJ,MAAM,GAAE,GAAG,CAAC,MAAM,GAAG,MAAM,CAAa;IAKpD,IAAI,IAAI,SAAS;CAGlB;AAED,qBAAa,UAAU,CAAC,QAAQ,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC1F,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAE,GAAG,CAAC,CAAC,GAAG,MAAM,CAAa;IAIjF,UAAU,IAAI,KAAK,CAAC,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAI9C,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe;CAMrC;AAED,qBAAa,eAAe;;CAE3B;AAED,qBAAa,WAAW,CAAC,QAAQ,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC3F,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAE,GAAG,CAAC,CAAC,GAAG,MAAM,CAAa;IAIjF,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,gBAAgB;IAQ/E,UAAU,IAAI,KAAK,CAAC,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAI/C,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB;CAGtC"} \ No newline at end of file +{"version":3,"file":"type_builder.d.ts","sourceRoot":"","sources":["typescript_src/type_builder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,IAAI,aAAa,EAC7B,WAAW,IAAI,YAAY,EAC3B,oBAAoB,IAAI,qBAAqB,EAC7C,gBAAgB,IAAI,iBAAiB,EACrC,SAAS,EACT,WAAW,IAAI,YAAY,EAC3B,WAAW,EACZ,MAAM,WAAW,CAAC;AAiBnB,KAAK,SAAS,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;AAEzE,KAAK,aAAa,CAChB,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,MAAM,IACnB,IAAI,IAAI,IAAI,MAAM,0BAA0B,IAAI,uBAAuB,CAAC;AAE5E,qBAAa,WAAW;IACtB,OAAO,CAAC,EAAE,CAAe;gBAEb,EAAE,OAAO,EAAE,EAAE;QAAE,OAAO,EAAE,WAAW,CAAA;KAAE;IAIjD,GAAG,IAAI,YAAY;IAInB,KAAK,IAAI,IAAI;IAIb,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,SAAS;IAInB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS;IAIvC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS;IAIpC,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS;IAItC,GAAG,IAAI,SAAS;IAIhB,KAAK,IAAI,SAAS;IAIlB,IAAI,IAAI,SAAS;IAIjB,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS;IAIhC,IAAI,IAAI,SAAS;IAIjB,GAAG,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS;IAIxD,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,SAAS;IAIpC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC;IAI1D,QAAQ,CACN,IAAI,SAAS,MAAM,EACnB,UAAU,SAAS,MAAM,EACzB,OAAO,SAAS,OAAO,EACvB,IAAI,EAAE,IAAI,GAAG,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC;IAItD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC;IAIxD,OAAO,CAAC,IAAI,SAAS,MAAM,EAAE,MAAM,SAAS,MAAM,EAAE,OAAO,SAAS,OAAO,EACzE,IAAI,EAAE,IAAI,GACT,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC;IAIrC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAG5B;AAED,qBAAa,YAAY,CACvB,IAAI,SAAS,MAAM,EACnB,YAAY,SAAS,MAAM,EAC3B,OAAO,SAAS,OAAO;IAEX,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,aAAa;IAE9C,IAAI,IAAI,SAAS;IAIjB,cAAc,IAAI,KAAK,CACrB;QACE,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,EAAE,YAAY,CAAC;QACvD,oBAAoB,CAClB,IAAI,EACJ,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,EAAE,YAAY,CAAC,EACvD,OAAO,CACR;KACF,CACF;IASD,KAAK,IAAI,IAAI;IAIb,WAAW,CACT,IAAI,EAAE,YAAY,GACjB,oBAAoB,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC;IACpD,WAAW,CACT,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,GACtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC;IAW9C;;;OAGG;IACH,WAAW,CACT,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,GACzC,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,EACtC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,SAAS,GACnB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC;IAO9C;;;OAGG;IACH,cAAc,CACZ,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,GACzC,aAAa,CAAC,IAAI,EAAE,gBAAgB,CAAC,EACzC,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,EAAE,KAAK,CAAC,GACrD,IAAI;IAMP;;;OAGG;IACH,QAAQ,CACN,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,GACzC,aAAa,CAAC,IAAI,EAAE,UAAU,CAAC,EACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC;IAK5C;;;OAGG;IACH,cAAc,CACZ,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,GACzC,aAAa,CAAC,IAAI,EAAE,gBAAgB,CAAC,EACzC,WAAW,EAAE,MAAM,GAAG,IAAI,GACzB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC;IAO5C,KAAK,IAAI,MAAM,GAAG,IAAI;IAItB,WAAW,IAAI,MAAM,GAAG,IAAI;IAI5B,MAAM,IAAI,MAAM,GAAG,SAAS;CAG7B;AAED,qBAAa,WAAW,CACtB,IAAI,SAAS,MAAM,EACnB,SAAS,SAAS,MAAM,EACxB,OAAO,SAAS,OAAO;IAEX,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,YAAY;IAE7C,IAAI,IAAI,SAAS;IAIjB,UAAU,IAAI,KAAK,CACjB;QACE,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,EAAE,SAAS,CAAC;QACjD,gBAAgB,CACd,IAAI,EACJ,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,EAAE,SAAS,CAAC,EACjD,OAAO,CACR;KACF,CACF;IASD;;;OAGG;IACH,QAAQ,CACN,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,GACrC,aAAa,CAAC,IAAI,EAAE,UAAU,CAAC,EACnC,IAAI,EAAE,MAAM,GACX,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC;IAK7C,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC;IACrE,QAAQ,CACN,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,GACtC,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC;IAQ1C;;;OAGG;IACH,WAAW,CAAC,CAAC,SAAS,SAAS,EAC7B,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,GACrC,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,EACtC,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,GACjC,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC;IAOxC;;;OAGG;IACH,QAAQ,CACN,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,GACrC,aAAa,CAAC,IAAI,EAAE,UAAU,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,CAAC,GAC9C,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC;IAKxC;;;OAGG;IACH,cAAc,CACZ,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,GACrC,aAAa,CAAC,IAAI,EAAE,gBAAgB,CAAC,EACzC,WAAW,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,CAAC,GACpD,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC;IAMxC,KAAK,IAAI,MAAM,GAAG,IAAI;IAItB,WAAW,IAAI,MAAM,GAAG,IAAI;CAG7B;AAED,cAAM,oBAAoB,CACxB,SAAS,SAAS,MAAM,EACxB,YAAY,SAAS,MAAM,EAC3B,OAAO,SAAS,OAAO;IAEX,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,qBAAqB;IAEvD,IAAI,IAAI,SAAS;IAIjB,OAAO,CACL,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,GACtD,aAAa,CAAC,GAAG,SAAS,IAAI,YAAY,EAAE,EAAE,SAAS,CAAC,EAC5D,SAAS,EAAE,SAAS,GACnB,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC;IAQzD,QAAQ,CACN,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,GACtD,aAAa,CAAC,GAAG,SAAS,IAAI,YAAY,EAAE,EAAE,UAAU,CAAC,EAC7D,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC;IAQzD,cAAc,CACZ,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,GACtD,aAAa,CAAC,GAAG,SAAS,IAAI,YAAY,EAAE,EAAE,gBAAgB,CAAC,EACnE,WAAW,EAAE,MAAM,GAAG,IAAI,GACzB,oBAAoB,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC;IAQzD,KAAK,IAAI,MAAM,GAAG,IAAI;IAItB,WAAW,IAAI,MAAM,GAAG,IAAI;IAI5B,MAAM,IAAI,MAAM,GAAG,SAAS;CAG7B;AAED,qBAAa,gBAAgB,CAC3B,QAAQ,SAAS,MAAM,EACvB,SAAS,SAAS,MAAM,EACxB,OAAO,SAAS,OAAO;IAEX,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,iBAAiB;IAEnD,QAAQ,CACN,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC,GAC9C,aAAa,CAAC,GAAG,QAAQ,IAAI,SAAS,EAAE,EAAE,UAAU,CAAC,EACzD,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC;IAOjD,cAAc,CACZ,IAAI,EAAE,OAAO,SAAS,IAAI,GACtB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC,GAC9C,aAAa,CAAC,GAAG,QAAQ,IAAI,SAAS,EAAE,EAAE,gBAAgB,CAAC,EAC/D,WAAW,EAAE,MAAM,GAAG,IAAI,GACzB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC;IAOjD,KAAK,IAAI,MAAM,GAAG,IAAI;IAItB,WAAW,IAAI,MAAM,GAAG,IAAI;IAI5B,MAAM,IAAI,MAAM,GAAG,SAAS;CAG7B"} \ No newline at end of file diff --git a/engine/language_client_typescript/type_builder.js b/engine/language_client_typescript/type_builder.js index ed96d00a04..c8a76816a1 100644 --- a/engine/language_client_typescript/type_builder.js +++ b/engine/language_client_typescript/type_builder.js @@ -1,26 +1,20 @@ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -exports.EnumBuilder = exports.EnumValueViewer = exports.EnumViewer = exports.EnumAst = exports.ClassBuilder = exports.ClassViewer = exports.ClassAst = exports.TypeBuilder = void 0; -const native_1 = require("./native"); +exports.EnumValueBuilder = exports.EnumBuilder = exports.ClassBuilder = exports.TypeBuilder = void 0; +const native_1 = require("../native"); class TypeBuilder { tb; - classes; - enums; - runtime; - constructor({ classes, enums, runtime }) { - this.classes = classes; - this.enums = enums; - this.tb = new native_1.TypeBuilder(); - this.runtime = runtime; - } - reset() { - this.tb.reset(); + constructor({ runtime }) { + this.tb = native_1.TypeBuilder.new(runtime); } _tb() { return this.tb; } - null() { - return this.tb.null(); + reset() { + this.tb.reset(); + } + toString() { + return this.tb.toString(); } string() { return this.tb.string(); @@ -46,179 +40,207 @@ class TypeBuilder { list(type) { return this.tb.list(type); } + null() { + return this.tb.null(); + } map(keyType, valueType) { return this.tb.map(keyType, valueType); } union(types) { return this.tb.union(types); } - classViewer(name, properties) { - return new ClassViewer(this.tb, name, new Set(properties)); - } - classBuilder(name, properties) { - return new ClassBuilder(this.tb, name, new Set(properties)); - } - enumViewer(name, values) { - return new EnumViewer(this.tb, name, new Set(values)); - } - enumBuilder(name, values) { - return new EnumBuilder(this.tb, name, new Set(values)); - } addClass(name) { - if (this.classes.has(name)) { - throw new Error(`Class ${name} already exists`); - } - if (this.enums.has(name)) { - throw new Error(`Enum ${name} already exists`); - } - this.classes.add(name); - return new ClassBuilder(this.tb, name); + return new ClassBuilder(this.tb.addClass(name)); + } + getClass(name) { + return new ClassBuilder(this.tb.getClass(name)); } addEnum(name) { - if (this.classes.has(name)) { - throw new Error(`Class ${name} already exists`); - } - if (this.enums.has(name)) { - throw new Error(`Enum ${name} already exists`); - } - this.enums.add(name); - return new EnumBuilder(this.tb, name); + return new EnumBuilder(this.tb.addEnum(name)); + } + getEnum(name) { + return new EnumBuilder(this.tb.getEnum(name)); } addBaml(baml) { - this.tb.addBaml(baml, this.runtime); + this.tb.addBaml(baml); } } exports.TypeBuilder = TypeBuilder; -class ClassAst { - properties; - bldr; - constructor(tb, name, properties = new Set()) { - this.properties = properties; - this.bldr = tb.getClass(name); - } - listProperties() { - return this.bldr.listProperties(); +class ClassBuilder { + cb; + constructor(cb) { + this.cb = cb; } type() { - return this.bldr.field(); - } -} -exports.ClassAst = ClassAst; -class ClassViewer extends ClassAst { - constructor(tb, name, properties = new Set()) { - super(tb, name, properties); + return this.cb.field(); } listProperties() { - return Array.from(this.properties).map((name) => [name, new ClassPropertyViewer()]); + return this.cb + .listProperties() + .map(([name, property]) => [ + name, + new ClassPropertyBuilder(property), + ]); } - property(name) { - if (!this.properties.has(name)) { - throw new Error(`Property ${name} not found.`); - } - return new ClassPropertyViewer(); + reset() { + return this.cb.reset(); + } + getProperty(name) { + return new ClassPropertyBuilder(this.cb.getProperty(name)); + } + /** + * addProperty: + * - only allowed if Class marked with @@dynamic + */ + addProperty(name, fieldType) { + let cpb = this.cb.addProperty(name, fieldType); + return new ClassPropertyBuilder(cpb); + } + /** + * removeProperty: + * - only allowed if Class marked with @@dynamic + */ + removeProperty(name) { + this.cb.removeProperty(name); + } + /** + * setAlias: + * - only allowed if Class marked with @@dynamic + */ + setAlias(alias) { + this.cb.setAlias(alias); + return this; } -} -exports.ClassViewer = ClassViewer; -class ClassBuilder extends ClassAst { - constructor(tb, name, properties = new Set()) { - super(tb, name, properties); - } - addProperty(name, type) { - if (this.properties.has(name)) { - throw new Error(`Property ${name} already exists.`); - } - this.properties.add(name); - return new ClassPropertyBuilder(this.bldr.property(name).setType(type)); + /** + * setDescription: + * - only allowed if Class marked with @@dynamic + */ + setDescription(description) { + this.cb.setDescription(description); + return this; } - listProperties() { - return this.bldr.listProperties(); + alias() { + return this.cb.alias(); } - removeProperty(name) { - this.properties.delete(name); - this.bldr.removeProperty(name); + description() { + return this.cb.description(); } - reset() { - this.bldr.reset(); - } - property(name) { - if (!this.properties.has(name)) { - throw new Error(`Property ${name} not found.`); - } - return new ClassPropertyBuilder(this.bldr.property(name)); + source() { + return this.cb.source(); } } exports.ClassBuilder = ClassBuilder; -class ClassPropertyViewer { - constructor() { } -} -class ClassPropertyBuilder { - bldr; - constructor(bldr) { - this.bldr = bldr; +class EnumBuilder { + eb; + constructor(eb) { + this.eb = eb; } - getType() { - return this.bldr.getType(); + type() { + return this.eb.field(); } - setType(type) { - this.bldr.setType(type); + listValues() { + return this.eb + .listValues() + .map(([name, value]) => [ + name, + new EnumValueBuilder(value), + ]); + } + /** + * addValue: + * - only allowed if Enum marked with @@dynamic + */ + addValue(name) { + let evb = this.eb.addValue(name); + return new EnumValueBuilder(evb); + } + getValue(name) { + let evb = this.eb.getValue(name); + return new EnumValueBuilder(evb); + } + /** + * removeValue: + * - only allowed if Enum marked with @@dynamic + */ + removeValue(name) { + this.eb.removeValue(name); return this; } - alias(alias) { - this.bldr.alias(alias); + /** + * setAlias: + * - only allowed if Enum marked with @@dynamic + */ + setAlias(alias) { + this.eb.setAlias(alias); return this; } - description(description) { - this.bldr.description(description); + /** + * setDescription: + * - only allowed if Enum marked with @@dynamic + */ + setDescription(description) { + this.eb.setDescription(description); return this; } + alias() { + return this.eb.alias(); + } + description() { + return this.eb.description(); + } } -class EnumAst { - values; - bldr; - constructor(tb, name, values = new Set()) { - this.values = values; - this.bldr = tb.getEnum(name); +exports.EnumBuilder = EnumBuilder; +class ClassPropertyBuilder { + cpb; + constructor(cpb) { + this.cpb = cpb; } type() { - return this.bldr.field(); + return this.cpb.getType(); } -} -exports.EnumAst = EnumAst; -class EnumViewer extends EnumAst { - constructor(tb, name, values = new Set()) { - super(tb, name, values); + setType(fieldType) { + this.cpb.setType(fieldType); + return this; } - listValues() { - return Array.from(this.values).map((name) => [name, new EnumValueViewer()]); + setAlias(alias) { + this.cpb.setAlias(alias); + return this; + } + setDescription(description) { + this.cpb.setDescription(description); + return this; } - value(name) { - if (!this.values.has(name)) { - throw new Error(`Value ${name} not found.`); - } - return new EnumValueViewer(); + alias() { + return this.cpb.alias(); + } + description() { + return this.cpb.description(); + } + source() { + return this.cpb.source(); } } -exports.EnumViewer = EnumViewer; -class EnumValueViewer { - constructor() { } -} -exports.EnumValueViewer = EnumValueViewer; -class EnumBuilder extends EnumAst { - constructor(tb, name, values = new Set()) { - super(tb, name, values); +class EnumValueBuilder { + evb; + constructor(evb) { + this.evb = evb; } - addValue(name) { - if (this.values.has(name)) { - throw new Error(`Value ${name} already exists.`); - } - this.values.add(name); - return this.bldr.value(name); + setAlias(alias) { + this.evb.setAlias(alias); + return this; } - listValues() { - return Array.from(this.values).map((name) => [name, this.bldr.value(name)]); + setDescription(description) { + this.evb.setDescription(description); + return this; } - value(name) { - return this.bldr.value(name); + alias() { + return this.evb.alias(); + } + description() { + return this.evb.description(); + } + source() { + return this.evb.source(); } } -exports.EnumBuilder = EnumBuilder; +exports.EnumValueBuilder = EnumValueBuilder; diff --git a/engine/language_client_typescript/typescript_src/type_builder.ts b/engine/language_client_typescript/typescript_src/type_builder.ts index b2d8bbafb8..5295e33f65 100644 --- a/engine/language_client_typescript/typescript_src/type_builder.ts +++ b/engine/language_client_typescript/typescript_src/type_builder.ts @@ -1,300 +1,551 @@ -import { - ClassBuilder as _ClassBuilder, - EnumBuilder as _EnumBuilder, - ClassPropertyBuilder as _ClassPropertyBuilder, - EnumValueBuilder, - FieldType, - TypeBuilder as _TypeBuilder, - BamlRuntime, -} from './native' - -type IsLiteral = string extends T ? false : true -type NameOf = IsLiteral extends true ? T : 'DynamicType' -type CheckNever = [T] extends [never] - ? `Error: Attempt to add value '${Value}' which is already a part of '${NameOf}'.` - : T -type ExcludeFrom = T extends U ? never : T -type RestrictNot = IsLiteral extends true - ? CheckNever, Name, Value> - : Value - -export class TypeBuilder { - private tb: _TypeBuilder - protected classes: Set - protected enums: Set - protected runtime: BamlRuntime - - constructor({ classes, enums, runtime }: { classes: Set; enums: Set; runtime: BamlRuntime }) { - this.classes = classes - this.enums = enums - this.tb = new _TypeBuilder() - this.runtime = runtime - } - - reset(): void { - this.tb.reset() - } - - _tb(): _TypeBuilder { - return this.tb - } - - null(): FieldType { - return this.tb.null() - } - - string(): FieldType { - return this.tb.string() - } - - literalString(value: string): FieldType { - return this.tb.literalString(value) - } - - literalInt(value: number): FieldType { - return this.tb.literalInt(value) - } - - literalBool(value: boolean): FieldType { - return this.tb.literalBool(value) - } - - int(): FieldType { - return this.tb.int() - } - - float(): FieldType { - return this.tb.float() - } - - bool(): FieldType { - return this.tb.bool() - } - - list(type: FieldType): FieldType { - return this.tb.list(type) - } - - map(keyType: FieldType, valueType: FieldType): FieldType { - return this.tb.map(keyType, valueType) - } - - union(types: FieldType[]): FieldType { - return this.tb.union(types) - } - - classViewer( - name: Name, - properties: Properties[], - ): ClassViewer { - return new ClassViewer(this.tb, name, new Set(properties)) - } - - classBuilder( - name: Name, - properties: Properties[], - ): ClassBuilder { - return new ClassBuilder(this.tb, name, new Set(properties)) - } - - enumViewer(name: Name, values: Values[]): EnumViewer { - return new EnumViewer(this.tb, name, new Set(values)) - } - - enumBuilder(name: Name, values: Values[]): EnumBuilder { - return new EnumBuilder(this.tb, name, new Set(values)) - } - - addClass(name: Name): ClassBuilder { - if (this.classes.has(name)) { - throw new Error(`Class ${name} already exists`) - } - if (this.enums.has(name)) { - throw new Error(`Enum ${name} already exists`) - } - this.classes.add(name) - return new ClassBuilder(this.tb, name) - } - - addEnum(name: Name): EnumBuilder { - if (this.classes.has(name)) { - throw new Error(`Class ${name} already exists`) - } - if (this.enums.has(name)) { - throw new Error(`Enum ${name} already exists`) - } - this.enums.add(name) - return new EnumBuilder(this.tb, name) - } - - addBaml(baml: string): void { - this.tb.addBaml(baml, this.runtime) - } -} - -export class ClassAst { - protected bldr: _ClassBuilder - - constructor( - tb: _TypeBuilder, - name: ClassName, - protected properties: Set = new Set(), - ) { - this.bldr = tb.getClass(name) - } - - listProperties(): Record { - return this.bldr.listProperties() - } - - type(): FieldType { - return this.bldr.field() - } -} - -export class ClassViewer extends ClassAst< - ClassName, - Properties +import type { FieldType } from "../native"; + +export type Type = FieldType; +export type Typeish = Type; + +type IsLiteral = string extends T ? false : true; +type NameOf< + T extends string, + Default extends string +> = IsLiteral extends true ? T : Default; + +type NameOfClass< + ClassName extends string, + Default extends string = "DynamicClass" +> = NameOf; +type NameOfProperty< + PropertyName extends string, + Default extends string = "dynamicProperty" +> = NameOf; +type NameOfClassProperty< + ClassName extends string, + PropertyName extends string +> = `${NameOfClass}.${NameOfProperty}`; + +type NameOfEnum = NameOf; +type NameOfEnumValue< + EnumName extends string, + EnumValueName extends string +> = `${NameOfEnum}.${NameOf}`; + +type Simplify = { [K in keyof T]: T[K] } & {}; + +type MustBeDynamic< + Name extends string, + Method extends string +> = `'${Name}.${Method}(..)' is only allowed when ${Name} has the @@dynamic block attribute in the .baml file. Did you mean to use .get${Capitalize}(..) or add @@dynamic to ${Name}?`; + +type PreventRedefinition< + Name extends string, + ExistingKeys +> = Name extends keyof ExistingKeys + ? `Class '${Name}' is already statically defined. Use .getClass('${Name}') instead of .class('${Name}') to access the existing class.` + : Name; + +type PreventEnumRedefinition< + Name extends string, + ExistingKeys +> = Name extends keyof ExistingKeys + ? `Enum '${Name}' is already statically defined. Use .getEnum('${Name}') instead of .enum('${Name}') to access the existing enum.` + : Name; + +type PreventPropertyRedefinition< + PropertyName extends string, + ExistingProperties, + ClassName extends string = string +> = PropertyName extends keyof ExistingProperties + ? `Property '${ClassName}.${PropertyName}' is already statically defined. Use .getProperty('${PropertyName}') instead of .property('${PropertyName}') to access the existing property.` + : PropertyName; + +type PreventEnumValueRedefinition< + ValueName extends string, + ExistingValues, + EnumName extends string = string +> = ValueName extends keyof ExistingValues + ? `Enum value '${EnumName}.${ValueName}' is already statically defined. Use .getValue('${ValueName}') instead of .value('${ValueName}') to access the existing value.` + : ValueName; + +type ValidatePropertiesConfig< + Configs extends Record, + ExistingProperties +> = { + [K in keyof Configs]: K extends keyof ExistingProperties + ? Configs[K] extends { type: any } + ? never + : Configs[K] + : Configs[K]; +}; + +export type ClassPropertyConfig = { + alias?: string | null; + description?: string | null; + skip?: boolean | null; +}; + +export type ExistingClassProperty = Partial>; + +export type NewClassProperty = + | Type + | ({ + type: Type; + } & ExistingClassProperty); + +export type ExistingEnumValue = { + alias?: string | null; + description?: string | null; + skip?: boolean | null; +}; + +export type NewEnumValue = string | ({ value: string } & ExistingEnumValue); + +export type ClassPropertyRecord = Record; + +export type EnumValueConfig = { + value?: string | null; + alias?: string | null; + description?: string | null; + skip?: boolean | null; +}; + +export type EnumValueRecord = Record; + +export type TypeAliasConfig = { + type: AliasType; + alias?: string | null; + description?: string | null; +}; + +export type ClassShape< + Properties extends ClassPropertyRecord, + Dynamic extends boolean +> = { + properties: Properties; + dynamic: Dynamic; +}; + +export type EnumShape< + Values extends EnumValueRecord, + Dynamic extends boolean +> = { + values: Values; + dynamic: Dynamic; +}; + +export type TypeAliasShape = { + dynamic: false; +}; + +export type ClassDictionary = { + [K in string]: ClassShape; +}; + +export type EnumDictionary = Record< + string, + EnumShape +>; + +export type TypeAliasDictionary = Record; + +type PropertyType< + Properties extends ClassPropertyRecord, + PropertyName extends string +> = Type; + +type ApplyClassProperty< + Properties extends ClassPropertyRecord, + PropertyName extends string, + Config extends NewClassProperty | ExistingClassProperty +> = Config extends ExistingClassProperty + ? Simplify< + Properties & { + [K in PropertyName]: Simplify< + (K extends keyof Properties ? Properties[K] : ClassPropertyConfig) & + Config + >; + } + > + : Simplify< + Properties & { + [K in PropertyName]: Config & NewClassProperty; + } + >; + +type ApplyClassProperties< + Properties extends ClassPropertyRecord, + Configs extends Record +> = Simplify< + Properties & { + [K in keyof Configs & string]: Configs[K] extends ExistingClassProperty + ? Simplify< + (K extends keyof Properties ? Properties[K] : ClassPropertyConfig) & + Configs[K] + > + : Configs[K] & NewClassProperty; + } +>; + +type EnumValueLiteral = Value extends string + ? Value + : "dynamicEnumValue"; + +type ApplyEnumValue< + Values extends EnumValueRecord, + ValueName extends string, + Value extends NewEnumValue | ExistingEnumValue +> = Value extends ExistingEnumValue + ? Simplify< + Values & { + [K in ValueName]: Simplify< + (K extends keyof Values ? Values[K] : { value: K }) & Value + >; + } + > + : Simplify< + Values & { + [K in ValueName]: Value & NewEnumValue; + } + >; + +type ApplyEnumValues< + Values extends EnumValueRecord, + Configs extends Record +> = Simplify< + Values & { + [K in keyof Configs & string]: Configs[K] extends ExistingEnumValue + ? Simplify< + (K extends keyof Values ? Values[K] : { value: K }) & Configs[K] + > + : Configs[K] & NewEnumValue; + } +>; + +type InferClassProperties< + Classes, + Name extends string +> = Name extends keyof Classes + ? Classes[Name] extends ClassShape + ? Props + : ClassPropertyRecord + : ClassPropertyRecord; + +type InferClassDynamic< + Classes, + Name extends string +> = Name extends keyof Classes + ? Classes[Name] extends ClassShape + ? Dynamic + : boolean + : true; + +type InferClassType = Name extends keyof Classes + ? Classes[Name] extends ClassShape + ? ClassType + : Type + : Type; + +type InferEnumValues = Name extends keyof Enums + ? Enums[Name] extends EnumShape + ? Values + : EnumValueRecord + : EnumValueRecord; + +type InferEnumDynamic = Name extends keyof Enums + ? Enums[Name] extends EnumShape + ? Dynamic + : boolean + : true; + +type InferEnumType = Name extends keyof Enums + ? Enums[Name] extends EnumShape + ? EnumType + : Type + : Type; + +type InferAliasType = Type; + +type InferAliasDynamic = false; + +export interface WithAliasAndDescription< + Dynamic extends boolean, + Name extends string > { - constructor(tb: _TypeBuilder, name: ClassName, properties: Set = new Set()) { - super(tb, name, properties) - } - - listProperties(): Array<[string, ClassPropertyViewer]> { - return Array.from(this.properties).map((name) => [name, new ClassPropertyViewer()]) - } - - property(name: string): ClassPropertyViewer { - if (!this.properties.has(name)) { - throw new Error(`Property ${name} not found.`) - } - return new ClassPropertyViewer() - } -} - -export class ClassBuilder extends ClassAst< - ClassName, - Properties -> { - constructor(tb: _TypeBuilder, name: ClassName, properties: Set = new Set()) { - super(tb, name, properties) - } - - addProperty(name: RestrictNot, type: FieldType): ClassPropertyBuilder { - if (this.properties.has(name)) { - throw new Error(`Property ${name} already exists.`) - } - this.properties.add(name) - return new ClassPropertyBuilder(this.bldr.property(name).setType(type)) - } - - listProperties(): Array<[string, ClassPropertyBuilder]> { - return this.bldr.listProperties() - } - - removeProperty(name: string): void { - this.properties.delete(name) - this.bldr.removeProperty(name) - } - - reset(): void { - this.bldr.reset() - } - - property(name: string): ClassPropertyBuilder { - if (!this.properties.has(name)) { - throw new Error(`Property ${name} not found.`) - } - return new ClassPropertyBuilder(this.bldr.property(name)) - } + alias: Dynamic extends true + ? (new_alias: string | null) => this + : MustBeDynamic; + description: Dynamic extends true + ? (new_description: string | null) => this + : MustBeDynamic; + + getAlias(): string | null; + getDescription(): string | null; } -class ClassPropertyViewer { - constructor() {} +export interface PropertyBuilder< + ClassName extends string, + PropertyName extends string, + Dynamic extends boolean +> extends WithAliasAndDescription< + Dynamic, + NameOfClassProperty + > { + getClassName(): NameOfClass; + getName(): NameOfProperty; + getType(): Type; } -class ClassPropertyBuilder { - private bldr: _ClassPropertyBuilder - - constructor(bldr: _ClassPropertyBuilder) { - this.bldr = bldr - } - - getType(): FieldType { - return this.bldr.getType() - } - - setType(type: FieldType): ClassPropertyBuilder { - this.bldr.setType(type) - return this - } - - alias(alias: string | null): ClassPropertyBuilder { - this.bldr.alias(alias) - return this - } - - description(description: string | null): ClassPropertyBuilder { - this.bldr.description(description) - return this - } +export interface ClassBuilder< + ClassName extends string, + Properties extends ClassPropertyRecord, + Dynamic extends boolean +> extends WithAliasAndDescription> { + getType(): Type; + getName(): NameOfClass; + + getProperties(): readonly PropertyBuilder< + ClassName, + keyof Properties & string, + Dynamic + >[]; + + getProperty( + property_name: PropertyKey + ): PropertyBuilder; + + getProperty( + property_name: PropertyKey + ): PropertyBuilder; + + property< + PropertyKey extends string, + Config extends NewClassProperty | ExistingClassProperty + >( + this: Dynamic extends true + ? ClassBuilder + : MustBeDynamic, + property_name: PreventPropertyRedefinition< + PropertyKey, + Properties, + ClassName + >, + config: Config + ): PropertyBuilder; + + properties< + Configs extends Record + >( + this: Dynamic extends true + ? ClassBuilder + : MustBeDynamic, + configs: Configs & + (keyof Configs & keyof Properties extends never + ? {} + : { + [K in keyof Configs & + keyof Properties]: `Property '${ClassName}.${K & + string}' is already statically defined. Remove the 'type' field - use only: { alias?, description? }`; + }) + ): ClassBuilder< + ClassName, + ApplyClassProperties, + Dynamic + >; } -export class EnumAst { - protected bldr: _EnumBuilder - - constructor( - tb: _TypeBuilder, - name: EnumName, - protected values: Set = new Set(), - ) { - this.bldr = tb.getEnum(name) - } - - type(): FieldType { - return this.bldr.field() - } +export interface EnumValueBuilder< + EnumName extends string, + ValueName extends string, + Dynamic extends boolean +> extends WithAliasAndDescription< + Dynamic, + NameOfEnumValue + > { + getEnumName(): NameOfEnum; + getName(): NameOfEnumValue; + getType(): Type; + + getSkip(): boolean; + skip(): this; } -export class EnumViewer extends EnumAst { - constructor(tb: _TypeBuilder, name: EnumName, values: Set = new Set()) { - super(tb, name, values) - } - - listValues(): Array<[string, EnumValueViewer]> { - return Array.from(this.values).map((name) => [name, new EnumValueViewer()]) - } - - value(name: string): EnumValueViewer { - if (!this.values.has(name)) { - throw new Error(`Value ${name} not found.`) - } - return new EnumValueViewer() - } +export interface EnumBuilder< + EnumName extends string, + Values extends EnumValueRecord, + Dynamic extends boolean, + EnumType extends Type = Type +> extends WithAliasAndDescription> { + readonly enumName: NameOfEnum; + readonly type: EnumType; + + listValues(): readonly EnumValueBuilder< + EnumName, + keyof Values & string, + Dynamic + >[]; + + getValue( + value_name: ValueKey + ): EnumValueBuilder; + + getValue( + value_name: ValueKey + ): EnumValueBuilder; + + value( + this: Dynamic extends true + ? EnumBuilder + : MustBeDynamic, + value_name: PreventEnumValueRedefinition< + EnumValueLiteral, + Values, + EnumName + > + ): EnumValueBuilder, Dynamic>; + + values( + this: Dynamic extends true + ? EnumBuilder + : MustBeDynamic, + values: NewValues extends readonly (infer V)[] + ? V extends keyof Values + ? `Enum value '${EnumName}.${V & + string}' is already statically defined. Use getValue('${V & + string}') instead.`[] + : NewValues + : never + ): EnumBuilder< + EnumName, + Values & { [K in NewValues[number]]: { value: K } }, + Dynamic, + EnumType + >; } -export class EnumValueViewer { - constructor() {} +type ClassDictionaryToBuilder = { + [K in keyof Classes & string]: ClassBuilder< + K, + Classes[K] extends ClassShape + ? Props + : ClassPropertyRecord, + Classes[K] extends ClassShape + ? Dynamic + : boolean + >; +}; + +export interface TypeRegistry< + Classes extends ClassDictionary = {}, + Enums extends EnumDictionary = {}, + TypeAliases extends TypeAliasDictionary = {} +> { + listClasses(): readonly ClassBuilder[]; + listEnums(): readonly EnumBuilder[]; + + getClass( + class_name: Name + ): ClassBuilder< + Name, + InferClassProperties, + InferClassDynamic + >; + + getClass( + class_name: Name + ): ClassBuilder; + + getEnum( + enum_name: Name + ): EnumBuilder< + Name, + InferEnumValues, + InferEnumDynamic + >; + + getEnum( + enum_name: Name + ): EnumBuilder; + + class< + Name extends string, + ExistingProps extends ClassPropertyRecord = {}, + Props extends Record = {} + >( + class_name: PreventRedefinition, + properties?: ExistingProps & Props + ): ClassBuilder; + + enum< + Name extends string, + Values extends EnumValueRecord = {}, + ExistingValues extends EnumValueRecord = {} + >( + enum_name: PreventEnumRedefinition, + values?: Values + ): EnumBuilder; + + toString(): string; + + string(): Type; + literalString(value: Value): Type; + literalInt(value: Value): Type; + literalBool(value: Value): Type; + int(): Type; + float(): Type; + bool(): Type; + list(type: ItemType): Type; + null(): Type; + map( + keyType: KeyType, + valueType: ValueType + ): Type; + union(types: Types): Type; + + getDependencies(type: Type): Type[]; } -export class EnumBuilder extends EnumAst { - constructor(tb: _TypeBuilder, name: EnumName, values: Set = new Set()) { - super(tb, name, values) - } - - addValue(name: RestrictNot): EnumValueBuilder { - if (this.values.has(name)) { - throw new Error(`Value ${name} already exists.`) +function test( + tb: TypeRegistry< + { + MyClass: { + properties: { + my_property: {}; + }; + dynamic: false; + }; + MyClass2: { + properties: { + my_property: {}; + }; + dynamic: true; + }; + }, + { + MyEnum: { + values: { + value1: {}; + }; + dynamic: false; + }; } - this.values.add(name) - return this.bldr.value(name) - } - - listValues(): Array<[string, EnumValueBuilder]> { - return Array.from(this.values).map((name) => [name, this.bldr.value(name)]) - } - - value(name: string): EnumValueBuilder { - return this.bldr.value(name) - } + > +) { + tb.class("Class").property("property", tb``.string()); + tb.getClass("MyClass").getProperty("property").getType(); + + tb.enum("Enum").value("value"); + + tb.listClasses().map((cls) => { + cls.getName(); + }); + + tb.class("MyClass").property("property", tb.string()); + tb.enum("MyEnum").value("newValue"); + tb.getClass("MyClass").property("my_property", tb.string()); + tb.getClass("MyClass2").properties({ + my_property: { type: tb.string(), alias: "myProp" }, + new_property: tb.int(), + another_property: { type: tb.string() }, + }); + tb.getEnum("MyEnum").value("value1"); + tb.getEnum("MyEnum").values(["value1", "value2", "value3"]); } +m; diff --git a/integ-tests/python-v1/baml_client/type_builder.py b/integ-tests/python-v1/baml_client/type_builder.py index e7f9757112..19ef44d354 100644 --- a/integ-tests/python-v1/baml_client/type_builder.py +++ b/integ-tests/python-v1/baml_client/type_builder.py @@ -19,39 +19,35 @@ class TypeBuilder(type_builder.TypeBuilder): def __init__(self): - super().__init__(classes=set( - ["AnotherObject","BigNumbers","BinaryNode","Blah","BlockConstraint","BlockConstraintForParam","BookOrder","ClassForNullLiteral","ClassOptionalOutput","ClassOptionalOutput2","ClassToRecAlias","ClassWithBlockDone","ClassWithImage","ClassWithoutDone","ClientDetails1559","ComplexMemoryObject","CompoundBigNumbers","ContactInfo","CustomStory","CustomTaskResult","Document1559","DummyOutput","DynInputOutput","DynamicClassOne","DynamicClassTwo","DynamicOutput","DynamicSchema","Earthling","Education","Email","EmailAddress","Event","FakeImage","FlightConfirmation","FooAny","Forest","FormatterTest0","FormatterTest1","FormatterTest2","FormatterTest3","GroceryReceipt","Haiku","InnerClass","InnerClass2","InputClass","InputClassNested","LinkedList","LinkedListAliasNode","LiteralClassHello","LiteralClassOne","LiteralClassTwo","MaintainFieldOrder","MalformedConstraints","MalformedConstraints2","Martian","MemoryObject","MergeAttrs","NamedArgsSingleClass","Nested","Nested2","NestedBlockConstraint","NestedBlockConstraintForParam","Node","NodeWithAliasIndirection","Note1599","OptionalListAndMap","OptionalTest_Prop1","OptionalTest_ReturnType","OrderInfo","OriginalA","OriginalB","Person","PhoneNumber","Quantity","RaysData","ReceiptInfo","ReceiptItem","Recipe","RecursiveAliasDependency","RenderEnumInput","RenderTestClass","Resume","Schema","SearchParams","SemanticContainer","SimpleTag","SmallThing","SomeClassNestedDynamic","StringToClassEntry","TestClassAlias","TestClassNested","TestClassWithEnum","TestMemoryOutput","TestOutputClass","Tree","TwoStoriesOneTitle","TwoStoriesOneTitleCheck","UnionTest_ReturnType","UniverseQuestion","UniverseQuestionInput","WithReasoning",] - ), enums=set( - ["AliasedEnum","Category","Category2","Category3","Color","DataType","DynEnumOne","DynEnumThree","DynEnumTwo","EnumInClass","EnumOutput","Hobby","MapKey","NamedArgsSingleEnum","NamedArgsSingleEnumList","OptionalTest_CategoryType","OrderStatus","RenderStatusEnum","RenderTestEnum","Tag","TestEnum",] - ), runtime=DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME) + super().__init__(runtime=DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME) # ######################################################################### # Generated enums 21 # ######################################################################### @property - def AliasedEnum(self) -> "AliasedEnumViewer": - return AliasedEnumViewer(self) + def AliasedEnum(self) -> "AliasedEnumBuilder": + return AliasedEnumBuilder(self) @property - def Category(self) -> "CategoryViewer": - return CategoryViewer(self) + def Category(self) -> "CategoryBuilder": + return CategoryBuilder(self) @property - def Category2(self) -> "Category2Viewer": - return Category2Viewer(self) + def Category2(self) -> "Category2Builder": + return Category2Builder(self) @property - def Category3(self) -> "Category3Viewer": - return Category3Viewer(self) + def Category3(self) -> "Category3Builder": + return Category3Builder(self) @property def Color(self) -> "ColorBuilder": return ColorBuilder(self) @property - def DataType(self) -> "DataTypeViewer": - return DataTypeViewer(self) + def DataType(self) -> "DataTypeBuilder": + return DataTypeBuilder(self) @property def DynEnumOne(self) -> "DynEnumOneBuilder": @@ -66,36 +62,36 @@ def DynEnumTwo(self) -> "DynEnumTwoBuilder": return DynEnumTwoBuilder(self) @property - def EnumInClass(self) -> "EnumInClassViewer": - return EnumInClassViewer(self) + def EnumInClass(self) -> "EnumInClassBuilder": + return EnumInClassBuilder(self) @property - def EnumOutput(self) -> "EnumOutputViewer": - return EnumOutputViewer(self) + def EnumOutput(self) -> "EnumOutputBuilder": + return EnumOutputBuilder(self) @property def Hobby(self) -> "HobbyBuilder": return HobbyBuilder(self) @property - def MapKey(self) -> "MapKeyViewer": - return MapKeyViewer(self) + def MapKey(self) -> "MapKeyBuilder": + return MapKeyBuilder(self) @property - def NamedArgsSingleEnum(self) -> "NamedArgsSingleEnumViewer": - return NamedArgsSingleEnumViewer(self) + def NamedArgsSingleEnum(self) -> "NamedArgsSingleEnumBuilder": + return NamedArgsSingleEnumBuilder(self) @property - def NamedArgsSingleEnumList(self) -> "NamedArgsSingleEnumListViewer": - return NamedArgsSingleEnumListViewer(self) + def NamedArgsSingleEnumList(self) -> "NamedArgsSingleEnumListBuilder": + return NamedArgsSingleEnumListBuilder(self) @property - def OptionalTest_CategoryType(self) -> "OptionalTest_CategoryTypeViewer": - return OptionalTest_CategoryTypeViewer(self) + def OptionalTest_CategoryType(self) -> "OptionalTest_CategoryTypeBuilder": + return OptionalTest_CategoryTypeBuilder(self) @property - def OrderStatus(self) -> "OrderStatusViewer": - return OrderStatusViewer(self) + def OrderStatus(self) -> "OrderStatusBuilder": + return OrderStatusBuilder(self) @property def RenderStatusEnum(self) -> "RenderStatusEnumBuilder": @@ -106,12 +102,12 @@ def RenderTestEnum(self) -> "RenderTestEnumBuilder": return RenderTestEnumBuilder(self) @property - def Tag(self) -> "TagViewer": - return TagViewer(self) + def Tag(self) -> "TagBuilder": + return TagBuilder(self) @property - def TestEnum(self) -> "TestEnumViewer": - return TestEnumViewer(self) + def TestEnum(self) -> "TestEnumBuilder": + return TestEnumBuilder(self) # ######################################################################### @@ -119,88 +115,88 @@ def TestEnum(self) -> "TestEnumViewer": # ######################################################################### @property - def AnotherObject(self) -> "AnotherObjectViewer": - return AnotherObjectViewer(self) + def AnotherObject(self) -> "AnotherObjectBuilder": + return AnotherObjectBuilder(self) @property - def BigNumbers(self) -> "BigNumbersViewer": - return BigNumbersViewer(self) + def BigNumbers(self) -> "BigNumbersBuilder": + return BigNumbersBuilder(self) @property - def BinaryNode(self) -> "BinaryNodeViewer": - return BinaryNodeViewer(self) + def BinaryNode(self) -> "BinaryNodeBuilder": + return BinaryNodeBuilder(self) @property - def Blah(self) -> "BlahViewer": - return BlahViewer(self) + def Blah(self) -> "BlahBuilder": + return BlahBuilder(self) @property - def BlockConstraint(self) -> "BlockConstraintViewer": - return BlockConstraintViewer(self) + def BlockConstraint(self) -> "BlockConstraintBuilder": + return BlockConstraintBuilder(self) @property - def BlockConstraintForParam(self) -> "BlockConstraintForParamViewer": - return BlockConstraintForParamViewer(self) + def BlockConstraintForParam(self) -> "BlockConstraintForParamBuilder": + return BlockConstraintForParamBuilder(self) @property - def BookOrder(self) -> "BookOrderViewer": - return BookOrderViewer(self) + def BookOrder(self) -> "BookOrderBuilder": + return BookOrderBuilder(self) @property - def ClassForNullLiteral(self) -> "ClassForNullLiteralViewer": - return ClassForNullLiteralViewer(self) + def ClassForNullLiteral(self) -> "ClassForNullLiteralBuilder": + return ClassForNullLiteralBuilder(self) @property - def ClassOptionalOutput(self) -> "ClassOptionalOutputViewer": - return ClassOptionalOutputViewer(self) + def ClassOptionalOutput(self) -> "ClassOptionalOutputBuilder": + return ClassOptionalOutputBuilder(self) @property - def ClassOptionalOutput2(self) -> "ClassOptionalOutput2Viewer": - return ClassOptionalOutput2Viewer(self) + def ClassOptionalOutput2(self) -> "ClassOptionalOutput2Builder": + return ClassOptionalOutput2Builder(self) @property - def ClassToRecAlias(self) -> "ClassToRecAliasViewer": - return ClassToRecAliasViewer(self) + def ClassToRecAlias(self) -> "ClassToRecAliasBuilder": + return ClassToRecAliasBuilder(self) @property - def ClassWithBlockDone(self) -> "ClassWithBlockDoneViewer": - return ClassWithBlockDoneViewer(self) + def ClassWithBlockDone(self) -> "ClassWithBlockDoneBuilder": + return ClassWithBlockDoneBuilder(self) @property - def ClassWithImage(self) -> "ClassWithImageViewer": - return ClassWithImageViewer(self) + def ClassWithImage(self) -> "ClassWithImageBuilder": + return ClassWithImageBuilder(self) @property - def ClassWithoutDone(self) -> "ClassWithoutDoneViewer": - return ClassWithoutDoneViewer(self) + def ClassWithoutDone(self) -> "ClassWithoutDoneBuilder": + return ClassWithoutDoneBuilder(self) @property - def ClientDetails1559(self) -> "ClientDetails1559Viewer": - return ClientDetails1559Viewer(self) + def ClientDetails1559(self) -> "ClientDetails1559Builder": + return ClientDetails1559Builder(self) @property - def ComplexMemoryObject(self) -> "ComplexMemoryObjectViewer": - return ComplexMemoryObjectViewer(self) + def ComplexMemoryObject(self) -> "ComplexMemoryObjectBuilder": + return ComplexMemoryObjectBuilder(self) @property - def CompoundBigNumbers(self) -> "CompoundBigNumbersViewer": - return CompoundBigNumbersViewer(self) + def CompoundBigNumbers(self) -> "CompoundBigNumbersBuilder": + return CompoundBigNumbersBuilder(self) @property - def ContactInfo(self) -> "ContactInfoViewer": - return ContactInfoViewer(self) + def ContactInfo(self) -> "ContactInfoBuilder": + return ContactInfoBuilder(self) @property - def CustomStory(self) -> "CustomStoryViewer": - return CustomStoryViewer(self) + def CustomStory(self) -> "CustomStoryBuilder": + return CustomStoryBuilder(self) @property - def CustomTaskResult(self) -> "CustomTaskResultViewer": - return CustomTaskResultViewer(self) + def CustomTaskResult(self) -> "CustomTaskResultBuilder": + return CustomTaskResultBuilder(self) @property - def Document1559(self) -> "Document1559Viewer": - return Document1559Viewer(self) + def Document1559(self) -> "Document1559Builder": + return Document1559Builder(self) @property def DummyOutput(self) -> "DummyOutputBuilder": @@ -227,176 +223,176 @@ def DynamicSchema(self) -> "DynamicSchemaBuilder": return DynamicSchemaBuilder(self) @property - def Earthling(self) -> "EarthlingViewer": - return EarthlingViewer(self) + def Earthling(self) -> "EarthlingBuilder": + return EarthlingBuilder(self) @property - def Education(self) -> "EducationViewer": - return EducationViewer(self) + def Education(self) -> "EducationBuilder": + return EducationBuilder(self) @property - def Email(self) -> "EmailViewer": - return EmailViewer(self) + def Email(self) -> "EmailBuilder": + return EmailBuilder(self) @property - def EmailAddress(self) -> "EmailAddressViewer": - return EmailAddressViewer(self) + def EmailAddress(self) -> "EmailAddressBuilder": + return EmailAddressBuilder(self) @property - def Event(self) -> "EventViewer": - return EventViewer(self) + def Event(self) -> "EventBuilder": + return EventBuilder(self) @property - def FakeImage(self) -> "FakeImageViewer": - return FakeImageViewer(self) + def FakeImage(self) -> "FakeImageBuilder": + return FakeImageBuilder(self) @property - def FlightConfirmation(self) -> "FlightConfirmationViewer": - return FlightConfirmationViewer(self) + def FlightConfirmation(self) -> "FlightConfirmationBuilder": + return FlightConfirmationBuilder(self) @property - def FooAny(self) -> "FooAnyViewer": - return FooAnyViewer(self) + def FooAny(self) -> "FooAnyBuilder": + return FooAnyBuilder(self) @property - def Forest(self) -> "ForestViewer": - return ForestViewer(self) + def Forest(self) -> "ForestBuilder": + return ForestBuilder(self) @property - def FormatterTest0(self) -> "FormatterTest0Viewer": - return FormatterTest0Viewer(self) + def FormatterTest0(self) -> "FormatterTest0Builder": + return FormatterTest0Builder(self) @property - def FormatterTest1(self) -> "FormatterTest1Viewer": - return FormatterTest1Viewer(self) + def FormatterTest1(self) -> "FormatterTest1Builder": + return FormatterTest1Builder(self) @property - def FormatterTest2(self) -> "FormatterTest2Viewer": - return FormatterTest2Viewer(self) + def FormatterTest2(self) -> "FormatterTest2Builder": + return FormatterTest2Builder(self) @property - def FormatterTest3(self) -> "FormatterTest3Viewer": - return FormatterTest3Viewer(self) + def FormatterTest3(self) -> "FormatterTest3Builder": + return FormatterTest3Builder(self) @property - def GroceryReceipt(self) -> "GroceryReceiptViewer": - return GroceryReceiptViewer(self) + def GroceryReceipt(self) -> "GroceryReceiptBuilder": + return GroceryReceiptBuilder(self) @property - def Haiku(self) -> "HaikuViewer": - return HaikuViewer(self) + def Haiku(self) -> "HaikuBuilder": + return HaikuBuilder(self) @property - def InnerClass(self) -> "InnerClassViewer": - return InnerClassViewer(self) + def InnerClass(self) -> "InnerClassBuilder": + return InnerClassBuilder(self) @property - def InnerClass2(self) -> "InnerClass2Viewer": - return InnerClass2Viewer(self) + def InnerClass2(self) -> "InnerClass2Builder": + return InnerClass2Builder(self) @property - def InputClass(self) -> "InputClassViewer": - return InputClassViewer(self) + def InputClass(self) -> "InputClassBuilder": + return InputClassBuilder(self) @property - def InputClassNested(self) -> "InputClassNestedViewer": - return InputClassNestedViewer(self) + def InputClassNested(self) -> "InputClassNestedBuilder": + return InputClassNestedBuilder(self) @property - def LinkedList(self) -> "LinkedListViewer": - return LinkedListViewer(self) + def LinkedList(self) -> "LinkedListBuilder": + return LinkedListBuilder(self) @property - def LinkedListAliasNode(self) -> "LinkedListAliasNodeViewer": - return LinkedListAliasNodeViewer(self) + def LinkedListAliasNode(self) -> "LinkedListAliasNodeBuilder": + return LinkedListAliasNodeBuilder(self) @property - def LiteralClassHello(self) -> "LiteralClassHelloViewer": - return LiteralClassHelloViewer(self) + def LiteralClassHello(self) -> "LiteralClassHelloBuilder": + return LiteralClassHelloBuilder(self) @property - def LiteralClassOne(self) -> "LiteralClassOneViewer": - return LiteralClassOneViewer(self) + def LiteralClassOne(self) -> "LiteralClassOneBuilder": + return LiteralClassOneBuilder(self) @property - def LiteralClassTwo(self) -> "LiteralClassTwoViewer": - return LiteralClassTwoViewer(self) + def LiteralClassTwo(self) -> "LiteralClassTwoBuilder": + return LiteralClassTwoBuilder(self) @property - def MaintainFieldOrder(self) -> "MaintainFieldOrderViewer": - return MaintainFieldOrderViewer(self) + def MaintainFieldOrder(self) -> "MaintainFieldOrderBuilder": + return MaintainFieldOrderBuilder(self) @property - def MalformedConstraints(self) -> "MalformedConstraintsViewer": - return MalformedConstraintsViewer(self) + def MalformedConstraints(self) -> "MalformedConstraintsBuilder": + return MalformedConstraintsBuilder(self) @property - def MalformedConstraints2(self) -> "MalformedConstraints2Viewer": - return MalformedConstraints2Viewer(self) + def MalformedConstraints2(self) -> "MalformedConstraints2Builder": + return MalformedConstraints2Builder(self) @property - def Martian(self) -> "MartianViewer": - return MartianViewer(self) + def Martian(self) -> "MartianBuilder": + return MartianBuilder(self) @property - def MemoryObject(self) -> "MemoryObjectViewer": - return MemoryObjectViewer(self) + def MemoryObject(self) -> "MemoryObjectBuilder": + return MemoryObjectBuilder(self) @property - def MergeAttrs(self) -> "MergeAttrsViewer": - return MergeAttrsViewer(self) + def MergeAttrs(self) -> "MergeAttrsBuilder": + return MergeAttrsBuilder(self) @property - def NamedArgsSingleClass(self) -> "NamedArgsSingleClassViewer": - return NamedArgsSingleClassViewer(self) + def NamedArgsSingleClass(self) -> "NamedArgsSingleClassBuilder": + return NamedArgsSingleClassBuilder(self) @property - def Nested(self) -> "NestedViewer": - return NestedViewer(self) + def Nested(self) -> "NestedBuilder": + return NestedBuilder(self) @property - def Nested2(self) -> "Nested2Viewer": - return Nested2Viewer(self) + def Nested2(self) -> "Nested2Builder": + return Nested2Builder(self) @property - def NestedBlockConstraint(self) -> "NestedBlockConstraintViewer": - return NestedBlockConstraintViewer(self) + def NestedBlockConstraint(self) -> "NestedBlockConstraintBuilder": + return NestedBlockConstraintBuilder(self) @property - def NestedBlockConstraintForParam(self) -> "NestedBlockConstraintForParamViewer": - return NestedBlockConstraintForParamViewer(self) + def NestedBlockConstraintForParam(self) -> "NestedBlockConstraintForParamBuilder": + return NestedBlockConstraintForParamBuilder(self) @property - def Node(self) -> "NodeViewer": - return NodeViewer(self) + def Node(self) -> "NodeBuilder": + return NodeBuilder(self) @property - def NodeWithAliasIndirection(self) -> "NodeWithAliasIndirectionViewer": - return NodeWithAliasIndirectionViewer(self) + def NodeWithAliasIndirection(self) -> "NodeWithAliasIndirectionBuilder": + return NodeWithAliasIndirectionBuilder(self) @property - def Note1599(self) -> "Note1599Viewer": - return Note1599Viewer(self) + def Note1599(self) -> "Note1599Builder": + return Note1599Builder(self) @property - def OptionalListAndMap(self) -> "OptionalListAndMapViewer": - return OptionalListAndMapViewer(self) + def OptionalListAndMap(self) -> "OptionalListAndMapBuilder": + return OptionalListAndMapBuilder(self) @property - def OptionalTest_Prop1(self) -> "OptionalTest_Prop1Viewer": - return OptionalTest_Prop1Viewer(self) + def OptionalTest_Prop1(self) -> "OptionalTest_Prop1Builder": + return OptionalTest_Prop1Builder(self) @property - def OptionalTest_ReturnType(self) -> "OptionalTest_ReturnTypeViewer": - return OptionalTest_ReturnTypeViewer(self) + def OptionalTest_ReturnType(self) -> "OptionalTest_ReturnTypeBuilder": + return OptionalTest_ReturnTypeBuilder(self) @property - def OrderInfo(self) -> "OrderInfoViewer": - return OrderInfoViewer(self) + def OrderInfo(self) -> "OrderInfoBuilder": + return OrderInfoBuilder(self) @property - def OriginalA(self) -> "OriginalAViewer": - return OriginalAViewer(self) + def OriginalA(self) -> "OriginalABuilder": + return OriginalABuilder(self) @property def OriginalB(self) -> "OriginalBBuilder": @@ -407,32 +403,32 @@ def Person(self) -> "PersonBuilder": return PersonBuilder(self) @property - def PhoneNumber(self) -> "PhoneNumberViewer": - return PhoneNumberViewer(self) + def PhoneNumber(self) -> "PhoneNumberBuilder": + return PhoneNumberBuilder(self) @property - def Quantity(self) -> "QuantityViewer": - return QuantityViewer(self) + def Quantity(self) -> "QuantityBuilder": + return QuantityBuilder(self) @property - def RaysData(self) -> "RaysDataViewer": - return RaysDataViewer(self) + def RaysData(self) -> "RaysDataBuilder": + return RaysDataBuilder(self) @property - def ReceiptInfo(self) -> "ReceiptInfoViewer": - return ReceiptInfoViewer(self) + def ReceiptInfo(self) -> "ReceiptInfoBuilder": + return ReceiptInfoBuilder(self) @property - def ReceiptItem(self) -> "ReceiptItemViewer": - return ReceiptItemViewer(self) + def ReceiptItem(self) -> "ReceiptItemBuilder": + return ReceiptItemBuilder(self) @property - def Recipe(self) -> "RecipeViewer": - return RecipeViewer(self) + def Recipe(self) -> "RecipeBuilder": + return RecipeBuilder(self) @property - def RecursiveAliasDependency(self) -> "RecursiveAliasDependencyViewer": - return RecursiveAliasDependencyViewer(self) + def RecursiveAliasDependency(self) -> "RecursiveAliasDependencyBuilder": + return RecursiveAliasDependencyBuilder(self) @property def RenderEnumInput(self) -> "RenderEnumInputBuilder": @@ -443,84 +439,84 @@ def RenderTestClass(self) -> "RenderTestClassBuilder": return RenderTestClassBuilder(self) @property - def Resume(self) -> "ResumeViewer": - return ResumeViewer(self) + def Resume(self) -> "ResumeBuilder": + return ResumeBuilder(self) @property - def Schema(self) -> "SchemaViewer": - return SchemaViewer(self) + def Schema(self) -> "SchemaBuilder": + return SchemaBuilder(self) @property - def SearchParams(self) -> "SearchParamsViewer": - return SearchParamsViewer(self) + def SearchParams(self) -> "SearchParamsBuilder": + return SearchParamsBuilder(self) @property - def SemanticContainer(self) -> "SemanticContainerViewer": - return SemanticContainerViewer(self) + def SemanticContainer(self) -> "SemanticContainerBuilder": + return SemanticContainerBuilder(self) @property - def SimpleTag(self) -> "SimpleTagViewer": - return SimpleTagViewer(self) + def SimpleTag(self) -> "SimpleTagBuilder": + return SimpleTagBuilder(self) @property - def SmallThing(self) -> "SmallThingViewer": - return SmallThingViewer(self) + def SmallThing(self) -> "SmallThingBuilder": + return SmallThingBuilder(self) @property def SomeClassNestedDynamic(self) -> "SomeClassNestedDynamicBuilder": return SomeClassNestedDynamicBuilder(self) @property - def StringToClassEntry(self) -> "StringToClassEntryViewer": - return StringToClassEntryViewer(self) + def StringToClassEntry(self) -> "StringToClassEntryBuilder": + return StringToClassEntryBuilder(self) @property - def TestClassAlias(self) -> "TestClassAliasViewer": - return TestClassAliasViewer(self) + def TestClassAlias(self) -> "TestClassAliasBuilder": + return TestClassAliasBuilder(self) @property - def TestClassNested(self) -> "TestClassNestedViewer": - return TestClassNestedViewer(self) + def TestClassNested(self) -> "TestClassNestedBuilder": + return TestClassNestedBuilder(self) @property - def TestClassWithEnum(self) -> "TestClassWithEnumViewer": - return TestClassWithEnumViewer(self) + def TestClassWithEnum(self) -> "TestClassWithEnumBuilder": + return TestClassWithEnumBuilder(self) @property - def TestMemoryOutput(self) -> "TestMemoryOutputViewer": - return TestMemoryOutputViewer(self) + def TestMemoryOutput(self) -> "TestMemoryOutputBuilder": + return TestMemoryOutputBuilder(self) @property - def TestOutputClass(self) -> "TestOutputClassViewer": - return TestOutputClassViewer(self) + def TestOutputClass(self) -> "TestOutputClassBuilder": + return TestOutputClassBuilder(self) @property - def Tree(self) -> "TreeViewer": - return TreeViewer(self) + def Tree(self) -> "TreeBuilder": + return TreeBuilder(self) @property - def TwoStoriesOneTitle(self) -> "TwoStoriesOneTitleViewer": - return TwoStoriesOneTitleViewer(self) + def TwoStoriesOneTitle(self) -> "TwoStoriesOneTitleBuilder": + return TwoStoriesOneTitleBuilder(self) @property - def TwoStoriesOneTitleCheck(self) -> "TwoStoriesOneTitleCheckViewer": - return TwoStoriesOneTitleCheckViewer(self) + def TwoStoriesOneTitleCheck(self) -> "TwoStoriesOneTitleCheckBuilder": + return TwoStoriesOneTitleCheckBuilder(self) @property - def UnionTest_ReturnType(self) -> "UnionTest_ReturnTypeViewer": - return UnionTest_ReturnTypeViewer(self) + def UnionTest_ReturnType(self) -> "UnionTest_ReturnTypeBuilder": + return UnionTest_ReturnTypeBuilder(self) @property - def UniverseQuestion(self) -> "UniverseQuestionViewer": - return UniverseQuestionViewer(self) + def UniverseQuestion(self) -> "UniverseQuestionBuilder": + return UniverseQuestionBuilder(self) @property - def UniverseQuestionInput(self) -> "UniverseQuestionInputViewer": - return UniverseQuestionInputViewer(self) + def UniverseQuestionInput(self) -> "UniverseQuestionInputBuilder": + return UniverseQuestionInputBuilder(self) @property - def WithReasoning(self) -> "WithReasoningViewer": - return WithReasoningViewer(self) + def WithReasoning(self) -> "WithReasoningBuilder": + return WithReasoningBuilder(self) @@ -531,9 +527,8 @@ def WithReasoning(self) -> "WithReasoningViewer": class AliasedEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("AliasedEnum") - self._values: typing.Set[str] = set([ "KEY_ONE", "KEY_TWO", ]) - self._vals = AliasedEnumValues(self._bldr, self._values) + self._bldr = _tb.get_enum("AliasedEnum") + self._vals = AliasedEnumValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -543,29 +538,28 @@ def values(self) -> "AliasedEnumValues": return self._vals -class AliasedEnumViewer(AliasedEnumAst): +class AliasedEnumBuilder(AliasedEnumAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class AliasedEnumValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def KEY_ONE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("KEY_ONE")) + def KEY_ONE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("KEY_ONE")) @property - def KEY_TWO(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("KEY_TWO")) + def KEY_TWO(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("KEY_TWO")) @@ -573,9 +567,8 @@ def KEY_TWO(self) -> type_builder.EnumValueViewer: class CategoryAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Category") - self._values: typing.Set[str] = set([ "Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ]) - self._vals = CategoryValues(self._bldr, self._values) + self._bldr = _tb.get_enum("Category") + self._vals = CategoryValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -585,41 +578,40 @@ def values(self) -> "CategoryValues": return self._vals -class CategoryViewer(CategoryAst): +class CategoryBuilder(CategoryAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class CategoryValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Refund(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Refund")) + def Refund(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Refund")) @property - def CancelOrder(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("CancelOrder")) + def CancelOrder(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("CancelOrder")) @property - def TechnicalSupport(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TechnicalSupport")) + def TechnicalSupport(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TechnicalSupport")) @property - def AccountIssue(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("AccountIssue")) + def AccountIssue(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("AccountIssue")) @property - def Question(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Question")) + def Question(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Question")) @@ -627,9 +619,8 @@ def Question(self) -> type_builder.EnumValueViewer: class Category2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Category2") - self._values: typing.Set[str] = set([ "Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ]) - self._vals = Category2Values(self._bldr, self._values) + self._bldr = _tb.get_enum("Category2") + self._vals = Category2Values(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -639,41 +630,40 @@ def values(self) -> "Category2Values": return self._vals -class Category2Viewer(Category2Ast): +class Category2Builder(Category2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class Category2Values: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Refund(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Refund")) + def Refund(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Refund")) @property - def CancelOrder(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("CancelOrder")) + def CancelOrder(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("CancelOrder")) @property - def TechnicalSupport(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TechnicalSupport")) + def TechnicalSupport(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TechnicalSupport")) @property - def AccountIssue(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("AccountIssue")) + def AccountIssue(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("AccountIssue")) @property - def Question(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Question")) + def Question(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Question")) @@ -681,9 +671,8 @@ def Question(self) -> type_builder.EnumValueViewer: class Category3Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Category3") - self._values: typing.Set[str] = set([ "Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ]) - self._vals = Category3Values(self._bldr, self._values) + self._bldr = _tb.get_enum("Category3") + self._vals = Category3Values(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -693,41 +682,40 @@ def values(self) -> "Category3Values": return self._vals -class Category3Viewer(Category3Ast): +class Category3Builder(Category3Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class Category3Values: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Refund(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Refund")) + def Refund(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Refund")) @property - def CancelOrder(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("CancelOrder")) + def CancelOrder(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("CancelOrder")) @property - def TechnicalSupport(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TechnicalSupport")) + def TechnicalSupport(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TechnicalSupport")) @property - def AccountIssue(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("AccountIssue")) + def AccountIssue(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("AccountIssue")) @property - def Question(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Question")) + def Question(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Question")) @@ -735,9 +723,8 @@ def Question(self) -> type_builder.EnumValueViewer: class ColorAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Color") - self._values: typing.Set[str] = set([ "RED", "BLUE", "GREEN", "YELLOW", "BLACK", "WHITE", ]) - self._vals = ColorValues(self._bldr, self._values) + self._bldr = _tb.get_enum("Color") + self._vals = ColorValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -752,50 +739,45 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class ColorValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @property - def RED(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("RED") + def RED(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("RED") @property - def BLUE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("BLUE") + def BLUE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("BLUE") @property - def GREEN(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("GREEN") + def GREEN(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("GREEN") @property - def YELLOW(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("YELLOW") + def YELLOW(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("YELLOW") @property - def BLACK(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("BLACK") + def BLACK(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("BLACK") @property - def WHITE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("WHITE") + def WHITE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("WHITE") @@ -803,9 +785,8 @@ def WHITE(self) -> baml_py.EnumValueBuilder: class DataTypeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("DataType") - self._values: typing.Set[str] = set([ "Resume", "Event", ]) - self._vals = DataTypeValues(self._bldr, self._values) + self._bldr = _tb.get_enum("DataType") + self._vals = DataTypeValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -815,29 +796,28 @@ def values(self) -> "DataTypeValues": return self._vals -class DataTypeViewer(DataTypeAst): +class DataTypeBuilder(DataTypeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class DataTypeValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Resume(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Resume")) + def Resume(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Resume")) @property - def Event(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Event")) + def Event(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Event")) @@ -845,9 +825,8 @@ def Event(self) -> type_builder.EnumValueViewer: class DynEnumOneAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("DynEnumOne") - self._values: typing.Set[str] = set([ ]) - self._vals = DynEnumOneValues(self._bldr, self._values) + self._bldr = _tb.get_enum("DynEnumOne") + self._vals = DynEnumOneValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -862,25 +841,20 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class DynEnumOneValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @@ -889,9 +863,8 @@ def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: class DynEnumThreeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("DynEnumThree") - self._values: typing.Set[str] = set([ "TRICYCLE", "TRIANGLE", ]) - self._vals = DynEnumThreeValues(self._bldr, self._values) + self._bldr = _tb.get_enum("DynEnumThree") + self._vals = DynEnumThreeValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -906,34 +879,29 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class DynEnumThreeValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @property - def TRICYCLE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("TRICYCLE") + def TRICYCLE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("TRICYCLE") @property - def TRIANGLE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("TRIANGLE") + def TRIANGLE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("TRIANGLE") @@ -941,9 +909,8 @@ def TRIANGLE(self) -> baml_py.EnumValueBuilder: class DynEnumTwoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("DynEnumTwo") - self._values: typing.Set[str] = set([ ]) - self._vals = DynEnumTwoValues(self._bldr, self._values) + self._bldr = _tb.get_enum("DynEnumTwo") + self._vals = DynEnumTwoValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -958,25 +925,20 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class DynEnumTwoValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @@ -985,9 +947,8 @@ def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: class EnumInClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("EnumInClass") - self._values: typing.Set[str] = set([ "ONE", "TWO", ]) - self._vals = EnumInClassValues(self._bldr, self._values) + self._bldr = _tb.get_enum("EnumInClass") + self._vals = EnumInClassValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -997,29 +958,28 @@ def values(self) -> "EnumInClassValues": return self._vals -class EnumInClassViewer(EnumInClassAst): +class EnumInClassBuilder(EnumInClassAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class EnumInClassValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ONE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("ONE")) + def ONE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("ONE")) @property - def TWO(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TWO")) + def TWO(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TWO")) @@ -1027,9 +987,8 @@ def TWO(self) -> type_builder.EnumValueViewer: class EnumOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("EnumOutput") - self._values: typing.Set[str] = set([ "ONE", "TWO", "THREE", ]) - self._vals = EnumOutputValues(self._bldr, self._values) + self._bldr = _tb.get_enum("EnumOutput") + self._vals = EnumOutputValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1039,33 +998,32 @@ def values(self) -> "EnumOutputValues": return self._vals -class EnumOutputViewer(EnumOutputAst): +class EnumOutputBuilder(EnumOutputAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class EnumOutputValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ONE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("ONE")) + def ONE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("ONE")) @property - def TWO(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TWO")) + def TWO(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TWO")) @property - def THREE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("THREE")) + def THREE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("THREE")) @@ -1073,9 +1031,8 @@ def THREE(self) -> type_builder.EnumValueViewer: class HobbyAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Hobby") - self._values: typing.Set[str] = set([ "SPORTS", "MUSIC", "READING", ]) - self._vals = HobbyValues(self._bldr, self._values) + self._bldr = _tb.get_enum("Hobby") + self._vals = HobbyValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1090,38 +1047,33 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class HobbyValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @property - def SPORTS(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("SPORTS") + def SPORTS(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("SPORTS") @property - def MUSIC(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("MUSIC") + def MUSIC(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("MUSIC") @property - def READING(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("READING") + def READING(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("READING") @@ -1129,9 +1081,8 @@ def READING(self) -> baml_py.EnumValueBuilder: class MapKeyAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("MapKey") - self._values: typing.Set[str] = set([ "A", "B", "C", ]) - self._vals = MapKeyValues(self._bldr, self._values) + self._bldr = _tb.get_enum("MapKey") + self._vals = MapKeyValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1141,33 +1092,32 @@ def values(self) -> "MapKeyValues": return self._vals -class MapKeyViewer(MapKeyAst): +class MapKeyBuilder(MapKeyAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class MapKeyValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def A(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("A")) + def A(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("A")) @property - def B(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("B")) + def B(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("B")) @property - def C(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("C")) + def C(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("C")) @@ -1175,9 +1125,8 @@ def C(self) -> type_builder.EnumValueViewer: class NamedArgsSingleEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("NamedArgsSingleEnum") - self._values: typing.Set[str] = set([ "ONE", "TWO", ]) - self._vals = NamedArgsSingleEnumValues(self._bldr, self._values) + self._bldr = _tb.get_enum("NamedArgsSingleEnum") + self._vals = NamedArgsSingleEnumValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1187,29 +1136,28 @@ def values(self) -> "NamedArgsSingleEnumValues": return self._vals -class NamedArgsSingleEnumViewer(NamedArgsSingleEnumAst): +class NamedArgsSingleEnumBuilder(NamedArgsSingleEnumAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class NamedArgsSingleEnumValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ONE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("ONE")) + def ONE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("ONE")) @property - def TWO(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TWO")) + def TWO(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TWO")) @@ -1217,9 +1165,8 @@ def TWO(self) -> type_builder.EnumValueViewer: class NamedArgsSingleEnumListAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("NamedArgsSingleEnumList") - self._values: typing.Set[str] = set([ "ONE", "TWO", ]) - self._vals = NamedArgsSingleEnumListValues(self._bldr, self._values) + self._bldr = _tb.get_enum("NamedArgsSingleEnumList") + self._vals = NamedArgsSingleEnumListValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1229,29 +1176,28 @@ def values(self) -> "NamedArgsSingleEnumListValues": return self._vals -class NamedArgsSingleEnumListViewer(NamedArgsSingleEnumListAst): +class NamedArgsSingleEnumListBuilder(NamedArgsSingleEnumListAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class NamedArgsSingleEnumListValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ONE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("ONE")) + def ONE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("ONE")) @property - def TWO(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TWO")) + def TWO(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TWO")) @@ -1259,9 +1205,8 @@ def TWO(self) -> type_builder.EnumValueViewer: class OptionalTest_CategoryTypeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("OptionalTest_CategoryType") - self._values: typing.Set[str] = set([ "Aleph", "Beta", "Gamma", ]) - self._vals = OptionalTest_CategoryTypeValues(self._bldr, self._values) + self._bldr = _tb.get_enum("OptionalTest_CategoryType") + self._vals = OptionalTest_CategoryTypeValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1271,33 +1216,32 @@ def values(self) -> "OptionalTest_CategoryTypeValues": return self._vals -class OptionalTest_CategoryTypeViewer(OptionalTest_CategoryTypeAst): +class OptionalTest_CategoryTypeBuilder(OptionalTest_CategoryTypeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class OptionalTest_CategoryTypeValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Aleph(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Aleph")) + def Aleph(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Aleph")) @property - def Beta(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Beta")) + def Beta(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Beta")) @property - def Gamma(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Gamma")) + def Gamma(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Gamma")) @@ -1305,9 +1249,8 @@ def Gamma(self) -> type_builder.EnumValueViewer: class OrderStatusAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("OrderStatus") - self._values: typing.Set[str] = set([ "ORDERED", "SHIPPED", "DELIVERED", "CANCELLED", ]) - self._vals = OrderStatusValues(self._bldr, self._values) + self._bldr = _tb.get_enum("OrderStatus") + self._vals = OrderStatusValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1317,37 +1260,36 @@ def values(self) -> "OrderStatusValues": return self._vals -class OrderStatusViewer(OrderStatusAst): +class OrderStatusBuilder(OrderStatusAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class OrderStatusValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ORDERED(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("ORDERED")) + def ORDERED(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("ORDERED")) @property - def SHIPPED(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("SHIPPED")) + def SHIPPED(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("SHIPPED")) @property - def DELIVERED(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("DELIVERED")) + def DELIVERED(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("DELIVERED")) @property - def CANCELLED(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("CANCELLED")) + def CANCELLED(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("CANCELLED")) @@ -1355,9 +1297,8 @@ def CANCELLED(self) -> type_builder.EnumValueViewer: class RenderStatusEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("RenderStatusEnum") - self._values: typing.Set[str] = set([ "ACTIVE", "INACTIVE", ]) - self._vals = RenderStatusEnumValues(self._bldr, self._values) + self._bldr = _tb.get_enum("RenderStatusEnum") + self._vals = RenderStatusEnumValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1372,34 +1313,29 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class RenderStatusEnumValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @property - def ACTIVE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("ACTIVE") + def ACTIVE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("ACTIVE") @property - def INACTIVE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("INACTIVE") + def INACTIVE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("INACTIVE") @@ -1407,9 +1343,8 @@ def INACTIVE(self) -> baml_py.EnumValueBuilder: class RenderTestEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("RenderTestEnum") - self._values: typing.Set[str] = set([ "BIKE", "SCOOTER", ]) - self._vals = RenderTestEnumValues(self._bldr, self._values) + self._bldr = _tb.get_enum("RenderTestEnum") + self._vals = RenderTestEnumValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1424,34 +1359,29 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class RenderTestEnumValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @property - def BIKE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("BIKE") + def BIKE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("BIKE") @property - def SCOOTER(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("SCOOTER") + def SCOOTER(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("SCOOTER") @@ -1459,9 +1389,8 @@ def SCOOTER(self) -> baml_py.EnumValueBuilder: class TagAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Tag") - self._values: typing.Set[str] = set([ "Security", "AI", "Blockchain", ]) - self._vals = TagValues(self._bldr, self._values) + self._bldr = _tb.get_enum("Tag") + self._vals = TagValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1471,33 +1400,32 @@ def values(self) -> "TagValues": return self._vals -class TagViewer(TagAst): +class TagBuilder(TagAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class TagValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Security(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Security")) + def Security(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Security")) @property - def AI(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("AI")) + def AI(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("AI")) @property - def Blockchain(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Blockchain")) + def Blockchain(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Blockchain")) @@ -1505,9 +1433,8 @@ def Blockchain(self) -> type_builder.EnumValueViewer: class TestEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("TestEnum") - self._values: typing.Set[str] = set([ "A", "B", "C", "D", "E", "F", "G", ]) - self._vals = TestEnumValues(self._bldr, self._values) + self._bldr = _tb.get_enum("TestEnum") + self._vals = TestEnumValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1517,49 +1444,48 @@ def values(self) -> "TestEnumValues": return self._vals -class TestEnumViewer(TestEnumAst): +class TestEnumBuilder(TestEnumAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class TestEnumValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def A(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("A")) + def A(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("A")) @property - def B(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("B")) + def B(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("B")) @property - def C(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("C")) + def C(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("C")) @property - def D(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("D")) + def D(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("D")) @property - def E(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("E")) + def E(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("E")) @property - def F(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("F")) + def F(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("F")) @property - def G(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("G")) + def G(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("G")) @@ -1572,9 +1498,8 @@ def G(self) -> type_builder.EnumValueViewer: class AnotherObjectAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("AnotherObject") - self._properties: typing.Set[str] = set([ "id", "thingy2", "thingy3", ]) - self._props = AnotherObjectProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("AnotherObject") + self._props = AnotherObjectProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1584,34 +1509,33 @@ def props(self) -> "AnotherObjectProperties": return self._props -class AnotherObjectViewer(AnotherObjectAst): +class AnotherObjectBuilder(AnotherObjectAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class AnotherObjectProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def id(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("id")) + def id(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("id")) @property - def thingy2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("thingy2")) + def thingy2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("thingy2")) @property - def thingy3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("thingy3")) + def thingy3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("thingy3")) @@ -1619,9 +1543,8 @@ def thingy3(self) -> type_builder.ClassPropertyViewer: class BigNumbersAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("BigNumbers") - self._properties: typing.Set[str] = set([ "a", "b", ]) - self._props = BigNumbersProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("BigNumbers") + self._props = BigNumbersProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1631,30 +1554,29 @@ def props(self) -> "BigNumbersProperties": return self._props -class BigNumbersViewer(BigNumbersAst): +class BigNumbersBuilder(BigNumbersAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BigNumbersProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("a")) + def a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("a")) @property - def b(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("b")) + def b(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("b")) @@ -1662,9 +1584,8 @@ def b(self) -> type_builder.ClassPropertyViewer: class BinaryNodeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("BinaryNode") - self._properties: typing.Set[str] = set([ "data", "left", "right", ]) - self._props = BinaryNodeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("BinaryNode") + self._props = BinaryNodeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1674,34 +1595,33 @@ def props(self) -> "BinaryNodeProperties": return self._props -class BinaryNodeViewer(BinaryNodeAst): +class BinaryNodeBuilder(BinaryNodeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BinaryNodeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def data(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("data")) + def data(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("data")) @property - def left(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("left")) + def left(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("left")) @property - def right(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("right")) + def right(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("right")) @@ -1709,9 +1629,8 @@ def right(self) -> type_builder.ClassPropertyViewer: class BlahAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Blah") - self._properties: typing.Set[str] = set([ "prop4", ]) - self._props = BlahProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Blah") + self._props = BlahProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1721,26 +1640,25 @@ def props(self) -> "BlahProperties": return self._props -class BlahViewer(BlahAst): +class BlahBuilder(BlahAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BlahProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop4(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop4")) + def prop4(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop4")) @@ -1748,9 +1666,8 @@ def prop4(self) -> type_builder.ClassPropertyViewer: class BlockConstraintAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("BlockConstraint") - self._properties: typing.Set[str] = set([ "foo", "bar", ]) - self._props = BlockConstraintProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("BlockConstraint") + self._props = BlockConstraintProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1760,30 +1677,29 @@ def props(self) -> "BlockConstraintProperties": return self._props -class BlockConstraintViewer(BlockConstraintAst): +class BlockConstraintBuilder(BlockConstraintAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BlockConstraintProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def foo(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("foo")) + def foo(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("foo")) @property - def bar(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("bar")) + def bar(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("bar")) @@ -1791,9 +1707,8 @@ def bar(self) -> type_builder.ClassPropertyViewer: class BlockConstraintForParamAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("BlockConstraintForParam") - self._properties: typing.Set[str] = set([ "bcfp", "bcfp2", ]) - self._props = BlockConstraintForParamProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("BlockConstraintForParam") + self._props = BlockConstraintForParamProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1803,30 +1718,29 @@ def props(self) -> "BlockConstraintForParamProperties": return self._props -class BlockConstraintForParamViewer(BlockConstraintForParamAst): +class BlockConstraintForParamBuilder(BlockConstraintForParamAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BlockConstraintForParamProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def bcfp(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("bcfp")) + def bcfp(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("bcfp")) @property - def bcfp2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("bcfp2")) + def bcfp2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("bcfp2")) @@ -1834,9 +1748,8 @@ def bcfp2(self) -> type_builder.ClassPropertyViewer: class BookOrderAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("BookOrder") - self._properties: typing.Set[str] = set([ "orderId", "title", "quantity", "price", ]) - self._props = BookOrderProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("BookOrder") + self._props = BookOrderProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1846,38 +1759,37 @@ def props(self) -> "BookOrderProperties": return self._props -class BookOrderViewer(BookOrderAst): +class BookOrderBuilder(BookOrderAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BookOrderProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def orderId(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("orderId")) + def orderId(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("orderId")) @property - def title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("title")) + def title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("title")) @property - def quantity(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("quantity")) + def quantity(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("quantity")) @property - def price(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("price")) + def price(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("price")) @@ -1885,9 +1797,8 @@ def price(self) -> type_builder.ClassPropertyViewer: class ClassForNullLiteralAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassForNullLiteral") - self._properties: typing.Set[str] = set([ "a", ]) - self._props = ClassForNullLiteralProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassForNullLiteral") + self._props = ClassForNullLiteralProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1897,26 +1808,25 @@ def props(self) -> "ClassForNullLiteralProperties": return self._props -class ClassForNullLiteralViewer(ClassForNullLiteralAst): +class ClassForNullLiteralBuilder(ClassForNullLiteralAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassForNullLiteralProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("a")) + def a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("a")) @@ -1924,9 +1834,8 @@ def a(self) -> type_builder.ClassPropertyViewer: class ClassOptionalOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassOptionalOutput") - self._properties: typing.Set[str] = set([ "prop1", "prop2", ]) - self._props = ClassOptionalOutputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassOptionalOutput") + self._props = ClassOptionalOutputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1936,30 +1845,29 @@ def props(self) -> "ClassOptionalOutputProperties": return self._props -class ClassOptionalOutputViewer(ClassOptionalOutputAst): +class ClassOptionalOutputBuilder(ClassOptionalOutputAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassOptionalOutputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @@ -1967,9 +1875,8 @@ def prop2(self) -> type_builder.ClassPropertyViewer: class ClassOptionalOutput2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassOptionalOutput2") - self._properties: typing.Set[str] = set([ "prop1", "prop2", "prop3", ]) - self._props = ClassOptionalOutput2Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassOptionalOutput2") + self._props = ClassOptionalOutput2Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1979,34 +1886,33 @@ def props(self) -> "ClassOptionalOutput2Properties": return self._props -class ClassOptionalOutput2Viewer(ClassOptionalOutput2Ast): +class ClassOptionalOutput2Builder(ClassOptionalOutput2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassOptionalOutput2Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @property - def prop3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop3")) + def prop3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop3")) @@ -2014,9 +1920,8 @@ def prop3(self) -> type_builder.ClassPropertyViewer: class ClassToRecAliasAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassToRecAlias") - self._properties: typing.Set[str] = set([ "list", ]) - self._props = ClassToRecAliasProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassToRecAlias") + self._props = ClassToRecAliasProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2026,26 +1931,25 @@ def props(self) -> "ClassToRecAliasProperties": return self._props -class ClassToRecAliasViewer(ClassToRecAliasAst): +class ClassToRecAliasBuilder(ClassToRecAliasAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassToRecAliasProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def list(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("list")) + def list(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("list")) @@ -2053,9 +1957,8 @@ def list(self) -> type_builder.ClassPropertyViewer: class ClassWithBlockDoneAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassWithBlockDone") - self._properties: typing.Set[str] = set([ "i_16_digits", "s_20_words", ]) - self._props = ClassWithBlockDoneProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassWithBlockDone") + self._props = ClassWithBlockDoneProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2065,30 +1968,29 @@ def props(self) -> "ClassWithBlockDoneProperties": return self._props -class ClassWithBlockDoneViewer(ClassWithBlockDoneAst): +class ClassWithBlockDoneBuilder(ClassWithBlockDoneAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassWithBlockDoneProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def i_16_digits(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("i_16_digits")) + def i_16_digits(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("i_16_digits")) @property - def s_20_words(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("s_20_words")) + def s_20_words(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("s_20_words")) @@ -2096,9 +1998,8 @@ def s_20_words(self) -> type_builder.ClassPropertyViewer: class ClassWithImageAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassWithImage") - self._properties: typing.Set[str] = set([ "myImage", "param2", "fake_image", ]) - self._props = ClassWithImageProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassWithImage") + self._props = ClassWithImageProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2108,34 +2009,33 @@ def props(self) -> "ClassWithImageProperties": return self._props -class ClassWithImageViewer(ClassWithImageAst): +class ClassWithImageBuilder(ClassWithImageAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassWithImageProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def myImage(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("myImage")) + def myImage(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("myImage")) @property - def param2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("param2")) + def param2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("param2")) @property - def fake_image(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("fake_image")) + def fake_image(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("fake_image")) @@ -2143,9 +2043,8 @@ def fake_image(self) -> type_builder.ClassPropertyViewer: class ClassWithoutDoneAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassWithoutDone") - self._properties: typing.Set[str] = set([ "i_16_digits", "s_20_words", ]) - self._props = ClassWithoutDoneProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassWithoutDone") + self._props = ClassWithoutDoneProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2155,30 +2054,29 @@ def props(self) -> "ClassWithoutDoneProperties": return self._props -class ClassWithoutDoneViewer(ClassWithoutDoneAst): +class ClassWithoutDoneBuilder(ClassWithoutDoneAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassWithoutDoneProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def i_16_digits(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("i_16_digits")) + def i_16_digits(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("i_16_digits")) @property - def s_20_words(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("s_20_words")) + def s_20_words(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("s_20_words")) @@ -2186,9 +2084,8 @@ def s_20_words(self) -> type_builder.ClassPropertyViewer: class ClientDetails1559Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClientDetails1559") - self._properties: typing.Set[str] = set([ "client_name", "client_address", "client_postal_code", "client_city", "client_country", "client_phone", "client_email", ]) - self._props = ClientDetails1559Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClientDetails1559") + self._props = ClientDetails1559Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2198,50 +2095,49 @@ def props(self) -> "ClientDetails1559Properties": return self._props -class ClientDetails1559Viewer(ClientDetails1559Ast): +class ClientDetails1559Builder(ClientDetails1559Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClientDetails1559Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def client_name(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_name")) + def client_name(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_name")) @property - def client_address(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_address")) + def client_address(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_address")) @property - def client_postal_code(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_postal_code")) + def client_postal_code(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_postal_code")) @property - def client_city(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_city")) + def client_city(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_city")) @property - def client_country(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_country")) + def client_country(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_country")) @property - def client_phone(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_phone")) + def client_phone(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_phone")) @property - def client_email(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_email")) + def client_email(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_email")) @@ -2249,9 +2145,8 @@ def client_email(self) -> type_builder.ClassPropertyViewer: class ComplexMemoryObjectAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ComplexMemoryObject") - self._properties: typing.Set[str] = set([ "id", "name", "description", "metadata", ]) - self._props = ComplexMemoryObjectProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ComplexMemoryObject") + self._props = ComplexMemoryObjectProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2261,38 +2156,37 @@ def props(self) -> "ComplexMemoryObjectProperties": return self._props -class ComplexMemoryObjectViewer(ComplexMemoryObjectAst): +class ComplexMemoryObjectBuilder(ComplexMemoryObjectAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ComplexMemoryObjectProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def id(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("id")) + def id(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("id")) @property - def name(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("name")) + def name(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("name")) @property - def description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("description")) + def description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("description")) @property - def metadata(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("metadata")) + def metadata(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("metadata")) @@ -2300,9 +2194,8 @@ def metadata(self) -> type_builder.ClassPropertyViewer: class CompoundBigNumbersAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("CompoundBigNumbers") - self._properties: typing.Set[str] = set([ "big", "big_nums", "another", ]) - self._props = CompoundBigNumbersProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("CompoundBigNumbers") + self._props = CompoundBigNumbersProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2312,34 +2205,33 @@ def props(self) -> "CompoundBigNumbersProperties": return self._props -class CompoundBigNumbersViewer(CompoundBigNumbersAst): +class CompoundBigNumbersBuilder(CompoundBigNumbersAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class CompoundBigNumbersProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def big(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("big")) + def big(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("big")) @property - def big_nums(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("big_nums")) + def big_nums(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("big_nums")) @property - def another(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("another")) + def another(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("another")) @@ -2347,9 +2239,8 @@ def another(self) -> type_builder.ClassPropertyViewer: class ContactInfoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ContactInfo") - self._properties: typing.Set[str] = set([ "primary", "secondary", ]) - self._props = ContactInfoProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ContactInfo") + self._props = ContactInfoProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2359,30 +2250,29 @@ def props(self) -> "ContactInfoProperties": return self._props -class ContactInfoViewer(ContactInfoAst): +class ContactInfoBuilder(ContactInfoAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ContactInfoProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def primary(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("primary")) + def primary(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("primary")) @property - def secondary(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("secondary")) + def secondary(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("secondary")) @@ -2390,9 +2280,8 @@ def secondary(self) -> type_builder.ClassPropertyViewer: class CustomStoryAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("CustomStory") - self._properties: typing.Set[str] = set([ "title", "characters", "content", ]) - self._props = CustomStoryProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("CustomStory") + self._props = CustomStoryProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2402,34 +2291,33 @@ def props(self) -> "CustomStoryProperties": return self._props -class CustomStoryViewer(CustomStoryAst): +class CustomStoryBuilder(CustomStoryAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class CustomStoryProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("title")) + def title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("title")) @property - def characters(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("characters")) + def characters(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("characters")) @property - def content(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("content")) + def content(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("content")) @@ -2437,9 +2325,8 @@ def content(self) -> type_builder.ClassPropertyViewer: class CustomTaskResultAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("CustomTaskResult") - self._properties: typing.Set[str] = set([ "bookOrder", "flightConfirmation", "groceryReceipt", ]) - self._props = CustomTaskResultProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("CustomTaskResult") + self._props = CustomTaskResultProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2449,34 +2336,33 @@ def props(self) -> "CustomTaskResultProperties": return self._props -class CustomTaskResultViewer(CustomTaskResultAst): +class CustomTaskResultBuilder(CustomTaskResultAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class CustomTaskResultProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def bookOrder(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("bookOrder")) + def bookOrder(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("bookOrder")) @property - def flightConfirmation(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("flightConfirmation")) + def flightConfirmation(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("flightConfirmation")) @property - def groceryReceipt(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("groceryReceipt")) + def groceryReceipt(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("groceryReceipt")) @@ -2484,9 +2370,8 @@ def groceryReceipt(self) -> type_builder.ClassPropertyViewer: class Document1559Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Document1559") - self._properties: typing.Set[str] = set([ "client_details", "notes", ]) - self._props = Document1559Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("Document1559") + self._props = Document1559Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2496,30 +2381,29 @@ def props(self) -> "Document1559Properties": return self._props -class Document1559Viewer(Document1559Ast): +class Document1559Builder(Document1559Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class Document1559Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def client_details(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_details")) + def client_details(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_details")) @property - def notes(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("notes")) + def notes(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("notes")) @@ -2527,9 +2411,8 @@ def notes(self) -> type_builder.ClassPropertyViewer: class DummyOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DummyOutput") - self._properties: typing.Set[str] = set([ "nonce", "nonce2", ]) - self._props = DummyOutputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DummyOutput") + self._props = DummyOutputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2544,12 +2427,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2562,24 +2443,21 @@ def reset(self) -> None: class DummyOutputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def nonce(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("nonce") + def nonce(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("nonce") @property - def nonce2(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("nonce2") + def nonce2(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("nonce2") @@ -2587,9 +2465,8 @@ def nonce2(self) -> baml_py.ClassPropertyBuilder: class DynInputOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DynInputOutput") - self._properties: typing.Set[str] = set([ "testKey", ]) - self._props = DynInputOutputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DynInputOutput") + self._props = DynInputOutputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2604,12 +2481,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2622,20 +2497,17 @@ def reset(self) -> None: class DynInputOutputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def testKey(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("testKey") + def testKey(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("testKey") @@ -2643,9 +2515,8 @@ def testKey(self) -> baml_py.ClassPropertyBuilder: class DynamicClassOneAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DynamicClassOne") - self._properties: typing.Set[str] = set([ ]) - self._props = DynamicClassOneProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DynamicClassOne") + self._props = DynamicClassOneProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2660,12 +2531,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2678,15 +2547,12 @@ def reset(self) -> None: class DynamicClassOneProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @@ -2695,9 +2561,8 @@ def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: class DynamicClassTwoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DynamicClassTwo") - self._properties: typing.Set[str] = set([ "hi", "some_class", "status", ]) - self._props = DynamicClassTwoProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DynamicClassTwo") + self._props = DynamicClassTwoProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2712,12 +2577,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2730,28 +2593,25 @@ def reset(self) -> None: class DynamicClassTwoProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def hi(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("hi") + def hi(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("hi") @property - def some_class(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("some_class") + def some_class(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("some_class") @property - def status(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("status") + def status(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("status") @@ -2759,9 +2619,8 @@ def status(self) -> baml_py.ClassPropertyBuilder: class DynamicOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DynamicOutput") - self._properties: typing.Set[str] = set([ ]) - self._props = DynamicOutputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DynamicOutput") + self._props = DynamicOutputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2776,12 +2635,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2794,15 +2651,12 @@ def reset(self) -> None: class DynamicOutputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @@ -2811,9 +2665,8 @@ def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: class DynamicSchemaAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DynamicSchema") - self._properties: typing.Set[str] = set([ ]) - self._props = DynamicSchemaProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DynamicSchema") + self._props = DynamicSchemaProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2828,12 +2681,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2846,15 +2697,12 @@ def reset(self) -> None: class DynamicSchemaProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @@ -2863,9 +2711,8 @@ def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: class EarthlingAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Earthling") - self._properties: typing.Set[str] = set([ "age", ]) - self._props = EarthlingProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Earthling") + self._props = EarthlingProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2875,26 +2722,25 @@ def props(self) -> "EarthlingProperties": return self._props -class EarthlingViewer(EarthlingAst): +class EarthlingBuilder(EarthlingAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class EarthlingProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def age(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("age")) + def age(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("age")) @@ -2902,9 +2748,8 @@ def age(self) -> type_builder.ClassPropertyViewer: class EducationAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Education") - self._properties: typing.Set[str] = set([ "institution", "location", "degree", "major", "graduation_date", ]) - self._props = EducationProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Education") + self._props = EducationProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2914,42 +2759,41 @@ def props(self) -> "EducationProperties": return self._props -class EducationViewer(EducationAst): +class EducationBuilder(EducationAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class EducationProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def institution(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("institution")) + def institution(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("institution")) @property - def location(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("location")) + def location(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("location")) @property - def degree(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("degree")) + def degree(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("degree")) @property - def major(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("major")) + def major(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("major")) @property - def graduation_date(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("graduation_date")) + def graduation_date(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("graduation_date")) @@ -2957,9 +2801,8 @@ def graduation_date(self) -> type_builder.ClassPropertyViewer: class EmailAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Email") - self._properties: typing.Set[str] = set([ "subject", "body", "from_address", ]) - self._props = EmailProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Email") + self._props = EmailProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2969,34 +2812,33 @@ def props(self) -> "EmailProperties": return self._props -class EmailViewer(EmailAst): +class EmailBuilder(EmailAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class EmailProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def subject(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("subject")) + def subject(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("subject")) @property - def body(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("body")) + def body(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("body")) @property - def from_address(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("from_address")) + def from_address(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("from_address")) @@ -3004,9 +2846,8 @@ def from_address(self) -> type_builder.ClassPropertyViewer: class EmailAddressAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("EmailAddress") - self._properties: typing.Set[str] = set([ "value", ]) - self._props = EmailAddressProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("EmailAddress") + self._props = EmailAddressProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3016,26 +2857,25 @@ def props(self) -> "EmailAddressProperties": return self._props -class EmailAddressViewer(EmailAddressAst): +class EmailAddressBuilder(EmailAddressAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class EmailAddressProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @@ -3043,9 +2883,8 @@ def value(self) -> type_builder.ClassPropertyViewer: class EventAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Event") - self._properties: typing.Set[str] = set([ "title", "date", "location", "description", ]) - self._props = EventProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Event") + self._props = EventProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3055,38 +2894,37 @@ def props(self) -> "EventProperties": return self._props -class EventViewer(EventAst): +class EventBuilder(EventAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class EventProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("title")) + def title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("title")) @property - def date(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("date")) + def date(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("date")) @property - def location(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("location")) + def location(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("location")) @property - def description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("description")) + def description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("description")) @@ -3094,9 +2932,8 @@ def description(self) -> type_builder.ClassPropertyViewer: class FakeImageAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FakeImage") - self._properties: typing.Set[str] = set([ "url", ]) - self._props = FakeImageProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("FakeImage") + self._props = FakeImageProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3106,26 +2943,25 @@ def props(self) -> "FakeImageProperties": return self._props -class FakeImageViewer(FakeImageAst): +class FakeImageBuilder(FakeImageAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FakeImageProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def url(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("url")) + def url(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("url")) @@ -3133,9 +2969,8 @@ def url(self) -> type_builder.ClassPropertyViewer: class FlightConfirmationAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FlightConfirmation") - self._properties: typing.Set[str] = set([ "confirmationNumber", "flightNumber", "departureTime", "arrivalTime", "seatNumber", ]) - self._props = FlightConfirmationProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("FlightConfirmation") + self._props = FlightConfirmationProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3145,42 +2980,41 @@ def props(self) -> "FlightConfirmationProperties": return self._props -class FlightConfirmationViewer(FlightConfirmationAst): +class FlightConfirmationBuilder(FlightConfirmationAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FlightConfirmationProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def confirmationNumber(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("confirmationNumber")) + def confirmationNumber(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("confirmationNumber")) @property - def flightNumber(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("flightNumber")) + def flightNumber(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("flightNumber")) @property - def departureTime(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("departureTime")) + def departureTime(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("departureTime")) @property - def arrivalTime(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("arrivalTime")) + def arrivalTime(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("arrivalTime")) @property - def seatNumber(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("seatNumber")) + def seatNumber(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("seatNumber")) @@ -3188,9 +3022,8 @@ def seatNumber(self) -> type_builder.ClassPropertyViewer: class FooAnyAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FooAny") - self._properties: typing.Set[str] = set([ "planetary_age", "certainty", "species", ]) - self._props = FooAnyProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("FooAny") + self._props = FooAnyProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3200,34 +3033,33 @@ def props(self) -> "FooAnyProperties": return self._props -class FooAnyViewer(FooAnyAst): +class FooAnyBuilder(FooAnyAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FooAnyProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def planetary_age(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("planetary_age")) + def planetary_age(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("planetary_age")) @property - def certainty(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("certainty")) + def certainty(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("certainty")) @property - def species(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("species")) + def species(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("species")) @@ -3235,9 +3067,8 @@ def species(self) -> type_builder.ClassPropertyViewer: class ForestAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Forest") - self._properties: typing.Set[str] = set([ "trees", ]) - self._props = ForestProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Forest") + self._props = ForestProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3247,26 +3078,25 @@ def props(self) -> "ForestProperties": return self._props -class ForestViewer(ForestAst): +class ForestBuilder(ForestAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ForestProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def trees(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("trees")) + def trees(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("trees")) @@ -3274,9 +3104,8 @@ def trees(self) -> type_builder.ClassPropertyViewer: class FormatterTest0Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FormatterTest0") - self._properties: typing.Set[str] = set([ "lorem", "ipsum", ]) - self._props = FormatterTest0Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("FormatterTest0") + self._props = FormatterTest0Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3286,30 +3115,29 @@ def props(self) -> "FormatterTest0Properties": return self._props -class FormatterTest0Viewer(FormatterTest0Ast): +class FormatterTest0Builder(FormatterTest0Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FormatterTest0Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def lorem(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("lorem")) + def lorem(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("lorem")) @property - def ipsum(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("ipsum")) + def ipsum(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("ipsum")) @@ -3317,9 +3145,8 @@ def ipsum(self) -> type_builder.ClassPropertyViewer: class FormatterTest1Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FormatterTest1") - self._properties: typing.Set[str] = set([ "lorem", "ipsum", ]) - self._props = FormatterTest1Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("FormatterTest1") + self._props = FormatterTest1Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3329,30 +3156,29 @@ def props(self) -> "FormatterTest1Properties": return self._props -class FormatterTest1Viewer(FormatterTest1Ast): +class FormatterTest1Builder(FormatterTest1Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FormatterTest1Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def lorem(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("lorem")) + def lorem(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("lorem")) @property - def ipsum(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("ipsum")) + def ipsum(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("ipsum")) @@ -3360,9 +3186,8 @@ def ipsum(self) -> type_builder.ClassPropertyViewer: class FormatterTest2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FormatterTest2") - self._properties: typing.Set[str] = set([ "lorem", "ipsum", ]) - self._props = FormatterTest2Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("FormatterTest2") + self._props = FormatterTest2Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3372,30 +3197,29 @@ def props(self) -> "FormatterTest2Properties": return self._props -class FormatterTest2Viewer(FormatterTest2Ast): +class FormatterTest2Builder(FormatterTest2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FormatterTest2Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def lorem(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("lorem")) + def lorem(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("lorem")) @property - def ipsum(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("ipsum")) + def ipsum(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("ipsum")) @@ -3403,9 +3227,8 @@ def ipsum(self) -> type_builder.ClassPropertyViewer: class FormatterTest3Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FormatterTest3") - self._properties: typing.Set[str] = set([ "lorem", "ipsum", ]) - self._props = FormatterTest3Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("FormatterTest3") + self._props = FormatterTest3Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3415,30 +3238,29 @@ def props(self) -> "FormatterTest3Properties": return self._props -class FormatterTest3Viewer(FormatterTest3Ast): +class FormatterTest3Builder(FormatterTest3Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FormatterTest3Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def lorem(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("lorem")) + def lorem(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("lorem")) @property - def ipsum(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("ipsum")) + def ipsum(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("ipsum")) @@ -3446,9 +3268,8 @@ def ipsum(self) -> type_builder.ClassPropertyViewer: class GroceryReceiptAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("GroceryReceipt") - self._properties: typing.Set[str] = set([ "receiptId", "storeName", "items", "totalAmount", ]) - self._props = GroceryReceiptProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("GroceryReceipt") + self._props = GroceryReceiptProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3458,38 +3279,37 @@ def props(self) -> "GroceryReceiptProperties": return self._props -class GroceryReceiptViewer(GroceryReceiptAst): +class GroceryReceiptBuilder(GroceryReceiptAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class GroceryReceiptProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def receiptId(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("receiptId")) + def receiptId(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("receiptId")) @property - def storeName(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("storeName")) + def storeName(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("storeName")) @property - def items(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("items")) + def items(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("items")) @property - def totalAmount(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("totalAmount")) + def totalAmount(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("totalAmount")) @@ -3497,9 +3317,8 @@ def totalAmount(self) -> type_builder.ClassPropertyViewer: class HaikuAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Haiku") - self._properties: typing.Set[str] = set([ "line1", "line2", "line3", ]) - self._props = HaikuProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Haiku") + self._props = HaikuProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3509,34 +3328,33 @@ def props(self) -> "HaikuProperties": return self._props -class HaikuViewer(HaikuAst): +class HaikuBuilder(HaikuAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class HaikuProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def line1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("line1")) + def line1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("line1")) @property - def line2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("line2")) + def line2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("line2")) @property - def line3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("line3")) + def line3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("line3")) @@ -3544,9 +3362,8 @@ def line3(self) -> type_builder.ClassPropertyViewer: class InnerClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("InnerClass") - self._properties: typing.Set[str] = set([ "prop1", "prop2", "inner", ]) - self._props = InnerClassProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("InnerClass") + self._props = InnerClassProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3556,34 +3373,33 @@ def props(self) -> "InnerClassProperties": return self._props -class InnerClassViewer(InnerClassAst): +class InnerClassBuilder(InnerClassAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class InnerClassProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @property - def inner(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("inner")) + def inner(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("inner")) @@ -3591,9 +3407,8 @@ def inner(self) -> type_builder.ClassPropertyViewer: class InnerClass2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("InnerClass2") - self._properties: typing.Set[str] = set([ "prop2", "prop3", ]) - self._props = InnerClass2Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("InnerClass2") + self._props = InnerClass2Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3603,30 +3418,29 @@ def props(self) -> "InnerClass2Properties": return self._props -class InnerClass2Viewer(InnerClass2Ast): +class InnerClass2Builder(InnerClass2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class InnerClass2Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @property - def prop3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop3")) + def prop3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop3")) @@ -3634,9 +3448,8 @@ def prop3(self) -> type_builder.ClassPropertyViewer: class InputClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("InputClass") - self._properties: typing.Set[str] = set([ "key", "key2", ]) - self._props = InputClassProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("InputClass") + self._props = InputClassProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3646,30 +3459,29 @@ def props(self) -> "InputClassProperties": return self._props -class InputClassViewer(InputClassAst): +class InputClassBuilder(InputClassAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class InputClassProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def key(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key")) + def key(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key")) @property - def key2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key2")) + def key2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key2")) @@ -3677,9 +3489,8 @@ def key2(self) -> type_builder.ClassPropertyViewer: class InputClassNestedAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("InputClassNested") - self._properties: typing.Set[str] = set([ "key", "nested", ]) - self._props = InputClassNestedProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("InputClassNested") + self._props = InputClassNestedProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3689,30 +3500,29 @@ def props(self) -> "InputClassNestedProperties": return self._props -class InputClassNestedViewer(InputClassNestedAst): +class InputClassNestedBuilder(InputClassNestedAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class InputClassNestedProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def key(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key")) + def key(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key")) @property - def nested(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("nested")) + def nested(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("nested")) @@ -3720,9 +3530,8 @@ def nested(self) -> type_builder.ClassPropertyViewer: class LinkedListAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("LinkedList") - self._properties: typing.Set[str] = set([ "head", "len", ]) - self._props = LinkedListProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("LinkedList") + self._props = LinkedListProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3732,30 +3541,29 @@ def props(self) -> "LinkedListProperties": return self._props -class LinkedListViewer(LinkedListAst): +class LinkedListBuilder(LinkedListAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class LinkedListProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def head(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("head")) + def head(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("head")) @property - def len(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("len")) + def len(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("len")) @@ -3763,9 +3571,8 @@ def len(self) -> type_builder.ClassPropertyViewer: class LinkedListAliasNodeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("LinkedListAliasNode") - self._properties: typing.Set[str] = set([ "value", "next", ]) - self._props = LinkedListAliasNodeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("LinkedListAliasNode") + self._props = LinkedListAliasNodeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3775,30 +3582,29 @@ def props(self) -> "LinkedListAliasNodeProperties": return self._props -class LinkedListAliasNodeViewer(LinkedListAliasNodeAst): +class LinkedListAliasNodeBuilder(LinkedListAliasNodeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class LinkedListAliasNodeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @property - def next(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("next")) + def next(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("next")) @@ -3806,9 +3612,8 @@ def next(self) -> type_builder.ClassPropertyViewer: class LiteralClassHelloAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("LiteralClassHello") - self._properties: typing.Set[str] = set([ "prop", ]) - self._props = LiteralClassHelloProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("LiteralClassHello") + self._props = LiteralClassHelloProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3818,26 +3623,25 @@ def props(self) -> "LiteralClassHelloProperties": return self._props -class LiteralClassHelloViewer(LiteralClassHelloAst): +class LiteralClassHelloBuilder(LiteralClassHelloAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class LiteralClassHelloProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop")) + def prop(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop")) @@ -3845,9 +3649,8 @@ def prop(self) -> type_builder.ClassPropertyViewer: class LiteralClassOneAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("LiteralClassOne") - self._properties: typing.Set[str] = set([ "prop", ]) - self._props = LiteralClassOneProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("LiteralClassOne") + self._props = LiteralClassOneProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3857,26 +3660,25 @@ def props(self) -> "LiteralClassOneProperties": return self._props -class LiteralClassOneViewer(LiteralClassOneAst): +class LiteralClassOneBuilder(LiteralClassOneAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class LiteralClassOneProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop")) + def prop(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop")) @@ -3884,9 +3686,8 @@ def prop(self) -> type_builder.ClassPropertyViewer: class LiteralClassTwoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("LiteralClassTwo") - self._properties: typing.Set[str] = set([ "prop", ]) - self._props = LiteralClassTwoProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("LiteralClassTwo") + self._props = LiteralClassTwoProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3896,26 +3697,25 @@ def props(self) -> "LiteralClassTwoProperties": return self._props -class LiteralClassTwoViewer(LiteralClassTwoAst): +class LiteralClassTwoBuilder(LiteralClassTwoAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class LiteralClassTwoProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop")) + def prop(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop")) @@ -3923,9 +3723,8 @@ def prop(self) -> type_builder.ClassPropertyViewer: class MaintainFieldOrderAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("MaintainFieldOrder") - self._properties: typing.Set[str] = set([ "a", "b", "c", ]) - self._props = MaintainFieldOrderProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("MaintainFieldOrder") + self._props = MaintainFieldOrderProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3935,34 +3734,33 @@ def props(self) -> "MaintainFieldOrderProperties": return self._props -class MaintainFieldOrderViewer(MaintainFieldOrderAst): +class MaintainFieldOrderBuilder(MaintainFieldOrderAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MaintainFieldOrderProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("a")) + def a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("a")) @property - def b(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("b")) + def b(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("b")) @property - def c(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("c")) + def c(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("c")) @@ -3970,9 +3768,8 @@ def c(self) -> type_builder.ClassPropertyViewer: class MalformedConstraintsAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("MalformedConstraints") - self._properties: typing.Set[str] = set([ "foo", ]) - self._props = MalformedConstraintsProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("MalformedConstraints") + self._props = MalformedConstraintsProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3982,26 +3779,25 @@ def props(self) -> "MalformedConstraintsProperties": return self._props -class MalformedConstraintsViewer(MalformedConstraintsAst): +class MalformedConstraintsBuilder(MalformedConstraintsAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MalformedConstraintsProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def foo(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("foo")) + def foo(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("foo")) @@ -4009,9 +3805,8 @@ def foo(self) -> type_builder.ClassPropertyViewer: class MalformedConstraints2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("MalformedConstraints2") - self._properties: typing.Set[str] = set([ "foo", ]) - self._props = MalformedConstraints2Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("MalformedConstraints2") + self._props = MalformedConstraints2Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4021,26 +3816,25 @@ def props(self) -> "MalformedConstraints2Properties": return self._props -class MalformedConstraints2Viewer(MalformedConstraints2Ast): +class MalformedConstraints2Builder(MalformedConstraints2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MalformedConstraints2Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def foo(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("foo")) + def foo(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("foo")) @@ -4048,9 +3842,8 @@ def foo(self) -> type_builder.ClassPropertyViewer: class MartianAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Martian") - self._properties: typing.Set[str] = set([ "age", ]) - self._props = MartianProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Martian") + self._props = MartianProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4060,26 +3853,25 @@ def props(self) -> "MartianProperties": return self._props -class MartianViewer(MartianAst): +class MartianBuilder(MartianAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MartianProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def age(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("age")) + def age(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("age")) @@ -4087,9 +3879,8 @@ def age(self) -> type_builder.ClassPropertyViewer: class MemoryObjectAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("MemoryObject") - self._properties: typing.Set[str] = set([ "id", "name", "description", ]) - self._props = MemoryObjectProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("MemoryObject") + self._props = MemoryObjectProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4099,34 +3890,33 @@ def props(self) -> "MemoryObjectProperties": return self._props -class MemoryObjectViewer(MemoryObjectAst): +class MemoryObjectBuilder(MemoryObjectAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MemoryObjectProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def id(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("id")) + def id(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("id")) @property - def name(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("name")) + def name(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("name")) @property - def description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("description")) + def description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("description")) @@ -4134,9 +3924,8 @@ def description(self) -> type_builder.ClassPropertyViewer: class MergeAttrsAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("MergeAttrs") - self._properties: typing.Set[str] = set([ "amount", ]) - self._props = MergeAttrsProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("MergeAttrs") + self._props = MergeAttrsProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4146,26 +3935,25 @@ def props(self) -> "MergeAttrsProperties": return self._props -class MergeAttrsViewer(MergeAttrsAst): +class MergeAttrsBuilder(MergeAttrsAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MergeAttrsProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def amount(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("amount")) + def amount(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("amount")) @@ -4173,9 +3961,8 @@ def amount(self) -> type_builder.ClassPropertyViewer: class NamedArgsSingleClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("NamedArgsSingleClass") - self._properties: typing.Set[str] = set([ "key", "key_two", "key_three", ]) - self._props = NamedArgsSingleClassProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("NamedArgsSingleClass") + self._props = NamedArgsSingleClassProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4185,34 +3972,33 @@ def props(self) -> "NamedArgsSingleClassProperties": return self._props -class NamedArgsSingleClassViewer(NamedArgsSingleClassAst): +class NamedArgsSingleClassBuilder(NamedArgsSingleClassAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NamedArgsSingleClassProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def key(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key")) + def key(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key")) @property - def key_two(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key_two")) + def key_two(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key_two")) @property - def key_three(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key_three")) + def key_three(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key_three")) @@ -4220,9 +4006,8 @@ def key_three(self) -> type_builder.ClassPropertyViewer: class NestedAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Nested") - self._properties: typing.Set[str] = set([ "prop3", "prop4", "prop20", ]) - self._props = NestedProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Nested") + self._props = NestedProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4232,34 +4017,33 @@ def props(self) -> "NestedProperties": return self._props -class NestedViewer(NestedAst): +class NestedBuilder(NestedAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NestedProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop3")) + def prop3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop3")) @property - def prop4(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop4")) + def prop4(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop4")) @property - def prop20(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop20")) + def prop20(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop20")) @@ -4267,9 +4051,8 @@ def prop20(self) -> type_builder.ClassPropertyViewer: class Nested2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Nested2") - self._properties: typing.Set[str] = set([ "prop11", "prop12", ]) - self._props = Nested2Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("Nested2") + self._props = Nested2Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4279,30 +4062,29 @@ def props(self) -> "Nested2Properties": return self._props -class Nested2Viewer(Nested2Ast): +class Nested2Builder(Nested2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class Nested2Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop11(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop11")) + def prop11(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop11")) @property - def prop12(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop12")) + def prop12(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop12")) @@ -4310,9 +4092,8 @@ def prop12(self) -> type_builder.ClassPropertyViewer: class NestedBlockConstraintAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("NestedBlockConstraint") - self._properties: typing.Set[str] = set([ "nbc", ]) - self._props = NestedBlockConstraintProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("NestedBlockConstraint") + self._props = NestedBlockConstraintProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4322,26 +4103,25 @@ def props(self) -> "NestedBlockConstraintProperties": return self._props -class NestedBlockConstraintViewer(NestedBlockConstraintAst): +class NestedBlockConstraintBuilder(NestedBlockConstraintAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NestedBlockConstraintProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def nbc(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("nbc")) + def nbc(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("nbc")) @@ -4349,9 +4129,8 @@ def nbc(self) -> type_builder.ClassPropertyViewer: class NestedBlockConstraintForParamAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("NestedBlockConstraintForParam") - self._properties: typing.Set[str] = set([ "nbcfp", ]) - self._props = NestedBlockConstraintForParamProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("NestedBlockConstraintForParam") + self._props = NestedBlockConstraintForParamProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4361,26 +4140,25 @@ def props(self) -> "NestedBlockConstraintForParamProperties": return self._props -class NestedBlockConstraintForParamViewer(NestedBlockConstraintForParamAst): +class NestedBlockConstraintForParamBuilder(NestedBlockConstraintForParamAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NestedBlockConstraintForParamProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def nbcfp(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("nbcfp")) + def nbcfp(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("nbcfp")) @@ -4388,9 +4166,8 @@ def nbcfp(self) -> type_builder.ClassPropertyViewer: class NodeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Node") - self._properties: typing.Set[str] = set([ "data", "next", ]) - self._props = NodeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Node") + self._props = NodeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4400,30 +4177,29 @@ def props(self) -> "NodeProperties": return self._props -class NodeViewer(NodeAst): +class NodeBuilder(NodeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NodeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def data(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("data")) + def data(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("data")) @property - def next(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("next")) + def next(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("next")) @@ -4431,9 +4207,8 @@ def next(self) -> type_builder.ClassPropertyViewer: class NodeWithAliasIndirectionAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("NodeWithAliasIndirection") - self._properties: typing.Set[str] = set([ "value", "next", ]) - self._props = NodeWithAliasIndirectionProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("NodeWithAliasIndirection") + self._props = NodeWithAliasIndirectionProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4443,30 +4218,29 @@ def props(self) -> "NodeWithAliasIndirectionProperties": return self._props -class NodeWithAliasIndirectionViewer(NodeWithAliasIndirectionAst): +class NodeWithAliasIndirectionBuilder(NodeWithAliasIndirectionAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NodeWithAliasIndirectionProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @property - def next(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("next")) + def next(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("next")) @@ -4474,9 +4248,8 @@ def next(self) -> type_builder.ClassPropertyViewer: class Note1599Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Note1599") - self._properties: typing.Set[str] = set([ "note_title", "note_description", "note_amount", ]) - self._props = Note1599Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("Note1599") + self._props = Note1599Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4486,34 +4259,33 @@ def props(self) -> "Note1599Properties": return self._props -class Note1599Viewer(Note1599Ast): +class Note1599Builder(Note1599Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class Note1599Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def note_title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("note_title")) + def note_title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("note_title")) @property - def note_description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("note_description")) + def note_description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("note_description")) @property - def note_amount(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("note_amount")) + def note_amount(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("note_amount")) @@ -4521,9 +4293,8 @@ def note_amount(self) -> type_builder.ClassPropertyViewer: class OptionalListAndMapAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OptionalListAndMap") - self._properties: typing.Set[str] = set([ "p", "q", ]) - self._props = OptionalListAndMapProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("OptionalListAndMap") + self._props = OptionalListAndMapProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4533,30 +4304,29 @@ def props(self) -> "OptionalListAndMapProperties": return self._props -class OptionalListAndMapViewer(OptionalListAndMapAst): +class OptionalListAndMapBuilder(OptionalListAndMapAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class OptionalListAndMapProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def p(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("p")) + def p(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("p")) @property - def q(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("q")) + def q(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("q")) @@ -4564,9 +4334,8 @@ def q(self) -> type_builder.ClassPropertyViewer: class OptionalTest_Prop1Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OptionalTest_Prop1") - self._properties: typing.Set[str] = set([ "omega_a", "omega_b", ]) - self._props = OptionalTest_Prop1Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("OptionalTest_Prop1") + self._props = OptionalTest_Prop1Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4576,30 +4345,29 @@ def props(self) -> "OptionalTest_Prop1Properties": return self._props -class OptionalTest_Prop1Viewer(OptionalTest_Prop1Ast): +class OptionalTest_Prop1Builder(OptionalTest_Prop1Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class OptionalTest_Prop1Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def omega_a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("omega_a")) + def omega_a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("omega_a")) @property - def omega_b(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("omega_b")) + def omega_b(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("omega_b")) @@ -4607,9 +4375,8 @@ def omega_b(self) -> type_builder.ClassPropertyViewer: class OptionalTest_ReturnTypeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OptionalTest_ReturnType") - self._properties: typing.Set[str] = set([ "omega_1", "omega_2", "omega_3", ]) - self._props = OptionalTest_ReturnTypeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("OptionalTest_ReturnType") + self._props = OptionalTest_ReturnTypeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4619,34 +4386,33 @@ def props(self) -> "OptionalTest_ReturnTypeProperties": return self._props -class OptionalTest_ReturnTypeViewer(OptionalTest_ReturnTypeAst): +class OptionalTest_ReturnTypeBuilder(OptionalTest_ReturnTypeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class OptionalTest_ReturnTypeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def omega_1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("omega_1")) + def omega_1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("omega_1")) @property - def omega_2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("omega_2")) + def omega_2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("omega_2")) @property - def omega_3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("omega_3")) + def omega_3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("omega_3")) @@ -4654,9 +4420,8 @@ def omega_3(self) -> type_builder.ClassPropertyViewer: class OrderInfoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OrderInfo") - self._properties: typing.Set[str] = set([ "order_status", "tracking_number", "estimated_arrival_date", ]) - self._props = OrderInfoProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("OrderInfo") + self._props = OrderInfoProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4666,34 +4431,33 @@ def props(self) -> "OrderInfoProperties": return self._props -class OrderInfoViewer(OrderInfoAst): +class OrderInfoBuilder(OrderInfoAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class OrderInfoProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def order_status(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("order_status")) + def order_status(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("order_status")) @property - def tracking_number(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("tracking_number")) + def tracking_number(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("tracking_number")) @property - def estimated_arrival_date(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("estimated_arrival_date")) + def estimated_arrival_date(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("estimated_arrival_date")) @@ -4701,9 +4465,8 @@ def estimated_arrival_date(self) -> type_builder.ClassPropertyViewer: class OriginalAAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OriginalA") - self._properties: typing.Set[str] = set([ "value", ]) - self._props = OriginalAProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("OriginalA") + self._props = OriginalAProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4713,26 +4476,25 @@ def props(self) -> "OriginalAProperties": return self._props -class OriginalAViewer(OriginalAAst): +class OriginalABuilder(OriginalAAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class OriginalAProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @@ -4740,9 +4502,8 @@ def value(self) -> type_builder.ClassPropertyViewer: class OriginalBAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OriginalB") - self._properties: typing.Set[str] = set([ "value", ]) - self._props = OriginalBProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("OriginalB") + self._props = OriginalBProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4757,12 +4518,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -4775,20 +4534,17 @@ def reset(self) -> None: class OriginalBProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def value(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("value") + def value(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("value") @@ -4796,9 +4552,8 @@ def value(self) -> baml_py.ClassPropertyBuilder: class PersonAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Person") - self._properties: typing.Set[str] = set([ "name", "hair_color", ]) - self._props = PersonProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Person") + self._props = PersonProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4813,12 +4568,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -4831,24 +4584,21 @@ def reset(self) -> None: class PersonProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def name(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("name") + def name(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("name") @property - def hair_color(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("hair_color") + def hair_color(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("hair_color") @@ -4856,9 +4606,8 @@ def hair_color(self) -> baml_py.ClassPropertyBuilder: class PhoneNumberAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("PhoneNumber") - self._properties: typing.Set[str] = set([ "value", ]) - self._props = PhoneNumberProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("PhoneNumber") + self._props = PhoneNumberProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4868,26 +4617,25 @@ def props(self) -> "PhoneNumberProperties": return self._props -class PhoneNumberViewer(PhoneNumberAst): +class PhoneNumberBuilder(PhoneNumberAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class PhoneNumberProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @@ -4895,9 +4643,8 @@ def value(self) -> type_builder.ClassPropertyViewer: class QuantityAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Quantity") - self._properties: typing.Set[str] = set([ "amount", "unit", ]) - self._props = QuantityProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Quantity") + self._props = QuantityProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4907,30 +4654,29 @@ def props(self) -> "QuantityProperties": return self._props -class QuantityViewer(QuantityAst): +class QuantityBuilder(QuantityAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class QuantityProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def amount(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("amount")) + def amount(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("amount")) @property - def unit(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("unit")) + def unit(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("unit")) @@ -4938,9 +4684,8 @@ def unit(self) -> type_builder.ClassPropertyViewer: class RaysDataAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("RaysData") - self._properties: typing.Set[str] = set([ "dataType", "value", ]) - self._props = RaysDataProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("RaysData") + self._props = RaysDataProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4950,30 +4695,29 @@ def props(self) -> "RaysDataProperties": return self._props -class RaysDataViewer(RaysDataAst): +class RaysDataBuilder(RaysDataAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class RaysDataProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def dataType(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("dataType")) + def dataType(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("dataType")) @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @@ -4981,9 +4725,8 @@ def value(self) -> type_builder.ClassPropertyViewer: class ReceiptInfoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ReceiptInfo") - self._properties: typing.Set[str] = set([ "items", "total_cost", "venue", ]) - self._props = ReceiptInfoProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ReceiptInfo") + self._props = ReceiptInfoProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4993,34 +4736,33 @@ def props(self) -> "ReceiptInfoProperties": return self._props -class ReceiptInfoViewer(ReceiptInfoAst): +class ReceiptInfoBuilder(ReceiptInfoAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ReceiptInfoProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def items(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("items")) + def items(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("items")) @property - def total_cost(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("total_cost")) + def total_cost(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("total_cost")) @property - def venue(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("venue")) + def venue(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("venue")) @@ -5028,9 +4770,8 @@ def venue(self) -> type_builder.ClassPropertyViewer: class ReceiptItemAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ReceiptItem") - self._properties: typing.Set[str] = set([ "name", "description", "quantity", "price", ]) - self._props = ReceiptItemProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ReceiptItem") + self._props = ReceiptItemProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5040,38 +4781,37 @@ def props(self) -> "ReceiptItemProperties": return self._props -class ReceiptItemViewer(ReceiptItemAst): +class ReceiptItemBuilder(ReceiptItemAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ReceiptItemProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def name(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("name")) + def name(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("name")) @property - def description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("description")) + def description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("description")) @property - def quantity(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("quantity")) + def quantity(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("quantity")) @property - def price(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("price")) + def price(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("price")) @@ -5079,9 +4819,8 @@ def price(self) -> type_builder.ClassPropertyViewer: class RecipeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Recipe") - self._properties: typing.Set[str] = set([ "ingredients", "recipe_type", ]) - self._props = RecipeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Recipe") + self._props = RecipeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5091,30 +4830,29 @@ def props(self) -> "RecipeProperties": return self._props -class RecipeViewer(RecipeAst): +class RecipeBuilder(RecipeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class RecipeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ingredients(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("ingredients")) + def ingredients(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("ingredients")) @property - def recipe_type(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("recipe_type")) + def recipe_type(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("recipe_type")) @@ -5122,9 +4860,8 @@ def recipe_type(self) -> type_builder.ClassPropertyViewer: class RecursiveAliasDependencyAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("RecursiveAliasDependency") - self._properties: typing.Set[str] = set([ "value", ]) - self._props = RecursiveAliasDependencyProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("RecursiveAliasDependency") + self._props = RecursiveAliasDependencyProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5134,26 +4871,25 @@ def props(self) -> "RecursiveAliasDependencyProperties": return self._props -class RecursiveAliasDependencyViewer(RecursiveAliasDependencyAst): +class RecursiveAliasDependencyBuilder(RecursiveAliasDependencyAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class RecursiveAliasDependencyProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @@ -5161,9 +4897,8 @@ def value(self) -> type_builder.ClassPropertyViewer: class RenderEnumInputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("RenderEnumInput") - self._properties: typing.Set[str] = set([ "testKey", ]) - self._props = RenderEnumInputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("RenderEnumInput") + self._props = RenderEnumInputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5178,12 +4913,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -5196,20 +4929,17 @@ def reset(self) -> None: class RenderEnumInputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def testKey(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("testKey") + def testKey(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("testKey") @@ -5217,9 +4947,8 @@ def testKey(self) -> baml_py.ClassPropertyBuilder: class RenderTestClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("RenderTestClass") - self._properties: typing.Set[str] = set([ "name", "status", ]) - self._props = RenderTestClassProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("RenderTestClass") + self._props = RenderTestClassProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5234,12 +4963,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -5252,24 +4979,21 @@ def reset(self) -> None: class RenderTestClassProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def name(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("name") + def name(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("name") @property - def status(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("status") + def status(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("status") @@ -5277,9 +5001,8 @@ def status(self) -> baml_py.ClassPropertyBuilder: class ResumeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Resume") - self._properties: typing.Set[str] = set([ "name", "email", "phone", "experience", "education", "skills", ]) - self._props = ResumeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Resume") + self._props = ResumeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5289,46 +5012,45 @@ def props(self) -> "ResumeProperties": return self._props -class ResumeViewer(ResumeAst): +class ResumeBuilder(ResumeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ResumeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def name(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("name")) + def name(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("name")) @property - def email(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("email")) + def email(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("email")) @property - def phone(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("phone")) + def phone(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("phone")) @property - def experience(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("experience")) + def experience(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("experience")) @property - def education(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("education")) + def education(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("education")) @property - def skills(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("skills")) + def skills(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("skills")) @@ -5336,9 +5058,8 @@ def skills(self) -> type_builder.ClassPropertyViewer: class SchemaAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Schema") - self._properties: typing.Set[str] = set([ "prop1", "prop2", "prop5", "prop6", "nested_attrs", "parens", "other_group", ]) - self._props = SchemaProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Schema") + self._props = SchemaProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5348,50 +5069,49 @@ def props(self) -> "SchemaProperties": return self._props -class SchemaViewer(SchemaAst): +class SchemaBuilder(SchemaAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class SchemaProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @property - def prop5(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop5")) + def prop5(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop5")) @property - def prop6(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop6")) + def prop6(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop6")) @property - def nested_attrs(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("nested_attrs")) + def nested_attrs(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("nested_attrs")) @property - def parens(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("parens")) + def parens(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("parens")) @property - def other_group(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("other_group")) + def other_group(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("other_group")) @@ -5399,9 +5119,8 @@ def other_group(self) -> type_builder.ClassPropertyViewer: class SearchParamsAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("SearchParams") - self._properties: typing.Set[str] = set([ "dateRange", "location", "jobTitle", "company", "description", "tags", ]) - self._props = SearchParamsProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("SearchParams") + self._props = SearchParamsProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5411,46 +5130,45 @@ def props(self) -> "SearchParamsProperties": return self._props -class SearchParamsViewer(SearchParamsAst): +class SearchParamsBuilder(SearchParamsAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class SearchParamsProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def dateRange(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("dateRange")) + def dateRange(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("dateRange")) @property - def location(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("location")) + def location(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("location")) @property - def jobTitle(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("jobTitle")) + def jobTitle(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("jobTitle")) @property - def company(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("company")) + def company(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("company")) @property - def description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("description")) + def description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("description")) @property - def tags(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("tags")) + def tags(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("tags")) @@ -5458,9 +5176,8 @@ def tags(self) -> type_builder.ClassPropertyViewer: class SemanticContainerAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("SemanticContainer") - self._properties: typing.Set[str] = set([ "sixteen_digit_number", "string_with_twenty_words", "class_1", "class_2", "class_done_needed", "class_needed", "three_small_things", "final_string", ]) - self._props = SemanticContainerProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("SemanticContainer") + self._props = SemanticContainerProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5470,54 +5187,53 @@ def props(self) -> "SemanticContainerProperties": return self._props -class SemanticContainerViewer(SemanticContainerAst): +class SemanticContainerBuilder(SemanticContainerAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class SemanticContainerProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def sixteen_digit_number(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("sixteen_digit_number")) + def sixteen_digit_number(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("sixteen_digit_number")) @property - def string_with_twenty_words(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("string_with_twenty_words")) + def string_with_twenty_words(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("string_with_twenty_words")) @property - def class_1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("class_1")) + def class_1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("class_1")) @property - def class_2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("class_2")) + def class_2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("class_2")) @property - def class_done_needed(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("class_done_needed")) + def class_done_needed(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("class_done_needed")) @property - def class_needed(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("class_needed")) + def class_needed(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("class_needed")) @property - def three_small_things(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("three_small_things")) + def three_small_things(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("three_small_things")) @property - def final_string(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("final_string")) + def final_string(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("final_string")) @@ -5525,9 +5241,8 @@ def final_string(self) -> type_builder.ClassPropertyViewer: class SimpleTagAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("SimpleTag") - self._properties: typing.Set[str] = set([ "field", ]) - self._props = SimpleTagProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("SimpleTag") + self._props = SimpleTagProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5537,26 +5252,25 @@ def props(self) -> "SimpleTagProperties": return self._props -class SimpleTagViewer(SimpleTagAst): +class SimpleTagBuilder(SimpleTagAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class SimpleTagProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def field(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("field")) + def field(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("field")) @@ -5564,9 +5278,8 @@ def field(self) -> type_builder.ClassPropertyViewer: class SmallThingAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("SmallThing") - self._properties: typing.Set[str] = set([ "i_16_digits", "i_8_digits", ]) - self._props = SmallThingProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("SmallThing") + self._props = SmallThingProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5576,30 +5289,29 @@ def props(self) -> "SmallThingProperties": return self._props -class SmallThingViewer(SmallThingAst): +class SmallThingBuilder(SmallThingAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class SmallThingProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def i_16_digits(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("i_16_digits")) + def i_16_digits(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("i_16_digits")) @property - def i_8_digits(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("i_8_digits")) + def i_8_digits(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("i_8_digits")) @@ -5607,9 +5319,8 @@ def i_8_digits(self) -> type_builder.ClassPropertyViewer: class SomeClassNestedDynamicAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("SomeClassNestedDynamic") - self._properties: typing.Set[str] = set([ "hi", ]) - self._props = SomeClassNestedDynamicProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("SomeClassNestedDynamic") + self._props = SomeClassNestedDynamicProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5624,12 +5335,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -5642,20 +5351,17 @@ def reset(self) -> None: class SomeClassNestedDynamicProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def hi(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("hi") + def hi(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("hi") @@ -5663,9 +5369,8 @@ def hi(self) -> baml_py.ClassPropertyBuilder: class StringToClassEntryAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("StringToClassEntry") - self._properties: typing.Set[str] = set([ "word", ]) - self._props = StringToClassEntryProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("StringToClassEntry") + self._props = StringToClassEntryProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5675,26 +5380,25 @@ def props(self) -> "StringToClassEntryProperties": return self._props -class StringToClassEntryViewer(StringToClassEntryAst): +class StringToClassEntryBuilder(StringToClassEntryAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class StringToClassEntryProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def word(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("word")) + def word(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("word")) @@ -5702,9 +5406,8 @@ def word(self) -> type_builder.ClassPropertyViewer: class TestClassAliasAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TestClassAlias") - self._properties: typing.Set[str] = set([ "key", "key2", "key3", "key4", "key5", ]) - self._props = TestClassAliasProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TestClassAlias") + self._props = TestClassAliasProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5714,42 +5417,41 @@ def props(self) -> "TestClassAliasProperties": return self._props -class TestClassAliasViewer(TestClassAliasAst): +class TestClassAliasBuilder(TestClassAliasAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TestClassAliasProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def key(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key")) + def key(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key")) @property - def key2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key2")) + def key2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key2")) @property - def key3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key3")) + def key3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key3")) @property - def key4(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key4")) + def key4(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key4")) @property - def key5(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key5")) + def key5(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key5")) @@ -5757,9 +5459,8 @@ def key5(self) -> type_builder.ClassPropertyViewer: class TestClassNestedAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TestClassNested") - self._properties: typing.Set[str] = set([ "prop1", "prop2", ]) - self._props = TestClassNestedProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TestClassNested") + self._props = TestClassNestedProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5769,30 +5470,29 @@ def props(self) -> "TestClassNestedProperties": return self._props -class TestClassNestedViewer(TestClassNestedAst): +class TestClassNestedBuilder(TestClassNestedAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TestClassNestedProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @@ -5800,9 +5500,8 @@ def prop2(self) -> type_builder.ClassPropertyViewer: class TestClassWithEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TestClassWithEnum") - self._properties: typing.Set[str] = set([ "prop1", "prop2", ]) - self._props = TestClassWithEnumProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TestClassWithEnum") + self._props = TestClassWithEnumProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5812,30 +5511,29 @@ def props(self) -> "TestClassWithEnumProperties": return self._props -class TestClassWithEnumViewer(TestClassWithEnumAst): +class TestClassWithEnumBuilder(TestClassWithEnumAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TestClassWithEnumProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @@ -5843,9 +5541,8 @@ def prop2(self) -> type_builder.ClassPropertyViewer: class TestMemoryOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TestMemoryOutput") - self._properties: typing.Set[str] = set([ "items", "more_items", ]) - self._props = TestMemoryOutputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TestMemoryOutput") + self._props = TestMemoryOutputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5855,30 +5552,29 @@ def props(self) -> "TestMemoryOutputProperties": return self._props -class TestMemoryOutputViewer(TestMemoryOutputAst): +class TestMemoryOutputBuilder(TestMemoryOutputAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TestMemoryOutputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def items(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("items")) + def items(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("items")) @property - def more_items(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("more_items")) + def more_items(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("more_items")) @@ -5886,9 +5582,8 @@ def more_items(self) -> type_builder.ClassPropertyViewer: class TestOutputClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TestOutputClass") - self._properties: typing.Set[str] = set([ "prop1", "prop2", ]) - self._props = TestOutputClassProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TestOutputClass") + self._props = TestOutputClassProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5898,30 +5593,29 @@ def props(self) -> "TestOutputClassProperties": return self._props -class TestOutputClassViewer(TestOutputClassAst): +class TestOutputClassBuilder(TestOutputClassAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TestOutputClassProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @@ -5929,9 +5623,8 @@ def prop2(self) -> type_builder.ClassPropertyViewer: class TreeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Tree") - self._properties: typing.Set[str] = set([ "data", "children", ]) - self._props = TreeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Tree") + self._props = TreeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5941,30 +5634,29 @@ def props(self) -> "TreeProperties": return self._props -class TreeViewer(TreeAst): +class TreeBuilder(TreeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TreeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def data(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("data")) + def data(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("data")) @property - def children(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("children")) + def children(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("children")) @@ -5972,9 +5664,8 @@ def children(self) -> type_builder.ClassPropertyViewer: class TwoStoriesOneTitleAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TwoStoriesOneTitle") - self._properties: typing.Set[str] = set([ "title", "story_a", "story_b", ]) - self._props = TwoStoriesOneTitleProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TwoStoriesOneTitle") + self._props = TwoStoriesOneTitleProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5984,34 +5675,33 @@ def props(self) -> "TwoStoriesOneTitleProperties": return self._props -class TwoStoriesOneTitleViewer(TwoStoriesOneTitleAst): +class TwoStoriesOneTitleBuilder(TwoStoriesOneTitleAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TwoStoriesOneTitleProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("title")) + def title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("title")) @property - def story_a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("story_a")) + def story_a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("story_a")) @property - def story_b(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("story_b")) + def story_b(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("story_b")) @@ -6019,9 +5709,8 @@ def story_b(self) -> type_builder.ClassPropertyViewer: class TwoStoriesOneTitleCheckAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TwoStoriesOneTitleCheck") - self._properties: typing.Set[str] = set([ "title", "story_a", "story_b", ]) - self._props = TwoStoriesOneTitleCheckProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TwoStoriesOneTitleCheck") + self._props = TwoStoriesOneTitleCheckProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -6031,34 +5720,33 @@ def props(self) -> "TwoStoriesOneTitleCheckProperties": return self._props -class TwoStoriesOneTitleCheckViewer(TwoStoriesOneTitleCheckAst): +class TwoStoriesOneTitleCheckBuilder(TwoStoriesOneTitleCheckAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TwoStoriesOneTitleCheckProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("title")) + def title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("title")) @property - def story_a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("story_a")) + def story_a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("story_a")) @property - def story_b(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("story_b")) + def story_b(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("story_b")) @@ -6066,9 +5754,8 @@ def story_b(self) -> type_builder.ClassPropertyViewer: class UnionTest_ReturnTypeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("UnionTest_ReturnType") - self._properties: typing.Set[str] = set([ "prop1", "prop2", "prop3", ]) - self._props = UnionTest_ReturnTypeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("UnionTest_ReturnType") + self._props = UnionTest_ReturnTypeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -6078,34 +5765,33 @@ def props(self) -> "UnionTest_ReturnTypeProperties": return self._props -class UnionTest_ReturnTypeViewer(UnionTest_ReturnTypeAst): +class UnionTest_ReturnTypeBuilder(UnionTest_ReturnTypeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class UnionTest_ReturnTypeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @property - def prop3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop3")) + def prop3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop3")) @@ -6113,9 +5799,8 @@ def prop3(self) -> type_builder.ClassPropertyViewer: class UniverseQuestionAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("UniverseQuestion") - self._properties: typing.Set[str] = set([ "question", "answer", ]) - self._props = UniverseQuestionProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("UniverseQuestion") + self._props = UniverseQuestionProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -6125,30 +5810,29 @@ def props(self) -> "UniverseQuestionProperties": return self._props -class UniverseQuestionViewer(UniverseQuestionAst): +class UniverseQuestionBuilder(UniverseQuestionAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class UniverseQuestionProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def question(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("question")) + def question(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("question")) @property - def answer(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("answer")) + def answer(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("answer")) @@ -6156,9 +5840,8 @@ def answer(self) -> type_builder.ClassPropertyViewer: class UniverseQuestionInputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("UniverseQuestionInput") - self._properties: typing.Set[str] = set([ "question", ]) - self._props = UniverseQuestionInputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("UniverseQuestionInput") + self._props = UniverseQuestionInputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -6168,26 +5851,25 @@ def props(self) -> "UniverseQuestionInputProperties": return self._props -class UniverseQuestionInputViewer(UniverseQuestionInputAst): +class UniverseQuestionInputBuilder(UniverseQuestionInputAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class UniverseQuestionInputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def question(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("question")) + def question(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("question")) @@ -6195,9 +5877,8 @@ def question(self) -> type_builder.ClassPropertyViewer: class WithReasoningAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("WithReasoning") - self._properties: typing.Set[str] = set([ "value", "reasoning", ]) - self._props = WithReasoningProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("WithReasoning") + self._props = WithReasoningProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -6207,30 +5888,29 @@ def props(self) -> "WithReasoningProperties": return self._props -class WithReasoningViewer(WithReasoningAst): +class WithReasoningBuilder(WithReasoningAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class WithReasoningProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @property - def reasoning(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("reasoning")) + def reasoning(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("reasoning")) diff --git a/integ-tests/python/baml_client/type_builder.py b/integ-tests/python/baml_client/type_builder.py index e7f9757112..19ef44d354 100644 --- a/integ-tests/python/baml_client/type_builder.py +++ b/integ-tests/python/baml_client/type_builder.py @@ -19,39 +19,35 @@ class TypeBuilder(type_builder.TypeBuilder): def __init__(self): - super().__init__(classes=set( - ["AnotherObject","BigNumbers","BinaryNode","Blah","BlockConstraint","BlockConstraintForParam","BookOrder","ClassForNullLiteral","ClassOptionalOutput","ClassOptionalOutput2","ClassToRecAlias","ClassWithBlockDone","ClassWithImage","ClassWithoutDone","ClientDetails1559","ComplexMemoryObject","CompoundBigNumbers","ContactInfo","CustomStory","CustomTaskResult","Document1559","DummyOutput","DynInputOutput","DynamicClassOne","DynamicClassTwo","DynamicOutput","DynamicSchema","Earthling","Education","Email","EmailAddress","Event","FakeImage","FlightConfirmation","FooAny","Forest","FormatterTest0","FormatterTest1","FormatterTest2","FormatterTest3","GroceryReceipt","Haiku","InnerClass","InnerClass2","InputClass","InputClassNested","LinkedList","LinkedListAliasNode","LiteralClassHello","LiteralClassOne","LiteralClassTwo","MaintainFieldOrder","MalformedConstraints","MalformedConstraints2","Martian","MemoryObject","MergeAttrs","NamedArgsSingleClass","Nested","Nested2","NestedBlockConstraint","NestedBlockConstraintForParam","Node","NodeWithAliasIndirection","Note1599","OptionalListAndMap","OptionalTest_Prop1","OptionalTest_ReturnType","OrderInfo","OriginalA","OriginalB","Person","PhoneNumber","Quantity","RaysData","ReceiptInfo","ReceiptItem","Recipe","RecursiveAliasDependency","RenderEnumInput","RenderTestClass","Resume","Schema","SearchParams","SemanticContainer","SimpleTag","SmallThing","SomeClassNestedDynamic","StringToClassEntry","TestClassAlias","TestClassNested","TestClassWithEnum","TestMemoryOutput","TestOutputClass","Tree","TwoStoriesOneTitle","TwoStoriesOneTitleCheck","UnionTest_ReturnType","UniverseQuestion","UniverseQuestionInput","WithReasoning",] - ), enums=set( - ["AliasedEnum","Category","Category2","Category3","Color","DataType","DynEnumOne","DynEnumThree","DynEnumTwo","EnumInClass","EnumOutput","Hobby","MapKey","NamedArgsSingleEnum","NamedArgsSingleEnumList","OptionalTest_CategoryType","OrderStatus","RenderStatusEnum","RenderTestEnum","Tag","TestEnum",] - ), runtime=DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME) + super().__init__(runtime=DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME) # ######################################################################### # Generated enums 21 # ######################################################################### @property - def AliasedEnum(self) -> "AliasedEnumViewer": - return AliasedEnumViewer(self) + def AliasedEnum(self) -> "AliasedEnumBuilder": + return AliasedEnumBuilder(self) @property - def Category(self) -> "CategoryViewer": - return CategoryViewer(self) + def Category(self) -> "CategoryBuilder": + return CategoryBuilder(self) @property - def Category2(self) -> "Category2Viewer": - return Category2Viewer(self) + def Category2(self) -> "Category2Builder": + return Category2Builder(self) @property - def Category3(self) -> "Category3Viewer": - return Category3Viewer(self) + def Category3(self) -> "Category3Builder": + return Category3Builder(self) @property def Color(self) -> "ColorBuilder": return ColorBuilder(self) @property - def DataType(self) -> "DataTypeViewer": - return DataTypeViewer(self) + def DataType(self) -> "DataTypeBuilder": + return DataTypeBuilder(self) @property def DynEnumOne(self) -> "DynEnumOneBuilder": @@ -66,36 +62,36 @@ def DynEnumTwo(self) -> "DynEnumTwoBuilder": return DynEnumTwoBuilder(self) @property - def EnumInClass(self) -> "EnumInClassViewer": - return EnumInClassViewer(self) + def EnumInClass(self) -> "EnumInClassBuilder": + return EnumInClassBuilder(self) @property - def EnumOutput(self) -> "EnumOutputViewer": - return EnumOutputViewer(self) + def EnumOutput(self) -> "EnumOutputBuilder": + return EnumOutputBuilder(self) @property def Hobby(self) -> "HobbyBuilder": return HobbyBuilder(self) @property - def MapKey(self) -> "MapKeyViewer": - return MapKeyViewer(self) + def MapKey(self) -> "MapKeyBuilder": + return MapKeyBuilder(self) @property - def NamedArgsSingleEnum(self) -> "NamedArgsSingleEnumViewer": - return NamedArgsSingleEnumViewer(self) + def NamedArgsSingleEnum(self) -> "NamedArgsSingleEnumBuilder": + return NamedArgsSingleEnumBuilder(self) @property - def NamedArgsSingleEnumList(self) -> "NamedArgsSingleEnumListViewer": - return NamedArgsSingleEnumListViewer(self) + def NamedArgsSingleEnumList(self) -> "NamedArgsSingleEnumListBuilder": + return NamedArgsSingleEnumListBuilder(self) @property - def OptionalTest_CategoryType(self) -> "OptionalTest_CategoryTypeViewer": - return OptionalTest_CategoryTypeViewer(self) + def OptionalTest_CategoryType(self) -> "OptionalTest_CategoryTypeBuilder": + return OptionalTest_CategoryTypeBuilder(self) @property - def OrderStatus(self) -> "OrderStatusViewer": - return OrderStatusViewer(self) + def OrderStatus(self) -> "OrderStatusBuilder": + return OrderStatusBuilder(self) @property def RenderStatusEnum(self) -> "RenderStatusEnumBuilder": @@ -106,12 +102,12 @@ def RenderTestEnum(self) -> "RenderTestEnumBuilder": return RenderTestEnumBuilder(self) @property - def Tag(self) -> "TagViewer": - return TagViewer(self) + def Tag(self) -> "TagBuilder": + return TagBuilder(self) @property - def TestEnum(self) -> "TestEnumViewer": - return TestEnumViewer(self) + def TestEnum(self) -> "TestEnumBuilder": + return TestEnumBuilder(self) # ######################################################################### @@ -119,88 +115,88 @@ def TestEnum(self) -> "TestEnumViewer": # ######################################################################### @property - def AnotherObject(self) -> "AnotherObjectViewer": - return AnotherObjectViewer(self) + def AnotherObject(self) -> "AnotherObjectBuilder": + return AnotherObjectBuilder(self) @property - def BigNumbers(self) -> "BigNumbersViewer": - return BigNumbersViewer(self) + def BigNumbers(self) -> "BigNumbersBuilder": + return BigNumbersBuilder(self) @property - def BinaryNode(self) -> "BinaryNodeViewer": - return BinaryNodeViewer(self) + def BinaryNode(self) -> "BinaryNodeBuilder": + return BinaryNodeBuilder(self) @property - def Blah(self) -> "BlahViewer": - return BlahViewer(self) + def Blah(self) -> "BlahBuilder": + return BlahBuilder(self) @property - def BlockConstraint(self) -> "BlockConstraintViewer": - return BlockConstraintViewer(self) + def BlockConstraint(self) -> "BlockConstraintBuilder": + return BlockConstraintBuilder(self) @property - def BlockConstraintForParam(self) -> "BlockConstraintForParamViewer": - return BlockConstraintForParamViewer(self) + def BlockConstraintForParam(self) -> "BlockConstraintForParamBuilder": + return BlockConstraintForParamBuilder(self) @property - def BookOrder(self) -> "BookOrderViewer": - return BookOrderViewer(self) + def BookOrder(self) -> "BookOrderBuilder": + return BookOrderBuilder(self) @property - def ClassForNullLiteral(self) -> "ClassForNullLiteralViewer": - return ClassForNullLiteralViewer(self) + def ClassForNullLiteral(self) -> "ClassForNullLiteralBuilder": + return ClassForNullLiteralBuilder(self) @property - def ClassOptionalOutput(self) -> "ClassOptionalOutputViewer": - return ClassOptionalOutputViewer(self) + def ClassOptionalOutput(self) -> "ClassOptionalOutputBuilder": + return ClassOptionalOutputBuilder(self) @property - def ClassOptionalOutput2(self) -> "ClassOptionalOutput2Viewer": - return ClassOptionalOutput2Viewer(self) + def ClassOptionalOutput2(self) -> "ClassOptionalOutput2Builder": + return ClassOptionalOutput2Builder(self) @property - def ClassToRecAlias(self) -> "ClassToRecAliasViewer": - return ClassToRecAliasViewer(self) + def ClassToRecAlias(self) -> "ClassToRecAliasBuilder": + return ClassToRecAliasBuilder(self) @property - def ClassWithBlockDone(self) -> "ClassWithBlockDoneViewer": - return ClassWithBlockDoneViewer(self) + def ClassWithBlockDone(self) -> "ClassWithBlockDoneBuilder": + return ClassWithBlockDoneBuilder(self) @property - def ClassWithImage(self) -> "ClassWithImageViewer": - return ClassWithImageViewer(self) + def ClassWithImage(self) -> "ClassWithImageBuilder": + return ClassWithImageBuilder(self) @property - def ClassWithoutDone(self) -> "ClassWithoutDoneViewer": - return ClassWithoutDoneViewer(self) + def ClassWithoutDone(self) -> "ClassWithoutDoneBuilder": + return ClassWithoutDoneBuilder(self) @property - def ClientDetails1559(self) -> "ClientDetails1559Viewer": - return ClientDetails1559Viewer(self) + def ClientDetails1559(self) -> "ClientDetails1559Builder": + return ClientDetails1559Builder(self) @property - def ComplexMemoryObject(self) -> "ComplexMemoryObjectViewer": - return ComplexMemoryObjectViewer(self) + def ComplexMemoryObject(self) -> "ComplexMemoryObjectBuilder": + return ComplexMemoryObjectBuilder(self) @property - def CompoundBigNumbers(self) -> "CompoundBigNumbersViewer": - return CompoundBigNumbersViewer(self) + def CompoundBigNumbers(self) -> "CompoundBigNumbersBuilder": + return CompoundBigNumbersBuilder(self) @property - def ContactInfo(self) -> "ContactInfoViewer": - return ContactInfoViewer(self) + def ContactInfo(self) -> "ContactInfoBuilder": + return ContactInfoBuilder(self) @property - def CustomStory(self) -> "CustomStoryViewer": - return CustomStoryViewer(self) + def CustomStory(self) -> "CustomStoryBuilder": + return CustomStoryBuilder(self) @property - def CustomTaskResult(self) -> "CustomTaskResultViewer": - return CustomTaskResultViewer(self) + def CustomTaskResult(self) -> "CustomTaskResultBuilder": + return CustomTaskResultBuilder(self) @property - def Document1559(self) -> "Document1559Viewer": - return Document1559Viewer(self) + def Document1559(self) -> "Document1559Builder": + return Document1559Builder(self) @property def DummyOutput(self) -> "DummyOutputBuilder": @@ -227,176 +223,176 @@ def DynamicSchema(self) -> "DynamicSchemaBuilder": return DynamicSchemaBuilder(self) @property - def Earthling(self) -> "EarthlingViewer": - return EarthlingViewer(self) + def Earthling(self) -> "EarthlingBuilder": + return EarthlingBuilder(self) @property - def Education(self) -> "EducationViewer": - return EducationViewer(self) + def Education(self) -> "EducationBuilder": + return EducationBuilder(self) @property - def Email(self) -> "EmailViewer": - return EmailViewer(self) + def Email(self) -> "EmailBuilder": + return EmailBuilder(self) @property - def EmailAddress(self) -> "EmailAddressViewer": - return EmailAddressViewer(self) + def EmailAddress(self) -> "EmailAddressBuilder": + return EmailAddressBuilder(self) @property - def Event(self) -> "EventViewer": - return EventViewer(self) + def Event(self) -> "EventBuilder": + return EventBuilder(self) @property - def FakeImage(self) -> "FakeImageViewer": - return FakeImageViewer(self) + def FakeImage(self) -> "FakeImageBuilder": + return FakeImageBuilder(self) @property - def FlightConfirmation(self) -> "FlightConfirmationViewer": - return FlightConfirmationViewer(self) + def FlightConfirmation(self) -> "FlightConfirmationBuilder": + return FlightConfirmationBuilder(self) @property - def FooAny(self) -> "FooAnyViewer": - return FooAnyViewer(self) + def FooAny(self) -> "FooAnyBuilder": + return FooAnyBuilder(self) @property - def Forest(self) -> "ForestViewer": - return ForestViewer(self) + def Forest(self) -> "ForestBuilder": + return ForestBuilder(self) @property - def FormatterTest0(self) -> "FormatterTest0Viewer": - return FormatterTest0Viewer(self) + def FormatterTest0(self) -> "FormatterTest0Builder": + return FormatterTest0Builder(self) @property - def FormatterTest1(self) -> "FormatterTest1Viewer": - return FormatterTest1Viewer(self) + def FormatterTest1(self) -> "FormatterTest1Builder": + return FormatterTest1Builder(self) @property - def FormatterTest2(self) -> "FormatterTest2Viewer": - return FormatterTest2Viewer(self) + def FormatterTest2(self) -> "FormatterTest2Builder": + return FormatterTest2Builder(self) @property - def FormatterTest3(self) -> "FormatterTest3Viewer": - return FormatterTest3Viewer(self) + def FormatterTest3(self) -> "FormatterTest3Builder": + return FormatterTest3Builder(self) @property - def GroceryReceipt(self) -> "GroceryReceiptViewer": - return GroceryReceiptViewer(self) + def GroceryReceipt(self) -> "GroceryReceiptBuilder": + return GroceryReceiptBuilder(self) @property - def Haiku(self) -> "HaikuViewer": - return HaikuViewer(self) + def Haiku(self) -> "HaikuBuilder": + return HaikuBuilder(self) @property - def InnerClass(self) -> "InnerClassViewer": - return InnerClassViewer(self) + def InnerClass(self) -> "InnerClassBuilder": + return InnerClassBuilder(self) @property - def InnerClass2(self) -> "InnerClass2Viewer": - return InnerClass2Viewer(self) + def InnerClass2(self) -> "InnerClass2Builder": + return InnerClass2Builder(self) @property - def InputClass(self) -> "InputClassViewer": - return InputClassViewer(self) + def InputClass(self) -> "InputClassBuilder": + return InputClassBuilder(self) @property - def InputClassNested(self) -> "InputClassNestedViewer": - return InputClassNestedViewer(self) + def InputClassNested(self) -> "InputClassNestedBuilder": + return InputClassNestedBuilder(self) @property - def LinkedList(self) -> "LinkedListViewer": - return LinkedListViewer(self) + def LinkedList(self) -> "LinkedListBuilder": + return LinkedListBuilder(self) @property - def LinkedListAliasNode(self) -> "LinkedListAliasNodeViewer": - return LinkedListAliasNodeViewer(self) + def LinkedListAliasNode(self) -> "LinkedListAliasNodeBuilder": + return LinkedListAliasNodeBuilder(self) @property - def LiteralClassHello(self) -> "LiteralClassHelloViewer": - return LiteralClassHelloViewer(self) + def LiteralClassHello(self) -> "LiteralClassHelloBuilder": + return LiteralClassHelloBuilder(self) @property - def LiteralClassOne(self) -> "LiteralClassOneViewer": - return LiteralClassOneViewer(self) + def LiteralClassOne(self) -> "LiteralClassOneBuilder": + return LiteralClassOneBuilder(self) @property - def LiteralClassTwo(self) -> "LiteralClassTwoViewer": - return LiteralClassTwoViewer(self) + def LiteralClassTwo(self) -> "LiteralClassTwoBuilder": + return LiteralClassTwoBuilder(self) @property - def MaintainFieldOrder(self) -> "MaintainFieldOrderViewer": - return MaintainFieldOrderViewer(self) + def MaintainFieldOrder(self) -> "MaintainFieldOrderBuilder": + return MaintainFieldOrderBuilder(self) @property - def MalformedConstraints(self) -> "MalformedConstraintsViewer": - return MalformedConstraintsViewer(self) + def MalformedConstraints(self) -> "MalformedConstraintsBuilder": + return MalformedConstraintsBuilder(self) @property - def MalformedConstraints2(self) -> "MalformedConstraints2Viewer": - return MalformedConstraints2Viewer(self) + def MalformedConstraints2(self) -> "MalformedConstraints2Builder": + return MalformedConstraints2Builder(self) @property - def Martian(self) -> "MartianViewer": - return MartianViewer(self) + def Martian(self) -> "MartianBuilder": + return MartianBuilder(self) @property - def MemoryObject(self) -> "MemoryObjectViewer": - return MemoryObjectViewer(self) + def MemoryObject(self) -> "MemoryObjectBuilder": + return MemoryObjectBuilder(self) @property - def MergeAttrs(self) -> "MergeAttrsViewer": - return MergeAttrsViewer(self) + def MergeAttrs(self) -> "MergeAttrsBuilder": + return MergeAttrsBuilder(self) @property - def NamedArgsSingleClass(self) -> "NamedArgsSingleClassViewer": - return NamedArgsSingleClassViewer(self) + def NamedArgsSingleClass(self) -> "NamedArgsSingleClassBuilder": + return NamedArgsSingleClassBuilder(self) @property - def Nested(self) -> "NestedViewer": - return NestedViewer(self) + def Nested(self) -> "NestedBuilder": + return NestedBuilder(self) @property - def Nested2(self) -> "Nested2Viewer": - return Nested2Viewer(self) + def Nested2(self) -> "Nested2Builder": + return Nested2Builder(self) @property - def NestedBlockConstraint(self) -> "NestedBlockConstraintViewer": - return NestedBlockConstraintViewer(self) + def NestedBlockConstraint(self) -> "NestedBlockConstraintBuilder": + return NestedBlockConstraintBuilder(self) @property - def NestedBlockConstraintForParam(self) -> "NestedBlockConstraintForParamViewer": - return NestedBlockConstraintForParamViewer(self) + def NestedBlockConstraintForParam(self) -> "NestedBlockConstraintForParamBuilder": + return NestedBlockConstraintForParamBuilder(self) @property - def Node(self) -> "NodeViewer": - return NodeViewer(self) + def Node(self) -> "NodeBuilder": + return NodeBuilder(self) @property - def NodeWithAliasIndirection(self) -> "NodeWithAliasIndirectionViewer": - return NodeWithAliasIndirectionViewer(self) + def NodeWithAliasIndirection(self) -> "NodeWithAliasIndirectionBuilder": + return NodeWithAliasIndirectionBuilder(self) @property - def Note1599(self) -> "Note1599Viewer": - return Note1599Viewer(self) + def Note1599(self) -> "Note1599Builder": + return Note1599Builder(self) @property - def OptionalListAndMap(self) -> "OptionalListAndMapViewer": - return OptionalListAndMapViewer(self) + def OptionalListAndMap(self) -> "OptionalListAndMapBuilder": + return OptionalListAndMapBuilder(self) @property - def OptionalTest_Prop1(self) -> "OptionalTest_Prop1Viewer": - return OptionalTest_Prop1Viewer(self) + def OptionalTest_Prop1(self) -> "OptionalTest_Prop1Builder": + return OptionalTest_Prop1Builder(self) @property - def OptionalTest_ReturnType(self) -> "OptionalTest_ReturnTypeViewer": - return OptionalTest_ReturnTypeViewer(self) + def OptionalTest_ReturnType(self) -> "OptionalTest_ReturnTypeBuilder": + return OptionalTest_ReturnTypeBuilder(self) @property - def OrderInfo(self) -> "OrderInfoViewer": - return OrderInfoViewer(self) + def OrderInfo(self) -> "OrderInfoBuilder": + return OrderInfoBuilder(self) @property - def OriginalA(self) -> "OriginalAViewer": - return OriginalAViewer(self) + def OriginalA(self) -> "OriginalABuilder": + return OriginalABuilder(self) @property def OriginalB(self) -> "OriginalBBuilder": @@ -407,32 +403,32 @@ def Person(self) -> "PersonBuilder": return PersonBuilder(self) @property - def PhoneNumber(self) -> "PhoneNumberViewer": - return PhoneNumberViewer(self) + def PhoneNumber(self) -> "PhoneNumberBuilder": + return PhoneNumberBuilder(self) @property - def Quantity(self) -> "QuantityViewer": - return QuantityViewer(self) + def Quantity(self) -> "QuantityBuilder": + return QuantityBuilder(self) @property - def RaysData(self) -> "RaysDataViewer": - return RaysDataViewer(self) + def RaysData(self) -> "RaysDataBuilder": + return RaysDataBuilder(self) @property - def ReceiptInfo(self) -> "ReceiptInfoViewer": - return ReceiptInfoViewer(self) + def ReceiptInfo(self) -> "ReceiptInfoBuilder": + return ReceiptInfoBuilder(self) @property - def ReceiptItem(self) -> "ReceiptItemViewer": - return ReceiptItemViewer(self) + def ReceiptItem(self) -> "ReceiptItemBuilder": + return ReceiptItemBuilder(self) @property - def Recipe(self) -> "RecipeViewer": - return RecipeViewer(self) + def Recipe(self) -> "RecipeBuilder": + return RecipeBuilder(self) @property - def RecursiveAliasDependency(self) -> "RecursiveAliasDependencyViewer": - return RecursiveAliasDependencyViewer(self) + def RecursiveAliasDependency(self) -> "RecursiveAliasDependencyBuilder": + return RecursiveAliasDependencyBuilder(self) @property def RenderEnumInput(self) -> "RenderEnumInputBuilder": @@ -443,84 +439,84 @@ def RenderTestClass(self) -> "RenderTestClassBuilder": return RenderTestClassBuilder(self) @property - def Resume(self) -> "ResumeViewer": - return ResumeViewer(self) + def Resume(self) -> "ResumeBuilder": + return ResumeBuilder(self) @property - def Schema(self) -> "SchemaViewer": - return SchemaViewer(self) + def Schema(self) -> "SchemaBuilder": + return SchemaBuilder(self) @property - def SearchParams(self) -> "SearchParamsViewer": - return SearchParamsViewer(self) + def SearchParams(self) -> "SearchParamsBuilder": + return SearchParamsBuilder(self) @property - def SemanticContainer(self) -> "SemanticContainerViewer": - return SemanticContainerViewer(self) + def SemanticContainer(self) -> "SemanticContainerBuilder": + return SemanticContainerBuilder(self) @property - def SimpleTag(self) -> "SimpleTagViewer": - return SimpleTagViewer(self) + def SimpleTag(self) -> "SimpleTagBuilder": + return SimpleTagBuilder(self) @property - def SmallThing(self) -> "SmallThingViewer": - return SmallThingViewer(self) + def SmallThing(self) -> "SmallThingBuilder": + return SmallThingBuilder(self) @property def SomeClassNestedDynamic(self) -> "SomeClassNestedDynamicBuilder": return SomeClassNestedDynamicBuilder(self) @property - def StringToClassEntry(self) -> "StringToClassEntryViewer": - return StringToClassEntryViewer(self) + def StringToClassEntry(self) -> "StringToClassEntryBuilder": + return StringToClassEntryBuilder(self) @property - def TestClassAlias(self) -> "TestClassAliasViewer": - return TestClassAliasViewer(self) + def TestClassAlias(self) -> "TestClassAliasBuilder": + return TestClassAliasBuilder(self) @property - def TestClassNested(self) -> "TestClassNestedViewer": - return TestClassNestedViewer(self) + def TestClassNested(self) -> "TestClassNestedBuilder": + return TestClassNestedBuilder(self) @property - def TestClassWithEnum(self) -> "TestClassWithEnumViewer": - return TestClassWithEnumViewer(self) + def TestClassWithEnum(self) -> "TestClassWithEnumBuilder": + return TestClassWithEnumBuilder(self) @property - def TestMemoryOutput(self) -> "TestMemoryOutputViewer": - return TestMemoryOutputViewer(self) + def TestMemoryOutput(self) -> "TestMemoryOutputBuilder": + return TestMemoryOutputBuilder(self) @property - def TestOutputClass(self) -> "TestOutputClassViewer": - return TestOutputClassViewer(self) + def TestOutputClass(self) -> "TestOutputClassBuilder": + return TestOutputClassBuilder(self) @property - def Tree(self) -> "TreeViewer": - return TreeViewer(self) + def Tree(self) -> "TreeBuilder": + return TreeBuilder(self) @property - def TwoStoriesOneTitle(self) -> "TwoStoriesOneTitleViewer": - return TwoStoriesOneTitleViewer(self) + def TwoStoriesOneTitle(self) -> "TwoStoriesOneTitleBuilder": + return TwoStoriesOneTitleBuilder(self) @property - def TwoStoriesOneTitleCheck(self) -> "TwoStoriesOneTitleCheckViewer": - return TwoStoriesOneTitleCheckViewer(self) + def TwoStoriesOneTitleCheck(self) -> "TwoStoriesOneTitleCheckBuilder": + return TwoStoriesOneTitleCheckBuilder(self) @property - def UnionTest_ReturnType(self) -> "UnionTest_ReturnTypeViewer": - return UnionTest_ReturnTypeViewer(self) + def UnionTest_ReturnType(self) -> "UnionTest_ReturnTypeBuilder": + return UnionTest_ReturnTypeBuilder(self) @property - def UniverseQuestion(self) -> "UniverseQuestionViewer": - return UniverseQuestionViewer(self) + def UniverseQuestion(self) -> "UniverseQuestionBuilder": + return UniverseQuestionBuilder(self) @property - def UniverseQuestionInput(self) -> "UniverseQuestionInputViewer": - return UniverseQuestionInputViewer(self) + def UniverseQuestionInput(self) -> "UniverseQuestionInputBuilder": + return UniverseQuestionInputBuilder(self) @property - def WithReasoning(self) -> "WithReasoningViewer": - return WithReasoningViewer(self) + def WithReasoning(self) -> "WithReasoningBuilder": + return WithReasoningBuilder(self) @@ -531,9 +527,8 @@ def WithReasoning(self) -> "WithReasoningViewer": class AliasedEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("AliasedEnum") - self._values: typing.Set[str] = set([ "KEY_ONE", "KEY_TWO", ]) - self._vals = AliasedEnumValues(self._bldr, self._values) + self._bldr = _tb.get_enum("AliasedEnum") + self._vals = AliasedEnumValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -543,29 +538,28 @@ def values(self) -> "AliasedEnumValues": return self._vals -class AliasedEnumViewer(AliasedEnumAst): +class AliasedEnumBuilder(AliasedEnumAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class AliasedEnumValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def KEY_ONE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("KEY_ONE")) + def KEY_ONE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("KEY_ONE")) @property - def KEY_TWO(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("KEY_TWO")) + def KEY_TWO(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("KEY_TWO")) @@ -573,9 +567,8 @@ def KEY_TWO(self) -> type_builder.EnumValueViewer: class CategoryAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Category") - self._values: typing.Set[str] = set([ "Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ]) - self._vals = CategoryValues(self._bldr, self._values) + self._bldr = _tb.get_enum("Category") + self._vals = CategoryValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -585,41 +578,40 @@ def values(self) -> "CategoryValues": return self._vals -class CategoryViewer(CategoryAst): +class CategoryBuilder(CategoryAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class CategoryValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Refund(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Refund")) + def Refund(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Refund")) @property - def CancelOrder(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("CancelOrder")) + def CancelOrder(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("CancelOrder")) @property - def TechnicalSupport(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TechnicalSupport")) + def TechnicalSupport(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TechnicalSupport")) @property - def AccountIssue(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("AccountIssue")) + def AccountIssue(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("AccountIssue")) @property - def Question(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Question")) + def Question(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Question")) @@ -627,9 +619,8 @@ def Question(self) -> type_builder.EnumValueViewer: class Category2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Category2") - self._values: typing.Set[str] = set([ "Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ]) - self._vals = Category2Values(self._bldr, self._values) + self._bldr = _tb.get_enum("Category2") + self._vals = Category2Values(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -639,41 +630,40 @@ def values(self) -> "Category2Values": return self._vals -class Category2Viewer(Category2Ast): +class Category2Builder(Category2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class Category2Values: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Refund(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Refund")) + def Refund(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Refund")) @property - def CancelOrder(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("CancelOrder")) + def CancelOrder(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("CancelOrder")) @property - def TechnicalSupport(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TechnicalSupport")) + def TechnicalSupport(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TechnicalSupport")) @property - def AccountIssue(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("AccountIssue")) + def AccountIssue(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("AccountIssue")) @property - def Question(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Question")) + def Question(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Question")) @@ -681,9 +671,8 @@ def Question(self) -> type_builder.EnumValueViewer: class Category3Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Category3") - self._values: typing.Set[str] = set([ "Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ]) - self._vals = Category3Values(self._bldr, self._values) + self._bldr = _tb.get_enum("Category3") + self._vals = Category3Values(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -693,41 +682,40 @@ def values(self) -> "Category3Values": return self._vals -class Category3Viewer(Category3Ast): +class Category3Builder(Category3Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class Category3Values: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Refund(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Refund")) + def Refund(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Refund")) @property - def CancelOrder(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("CancelOrder")) + def CancelOrder(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("CancelOrder")) @property - def TechnicalSupport(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TechnicalSupport")) + def TechnicalSupport(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TechnicalSupport")) @property - def AccountIssue(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("AccountIssue")) + def AccountIssue(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("AccountIssue")) @property - def Question(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Question")) + def Question(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Question")) @@ -735,9 +723,8 @@ def Question(self) -> type_builder.EnumValueViewer: class ColorAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Color") - self._values: typing.Set[str] = set([ "RED", "BLUE", "GREEN", "YELLOW", "BLACK", "WHITE", ]) - self._vals = ColorValues(self._bldr, self._values) + self._bldr = _tb.get_enum("Color") + self._vals = ColorValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -752,50 +739,45 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class ColorValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @property - def RED(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("RED") + def RED(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("RED") @property - def BLUE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("BLUE") + def BLUE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("BLUE") @property - def GREEN(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("GREEN") + def GREEN(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("GREEN") @property - def YELLOW(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("YELLOW") + def YELLOW(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("YELLOW") @property - def BLACK(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("BLACK") + def BLACK(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("BLACK") @property - def WHITE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("WHITE") + def WHITE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("WHITE") @@ -803,9 +785,8 @@ def WHITE(self) -> baml_py.EnumValueBuilder: class DataTypeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("DataType") - self._values: typing.Set[str] = set([ "Resume", "Event", ]) - self._vals = DataTypeValues(self._bldr, self._values) + self._bldr = _tb.get_enum("DataType") + self._vals = DataTypeValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -815,29 +796,28 @@ def values(self) -> "DataTypeValues": return self._vals -class DataTypeViewer(DataTypeAst): +class DataTypeBuilder(DataTypeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class DataTypeValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Resume(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Resume")) + def Resume(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Resume")) @property - def Event(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Event")) + def Event(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Event")) @@ -845,9 +825,8 @@ def Event(self) -> type_builder.EnumValueViewer: class DynEnumOneAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("DynEnumOne") - self._values: typing.Set[str] = set([ ]) - self._vals = DynEnumOneValues(self._bldr, self._values) + self._bldr = _tb.get_enum("DynEnumOne") + self._vals = DynEnumOneValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -862,25 +841,20 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class DynEnumOneValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @@ -889,9 +863,8 @@ def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: class DynEnumThreeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("DynEnumThree") - self._values: typing.Set[str] = set([ "TRICYCLE", "TRIANGLE", ]) - self._vals = DynEnumThreeValues(self._bldr, self._values) + self._bldr = _tb.get_enum("DynEnumThree") + self._vals = DynEnumThreeValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -906,34 +879,29 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class DynEnumThreeValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @property - def TRICYCLE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("TRICYCLE") + def TRICYCLE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("TRICYCLE") @property - def TRIANGLE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("TRIANGLE") + def TRIANGLE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("TRIANGLE") @@ -941,9 +909,8 @@ def TRIANGLE(self) -> baml_py.EnumValueBuilder: class DynEnumTwoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("DynEnumTwo") - self._values: typing.Set[str] = set([ ]) - self._vals = DynEnumTwoValues(self._bldr, self._values) + self._bldr = _tb.get_enum("DynEnumTwo") + self._vals = DynEnumTwoValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -958,25 +925,20 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class DynEnumTwoValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @@ -985,9 +947,8 @@ def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: class EnumInClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("EnumInClass") - self._values: typing.Set[str] = set([ "ONE", "TWO", ]) - self._vals = EnumInClassValues(self._bldr, self._values) + self._bldr = _tb.get_enum("EnumInClass") + self._vals = EnumInClassValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -997,29 +958,28 @@ def values(self) -> "EnumInClassValues": return self._vals -class EnumInClassViewer(EnumInClassAst): +class EnumInClassBuilder(EnumInClassAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class EnumInClassValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ONE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("ONE")) + def ONE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("ONE")) @property - def TWO(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TWO")) + def TWO(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TWO")) @@ -1027,9 +987,8 @@ def TWO(self) -> type_builder.EnumValueViewer: class EnumOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("EnumOutput") - self._values: typing.Set[str] = set([ "ONE", "TWO", "THREE", ]) - self._vals = EnumOutputValues(self._bldr, self._values) + self._bldr = _tb.get_enum("EnumOutput") + self._vals = EnumOutputValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1039,33 +998,32 @@ def values(self) -> "EnumOutputValues": return self._vals -class EnumOutputViewer(EnumOutputAst): +class EnumOutputBuilder(EnumOutputAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class EnumOutputValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ONE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("ONE")) + def ONE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("ONE")) @property - def TWO(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TWO")) + def TWO(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TWO")) @property - def THREE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("THREE")) + def THREE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("THREE")) @@ -1073,9 +1031,8 @@ def THREE(self) -> type_builder.EnumValueViewer: class HobbyAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Hobby") - self._values: typing.Set[str] = set([ "SPORTS", "MUSIC", "READING", ]) - self._vals = HobbyValues(self._bldr, self._values) + self._bldr = _tb.get_enum("Hobby") + self._vals = HobbyValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1090,38 +1047,33 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class HobbyValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @property - def SPORTS(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("SPORTS") + def SPORTS(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("SPORTS") @property - def MUSIC(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("MUSIC") + def MUSIC(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("MUSIC") @property - def READING(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("READING") + def READING(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("READING") @@ -1129,9 +1081,8 @@ def READING(self) -> baml_py.EnumValueBuilder: class MapKeyAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("MapKey") - self._values: typing.Set[str] = set([ "A", "B", "C", ]) - self._vals = MapKeyValues(self._bldr, self._values) + self._bldr = _tb.get_enum("MapKey") + self._vals = MapKeyValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1141,33 +1092,32 @@ def values(self) -> "MapKeyValues": return self._vals -class MapKeyViewer(MapKeyAst): +class MapKeyBuilder(MapKeyAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class MapKeyValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def A(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("A")) + def A(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("A")) @property - def B(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("B")) + def B(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("B")) @property - def C(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("C")) + def C(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("C")) @@ -1175,9 +1125,8 @@ def C(self) -> type_builder.EnumValueViewer: class NamedArgsSingleEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("NamedArgsSingleEnum") - self._values: typing.Set[str] = set([ "ONE", "TWO", ]) - self._vals = NamedArgsSingleEnumValues(self._bldr, self._values) + self._bldr = _tb.get_enum("NamedArgsSingleEnum") + self._vals = NamedArgsSingleEnumValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1187,29 +1136,28 @@ def values(self) -> "NamedArgsSingleEnumValues": return self._vals -class NamedArgsSingleEnumViewer(NamedArgsSingleEnumAst): +class NamedArgsSingleEnumBuilder(NamedArgsSingleEnumAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class NamedArgsSingleEnumValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ONE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("ONE")) + def ONE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("ONE")) @property - def TWO(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TWO")) + def TWO(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TWO")) @@ -1217,9 +1165,8 @@ def TWO(self) -> type_builder.EnumValueViewer: class NamedArgsSingleEnumListAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("NamedArgsSingleEnumList") - self._values: typing.Set[str] = set([ "ONE", "TWO", ]) - self._vals = NamedArgsSingleEnumListValues(self._bldr, self._values) + self._bldr = _tb.get_enum("NamedArgsSingleEnumList") + self._vals = NamedArgsSingleEnumListValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1229,29 +1176,28 @@ def values(self) -> "NamedArgsSingleEnumListValues": return self._vals -class NamedArgsSingleEnumListViewer(NamedArgsSingleEnumListAst): +class NamedArgsSingleEnumListBuilder(NamedArgsSingleEnumListAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class NamedArgsSingleEnumListValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ONE(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("ONE")) + def ONE(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("ONE")) @property - def TWO(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("TWO")) + def TWO(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("TWO")) @@ -1259,9 +1205,8 @@ def TWO(self) -> type_builder.EnumValueViewer: class OptionalTest_CategoryTypeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("OptionalTest_CategoryType") - self._values: typing.Set[str] = set([ "Aleph", "Beta", "Gamma", ]) - self._vals = OptionalTest_CategoryTypeValues(self._bldr, self._values) + self._bldr = _tb.get_enum("OptionalTest_CategoryType") + self._vals = OptionalTest_CategoryTypeValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1271,33 +1216,32 @@ def values(self) -> "OptionalTest_CategoryTypeValues": return self._vals -class OptionalTest_CategoryTypeViewer(OptionalTest_CategoryTypeAst): +class OptionalTest_CategoryTypeBuilder(OptionalTest_CategoryTypeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class OptionalTest_CategoryTypeValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Aleph(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Aleph")) + def Aleph(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Aleph")) @property - def Beta(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Beta")) + def Beta(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Beta")) @property - def Gamma(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Gamma")) + def Gamma(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Gamma")) @@ -1305,9 +1249,8 @@ def Gamma(self) -> type_builder.EnumValueViewer: class OrderStatusAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("OrderStatus") - self._values: typing.Set[str] = set([ "ORDERED", "SHIPPED", "DELIVERED", "CANCELLED", ]) - self._vals = OrderStatusValues(self._bldr, self._values) + self._bldr = _tb.get_enum("OrderStatus") + self._vals = OrderStatusValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1317,37 +1260,36 @@ def values(self) -> "OrderStatusValues": return self._vals -class OrderStatusViewer(OrderStatusAst): +class OrderStatusBuilder(OrderStatusAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class OrderStatusValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ORDERED(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("ORDERED")) + def ORDERED(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("ORDERED")) @property - def SHIPPED(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("SHIPPED")) + def SHIPPED(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("SHIPPED")) @property - def DELIVERED(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("DELIVERED")) + def DELIVERED(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("DELIVERED")) @property - def CANCELLED(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("CANCELLED")) + def CANCELLED(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("CANCELLED")) @@ -1355,9 +1297,8 @@ def CANCELLED(self) -> type_builder.EnumValueViewer: class RenderStatusEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("RenderStatusEnum") - self._values: typing.Set[str] = set([ "ACTIVE", "INACTIVE", ]) - self._vals = RenderStatusEnumValues(self._bldr, self._values) + self._bldr = _tb.get_enum("RenderStatusEnum") + self._vals = RenderStatusEnumValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1372,34 +1313,29 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class RenderStatusEnumValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @property - def ACTIVE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("ACTIVE") + def ACTIVE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("ACTIVE") @property - def INACTIVE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("INACTIVE") + def INACTIVE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("INACTIVE") @@ -1407,9 +1343,8 @@ def INACTIVE(self) -> baml_py.EnumValueBuilder: class RenderTestEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("RenderTestEnum") - self._values: typing.Set[str] = set([ "BIKE", "SCOOTER", ]) - self._vals = RenderTestEnumValues(self._bldr, self._values) + self._bldr = _tb.get_enum("RenderTestEnum") + self._vals = RenderTestEnumValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1424,34 +1359,29 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, baml_py.EnumValueBuilder]]: - return [(name, self._bldr.value(name)) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return self._bldr.list_values() - def add_value(self, name: str) -> baml_py.EnumValueBuilder: - if name in self._values: - raise ValueError(f"Value {name} already exists.") - return self._bldr.value(name) + def add_value(self, name: str) -> type_builder.EnumValueBuilder: + return self._bldr.add_value(name) class RenderTestEnumValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.EnumValueBuilder: - if name not in self.__values: - raise AttributeError(f"Value {name} not found.") - return self.__bldr.value(name) + def __getattr__(self, name: str) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value(name) @property - def BIKE(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("BIKE") + def BIKE(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("BIKE") @property - def SCOOTER(self) -> baml_py.EnumValueBuilder: - return self.__bldr.value("SCOOTER") + def SCOOTER(self) -> type_builder.EnumValueBuilder: + return self.__bldr.get_value("SCOOTER") @@ -1459,9 +1389,8 @@ def SCOOTER(self) -> baml_py.EnumValueBuilder: class TagAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("Tag") - self._values: typing.Set[str] = set([ "Security", "AI", "Blockchain", ]) - self._vals = TagValues(self._bldr, self._values) + self._bldr = _tb.get_enum("Tag") + self._vals = TagValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1471,33 +1400,32 @@ def values(self) -> "TagValues": return self._vals -class TagViewer(TagAst): +class TagBuilder(TagAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class TagValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def Security(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Security")) + def Security(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Security")) @property - def AI(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("AI")) + def AI(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("AI")) @property - def Blockchain(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("Blockchain")) + def Blockchain(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("Blockchain")) @@ -1505,9 +1433,8 @@ def Blockchain(self) -> type_builder.EnumValueViewer: class TestEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.enum("TestEnum") - self._values: typing.Set[str] = set([ "A", "B", "C", "D", "E", "F", "G", ]) - self._vals = TestEnumValues(self._bldr, self._values) + self._bldr = _tb.get_enum("TestEnum") + self._vals = TestEnumValues(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1517,49 +1444,48 @@ def values(self) -> "TestEnumValues": return self._vals -class TestEnumViewer(TestEnumAst): +class TestEnumBuilder(TestEnumAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueViewer]]: - return [(name, type_builder.EnumValueViewer(self._bldr.value(name))) for name in self._values] + def list_values(self) -> typing.List[typing.Tuple[str, type_builder.EnumValueBuilder]]: + return [(name, type_builder.EnumValueBuilder(self._bldr.value(name))) for name in self._values] class TestEnumValues: - def __init__(self, enum_bldr: baml_py.EnumBuilder, values: typing.Set[str]): + def __init__(self, enum_bldr: baml_py.EnumBuilder): self.__bldr = enum_bldr - self.__values = values # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def A(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("A")) + def A(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("A")) @property - def B(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("B")) + def B(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("B")) @property - def C(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("C")) + def C(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("C")) @property - def D(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("D")) + def D(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("D")) @property - def E(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("E")) + def E(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("E")) @property - def F(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("F")) + def F(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("F")) @property - def G(self) -> type_builder.EnumValueViewer: - return type_builder.EnumValueViewer(self.__bldr.value("G")) + def G(self) -> type_builder.EnumValueBuilder: + return type_builder.EnumValueBuilder(self.__bldr.get_value("G")) @@ -1572,9 +1498,8 @@ def G(self) -> type_builder.EnumValueViewer: class AnotherObjectAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("AnotherObject") - self._properties: typing.Set[str] = set([ "id", "thingy2", "thingy3", ]) - self._props = AnotherObjectProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("AnotherObject") + self._props = AnotherObjectProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1584,34 +1509,33 @@ def props(self) -> "AnotherObjectProperties": return self._props -class AnotherObjectViewer(AnotherObjectAst): +class AnotherObjectBuilder(AnotherObjectAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class AnotherObjectProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def id(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("id")) + def id(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("id")) @property - def thingy2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("thingy2")) + def thingy2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("thingy2")) @property - def thingy3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("thingy3")) + def thingy3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("thingy3")) @@ -1619,9 +1543,8 @@ def thingy3(self) -> type_builder.ClassPropertyViewer: class BigNumbersAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("BigNumbers") - self._properties: typing.Set[str] = set([ "a", "b", ]) - self._props = BigNumbersProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("BigNumbers") + self._props = BigNumbersProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1631,30 +1554,29 @@ def props(self) -> "BigNumbersProperties": return self._props -class BigNumbersViewer(BigNumbersAst): +class BigNumbersBuilder(BigNumbersAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BigNumbersProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("a")) + def a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("a")) @property - def b(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("b")) + def b(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("b")) @@ -1662,9 +1584,8 @@ def b(self) -> type_builder.ClassPropertyViewer: class BinaryNodeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("BinaryNode") - self._properties: typing.Set[str] = set([ "data", "left", "right", ]) - self._props = BinaryNodeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("BinaryNode") + self._props = BinaryNodeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1674,34 +1595,33 @@ def props(self) -> "BinaryNodeProperties": return self._props -class BinaryNodeViewer(BinaryNodeAst): +class BinaryNodeBuilder(BinaryNodeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BinaryNodeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def data(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("data")) + def data(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("data")) @property - def left(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("left")) + def left(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("left")) @property - def right(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("right")) + def right(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("right")) @@ -1709,9 +1629,8 @@ def right(self) -> type_builder.ClassPropertyViewer: class BlahAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Blah") - self._properties: typing.Set[str] = set([ "prop4", ]) - self._props = BlahProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Blah") + self._props = BlahProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1721,26 +1640,25 @@ def props(self) -> "BlahProperties": return self._props -class BlahViewer(BlahAst): +class BlahBuilder(BlahAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BlahProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop4(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop4")) + def prop4(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop4")) @@ -1748,9 +1666,8 @@ def prop4(self) -> type_builder.ClassPropertyViewer: class BlockConstraintAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("BlockConstraint") - self._properties: typing.Set[str] = set([ "foo", "bar", ]) - self._props = BlockConstraintProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("BlockConstraint") + self._props = BlockConstraintProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1760,30 +1677,29 @@ def props(self) -> "BlockConstraintProperties": return self._props -class BlockConstraintViewer(BlockConstraintAst): +class BlockConstraintBuilder(BlockConstraintAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BlockConstraintProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def foo(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("foo")) + def foo(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("foo")) @property - def bar(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("bar")) + def bar(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("bar")) @@ -1791,9 +1707,8 @@ def bar(self) -> type_builder.ClassPropertyViewer: class BlockConstraintForParamAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("BlockConstraintForParam") - self._properties: typing.Set[str] = set([ "bcfp", "bcfp2", ]) - self._props = BlockConstraintForParamProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("BlockConstraintForParam") + self._props = BlockConstraintForParamProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1803,30 +1718,29 @@ def props(self) -> "BlockConstraintForParamProperties": return self._props -class BlockConstraintForParamViewer(BlockConstraintForParamAst): +class BlockConstraintForParamBuilder(BlockConstraintForParamAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BlockConstraintForParamProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def bcfp(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("bcfp")) + def bcfp(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("bcfp")) @property - def bcfp2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("bcfp2")) + def bcfp2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("bcfp2")) @@ -1834,9 +1748,8 @@ def bcfp2(self) -> type_builder.ClassPropertyViewer: class BookOrderAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("BookOrder") - self._properties: typing.Set[str] = set([ "orderId", "title", "quantity", "price", ]) - self._props = BookOrderProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("BookOrder") + self._props = BookOrderProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1846,38 +1759,37 @@ def props(self) -> "BookOrderProperties": return self._props -class BookOrderViewer(BookOrderAst): +class BookOrderBuilder(BookOrderAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class BookOrderProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def orderId(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("orderId")) + def orderId(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("orderId")) @property - def title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("title")) + def title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("title")) @property - def quantity(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("quantity")) + def quantity(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("quantity")) @property - def price(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("price")) + def price(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("price")) @@ -1885,9 +1797,8 @@ def price(self) -> type_builder.ClassPropertyViewer: class ClassForNullLiteralAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassForNullLiteral") - self._properties: typing.Set[str] = set([ "a", ]) - self._props = ClassForNullLiteralProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassForNullLiteral") + self._props = ClassForNullLiteralProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1897,26 +1808,25 @@ def props(self) -> "ClassForNullLiteralProperties": return self._props -class ClassForNullLiteralViewer(ClassForNullLiteralAst): +class ClassForNullLiteralBuilder(ClassForNullLiteralAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassForNullLiteralProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("a")) + def a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("a")) @@ -1924,9 +1834,8 @@ def a(self) -> type_builder.ClassPropertyViewer: class ClassOptionalOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassOptionalOutput") - self._properties: typing.Set[str] = set([ "prop1", "prop2", ]) - self._props = ClassOptionalOutputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassOptionalOutput") + self._props = ClassOptionalOutputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1936,30 +1845,29 @@ def props(self) -> "ClassOptionalOutputProperties": return self._props -class ClassOptionalOutputViewer(ClassOptionalOutputAst): +class ClassOptionalOutputBuilder(ClassOptionalOutputAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassOptionalOutputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @@ -1967,9 +1875,8 @@ def prop2(self) -> type_builder.ClassPropertyViewer: class ClassOptionalOutput2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassOptionalOutput2") - self._properties: typing.Set[str] = set([ "prop1", "prop2", "prop3", ]) - self._props = ClassOptionalOutput2Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassOptionalOutput2") + self._props = ClassOptionalOutput2Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -1979,34 +1886,33 @@ def props(self) -> "ClassOptionalOutput2Properties": return self._props -class ClassOptionalOutput2Viewer(ClassOptionalOutput2Ast): +class ClassOptionalOutput2Builder(ClassOptionalOutput2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassOptionalOutput2Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @property - def prop3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop3")) + def prop3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop3")) @@ -2014,9 +1920,8 @@ def prop3(self) -> type_builder.ClassPropertyViewer: class ClassToRecAliasAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassToRecAlias") - self._properties: typing.Set[str] = set([ "list", ]) - self._props = ClassToRecAliasProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassToRecAlias") + self._props = ClassToRecAliasProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2026,26 +1931,25 @@ def props(self) -> "ClassToRecAliasProperties": return self._props -class ClassToRecAliasViewer(ClassToRecAliasAst): +class ClassToRecAliasBuilder(ClassToRecAliasAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassToRecAliasProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def list(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("list")) + def list(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("list")) @@ -2053,9 +1957,8 @@ def list(self) -> type_builder.ClassPropertyViewer: class ClassWithBlockDoneAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassWithBlockDone") - self._properties: typing.Set[str] = set([ "i_16_digits", "s_20_words", ]) - self._props = ClassWithBlockDoneProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassWithBlockDone") + self._props = ClassWithBlockDoneProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2065,30 +1968,29 @@ def props(self) -> "ClassWithBlockDoneProperties": return self._props -class ClassWithBlockDoneViewer(ClassWithBlockDoneAst): +class ClassWithBlockDoneBuilder(ClassWithBlockDoneAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassWithBlockDoneProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def i_16_digits(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("i_16_digits")) + def i_16_digits(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("i_16_digits")) @property - def s_20_words(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("s_20_words")) + def s_20_words(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("s_20_words")) @@ -2096,9 +1998,8 @@ def s_20_words(self) -> type_builder.ClassPropertyViewer: class ClassWithImageAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassWithImage") - self._properties: typing.Set[str] = set([ "myImage", "param2", "fake_image", ]) - self._props = ClassWithImageProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassWithImage") + self._props = ClassWithImageProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2108,34 +2009,33 @@ def props(self) -> "ClassWithImageProperties": return self._props -class ClassWithImageViewer(ClassWithImageAst): +class ClassWithImageBuilder(ClassWithImageAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassWithImageProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def myImage(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("myImage")) + def myImage(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("myImage")) @property - def param2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("param2")) + def param2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("param2")) @property - def fake_image(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("fake_image")) + def fake_image(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("fake_image")) @@ -2143,9 +2043,8 @@ def fake_image(self) -> type_builder.ClassPropertyViewer: class ClassWithoutDoneAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClassWithoutDone") - self._properties: typing.Set[str] = set([ "i_16_digits", "s_20_words", ]) - self._props = ClassWithoutDoneProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClassWithoutDone") + self._props = ClassWithoutDoneProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2155,30 +2054,29 @@ def props(self) -> "ClassWithoutDoneProperties": return self._props -class ClassWithoutDoneViewer(ClassWithoutDoneAst): +class ClassWithoutDoneBuilder(ClassWithoutDoneAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClassWithoutDoneProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def i_16_digits(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("i_16_digits")) + def i_16_digits(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("i_16_digits")) @property - def s_20_words(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("s_20_words")) + def s_20_words(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("s_20_words")) @@ -2186,9 +2084,8 @@ def s_20_words(self) -> type_builder.ClassPropertyViewer: class ClientDetails1559Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ClientDetails1559") - self._properties: typing.Set[str] = set([ "client_name", "client_address", "client_postal_code", "client_city", "client_country", "client_phone", "client_email", ]) - self._props = ClientDetails1559Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("ClientDetails1559") + self._props = ClientDetails1559Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2198,50 +2095,49 @@ def props(self) -> "ClientDetails1559Properties": return self._props -class ClientDetails1559Viewer(ClientDetails1559Ast): +class ClientDetails1559Builder(ClientDetails1559Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ClientDetails1559Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def client_name(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_name")) + def client_name(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_name")) @property - def client_address(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_address")) + def client_address(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_address")) @property - def client_postal_code(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_postal_code")) + def client_postal_code(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_postal_code")) @property - def client_city(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_city")) + def client_city(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_city")) @property - def client_country(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_country")) + def client_country(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_country")) @property - def client_phone(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_phone")) + def client_phone(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_phone")) @property - def client_email(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_email")) + def client_email(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_email")) @@ -2249,9 +2145,8 @@ def client_email(self) -> type_builder.ClassPropertyViewer: class ComplexMemoryObjectAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ComplexMemoryObject") - self._properties: typing.Set[str] = set([ "id", "name", "description", "metadata", ]) - self._props = ComplexMemoryObjectProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ComplexMemoryObject") + self._props = ComplexMemoryObjectProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2261,38 +2156,37 @@ def props(self) -> "ComplexMemoryObjectProperties": return self._props -class ComplexMemoryObjectViewer(ComplexMemoryObjectAst): +class ComplexMemoryObjectBuilder(ComplexMemoryObjectAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ComplexMemoryObjectProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def id(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("id")) + def id(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("id")) @property - def name(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("name")) + def name(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("name")) @property - def description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("description")) + def description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("description")) @property - def metadata(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("metadata")) + def metadata(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("metadata")) @@ -2300,9 +2194,8 @@ def metadata(self) -> type_builder.ClassPropertyViewer: class CompoundBigNumbersAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("CompoundBigNumbers") - self._properties: typing.Set[str] = set([ "big", "big_nums", "another", ]) - self._props = CompoundBigNumbersProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("CompoundBigNumbers") + self._props = CompoundBigNumbersProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2312,34 +2205,33 @@ def props(self) -> "CompoundBigNumbersProperties": return self._props -class CompoundBigNumbersViewer(CompoundBigNumbersAst): +class CompoundBigNumbersBuilder(CompoundBigNumbersAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class CompoundBigNumbersProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def big(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("big")) + def big(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("big")) @property - def big_nums(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("big_nums")) + def big_nums(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("big_nums")) @property - def another(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("another")) + def another(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("another")) @@ -2347,9 +2239,8 @@ def another(self) -> type_builder.ClassPropertyViewer: class ContactInfoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ContactInfo") - self._properties: typing.Set[str] = set([ "primary", "secondary", ]) - self._props = ContactInfoProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ContactInfo") + self._props = ContactInfoProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2359,30 +2250,29 @@ def props(self) -> "ContactInfoProperties": return self._props -class ContactInfoViewer(ContactInfoAst): +class ContactInfoBuilder(ContactInfoAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ContactInfoProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def primary(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("primary")) + def primary(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("primary")) @property - def secondary(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("secondary")) + def secondary(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("secondary")) @@ -2390,9 +2280,8 @@ def secondary(self) -> type_builder.ClassPropertyViewer: class CustomStoryAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("CustomStory") - self._properties: typing.Set[str] = set([ "title", "characters", "content", ]) - self._props = CustomStoryProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("CustomStory") + self._props = CustomStoryProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2402,34 +2291,33 @@ def props(self) -> "CustomStoryProperties": return self._props -class CustomStoryViewer(CustomStoryAst): +class CustomStoryBuilder(CustomStoryAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class CustomStoryProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("title")) + def title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("title")) @property - def characters(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("characters")) + def characters(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("characters")) @property - def content(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("content")) + def content(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("content")) @@ -2437,9 +2325,8 @@ def content(self) -> type_builder.ClassPropertyViewer: class CustomTaskResultAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("CustomTaskResult") - self._properties: typing.Set[str] = set([ "bookOrder", "flightConfirmation", "groceryReceipt", ]) - self._props = CustomTaskResultProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("CustomTaskResult") + self._props = CustomTaskResultProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2449,34 +2336,33 @@ def props(self) -> "CustomTaskResultProperties": return self._props -class CustomTaskResultViewer(CustomTaskResultAst): +class CustomTaskResultBuilder(CustomTaskResultAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class CustomTaskResultProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def bookOrder(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("bookOrder")) + def bookOrder(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("bookOrder")) @property - def flightConfirmation(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("flightConfirmation")) + def flightConfirmation(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("flightConfirmation")) @property - def groceryReceipt(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("groceryReceipt")) + def groceryReceipt(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("groceryReceipt")) @@ -2484,9 +2370,8 @@ def groceryReceipt(self) -> type_builder.ClassPropertyViewer: class Document1559Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Document1559") - self._properties: typing.Set[str] = set([ "client_details", "notes", ]) - self._props = Document1559Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("Document1559") + self._props = Document1559Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2496,30 +2381,29 @@ def props(self) -> "Document1559Properties": return self._props -class Document1559Viewer(Document1559Ast): +class Document1559Builder(Document1559Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class Document1559Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def client_details(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("client_details")) + def client_details(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("client_details")) @property - def notes(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("notes")) + def notes(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("notes")) @@ -2527,9 +2411,8 @@ def notes(self) -> type_builder.ClassPropertyViewer: class DummyOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DummyOutput") - self._properties: typing.Set[str] = set([ "nonce", "nonce2", ]) - self._props = DummyOutputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DummyOutput") + self._props = DummyOutputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2544,12 +2427,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2562,24 +2443,21 @@ def reset(self) -> None: class DummyOutputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def nonce(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("nonce") + def nonce(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("nonce") @property - def nonce2(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("nonce2") + def nonce2(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("nonce2") @@ -2587,9 +2465,8 @@ def nonce2(self) -> baml_py.ClassPropertyBuilder: class DynInputOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DynInputOutput") - self._properties: typing.Set[str] = set([ "testKey", ]) - self._props = DynInputOutputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DynInputOutput") + self._props = DynInputOutputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2604,12 +2481,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2622,20 +2497,17 @@ def reset(self) -> None: class DynInputOutputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def testKey(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("testKey") + def testKey(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("testKey") @@ -2643,9 +2515,8 @@ def testKey(self) -> baml_py.ClassPropertyBuilder: class DynamicClassOneAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DynamicClassOne") - self._properties: typing.Set[str] = set([ ]) - self._props = DynamicClassOneProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DynamicClassOne") + self._props = DynamicClassOneProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2660,12 +2531,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2678,15 +2547,12 @@ def reset(self) -> None: class DynamicClassOneProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @@ -2695,9 +2561,8 @@ def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: class DynamicClassTwoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DynamicClassTwo") - self._properties: typing.Set[str] = set([ "hi", "some_class", "status", ]) - self._props = DynamicClassTwoProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DynamicClassTwo") + self._props = DynamicClassTwoProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2712,12 +2577,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2730,28 +2593,25 @@ def reset(self) -> None: class DynamicClassTwoProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def hi(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("hi") + def hi(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("hi") @property - def some_class(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("some_class") + def some_class(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("some_class") @property - def status(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("status") + def status(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("status") @@ -2759,9 +2619,8 @@ def status(self) -> baml_py.ClassPropertyBuilder: class DynamicOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DynamicOutput") - self._properties: typing.Set[str] = set([ ]) - self._props = DynamicOutputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DynamicOutput") + self._props = DynamicOutputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2776,12 +2635,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2794,15 +2651,12 @@ def reset(self) -> None: class DynamicOutputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @@ -2811,9 +2665,8 @@ def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: class DynamicSchemaAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("DynamicSchema") - self._properties: typing.Set[str] = set([ ]) - self._props = DynamicSchemaProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("DynamicSchema") + self._props = DynamicSchemaProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2828,12 +2681,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -2846,15 +2697,12 @@ def reset(self) -> None: class DynamicSchemaProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @@ -2863,9 +2711,8 @@ def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: class EarthlingAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Earthling") - self._properties: typing.Set[str] = set([ "age", ]) - self._props = EarthlingProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Earthling") + self._props = EarthlingProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2875,26 +2722,25 @@ def props(self) -> "EarthlingProperties": return self._props -class EarthlingViewer(EarthlingAst): +class EarthlingBuilder(EarthlingAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class EarthlingProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def age(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("age")) + def age(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("age")) @@ -2902,9 +2748,8 @@ def age(self) -> type_builder.ClassPropertyViewer: class EducationAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Education") - self._properties: typing.Set[str] = set([ "institution", "location", "degree", "major", "graduation_date", ]) - self._props = EducationProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Education") + self._props = EducationProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2914,42 +2759,41 @@ def props(self) -> "EducationProperties": return self._props -class EducationViewer(EducationAst): +class EducationBuilder(EducationAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class EducationProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def institution(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("institution")) + def institution(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("institution")) @property - def location(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("location")) + def location(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("location")) @property - def degree(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("degree")) + def degree(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("degree")) @property - def major(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("major")) + def major(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("major")) @property - def graduation_date(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("graduation_date")) + def graduation_date(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("graduation_date")) @@ -2957,9 +2801,8 @@ def graduation_date(self) -> type_builder.ClassPropertyViewer: class EmailAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Email") - self._properties: typing.Set[str] = set([ "subject", "body", "from_address", ]) - self._props = EmailProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Email") + self._props = EmailProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -2969,34 +2812,33 @@ def props(self) -> "EmailProperties": return self._props -class EmailViewer(EmailAst): +class EmailBuilder(EmailAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class EmailProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def subject(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("subject")) + def subject(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("subject")) @property - def body(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("body")) + def body(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("body")) @property - def from_address(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("from_address")) + def from_address(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("from_address")) @@ -3004,9 +2846,8 @@ def from_address(self) -> type_builder.ClassPropertyViewer: class EmailAddressAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("EmailAddress") - self._properties: typing.Set[str] = set([ "value", ]) - self._props = EmailAddressProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("EmailAddress") + self._props = EmailAddressProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3016,26 +2857,25 @@ def props(self) -> "EmailAddressProperties": return self._props -class EmailAddressViewer(EmailAddressAst): +class EmailAddressBuilder(EmailAddressAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class EmailAddressProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @@ -3043,9 +2883,8 @@ def value(self) -> type_builder.ClassPropertyViewer: class EventAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Event") - self._properties: typing.Set[str] = set([ "title", "date", "location", "description", ]) - self._props = EventProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Event") + self._props = EventProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3055,38 +2894,37 @@ def props(self) -> "EventProperties": return self._props -class EventViewer(EventAst): +class EventBuilder(EventAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class EventProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("title")) + def title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("title")) @property - def date(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("date")) + def date(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("date")) @property - def location(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("location")) + def location(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("location")) @property - def description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("description")) + def description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("description")) @@ -3094,9 +2932,8 @@ def description(self) -> type_builder.ClassPropertyViewer: class FakeImageAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FakeImage") - self._properties: typing.Set[str] = set([ "url", ]) - self._props = FakeImageProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("FakeImage") + self._props = FakeImageProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3106,26 +2943,25 @@ def props(self) -> "FakeImageProperties": return self._props -class FakeImageViewer(FakeImageAst): +class FakeImageBuilder(FakeImageAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FakeImageProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def url(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("url")) + def url(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("url")) @@ -3133,9 +2969,8 @@ def url(self) -> type_builder.ClassPropertyViewer: class FlightConfirmationAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FlightConfirmation") - self._properties: typing.Set[str] = set([ "confirmationNumber", "flightNumber", "departureTime", "arrivalTime", "seatNumber", ]) - self._props = FlightConfirmationProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("FlightConfirmation") + self._props = FlightConfirmationProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3145,42 +2980,41 @@ def props(self) -> "FlightConfirmationProperties": return self._props -class FlightConfirmationViewer(FlightConfirmationAst): +class FlightConfirmationBuilder(FlightConfirmationAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FlightConfirmationProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def confirmationNumber(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("confirmationNumber")) + def confirmationNumber(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("confirmationNumber")) @property - def flightNumber(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("flightNumber")) + def flightNumber(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("flightNumber")) @property - def departureTime(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("departureTime")) + def departureTime(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("departureTime")) @property - def arrivalTime(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("arrivalTime")) + def arrivalTime(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("arrivalTime")) @property - def seatNumber(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("seatNumber")) + def seatNumber(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("seatNumber")) @@ -3188,9 +3022,8 @@ def seatNumber(self) -> type_builder.ClassPropertyViewer: class FooAnyAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FooAny") - self._properties: typing.Set[str] = set([ "planetary_age", "certainty", "species", ]) - self._props = FooAnyProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("FooAny") + self._props = FooAnyProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3200,34 +3033,33 @@ def props(self) -> "FooAnyProperties": return self._props -class FooAnyViewer(FooAnyAst): +class FooAnyBuilder(FooAnyAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FooAnyProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def planetary_age(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("planetary_age")) + def planetary_age(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("planetary_age")) @property - def certainty(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("certainty")) + def certainty(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("certainty")) @property - def species(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("species")) + def species(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("species")) @@ -3235,9 +3067,8 @@ def species(self) -> type_builder.ClassPropertyViewer: class ForestAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Forest") - self._properties: typing.Set[str] = set([ "trees", ]) - self._props = ForestProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Forest") + self._props = ForestProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3247,26 +3078,25 @@ def props(self) -> "ForestProperties": return self._props -class ForestViewer(ForestAst): +class ForestBuilder(ForestAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ForestProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def trees(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("trees")) + def trees(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("trees")) @@ -3274,9 +3104,8 @@ def trees(self) -> type_builder.ClassPropertyViewer: class FormatterTest0Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FormatterTest0") - self._properties: typing.Set[str] = set([ "lorem", "ipsum", ]) - self._props = FormatterTest0Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("FormatterTest0") + self._props = FormatterTest0Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3286,30 +3115,29 @@ def props(self) -> "FormatterTest0Properties": return self._props -class FormatterTest0Viewer(FormatterTest0Ast): +class FormatterTest0Builder(FormatterTest0Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FormatterTest0Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def lorem(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("lorem")) + def lorem(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("lorem")) @property - def ipsum(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("ipsum")) + def ipsum(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("ipsum")) @@ -3317,9 +3145,8 @@ def ipsum(self) -> type_builder.ClassPropertyViewer: class FormatterTest1Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FormatterTest1") - self._properties: typing.Set[str] = set([ "lorem", "ipsum", ]) - self._props = FormatterTest1Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("FormatterTest1") + self._props = FormatterTest1Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3329,30 +3156,29 @@ def props(self) -> "FormatterTest1Properties": return self._props -class FormatterTest1Viewer(FormatterTest1Ast): +class FormatterTest1Builder(FormatterTest1Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FormatterTest1Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def lorem(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("lorem")) + def lorem(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("lorem")) @property - def ipsum(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("ipsum")) + def ipsum(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("ipsum")) @@ -3360,9 +3186,8 @@ def ipsum(self) -> type_builder.ClassPropertyViewer: class FormatterTest2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FormatterTest2") - self._properties: typing.Set[str] = set([ "lorem", "ipsum", ]) - self._props = FormatterTest2Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("FormatterTest2") + self._props = FormatterTest2Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3372,30 +3197,29 @@ def props(self) -> "FormatterTest2Properties": return self._props -class FormatterTest2Viewer(FormatterTest2Ast): +class FormatterTest2Builder(FormatterTest2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FormatterTest2Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def lorem(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("lorem")) + def lorem(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("lorem")) @property - def ipsum(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("ipsum")) + def ipsum(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("ipsum")) @@ -3403,9 +3227,8 @@ def ipsum(self) -> type_builder.ClassPropertyViewer: class FormatterTest3Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("FormatterTest3") - self._properties: typing.Set[str] = set([ "lorem", "ipsum", ]) - self._props = FormatterTest3Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("FormatterTest3") + self._props = FormatterTest3Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3415,30 +3238,29 @@ def props(self) -> "FormatterTest3Properties": return self._props -class FormatterTest3Viewer(FormatterTest3Ast): +class FormatterTest3Builder(FormatterTest3Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class FormatterTest3Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def lorem(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("lorem")) + def lorem(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("lorem")) @property - def ipsum(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("ipsum")) + def ipsum(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("ipsum")) @@ -3446,9 +3268,8 @@ def ipsum(self) -> type_builder.ClassPropertyViewer: class GroceryReceiptAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("GroceryReceipt") - self._properties: typing.Set[str] = set([ "receiptId", "storeName", "items", "totalAmount", ]) - self._props = GroceryReceiptProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("GroceryReceipt") + self._props = GroceryReceiptProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3458,38 +3279,37 @@ def props(self) -> "GroceryReceiptProperties": return self._props -class GroceryReceiptViewer(GroceryReceiptAst): +class GroceryReceiptBuilder(GroceryReceiptAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class GroceryReceiptProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def receiptId(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("receiptId")) + def receiptId(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("receiptId")) @property - def storeName(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("storeName")) + def storeName(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("storeName")) @property - def items(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("items")) + def items(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("items")) @property - def totalAmount(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("totalAmount")) + def totalAmount(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("totalAmount")) @@ -3497,9 +3317,8 @@ def totalAmount(self) -> type_builder.ClassPropertyViewer: class HaikuAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Haiku") - self._properties: typing.Set[str] = set([ "line1", "line2", "line3", ]) - self._props = HaikuProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Haiku") + self._props = HaikuProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3509,34 +3328,33 @@ def props(self) -> "HaikuProperties": return self._props -class HaikuViewer(HaikuAst): +class HaikuBuilder(HaikuAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class HaikuProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def line1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("line1")) + def line1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("line1")) @property - def line2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("line2")) + def line2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("line2")) @property - def line3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("line3")) + def line3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("line3")) @@ -3544,9 +3362,8 @@ def line3(self) -> type_builder.ClassPropertyViewer: class InnerClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("InnerClass") - self._properties: typing.Set[str] = set([ "prop1", "prop2", "inner", ]) - self._props = InnerClassProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("InnerClass") + self._props = InnerClassProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3556,34 +3373,33 @@ def props(self) -> "InnerClassProperties": return self._props -class InnerClassViewer(InnerClassAst): +class InnerClassBuilder(InnerClassAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class InnerClassProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @property - def inner(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("inner")) + def inner(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("inner")) @@ -3591,9 +3407,8 @@ def inner(self) -> type_builder.ClassPropertyViewer: class InnerClass2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("InnerClass2") - self._properties: typing.Set[str] = set([ "prop2", "prop3", ]) - self._props = InnerClass2Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("InnerClass2") + self._props = InnerClass2Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3603,30 +3418,29 @@ def props(self) -> "InnerClass2Properties": return self._props -class InnerClass2Viewer(InnerClass2Ast): +class InnerClass2Builder(InnerClass2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class InnerClass2Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @property - def prop3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop3")) + def prop3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop3")) @@ -3634,9 +3448,8 @@ def prop3(self) -> type_builder.ClassPropertyViewer: class InputClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("InputClass") - self._properties: typing.Set[str] = set([ "key", "key2", ]) - self._props = InputClassProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("InputClass") + self._props = InputClassProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3646,30 +3459,29 @@ def props(self) -> "InputClassProperties": return self._props -class InputClassViewer(InputClassAst): +class InputClassBuilder(InputClassAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class InputClassProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def key(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key")) + def key(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key")) @property - def key2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key2")) + def key2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key2")) @@ -3677,9 +3489,8 @@ def key2(self) -> type_builder.ClassPropertyViewer: class InputClassNestedAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("InputClassNested") - self._properties: typing.Set[str] = set([ "key", "nested", ]) - self._props = InputClassNestedProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("InputClassNested") + self._props = InputClassNestedProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3689,30 +3500,29 @@ def props(self) -> "InputClassNestedProperties": return self._props -class InputClassNestedViewer(InputClassNestedAst): +class InputClassNestedBuilder(InputClassNestedAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class InputClassNestedProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def key(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key")) + def key(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key")) @property - def nested(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("nested")) + def nested(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("nested")) @@ -3720,9 +3530,8 @@ def nested(self) -> type_builder.ClassPropertyViewer: class LinkedListAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("LinkedList") - self._properties: typing.Set[str] = set([ "head", "len", ]) - self._props = LinkedListProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("LinkedList") + self._props = LinkedListProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3732,30 +3541,29 @@ def props(self) -> "LinkedListProperties": return self._props -class LinkedListViewer(LinkedListAst): +class LinkedListBuilder(LinkedListAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class LinkedListProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def head(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("head")) + def head(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("head")) @property - def len(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("len")) + def len(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("len")) @@ -3763,9 +3571,8 @@ def len(self) -> type_builder.ClassPropertyViewer: class LinkedListAliasNodeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("LinkedListAliasNode") - self._properties: typing.Set[str] = set([ "value", "next", ]) - self._props = LinkedListAliasNodeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("LinkedListAliasNode") + self._props = LinkedListAliasNodeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3775,30 +3582,29 @@ def props(self) -> "LinkedListAliasNodeProperties": return self._props -class LinkedListAliasNodeViewer(LinkedListAliasNodeAst): +class LinkedListAliasNodeBuilder(LinkedListAliasNodeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class LinkedListAliasNodeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @property - def next(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("next")) + def next(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("next")) @@ -3806,9 +3612,8 @@ def next(self) -> type_builder.ClassPropertyViewer: class LiteralClassHelloAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("LiteralClassHello") - self._properties: typing.Set[str] = set([ "prop", ]) - self._props = LiteralClassHelloProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("LiteralClassHello") + self._props = LiteralClassHelloProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3818,26 +3623,25 @@ def props(self) -> "LiteralClassHelloProperties": return self._props -class LiteralClassHelloViewer(LiteralClassHelloAst): +class LiteralClassHelloBuilder(LiteralClassHelloAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class LiteralClassHelloProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop")) + def prop(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop")) @@ -3845,9 +3649,8 @@ def prop(self) -> type_builder.ClassPropertyViewer: class LiteralClassOneAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("LiteralClassOne") - self._properties: typing.Set[str] = set([ "prop", ]) - self._props = LiteralClassOneProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("LiteralClassOne") + self._props = LiteralClassOneProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3857,26 +3660,25 @@ def props(self) -> "LiteralClassOneProperties": return self._props -class LiteralClassOneViewer(LiteralClassOneAst): +class LiteralClassOneBuilder(LiteralClassOneAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class LiteralClassOneProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop")) + def prop(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop")) @@ -3884,9 +3686,8 @@ def prop(self) -> type_builder.ClassPropertyViewer: class LiteralClassTwoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("LiteralClassTwo") - self._properties: typing.Set[str] = set([ "prop", ]) - self._props = LiteralClassTwoProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("LiteralClassTwo") + self._props = LiteralClassTwoProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3896,26 +3697,25 @@ def props(self) -> "LiteralClassTwoProperties": return self._props -class LiteralClassTwoViewer(LiteralClassTwoAst): +class LiteralClassTwoBuilder(LiteralClassTwoAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class LiteralClassTwoProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop")) + def prop(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop")) @@ -3923,9 +3723,8 @@ def prop(self) -> type_builder.ClassPropertyViewer: class MaintainFieldOrderAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("MaintainFieldOrder") - self._properties: typing.Set[str] = set([ "a", "b", "c", ]) - self._props = MaintainFieldOrderProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("MaintainFieldOrder") + self._props = MaintainFieldOrderProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3935,34 +3734,33 @@ def props(self) -> "MaintainFieldOrderProperties": return self._props -class MaintainFieldOrderViewer(MaintainFieldOrderAst): +class MaintainFieldOrderBuilder(MaintainFieldOrderAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MaintainFieldOrderProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("a")) + def a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("a")) @property - def b(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("b")) + def b(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("b")) @property - def c(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("c")) + def c(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("c")) @@ -3970,9 +3768,8 @@ def c(self) -> type_builder.ClassPropertyViewer: class MalformedConstraintsAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("MalformedConstraints") - self._properties: typing.Set[str] = set([ "foo", ]) - self._props = MalformedConstraintsProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("MalformedConstraints") + self._props = MalformedConstraintsProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -3982,26 +3779,25 @@ def props(self) -> "MalformedConstraintsProperties": return self._props -class MalformedConstraintsViewer(MalformedConstraintsAst): +class MalformedConstraintsBuilder(MalformedConstraintsAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MalformedConstraintsProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def foo(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("foo")) + def foo(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("foo")) @@ -4009,9 +3805,8 @@ def foo(self) -> type_builder.ClassPropertyViewer: class MalformedConstraints2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("MalformedConstraints2") - self._properties: typing.Set[str] = set([ "foo", ]) - self._props = MalformedConstraints2Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("MalformedConstraints2") + self._props = MalformedConstraints2Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4021,26 +3816,25 @@ def props(self) -> "MalformedConstraints2Properties": return self._props -class MalformedConstraints2Viewer(MalformedConstraints2Ast): +class MalformedConstraints2Builder(MalformedConstraints2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MalformedConstraints2Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def foo(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("foo")) + def foo(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("foo")) @@ -4048,9 +3842,8 @@ def foo(self) -> type_builder.ClassPropertyViewer: class MartianAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Martian") - self._properties: typing.Set[str] = set([ "age", ]) - self._props = MartianProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Martian") + self._props = MartianProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4060,26 +3853,25 @@ def props(self) -> "MartianProperties": return self._props -class MartianViewer(MartianAst): +class MartianBuilder(MartianAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MartianProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def age(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("age")) + def age(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("age")) @@ -4087,9 +3879,8 @@ def age(self) -> type_builder.ClassPropertyViewer: class MemoryObjectAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("MemoryObject") - self._properties: typing.Set[str] = set([ "id", "name", "description", ]) - self._props = MemoryObjectProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("MemoryObject") + self._props = MemoryObjectProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4099,34 +3890,33 @@ def props(self) -> "MemoryObjectProperties": return self._props -class MemoryObjectViewer(MemoryObjectAst): +class MemoryObjectBuilder(MemoryObjectAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MemoryObjectProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def id(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("id")) + def id(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("id")) @property - def name(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("name")) + def name(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("name")) @property - def description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("description")) + def description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("description")) @@ -4134,9 +3924,8 @@ def description(self) -> type_builder.ClassPropertyViewer: class MergeAttrsAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("MergeAttrs") - self._properties: typing.Set[str] = set([ "amount", ]) - self._props = MergeAttrsProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("MergeAttrs") + self._props = MergeAttrsProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4146,26 +3935,25 @@ def props(self) -> "MergeAttrsProperties": return self._props -class MergeAttrsViewer(MergeAttrsAst): +class MergeAttrsBuilder(MergeAttrsAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class MergeAttrsProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def amount(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("amount")) + def amount(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("amount")) @@ -4173,9 +3961,8 @@ def amount(self) -> type_builder.ClassPropertyViewer: class NamedArgsSingleClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("NamedArgsSingleClass") - self._properties: typing.Set[str] = set([ "key", "key_two", "key_three", ]) - self._props = NamedArgsSingleClassProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("NamedArgsSingleClass") + self._props = NamedArgsSingleClassProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4185,34 +3972,33 @@ def props(self) -> "NamedArgsSingleClassProperties": return self._props -class NamedArgsSingleClassViewer(NamedArgsSingleClassAst): +class NamedArgsSingleClassBuilder(NamedArgsSingleClassAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NamedArgsSingleClassProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def key(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key")) + def key(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key")) @property - def key_two(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key_two")) + def key_two(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key_two")) @property - def key_three(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key_three")) + def key_three(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key_three")) @@ -4220,9 +4006,8 @@ def key_three(self) -> type_builder.ClassPropertyViewer: class NestedAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Nested") - self._properties: typing.Set[str] = set([ "prop3", "prop4", "prop20", ]) - self._props = NestedProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Nested") + self._props = NestedProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4232,34 +4017,33 @@ def props(self) -> "NestedProperties": return self._props -class NestedViewer(NestedAst): +class NestedBuilder(NestedAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NestedProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop3")) + def prop3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop3")) @property - def prop4(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop4")) + def prop4(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop4")) @property - def prop20(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop20")) + def prop20(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop20")) @@ -4267,9 +4051,8 @@ def prop20(self) -> type_builder.ClassPropertyViewer: class Nested2Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Nested2") - self._properties: typing.Set[str] = set([ "prop11", "prop12", ]) - self._props = Nested2Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("Nested2") + self._props = Nested2Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4279,30 +4062,29 @@ def props(self) -> "Nested2Properties": return self._props -class Nested2Viewer(Nested2Ast): +class Nested2Builder(Nested2Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class Nested2Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop11(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop11")) + def prop11(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop11")) @property - def prop12(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop12")) + def prop12(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop12")) @@ -4310,9 +4092,8 @@ def prop12(self) -> type_builder.ClassPropertyViewer: class NestedBlockConstraintAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("NestedBlockConstraint") - self._properties: typing.Set[str] = set([ "nbc", ]) - self._props = NestedBlockConstraintProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("NestedBlockConstraint") + self._props = NestedBlockConstraintProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4322,26 +4103,25 @@ def props(self) -> "NestedBlockConstraintProperties": return self._props -class NestedBlockConstraintViewer(NestedBlockConstraintAst): +class NestedBlockConstraintBuilder(NestedBlockConstraintAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NestedBlockConstraintProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def nbc(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("nbc")) + def nbc(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("nbc")) @@ -4349,9 +4129,8 @@ def nbc(self) -> type_builder.ClassPropertyViewer: class NestedBlockConstraintForParamAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("NestedBlockConstraintForParam") - self._properties: typing.Set[str] = set([ "nbcfp", ]) - self._props = NestedBlockConstraintForParamProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("NestedBlockConstraintForParam") + self._props = NestedBlockConstraintForParamProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4361,26 +4140,25 @@ def props(self) -> "NestedBlockConstraintForParamProperties": return self._props -class NestedBlockConstraintForParamViewer(NestedBlockConstraintForParamAst): +class NestedBlockConstraintForParamBuilder(NestedBlockConstraintForParamAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NestedBlockConstraintForParamProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def nbcfp(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("nbcfp")) + def nbcfp(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("nbcfp")) @@ -4388,9 +4166,8 @@ def nbcfp(self) -> type_builder.ClassPropertyViewer: class NodeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Node") - self._properties: typing.Set[str] = set([ "data", "next", ]) - self._props = NodeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Node") + self._props = NodeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4400,30 +4177,29 @@ def props(self) -> "NodeProperties": return self._props -class NodeViewer(NodeAst): +class NodeBuilder(NodeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NodeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def data(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("data")) + def data(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("data")) @property - def next(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("next")) + def next(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("next")) @@ -4431,9 +4207,8 @@ def next(self) -> type_builder.ClassPropertyViewer: class NodeWithAliasIndirectionAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("NodeWithAliasIndirection") - self._properties: typing.Set[str] = set([ "value", "next", ]) - self._props = NodeWithAliasIndirectionProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("NodeWithAliasIndirection") + self._props = NodeWithAliasIndirectionProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4443,30 +4218,29 @@ def props(self) -> "NodeWithAliasIndirectionProperties": return self._props -class NodeWithAliasIndirectionViewer(NodeWithAliasIndirectionAst): +class NodeWithAliasIndirectionBuilder(NodeWithAliasIndirectionAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class NodeWithAliasIndirectionProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @property - def next(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("next")) + def next(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("next")) @@ -4474,9 +4248,8 @@ def next(self) -> type_builder.ClassPropertyViewer: class Note1599Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Note1599") - self._properties: typing.Set[str] = set([ "note_title", "note_description", "note_amount", ]) - self._props = Note1599Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("Note1599") + self._props = Note1599Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4486,34 +4259,33 @@ def props(self) -> "Note1599Properties": return self._props -class Note1599Viewer(Note1599Ast): +class Note1599Builder(Note1599Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class Note1599Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def note_title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("note_title")) + def note_title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("note_title")) @property - def note_description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("note_description")) + def note_description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("note_description")) @property - def note_amount(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("note_amount")) + def note_amount(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("note_amount")) @@ -4521,9 +4293,8 @@ def note_amount(self) -> type_builder.ClassPropertyViewer: class OptionalListAndMapAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OptionalListAndMap") - self._properties: typing.Set[str] = set([ "p", "q", ]) - self._props = OptionalListAndMapProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("OptionalListAndMap") + self._props = OptionalListAndMapProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4533,30 +4304,29 @@ def props(self) -> "OptionalListAndMapProperties": return self._props -class OptionalListAndMapViewer(OptionalListAndMapAst): +class OptionalListAndMapBuilder(OptionalListAndMapAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class OptionalListAndMapProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def p(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("p")) + def p(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("p")) @property - def q(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("q")) + def q(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("q")) @@ -4564,9 +4334,8 @@ def q(self) -> type_builder.ClassPropertyViewer: class OptionalTest_Prop1Ast: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OptionalTest_Prop1") - self._properties: typing.Set[str] = set([ "omega_a", "omega_b", ]) - self._props = OptionalTest_Prop1Properties(self._bldr, self._properties) + self._bldr = _tb.get_class("OptionalTest_Prop1") + self._props = OptionalTest_Prop1Properties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4576,30 +4345,29 @@ def props(self) -> "OptionalTest_Prop1Properties": return self._props -class OptionalTest_Prop1Viewer(OptionalTest_Prop1Ast): +class OptionalTest_Prop1Builder(OptionalTest_Prop1Ast): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class OptionalTest_Prop1Properties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def omega_a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("omega_a")) + def omega_a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("omega_a")) @property - def omega_b(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("omega_b")) + def omega_b(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("omega_b")) @@ -4607,9 +4375,8 @@ def omega_b(self) -> type_builder.ClassPropertyViewer: class OptionalTest_ReturnTypeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OptionalTest_ReturnType") - self._properties: typing.Set[str] = set([ "omega_1", "omega_2", "omega_3", ]) - self._props = OptionalTest_ReturnTypeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("OptionalTest_ReturnType") + self._props = OptionalTest_ReturnTypeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4619,34 +4386,33 @@ def props(self) -> "OptionalTest_ReturnTypeProperties": return self._props -class OptionalTest_ReturnTypeViewer(OptionalTest_ReturnTypeAst): +class OptionalTest_ReturnTypeBuilder(OptionalTest_ReturnTypeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class OptionalTest_ReturnTypeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def omega_1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("omega_1")) + def omega_1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("omega_1")) @property - def omega_2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("omega_2")) + def omega_2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("omega_2")) @property - def omega_3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("omega_3")) + def omega_3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("omega_3")) @@ -4654,9 +4420,8 @@ def omega_3(self) -> type_builder.ClassPropertyViewer: class OrderInfoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OrderInfo") - self._properties: typing.Set[str] = set([ "order_status", "tracking_number", "estimated_arrival_date", ]) - self._props = OrderInfoProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("OrderInfo") + self._props = OrderInfoProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4666,34 +4431,33 @@ def props(self) -> "OrderInfoProperties": return self._props -class OrderInfoViewer(OrderInfoAst): +class OrderInfoBuilder(OrderInfoAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class OrderInfoProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def order_status(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("order_status")) + def order_status(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("order_status")) @property - def tracking_number(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("tracking_number")) + def tracking_number(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("tracking_number")) @property - def estimated_arrival_date(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("estimated_arrival_date")) + def estimated_arrival_date(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("estimated_arrival_date")) @@ -4701,9 +4465,8 @@ def estimated_arrival_date(self) -> type_builder.ClassPropertyViewer: class OriginalAAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OriginalA") - self._properties: typing.Set[str] = set([ "value", ]) - self._props = OriginalAProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("OriginalA") + self._props = OriginalAProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4713,26 +4476,25 @@ def props(self) -> "OriginalAProperties": return self._props -class OriginalAViewer(OriginalAAst): +class OriginalABuilder(OriginalAAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class OriginalAProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @@ -4740,9 +4502,8 @@ def value(self) -> type_builder.ClassPropertyViewer: class OriginalBAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("OriginalB") - self._properties: typing.Set[str] = set([ "value", ]) - self._props = OriginalBProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("OriginalB") + self._props = OriginalBProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4757,12 +4518,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -4775,20 +4534,17 @@ def reset(self) -> None: class OriginalBProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def value(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("value") + def value(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("value") @@ -4796,9 +4552,8 @@ def value(self) -> baml_py.ClassPropertyBuilder: class PersonAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Person") - self._properties: typing.Set[str] = set([ "name", "hair_color", ]) - self._props = PersonProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Person") + self._props = PersonProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4813,12 +4568,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -4831,24 +4584,21 @@ def reset(self) -> None: class PersonProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def name(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("name") + def name(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("name") @property - def hair_color(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("hair_color") + def hair_color(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("hair_color") @@ -4856,9 +4606,8 @@ def hair_color(self) -> baml_py.ClassPropertyBuilder: class PhoneNumberAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("PhoneNumber") - self._properties: typing.Set[str] = set([ "value", ]) - self._props = PhoneNumberProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("PhoneNumber") + self._props = PhoneNumberProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4868,26 +4617,25 @@ def props(self) -> "PhoneNumberProperties": return self._props -class PhoneNumberViewer(PhoneNumberAst): +class PhoneNumberBuilder(PhoneNumberAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class PhoneNumberProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @@ -4895,9 +4643,8 @@ def value(self) -> type_builder.ClassPropertyViewer: class QuantityAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Quantity") - self._properties: typing.Set[str] = set([ "amount", "unit", ]) - self._props = QuantityProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Quantity") + self._props = QuantityProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4907,30 +4654,29 @@ def props(self) -> "QuantityProperties": return self._props -class QuantityViewer(QuantityAst): +class QuantityBuilder(QuantityAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class QuantityProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def amount(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("amount")) + def amount(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("amount")) @property - def unit(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("unit")) + def unit(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("unit")) @@ -4938,9 +4684,8 @@ def unit(self) -> type_builder.ClassPropertyViewer: class RaysDataAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("RaysData") - self._properties: typing.Set[str] = set([ "dataType", "value", ]) - self._props = RaysDataProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("RaysData") + self._props = RaysDataProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4950,30 +4695,29 @@ def props(self) -> "RaysDataProperties": return self._props -class RaysDataViewer(RaysDataAst): +class RaysDataBuilder(RaysDataAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class RaysDataProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def dataType(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("dataType")) + def dataType(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("dataType")) @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @@ -4981,9 +4725,8 @@ def value(self) -> type_builder.ClassPropertyViewer: class ReceiptInfoAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ReceiptInfo") - self._properties: typing.Set[str] = set([ "items", "total_cost", "venue", ]) - self._props = ReceiptInfoProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ReceiptInfo") + self._props = ReceiptInfoProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -4993,34 +4736,33 @@ def props(self) -> "ReceiptInfoProperties": return self._props -class ReceiptInfoViewer(ReceiptInfoAst): +class ReceiptInfoBuilder(ReceiptInfoAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ReceiptInfoProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def items(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("items")) + def items(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("items")) @property - def total_cost(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("total_cost")) + def total_cost(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("total_cost")) @property - def venue(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("venue")) + def venue(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("venue")) @@ -5028,9 +4770,8 @@ def venue(self) -> type_builder.ClassPropertyViewer: class ReceiptItemAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("ReceiptItem") - self._properties: typing.Set[str] = set([ "name", "description", "quantity", "price", ]) - self._props = ReceiptItemProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("ReceiptItem") + self._props = ReceiptItemProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5040,38 +4781,37 @@ def props(self) -> "ReceiptItemProperties": return self._props -class ReceiptItemViewer(ReceiptItemAst): +class ReceiptItemBuilder(ReceiptItemAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ReceiptItemProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def name(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("name")) + def name(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("name")) @property - def description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("description")) + def description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("description")) @property - def quantity(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("quantity")) + def quantity(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("quantity")) @property - def price(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("price")) + def price(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("price")) @@ -5079,9 +4819,8 @@ def price(self) -> type_builder.ClassPropertyViewer: class RecipeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Recipe") - self._properties: typing.Set[str] = set([ "ingredients", "recipe_type", ]) - self._props = RecipeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Recipe") + self._props = RecipeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5091,30 +4830,29 @@ def props(self) -> "RecipeProperties": return self._props -class RecipeViewer(RecipeAst): +class RecipeBuilder(RecipeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class RecipeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def ingredients(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("ingredients")) + def ingredients(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("ingredients")) @property - def recipe_type(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("recipe_type")) + def recipe_type(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("recipe_type")) @@ -5122,9 +4860,8 @@ def recipe_type(self) -> type_builder.ClassPropertyViewer: class RecursiveAliasDependencyAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("RecursiveAliasDependency") - self._properties: typing.Set[str] = set([ "value", ]) - self._props = RecursiveAliasDependencyProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("RecursiveAliasDependency") + self._props = RecursiveAliasDependencyProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5134,26 +4871,25 @@ def props(self) -> "RecursiveAliasDependencyProperties": return self._props -class RecursiveAliasDependencyViewer(RecursiveAliasDependencyAst): +class RecursiveAliasDependencyBuilder(RecursiveAliasDependencyAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class RecursiveAliasDependencyProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @@ -5161,9 +4897,8 @@ def value(self) -> type_builder.ClassPropertyViewer: class RenderEnumInputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("RenderEnumInput") - self._properties: typing.Set[str] = set([ "testKey", ]) - self._props = RenderEnumInputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("RenderEnumInput") + self._props = RenderEnumInputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5178,12 +4913,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -5196,20 +4929,17 @@ def reset(self) -> None: class RenderEnumInputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def testKey(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("testKey") + def testKey(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("testKey") @@ -5217,9 +4947,8 @@ def testKey(self) -> baml_py.ClassPropertyBuilder: class RenderTestClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("RenderTestClass") - self._properties: typing.Set[str] = set([ "name", "status", ]) - self._props = RenderTestClassProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("RenderTestClass") + self._props = RenderTestClassProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5234,12 +4963,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -5252,24 +4979,21 @@ def reset(self) -> None: class RenderTestClassProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def name(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("name") + def name(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("name") @property - def status(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("status") + def status(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("status") @@ -5277,9 +5001,8 @@ def status(self) -> baml_py.ClassPropertyBuilder: class ResumeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Resume") - self._properties: typing.Set[str] = set([ "name", "email", "phone", "experience", "education", "skills", ]) - self._props = ResumeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Resume") + self._props = ResumeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5289,46 +5012,45 @@ def props(self) -> "ResumeProperties": return self._props -class ResumeViewer(ResumeAst): +class ResumeBuilder(ResumeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class ResumeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def name(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("name")) + def name(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("name")) @property - def email(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("email")) + def email(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("email")) @property - def phone(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("phone")) + def phone(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("phone")) @property - def experience(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("experience")) + def experience(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("experience")) @property - def education(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("education")) + def education(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("education")) @property - def skills(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("skills")) + def skills(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("skills")) @@ -5336,9 +5058,8 @@ def skills(self) -> type_builder.ClassPropertyViewer: class SchemaAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Schema") - self._properties: typing.Set[str] = set([ "prop1", "prop2", "prop5", "prop6", "nested_attrs", "parens", "other_group", ]) - self._props = SchemaProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Schema") + self._props = SchemaProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5348,50 +5069,49 @@ def props(self) -> "SchemaProperties": return self._props -class SchemaViewer(SchemaAst): +class SchemaBuilder(SchemaAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class SchemaProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @property - def prop5(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop5")) + def prop5(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop5")) @property - def prop6(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop6")) + def prop6(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop6")) @property - def nested_attrs(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("nested_attrs")) + def nested_attrs(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("nested_attrs")) @property - def parens(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("parens")) + def parens(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("parens")) @property - def other_group(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("other_group")) + def other_group(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("other_group")) @@ -5399,9 +5119,8 @@ def other_group(self) -> type_builder.ClassPropertyViewer: class SearchParamsAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("SearchParams") - self._properties: typing.Set[str] = set([ "dateRange", "location", "jobTitle", "company", "description", "tags", ]) - self._props = SearchParamsProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("SearchParams") + self._props = SearchParamsProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5411,46 +5130,45 @@ def props(self) -> "SearchParamsProperties": return self._props -class SearchParamsViewer(SearchParamsAst): +class SearchParamsBuilder(SearchParamsAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class SearchParamsProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def dateRange(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("dateRange")) + def dateRange(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("dateRange")) @property - def location(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("location")) + def location(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("location")) @property - def jobTitle(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("jobTitle")) + def jobTitle(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("jobTitle")) @property - def company(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("company")) + def company(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("company")) @property - def description(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("description")) + def description(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("description")) @property - def tags(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("tags")) + def tags(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("tags")) @@ -5458,9 +5176,8 @@ def tags(self) -> type_builder.ClassPropertyViewer: class SemanticContainerAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("SemanticContainer") - self._properties: typing.Set[str] = set([ "sixteen_digit_number", "string_with_twenty_words", "class_1", "class_2", "class_done_needed", "class_needed", "three_small_things", "final_string", ]) - self._props = SemanticContainerProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("SemanticContainer") + self._props = SemanticContainerProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5470,54 +5187,53 @@ def props(self) -> "SemanticContainerProperties": return self._props -class SemanticContainerViewer(SemanticContainerAst): +class SemanticContainerBuilder(SemanticContainerAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class SemanticContainerProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def sixteen_digit_number(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("sixteen_digit_number")) + def sixteen_digit_number(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("sixteen_digit_number")) @property - def string_with_twenty_words(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("string_with_twenty_words")) + def string_with_twenty_words(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("string_with_twenty_words")) @property - def class_1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("class_1")) + def class_1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("class_1")) @property - def class_2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("class_2")) + def class_2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("class_2")) @property - def class_done_needed(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("class_done_needed")) + def class_done_needed(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("class_done_needed")) @property - def class_needed(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("class_needed")) + def class_needed(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("class_needed")) @property - def three_small_things(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("three_small_things")) + def three_small_things(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("three_small_things")) @property - def final_string(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("final_string")) + def final_string(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("final_string")) @@ -5525,9 +5241,8 @@ def final_string(self) -> type_builder.ClassPropertyViewer: class SimpleTagAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("SimpleTag") - self._properties: typing.Set[str] = set([ "field", ]) - self._props = SimpleTagProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("SimpleTag") + self._props = SimpleTagProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5537,26 +5252,25 @@ def props(self) -> "SimpleTagProperties": return self._props -class SimpleTagViewer(SimpleTagAst): +class SimpleTagBuilder(SimpleTagAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class SimpleTagProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def field(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("field")) + def field(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("field")) @@ -5564,9 +5278,8 @@ def field(self) -> type_builder.ClassPropertyViewer: class SmallThingAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("SmallThing") - self._properties: typing.Set[str] = set([ "i_16_digits", "i_8_digits", ]) - self._props = SmallThingProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("SmallThing") + self._props = SmallThingProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5576,30 +5289,29 @@ def props(self) -> "SmallThingProperties": return self._props -class SmallThingViewer(SmallThingAst): +class SmallThingBuilder(SmallThingAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class SmallThingProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def i_16_digits(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("i_16_digits")) + def i_16_digits(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("i_16_digits")) @property - def i_8_digits(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("i_8_digits")) + def i_8_digits(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("i_8_digits")) @@ -5607,9 +5319,8 @@ def i_8_digits(self) -> type_builder.ClassPropertyViewer: class SomeClassNestedDynamicAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("SomeClassNestedDynamic") - self._properties: typing.Set[str] = set([ "hi", ]) - self._props = SomeClassNestedDynamicProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("SomeClassNestedDynamic") + self._props = SomeClassNestedDynamicProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5624,12 +5335,10 @@ def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def add_property(self, name: str, type: baml_py.FieldType) -> baml_py.ClassPropertyBuilder: - if name in self._properties: - raise ValueError(f"Property {name} already exists.") - return self._bldr.property(name).type(type) + def add_property(self, name: str, type: baml_py.FieldType) -> type_builder.ClassPropertyBuilder: + return self._bldr.add_property(name, type) - def list_properties(self) -> typing.List[typing.Tuple[str, baml_py.ClassPropertyBuilder]]: + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: return self._bldr.list_properties() def remove_property(self, name: str) -> None: @@ -5642,20 +5351,17 @@ def reset(self) -> None: class SomeClassNestedDynamicProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 - def __getattr__(self, name: str) -> baml_py.ClassPropertyBuilder: - if name not in self.__properties: - raise AttributeError(f"Property {name} not found.") - return self.__bldr.property(name) + def __getattr__(self, name: str) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property(name) @property - def hi(self) -> baml_py.ClassPropertyBuilder: - return self.__bldr.property("hi") + def hi(self) -> type_builder.ClassPropertyBuilder: + return self.__bldr.get_property("hi") @@ -5663,9 +5369,8 @@ def hi(self) -> baml_py.ClassPropertyBuilder: class StringToClassEntryAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("StringToClassEntry") - self._properties: typing.Set[str] = set([ "word", ]) - self._props = StringToClassEntryProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("StringToClassEntry") + self._props = StringToClassEntryProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5675,26 +5380,25 @@ def props(self) -> "StringToClassEntryProperties": return self._props -class StringToClassEntryViewer(StringToClassEntryAst): +class StringToClassEntryBuilder(StringToClassEntryAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class StringToClassEntryProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def word(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("word")) + def word(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("word")) @@ -5702,9 +5406,8 @@ def word(self) -> type_builder.ClassPropertyViewer: class TestClassAliasAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TestClassAlias") - self._properties: typing.Set[str] = set([ "key", "key2", "key3", "key4", "key5", ]) - self._props = TestClassAliasProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TestClassAlias") + self._props = TestClassAliasProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5714,42 +5417,41 @@ def props(self) -> "TestClassAliasProperties": return self._props -class TestClassAliasViewer(TestClassAliasAst): +class TestClassAliasBuilder(TestClassAliasAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TestClassAliasProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def key(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key")) + def key(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key")) @property - def key2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key2")) + def key2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key2")) @property - def key3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key3")) + def key3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key3")) @property - def key4(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key4")) + def key4(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key4")) @property - def key5(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("key5")) + def key5(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("key5")) @@ -5757,9 +5459,8 @@ def key5(self) -> type_builder.ClassPropertyViewer: class TestClassNestedAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TestClassNested") - self._properties: typing.Set[str] = set([ "prop1", "prop2", ]) - self._props = TestClassNestedProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TestClassNested") + self._props = TestClassNestedProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5769,30 +5470,29 @@ def props(self) -> "TestClassNestedProperties": return self._props -class TestClassNestedViewer(TestClassNestedAst): +class TestClassNestedBuilder(TestClassNestedAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TestClassNestedProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @@ -5800,9 +5500,8 @@ def prop2(self) -> type_builder.ClassPropertyViewer: class TestClassWithEnumAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TestClassWithEnum") - self._properties: typing.Set[str] = set([ "prop1", "prop2", ]) - self._props = TestClassWithEnumProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TestClassWithEnum") + self._props = TestClassWithEnumProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5812,30 +5511,29 @@ def props(self) -> "TestClassWithEnumProperties": return self._props -class TestClassWithEnumViewer(TestClassWithEnumAst): +class TestClassWithEnumBuilder(TestClassWithEnumAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TestClassWithEnumProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @@ -5843,9 +5541,8 @@ def prop2(self) -> type_builder.ClassPropertyViewer: class TestMemoryOutputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TestMemoryOutput") - self._properties: typing.Set[str] = set([ "items", "more_items", ]) - self._props = TestMemoryOutputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TestMemoryOutput") + self._props = TestMemoryOutputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5855,30 +5552,29 @@ def props(self) -> "TestMemoryOutputProperties": return self._props -class TestMemoryOutputViewer(TestMemoryOutputAst): +class TestMemoryOutputBuilder(TestMemoryOutputAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TestMemoryOutputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def items(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("items")) + def items(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("items")) @property - def more_items(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("more_items")) + def more_items(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("more_items")) @@ -5886,9 +5582,8 @@ def more_items(self) -> type_builder.ClassPropertyViewer: class TestOutputClassAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TestOutputClass") - self._properties: typing.Set[str] = set([ "prop1", "prop2", ]) - self._props = TestOutputClassProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TestOutputClass") + self._props = TestOutputClassProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5898,30 +5593,29 @@ def props(self) -> "TestOutputClassProperties": return self._props -class TestOutputClassViewer(TestOutputClassAst): +class TestOutputClassBuilder(TestOutputClassAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TestOutputClassProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @@ -5929,9 +5623,8 @@ def prop2(self) -> type_builder.ClassPropertyViewer: class TreeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("Tree") - self._properties: typing.Set[str] = set([ "data", "children", ]) - self._props = TreeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("Tree") + self._props = TreeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5941,30 +5634,29 @@ def props(self) -> "TreeProperties": return self._props -class TreeViewer(TreeAst): +class TreeBuilder(TreeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TreeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def data(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("data")) + def data(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("data")) @property - def children(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("children")) + def children(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("children")) @@ -5972,9 +5664,8 @@ def children(self) -> type_builder.ClassPropertyViewer: class TwoStoriesOneTitleAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TwoStoriesOneTitle") - self._properties: typing.Set[str] = set([ "title", "story_a", "story_b", ]) - self._props = TwoStoriesOneTitleProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TwoStoriesOneTitle") + self._props = TwoStoriesOneTitleProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -5984,34 +5675,33 @@ def props(self) -> "TwoStoriesOneTitleProperties": return self._props -class TwoStoriesOneTitleViewer(TwoStoriesOneTitleAst): +class TwoStoriesOneTitleBuilder(TwoStoriesOneTitleAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TwoStoriesOneTitleProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("title")) + def title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("title")) @property - def story_a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("story_a")) + def story_a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("story_a")) @property - def story_b(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("story_b")) + def story_b(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("story_b")) @@ -6019,9 +5709,8 @@ def story_b(self) -> type_builder.ClassPropertyViewer: class TwoStoriesOneTitleCheckAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("TwoStoriesOneTitleCheck") - self._properties: typing.Set[str] = set([ "title", "story_a", "story_b", ]) - self._props = TwoStoriesOneTitleCheckProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("TwoStoriesOneTitleCheck") + self._props = TwoStoriesOneTitleCheckProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -6031,34 +5720,33 @@ def props(self) -> "TwoStoriesOneTitleCheckProperties": return self._props -class TwoStoriesOneTitleCheckViewer(TwoStoriesOneTitleCheckAst): +class TwoStoriesOneTitleCheckBuilder(TwoStoriesOneTitleCheckAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class TwoStoriesOneTitleCheckProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def title(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("title")) + def title(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("title")) @property - def story_a(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("story_a")) + def story_a(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("story_a")) @property - def story_b(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("story_b")) + def story_b(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("story_b")) @@ -6066,9 +5754,8 @@ def story_b(self) -> type_builder.ClassPropertyViewer: class UnionTest_ReturnTypeAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("UnionTest_ReturnType") - self._properties: typing.Set[str] = set([ "prop1", "prop2", "prop3", ]) - self._props = UnionTest_ReturnTypeProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("UnionTest_ReturnType") + self._props = UnionTest_ReturnTypeProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -6078,34 +5765,33 @@ def props(self) -> "UnionTest_ReturnTypeProperties": return self._props -class UnionTest_ReturnTypeViewer(UnionTest_ReturnTypeAst): +class UnionTest_ReturnTypeBuilder(UnionTest_ReturnTypeAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class UnionTest_ReturnTypeProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def prop1(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop1")) + def prop1(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop1")) @property - def prop2(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop2")) + def prop2(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop2")) @property - def prop3(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("prop3")) + def prop3(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("prop3")) @@ -6113,9 +5799,8 @@ def prop3(self) -> type_builder.ClassPropertyViewer: class UniverseQuestionAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("UniverseQuestion") - self._properties: typing.Set[str] = set([ "question", "answer", ]) - self._props = UniverseQuestionProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("UniverseQuestion") + self._props = UniverseQuestionProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -6125,30 +5810,29 @@ def props(self) -> "UniverseQuestionProperties": return self._props -class UniverseQuestionViewer(UniverseQuestionAst): +class UniverseQuestionBuilder(UniverseQuestionAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class UniverseQuestionProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def question(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("question")) + def question(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("question")) @property - def answer(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("answer")) + def answer(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("answer")) @@ -6156,9 +5840,8 @@ def answer(self) -> type_builder.ClassPropertyViewer: class UniverseQuestionInputAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("UniverseQuestionInput") - self._properties: typing.Set[str] = set([ "question", ]) - self._props = UniverseQuestionInputProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("UniverseQuestionInput") + self._props = UniverseQuestionInputProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -6168,26 +5851,25 @@ def props(self) -> "UniverseQuestionInputProperties": return self._props -class UniverseQuestionInputViewer(UniverseQuestionInputAst): +class UniverseQuestionInputBuilder(UniverseQuestionInputAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class UniverseQuestionInputProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def question(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("question")) + def question(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("question")) @@ -6195,9 +5877,8 @@ def question(self) -> type_builder.ClassPropertyViewer: class WithReasoningAst: def __init__(self, tb: type_builder.TypeBuilder): _tb = tb._tb # type: ignore (we know how to use this private attribute) - self._bldr = _tb.class_("WithReasoning") - self._properties: typing.Set[str] = set([ "value", "reasoning", ]) - self._props = WithReasoningProperties(self._bldr, self._properties) + self._bldr = _tb.get_class("WithReasoning") + self._props = WithReasoningProperties(self._bldr) def type(self) -> baml_py.FieldType: return self._bldr.field() @@ -6207,30 +5888,29 @@ def props(self) -> "WithReasoningProperties": return self._props -class WithReasoningViewer(WithReasoningAst): +class WithReasoningBuilder(WithReasoningAst): def __init__(self, tb: type_builder.TypeBuilder): super().__init__(tb) - def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyViewer]]: - return [(name, type_builder.ClassPropertyViewer(self._bldr.property(name))) for name in self._properties] + def list_properties(self) -> typing.List[typing.Tuple[str, type_builder.ClassPropertyBuilder]]: + return [(name, type_builder.ClassPropertyBuilder(self._bldr.property(name))) for name in self._properties] class WithReasoningProperties: - def __init__(self, bldr: baml_py.ClassBuilder, properties: typing.Set[str]): + def __init__(self, bldr: baml_py.ClassBuilder): self.__bldr = bldr - self.__properties = properties # type: ignore (we know how to use this private attribute) # noqa: F821 @property - def value(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("value")) + def value(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("value")) @property - def reasoning(self) -> type_builder.ClassPropertyViewer: - return type_builder.ClassPropertyViewer(self.__bldr.property("reasoning")) + def reasoning(self) -> type_builder.ClassPropertyBuilder: + return type_builder.ClassPropertyBuilder(self.__bldr.get_property("reasoning")) diff --git a/integ-tests/python/tests/test_typebuilder.py b/integ-tests/python/tests/test_typebuilder.py index c69b0a2ced..9f8a693c4a 100644 --- a/integ-tests/python/tests/test_typebuilder.py +++ b/integ-tests/python/tests/test_typebuilder.py @@ -18,15 +18,15 @@ async def test_dynamic(): tb = TypeBuilder() tb.Person.add_property("last_name", tb.string().list()) - tb.Person.add_property("height", tb.float().optional()).description( + tb.Person.add_property("height", tb.float().optional()).set_description( "Height in meters" ) tb.Hobby.add_value("chess") for name, val in tb.Hobby.list_values(): - val.alias(name.lower()) + val.set_alias(name.lower()) - tb.Person.add_property("hobbies", tb.Hobby.type().list()).description( + tb.Person.add_property("hobbies", tb.Hobby.type().list()).set_description( "Some suggested hobbies they might be good at" ) @@ -94,7 +94,7 @@ async def test_dynamic_class_nested_output_no_stream(): # name should be first in the prompt schema tb.DynamicOutput.add_property("name", nested_class.type().optional()) tb.DynamicOutput.add_property("address", other_nested_class.type().optional()) - tb.DynamicOutput.add_property("hair_color", tb.string()).alias("hairColor") + tb.DynamicOutput.add_property("hair_color", tb.string()).set_alias("hairColor") tb.DynamicOutput.add_property("height", tb.float().optional()) output = await b.MyFunc( @@ -298,7 +298,7 @@ async def test_dynamic_output_map(): tb.DynamicOutput.add_property("hair_color", tb.string()) tb.DynamicOutput.add_property( "attributes", tb.map(tb.string(), tb.string()) - ).description("Things like 'eye_color' or 'facial_hair'") + ).set_description("Things like 'eye_color' or 'facial_hair'") print(tb.DynamicOutput.list_properties()) for prop, _ in tb.DynamicOutput.list_properties(): print(f"Property: {prop}") @@ -322,7 +322,7 @@ async def test_dynamic_output_union(): tb.DynamicOutput.add_property("hair_color", tb.string()) tb.DynamicOutput.add_property( "attributes", tb.map(tb.string(), tb.string()) - ).description("Things like 'eye_color' or 'facial_hair'") + ).set_description("Things like 'eye_color' or 'facial_hair'") # Define two classes class1 = tb.add_class("Class1") class1.add_property("meters", tb.float()) @@ -378,7 +378,7 @@ async def test_add_baml_existing_class(): tb.add_baml( """ class ExtraPersonInfo { - height int + height int @description("feet") weight int } @@ -526,7 +526,6 @@ async def test_referencing_existing_class_types(): tb.Person.add_property("props", tb.union([tb.Resume.type(), tb.Hobby.type()])) - def test_typebuilder_and_fieldtype_imports(): """Test that both TypeBuilder and FieldType can be imported from baml_client.type_builder""" # Test importing both from the same module @@ -548,20 +547,25 @@ def test_typebuilder_and_fieldtype_imports(): def test_type_builder_list_properties(): tb = TypeBuilder() tb.Person.add_property("last_name", tb.string().list()) - tb.Person.add_property("height", tb.float().optional()).description("Height in meters") - - props = {name: builder.get_type() for name, builder in tb.Person.list_properties()} + tb.Person.add_property("height", tb.float().optional()).set_description( + "Height in meters" + ) - assert props == { - "last_name": tb.string().list(), - "height": tb.float().optional() + props = { + name: builder.type() + for name, builder in tb.Person.list_properties() + if builder.source == "dynamic" } + assert props == {"last_name": tb.string().list(), "height": tb.float().optional()} + def test_type_builder_reset(): tb = TypeBuilder() tb.Person.add_property("last_name", tb.string().list()) - tb.Person.add_property("height", tb.float().optional()).description("Height in meters") + tb.Person.add_property("height", tb.float().optional()).set_description( + "Height in meters" + ) tb.reset() person_props_after_tb_reset = {name for name, _ in tb.Person.list_properties()} @@ -573,15 +577,21 @@ def test_type_builder_reset(): def test_type_builder_class_reset(): tb = TypeBuilder() tb.Person.add_property("last_name", tb.string().list()) - tb.Person.add_property("height", tb.float().optional()).description("Height in meters") + tb.Person.add_property("height", tb.float().optional()).set_description( + "Height in meters" + ) tb.DynamicOutput.add_property("hair_color", tb.string()) - tb.DynamicOutput.add_property("height", tb.float().optional()).description("Height in meters") + tb.DynamicOutput.add_property("height", tb.float().optional()).set_description( + "Height in meters" + ) tb.Person.reset() person_props_after_class_reset = {name for name, _ in tb.Person.list_properties()} - dynamic_output_props_after_class_reset = {name for name, _ in tb.DynamicOutput.list_properties()} + dynamic_output_props_after_class_reset = { + name for name, _ in tb.DynamicOutput.list_properties() + } assert "last_name" not in person_props_after_class_reset assert "height" not in person_props_after_class_reset @@ -593,11 +603,15 @@ def test_type_builder_class_reset(): def test_type_builder_class_remove_property(): tb = TypeBuilder() tb.Person.add_property("last_name", tb.string().list()) - tb.Person.add_property("height", tb.float().optional()).description("Height in meters") + tb.Person.add_property("height", tb.float().optional()).set_description( + "Height in meters" + ) tb.Person.remove_property("last_name") - person_props_after_class_remove_property = {name for name, _ in tb.Person.list_properties()} + person_props_after_class_remove_property = { + name for name, _ in tb.Person.list_properties() + } assert "last_name" not in person_props_after_class_remove_property assert "height" in person_props_after_class_remove_property @@ -607,11 +621,15 @@ def test_type_builder_add_class_reset(): tb = TypeBuilder() person_class = tb.add_class("AddedPerson") person_class.add_property("last_name", tb.string().list()) - person_class.add_property("height", tb.float().optional()).description("Height in meters") + person_class.add_property("height", tb.float().optional()).set_description( + "Height in meters" + ) person_class.reset() - person_props_after_class_reset = {name for name, _ in person_class.list_properties()} + person_props_after_class_reset = { + name for name, _ in person_class.list_properties() + } assert "last_name" not in person_props_after_class_reset assert "height" not in person_props_after_class_reset @@ -621,11 +639,15 @@ def test_type_builder_add_class_remove_property(): tb = TypeBuilder() person_class = tb.add_class("AddedPerson") person_class.add_property("last_name", tb.string().list()) - person_class.add_property("height", tb.float().optional()).description("Height in meters") + person_class.add_property("height", tb.float().optional()).set_description( + "Height in meters" + ) person_class.remove_property("last_name") - person_props_after_class_remove_property = {name for name, _ in person_class.list_properties()} + person_props_after_class_remove_property = { + name for name, _ in person_class.list_properties() + } assert "last_name" not in person_props_after_class_remove_property assert "height" in person_props_after_class_remove_property @@ -634,27 +656,31 @@ def test_type_builder_add_class_remove_property(): def test_class_prop_get_type(): tb = TypeBuilder() tb.Person.add_property("last_name", tb.string().list()) - tb.Person.add_property("height", tb.float().optional()).description("Height in meters") + tb.Person.add_property("height", tb.float().optional()).set_description( + "Height in meters" + ) props = {name: prop_type for name, prop_type in tb.Person.list_properties()} - assert props["last_name"].get_type() == tb.string().list() - assert props["height"].get_type() == tb.float().optional() + assert props["last_name"].type() == tb.string().list() + assert props["height"].type() == tb.float().optional() def test_class_prop_set_type(): tb = TypeBuilder() tb.Person.add_property("last_name", tb.string().list()) - tb.Person.add_property("height", tb.float().optional()).description("Height in meters") + tb.Person.add_property("height", tb.float().optional()).set_description( + "Height in meters" + ) # Modify props. props = {name: prop_type for name, prop_type in tb.Person.list_properties()} - props["last_name"].type(tb.string()) - props["height"].type(tb.int()) + props["last_name"].set_type(tb.string()) + props["height"].set_type(tb.int()) # Verify changes. props = {name: prop_type for name, prop_type in tb.Person.list_properties()} - assert props["last_name"].get_type() == tb.string() - assert props["height"].get_type() == tb.int() + assert props["last_name"].type() == tb.string() + assert props["height"].type() == tb.int() diff --git a/integ-tests/python/uv.lock b/integ-tests/python/uv.lock index c371b6d6e1..95d92ac091 100644 --- a/integ-tests/python/uv.lock +++ b/integ-tests/python/uv.lock @@ -1,5 +1,4 @@ version = 1 -revision = 2 requires-python = ">=3.9, <4" resolution-markers = [ "python_full_version < '3.10'", @@ -10,9 +9,9 @@ resolution-markers = [ name = "annotated-types" version = "0.7.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload_time = "2024-05-20T21:33:25.928Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 } wheels = [ - { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload_time = "2024-05-20T21:33:24.1Z" }, + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 }, ] [[package]] @@ -28,9 +27,9 @@ dependencies = [ { name = "sniffio" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/86/e3/a88c8494ce4d1a88252b9e053607e885f9b14d0a32273d47b727cbee4228/anthropic-0.49.0.tar.gz", hash = "sha256:c09e885b0f674b9119b4f296d8508907f6cff0009bc20d5cf6b35936c40b4398", size = 210016, upload_time = "2025-02-28T19:35:47.01Z" } +sdist = { url = "https://files.pythonhosted.org/packages/86/e3/a88c8494ce4d1a88252b9e053607e885f9b14d0a32273d47b727cbee4228/anthropic-0.49.0.tar.gz", hash = "sha256:c09e885b0f674b9119b4f296d8508907f6cff0009bc20d5cf6b35936c40b4398", size = 210016 } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/74/5d90ad14d55fbe3f9c474fdcb6e34b4bed99e3be8efac98734a5ddce88c1/anthropic-0.49.0-py3-none-any.whl", hash = "sha256:bbc17ad4e7094988d2fa86b87753ded8dce12498f4b85fe5810f208f454a8375", size = 243368, upload_time = "2025-02-28T19:35:44.963Z" }, + { url = "https://files.pythonhosted.org/packages/76/74/5d90ad14d55fbe3f9c474fdcb6e34b4bed99e3be8efac98734a5ddce88c1/anthropic-0.49.0-py3-none-any.whl", hash = "sha256:bbc17ad4e7094988d2fa86b87753ded8dce12498f4b85fe5810f208f454a8375", size = 243368 }, ] [[package]] @@ -43,24 +42,24 @@ dependencies = [ { name = "sniffio" }, { name = "typing-extensions", marker = "python_full_version < '3.13'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload_time = "2025-03-17T00:02:54.77Z" } +sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949 } wheels = [ - { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload_time = "2025-03-17T00:02:52.713Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916 }, ] [[package]] name = "assertpy" version = "1.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4f/39/720b5d4463612a40a166d00999cbb715fce3edaf08a9a7588ba5985699ec/assertpy-1.1.tar.gz", hash = "sha256:acc64329934ad71a3221de185517a43af33e373bb44dc05b5a9b174394ef4833", size = 25421, upload_time = "2020-07-19T14:39:02.462Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4f/39/720b5d4463612a40a166d00999cbb715fce3edaf08a9a7588ba5985699ec/assertpy-1.1.tar.gz", hash = "sha256:acc64329934ad71a3221de185517a43af33e373bb44dc05b5a9b174394ef4833", size = 25421 } [[package]] name = "blinker" version = "1.8.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1e/57/a6a1721eff09598fb01f3c7cda070c1b6a0f12d63c83236edf79a440abcc/blinker-1.8.2.tar.gz", hash = "sha256:8f77b09d3bf7c795e969e9486f39c2c5e9c39d4ee07424be2bc594ece9642d83", size = 23161, upload_time = "2024-05-06T17:04:10.101Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1e/57/a6a1721eff09598fb01f3c7cda070c1b6a0f12d63c83236edf79a440abcc/blinker-1.8.2.tar.gz", hash = "sha256:8f77b09d3bf7c795e969e9486f39c2c5e9c39d4ee07424be2bc594ece9642d83", size = 23161 } wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/2a/10164ed1f31196a2f7f3799368a821765c62851ead0e630ab52b8e14b4d0/blinker-1.8.2-py3-none-any.whl", hash = "sha256:1779309f71bf239144b9399d06ae925637cf6634cf6bd131104184531bf67c01", size = 9456, upload_time = "2024-05-06T17:04:08.444Z" }, + { url = "https://files.pythonhosted.org/packages/bb/2a/10164ed1f31196a2f7f3799368a821765c62851ead0e630ab52b8e14b4d0/blinker-1.8.2-py3-none-any.whl", hash = "sha256:1779309f71bf239144b9399d06ae925637cf6634cf6bd131104184531bf67c01", size = 9456 }, ] [[package]] @@ -72,9 +71,9 @@ dependencies = [ { name = "jmespath" }, { name = "s3transfer" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/82/8c/2ca661db6c9e591d9dc46149b43a91385283c852436ccba62e199643e196/boto3-1.37.37.tar.gz", hash = "sha256:752d31105a45e3e01c8c68471db14ae439990b75a35e72b591ca528e2575b28f", size = 111666, upload_time = "2025-04-18T19:21:46.741Z" } +sdist = { url = "https://files.pythonhosted.org/packages/82/8c/2ca661db6c9e591d9dc46149b43a91385283c852436ccba62e199643e196/boto3-1.37.37.tar.gz", hash = "sha256:752d31105a45e3e01c8c68471db14ae439990b75a35e72b591ca528e2575b28f", size = 111666 } wheels = [ - { url = "https://files.pythonhosted.org/packages/e4/5f/032d93e74949222ffbfbc3270f29a3ee423fe648de8a31c49cce0cbb0a09/boto3-1.37.37-py3-none-any.whl", hash = "sha256:d125cb11e22817f7a2581bade4bf7b75247b401888890239ceb5d3e902ccaf38", size = 139917, upload_time = "2025-04-18T19:21:43.769Z" }, + { url = "https://files.pythonhosted.org/packages/e4/5f/032d93e74949222ffbfbc3270f29a3ee423fe648de8a31c49cce0cbb0a09/boto3-1.37.37-py3-none-any.whl", hash = "sha256:d125cb11e22817f7a2581bade4bf7b75247b401888890239ceb5d3e902ccaf38", size = 139917 }, ] [[package]] @@ -87,111 +86,111 @@ dependencies = [ { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, { name = "urllib3", version = "2.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/96/d0/70969515e3ae8ff0fcccf22827d5d131bc7b8729331127415cf8f2861d63/botocore-1.37.37.tar.gz", hash = "sha256:3eadde6fed95c4cb469cc39d1c3558528b7fa76d23e7e16d4bddc77250431a64", size = 13828530, upload_time = "2025-04-18T19:21:32.145Z" } +sdist = { url = "https://files.pythonhosted.org/packages/96/d0/70969515e3ae8ff0fcccf22827d5d131bc7b8729331127415cf8f2861d63/botocore-1.37.37.tar.gz", hash = "sha256:3eadde6fed95c4cb469cc39d1c3558528b7fa76d23e7e16d4bddc77250431a64", size = 13828530 } wheels = [ - { url = "https://files.pythonhosted.org/packages/fe/17/602915b29cb695e1e66f65e33b1026f1534e49975d99ea4e32e58d963542/botocore-1.37.37-py3-none-any.whl", hash = "sha256:eb730ff978f47c02f0c8ed07bccdc0db6d8fa098ed32ac31bee1da0e9be480d1", size = 13495584, upload_time = "2025-04-18T19:21:26.45Z" }, + { url = "https://files.pythonhosted.org/packages/fe/17/602915b29cb695e1e66f65e33b1026f1534e49975d99ea4e32e58d963542/botocore-1.37.37-py3-none-any.whl", hash = "sha256:eb730ff978f47c02f0c8ed07bccdc0db6d8fa098ed32ac31bee1da0e9be480d1", size = 13495584 }, ] [[package]] name = "cachetools" version = "5.5.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6c/81/3747dad6b14fa2cf53fcf10548cf5aea6913e96fab41a3c198676f8948a5/cachetools-5.5.2.tar.gz", hash = "sha256:1a661caa9175d26759571b2e19580f9d6393969e5dfca11fdb1f947a23e640d4", size = 28380, upload_time = "2025-02-20T21:01:19.524Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/81/3747dad6b14fa2cf53fcf10548cf5aea6913e96fab41a3c198676f8948a5/cachetools-5.5.2.tar.gz", hash = "sha256:1a661caa9175d26759571b2e19580f9d6393969e5dfca11fdb1f947a23e640d4", size = 28380 } wheels = [ - { url = "https://files.pythonhosted.org/packages/72/76/20fa66124dbe6be5cafeb312ece67de6b61dd91a0247d1ea13db4ebb33c2/cachetools-5.5.2-py3-none-any.whl", hash = "sha256:d26a22bcc62eb95c3beabd9f1ee5e820d3d2704fe2967cbe350e20c8ffcd3f0a", size = 10080, upload_time = "2025-02-20T21:01:16.647Z" }, + { url = "https://files.pythonhosted.org/packages/72/76/20fa66124dbe6be5cafeb312ece67de6b61dd91a0247d1ea13db4ebb33c2/cachetools-5.5.2-py3-none-any.whl", hash = "sha256:d26a22bcc62eb95c3beabd9f1ee5e820d3d2704fe2967cbe350e20c8ffcd3f0a", size = 10080 }, ] [[package]] name = "certifi" version = "2024.8.30" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b0/ee/9b19140fe824b367c04c5e1b369942dd754c4c5462d5674002f75c4dedc1/certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9", size = 168507, upload_time = "2024-08-30T01:55:04.365Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/ee/9b19140fe824b367c04c5e1b369942dd754c4c5462d5674002f75c4dedc1/certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9", size = 168507 } wheels = [ - { url = "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", size = 167321, upload_time = "2024-08-30T01:55:02.591Z" }, + { url = "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", size = 167321 }, ] [[package]] name = "charset-normalizer" version = "3.4.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", size = 106620, upload_time = "2024-10-09T07:40:20.413Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", size = 106620 } wheels = [ - { url = "https://files.pythonhosted.org/packages/69/8b/825cc84cf13a28bfbcba7c416ec22bf85a9584971be15b21dd8300c65b7f/charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4f9fc98dad6c2eaa32fc3af1417d95b5e3d08aff968df0cd320066def971f9a6", size = 196363, upload_time = "2024-10-09T07:38:02.622Z" }, - { url = "https://files.pythonhosted.org/packages/23/81/d7eef6a99e42c77f444fdd7bc894b0ceca6c3a95c51239e74a722039521c/charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0de7b687289d3c1b3e8660d0741874abe7888100efe14bd0f9fd7141bcbda92b", size = 125639, upload_time = "2024-10-09T07:38:04.044Z" }, - { url = "https://files.pythonhosted.org/packages/21/67/b4564d81f48042f520c948abac7079356e94b30cb8ffb22e747532cf469d/charset_normalizer-3.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ed2e36c3e9b4f21dd9422f6893dec0abf2cca553af509b10cd630f878d3eb99", size = 120451, upload_time = "2024-10-09T07:38:04.997Z" }, - { url = "https://files.pythonhosted.org/packages/c2/72/12a7f0943dd71fb5b4e7b55c41327ac0a1663046a868ee4d0d8e9c369b85/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d3ff7fc90b98c637bda91c89d51264a3dcf210cade3a2c6f838c7268d7a4ca", size = 140041, upload_time = "2024-10-09T07:38:06.676Z" }, - { url = "https://files.pythonhosted.org/packages/67/56/fa28c2c3e31217c4c52158537a2cf5d98a6c1e89d31faf476c89391cd16b/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1110e22af8ca26b90bd6364fe4c763329b0ebf1ee213ba32b68c73de5752323d", size = 150333, upload_time = "2024-10-09T07:38:08.626Z" }, - { url = "https://files.pythonhosted.org/packages/f9/d2/466a9be1f32d89eb1554cf84073a5ed9262047acee1ab39cbaefc19635d2/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86f4e8cca779080f66ff4f191a685ced73d2f72d50216f7112185dc02b90b9b7", size = 142921, upload_time = "2024-10-09T07:38:10.301Z" }, - { url = "https://files.pythonhosted.org/packages/f8/01/344ec40cf5d85c1da3c1f57566c59e0c9b56bcc5566c08804a95a6cc8257/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f683ddc7eedd742e2889d2bfb96d69573fde1d92fcb811979cdb7165bb9c7d3", size = 144785, upload_time = "2024-10-09T07:38:12.019Z" }, - { url = "https://files.pythonhosted.org/packages/73/8b/2102692cb6d7e9f03b9a33a710e0164cadfce312872e3efc7cfe22ed26b4/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27623ba66c183eca01bf9ff833875b459cad267aeeb044477fedac35e19ba907", size = 146631, upload_time = "2024-10-09T07:38:13.701Z" }, - { url = "https://files.pythonhosted.org/packages/d8/96/cc2c1b5d994119ce9f088a9a0c3ebd489d360a2eb058e2c8049f27092847/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f606a1881d2663630ea5b8ce2efe2111740df4b687bd78b34a8131baa007f79b", size = 140867, upload_time = "2024-10-09T07:38:15.403Z" }, - { url = "https://files.pythonhosted.org/packages/c9/27/cde291783715b8ec30a61c810d0120411844bc4c23b50189b81188b273db/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0b309d1747110feb25d7ed6b01afdec269c647d382c857ef4663bbe6ad95a912", size = 149273, upload_time = "2024-10-09T07:38:16.433Z" }, - { url = "https://files.pythonhosted.org/packages/3a/a4/8633b0fc1a2d1834d5393dafecce4a1cc56727bfd82b4dc18fc92f0d3cc3/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:136815f06a3ae311fae551c3df1f998a1ebd01ddd424aa5603a4336997629e95", size = 152437, upload_time = "2024-10-09T07:38:18.013Z" }, - { url = "https://files.pythonhosted.org/packages/64/ea/69af161062166b5975ccbb0961fd2384853190c70786f288684490913bf5/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:14215b71a762336254351b00ec720a8e85cada43b987da5a042e4ce3e82bd68e", size = 150087, upload_time = "2024-10-09T07:38:19.089Z" }, - { url = "https://files.pythonhosted.org/packages/3b/fd/e60a9d9fd967f4ad5a92810138192f825d77b4fa2a557990fd575a47695b/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79983512b108e4a164b9c8d34de3992f76d48cadc9554c9e60b43f308988aabe", size = 145142, upload_time = "2024-10-09T07:38:20.78Z" }, - { url = "https://files.pythonhosted.org/packages/6d/02/8cb0988a1e49ac9ce2eed1e07b77ff118f2923e9ebd0ede41ba85f2dcb04/charset_normalizer-3.4.0-cp310-cp310-win32.whl", hash = "sha256:c94057af19bc953643a33581844649a7fdab902624d2eb739738a30e2b3e60fc", size = 94701, upload_time = "2024-10-09T07:38:21.851Z" }, - { url = "https://files.pythonhosted.org/packages/d6/20/f1d4670a8a723c46be695dff449d86d6092916f9e99c53051954ee33a1bc/charset_normalizer-3.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:55f56e2ebd4e3bc50442fbc0888c9d8c94e4e06a933804e2af3e89e2f9c1c749", size = 102191, upload_time = "2024-10-09T07:38:23.467Z" }, - { url = "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", size = 193339, upload_time = "2024-10-09T07:38:24.527Z" }, - { url = "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", size = 124366, upload_time = "2024-10-09T07:38:26.488Z" }, - { url = "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", size = 118874, upload_time = "2024-10-09T07:38:28.115Z" }, - { url = "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", size = 138243, upload_time = "2024-10-09T07:38:29.822Z" }, - { url = "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", size = 148676, upload_time = "2024-10-09T07:38:30.869Z" }, - { url = "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", size = 141289, upload_time = "2024-10-09T07:38:32.557Z" }, - { url = "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", size = 142585, upload_time = "2024-10-09T07:38:33.649Z" }, - { url = "https://files.pythonhosted.org/packages/3b/a0/a68980ab8a1f45a36d9745d35049c1af57d27255eff8c907e3add84cf68f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82357d85de703176b5587dbe6ade8ff67f9f69a41c0733cf2425378b49954de5", size = 144408, upload_time = "2024-10-09T07:38:34.687Z" }, - { url = "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", size = 139076, upload_time = "2024-10-09T07:38:36.417Z" }, - { url = "https://files.pythonhosted.org/packages/fb/9d/9c13753a5a6e0db4a0a6edb1cef7aee39859177b64e1a1e748a6e3ba62c2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8ce7fd6767a1cc5a92a639b391891bf1c268b03ec7e021c7d6d902285259685c", size = 146874, upload_time = "2024-10-09T07:38:37.59Z" }, - { url = "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", size = 150871, upload_time = "2024-10-09T07:38:38.666Z" }, - { url = "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", size = 148546, upload_time = "2024-10-09T07:38:40.459Z" }, - { url = "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", size = 143048, upload_time = "2024-10-09T07:38:42.178Z" }, - { url = "https://files.pythonhosted.org/packages/01/f8/38842422988b795220eb8038745d27a675ce066e2ada79516c118f291f07/charset_normalizer-3.4.0-cp311-cp311-win32.whl", hash = "sha256:9ae4ef0b3f6b41bad6366fb0ea4fc1d7ed051528e113a60fa2a65a9abb5b1d99", size = 94389, upload_time = "2024-10-09T07:38:43.339Z" }, - { url = "https://files.pythonhosted.org/packages/0b/6e/b13bd47fa9023b3699e94abf565b5a2f0b0be6e9ddac9812182596ee62e4/charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27", size = 101752, upload_time = "2024-10-09T07:38:44.276Z" }, - { url = "https://files.pythonhosted.org/packages/d3/0b/4b7a70987abf9b8196845806198975b6aab4ce016632f817ad758a5aa056/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6", size = 194445, upload_time = "2024-10-09T07:38:45.275Z" }, - { url = "https://files.pythonhosted.org/packages/50/89/354cc56cf4dd2449715bc9a0f54f3aef3dc700d2d62d1fa5bbea53b13426/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf", size = 125275, upload_time = "2024-10-09T07:38:46.449Z" }, - { url = "https://files.pythonhosted.org/packages/fa/44/b730e2a2580110ced837ac083d8ad222343c96bb6b66e9e4e706e4d0b6df/charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db", size = 119020, upload_time = "2024-10-09T07:38:48.88Z" }, - { url = "https://files.pythonhosted.org/packages/9d/e4/9263b8240ed9472a2ae7ddc3e516e71ef46617fe40eaa51221ccd4ad9a27/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1", size = 139128, upload_time = "2024-10-09T07:38:49.86Z" }, - { url = "https://files.pythonhosted.org/packages/6b/e3/9f73e779315a54334240353eaea75854a9a690f3f580e4bd85d977cb2204/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03", size = 149277, upload_time = "2024-10-09T07:38:52.306Z" }, - { url = "https://files.pythonhosted.org/packages/1a/cf/f1f50c2f295312edb8a548d3fa56a5c923b146cd3f24114d5adb7e7be558/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284", size = 142174, upload_time = "2024-10-09T07:38:53.458Z" }, - { url = "https://files.pythonhosted.org/packages/16/92/92a76dc2ff3a12e69ba94e7e05168d37d0345fa08c87e1fe24d0c2a42223/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15", size = 143838, upload_time = "2024-10-09T07:38:54.691Z" }, - { url = "https://files.pythonhosted.org/packages/a4/01/2117ff2b1dfc61695daf2babe4a874bca328489afa85952440b59819e9d7/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8", size = 146149, upload_time = "2024-10-09T07:38:55.737Z" }, - { url = "https://files.pythonhosted.org/packages/f6/9b/93a332b8d25b347f6839ca0a61b7f0287b0930216994e8bf67a75d050255/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2", size = 140043, upload_time = "2024-10-09T07:38:57.44Z" }, - { url = "https://files.pythonhosted.org/packages/ab/f6/7ac4a01adcdecbc7a7587767c776d53d369b8b971382b91211489535acf0/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719", size = 148229, upload_time = "2024-10-09T07:38:58.782Z" }, - { url = "https://files.pythonhosted.org/packages/9d/be/5708ad18161dee7dc6a0f7e6cf3a88ea6279c3e8484844c0590e50e803ef/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631", size = 151556, upload_time = "2024-10-09T07:39:00.467Z" }, - { url = "https://files.pythonhosted.org/packages/5a/bb/3d8bc22bacb9eb89785e83e6723f9888265f3a0de3b9ce724d66bd49884e/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b", size = 149772, upload_time = "2024-10-09T07:39:01.5Z" }, - { url = "https://files.pythonhosted.org/packages/f7/fa/d3fc622de05a86f30beea5fc4e9ac46aead4731e73fd9055496732bcc0a4/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565", size = 144800, upload_time = "2024-10-09T07:39:02.491Z" }, - { url = "https://files.pythonhosted.org/packages/9a/65/bdb9bc496d7d190d725e96816e20e2ae3a6fa42a5cac99c3c3d6ff884118/charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7", size = 94836, upload_time = "2024-10-09T07:39:04.607Z" }, - { url = "https://files.pythonhosted.org/packages/3e/67/7b72b69d25b89c0b3cea583ee372c43aa24df15f0e0f8d3982c57804984b/charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9", size = 102187, upload_time = "2024-10-09T07:39:06.247Z" }, - { url = "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", size = 194617, upload_time = "2024-10-09T07:39:07.317Z" }, - { url = "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", size = 125310, upload_time = "2024-10-09T07:39:08.353Z" }, - { url = "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", size = 119126, upload_time = "2024-10-09T07:39:09.327Z" }, - { url = "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", size = 139342, upload_time = "2024-10-09T07:39:10.322Z" }, - { url = "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", size = 149383, upload_time = "2024-10-09T07:39:12.042Z" }, - { url = "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", size = 142214, upload_time = "2024-10-09T07:39:13.059Z" }, - { url = "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", size = 144104, upload_time = "2024-10-09T07:39:14.815Z" }, - { url = "https://files.pythonhosted.org/packages/ee/68/efad5dcb306bf37db7db338338e7bb8ebd8cf38ee5bbd5ceaaaa46f257e6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d", size = 146255, upload_time = "2024-10-09T07:39:15.868Z" }, - { url = "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", size = 140251, upload_time = "2024-10-09T07:39:16.995Z" }, - { url = "https://files.pythonhosted.org/packages/7d/0d/6f32255c1979653b448d3c709583557a4d24ff97ac4f3a5be156b2e6a210/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90", size = 148474, upload_time = "2024-10-09T07:39:18.021Z" }, - { url = "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", size = 151849, upload_time = "2024-10-09T07:39:19.243Z" }, - { url = "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", size = 149781, upload_time = "2024-10-09T07:39:20.397Z" }, - { url = "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", size = 144970, upload_time = "2024-10-09T07:39:21.452Z" }, - { url = "https://files.pythonhosted.org/packages/cc/67/e5e7e0cbfefc4ca79025238b43cdf8a2037854195b37d6417f3d0895c4c2/charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67", size = 94973, upload_time = "2024-10-09T07:39:22.509Z" }, - { url = "https://files.pythonhosted.org/packages/65/97/fc9bbc54ee13d33dc54a7fcf17b26368b18505500fc01e228c27b5222d80/charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b", size = 102308, upload_time = "2024-10-09T07:39:23.524Z" }, - { url = "https://files.pythonhosted.org/packages/54/2f/28659eee7f5d003e0f5a3b572765bf76d6e0fe6601ab1f1b1dd4cba7e4f1/charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:980b4f289d1d90ca5efcf07958d3eb38ed9c0b7676bf2831a54d4f66f9c27dfa", size = 196326, upload_time = "2024-10-09T07:39:59.619Z" }, - { url = "https://files.pythonhosted.org/packages/d1/18/92869d5c0057baa973a3ee2af71573be7b084b3c3d428fe6463ce71167f8/charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f28f891ccd15c514a0981f3b9db9aa23d62fe1a99997512b0491d2ed323d229a", size = 125614, upload_time = "2024-10-09T07:40:00.776Z" }, - { url = "https://files.pythonhosted.org/packages/d6/27/327904c5a54a7796bb9f36810ec4173d2df5d88b401d2b95ef53111d214e/charset_normalizer-3.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8aacce6e2e1edcb6ac625fb0f8c3a9570ccc7bfba1f63419b3769ccf6a00ed0", size = 120450, upload_time = "2024-10-09T07:40:02.621Z" }, - { url = "https://files.pythonhosted.org/packages/a4/23/65af317914a0308495133b2d654cf67b11bbd6ca16637c4e8a38f80a5a69/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd7af3717683bea4c87acd8c0d3d5b44d56120b26fd3f8a692bdd2d5260c620a", size = 140135, upload_time = "2024-10-09T07:40:05.719Z" }, - { url = "https://files.pythonhosted.org/packages/f2/41/6190102ad521a8aa888519bb014a74251ac4586cde9b38e790901684f9ab/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ff2ed8194587faf56555927b3aa10e6fb69d931e33953943bc4f837dfee2242", size = 150413, upload_time = "2024-10-09T07:40:06.777Z" }, - { url = "https://files.pythonhosted.org/packages/7b/ab/f47b0159a69eab9bd915591106859f49670c75f9a19082505ff16f50efc0/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e91f541a85298cf35433bf66f3fab2a4a2cff05c127eeca4af174f6d497f0d4b", size = 142992, upload_time = "2024-10-09T07:40:07.921Z" }, - { url = "https://files.pythonhosted.org/packages/28/89/60f51ad71f63aaaa7e51a2a2ad37919985a341a1d267070f212cdf6c2d22/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:309a7de0a0ff3040acaebb35ec45d18db4b28232f21998851cfa709eeff49d62", size = 144871, upload_time = "2024-10-09T07:40:09.035Z" }, - { url = "https://files.pythonhosted.org/packages/0c/48/0050550275fea585a6e24460b42465020b53375017d8596c96be57bfabca/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:285e96d9d53422efc0d7a17c60e59f37fbf3dfa942073f666db4ac71e8d726d0", size = 146756, upload_time = "2024-10-09T07:40:10.186Z" }, - { url = "https://files.pythonhosted.org/packages/dc/b5/47f8ee91455946f745e6c9ddbb0f8f50314d2416dd922b213e7d5551ad09/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:5d447056e2ca60382d460a604b6302d8db69476fd2015c81e7c35417cfabe4cd", size = 141034, upload_time = "2024-10-09T07:40:11.386Z" }, - { url = "https://files.pythonhosted.org/packages/84/79/5c731059ebab43e80bf61fa51666b9b18167974b82004f18c76378ed31a3/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:20587d20f557fe189b7947d8e7ec5afa110ccf72a3128d61a2a387c3313f46be", size = 149434, upload_time = "2024-10-09T07:40:12.513Z" }, - { url = "https://files.pythonhosted.org/packages/ca/f3/0719cd09fc4dc42066f239cb3c48ced17fc3316afca3e2a30a4756fe49ab/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:130272c698667a982a5d0e626851ceff662565379baf0ff2cc58067b81d4f11d", size = 152443, upload_time = "2024-10-09T07:40:13.655Z" }, - { url = "https://files.pythonhosted.org/packages/f7/0e/c6357297f1157c8e8227ff337e93fd0a90e498e3d6ab96b2782204ecae48/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:ab22fbd9765e6954bc0bcff24c25ff71dcbfdb185fcdaca49e81bac68fe724d3", size = 150294, upload_time = "2024-10-09T07:40:14.883Z" }, - { url = "https://files.pythonhosted.org/packages/54/9a/acfa96dc4ea8c928040b15822b59d0863d6e1757fba8bd7de3dc4f761c13/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7782afc9b6b42200f7362858f9e73b1f8316afb276d316336c0ec3bd73312742", size = 145314, upload_time = "2024-10-09T07:40:16.043Z" }, - { url = "https://files.pythonhosted.org/packages/73/1c/b10a63032eaebb8d7bcb8544f12f063f41f5f463778ac61da15d9985e8b6/charset_normalizer-3.4.0-cp39-cp39-win32.whl", hash = "sha256:2de62e8801ddfff069cd5c504ce3bc9672b23266597d4e4f50eda28846c322f2", size = 94724, upload_time = "2024-10-09T07:40:17.199Z" }, - { url = "https://files.pythonhosted.org/packages/c5/77/3a78bf28bfaa0863f9cfef278dbeadf55efe064eafff8c7c424ae3c4c1bf/charset_normalizer-3.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:95c3c157765b031331dd4db3c775e58deaee050a3042fcad72cbc4189d7c8dca", size = 102159, upload_time = "2024-10-09T07:40:18.264Z" }, - { url = "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", size = 49446, upload_time = "2024-10-09T07:40:19.383Z" }, + { url = "https://files.pythonhosted.org/packages/69/8b/825cc84cf13a28bfbcba7c416ec22bf85a9584971be15b21dd8300c65b7f/charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4f9fc98dad6c2eaa32fc3af1417d95b5e3d08aff968df0cd320066def971f9a6", size = 196363 }, + { url = "https://files.pythonhosted.org/packages/23/81/d7eef6a99e42c77f444fdd7bc894b0ceca6c3a95c51239e74a722039521c/charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0de7b687289d3c1b3e8660d0741874abe7888100efe14bd0f9fd7141bcbda92b", size = 125639 }, + { url = "https://files.pythonhosted.org/packages/21/67/b4564d81f48042f520c948abac7079356e94b30cb8ffb22e747532cf469d/charset_normalizer-3.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ed2e36c3e9b4f21dd9422f6893dec0abf2cca553af509b10cd630f878d3eb99", size = 120451 }, + { url = "https://files.pythonhosted.org/packages/c2/72/12a7f0943dd71fb5b4e7b55c41327ac0a1663046a868ee4d0d8e9c369b85/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d3ff7fc90b98c637bda91c89d51264a3dcf210cade3a2c6f838c7268d7a4ca", size = 140041 }, + { url = "https://files.pythonhosted.org/packages/67/56/fa28c2c3e31217c4c52158537a2cf5d98a6c1e89d31faf476c89391cd16b/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1110e22af8ca26b90bd6364fe4c763329b0ebf1ee213ba32b68c73de5752323d", size = 150333 }, + { url = "https://files.pythonhosted.org/packages/f9/d2/466a9be1f32d89eb1554cf84073a5ed9262047acee1ab39cbaefc19635d2/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86f4e8cca779080f66ff4f191a685ced73d2f72d50216f7112185dc02b90b9b7", size = 142921 }, + { url = "https://files.pythonhosted.org/packages/f8/01/344ec40cf5d85c1da3c1f57566c59e0c9b56bcc5566c08804a95a6cc8257/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f683ddc7eedd742e2889d2bfb96d69573fde1d92fcb811979cdb7165bb9c7d3", size = 144785 }, + { url = "https://files.pythonhosted.org/packages/73/8b/2102692cb6d7e9f03b9a33a710e0164cadfce312872e3efc7cfe22ed26b4/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27623ba66c183eca01bf9ff833875b459cad267aeeb044477fedac35e19ba907", size = 146631 }, + { url = "https://files.pythonhosted.org/packages/d8/96/cc2c1b5d994119ce9f088a9a0c3ebd489d360a2eb058e2c8049f27092847/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f606a1881d2663630ea5b8ce2efe2111740df4b687bd78b34a8131baa007f79b", size = 140867 }, + { url = "https://files.pythonhosted.org/packages/c9/27/cde291783715b8ec30a61c810d0120411844bc4c23b50189b81188b273db/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0b309d1747110feb25d7ed6b01afdec269c647d382c857ef4663bbe6ad95a912", size = 149273 }, + { url = "https://files.pythonhosted.org/packages/3a/a4/8633b0fc1a2d1834d5393dafecce4a1cc56727bfd82b4dc18fc92f0d3cc3/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:136815f06a3ae311fae551c3df1f998a1ebd01ddd424aa5603a4336997629e95", size = 152437 }, + { url = "https://files.pythonhosted.org/packages/64/ea/69af161062166b5975ccbb0961fd2384853190c70786f288684490913bf5/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:14215b71a762336254351b00ec720a8e85cada43b987da5a042e4ce3e82bd68e", size = 150087 }, + { url = "https://files.pythonhosted.org/packages/3b/fd/e60a9d9fd967f4ad5a92810138192f825d77b4fa2a557990fd575a47695b/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79983512b108e4a164b9c8d34de3992f76d48cadc9554c9e60b43f308988aabe", size = 145142 }, + { url = "https://files.pythonhosted.org/packages/6d/02/8cb0988a1e49ac9ce2eed1e07b77ff118f2923e9ebd0ede41ba85f2dcb04/charset_normalizer-3.4.0-cp310-cp310-win32.whl", hash = "sha256:c94057af19bc953643a33581844649a7fdab902624d2eb739738a30e2b3e60fc", size = 94701 }, + { url = "https://files.pythonhosted.org/packages/d6/20/f1d4670a8a723c46be695dff449d86d6092916f9e99c53051954ee33a1bc/charset_normalizer-3.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:55f56e2ebd4e3bc50442fbc0888c9d8c94e4e06a933804e2af3e89e2f9c1c749", size = 102191 }, + { url = "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", size = 193339 }, + { url = "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", size = 124366 }, + { url = "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", size = 118874 }, + { url = "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", size = 138243 }, + { url = "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", size = 148676 }, + { url = "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", size = 141289 }, + { url = "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", size = 142585 }, + { url = "https://files.pythonhosted.org/packages/3b/a0/a68980ab8a1f45a36d9745d35049c1af57d27255eff8c907e3add84cf68f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82357d85de703176b5587dbe6ade8ff67f9f69a41c0733cf2425378b49954de5", size = 144408 }, + { url = "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", size = 139076 }, + { url = "https://files.pythonhosted.org/packages/fb/9d/9c13753a5a6e0db4a0a6edb1cef7aee39859177b64e1a1e748a6e3ba62c2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8ce7fd6767a1cc5a92a639b391891bf1c268b03ec7e021c7d6d902285259685c", size = 146874 }, + { url = "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", size = 150871 }, + { url = "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", size = 148546 }, + { url = "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", size = 143048 }, + { url = "https://files.pythonhosted.org/packages/01/f8/38842422988b795220eb8038745d27a675ce066e2ada79516c118f291f07/charset_normalizer-3.4.0-cp311-cp311-win32.whl", hash = "sha256:9ae4ef0b3f6b41bad6366fb0ea4fc1d7ed051528e113a60fa2a65a9abb5b1d99", size = 94389 }, + { url = "https://files.pythonhosted.org/packages/0b/6e/b13bd47fa9023b3699e94abf565b5a2f0b0be6e9ddac9812182596ee62e4/charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27", size = 101752 }, + { url = "https://files.pythonhosted.org/packages/d3/0b/4b7a70987abf9b8196845806198975b6aab4ce016632f817ad758a5aa056/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6", size = 194445 }, + { url = "https://files.pythonhosted.org/packages/50/89/354cc56cf4dd2449715bc9a0f54f3aef3dc700d2d62d1fa5bbea53b13426/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf", size = 125275 }, + { url = "https://files.pythonhosted.org/packages/fa/44/b730e2a2580110ced837ac083d8ad222343c96bb6b66e9e4e706e4d0b6df/charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db", size = 119020 }, + { url = "https://files.pythonhosted.org/packages/9d/e4/9263b8240ed9472a2ae7ddc3e516e71ef46617fe40eaa51221ccd4ad9a27/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1", size = 139128 }, + { url = "https://files.pythonhosted.org/packages/6b/e3/9f73e779315a54334240353eaea75854a9a690f3f580e4bd85d977cb2204/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03", size = 149277 }, + { url = "https://files.pythonhosted.org/packages/1a/cf/f1f50c2f295312edb8a548d3fa56a5c923b146cd3f24114d5adb7e7be558/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284", size = 142174 }, + { url = "https://files.pythonhosted.org/packages/16/92/92a76dc2ff3a12e69ba94e7e05168d37d0345fa08c87e1fe24d0c2a42223/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15", size = 143838 }, + { url = "https://files.pythonhosted.org/packages/a4/01/2117ff2b1dfc61695daf2babe4a874bca328489afa85952440b59819e9d7/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8", size = 146149 }, + { url = "https://files.pythonhosted.org/packages/f6/9b/93a332b8d25b347f6839ca0a61b7f0287b0930216994e8bf67a75d050255/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2", size = 140043 }, + { url = "https://files.pythonhosted.org/packages/ab/f6/7ac4a01adcdecbc7a7587767c776d53d369b8b971382b91211489535acf0/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719", size = 148229 }, + { url = "https://files.pythonhosted.org/packages/9d/be/5708ad18161dee7dc6a0f7e6cf3a88ea6279c3e8484844c0590e50e803ef/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631", size = 151556 }, + { url = "https://files.pythonhosted.org/packages/5a/bb/3d8bc22bacb9eb89785e83e6723f9888265f3a0de3b9ce724d66bd49884e/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b", size = 149772 }, + { url = "https://files.pythonhosted.org/packages/f7/fa/d3fc622de05a86f30beea5fc4e9ac46aead4731e73fd9055496732bcc0a4/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565", size = 144800 }, + { url = "https://files.pythonhosted.org/packages/9a/65/bdb9bc496d7d190d725e96816e20e2ae3a6fa42a5cac99c3c3d6ff884118/charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7", size = 94836 }, + { url = "https://files.pythonhosted.org/packages/3e/67/7b72b69d25b89c0b3cea583ee372c43aa24df15f0e0f8d3982c57804984b/charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9", size = 102187 }, + { url = "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", size = 194617 }, + { url = "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", size = 125310 }, + { url = "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", size = 119126 }, + { url = "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", size = 139342 }, + { url = "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", size = 149383 }, + { url = "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", size = 142214 }, + { url = "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", size = 144104 }, + { url = "https://files.pythonhosted.org/packages/ee/68/efad5dcb306bf37db7db338338e7bb8ebd8cf38ee5bbd5ceaaaa46f257e6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d", size = 146255 }, + { url = "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", size = 140251 }, + { url = "https://files.pythonhosted.org/packages/7d/0d/6f32255c1979653b448d3c709583557a4d24ff97ac4f3a5be156b2e6a210/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90", size = 148474 }, + { url = "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", size = 151849 }, + { url = "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", size = 149781 }, + { url = "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", size = 144970 }, + { url = "https://files.pythonhosted.org/packages/cc/67/e5e7e0cbfefc4ca79025238b43cdf8a2037854195b37d6417f3d0895c4c2/charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67", size = 94973 }, + { url = "https://files.pythonhosted.org/packages/65/97/fc9bbc54ee13d33dc54a7fcf17b26368b18505500fc01e228c27b5222d80/charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b", size = 102308 }, + { url = "https://files.pythonhosted.org/packages/54/2f/28659eee7f5d003e0f5a3b572765bf76d6e0fe6601ab1f1b1dd4cba7e4f1/charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:980b4f289d1d90ca5efcf07958d3eb38ed9c0b7676bf2831a54d4f66f9c27dfa", size = 196326 }, + { url = "https://files.pythonhosted.org/packages/d1/18/92869d5c0057baa973a3ee2af71573be7b084b3c3d428fe6463ce71167f8/charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f28f891ccd15c514a0981f3b9db9aa23d62fe1a99997512b0491d2ed323d229a", size = 125614 }, + { url = "https://files.pythonhosted.org/packages/d6/27/327904c5a54a7796bb9f36810ec4173d2df5d88b401d2b95ef53111d214e/charset_normalizer-3.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8aacce6e2e1edcb6ac625fb0f8c3a9570ccc7bfba1f63419b3769ccf6a00ed0", size = 120450 }, + { url = "https://files.pythonhosted.org/packages/a4/23/65af317914a0308495133b2d654cf67b11bbd6ca16637c4e8a38f80a5a69/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd7af3717683bea4c87acd8c0d3d5b44d56120b26fd3f8a692bdd2d5260c620a", size = 140135 }, + { url = "https://files.pythonhosted.org/packages/f2/41/6190102ad521a8aa888519bb014a74251ac4586cde9b38e790901684f9ab/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ff2ed8194587faf56555927b3aa10e6fb69d931e33953943bc4f837dfee2242", size = 150413 }, + { url = "https://files.pythonhosted.org/packages/7b/ab/f47b0159a69eab9bd915591106859f49670c75f9a19082505ff16f50efc0/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e91f541a85298cf35433bf66f3fab2a4a2cff05c127eeca4af174f6d497f0d4b", size = 142992 }, + { url = "https://files.pythonhosted.org/packages/28/89/60f51ad71f63aaaa7e51a2a2ad37919985a341a1d267070f212cdf6c2d22/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:309a7de0a0ff3040acaebb35ec45d18db4b28232f21998851cfa709eeff49d62", size = 144871 }, + { url = "https://files.pythonhosted.org/packages/0c/48/0050550275fea585a6e24460b42465020b53375017d8596c96be57bfabca/charset_normalizer-3.4.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:285e96d9d53422efc0d7a17c60e59f37fbf3dfa942073f666db4ac71e8d726d0", size = 146756 }, + { url = "https://files.pythonhosted.org/packages/dc/b5/47f8ee91455946f745e6c9ddbb0f8f50314d2416dd922b213e7d5551ad09/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:5d447056e2ca60382d460a604b6302d8db69476fd2015c81e7c35417cfabe4cd", size = 141034 }, + { url = "https://files.pythonhosted.org/packages/84/79/5c731059ebab43e80bf61fa51666b9b18167974b82004f18c76378ed31a3/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:20587d20f557fe189b7947d8e7ec5afa110ccf72a3128d61a2a387c3313f46be", size = 149434 }, + { url = "https://files.pythonhosted.org/packages/ca/f3/0719cd09fc4dc42066f239cb3c48ced17fc3316afca3e2a30a4756fe49ab/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:130272c698667a982a5d0e626851ceff662565379baf0ff2cc58067b81d4f11d", size = 152443 }, + { url = "https://files.pythonhosted.org/packages/f7/0e/c6357297f1157c8e8227ff337e93fd0a90e498e3d6ab96b2782204ecae48/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:ab22fbd9765e6954bc0bcff24c25ff71dcbfdb185fcdaca49e81bac68fe724d3", size = 150294 }, + { url = "https://files.pythonhosted.org/packages/54/9a/acfa96dc4ea8c928040b15822b59d0863d6e1757fba8bd7de3dc4f761c13/charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7782afc9b6b42200f7362858f9e73b1f8316afb276d316336c0ec3bd73312742", size = 145314 }, + { url = "https://files.pythonhosted.org/packages/73/1c/b10a63032eaebb8d7bcb8544f12f063f41f5f463778ac61da15d9985e8b6/charset_normalizer-3.4.0-cp39-cp39-win32.whl", hash = "sha256:2de62e8801ddfff069cd5c504ce3bc9672b23266597d4e4f50eda28846c322f2", size = 94724 }, + { url = "https://files.pythonhosted.org/packages/c5/77/3a78bf28bfaa0863f9cfef278dbeadf55efe064eafff8c7c424ae3c4c1bf/charset_normalizer-3.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:95c3c157765b031331dd4db3c775e58deaee050a3042fcad72cbc4189d7c8dca", size = 102159 }, + { url = "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", size = 49446 }, ] [[package]] @@ -199,38 +198,38 @@ name = "click" version = "8.1.8" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "colorama", marker = "platform_system == 'Windows'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593, upload_time = "2024-12-21T18:38:44.339Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 } wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188, upload_time = "2024-12-21T18:38:41.666Z" }, + { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188 }, ] [[package]] name = "colorama" version = "0.4.6" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload_time = "2022-10-25T02:36:22.414Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload_time = "2022-10-25T02:36:20.889Z" }, + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, ] [[package]] name = "distro" version = "1.9.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload_time = "2023-12-24T09:54:32.31Z" } +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722 } wheels = [ - { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload_time = "2023-12-24T09:54:30.421Z" }, + { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277 }, ] [[package]] name = "exceptiongroup" version = "1.2.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883, upload_time = "2024-07-12T22:26:00.161Z" } +sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 } wheels = [ - { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453, upload_time = "2024-07-12T22:25:58.476Z" }, + { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 }, ] [[package]] @@ -245,9 +244,9 @@ dependencies = [ { name = "jinja2" }, { name = "werkzeug" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/41/e1/d104c83026f8d35dfd2c261df7d64738341067526406b40190bc063e829a/flask-3.0.3.tar.gz", hash = "sha256:ceb27b0af3823ea2737928a4d99d125a06175b8512c445cbd9a9ce200ef76842", size = 676315, upload_time = "2024-04-07T19:26:11.035Z" } +sdist = { url = "https://files.pythonhosted.org/packages/41/e1/d104c83026f8d35dfd2c261df7d64738341067526406b40190bc063e829a/flask-3.0.3.tar.gz", hash = "sha256:ceb27b0af3823ea2737928a4d99d125a06175b8512c445cbd9a9ce200ef76842", size = 676315 } wheels = [ - { url = "https://files.pythonhosted.org/packages/61/80/ffe1da13ad9300f87c93af113edd0638c75138c42a0994becfacac078c06/flask-3.0.3-py3-none-any.whl", hash = "sha256:34e815dfaa43340d1d15a5c3a02b8476004037eb4840b34910c6e21679d288f3", size = 101735, upload_time = "2024-04-07T19:26:08.569Z" }, + { url = "https://files.pythonhosted.org/packages/61/80/ffe1da13ad9300f87c93af113edd0638c75138c42a0994becfacac078c06/flask-3.0.3-py3-none-any.whl", hash = "sha256:34e815dfaa43340d1d15a5c3a02b8476004037eb4840b34910c6e21679d288f3", size = 101735 }, ] [[package]] @@ -257,9 +256,9 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "flask" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/22/21/0160aa217c4df74e44a04919213f9c8af7e68551c10267b055f1e09d421c/Flask-HTTPAuth-4.8.0.tar.gz", hash = "sha256:66568a05bc73942c65f1e2201ae746295816dc009edd84b482c44c758d75097a", size = 230314, upload_time = "2023-04-27T09:25:57.48Z" } +sdist = { url = "https://files.pythonhosted.org/packages/22/21/0160aa217c4df74e44a04919213f9c8af7e68551c10267b055f1e09d421c/Flask-HTTPAuth-4.8.0.tar.gz", hash = "sha256:66568a05bc73942c65f1e2201ae746295816dc009edd84b482c44c758d75097a", size = 230314 } wheels = [ - { url = "https://files.pythonhosted.org/packages/83/c4/e64ace124b927cd1f29270050ee0e0ef5faad75a512c5c8d733961dda9ca/Flask_HTTPAuth-4.8.0-py3-none-any.whl", hash = "sha256:a58fedd09989b9975448eef04806b096a3964a7feeebc0a78831ff55685b62b0", size = 6958, upload_time = "2023-04-27T09:25:55.803Z" }, + { url = "https://files.pythonhosted.org/packages/83/c4/e64ace124b927cd1f29270050ee0e0ef5faad75a512c5c8d733961dda9ca/Flask_HTTPAuth-4.8.0-py3-none-any.whl", hash = "sha256:a58fedd09989b9975448eef04806b096a3964a7feeebc0a78831ff55685b62b0", size = 6958 }, ] [[package]] @@ -271,9 +270,9 @@ dependencies = [ { name = "pyasn1-modules" }, { name = "rsa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c6/eb/d504ba1daf190af6b204a9d4714d457462b486043744901a6eeea711f913/google_auth-2.38.0.tar.gz", hash = "sha256:8285113607d3b80a3f1543b75962447ba8a09fe85783432a784fdeef6ac094c4", size = 270866, upload_time = "2025-01-23T01:05:29.119Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c6/eb/d504ba1daf190af6b204a9d4714d457462b486043744901a6eeea711f913/google_auth-2.38.0.tar.gz", hash = "sha256:8285113607d3b80a3f1543b75962447ba8a09fe85783432a784fdeef6ac094c4", size = 270866 } wheels = [ - { url = "https://files.pythonhosted.org/packages/9d/47/603554949a37bca5b7f894d51896a9c534b9eab808e2520a748e081669d0/google_auth-2.38.0-py2.py3-none-any.whl", hash = "sha256:e7dae6694313f434a2727bf2906f27ad259bae090d7aa896590d86feec3d9d4a", size = 210770, upload_time = "2025-01-23T01:05:26.572Z" }, + { url = "https://files.pythonhosted.org/packages/9d/47/603554949a37bca5b7f894d51896a9c534b9eab808e2520a748e081669d0/google_auth-2.38.0-py2.py3-none-any.whl", hash = "sha256:e7dae6694313f434a2727bf2906f27ad259bae090d7aa896590d86feec3d9d4a", size = 210770 }, ] [[package]] @@ -289,18 +288,18 @@ dependencies = [ { name = "typing-extensions" }, { name = "websockets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/23/21/6f164fcb13293f520e016171be92611126d6bd2e9ceb246b32451c4ef51b/google_genai-1.5.0.tar.gz", hash = "sha256:83fcfc4956ad32ecea1fda37d8f3f7cbadbdeebd2310f2a55bc7564a2f1d459f", size = 135903, upload_time = "2025-03-07T00:34:53.186Z" } +sdist = { url = "https://files.pythonhosted.org/packages/23/21/6f164fcb13293f520e016171be92611126d6bd2e9ceb246b32451c4ef51b/google_genai-1.5.0.tar.gz", hash = "sha256:83fcfc4956ad32ecea1fda37d8f3f7cbadbdeebd2310f2a55bc7564a2f1d459f", size = 135903 } wheels = [ - { url = "https://files.pythonhosted.org/packages/ec/2a/a55da0c959326a7cf3c13398fc93c8e2af624b054ef3fa85b4cb6d0e2c96/google_genai-1.5.0-py3-none-any.whl", hash = "sha256:0ad433836a402957a967ccd57cbab7768325d28966a8556771974ae1c018be59", size = 142404, upload_time = "2025-03-07T00:34:51.157Z" }, + { url = "https://files.pythonhosted.org/packages/ec/2a/a55da0c959326a7cf3c13398fc93c8e2af624b054ef3fa85b4cb6d0e2c96/google_genai-1.5.0-py3-none-any.whl", hash = "sha256:0ad433836a402957a967ccd57cbab7768325d28966a8556771974ae1c018be59", size = 142404 }, ] [[package]] name = "h11" version = "0.14.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418, upload_time = "2022-09-25T15:40:01.519Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 } wheels = [ - { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259, upload_time = "2022-09-25T15:39:59.68Z" }, + { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 }, ] [[package]] @@ -311,9 +310,9 @@ dependencies = [ { name = "certifi" }, { name = "h11" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/6a/41/d7d0a89eb493922c37d343b607bc1b5da7f5be7e383740b4753ad8943e90/httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c", size = 85196, upload_time = "2024-11-15T12:30:47.531Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/41/d7d0a89eb493922c37d343b607bc1b5da7f5be7e383740b4753ad8943e90/httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c", size = 85196 } wheels = [ - { url = "https://files.pythonhosted.org/packages/87/f5/72347bc88306acb359581ac4d52f23c0ef445b57157adedb9aee0cd689d2/httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd", size = 78551, upload_time = "2024-11-15T12:30:45.782Z" }, + { url = "https://files.pythonhosted.org/packages/87/f5/72347bc88306acb359581ac4d52f23c0ef445b57157adedb9aee0cd689d2/httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd", size = 78551 }, ] [[package]] @@ -326,18 +325,18 @@ dependencies = [ { name = "httpcore" }, { name = "idna" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload_time = "2024-12-06T15:37:23.222Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 } wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload_time = "2024-12-06T15:37:21.509Z" }, + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 }, ] [[package]] name = "idna" version = "3.10" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload_time = "2024-09-15T18:07:39.745Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload_time = "2024-09-15T18:07:37.964Z" }, + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, ] [[package]] @@ -347,27 +346,27 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "zipp", marker = "python_full_version < '3.10'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7", size = 55304, upload_time = "2024-09-11T14:56:08.937Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7", size = 55304 } wheels = [ - { url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b", size = 26514, upload_time = "2024-09-11T14:56:07.019Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b", size = 26514 }, ] [[package]] name = "iniconfig" version = "2.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646, upload_time = "2023-01-07T11:08:11.254Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 } wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892, upload_time = "2023-01-07T11:08:09.864Z" }, + { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 }, ] [[package]] name = "itsdangerous" version = "2.2.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410, upload_time = "2024-04-16T21:28:15.614Z" } +sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410 } wheels = [ - { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234, upload_time = "2024-04-16T21:28:14.499Z" }, + { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234 }, ] [[package]] @@ -377,137 +376,137 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "markupsafe" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/af/92/b3130cbbf5591acf9ade8708c365f3238046ac7cb8ccba6e81abccb0ccff/jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb", size = 244674, upload_time = "2024-12-21T18:30:22.828Z" } +sdist = { url = "https://files.pythonhosted.org/packages/af/92/b3130cbbf5591acf9ade8708c365f3238046ac7cb8ccba6e81abccb0ccff/jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb", size = 244674 } wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/0f/2ba5fbcd631e3e88689309dbe978c5769e883e4b84ebfe7da30b43275c5a/jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb", size = 134596, upload_time = "2024-12-21T18:30:19.133Z" }, + { url = "https://files.pythonhosted.org/packages/bd/0f/2ba5fbcd631e3e88689309dbe978c5769e883e4b84ebfe7da30b43275c5a/jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb", size = 134596 }, ] [[package]] name = "jiter" version = "0.8.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f8/70/90bc7bd3932e651486861df5c8ffea4ca7c77d28e8532ddefe2abc561a53/jiter-0.8.2.tar.gz", hash = "sha256:cd73d3e740666d0e639f678adb176fad25c1bcbdae88d8d7b857e1783bb4212d", size = 163007, upload_time = "2024-12-09T18:11:08.649Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/70/90bc7bd3932e651486861df5c8ffea4ca7c77d28e8532ddefe2abc561a53/jiter-0.8.2.tar.gz", hash = "sha256:cd73d3e740666d0e639f678adb176fad25c1bcbdae88d8d7b857e1783bb4212d", size = 163007 } wheels = [ - { url = "https://files.pythonhosted.org/packages/f2/f3/8c11e0e87bd5934c414f9b1cfae3cbfd4a938d4669d57cb427e1c4d11a7f/jiter-0.8.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:ca8577f6a413abe29b079bc30f907894d7eb07a865c4df69475e868d73e71c7b", size = 303381, upload_time = "2024-12-09T18:09:00.301Z" }, - { url = "https://files.pythonhosted.org/packages/ea/28/4cd3f0bcbf40e946bc6a62a82c951afc386a25673d3d8d5ee461f1559bbe/jiter-0.8.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b25bd626bde7fb51534190c7e3cb97cee89ee76b76d7585580e22f34f5e3f393", size = 311718, upload_time = "2024-12-09T18:09:02.53Z" }, - { url = "https://files.pythonhosted.org/packages/0d/17/57acab00507e60bd954eaec0837d9d7b119b4117ff49b8a62f2b646f32ed/jiter-0.8.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5c826a221851a8dc028eb6d7d6429ba03184fa3c7e83ae01cd6d3bd1d4bd17d", size = 335465, upload_time = "2024-12-09T18:09:04.044Z" }, - { url = "https://files.pythonhosted.org/packages/74/b9/1a3ddd2bc95ae17c815b021521020f40c60b32137730126bada962ef32b4/jiter-0.8.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d35c864c2dff13dfd79fb070fc4fc6235d7b9b359efe340e1261deb21b9fcb66", size = 355570, upload_time = "2024-12-09T18:09:05.445Z" }, - { url = "https://files.pythonhosted.org/packages/78/69/6d29e2296a934199a7d0dde673ecccf98c9c8db44caf0248b3f2b65483cb/jiter-0.8.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f557c55bc2b7676e74d39d19bcb8775ca295c7a028246175d6a8b431e70835e5", size = 381383, upload_time = "2024-12-09T18:09:07.499Z" }, - { url = "https://files.pythonhosted.org/packages/22/d7/fbc4c3fb1bf65f9be22a32759b539f88e897aeb13fe84ab0266e4423487a/jiter-0.8.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:580ccf358539153db147e40751a0b41688a5ceb275e6f3e93d91c9467f42b2e3", size = 390454, upload_time = "2024-12-09T18:09:09.587Z" }, - { url = "https://files.pythonhosted.org/packages/4d/a0/3993cda2e267fe679b45d0bcc2cef0b4504b0aa810659cdae9737d6bace9/jiter-0.8.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:af102d3372e917cffce49b521e4c32c497515119dc7bd8a75665e90a718bbf08", size = 345039, upload_time = "2024-12-09T18:09:11.045Z" }, - { url = "https://files.pythonhosted.org/packages/b9/ef/69c18562b4c09ce88fab5df1dcaf643f6b1a8b970b65216e7221169b81c4/jiter-0.8.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cadcc978f82397d515bb2683fc0d50103acff2a180552654bb92d6045dec2c49", size = 376200, upload_time = "2024-12-09T18:09:13.104Z" }, - { url = "https://files.pythonhosted.org/packages/4d/17/0b5a8de46a6ab4d836f70934036278b49b8530c292b29dde3483326d4555/jiter-0.8.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:ba5bdf56969cad2019d4e8ffd3f879b5fdc792624129741d3d83fc832fef8c7d", size = 511158, upload_time = "2024-12-09T18:09:15.222Z" }, - { url = "https://files.pythonhosted.org/packages/6c/b2/c401a0a2554b36c9e6d6e4876b43790d75139cf3936f0222e675cbc23451/jiter-0.8.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:3b94a33a241bee9e34b8481cdcaa3d5c2116f575e0226e421bed3f7a6ea71cff", size = 503956, upload_time = "2024-12-09T18:09:16.595Z" }, - { url = "https://files.pythonhosted.org/packages/d4/02/a0291ed7d72c0ac130f172354ee3cf0b2556b69584de391463a8ee534f40/jiter-0.8.2-cp310-cp310-win32.whl", hash = "sha256:6e5337bf454abddd91bd048ce0dca5134056fc99ca0205258766db35d0a2ea43", size = 202846, upload_time = "2024-12-09T18:09:19.347Z" }, - { url = "https://files.pythonhosted.org/packages/ad/20/8c988831ae4bf437e29f1671e198fc99ba8fe49f2895f23789acad1d1811/jiter-0.8.2-cp310-cp310-win_amd64.whl", hash = "sha256:4a9220497ca0cb1fe94e3f334f65b9b5102a0b8147646118f020d8ce1de70105", size = 204414, upload_time = "2024-12-09T18:09:20.904Z" }, - { url = "https://files.pythonhosted.org/packages/cb/b0/c1a7caa7f9dc5f1f6cfa08722867790fe2d3645d6e7170ca280e6e52d163/jiter-0.8.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:2dd61c5afc88a4fda7d8b2cf03ae5947c6ac7516d32b7a15bf4b49569a5c076b", size = 303666, upload_time = "2024-12-09T18:09:23.145Z" }, - { url = "https://files.pythonhosted.org/packages/f5/97/0468bc9eeae43079aaa5feb9267964e496bf13133d469cfdc135498f8dd0/jiter-0.8.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a6c710d657c8d1d2adbbb5c0b0c6bfcec28fd35bd6b5f016395f9ac43e878a15", size = 311934, upload_time = "2024-12-09T18:09:25.098Z" }, - { url = "https://files.pythonhosted.org/packages/e5/69/64058e18263d9a5f1e10f90c436853616d5f047d997c37c7b2df11b085ec/jiter-0.8.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9584de0cd306072635fe4b89742bf26feae858a0683b399ad0c2509011b9dc0", size = 335506, upload_time = "2024-12-09T18:09:26.407Z" }, - { url = "https://files.pythonhosted.org/packages/9d/14/b747f9a77b8c0542141d77ca1e2a7523e854754af2c339ac89a8b66527d6/jiter-0.8.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5a90a923338531b7970abb063cfc087eebae6ef8ec8139762007188f6bc69a9f", size = 355849, upload_time = "2024-12-09T18:09:27.686Z" }, - { url = "https://files.pythonhosted.org/packages/53/e2/98a08161db7cc9d0e39bc385415890928ff09709034982f48eccfca40733/jiter-0.8.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d21974d246ed0181558087cd9f76e84e8321091ebfb3a93d4c341479a736f099", size = 381700, upload_time = "2024-12-09T18:09:28.989Z" }, - { url = "https://files.pythonhosted.org/packages/7a/38/1674672954d35bce3b1c9af99d5849f9256ac8f5b672e020ac7821581206/jiter-0.8.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:32475a42b2ea7b344069dc1e81445cfc00b9d0e3ca837f0523072432332e9f74", size = 389710, upload_time = "2024-12-09T18:09:30.565Z" }, - { url = "https://files.pythonhosted.org/packages/f8/9b/92f9da9a9e107d019bcf883cd9125fa1690079f323f5a9d5c6986eeec3c0/jiter-0.8.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b9931fd36ee513c26b5bf08c940b0ac875de175341cbdd4fa3be109f0492586", size = 345553, upload_time = "2024-12-09T18:09:32.735Z" }, - { url = "https://files.pythonhosted.org/packages/44/a6/6d030003394e9659cd0d7136bbeabd82e869849ceccddc34d40abbbbb269/jiter-0.8.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce0820f4a3a59ddced7fce696d86a096d5cc48d32a4183483a17671a61edfddc", size = 376388, upload_time = "2024-12-09T18:09:34.723Z" }, - { url = "https://files.pythonhosted.org/packages/ad/8d/87b09e648e4aca5f9af89e3ab3cfb93db2d1e633b2f2931ede8dabd9b19a/jiter-0.8.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:8ffc86ae5e3e6a93765d49d1ab47b6075a9c978a2b3b80f0f32628f39caa0c88", size = 511226, upload_time = "2024-12-09T18:09:36.13Z" }, - { url = "https://files.pythonhosted.org/packages/77/95/8008ebe4cdc82eac1c97864a8042ca7e383ed67e0ec17bfd03797045c727/jiter-0.8.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5127dc1abd809431172bc3fbe8168d6b90556a30bb10acd5ded41c3cfd6f43b6", size = 504134, upload_time = "2024-12-09T18:09:37.581Z" }, - { url = "https://files.pythonhosted.org/packages/26/0d/3056a74de13e8b2562e4d526de6dac2f65d91ace63a8234deb9284a1d24d/jiter-0.8.2-cp311-cp311-win32.whl", hash = "sha256:66227a2c7b575720c1871c8800d3a0122bb8ee94edb43a5685aa9aceb2782d44", size = 203103, upload_time = "2024-12-09T18:09:38.881Z" }, - { url = "https://files.pythonhosted.org/packages/4e/1e/7f96b798f356e531ffc0f53dd2f37185fac60fae4d6c612bbbd4639b90aa/jiter-0.8.2-cp311-cp311-win_amd64.whl", hash = "sha256:cde031d8413842a1e7501e9129b8e676e62a657f8ec8166e18a70d94d4682855", size = 206717, upload_time = "2024-12-09T18:09:41.064Z" }, - { url = "https://files.pythonhosted.org/packages/a1/17/c8747af8ea4e045f57d6cfd6fc180752cab9bc3de0e8a0c9ca4e8af333b1/jiter-0.8.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:e6ec2be506e7d6f9527dae9ff4b7f54e68ea44a0ef6b098256ddf895218a2f8f", size = 302027, upload_time = "2024-12-09T18:09:43.11Z" }, - { url = "https://files.pythonhosted.org/packages/3c/c1/6da849640cd35a41e91085723b76acc818d4b7d92b0b6e5111736ce1dd10/jiter-0.8.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76e324da7b5da060287c54f2fabd3db5f76468006c811831f051942bf68c9d44", size = 310326, upload_time = "2024-12-09T18:09:44.426Z" }, - { url = "https://files.pythonhosted.org/packages/06/99/a2bf660d8ccffee9ad7ed46b4f860d2108a148d0ea36043fd16f4dc37e94/jiter-0.8.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:180a8aea058f7535d1c84183c0362c710f4750bef66630c05f40c93c2b152a0f", size = 334242, upload_time = "2024-12-09T18:09:45.915Z" }, - { url = "https://files.pythonhosted.org/packages/a7/5f/cea1c17864828731f11427b9d1ab7f24764dbd9aaf4648a7f851164d2718/jiter-0.8.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:025337859077b41548bdcbabe38698bcd93cfe10b06ff66617a48ff92c9aec60", size = 356654, upload_time = "2024-12-09T18:09:47.619Z" }, - { url = "https://files.pythonhosted.org/packages/e9/13/62774b7e5e7f5d5043efe1d0f94ead66e6d0f894ae010adb56b3f788de71/jiter-0.8.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ecff0dc14f409599bbcafa7e470c00b80f17abc14d1405d38ab02e4b42e55b57", size = 379967, upload_time = "2024-12-09T18:09:49.987Z" }, - { url = "https://files.pythonhosted.org/packages/ec/fb/096b34c553bb0bd3f2289d5013dcad6074948b8d55212aa13a10d44c5326/jiter-0.8.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ffd9fee7d0775ebaba131f7ca2e2d83839a62ad65e8e02fe2bd8fc975cedeb9e", size = 389252, upload_time = "2024-12-09T18:09:51.329Z" }, - { url = "https://files.pythonhosted.org/packages/17/61/beea645c0bf398ced8b199e377b61eb999d8e46e053bb285c91c3d3eaab0/jiter-0.8.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14601dcac4889e0a1c75ccf6a0e4baf70dbc75041e51bcf8d0e9274519df6887", size = 345490, upload_time = "2024-12-09T18:09:52.646Z" }, - { url = "https://files.pythonhosted.org/packages/d5/df/834aa17ad5dcc3cf0118821da0a0cf1589ea7db9832589278553640366bc/jiter-0.8.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:92249669925bc1c54fcd2ec73f70f2c1d6a817928480ee1c65af5f6b81cdf12d", size = 376991, upload_time = "2024-12-09T18:09:53.972Z" }, - { url = "https://files.pythonhosted.org/packages/67/80/87d140399d382fb4ea5b3d56e7ecaa4efdca17cd7411ff904c1517855314/jiter-0.8.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e725edd0929fa79f8349ab4ec7f81c714df51dc4e991539a578e5018fa4a7152", size = 510822, upload_time = "2024-12-09T18:09:55.439Z" }, - { url = "https://files.pythonhosted.org/packages/5c/37/3394bb47bac1ad2cb0465601f86828a0518d07828a650722e55268cdb7e6/jiter-0.8.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bf55846c7b7a680eebaf9c3c48d630e1bf51bdf76c68a5f654b8524335b0ad29", size = 503730, upload_time = "2024-12-09T18:09:59.494Z" }, - { url = "https://files.pythonhosted.org/packages/f9/e2/253fc1fa59103bb4e3aa0665d6ceb1818df1cd7bf3eb492c4dad229b1cd4/jiter-0.8.2-cp312-cp312-win32.whl", hash = "sha256:7efe4853ecd3d6110301665a5178b9856be7e2a9485f49d91aa4d737ad2ae49e", size = 203375, upload_time = "2024-12-09T18:10:00.814Z" }, - { url = "https://files.pythonhosted.org/packages/41/69/6d4bbe66b3b3b4507e47aa1dd5d075919ad242b4b1115b3f80eecd443687/jiter-0.8.2-cp312-cp312-win_amd64.whl", hash = "sha256:83c0efd80b29695058d0fd2fa8a556490dbce9804eac3e281f373bbc99045f6c", size = 204740, upload_time = "2024-12-09T18:10:02.146Z" }, - { url = "https://files.pythonhosted.org/packages/6c/b0/bfa1f6f2c956b948802ef5a021281978bf53b7a6ca54bb126fd88a5d014e/jiter-0.8.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:ca1f08b8e43dc3bd0594c992fb1fd2f7ce87f7bf0d44358198d6da8034afdf84", size = 301190, upload_time = "2024-12-09T18:10:03.463Z" }, - { url = "https://files.pythonhosted.org/packages/a4/8f/396ddb4e292b5ea57e45ade5dc48229556b9044bad29a3b4b2dddeaedd52/jiter-0.8.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5672a86d55416ccd214c778efccf3266b84f87b89063b582167d803246354be4", size = 309334, upload_time = "2024-12-09T18:10:05.774Z" }, - { url = "https://files.pythonhosted.org/packages/7f/68/805978f2f446fa6362ba0cc2e4489b945695940656edd844e110a61c98f8/jiter-0.8.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58dc9bc9767a1101f4e5e22db1b652161a225874d66f0e5cb8e2c7d1c438b587", size = 333918, upload_time = "2024-12-09T18:10:07.158Z" }, - { url = "https://files.pythonhosted.org/packages/b3/99/0f71f7be667c33403fa9706e5b50583ae5106d96fab997fa7e2f38ee8347/jiter-0.8.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:37b2998606d6dadbb5ccda959a33d6a5e853252d921fec1792fc902351bb4e2c", size = 356057, upload_time = "2024-12-09T18:10:09.341Z" }, - { url = "https://files.pythonhosted.org/packages/8d/50/a82796e421a22b699ee4d2ce527e5bcb29471a2351cbdc931819d941a167/jiter-0.8.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ab9a87f3784eb0e098f84a32670cfe4a79cb6512fd8f42ae3d0709f06405d18", size = 379790, upload_time = "2024-12-09T18:10:10.702Z" }, - { url = "https://files.pythonhosted.org/packages/3c/31/10fb012b00f6d83342ca9e2c9618869ab449f1aa78c8f1b2193a6b49647c/jiter-0.8.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:79aec8172b9e3c6d05fd4b219d5de1ac616bd8da934107325a6c0d0e866a21b6", size = 388285, upload_time = "2024-12-09T18:10:12.721Z" }, - { url = "https://files.pythonhosted.org/packages/c8/81/f15ebf7de57be488aa22944bf4274962aca8092e4f7817f92ffa50d3ee46/jiter-0.8.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:711e408732d4e9a0208008e5892c2966b485c783cd2d9a681f3eb147cf36c7ef", size = 344764, upload_time = "2024-12-09T18:10:14.075Z" }, - { url = "https://files.pythonhosted.org/packages/b3/e8/0cae550d72b48829ba653eb348cdc25f3f06f8a62363723702ec18e7be9c/jiter-0.8.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:653cf462db4e8c41995e33d865965e79641ef45369d8a11f54cd30888b7e6ff1", size = 376620, upload_time = "2024-12-09T18:10:15.487Z" }, - { url = "https://files.pythonhosted.org/packages/b8/50/e5478ff9d82534a944c03b63bc217c5f37019d4a34d288db0f079b13c10b/jiter-0.8.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:9c63eaef32b7bebac8ebebf4dabebdbc6769a09c127294db6babee38e9f405b9", size = 510402, upload_time = "2024-12-09T18:10:17.499Z" }, - { url = "https://files.pythonhosted.org/packages/8e/1e/3de48bbebbc8f7025bd454cedc8c62378c0e32dd483dece5f4a814a5cb55/jiter-0.8.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:eb21aaa9a200d0a80dacc7a81038d2e476ffe473ffdd9c91eb745d623561de05", size = 503018, upload_time = "2024-12-09T18:10:18.92Z" }, - { url = "https://files.pythonhosted.org/packages/d5/cd/d5a5501d72a11fe3e5fd65c78c884e5164eefe80077680533919be22d3a3/jiter-0.8.2-cp313-cp313-win32.whl", hash = "sha256:789361ed945d8d42850f919342a8665d2dc79e7e44ca1c97cc786966a21f627a", size = 203190, upload_time = "2024-12-09T18:10:20.801Z" }, - { url = "https://files.pythonhosted.org/packages/51/bf/e5ca301245ba951447e3ad677a02a64a8845b185de2603dabd83e1e4b9c6/jiter-0.8.2-cp313-cp313-win_amd64.whl", hash = "sha256:ab7f43235d71e03b941c1630f4b6e3055d46b6cb8728a17663eaac9d8e83a865", size = 203551, upload_time = "2024-12-09T18:10:22.822Z" }, - { url = "https://files.pythonhosted.org/packages/2f/3c/71a491952c37b87d127790dd7a0b1ebea0514c6b6ad30085b16bbe00aee6/jiter-0.8.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b426f72cd77da3fec300ed3bc990895e2dd6b49e3bfe6c438592a3ba660e41ca", size = 308347, upload_time = "2024-12-09T18:10:24.139Z" }, - { url = "https://files.pythonhosted.org/packages/a0/4c/c02408042e6a7605ec063daed138e07b982fdb98467deaaf1c90950cf2c6/jiter-0.8.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2dd880785088ff2ad21ffee205e58a8c1ddabc63612444ae41e5e4b321b39c0", size = 342875, upload_time = "2024-12-09T18:10:25.553Z" }, - { url = "https://files.pythonhosted.org/packages/91/61/c80ef80ed8a0a21158e289ef70dac01e351d929a1c30cb0f49be60772547/jiter-0.8.2-cp313-cp313t-win_amd64.whl", hash = "sha256:3ac9f578c46f22405ff7f8b1f5848fb753cc4b8377fbec8470a7dc3997ca7566", size = 202374, upload_time = "2024-12-09T18:10:26.958Z" }, - { url = "https://files.pythonhosted.org/packages/c9/b2/ed7fbabd21c3cf556d6ea849cee35c74f13a509e668baad8323091e2867e/jiter-0.8.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:e41e75344acef3fc59ba4765df29f107f309ca9e8eace5baacabd9217e52a5ee", size = 304502, upload_time = "2024-12-09T18:10:47.204Z" }, - { url = "https://files.pythonhosted.org/packages/75/6e/1386857ac9165c1e9c71031566e7884d8a4f63724ce29ad1ace5bfe1351c/jiter-0.8.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7f22b16b35d5c1df9dfd58843ab2cd25e6bf15191f5a236bed177afade507bfc", size = 300982, upload_time = "2024-12-09T18:10:48.567Z" }, - { url = "https://files.pythonhosted.org/packages/56/4c/b413977c20bbb359b4d6c91d04f7f36fc525af0b7778119815477fc97242/jiter-0.8.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7200b8f7619d36aa51c803fd52020a2dfbea36ffec1b5e22cab11fd34d95a6d", size = 335344, upload_time = "2024-12-09T18:10:49.913Z" }, - { url = "https://files.pythonhosted.org/packages/b0/59/51b080519938192edd33b4e8d48adb7e9bf9e0d699ec8b91119b9269fc75/jiter-0.8.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:70bf4c43652cc294040dbb62256c83c8718370c8b93dd93d934b9a7bf6c4f53c", size = 356298, upload_time = "2024-12-09T18:10:51.482Z" }, - { url = "https://files.pythonhosted.org/packages/72/bb/828db5ea406916d7b2232be31393f782b0f71bcb0b128750c4a028157565/jiter-0.8.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f9d471356dc16f84ed48768b8ee79f29514295c7295cb41e1133ec0b2b8d637d", size = 381703, upload_time = "2024-12-09T18:10:53.405Z" }, - { url = "https://files.pythonhosted.org/packages/c0/88/45d33a8728733e161e9783c54d8ecca0fc4c1aa74b1cebea1d97917eddc3/jiter-0.8.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:859e8eb3507894093d01929e12e267f83b1d5f6221099d3ec976f0c995cb6bd9", size = 391281, upload_time = "2024-12-09T18:10:55.59Z" }, - { url = "https://files.pythonhosted.org/packages/45/3e/142712e0f45c28ad8a678dc8732a78294ce5a36fc694141f772bb827a8f2/jiter-0.8.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaa58399c01db555346647a907b4ef6d4f584b123943be6ed5588c3f2359c9f4", size = 345553, upload_time = "2024-12-09T18:10:57.401Z" }, - { url = "https://files.pythonhosted.org/packages/36/42/9b463b59fd22687b6da1afcad6c9adc870464a808208651de73f1dbeda09/jiter-0.8.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8f2d5ed877f089862f4c7aacf3a542627c1496f972a34d0474ce85ee7d939c27", size = 377063, upload_time = "2024-12-09T18:10:58.855Z" }, - { url = "https://files.pythonhosted.org/packages/83/b3/44b1f5cd2e4eb15757eec341b25399da4c90515bb881ef6636b50a8c08a5/jiter-0.8.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:03c9df035d4f8d647f8c210ddc2ae0728387275340668fb30d2421e17d9a0841", size = 512543, upload_time = "2024-12-09T18:11:00.271Z" }, - { url = "https://files.pythonhosted.org/packages/46/4e/c695c803aa2b668c057b2dea1cdd7a884d1a819ce610cec0be9666210bfd/jiter-0.8.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8bd2a824d08d8977bb2794ea2682f898ad3d8837932e3a74937e93d62ecbb637", size = 505141, upload_time = "2024-12-09T18:11:02.134Z" }, - { url = "https://files.pythonhosted.org/packages/8e/51/e805b837db056f872db0b7a7a3610b7d764392be696dbe47afa0bea05bf2/jiter-0.8.2-cp39-cp39-win32.whl", hash = "sha256:ca29b6371ebc40e496995c94b988a101b9fbbed48a51190a4461fcb0a68b4a36", size = 203529, upload_time = "2024-12-09T18:11:04.227Z" }, - { url = "https://files.pythonhosted.org/packages/32/b7/a3cde72c644fd1caf9da07fb38cf2c130f43484d8f91011940b7c4f42c8f/jiter-0.8.2-cp39-cp39-win_amd64.whl", hash = "sha256:1c0dfbd1be3cbefc7510102370d86e35d1d53e5a93d48519688b1bf0f761160a", size = 207527, upload_time = "2024-12-09T18:11:06.549Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f3/8c11e0e87bd5934c414f9b1cfae3cbfd4a938d4669d57cb427e1c4d11a7f/jiter-0.8.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:ca8577f6a413abe29b079bc30f907894d7eb07a865c4df69475e868d73e71c7b", size = 303381 }, + { url = "https://files.pythonhosted.org/packages/ea/28/4cd3f0bcbf40e946bc6a62a82c951afc386a25673d3d8d5ee461f1559bbe/jiter-0.8.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b25bd626bde7fb51534190c7e3cb97cee89ee76b76d7585580e22f34f5e3f393", size = 311718 }, + { url = "https://files.pythonhosted.org/packages/0d/17/57acab00507e60bd954eaec0837d9d7b119b4117ff49b8a62f2b646f32ed/jiter-0.8.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5c826a221851a8dc028eb6d7d6429ba03184fa3c7e83ae01cd6d3bd1d4bd17d", size = 335465 }, + { url = "https://files.pythonhosted.org/packages/74/b9/1a3ddd2bc95ae17c815b021521020f40c60b32137730126bada962ef32b4/jiter-0.8.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d35c864c2dff13dfd79fb070fc4fc6235d7b9b359efe340e1261deb21b9fcb66", size = 355570 }, + { url = "https://files.pythonhosted.org/packages/78/69/6d29e2296a934199a7d0dde673ecccf98c9c8db44caf0248b3f2b65483cb/jiter-0.8.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f557c55bc2b7676e74d39d19bcb8775ca295c7a028246175d6a8b431e70835e5", size = 381383 }, + { url = "https://files.pythonhosted.org/packages/22/d7/fbc4c3fb1bf65f9be22a32759b539f88e897aeb13fe84ab0266e4423487a/jiter-0.8.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:580ccf358539153db147e40751a0b41688a5ceb275e6f3e93d91c9467f42b2e3", size = 390454 }, + { url = "https://files.pythonhosted.org/packages/4d/a0/3993cda2e267fe679b45d0bcc2cef0b4504b0aa810659cdae9737d6bace9/jiter-0.8.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:af102d3372e917cffce49b521e4c32c497515119dc7bd8a75665e90a718bbf08", size = 345039 }, + { url = "https://files.pythonhosted.org/packages/b9/ef/69c18562b4c09ce88fab5df1dcaf643f6b1a8b970b65216e7221169b81c4/jiter-0.8.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cadcc978f82397d515bb2683fc0d50103acff2a180552654bb92d6045dec2c49", size = 376200 }, + { url = "https://files.pythonhosted.org/packages/4d/17/0b5a8de46a6ab4d836f70934036278b49b8530c292b29dde3483326d4555/jiter-0.8.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:ba5bdf56969cad2019d4e8ffd3f879b5fdc792624129741d3d83fc832fef8c7d", size = 511158 }, + { url = "https://files.pythonhosted.org/packages/6c/b2/c401a0a2554b36c9e6d6e4876b43790d75139cf3936f0222e675cbc23451/jiter-0.8.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:3b94a33a241bee9e34b8481cdcaa3d5c2116f575e0226e421bed3f7a6ea71cff", size = 503956 }, + { url = "https://files.pythonhosted.org/packages/d4/02/a0291ed7d72c0ac130f172354ee3cf0b2556b69584de391463a8ee534f40/jiter-0.8.2-cp310-cp310-win32.whl", hash = "sha256:6e5337bf454abddd91bd048ce0dca5134056fc99ca0205258766db35d0a2ea43", size = 202846 }, + { url = "https://files.pythonhosted.org/packages/ad/20/8c988831ae4bf437e29f1671e198fc99ba8fe49f2895f23789acad1d1811/jiter-0.8.2-cp310-cp310-win_amd64.whl", hash = "sha256:4a9220497ca0cb1fe94e3f334f65b9b5102a0b8147646118f020d8ce1de70105", size = 204414 }, + { url = "https://files.pythonhosted.org/packages/cb/b0/c1a7caa7f9dc5f1f6cfa08722867790fe2d3645d6e7170ca280e6e52d163/jiter-0.8.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:2dd61c5afc88a4fda7d8b2cf03ae5947c6ac7516d32b7a15bf4b49569a5c076b", size = 303666 }, + { url = "https://files.pythonhosted.org/packages/f5/97/0468bc9eeae43079aaa5feb9267964e496bf13133d469cfdc135498f8dd0/jiter-0.8.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a6c710d657c8d1d2adbbb5c0b0c6bfcec28fd35bd6b5f016395f9ac43e878a15", size = 311934 }, + { url = "https://files.pythonhosted.org/packages/e5/69/64058e18263d9a5f1e10f90c436853616d5f047d997c37c7b2df11b085ec/jiter-0.8.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9584de0cd306072635fe4b89742bf26feae858a0683b399ad0c2509011b9dc0", size = 335506 }, + { url = "https://files.pythonhosted.org/packages/9d/14/b747f9a77b8c0542141d77ca1e2a7523e854754af2c339ac89a8b66527d6/jiter-0.8.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5a90a923338531b7970abb063cfc087eebae6ef8ec8139762007188f6bc69a9f", size = 355849 }, + { url = "https://files.pythonhosted.org/packages/53/e2/98a08161db7cc9d0e39bc385415890928ff09709034982f48eccfca40733/jiter-0.8.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d21974d246ed0181558087cd9f76e84e8321091ebfb3a93d4c341479a736f099", size = 381700 }, + { url = "https://files.pythonhosted.org/packages/7a/38/1674672954d35bce3b1c9af99d5849f9256ac8f5b672e020ac7821581206/jiter-0.8.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:32475a42b2ea7b344069dc1e81445cfc00b9d0e3ca837f0523072432332e9f74", size = 389710 }, + { url = "https://files.pythonhosted.org/packages/f8/9b/92f9da9a9e107d019bcf883cd9125fa1690079f323f5a9d5c6986eeec3c0/jiter-0.8.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b9931fd36ee513c26b5bf08c940b0ac875de175341cbdd4fa3be109f0492586", size = 345553 }, + { url = "https://files.pythonhosted.org/packages/44/a6/6d030003394e9659cd0d7136bbeabd82e869849ceccddc34d40abbbbb269/jiter-0.8.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ce0820f4a3a59ddced7fce696d86a096d5cc48d32a4183483a17671a61edfddc", size = 376388 }, + { url = "https://files.pythonhosted.org/packages/ad/8d/87b09e648e4aca5f9af89e3ab3cfb93db2d1e633b2f2931ede8dabd9b19a/jiter-0.8.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:8ffc86ae5e3e6a93765d49d1ab47b6075a9c978a2b3b80f0f32628f39caa0c88", size = 511226 }, + { url = "https://files.pythonhosted.org/packages/77/95/8008ebe4cdc82eac1c97864a8042ca7e383ed67e0ec17bfd03797045c727/jiter-0.8.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5127dc1abd809431172bc3fbe8168d6b90556a30bb10acd5ded41c3cfd6f43b6", size = 504134 }, + { url = "https://files.pythonhosted.org/packages/26/0d/3056a74de13e8b2562e4d526de6dac2f65d91ace63a8234deb9284a1d24d/jiter-0.8.2-cp311-cp311-win32.whl", hash = "sha256:66227a2c7b575720c1871c8800d3a0122bb8ee94edb43a5685aa9aceb2782d44", size = 203103 }, + { url = "https://files.pythonhosted.org/packages/4e/1e/7f96b798f356e531ffc0f53dd2f37185fac60fae4d6c612bbbd4639b90aa/jiter-0.8.2-cp311-cp311-win_amd64.whl", hash = "sha256:cde031d8413842a1e7501e9129b8e676e62a657f8ec8166e18a70d94d4682855", size = 206717 }, + { url = "https://files.pythonhosted.org/packages/a1/17/c8747af8ea4e045f57d6cfd6fc180752cab9bc3de0e8a0c9ca4e8af333b1/jiter-0.8.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:e6ec2be506e7d6f9527dae9ff4b7f54e68ea44a0ef6b098256ddf895218a2f8f", size = 302027 }, + { url = "https://files.pythonhosted.org/packages/3c/c1/6da849640cd35a41e91085723b76acc818d4b7d92b0b6e5111736ce1dd10/jiter-0.8.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76e324da7b5da060287c54f2fabd3db5f76468006c811831f051942bf68c9d44", size = 310326 }, + { url = "https://files.pythonhosted.org/packages/06/99/a2bf660d8ccffee9ad7ed46b4f860d2108a148d0ea36043fd16f4dc37e94/jiter-0.8.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:180a8aea058f7535d1c84183c0362c710f4750bef66630c05f40c93c2b152a0f", size = 334242 }, + { url = "https://files.pythonhosted.org/packages/a7/5f/cea1c17864828731f11427b9d1ab7f24764dbd9aaf4648a7f851164d2718/jiter-0.8.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:025337859077b41548bdcbabe38698bcd93cfe10b06ff66617a48ff92c9aec60", size = 356654 }, + { url = "https://files.pythonhosted.org/packages/e9/13/62774b7e5e7f5d5043efe1d0f94ead66e6d0f894ae010adb56b3f788de71/jiter-0.8.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ecff0dc14f409599bbcafa7e470c00b80f17abc14d1405d38ab02e4b42e55b57", size = 379967 }, + { url = "https://files.pythonhosted.org/packages/ec/fb/096b34c553bb0bd3f2289d5013dcad6074948b8d55212aa13a10d44c5326/jiter-0.8.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ffd9fee7d0775ebaba131f7ca2e2d83839a62ad65e8e02fe2bd8fc975cedeb9e", size = 389252 }, + { url = "https://files.pythonhosted.org/packages/17/61/beea645c0bf398ced8b199e377b61eb999d8e46e053bb285c91c3d3eaab0/jiter-0.8.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14601dcac4889e0a1c75ccf6a0e4baf70dbc75041e51bcf8d0e9274519df6887", size = 345490 }, + { url = "https://files.pythonhosted.org/packages/d5/df/834aa17ad5dcc3cf0118821da0a0cf1589ea7db9832589278553640366bc/jiter-0.8.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:92249669925bc1c54fcd2ec73f70f2c1d6a817928480ee1c65af5f6b81cdf12d", size = 376991 }, + { url = "https://files.pythonhosted.org/packages/67/80/87d140399d382fb4ea5b3d56e7ecaa4efdca17cd7411ff904c1517855314/jiter-0.8.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e725edd0929fa79f8349ab4ec7f81c714df51dc4e991539a578e5018fa4a7152", size = 510822 }, + { url = "https://files.pythonhosted.org/packages/5c/37/3394bb47bac1ad2cb0465601f86828a0518d07828a650722e55268cdb7e6/jiter-0.8.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bf55846c7b7a680eebaf9c3c48d630e1bf51bdf76c68a5f654b8524335b0ad29", size = 503730 }, + { url = "https://files.pythonhosted.org/packages/f9/e2/253fc1fa59103bb4e3aa0665d6ceb1818df1cd7bf3eb492c4dad229b1cd4/jiter-0.8.2-cp312-cp312-win32.whl", hash = "sha256:7efe4853ecd3d6110301665a5178b9856be7e2a9485f49d91aa4d737ad2ae49e", size = 203375 }, + { url = "https://files.pythonhosted.org/packages/41/69/6d4bbe66b3b3b4507e47aa1dd5d075919ad242b4b1115b3f80eecd443687/jiter-0.8.2-cp312-cp312-win_amd64.whl", hash = "sha256:83c0efd80b29695058d0fd2fa8a556490dbce9804eac3e281f373bbc99045f6c", size = 204740 }, + { url = "https://files.pythonhosted.org/packages/6c/b0/bfa1f6f2c956b948802ef5a021281978bf53b7a6ca54bb126fd88a5d014e/jiter-0.8.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:ca1f08b8e43dc3bd0594c992fb1fd2f7ce87f7bf0d44358198d6da8034afdf84", size = 301190 }, + { url = "https://files.pythonhosted.org/packages/a4/8f/396ddb4e292b5ea57e45ade5dc48229556b9044bad29a3b4b2dddeaedd52/jiter-0.8.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5672a86d55416ccd214c778efccf3266b84f87b89063b582167d803246354be4", size = 309334 }, + { url = "https://files.pythonhosted.org/packages/7f/68/805978f2f446fa6362ba0cc2e4489b945695940656edd844e110a61c98f8/jiter-0.8.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58dc9bc9767a1101f4e5e22db1b652161a225874d66f0e5cb8e2c7d1c438b587", size = 333918 }, + { url = "https://files.pythonhosted.org/packages/b3/99/0f71f7be667c33403fa9706e5b50583ae5106d96fab997fa7e2f38ee8347/jiter-0.8.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:37b2998606d6dadbb5ccda959a33d6a5e853252d921fec1792fc902351bb4e2c", size = 356057 }, + { url = "https://files.pythonhosted.org/packages/8d/50/a82796e421a22b699ee4d2ce527e5bcb29471a2351cbdc931819d941a167/jiter-0.8.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ab9a87f3784eb0e098f84a32670cfe4a79cb6512fd8f42ae3d0709f06405d18", size = 379790 }, + { url = "https://files.pythonhosted.org/packages/3c/31/10fb012b00f6d83342ca9e2c9618869ab449f1aa78c8f1b2193a6b49647c/jiter-0.8.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:79aec8172b9e3c6d05fd4b219d5de1ac616bd8da934107325a6c0d0e866a21b6", size = 388285 }, + { url = "https://files.pythonhosted.org/packages/c8/81/f15ebf7de57be488aa22944bf4274962aca8092e4f7817f92ffa50d3ee46/jiter-0.8.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:711e408732d4e9a0208008e5892c2966b485c783cd2d9a681f3eb147cf36c7ef", size = 344764 }, + { url = "https://files.pythonhosted.org/packages/b3/e8/0cae550d72b48829ba653eb348cdc25f3f06f8a62363723702ec18e7be9c/jiter-0.8.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:653cf462db4e8c41995e33d865965e79641ef45369d8a11f54cd30888b7e6ff1", size = 376620 }, + { url = "https://files.pythonhosted.org/packages/b8/50/e5478ff9d82534a944c03b63bc217c5f37019d4a34d288db0f079b13c10b/jiter-0.8.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:9c63eaef32b7bebac8ebebf4dabebdbc6769a09c127294db6babee38e9f405b9", size = 510402 }, + { url = "https://files.pythonhosted.org/packages/8e/1e/3de48bbebbc8f7025bd454cedc8c62378c0e32dd483dece5f4a814a5cb55/jiter-0.8.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:eb21aaa9a200d0a80dacc7a81038d2e476ffe473ffdd9c91eb745d623561de05", size = 503018 }, + { url = "https://files.pythonhosted.org/packages/d5/cd/d5a5501d72a11fe3e5fd65c78c884e5164eefe80077680533919be22d3a3/jiter-0.8.2-cp313-cp313-win32.whl", hash = "sha256:789361ed945d8d42850f919342a8665d2dc79e7e44ca1c97cc786966a21f627a", size = 203190 }, + { url = "https://files.pythonhosted.org/packages/51/bf/e5ca301245ba951447e3ad677a02a64a8845b185de2603dabd83e1e4b9c6/jiter-0.8.2-cp313-cp313-win_amd64.whl", hash = "sha256:ab7f43235d71e03b941c1630f4b6e3055d46b6cb8728a17663eaac9d8e83a865", size = 203551 }, + { url = "https://files.pythonhosted.org/packages/2f/3c/71a491952c37b87d127790dd7a0b1ebea0514c6b6ad30085b16bbe00aee6/jiter-0.8.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b426f72cd77da3fec300ed3bc990895e2dd6b49e3bfe6c438592a3ba660e41ca", size = 308347 }, + { url = "https://files.pythonhosted.org/packages/a0/4c/c02408042e6a7605ec063daed138e07b982fdb98467deaaf1c90950cf2c6/jiter-0.8.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2dd880785088ff2ad21ffee205e58a8c1ddabc63612444ae41e5e4b321b39c0", size = 342875 }, + { url = "https://files.pythonhosted.org/packages/91/61/c80ef80ed8a0a21158e289ef70dac01e351d929a1c30cb0f49be60772547/jiter-0.8.2-cp313-cp313t-win_amd64.whl", hash = "sha256:3ac9f578c46f22405ff7f8b1f5848fb753cc4b8377fbec8470a7dc3997ca7566", size = 202374 }, + { url = "https://files.pythonhosted.org/packages/c9/b2/ed7fbabd21c3cf556d6ea849cee35c74f13a509e668baad8323091e2867e/jiter-0.8.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:e41e75344acef3fc59ba4765df29f107f309ca9e8eace5baacabd9217e52a5ee", size = 304502 }, + { url = "https://files.pythonhosted.org/packages/75/6e/1386857ac9165c1e9c71031566e7884d8a4f63724ce29ad1ace5bfe1351c/jiter-0.8.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7f22b16b35d5c1df9dfd58843ab2cd25e6bf15191f5a236bed177afade507bfc", size = 300982 }, + { url = "https://files.pythonhosted.org/packages/56/4c/b413977c20bbb359b4d6c91d04f7f36fc525af0b7778119815477fc97242/jiter-0.8.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7200b8f7619d36aa51c803fd52020a2dfbea36ffec1b5e22cab11fd34d95a6d", size = 335344 }, + { url = "https://files.pythonhosted.org/packages/b0/59/51b080519938192edd33b4e8d48adb7e9bf9e0d699ec8b91119b9269fc75/jiter-0.8.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:70bf4c43652cc294040dbb62256c83c8718370c8b93dd93d934b9a7bf6c4f53c", size = 356298 }, + { url = "https://files.pythonhosted.org/packages/72/bb/828db5ea406916d7b2232be31393f782b0f71bcb0b128750c4a028157565/jiter-0.8.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f9d471356dc16f84ed48768b8ee79f29514295c7295cb41e1133ec0b2b8d637d", size = 381703 }, + { url = "https://files.pythonhosted.org/packages/c0/88/45d33a8728733e161e9783c54d8ecca0fc4c1aa74b1cebea1d97917eddc3/jiter-0.8.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:859e8eb3507894093d01929e12e267f83b1d5f6221099d3ec976f0c995cb6bd9", size = 391281 }, + { url = "https://files.pythonhosted.org/packages/45/3e/142712e0f45c28ad8a678dc8732a78294ce5a36fc694141f772bb827a8f2/jiter-0.8.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaa58399c01db555346647a907b4ef6d4f584b123943be6ed5588c3f2359c9f4", size = 345553 }, + { url = "https://files.pythonhosted.org/packages/36/42/9b463b59fd22687b6da1afcad6c9adc870464a808208651de73f1dbeda09/jiter-0.8.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8f2d5ed877f089862f4c7aacf3a542627c1496f972a34d0474ce85ee7d939c27", size = 377063 }, + { url = "https://files.pythonhosted.org/packages/83/b3/44b1f5cd2e4eb15757eec341b25399da4c90515bb881ef6636b50a8c08a5/jiter-0.8.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:03c9df035d4f8d647f8c210ddc2ae0728387275340668fb30d2421e17d9a0841", size = 512543 }, + { url = "https://files.pythonhosted.org/packages/46/4e/c695c803aa2b668c057b2dea1cdd7a884d1a819ce610cec0be9666210bfd/jiter-0.8.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8bd2a824d08d8977bb2794ea2682f898ad3d8837932e3a74937e93d62ecbb637", size = 505141 }, + { url = "https://files.pythonhosted.org/packages/8e/51/e805b837db056f872db0b7a7a3610b7d764392be696dbe47afa0bea05bf2/jiter-0.8.2-cp39-cp39-win32.whl", hash = "sha256:ca29b6371ebc40e496995c94b988a101b9fbbed48a51190a4461fcb0a68b4a36", size = 203529 }, + { url = "https://files.pythonhosted.org/packages/32/b7/a3cde72c644fd1caf9da07fb38cf2c130f43484d8f91011940b7c4f42c8f/jiter-0.8.2-cp39-cp39-win_amd64.whl", hash = "sha256:1c0dfbd1be3cbefc7510102370d86e35d1d53e5a93d48519688b1bf0f761160a", size = 207527 }, ] [[package]] name = "jmespath" version = "1.0.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843, upload_time = "2022-06-17T18:00:12.224Z" } +sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843 } wheels = [ - { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload_time = "2022-06-17T18:00:10.251Z" }, + { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256 }, ] [[package]] name = "markupsafe" version = "2.1.5" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/87/5b/aae44c6655f3801e81aa3eef09dbbf012431987ba564d7231722f68df02d/MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b", size = 19384, upload_time = "2024-02-02T16:31:22.863Z" } +sdist = { url = "https://files.pythonhosted.org/packages/87/5b/aae44c6655f3801e81aa3eef09dbbf012431987ba564d7231722f68df02d/MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b", size = 19384 } wheels = [ - { url = "https://files.pythonhosted.org/packages/e4/54/ad5eb37bf9d51800010a74e4665425831a9db4e7c4e0fde4352e391e808e/MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc", size = 18206, upload_time = "2024-02-02T16:30:04.105Z" }, - { url = "https://files.pythonhosted.org/packages/6a/4a/a4d49415e600bacae038c67f9fecc1d5433b9d3c71a4de6f33537b89654c/MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5", size = 14079, upload_time = "2024-02-02T16:30:06.5Z" }, - { url = "https://files.pythonhosted.org/packages/0a/7b/85681ae3c33c385b10ac0f8dd025c30af83c78cec1c37a6aa3b55e67f5ec/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46", size = 26620, upload_time = "2024-02-02T16:30:08.31Z" }, - { url = "https://files.pythonhosted.org/packages/7c/52/2b1b570f6b8b803cef5ac28fdf78c0da318916c7d2fe9402a84d591b394c/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f", size = 25818, upload_time = "2024-02-02T16:30:09.577Z" }, - { url = "https://files.pythonhosted.org/packages/29/fe/a36ba8c7ca55621620b2d7c585313efd10729e63ef81e4e61f52330da781/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900", size = 25493, upload_time = "2024-02-02T16:30:11.488Z" }, - { url = "https://files.pythonhosted.org/packages/60/ae/9c60231cdfda003434e8bd27282b1f4e197ad5a710c14bee8bea8a9ca4f0/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff", size = 30630, upload_time = "2024-02-02T16:30:13.144Z" }, - { url = "https://files.pythonhosted.org/packages/65/dc/1510be4d179869f5dafe071aecb3f1f41b45d37c02329dfba01ff59e5ac5/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad", size = 29745, upload_time = "2024-02-02T16:30:14.222Z" }, - { url = "https://files.pythonhosted.org/packages/30/39/8d845dd7d0b0613d86e0ef89549bfb5f61ed781f59af45fc96496e897f3a/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd", size = 30021, upload_time = "2024-02-02T16:30:16.032Z" }, - { url = "https://files.pythonhosted.org/packages/c7/5c/356a6f62e4f3c5fbf2602b4771376af22a3b16efa74eb8716fb4e328e01e/MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4", size = 16659, upload_time = "2024-02-02T16:30:17.079Z" }, - { url = "https://files.pythonhosted.org/packages/69/48/acbf292615c65f0604a0c6fc402ce6d8c991276e16c80c46a8f758fbd30c/MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5", size = 17213, upload_time = "2024-02-02T16:30:18.251Z" }, - { url = "https://files.pythonhosted.org/packages/11/e7/291e55127bb2ae67c64d66cef01432b5933859dfb7d6949daa721b89d0b3/MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f", size = 18219, upload_time = "2024-02-02T16:30:19.988Z" }, - { url = "https://files.pythonhosted.org/packages/6b/cb/aed7a284c00dfa7c0682d14df85ad4955a350a21d2e3b06d8240497359bf/MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2", size = 14098, upload_time = "2024-02-02T16:30:21.063Z" }, - { url = "https://files.pythonhosted.org/packages/1c/cf/35fe557e53709e93feb65575c93927942087e9b97213eabc3fe9d5b25a55/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced", size = 29014, upload_time = "2024-02-02T16:30:22.926Z" }, - { url = "https://files.pythonhosted.org/packages/97/18/c30da5e7a0e7f4603abfc6780574131221d9148f323752c2755d48abad30/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5", size = 28220, upload_time = "2024-02-02T16:30:24.76Z" }, - { url = "https://files.pythonhosted.org/packages/0c/40/2e73e7d532d030b1e41180807a80d564eda53babaf04d65e15c1cf897e40/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c", size = 27756, upload_time = "2024-02-02T16:30:25.877Z" }, - { url = "https://files.pythonhosted.org/packages/18/46/5dca760547e8c59c5311b332f70605d24c99d1303dd9a6e1fc3ed0d73561/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f", size = 33988, upload_time = "2024-02-02T16:30:26.935Z" }, - { url = "https://files.pythonhosted.org/packages/6d/c5/27febe918ac36397919cd4a67d5579cbbfa8da027fa1238af6285bb368ea/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a", size = 32718, upload_time = "2024-02-02T16:30:28.111Z" }, - { url = "https://files.pythonhosted.org/packages/f8/81/56e567126a2c2bc2684d6391332e357589a96a76cb9f8e5052d85cb0ead8/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f", size = 33317, upload_time = "2024-02-02T16:30:29.214Z" }, - { url = "https://files.pythonhosted.org/packages/00/0b/23f4b2470accb53285c613a3ab9ec19dc944eaf53592cb6d9e2af8aa24cc/MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906", size = 16670, upload_time = "2024-02-02T16:30:30.915Z" }, - { url = "https://files.pythonhosted.org/packages/b7/a2/c78a06a9ec6d04b3445a949615c4c7ed86a0b2eb68e44e7541b9d57067cc/MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617", size = 17224, upload_time = "2024-02-02T16:30:32.09Z" }, - { url = "https://files.pythonhosted.org/packages/53/bd/583bf3e4c8d6a321938c13f49d44024dbe5ed63e0a7ba127e454a66da974/MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1", size = 18215, upload_time = "2024-02-02T16:30:33.081Z" }, - { url = "https://files.pythonhosted.org/packages/48/d6/e7cd795fc710292c3af3a06d80868ce4b02bfbbf370b7cee11d282815a2a/MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4", size = 14069, upload_time = "2024-02-02T16:30:34.148Z" }, - { url = "https://files.pythonhosted.org/packages/51/b5/5d8ec796e2a08fc814a2c7d2584b55f889a55cf17dd1a90f2beb70744e5c/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee", size = 29452, upload_time = "2024-02-02T16:30:35.149Z" }, - { url = "https://files.pythonhosted.org/packages/0a/0d/2454f072fae3b5a137c119abf15465d1771319dfe9e4acbb31722a0fff91/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5", size = 28462, upload_time = "2024-02-02T16:30:36.166Z" }, - { url = "https://files.pythonhosted.org/packages/2d/75/fd6cb2e68780f72d47e6671840ca517bda5ef663d30ada7616b0462ad1e3/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b", size = 27869, upload_time = "2024-02-02T16:30:37.834Z" }, - { url = "https://files.pythonhosted.org/packages/b0/81/147c477391c2750e8fc7705829f7351cf1cd3be64406edcf900dc633feb2/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a", size = 33906, upload_time = "2024-02-02T16:30:39.366Z" }, - { url = "https://files.pythonhosted.org/packages/8b/ff/9a52b71839d7a256b563e85d11050e307121000dcebc97df120176b3ad93/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f", size = 32296, upload_time = "2024-02-02T16:30:40.413Z" }, - { url = "https://files.pythonhosted.org/packages/88/07/2dc76aa51b481eb96a4c3198894f38b480490e834479611a4053fbf08623/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169", size = 33038, upload_time = "2024-02-02T16:30:42.243Z" }, - { url = "https://files.pythonhosted.org/packages/96/0c/620c1fb3661858c0e37eb3cbffd8c6f732a67cd97296f725789679801b31/MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad", size = 16572, upload_time = "2024-02-02T16:30:43.326Z" }, - { url = "https://files.pythonhosted.org/packages/3f/14/c3554d512d5f9100a95e737502f4a2323a1959f6d0d01e0d0997b35f7b10/MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb", size = 17127, upload_time = "2024-02-02T16:30:44.418Z" }, - { url = "https://files.pythonhosted.org/packages/0f/31/780bb297db036ba7b7bbede5e1d7f1e14d704ad4beb3ce53fb495d22bc62/MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf", size = 18193, upload_time = "2024-02-02T16:31:10.155Z" }, - { url = "https://files.pythonhosted.org/packages/6c/77/d77701bbef72892affe060cdacb7a2ed7fd68dae3b477a8642f15ad3b132/MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2", size = 14073, upload_time = "2024-02-02T16:31:11.442Z" }, - { url = "https://files.pythonhosted.org/packages/d9/a7/1e558b4f78454c8a3a0199292d96159eb4d091f983bc35ef258314fe7269/MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8", size = 26486, upload_time = "2024-02-02T16:31:12.488Z" }, - { url = "https://files.pythonhosted.org/packages/5f/5a/360da85076688755ea0cceb92472923086993e86b5613bbae9fbc14136b0/MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3", size = 25685, upload_time = "2024-02-02T16:31:13.726Z" }, - { url = "https://files.pythonhosted.org/packages/6a/18/ae5a258e3401f9b8312f92b028c54d7026a97ec3ab20bfaddbdfa7d8cce8/MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465", size = 25338, upload_time = "2024-02-02T16:31:14.812Z" }, - { url = "https://files.pythonhosted.org/packages/0b/cc/48206bd61c5b9d0129f4d75243b156929b04c94c09041321456fd06a876d/MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e", size = 30439, upload_time = "2024-02-02T16:31:15.946Z" }, - { url = "https://files.pythonhosted.org/packages/d1/06/a41c112ab9ffdeeb5f77bc3e331fdadf97fa65e52e44ba31880f4e7f983c/MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea", size = 29531, upload_time = "2024-02-02T16:31:17.13Z" }, - { url = "https://files.pythonhosted.org/packages/02/8c/ab9a463301a50dab04d5472e998acbd4080597abc048166ded5c7aa768c8/MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6", size = 29823, upload_time = "2024-02-02T16:31:18.247Z" }, - { url = "https://files.pythonhosted.org/packages/bc/29/9bc18da763496b055d8e98ce476c8e718dcfd78157e17f555ce6dd7d0895/MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf", size = 16658, upload_time = "2024-02-02T16:31:19.583Z" }, - { url = "https://files.pythonhosted.org/packages/f6/f8/4da07de16f10551ca1f640c92b5f316f9394088b183c6a57183df6de5ae4/MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5", size = 17211, upload_time = "2024-02-02T16:31:20.96Z" }, + { url = "https://files.pythonhosted.org/packages/e4/54/ad5eb37bf9d51800010a74e4665425831a9db4e7c4e0fde4352e391e808e/MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc", size = 18206 }, + { url = "https://files.pythonhosted.org/packages/6a/4a/a4d49415e600bacae038c67f9fecc1d5433b9d3c71a4de6f33537b89654c/MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5", size = 14079 }, + { url = "https://files.pythonhosted.org/packages/0a/7b/85681ae3c33c385b10ac0f8dd025c30af83c78cec1c37a6aa3b55e67f5ec/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46", size = 26620 }, + { url = "https://files.pythonhosted.org/packages/7c/52/2b1b570f6b8b803cef5ac28fdf78c0da318916c7d2fe9402a84d591b394c/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f", size = 25818 }, + { url = "https://files.pythonhosted.org/packages/29/fe/a36ba8c7ca55621620b2d7c585313efd10729e63ef81e4e61f52330da781/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900", size = 25493 }, + { url = "https://files.pythonhosted.org/packages/60/ae/9c60231cdfda003434e8bd27282b1f4e197ad5a710c14bee8bea8a9ca4f0/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff", size = 30630 }, + { url = "https://files.pythonhosted.org/packages/65/dc/1510be4d179869f5dafe071aecb3f1f41b45d37c02329dfba01ff59e5ac5/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad", size = 29745 }, + { url = "https://files.pythonhosted.org/packages/30/39/8d845dd7d0b0613d86e0ef89549bfb5f61ed781f59af45fc96496e897f3a/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd", size = 30021 }, + { url = "https://files.pythonhosted.org/packages/c7/5c/356a6f62e4f3c5fbf2602b4771376af22a3b16efa74eb8716fb4e328e01e/MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4", size = 16659 }, + { url = "https://files.pythonhosted.org/packages/69/48/acbf292615c65f0604a0c6fc402ce6d8c991276e16c80c46a8f758fbd30c/MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5", size = 17213 }, + { url = "https://files.pythonhosted.org/packages/11/e7/291e55127bb2ae67c64d66cef01432b5933859dfb7d6949daa721b89d0b3/MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f", size = 18219 }, + { url = "https://files.pythonhosted.org/packages/6b/cb/aed7a284c00dfa7c0682d14df85ad4955a350a21d2e3b06d8240497359bf/MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2", size = 14098 }, + { url = "https://files.pythonhosted.org/packages/1c/cf/35fe557e53709e93feb65575c93927942087e9b97213eabc3fe9d5b25a55/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced", size = 29014 }, + { url = "https://files.pythonhosted.org/packages/97/18/c30da5e7a0e7f4603abfc6780574131221d9148f323752c2755d48abad30/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5", size = 28220 }, + { url = "https://files.pythonhosted.org/packages/0c/40/2e73e7d532d030b1e41180807a80d564eda53babaf04d65e15c1cf897e40/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c", size = 27756 }, + { url = "https://files.pythonhosted.org/packages/18/46/5dca760547e8c59c5311b332f70605d24c99d1303dd9a6e1fc3ed0d73561/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f", size = 33988 }, + { url = "https://files.pythonhosted.org/packages/6d/c5/27febe918ac36397919cd4a67d5579cbbfa8da027fa1238af6285bb368ea/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a", size = 32718 }, + { url = "https://files.pythonhosted.org/packages/f8/81/56e567126a2c2bc2684d6391332e357589a96a76cb9f8e5052d85cb0ead8/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f", size = 33317 }, + { url = "https://files.pythonhosted.org/packages/00/0b/23f4b2470accb53285c613a3ab9ec19dc944eaf53592cb6d9e2af8aa24cc/MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906", size = 16670 }, + { url = "https://files.pythonhosted.org/packages/b7/a2/c78a06a9ec6d04b3445a949615c4c7ed86a0b2eb68e44e7541b9d57067cc/MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617", size = 17224 }, + { url = "https://files.pythonhosted.org/packages/53/bd/583bf3e4c8d6a321938c13f49d44024dbe5ed63e0a7ba127e454a66da974/MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1", size = 18215 }, + { url = "https://files.pythonhosted.org/packages/48/d6/e7cd795fc710292c3af3a06d80868ce4b02bfbbf370b7cee11d282815a2a/MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4", size = 14069 }, + { url = "https://files.pythonhosted.org/packages/51/b5/5d8ec796e2a08fc814a2c7d2584b55f889a55cf17dd1a90f2beb70744e5c/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee", size = 29452 }, + { url = "https://files.pythonhosted.org/packages/0a/0d/2454f072fae3b5a137c119abf15465d1771319dfe9e4acbb31722a0fff91/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5", size = 28462 }, + { url = "https://files.pythonhosted.org/packages/2d/75/fd6cb2e68780f72d47e6671840ca517bda5ef663d30ada7616b0462ad1e3/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b", size = 27869 }, + { url = "https://files.pythonhosted.org/packages/b0/81/147c477391c2750e8fc7705829f7351cf1cd3be64406edcf900dc633feb2/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a", size = 33906 }, + { url = "https://files.pythonhosted.org/packages/8b/ff/9a52b71839d7a256b563e85d11050e307121000dcebc97df120176b3ad93/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f", size = 32296 }, + { url = "https://files.pythonhosted.org/packages/88/07/2dc76aa51b481eb96a4c3198894f38b480490e834479611a4053fbf08623/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169", size = 33038 }, + { url = "https://files.pythonhosted.org/packages/96/0c/620c1fb3661858c0e37eb3cbffd8c6f732a67cd97296f725789679801b31/MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad", size = 16572 }, + { url = "https://files.pythonhosted.org/packages/3f/14/c3554d512d5f9100a95e737502f4a2323a1959f6d0d01e0d0997b35f7b10/MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb", size = 17127 }, + { url = "https://files.pythonhosted.org/packages/0f/31/780bb297db036ba7b7bbede5e1d7f1e14d704ad4beb3ce53fb495d22bc62/MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf", size = 18193 }, + { url = "https://files.pythonhosted.org/packages/6c/77/d77701bbef72892affe060cdacb7a2ed7fd68dae3b477a8642f15ad3b132/MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2", size = 14073 }, + { url = "https://files.pythonhosted.org/packages/d9/a7/1e558b4f78454c8a3a0199292d96159eb4d091f983bc35ef258314fe7269/MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8", size = 26486 }, + { url = "https://files.pythonhosted.org/packages/5f/5a/360da85076688755ea0cceb92472923086993e86b5613bbae9fbc14136b0/MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3", size = 25685 }, + { url = "https://files.pythonhosted.org/packages/6a/18/ae5a258e3401f9b8312f92b028c54d7026a97ec3ab20bfaddbdfa7d8cce8/MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465", size = 25338 }, + { url = "https://files.pythonhosted.org/packages/0b/cc/48206bd61c5b9d0129f4d75243b156929b04c94c09041321456fd06a876d/MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e", size = 30439 }, + { url = "https://files.pythonhosted.org/packages/d1/06/a41c112ab9ffdeeb5f77bc3e331fdadf97fa65e52e44ba31880f4e7f983c/MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea", size = 29531 }, + { url = "https://files.pythonhosted.org/packages/02/8c/ab9a463301a50dab04d5472e998acbd4080597abc048166ded5c7aa768c8/MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6", size = 29823 }, + { url = "https://files.pythonhosted.org/packages/bc/29/9bc18da763496b055d8e98ce476c8e718dcfd78157e17f555ce6dd7d0895/MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf", size = 16658 }, + { url = "https://files.pythonhosted.org/packages/f6/f8/4da07de16f10551ca1f640c92b5f316f9394088b183c6a57183df6de5ae4/MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5", size = 17211 }, ] [[package]] @@ -517,20 +516,20 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "tomli", marker = "python_full_version < '3.11'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/51/28/31a650d9209d873b6aec759c944bd284155154d7a01f7f541786d7c435ca/maturin-1.7.4.tar.gz", hash = "sha256:2b349d742a07527d236f0b4b6cab26f53ebecad0ceabfc09ec4c6a396e3176f9", size = 191145, upload_time = "2024-09-26T03:36:19.196Z" } +sdist = { url = "https://files.pythonhosted.org/packages/51/28/31a650d9209d873b6aec759c944bd284155154d7a01f7f541786d7c435ca/maturin-1.7.4.tar.gz", hash = "sha256:2b349d742a07527d236f0b4b6cab26f53ebecad0ceabfc09ec4c6a396e3176f9", size = 191145 } wheels = [ - { url = "https://files.pythonhosted.org/packages/85/19/b5be36f3cb30ba72aa2232492d4462409955da134ea25083f0e625618082/maturin-1.7.4-py3-none-linux_armv6l.whl", hash = "sha256:eb7b7753b733ae302c08f80bca7b0c3fda1eea665c2b1922c58795f35a54c833", size = 8215481, upload_time = "2024-09-26T03:35:42.249Z" }, - { url = "https://files.pythonhosted.org/packages/4f/0a/1b2a2fda3f338dedd219de358d77b01f1138bc4bc6b4c73b6ea01d8ddd9e/maturin-1.7.4-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:0182a9638399c8835afd39d2aeacf56908e37cba3f7abb15816b9df6774fab81", size = 15930801, upload_time = "2024-09-26T03:35:45.875Z" }, - { url = "https://files.pythonhosted.org/packages/21/df/f75dcd8472f3be5b528942b11444eb4a82aa1aced7d105a8ba39bb85ece8/maturin-1.7.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:41a29c5b23f3ebdfe7633637e3de256579a1b2700c04cd68c16ed46934440c5a", size = 8166643, upload_time = "2024-09-26T03:35:48.872Z" }, - { url = "https://files.pythonhosted.org/packages/87/43/52baa75e6dae9848ea22ae6bd405e7f7da091ba63409b07912048fde2083/maturin-1.7.4-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:23fae44e345a2da5cb391ae878726fb793394826e2f97febe41710bd4099460e", size = 8560688, upload_time = "2024-09-26T03:35:51.156Z" }, - { url = "https://files.pythonhosted.org/packages/84/97/5e2bfbcf42725ba5f64310423edcf00d90e684a61d55dd0a26b2313a44b6/maturin-1.7.4-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:8b441521c151f0dbe70ed06fb1feb29b855d787bda038ff4330ca962e5d56641", size = 8939107, upload_time = "2024-09-26T03:35:54.444Z" }, - { url = "https://files.pythonhosted.org/packages/34/59/e0d58ce67a8a6245dcb74ffb81cb12f0cda8b622c8d902f2371de742ae04/maturin-1.7.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:7ccb66d0c5297cf06652c5f72cb398f447d3a332eccf5d1e73b3fe14dbc9498c", size = 8425431, upload_time = "2024-09-26T03:35:57.888Z" }, - { url = "https://files.pythonhosted.org/packages/53/20/4b79324b14a1f39b2c66eb1ad681cf8b0fff1f905374b0cca59fc9c8ef7a/maturin-1.7.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:71f668f19e719048605dbca6a1f4d0dc03b987c922ad9c4bf5be03b9b278e4c3", size = 8104459, upload_time = "2024-09-26T03:36:01.468Z" }, - { url = "https://files.pythonhosted.org/packages/7f/fa/8d9497c62451fc19f52cda1ad652c5dca4e9646ff93be35250070afbc2af/maturin-1.7.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:c179fcb2b494f19186781b667320e43d95b3e71fcb1c98fffad9ef6bd6e276b3", size = 8729663, upload_time = "2024-09-26T03:36:04.192Z" }, - { url = "https://files.pythonhosted.org/packages/a4/e9/15a24263de981928303ca64465d5d9d5062f248b9ceaab3de5857ee0ba83/maturin-1.7.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fd5b4b95286f2f376437340f8a4908f4761587212170263084455be8099099a7", size = 10142511, upload_time = "2024-09-26T03:36:07.675Z" }, - { url = "https://files.pythonhosted.org/packages/a5/5d/59765561ea1a5f993141a403eb4ae85b7a8bd118971de0ed14048e3faf7f/maturin-1.7.4-py3-none-win32.whl", hash = "sha256:35487a424467d1fda4567cbb02d21f09febb10eda22f5fd647b130bc0767dc61", size = 6578873, upload_time = "2024-09-26T03:36:10.964Z" }, - { url = "https://files.pythonhosted.org/packages/72/50/a9b402aa506bad6c066c7775b1cb3036b7b1c74b9de708ed537ee804ea4a/maturin-1.7.4-py3-none-win_amd64.whl", hash = "sha256:f70c1c8ec9bd4749a53c0f3ae8fdbb326ce45be4f1c5551985ee25a6d7150328", size = 7442039, upload_time = "2024-09-26T03:36:13.81Z" }, - { url = "https://files.pythonhosted.org/packages/30/38/8e27282ab6ff94291f04e3eb11ba960dfb487605d73cec75177d3a29879a/maturin-1.7.4-py3-none-win_arm64.whl", hash = "sha256:f3d38a6d0c7fd7b04bec30dd470b2173cf9bd184ab6220c1acaf49df6b48faf5", size = 6388008, upload_time = "2024-09-26T03:36:16.663Z" }, + { url = "https://files.pythonhosted.org/packages/85/19/b5be36f3cb30ba72aa2232492d4462409955da134ea25083f0e625618082/maturin-1.7.4-py3-none-linux_armv6l.whl", hash = "sha256:eb7b7753b733ae302c08f80bca7b0c3fda1eea665c2b1922c58795f35a54c833", size = 8215481 }, + { url = "https://files.pythonhosted.org/packages/4f/0a/1b2a2fda3f338dedd219de358d77b01f1138bc4bc6b4c73b6ea01d8ddd9e/maturin-1.7.4-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:0182a9638399c8835afd39d2aeacf56908e37cba3f7abb15816b9df6774fab81", size = 15930801 }, + { url = "https://files.pythonhosted.org/packages/21/df/f75dcd8472f3be5b528942b11444eb4a82aa1aced7d105a8ba39bb85ece8/maturin-1.7.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:41a29c5b23f3ebdfe7633637e3de256579a1b2700c04cd68c16ed46934440c5a", size = 8166643 }, + { url = "https://files.pythonhosted.org/packages/87/43/52baa75e6dae9848ea22ae6bd405e7f7da091ba63409b07912048fde2083/maturin-1.7.4-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:23fae44e345a2da5cb391ae878726fb793394826e2f97febe41710bd4099460e", size = 8560688 }, + { url = "https://files.pythonhosted.org/packages/84/97/5e2bfbcf42725ba5f64310423edcf00d90e684a61d55dd0a26b2313a44b6/maturin-1.7.4-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:8b441521c151f0dbe70ed06fb1feb29b855d787bda038ff4330ca962e5d56641", size = 8939107 }, + { url = "https://files.pythonhosted.org/packages/34/59/e0d58ce67a8a6245dcb74ffb81cb12f0cda8b622c8d902f2371de742ae04/maturin-1.7.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:7ccb66d0c5297cf06652c5f72cb398f447d3a332eccf5d1e73b3fe14dbc9498c", size = 8425431 }, + { url = "https://files.pythonhosted.org/packages/53/20/4b79324b14a1f39b2c66eb1ad681cf8b0fff1f905374b0cca59fc9c8ef7a/maturin-1.7.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:71f668f19e719048605dbca6a1f4d0dc03b987c922ad9c4bf5be03b9b278e4c3", size = 8104459 }, + { url = "https://files.pythonhosted.org/packages/7f/fa/8d9497c62451fc19f52cda1ad652c5dca4e9646ff93be35250070afbc2af/maturin-1.7.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:c179fcb2b494f19186781b667320e43d95b3e71fcb1c98fffad9ef6bd6e276b3", size = 8729663 }, + { url = "https://files.pythonhosted.org/packages/a4/e9/15a24263de981928303ca64465d5d9d5062f248b9ceaab3de5857ee0ba83/maturin-1.7.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fd5b4b95286f2f376437340f8a4908f4761587212170263084455be8099099a7", size = 10142511 }, + { url = "https://files.pythonhosted.org/packages/a5/5d/59765561ea1a5f993141a403eb4ae85b7a8bd118971de0ed14048e3faf7f/maturin-1.7.4-py3-none-win32.whl", hash = "sha256:35487a424467d1fda4567cbb02d21f09febb10eda22f5fd647b130bc0767dc61", size = 6578873 }, + { url = "https://files.pythonhosted.org/packages/72/50/a9b402aa506bad6c066c7775b1cb3036b7b1c74b9de708ed537ee804ea4a/maturin-1.7.4-py3-none-win_amd64.whl", hash = "sha256:f70c1c8ec9bd4749a53c0f3ae8fdbb326ce45be4f1c5551985ee25a6d7150328", size = 7442039 }, + { url = "https://files.pythonhosted.org/packages/30/38/8e27282ab6ff94291f04e3eb11ba960dfb487605d73cec75177d3a29879a/maturin-1.7.4-py3-none-win_arm64.whl", hash = "sha256:f3d38a6d0c7fd7b04bec30dd470b2173cf9bd184ab6220c1acaf49df6b48faf5", size = 6388008 }, ] [[package]] @@ -547,60 +546,62 @@ dependencies = [ { name = "tqdm" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e4/d7/e91c6a9cf71726420cddf539852ee4c29176ebb716a702d9118d0409fd8e/openai-1.93.0.tar.gz", hash = "sha256:988f31ade95e1ff0585af11cc5a64510225e4f5cd392698c675d0a9265b8e337", size = 486573, upload_time = "2025-06-27T21:21:39.421Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/d7/e91c6a9cf71726420cddf539852ee4c29176ebb716a702d9118d0409fd8e/openai-1.93.0.tar.gz", hash = "sha256:988f31ade95e1ff0585af11cc5a64510225e4f5cd392698c675d0a9265b8e337", size = 486573 } wheels = [ - { url = "https://files.pythonhosted.org/packages/64/46/a10d9df4673df56f71201d129ba1cb19eaff3366d08c8664d61a7df52e65/openai-1.93.0-py3-none-any.whl", hash = "sha256:3d746fe5498f0dd72e0d9ab706f26c91c0f646bf7459e5629af8ba7c9dbdf090", size = 755038, upload_time = "2025-06-27T21:21:37.532Z" }, + { url = "https://files.pythonhosted.org/packages/64/46/a10d9df4673df56f71201d129ba1cb19eaff3366d08c8664d61a7df52e65/openai-1.93.0-py3-none-any.whl", hash = "sha256:3d746fe5498f0dd72e0d9ab706f26c91c0f646bf7459e5629af8ba7c9dbdf090", size = 755038 }, ] [[package]] name = "packaging" version = "24.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950, upload_time = "2024-11-08T09:47:47.202Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451, upload_time = "2024-11-08T09:47:44.722Z" }, + { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, ] [[package]] name = "pip" version = "25.1.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/59/de/241caa0ca606f2ec5fe0c1f4261b0465df78d786a38da693864a116c37f4/pip-25.1.1.tar.gz", hash = "sha256:3de45d411d308d5054c2168185d8da7f9a2cd753dbac8acbfa88a8909ecd9077", size = 1940155, upload_time = "2025-05-02T15:14:02.057Z" } +sdist = { url = "https://files.pythonhosted.org/packages/59/de/241caa0ca606f2ec5fe0c1f4261b0465df78d786a38da693864a116c37f4/pip-25.1.1.tar.gz", hash = "sha256:3de45d411d308d5054c2168185d8da7f9a2cd753dbac8acbfa88a8909ecd9077", size = 1940155 } wheels = [ - { url = "https://files.pythonhosted.org/packages/29/a2/d40fb2460e883eca5199c62cfc2463fd261f760556ae6290f88488c362c0/pip-25.1.1-py3-none-any.whl", hash = "sha256:2913a38a2abf4ea6b64ab507bd9e967f3b53dc1ede74b01b0931e1ce548751af", size = 1825227, upload_time = "2025-05-02T15:13:59.102Z" }, + { url = "https://files.pythonhosted.org/packages/29/a2/d40fb2460e883eca5199c62cfc2463fd261f760556ae6290f88488c362c0/pip-25.1.1-py3-none-any.whl", hash = "sha256:2913a38a2abf4ea6b64ab507bd9e967f3b53dc1ede74b01b0931e1ce548751af", size = 1825227 }, ] [[package]] name = "pluggy" version = "1.5.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955, upload_time = "2024-04-20T21:34:42.531Z" } +sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556, upload_time = "2024-04-20T21:34:40.434Z" }, + { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, ] [[package]] name = "psutil" version = "6.1.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1f/5a/07871137bb752428aa4b659f910b399ba6f291156bdea939be3e96cae7cb/psutil-6.1.1.tar.gz", hash = "sha256:cf8496728c18f2d0b45198f06895be52f36611711746b7f30c464b422b50e2f5", size = 508502, upload_time = "2024-12-19T18:21:20.568Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1f/5a/07871137bb752428aa4b659f910b399ba6f291156bdea939be3e96cae7cb/psutil-6.1.1.tar.gz", hash = "sha256:cf8496728c18f2d0b45198f06895be52f36611711746b7f30c464b422b50e2f5", size = 508502 } wheels = [ - { url = "https://files.pythonhosted.org/packages/61/99/ca79d302be46f7bdd8321089762dd4476ee725fce16fc2b2e1dbba8cac17/psutil-6.1.1-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:fc0ed7fe2231a444fc219b9c42d0376e0a9a1a72f16c5cfa0f68d19f1a0663e8", size = 247511, upload_time = "2024-12-19T18:21:45.163Z" }, - { url = "https://files.pythonhosted.org/packages/0b/6b/73dbde0dd38f3782905d4587049b9be64d76671042fdcaf60e2430c6796d/psutil-6.1.1-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0bdd4eab935276290ad3cb718e9809412895ca6b5b334f5a9111ee6d9aff9377", size = 248985, upload_time = "2024-12-19T18:21:49.254Z" }, - { url = "https://files.pythonhosted.org/packages/17/38/c319d31a1d3f88c5b79c68b3116c129e5133f1822157dd6da34043e32ed6/psutil-6.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b6e06c20c05fe95a3d7302d74e7097756d4ba1247975ad6905441ae1b5b66003", size = 284488, upload_time = "2024-12-19T18:21:51.638Z" }, - { url = "https://files.pythonhosted.org/packages/9c/39/0f88a830a1c8a3aba27fededc642da37613c57cbff143412e3536f89784f/psutil-6.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97f7cb9921fbec4904f522d972f0c0e1f4fabbdd4e0287813b21215074a0f160", size = 287477, upload_time = "2024-12-19T18:21:55.306Z" }, - { url = "https://files.pythonhosted.org/packages/47/da/99f4345d4ddf2845cb5b5bd0d93d554e84542d116934fde07a0c50bd4e9f/psutil-6.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:33431e84fee02bc84ea36d9e2c4a6d395d479c9dd9bba2376c1f6ee8f3a4e0b3", size = 289017, upload_time = "2024-12-19T18:21:57.875Z" }, - { url = "https://files.pythonhosted.org/packages/38/53/bd755c2896f4461fd4f36fa6a6dcb66a88a9e4b9fd4e5b66a77cf9d4a584/psutil-6.1.1-cp37-abi3-win32.whl", hash = "sha256:eaa912e0b11848c4d9279a93d7e2783df352b082f40111e078388701fd479e53", size = 250602, upload_time = "2024-12-19T18:22:08.808Z" }, - { url = "https://files.pythonhosted.org/packages/7b/d7/7831438e6c3ebbfa6e01a927127a6cb42ad3ab844247f3c5b96bea25d73d/psutil-6.1.1-cp37-abi3-win_amd64.whl", hash = "sha256:f35cfccb065fff93529d2afb4a2e89e363fe63ca1e4a5da22b603a85833c2649", size = 254444, upload_time = "2024-12-19T18:22:11.335Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d4/8095b53c4950f44dc99b8d983b796f405ae1f58d80978fcc0421491b4201/psutil-6.1.1-cp27-none-win32.whl", hash = "sha256:6d4281f5bbca041e2292be3380ec56a9413b790579b8e593b1784499d0005dac", size = 246855 }, + { url = "https://files.pythonhosted.org/packages/b1/63/0b6425ea4f2375988209a9934c90d6079cc7537847ed58a28fbe30f4277e/psutil-6.1.1-cp27-none-win_amd64.whl", hash = "sha256:c777eb75bb33c47377c9af68f30e9f11bc78e0f07fbf907be4a5d70b2fe5f030", size = 250110 }, + { url = "https://files.pythonhosted.org/packages/61/99/ca79d302be46f7bdd8321089762dd4476ee725fce16fc2b2e1dbba8cac17/psutil-6.1.1-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:fc0ed7fe2231a444fc219b9c42d0376e0a9a1a72f16c5cfa0f68d19f1a0663e8", size = 247511 }, + { url = "https://files.pythonhosted.org/packages/0b/6b/73dbde0dd38f3782905d4587049b9be64d76671042fdcaf60e2430c6796d/psutil-6.1.1-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0bdd4eab935276290ad3cb718e9809412895ca6b5b334f5a9111ee6d9aff9377", size = 248985 }, + { url = "https://files.pythonhosted.org/packages/17/38/c319d31a1d3f88c5b79c68b3116c129e5133f1822157dd6da34043e32ed6/psutil-6.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b6e06c20c05fe95a3d7302d74e7097756d4ba1247975ad6905441ae1b5b66003", size = 284488 }, + { url = "https://files.pythonhosted.org/packages/9c/39/0f88a830a1c8a3aba27fededc642da37613c57cbff143412e3536f89784f/psutil-6.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97f7cb9921fbec4904f522d972f0c0e1f4fabbdd4e0287813b21215074a0f160", size = 287477 }, + { url = "https://files.pythonhosted.org/packages/47/da/99f4345d4ddf2845cb5b5bd0d93d554e84542d116934fde07a0c50bd4e9f/psutil-6.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:33431e84fee02bc84ea36d9e2c4a6d395d479c9dd9bba2376c1f6ee8f3a4e0b3", size = 289017 }, + { url = "https://files.pythonhosted.org/packages/38/53/bd755c2896f4461fd4f36fa6a6dcb66a88a9e4b9fd4e5b66a77cf9d4a584/psutil-6.1.1-cp37-abi3-win32.whl", hash = "sha256:eaa912e0b11848c4d9279a93d7e2783df352b082f40111e078388701fd479e53", size = 250602 }, + { url = "https://files.pythonhosted.org/packages/7b/d7/7831438e6c3ebbfa6e01a927127a6cb42ad3ab844247f3c5b96bea25d73d/psutil-6.1.1-cp37-abi3-win_amd64.whl", hash = "sha256:f35cfccb065fff93529d2afb4a2e89e363fe63ca1e4a5da22b603a85833c2649", size = 254444 }, ] [[package]] name = "pyasn1" version = "0.6.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322, upload_time = "2024-09-10T22:41:42.55Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322 } wheels = [ - { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135, upload_time = "2024-09-11T16:00:36.122Z" }, + { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135 }, ] [[package]] @@ -610,9 +611,9 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyasn1" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1d/67/6afbf0d507f73c32d21084a79946bfcfca5fbc62a72057e9c23797a737c9/pyasn1_modules-0.4.1.tar.gz", hash = "sha256:c28e2dbf9c06ad61c71a075c7e0f9fd0f1b0bb2d2ad4377f240d33ac2ab60a7c", size = 310028, upload_time = "2024-09-10T22:42:08.349Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/67/6afbf0d507f73c32d21084a79946bfcfca5fbc62a72057e9c23797a737c9/pyasn1_modules-0.4.1.tar.gz", hash = "sha256:c28e2dbf9c06ad61c71a075c7e0f9fd0f1b0bb2d2ad4377f240d33ac2ab60a7c", size = 310028 } wheels = [ - { url = "https://files.pythonhosted.org/packages/77/89/bc88a6711935ba795a679ea6ebee07e128050d6382eaa35a0a47c8032bdc/pyasn1_modules-0.4.1-py3-none-any.whl", hash = "sha256:49bfa96b45a292b711e986f222502c1c9a5e1f4e568fc30e2574a6c7d07838fd", size = 181537, upload_time = "2024-09-11T16:02:10.336Z" }, + { url = "https://files.pythonhosted.org/packages/77/89/bc88a6711935ba795a679ea6ebee07e128050d6382eaa35a0a47c8032bdc/pyasn1_modules-0.4.1-py3-none-any.whl", hash = "sha256:49bfa96b45a292b711e986f222502c1c9a5e1f4e568fc30e2574a6c7d07838fd", size = 181537 }, ] [[package]] @@ -624,9 +625,9 @@ dependencies = [ { name = "pydantic-core" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b7/ae/d5220c5c52b158b1de7ca89fc5edb72f304a70a4c540c84c8844bf4008de/pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236", size = 761681, upload_time = "2025-01-24T01:42:12.693Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b7/ae/d5220c5c52b158b1de7ca89fc5edb72f304a70a4c540c84c8844bf4008de/pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236", size = 761681 } wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/3c/8cc1cc84deffa6e25d2d0c688ebb80635dfdbf1dbea3e30c541c8cf4d860/pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584", size = 431696, upload_time = "2025-01-24T01:42:10.371Z" }, + { url = "https://files.pythonhosted.org/packages/f4/3c/8cc1cc84deffa6e25d2d0c688ebb80635dfdbf1dbea3e30c541c8cf4d860/pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584", size = 431696 }, ] [[package]] @@ -636,103 +637,103 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fc/01/f3e5ac5e7c25833db5eb555f7b7ab24cd6f8c322d3a3ad2d67a952dc0abc/pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39", size = 413443, upload_time = "2024-12-18T11:31:54.917Z" } +sdist = { url = "https://files.pythonhosted.org/packages/fc/01/f3e5ac5e7c25833db5eb555f7b7ab24cd6f8c322d3a3ad2d67a952dc0abc/pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39", size = 413443 } wheels = [ - { url = "https://files.pythonhosted.org/packages/3a/bc/fed5f74b5d802cf9a03e83f60f18864e90e3aed7223adaca5ffb7a8d8d64/pydantic_core-2.27.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2d367ca20b2f14095a8f4fa1210f5a7b78b8a20009ecced6b12818f455b1e9fa", size = 1895938, upload_time = "2024-12-18T11:27:14.406Z" }, - { url = "https://files.pythonhosted.org/packages/71/2a/185aff24ce844e39abb8dd680f4e959f0006944f4a8a0ea372d9f9ae2e53/pydantic_core-2.27.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:491a2b73db93fab69731eaee494f320faa4e093dbed776be1a829c2eb222c34c", size = 1815684, upload_time = "2024-12-18T11:27:16.489Z" }, - { url = "https://files.pythonhosted.org/packages/c3/43/fafabd3d94d159d4f1ed62e383e264f146a17dd4d48453319fd782e7979e/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7969e133a6f183be60e9f6f56bfae753585680f3b7307a8e555a948d443cc05a", size = 1829169, upload_time = "2024-12-18T11:27:22.16Z" }, - { url = "https://files.pythonhosted.org/packages/a2/d1/f2dfe1a2a637ce6800b799aa086d079998959f6f1215eb4497966efd2274/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3de9961f2a346257caf0aa508a4da705467f53778e9ef6fe744c038119737ef5", size = 1867227, upload_time = "2024-12-18T11:27:25.097Z" }, - { url = "https://files.pythonhosted.org/packages/7d/39/e06fcbcc1c785daa3160ccf6c1c38fea31f5754b756e34b65f74e99780b5/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e2bb4d3e5873c37bb3dd58714d4cd0b0e6238cebc4177ac8fe878f8b3aa8e74c", size = 2037695, upload_time = "2024-12-18T11:27:28.656Z" }, - { url = "https://files.pythonhosted.org/packages/7a/67/61291ee98e07f0650eb756d44998214231f50751ba7e13f4f325d95249ab/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:280d219beebb0752699480fe8f1dc61ab6615c2046d76b7ab7ee38858de0a4e7", size = 2741662, upload_time = "2024-12-18T11:27:30.798Z" }, - { url = "https://files.pythonhosted.org/packages/32/90/3b15e31b88ca39e9e626630b4c4a1f5a0dfd09076366f4219429e6786076/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47956ae78b6422cbd46f772f1746799cbb862de838fd8d1fbd34a82e05b0983a", size = 1993370, upload_time = "2024-12-18T11:27:33.692Z" }, - { url = "https://files.pythonhosted.org/packages/ff/83/c06d333ee3a67e2e13e07794995c1535565132940715931c1c43bfc85b11/pydantic_core-2.27.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:14d4a5c49d2f009d62a2a7140d3064f686d17a5d1a268bc641954ba181880236", size = 1996813, upload_time = "2024-12-18T11:27:37.111Z" }, - { url = "https://files.pythonhosted.org/packages/7c/f7/89be1c8deb6e22618a74f0ca0d933fdcb8baa254753b26b25ad3acff8f74/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:337b443af21d488716f8d0b6164de833e788aa6bd7e3a39c005febc1284f4962", size = 2005287, upload_time = "2024-12-18T11:27:40.566Z" }, - { url = "https://files.pythonhosted.org/packages/b7/7d/8eb3e23206c00ef7feee17b83a4ffa0a623eb1a9d382e56e4aa46fd15ff2/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:03d0f86ea3184a12f41a2d23f7ccb79cdb5a18e06993f8a45baa8dfec746f0e9", size = 2128414, upload_time = "2024-12-18T11:27:43.757Z" }, - { url = "https://files.pythonhosted.org/packages/4e/99/fe80f3ff8dd71a3ea15763878d464476e6cb0a2db95ff1c5c554133b6b83/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7041c36f5680c6e0f08d922aed302e98b3745d97fe1589db0a3eebf6624523af", size = 2155301, upload_time = "2024-12-18T11:27:47.36Z" }, - { url = "https://files.pythonhosted.org/packages/2b/a3/e50460b9a5789ca1451b70d4f52546fa9e2b420ba3bfa6100105c0559238/pydantic_core-2.27.2-cp310-cp310-win32.whl", hash = "sha256:50a68f3e3819077be2c98110c1f9dcb3817e93f267ba80a2c05bb4f8799e2ff4", size = 1816685, upload_time = "2024-12-18T11:27:50.508Z" }, - { url = "https://files.pythonhosted.org/packages/57/4c/a8838731cb0f2c2a39d3535376466de6049034d7b239c0202a64aaa05533/pydantic_core-2.27.2-cp310-cp310-win_amd64.whl", hash = "sha256:e0fd26b16394ead34a424eecf8a31a1f5137094cabe84a1bcb10fa6ba39d3d31", size = 1982876, upload_time = "2024-12-18T11:27:53.54Z" }, - { url = "https://files.pythonhosted.org/packages/c2/89/f3450af9d09d44eea1f2c369f49e8f181d742f28220f88cc4dfaae91ea6e/pydantic_core-2.27.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:8e10c99ef58cfdf2a66fc15d66b16c4a04f62bca39db589ae8cba08bc55331bc", size = 1893421, upload_time = "2024-12-18T11:27:55.409Z" }, - { url = "https://files.pythonhosted.org/packages/9e/e3/71fe85af2021f3f386da42d291412e5baf6ce7716bd7101ea49c810eda90/pydantic_core-2.27.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:26f32e0adf166a84d0cb63be85c562ca8a6fa8de28e5f0d92250c6b7e9e2aff7", size = 1814998, upload_time = "2024-12-18T11:27:57.252Z" }, - { url = "https://files.pythonhosted.org/packages/a6/3c/724039e0d848fd69dbf5806894e26479577316c6f0f112bacaf67aa889ac/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c19d1ea0673cd13cc2f872f6c9ab42acc4e4f492a7ca9d3795ce2b112dd7e15", size = 1826167, upload_time = "2024-12-18T11:27:59.146Z" }, - { url = "https://files.pythonhosted.org/packages/2b/5b/1b29e8c1fb5f3199a9a57c1452004ff39f494bbe9bdbe9a81e18172e40d3/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e68c4446fe0810e959cdff46ab0a41ce2f2c86d227d96dc3847af0ba7def306", size = 1865071, upload_time = "2024-12-18T11:28:02.625Z" }, - { url = "https://files.pythonhosted.org/packages/89/6c/3985203863d76bb7d7266e36970d7e3b6385148c18a68cc8915fd8c84d57/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d9640b0059ff4f14d1f37321b94061c6db164fbe49b334b31643e0528d100d99", size = 2036244, upload_time = "2024-12-18T11:28:04.442Z" }, - { url = "https://files.pythonhosted.org/packages/0e/41/f15316858a246b5d723f7d7f599f79e37493b2e84bfc789e58d88c209f8a/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40d02e7d45c9f8af700f3452f329ead92da4c5f4317ca9b896de7ce7199ea459", size = 2737470, upload_time = "2024-12-18T11:28:07.679Z" }, - { url = "https://files.pythonhosted.org/packages/a8/7c/b860618c25678bbd6d1d99dbdfdf0510ccb50790099b963ff78a124b754f/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c1fd185014191700554795c99b347d64f2bb637966c4cfc16998a0ca700d048", size = 1992291, upload_time = "2024-12-18T11:28:10.297Z" }, - { url = "https://files.pythonhosted.org/packages/bf/73/42c3742a391eccbeab39f15213ecda3104ae8682ba3c0c28069fbcb8c10d/pydantic_core-2.27.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d81d2068e1c1228a565af076598f9e7451712700b673de8f502f0334f281387d", size = 1994613, upload_time = "2024-12-18T11:28:13.362Z" }, - { url = "https://files.pythonhosted.org/packages/94/7a/941e89096d1175d56f59340f3a8ebaf20762fef222c298ea96d36a6328c5/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1a4207639fb02ec2dbb76227d7c751a20b1a6b4bc52850568e52260cae64ca3b", size = 2002355, upload_time = "2024-12-18T11:28:16.587Z" }, - { url = "https://files.pythonhosted.org/packages/6e/95/2359937a73d49e336a5a19848713555605d4d8d6940c3ec6c6c0ca4dcf25/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:3de3ce3c9ddc8bbd88f6e0e304dea0e66d843ec9de1b0042b0911c1663ffd474", size = 2126661, upload_time = "2024-12-18T11:28:18.407Z" }, - { url = "https://files.pythonhosted.org/packages/2b/4c/ca02b7bdb6012a1adef21a50625b14f43ed4d11f1fc237f9d7490aa5078c/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:30c5f68ded0c36466acede341551106821043e9afaad516adfb6e8fa80a4e6a6", size = 2153261, upload_time = "2024-12-18T11:28:21.471Z" }, - { url = "https://files.pythonhosted.org/packages/72/9d/a241db83f973049a1092a079272ffe2e3e82e98561ef6214ab53fe53b1c7/pydantic_core-2.27.2-cp311-cp311-win32.whl", hash = "sha256:c70c26d2c99f78b125a3459f8afe1aed4d9687c24fd677c6a4436bc042e50d6c", size = 1812361, upload_time = "2024-12-18T11:28:23.53Z" }, - { url = "https://files.pythonhosted.org/packages/e8/ef/013f07248041b74abd48a385e2110aa3a9bbfef0fbd97d4e6d07d2f5b89a/pydantic_core-2.27.2-cp311-cp311-win_amd64.whl", hash = "sha256:08e125dbdc505fa69ca7d9c499639ab6407cfa909214d500897d02afb816e7cc", size = 1982484, upload_time = "2024-12-18T11:28:25.391Z" }, - { url = "https://files.pythonhosted.org/packages/10/1c/16b3a3e3398fd29dca77cea0a1d998d6bde3902fa2706985191e2313cc76/pydantic_core-2.27.2-cp311-cp311-win_arm64.whl", hash = "sha256:26f0d68d4b235a2bae0c3fc585c585b4ecc51382db0e3ba402a22cbc440915e4", size = 1867102, upload_time = "2024-12-18T11:28:28.593Z" }, - { url = "https://files.pythonhosted.org/packages/d6/74/51c8a5482ca447871c93e142d9d4a92ead74de6c8dc5e66733e22c9bba89/pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0", size = 1893127, upload_time = "2024-12-18T11:28:30.346Z" }, - { url = "https://files.pythonhosted.org/packages/d3/f3/c97e80721735868313c58b89d2de85fa80fe8dfeeed84dc51598b92a135e/pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef", size = 1811340, upload_time = "2024-12-18T11:28:32.521Z" }, - { url = "https://files.pythonhosted.org/packages/9e/91/840ec1375e686dbae1bd80a9e46c26a1e0083e1186abc610efa3d9a36180/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7", size = 1822900, upload_time = "2024-12-18T11:28:34.507Z" }, - { url = "https://files.pythonhosted.org/packages/f6/31/4240bc96025035500c18adc149aa6ffdf1a0062a4b525c932065ceb4d868/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934", size = 1869177, upload_time = "2024-12-18T11:28:36.488Z" }, - { url = "https://files.pythonhosted.org/packages/fa/20/02fbaadb7808be578317015c462655c317a77a7c8f0ef274bc016a784c54/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6", size = 2038046, upload_time = "2024-12-18T11:28:39.409Z" }, - { url = "https://files.pythonhosted.org/packages/06/86/7f306b904e6c9eccf0668248b3f272090e49c275bc488a7b88b0823444a4/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c", size = 2685386, upload_time = "2024-12-18T11:28:41.221Z" }, - { url = "https://files.pythonhosted.org/packages/8d/f0/49129b27c43396581a635d8710dae54a791b17dfc50c70164866bbf865e3/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2", size = 1997060, upload_time = "2024-12-18T11:28:44.709Z" }, - { url = "https://files.pythonhosted.org/packages/0d/0f/943b4af7cd416c477fd40b187036c4f89b416a33d3cc0ab7b82708a667aa/pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4", size = 2004870, upload_time = "2024-12-18T11:28:46.839Z" }, - { url = "https://files.pythonhosted.org/packages/35/40/aea70b5b1a63911c53a4c8117c0a828d6790483f858041f47bab0b779f44/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3", size = 1999822, upload_time = "2024-12-18T11:28:48.896Z" }, - { url = "https://files.pythonhosted.org/packages/f2/b3/807b94fd337d58effc5498fd1a7a4d9d59af4133e83e32ae39a96fddec9d/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4", size = 2130364, upload_time = "2024-12-18T11:28:50.755Z" }, - { url = "https://files.pythonhosted.org/packages/fc/df/791c827cd4ee6efd59248dca9369fb35e80a9484462c33c6649a8d02b565/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57", size = 2158303, upload_time = "2024-12-18T11:28:54.122Z" }, - { url = "https://files.pythonhosted.org/packages/9b/67/4e197c300976af185b7cef4c02203e175fb127e414125916bf1128b639a9/pydantic_core-2.27.2-cp312-cp312-win32.whl", hash = "sha256:1e2cb691ed9834cd6a8be61228471d0a503731abfb42f82458ff27be7b2186fc", size = 1834064, upload_time = "2024-12-18T11:28:56.074Z" }, - { url = "https://files.pythonhosted.org/packages/1f/ea/cd7209a889163b8dcca139fe32b9687dd05249161a3edda62860430457a5/pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9", size = 1989046, upload_time = "2024-12-18T11:28:58.107Z" }, - { url = "https://files.pythonhosted.org/packages/bc/49/c54baab2f4658c26ac633d798dab66b4c3a9bbf47cff5284e9c182f4137a/pydantic_core-2.27.2-cp312-cp312-win_arm64.whl", hash = "sha256:3911ac9284cd8a1792d3cb26a2da18f3ca26c6908cc434a18f730dc0db7bfa3b", size = 1885092, upload_time = "2024-12-18T11:29:01.335Z" }, - { url = "https://files.pythonhosted.org/packages/41/b1/9bc383f48f8002f99104e3acff6cba1231b29ef76cfa45d1506a5cad1f84/pydantic_core-2.27.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7d14bd329640e63852364c306f4d23eb744e0f8193148d4044dd3dacdaacbd8b", size = 1892709, upload_time = "2024-12-18T11:29:03.193Z" }, - { url = "https://files.pythonhosted.org/packages/10/6c/e62b8657b834f3eb2961b49ec8e301eb99946245e70bf42c8817350cbefc/pydantic_core-2.27.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82f91663004eb8ed30ff478d77c4d1179b3563df6cdb15c0817cd1cdaf34d154", size = 1811273, upload_time = "2024-12-18T11:29:05.306Z" }, - { url = "https://files.pythonhosted.org/packages/ba/15/52cfe49c8c986e081b863b102d6b859d9defc63446b642ccbbb3742bf371/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71b24c7d61131bb83df10cc7e687433609963a944ccf45190cfc21e0887b08c9", size = 1823027, upload_time = "2024-12-18T11:29:07.294Z" }, - { url = "https://files.pythonhosted.org/packages/b1/1c/b6f402cfc18ec0024120602bdbcebc7bdd5b856528c013bd4d13865ca473/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa8e459d4954f608fa26116118bb67f56b93b209c39b008277ace29937453dc9", size = 1868888, upload_time = "2024-12-18T11:29:09.249Z" }, - { url = "https://files.pythonhosted.org/packages/bd/7b/8cb75b66ac37bc2975a3b7de99f3c6f355fcc4d89820b61dffa8f1e81677/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8918cbebc8da707ba805b7fd0b382816858728ae7fe19a942080c24e5b7cd1", size = 2037738, upload_time = "2024-12-18T11:29:11.23Z" }, - { url = "https://files.pythonhosted.org/packages/c8/f1/786d8fe78970a06f61df22cba58e365ce304bf9b9f46cc71c8c424e0c334/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eda3f5c2a021bbc5d976107bb302e0131351c2ba54343f8a496dc8783d3d3a6a", size = 2685138, upload_time = "2024-12-18T11:29:16.396Z" }, - { url = "https://files.pythonhosted.org/packages/a6/74/d12b2cd841d8724dc8ffb13fc5cef86566a53ed358103150209ecd5d1999/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8086fa684c4775c27f03f062cbb9eaa6e17f064307e86b21b9e0abc9c0f02e", size = 1997025, upload_time = "2024-12-18T11:29:20.25Z" }, - { url = "https://files.pythonhosted.org/packages/a0/6e/940bcd631bc4d9a06c9539b51f070b66e8f370ed0933f392db6ff350d873/pydantic_core-2.27.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8d9b3388db186ba0c099a6d20f0604a44eabdeef1777ddd94786cdae158729e4", size = 2004633, upload_time = "2024-12-18T11:29:23.877Z" }, - { url = "https://files.pythonhosted.org/packages/50/cc/a46b34f1708d82498c227d5d80ce615b2dd502ddcfd8376fc14a36655af1/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7a66efda2387de898c8f38c0cf7f14fca0b51a8ef0b24bfea5849f1b3c95af27", size = 1999404, upload_time = "2024-12-18T11:29:25.872Z" }, - { url = "https://files.pythonhosted.org/packages/ca/2d/c365cfa930ed23bc58c41463bae347d1005537dc8db79e998af8ba28d35e/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:18a101c168e4e092ab40dbc2503bdc0f62010e95d292b27827871dc85450d7ee", size = 2130130, upload_time = "2024-12-18T11:29:29.252Z" }, - { url = "https://files.pythonhosted.org/packages/f4/d7/eb64d015c350b7cdb371145b54d96c919d4db516817f31cd1c650cae3b21/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ba5dd002f88b78a4215ed2f8ddbdf85e8513382820ba15ad5ad8955ce0ca19a1", size = 2157946, upload_time = "2024-12-18T11:29:31.338Z" }, - { url = "https://files.pythonhosted.org/packages/a4/99/bddde3ddde76c03b65dfd5a66ab436c4e58ffc42927d4ff1198ffbf96f5f/pydantic_core-2.27.2-cp313-cp313-win32.whl", hash = "sha256:1ebaf1d0481914d004a573394f4be3a7616334be70261007e47c2a6fe7e50130", size = 1834387, upload_time = "2024-12-18T11:29:33.481Z" }, - { url = "https://files.pythonhosted.org/packages/71/47/82b5e846e01b26ac6f1893d3c5f9f3a2eb6ba79be26eef0b759b4fe72946/pydantic_core-2.27.2-cp313-cp313-win_amd64.whl", hash = "sha256:953101387ecf2f5652883208769a79e48db18c6df442568a0b5ccd8c2723abee", size = 1990453, upload_time = "2024-12-18T11:29:35.533Z" }, - { url = "https://files.pythonhosted.org/packages/51/b2/b2b50d5ecf21acf870190ae5d093602d95f66c9c31f9d5de6062eb329ad1/pydantic_core-2.27.2-cp313-cp313-win_arm64.whl", hash = "sha256:ac4dbfd1691affb8f48c2c13241a2e3b60ff23247cbcf981759c768b6633cf8b", size = 1885186, upload_time = "2024-12-18T11:29:37.649Z" }, - { url = "https://files.pythonhosted.org/packages/27/97/3aef1ddb65c5ccd6eda9050036c956ff6ecbfe66cb7eb40f280f121a5bb0/pydantic_core-2.27.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:c10eb4f1659290b523af58fa7cffb452a61ad6ae5613404519aee4bfbf1df993", size = 1896475, upload_time = "2024-12-18T11:30:18.316Z" }, - { url = "https://files.pythonhosted.org/packages/ad/d3/5668da70e373c9904ed2f372cb52c0b996426f302e0dee2e65634c92007d/pydantic_core-2.27.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ef592d4bad47296fb11f96cd7dc898b92e795032b4894dfb4076cfccd43a9308", size = 1772279, upload_time = "2024-12-18T11:30:20.547Z" }, - { url = "https://files.pythonhosted.org/packages/8a/9e/e44b8cb0edf04a2f0a1f6425a65ee089c1d6f9c4c2dcab0209127b6fdfc2/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c61709a844acc6bf0b7dce7daae75195a10aac96a596ea1b776996414791ede4", size = 1829112, upload_time = "2024-12-18T11:30:23.255Z" }, - { url = "https://files.pythonhosted.org/packages/1c/90/1160d7ac700102effe11616e8119e268770f2a2aa5afb935f3ee6832987d/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:42c5f762659e47fdb7b16956c71598292f60a03aa92f8b6351504359dbdba6cf", size = 1866780, upload_time = "2024-12-18T11:30:25.742Z" }, - { url = "https://files.pythonhosted.org/packages/ee/33/13983426df09a36d22c15980008f8d9c77674fc319351813b5a2739b70f3/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c9775e339e42e79ec99c441d9730fccf07414af63eac2f0e48e08fd38a64d76", size = 2037943, upload_time = "2024-12-18T11:30:28.036Z" }, - { url = "https://files.pythonhosted.org/packages/01/d7/ced164e376f6747e9158c89988c293cd524ab8d215ae4e185e9929655d5c/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:57762139821c31847cfb2df63c12f725788bd9f04bc2fb392790959b8f70f118", size = 2740492, upload_time = "2024-12-18T11:30:30.412Z" }, - { url = "https://files.pythonhosted.org/packages/8b/1f/3dc6e769d5b7461040778816aab2b00422427bcaa4b56cc89e9c653b2605/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d1e85068e818c73e048fe28cfc769040bb1f475524f4745a5dc621f75ac7630", size = 1995714, upload_time = "2024-12-18T11:30:34.358Z" }, - { url = "https://files.pythonhosted.org/packages/07/d7/a0bd09bc39283530b3f7c27033a814ef254ba3bd0b5cfd040b7abf1fe5da/pydantic_core-2.27.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:097830ed52fd9e427942ff3b9bc17fab52913b2f50f2880dc4a5611446606a54", size = 1997163, upload_time = "2024-12-18T11:30:37.979Z" }, - { url = "https://files.pythonhosted.org/packages/2d/bb/2db4ad1762e1c5699d9b857eeb41959191980de6feb054e70f93085e1bcd/pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:044a50963a614ecfae59bb1eaf7ea7efc4bc62f49ed594e18fa1e5d953c40e9f", size = 2005217, upload_time = "2024-12-18T11:30:40.367Z" }, - { url = "https://files.pythonhosted.org/packages/53/5f/23a5a3e7b8403f8dd8fc8a6f8b49f6b55c7d715b77dcf1f8ae919eeb5628/pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:4e0b4220ba5b40d727c7f879eac379b822eee5d8fff418e9d3381ee45b3b0362", size = 2127899, upload_time = "2024-12-18T11:30:42.737Z" }, - { url = "https://files.pythonhosted.org/packages/c2/ae/aa38bb8dd3d89c2f1d8362dd890ee8f3b967330821d03bbe08fa01ce3766/pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5e4f4bb20d75e9325cc9696c6802657b58bc1dbbe3022f32cc2b2b632c3fbb96", size = 2155726, upload_time = "2024-12-18T11:30:45.279Z" }, - { url = "https://files.pythonhosted.org/packages/98/61/4f784608cc9e98f70839187117ce840480f768fed5d386f924074bf6213c/pydantic_core-2.27.2-cp39-cp39-win32.whl", hash = "sha256:cca63613e90d001b9f2f9a9ceb276c308bfa2a43fafb75c8031c4f66039e8c6e", size = 1817219, upload_time = "2024-12-18T11:30:47.718Z" }, - { url = "https://files.pythonhosted.org/packages/57/82/bb16a68e4a1a858bb3768c2c8f1ff8d8978014e16598f001ea29a25bf1d1/pydantic_core-2.27.2-cp39-cp39-win_amd64.whl", hash = "sha256:77d1bca19b0f7021b3a982e6f903dcd5b2b06076def36a652e3907f596e29f67", size = 1985382, upload_time = "2024-12-18T11:30:51.871Z" }, - { url = "https://files.pythonhosted.org/packages/46/72/af70981a341500419e67d5cb45abe552a7c74b66326ac8877588488da1ac/pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2bf14caea37e91198329b828eae1618c068dfb8ef17bb33287a7ad4b61ac314e", size = 1891159, upload_time = "2024-12-18T11:30:54.382Z" }, - { url = "https://files.pythonhosted.org/packages/ad/3d/c5913cccdef93e0a6a95c2d057d2c2cba347815c845cda79ddd3c0f5e17d/pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0cb791f5b45307caae8810c2023a184c74605ec3bcbb67d13846c28ff731ff8", size = 1768331, upload_time = "2024-12-18T11:30:58.178Z" }, - { url = "https://files.pythonhosted.org/packages/f6/f0/a3ae8fbee269e4934f14e2e0e00928f9346c5943174f2811193113e58252/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:688d3fd9fcb71f41c4c015c023d12a79d1c4c0732ec9eb35d96e3388a120dcf3", size = 1822467, upload_time = "2024-12-18T11:31:00.6Z" }, - { url = "https://files.pythonhosted.org/packages/d7/7a/7bbf241a04e9f9ea24cd5874354a83526d639b02674648af3f350554276c/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d591580c34f4d731592f0e9fe40f9cc1b430d297eecc70b962e93c5c668f15f", size = 1979797, upload_time = "2024-12-18T11:31:07.243Z" }, - { url = "https://files.pythonhosted.org/packages/4f/5f/4784c6107731f89e0005a92ecb8a2efeafdb55eb992b8e9d0a2be5199335/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:82f986faf4e644ffc189a7f1aafc86e46ef70372bb153e7001e8afccc6e54133", size = 1987839, upload_time = "2024-12-18T11:31:09.775Z" }, - { url = "https://files.pythonhosted.org/packages/6d/a7/61246562b651dff00de86a5f01b6e4befb518df314c54dec187a78d81c84/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:bec317a27290e2537f922639cafd54990551725fc844249e64c523301d0822fc", size = 1998861, upload_time = "2024-12-18T11:31:13.469Z" }, - { url = "https://files.pythonhosted.org/packages/86/aa/837821ecf0c022bbb74ca132e117c358321e72e7f9702d1b6a03758545e2/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:0296abcb83a797db256b773f45773da397da75a08f5fcaef41f2044adec05f50", size = 2116582, upload_time = "2024-12-18T11:31:17.423Z" }, - { url = "https://files.pythonhosted.org/packages/81/b0/5e74656e95623cbaa0a6278d16cf15e10a51f6002e3ec126541e95c29ea3/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:0d75070718e369e452075a6017fbf187f788e17ed67a3abd47fa934d001863d9", size = 2151985, upload_time = "2024-12-18T11:31:19.901Z" }, - { url = "https://files.pythonhosted.org/packages/63/37/3e32eeb2a451fddaa3898e2163746b0cffbbdbb4740d38372db0490d67f3/pydantic_core-2.27.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7e17b560be3c98a8e3aa66ce828bdebb9e9ac6ad5466fba92eb74c4c95cb1151", size = 2004715, upload_time = "2024-12-18T11:31:22.821Z" }, - { url = "https://files.pythonhosted.org/packages/29/0e/dcaea00c9dbd0348b723cae82b0e0c122e0fa2b43fa933e1622fd237a3ee/pydantic_core-2.27.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c33939a82924da9ed65dab5a65d427205a73181d8098e79b6b426bdf8ad4e656", size = 1891733, upload_time = "2024-12-18T11:31:26.876Z" }, - { url = "https://files.pythonhosted.org/packages/86/d3/e797bba8860ce650272bda6383a9d8cad1d1c9a75a640c9d0e848076f85e/pydantic_core-2.27.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:00bad2484fa6bda1e216e7345a798bd37c68fb2d97558edd584942aa41b7d278", size = 1768375, upload_time = "2024-12-18T11:31:29.276Z" }, - { url = "https://files.pythonhosted.org/packages/41/f7/f847b15fb14978ca2b30262548f5fc4872b2724e90f116393eb69008299d/pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c817e2b40aba42bac6f457498dacabc568c3b7a986fc9ba7c8d9d260b71485fb", size = 1822307, upload_time = "2024-12-18T11:31:33.123Z" }, - { url = "https://files.pythonhosted.org/packages/9c/63/ed80ec8255b587b2f108e514dc03eed1546cd00f0af281e699797f373f38/pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:251136cdad0cb722e93732cb45ca5299fb56e1344a833640bf93b2803f8d1bfd", size = 1979971, upload_time = "2024-12-18T11:31:35.755Z" }, - { url = "https://files.pythonhosted.org/packages/a9/6d/6d18308a45454a0de0e975d70171cadaf454bc7a0bf86b9c7688e313f0bb/pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d2088237af596f0a524d3afc39ab3b036e8adb054ee57cbb1dcf8e09da5b29cc", size = 1987616, upload_time = "2024-12-18T11:31:38.534Z" }, - { url = "https://files.pythonhosted.org/packages/82/8a/05f8780f2c1081b800a7ca54c1971e291c2d07d1a50fb23c7e4aef4ed403/pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:d4041c0b966a84b4ae7a09832eb691a35aec90910cd2dbe7a208de59be77965b", size = 1998943, upload_time = "2024-12-18T11:31:41.853Z" }, - { url = "https://files.pythonhosted.org/packages/5e/3e/fe5b6613d9e4c0038434396b46c5303f5ade871166900b357ada4766c5b7/pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:8083d4e875ebe0b864ffef72a4304827015cff328a1be6e22cc850753bfb122b", size = 2116654, upload_time = "2024-12-18T11:31:44.756Z" }, - { url = "https://files.pythonhosted.org/packages/db/ad/28869f58938fad8cc84739c4e592989730bfb69b7c90a8fff138dff18e1e/pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f141ee28a0ad2123b6611b6ceff018039df17f32ada8b534e6aa039545a3efb2", size = 2152292, upload_time = "2024-12-18T11:31:48.613Z" }, - { url = "https://files.pythonhosted.org/packages/a1/0c/c5c5cd3689c32ed1fe8c5d234b079c12c281c051759770c05b8bed6412b5/pydantic_core-2.27.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7d0c8399fcc1848491f00e0314bd59fb34a9c008761bcb422a057670c3f65e35", size = 2004961, upload_time = "2024-12-18T11:31:52.446Z" }, + { url = "https://files.pythonhosted.org/packages/3a/bc/fed5f74b5d802cf9a03e83f60f18864e90e3aed7223adaca5ffb7a8d8d64/pydantic_core-2.27.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2d367ca20b2f14095a8f4fa1210f5a7b78b8a20009ecced6b12818f455b1e9fa", size = 1895938 }, + { url = "https://files.pythonhosted.org/packages/71/2a/185aff24ce844e39abb8dd680f4e959f0006944f4a8a0ea372d9f9ae2e53/pydantic_core-2.27.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:491a2b73db93fab69731eaee494f320faa4e093dbed776be1a829c2eb222c34c", size = 1815684 }, + { url = "https://files.pythonhosted.org/packages/c3/43/fafabd3d94d159d4f1ed62e383e264f146a17dd4d48453319fd782e7979e/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7969e133a6f183be60e9f6f56bfae753585680f3b7307a8e555a948d443cc05a", size = 1829169 }, + { url = "https://files.pythonhosted.org/packages/a2/d1/f2dfe1a2a637ce6800b799aa086d079998959f6f1215eb4497966efd2274/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3de9961f2a346257caf0aa508a4da705467f53778e9ef6fe744c038119737ef5", size = 1867227 }, + { url = "https://files.pythonhosted.org/packages/7d/39/e06fcbcc1c785daa3160ccf6c1c38fea31f5754b756e34b65f74e99780b5/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e2bb4d3e5873c37bb3dd58714d4cd0b0e6238cebc4177ac8fe878f8b3aa8e74c", size = 2037695 }, + { url = "https://files.pythonhosted.org/packages/7a/67/61291ee98e07f0650eb756d44998214231f50751ba7e13f4f325d95249ab/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:280d219beebb0752699480fe8f1dc61ab6615c2046d76b7ab7ee38858de0a4e7", size = 2741662 }, + { url = "https://files.pythonhosted.org/packages/32/90/3b15e31b88ca39e9e626630b4c4a1f5a0dfd09076366f4219429e6786076/pydantic_core-2.27.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47956ae78b6422cbd46f772f1746799cbb862de838fd8d1fbd34a82e05b0983a", size = 1993370 }, + { url = "https://files.pythonhosted.org/packages/ff/83/c06d333ee3a67e2e13e07794995c1535565132940715931c1c43bfc85b11/pydantic_core-2.27.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:14d4a5c49d2f009d62a2a7140d3064f686d17a5d1a268bc641954ba181880236", size = 1996813 }, + { url = "https://files.pythonhosted.org/packages/7c/f7/89be1c8deb6e22618a74f0ca0d933fdcb8baa254753b26b25ad3acff8f74/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:337b443af21d488716f8d0b6164de833e788aa6bd7e3a39c005febc1284f4962", size = 2005287 }, + { url = "https://files.pythonhosted.org/packages/b7/7d/8eb3e23206c00ef7feee17b83a4ffa0a623eb1a9d382e56e4aa46fd15ff2/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:03d0f86ea3184a12f41a2d23f7ccb79cdb5a18e06993f8a45baa8dfec746f0e9", size = 2128414 }, + { url = "https://files.pythonhosted.org/packages/4e/99/fe80f3ff8dd71a3ea15763878d464476e6cb0a2db95ff1c5c554133b6b83/pydantic_core-2.27.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7041c36f5680c6e0f08d922aed302e98b3745d97fe1589db0a3eebf6624523af", size = 2155301 }, + { url = "https://files.pythonhosted.org/packages/2b/a3/e50460b9a5789ca1451b70d4f52546fa9e2b420ba3bfa6100105c0559238/pydantic_core-2.27.2-cp310-cp310-win32.whl", hash = "sha256:50a68f3e3819077be2c98110c1f9dcb3817e93f267ba80a2c05bb4f8799e2ff4", size = 1816685 }, + { url = "https://files.pythonhosted.org/packages/57/4c/a8838731cb0f2c2a39d3535376466de6049034d7b239c0202a64aaa05533/pydantic_core-2.27.2-cp310-cp310-win_amd64.whl", hash = "sha256:e0fd26b16394ead34a424eecf8a31a1f5137094cabe84a1bcb10fa6ba39d3d31", size = 1982876 }, + { url = "https://files.pythonhosted.org/packages/c2/89/f3450af9d09d44eea1f2c369f49e8f181d742f28220f88cc4dfaae91ea6e/pydantic_core-2.27.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:8e10c99ef58cfdf2a66fc15d66b16c4a04f62bca39db589ae8cba08bc55331bc", size = 1893421 }, + { url = "https://files.pythonhosted.org/packages/9e/e3/71fe85af2021f3f386da42d291412e5baf6ce7716bd7101ea49c810eda90/pydantic_core-2.27.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:26f32e0adf166a84d0cb63be85c562ca8a6fa8de28e5f0d92250c6b7e9e2aff7", size = 1814998 }, + { url = "https://files.pythonhosted.org/packages/a6/3c/724039e0d848fd69dbf5806894e26479577316c6f0f112bacaf67aa889ac/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c19d1ea0673cd13cc2f872f6c9ab42acc4e4f492a7ca9d3795ce2b112dd7e15", size = 1826167 }, + { url = "https://files.pythonhosted.org/packages/2b/5b/1b29e8c1fb5f3199a9a57c1452004ff39f494bbe9bdbe9a81e18172e40d3/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e68c4446fe0810e959cdff46ab0a41ce2f2c86d227d96dc3847af0ba7def306", size = 1865071 }, + { url = "https://files.pythonhosted.org/packages/89/6c/3985203863d76bb7d7266e36970d7e3b6385148c18a68cc8915fd8c84d57/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d9640b0059ff4f14d1f37321b94061c6db164fbe49b334b31643e0528d100d99", size = 2036244 }, + { url = "https://files.pythonhosted.org/packages/0e/41/f15316858a246b5d723f7d7f599f79e37493b2e84bfc789e58d88c209f8a/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40d02e7d45c9f8af700f3452f329ead92da4c5f4317ca9b896de7ce7199ea459", size = 2737470 }, + { url = "https://files.pythonhosted.org/packages/a8/7c/b860618c25678bbd6d1d99dbdfdf0510ccb50790099b963ff78a124b754f/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c1fd185014191700554795c99b347d64f2bb637966c4cfc16998a0ca700d048", size = 1992291 }, + { url = "https://files.pythonhosted.org/packages/bf/73/42c3742a391eccbeab39f15213ecda3104ae8682ba3c0c28069fbcb8c10d/pydantic_core-2.27.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d81d2068e1c1228a565af076598f9e7451712700b673de8f502f0334f281387d", size = 1994613 }, + { url = "https://files.pythonhosted.org/packages/94/7a/941e89096d1175d56f59340f3a8ebaf20762fef222c298ea96d36a6328c5/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1a4207639fb02ec2dbb76227d7c751a20b1a6b4bc52850568e52260cae64ca3b", size = 2002355 }, + { url = "https://files.pythonhosted.org/packages/6e/95/2359937a73d49e336a5a19848713555605d4d8d6940c3ec6c6c0ca4dcf25/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:3de3ce3c9ddc8bbd88f6e0e304dea0e66d843ec9de1b0042b0911c1663ffd474", size = 2126661 }, + { url = "https://files.pythonhosted.org/packages/2b/4c/ca02b7bdb6012a1adef21a50625b14f43ed4d11f1fc237f9d7490aa5078c/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:30c5f68ded0c36466acede341551106821043e9afaad516adfb6e8fa80a4e6a6", size = 2153261 }, + { url = "https://files.pythonhosted.org/packages/72/9d/a241db83f973049a1092a079272ffe2e3e82e98561ef6214ab53fe53b1c7/pydantic_core-2.27.2-cp311-cp311-win32.whl", hash = "sha256:c70c26d2c99f78b125a3459f8afe1aed4d9687c24fd677c6a4436bc042e50d6c", size = 1812361 }, + { url = "https://files.pythonhosted.org/packages/e8/ef/013f07248041b74abd48a385e2110aa3a9bbfef0fbd97d4e6d07d2f5b89a/pydantic_core-2.27.2-cp311-cp311-win_amd64.whl", hash = "sha256:08e125dbdc505fa69ca7d9c499639ab6407cfa909214d500897d02afb816e7cc", size = 1982484 }, + { url = "https://files.pythonhosted.org/packages/10/1c/16b3a3e3398fd29dca77cea0a1d998d6bde3902fa2706985191e2313cc76/pydantic_core-2.27.2-cp311-cp311-win_arm64.whl", hash = "sha256:26f0d68d4b235a2bae0c3fc585c585b4ecc51382db0e3ba402a22cbc440915e4", size = 1867102 }, + { url = "https://files.pythonhosted.org/packages/d6/74/51c8a5482ca447871c93e142d9d4a92ead74de6c8dc5e66733e22c9bba89/pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0", size = 1893127 }, + { url = "https://files.pythonhosted.org/packages/d3/f3/c97e80721735868313c58b89d2de85fa80fe8dfeeed84dc51598b92a135e/pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef", size = 1811340 }, + { url = "https://files.pythonhosted.org/packages/9e/91/840ec1375e686dbae1bd80a9e46c26a1e0083e1186abc610efa3d9a36180/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7", size = 1822900 }, + { url = "https://files.pythonhosted.org/packages/f6/31/4240bc96025035500c18adc149aa6ffdf1a0062a4b525c932065ceb4d868/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934", size = 1869177 }, + { url = "https://files.pythonhosted.org/packages/fa/20/02fbaadb7808be578317015c462655c317a77a7c8f0ef274bc016a784c54/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6", size = 2038046 }, + { url = "https://files.pythonhosted.org/packages/06/86/7f306b904e6c9eccf0668248b3f272090e49c275bc488a7b88b0823444a4/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c", size = 2685386 }, + { url = "https://files.pythonhosted.org/packages/8d/f0/49129b27c43396581a635d8710dae54a791b17dfc50c70164866bbf865e3/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2", size = 1997060 }, + { url = "https://files.pythonhosted.org/packages/0d/0f/943b4af7cd416c477fd40b187036c4f89b416a33d3cc0ab7b82708a667aa/pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4", size = 2004870 }, + { url = "https://files.pythonhosted.org/packages/35/40/aea70b5b1a63911c53a4c8117c0a828d6790483f858041f47bab0b779f44/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3", size = 1999822 }, + { url = "https://files.pythonhosted.org/packages/f2/b3/807b94fd337d58effc5498fd1a7a4d9d59af4133e83e32ae39a96fddec9d/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4", size = 2130364 }, + { url = "https://files.pythonhosted.org/packages/fc/df/791c827cd4ee6efd59248dca9369fb35e80a9484462c33c6649a8d02b565/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57", size = 2158303 }, + { url = "https://files.pythonhosted.org/packages/9b/67/4e197c300976af185b7cef4c02203e175fb127e414125916bf1128b639a9/pydantic_core-2.27.2-cp312-cp312-win32.whl", hash = "sha256:1e2cb691ed9834cd6a8be61228471d0a503731abfb42f82458ff27be7b2186fc", size = 1834064 }, + { url = "https://files.pythonhosted.org/packages/1f/ea/cd7209a889163b8dcca139fe32b9687dd05249161a3edda62860430457a5/pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9", size = 1989046 }, + { url = "https://files.pythonhosted.org/packages/bc/49/c54baab2f4658c26ac633d798dab66b4c3a9bbf47cff5284e9c182f4137a/pydantic_core-2.27.2-cp312-cp312-win_arm64.whl", hash = "sha256:3911ac9284cd8a1792d3cb26a2da18f3ca26c6908cc434a18f730dc0db7bfa3b", size = 1885092 }, + { url = "https://files.pythonhosted.org/packages/41/b1/9bc383f48f8002f99104e3acff6cba1231b29ef76cfa45d1506a5cad1f84/pydantic_core-2.27.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7d14bd329640e63852364c306f4d23eb744e0f8193148d4044dd3dacdaacbd8b", size = 1892709 }, + { url = "https://files.pythonhosted.org/packages/10/6c/e62b8657b834f3eb2961b49ec8e301eb99946245e70bf42c8817350cbefc/pydantic_core-2.27.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82f91663004eb8ed30ff478d77c4d1179b3563df6cdb15c0817cd1cdaf34d154", size = 1811273 }, + { url = "https://files.pythonhosted.org/packages/ba/15/52cfe49c8c986e081b863b102d6b859d9defc63446b642ccbbb3742bf371/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71b24c7d61131bb83df10cc7e687433609963a944ccf45190cfc21e0887b08c9", size = 1823027 }, + { url = "https://files.pythonhosted.org/packages/b1/1c/b6f402cfc18ec0024120602bdbcebc7bdd5b856528c013bd4d13865ca473/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa8e459d4954f608fa26116118bb67f56b93b209c39b008277ace29937453dc9", size = 1868888 }, + { url = "https://files.pythonhosted.org/packages/bd/7b/8cb75b66ac37bc2975a3b7de99f3c6f355fcc4d89820b61dffa8f1e81677/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8918cbebc8da707ba805b7fd0b382816858728ae7fe19a942080c24e5b7cd1", size = 2037738 }, + { url = "https://files.pythonhosted.org/packages/c8/f1/786d8fe78970a06f61df22cba58e365ce304bf9b9f46cc71c8c424e0c334/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eda3f5c2a021bbc5d976107bb302e0131351c2ba54343f8a496dc8783d3d3a6a", size = 2685138 }, + { url = "https://files.pythonhosted.org/packages/a6/74/d12b2cd841d8724dc8ffb13fc5cef86566a53ed358103150209ecd5d1999/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8086fa684c4775c27f03f062cbb9eaa6e17f064307e86b21b9e0abc9c0f02e", size = 1997025 }, + { url = "https://files.pythonhosted.org/packages/a0/6e/940bcd631bc4d9a06c9539b51f070b66e8f370ed0933f392db6ff350d873/pydantic_core-2.27.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8d9b3388db186ba0c099a6d20f0604a44eabdeef1777ddd94786cdae158729e4", size = 2004633 }, + { url = "https://files.pythonhosted.org/packages/50/cc/a46b34f1708d82498c227d5d80ce615b2dd502ddcfd8376fc14a36655af1/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7a66efda2387de898c8f38c0cf7f14fca0b51a8ef0b24bfea5849f1b3c95af27", size = 1999404 }, + { url = "https://files.pythonhosted.org/packages/ca/2d/c365cfa930ed23bc58c41463bae347d1005537dc8db79e998af8ba28d35e/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:18a101c168e4e092ab40dbc2503bdc0f62010e95d292b27827871dc85450d7ee", size = 2130130 }, + { url = "https://files.pythonhosted.org/packages/f4/d7/eb64d015c350b7cdb371145b54d96c919d4db516817f31cd1c650cae3b21/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ba5dd002f88b78a4215ed2f8ddbdf85e8513382820ba15ad5ad8955ce0ca19a1", size = 2157946 }, + { url = "https://files.pythonhosted.org/packages/a4/99/bddde3ddde76c03b65dfd5a66ab436c4e58ffc42927d4ff1198ffbf96f5f/pydantic_core-2.27.2-cp313-cp313-win32.whl", hash = "sha256:1ebaf1d0481914d004a573394f4be3a7616334be70261007e47c2a6fe7e50130", size = 1834387 }, + { url = "https://files.pythonhosted.org/packages/71/47/82b5e846e01b26ac6f1893d3c5f9f3a2eb6ba79be26eef0b759b4fe72946/pydantic_core-2.27.2-cp313-cp313-win_amd64.whl", hash = "sha256:953101387ecf2f5652883208769a79e48db18c6df442568a0b5ccd8c2723abee", size = 1990453 }, + { url = "https://files.pythonhosted.org/packages/51/b2/b2b50d5ecf21acf870190ae5d093602d95f66c9c31f9d5de6062eb329ad1/pydantic_core-2.27.2-cp313-cp313-win_arm64.whl", hash = "sha256:ac4dbfd1691affb8f48c2c13241a2e3b60ff23247cbcf981759c768b6633cf8b", size = 1885186 }, + { url = "https://files.pythonhosted.org/packages/27/97/3aef1ddb65c5ccd6eda9050036c956ff6ecbfe66cb7eb40f280f121a5bb0/pydantic_core-2.27.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:c10eb4f1659290b523af58fa7cffb452a61ad6ae5613404519aee4bfbf1df993", size = 1896475 }, + { url = "https://files.pythonhosted.org/packages/ad/d3/5668da70e373c9904ed2f372cb52c0b996426f302e0dee2e65634c92007d/pydantic_core-2.27.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ef592d4bad47296fb11f96cd7dc898b92e795032b4894dfb4076cfccd43a9308", size = 1772279 }, + { url = "https://files.pythonhosted.org/packages/8a/9e/e44b8cb0edf04a2f0a1f6425a65ee089c1d6f9c4c2dcab0209127b6fdfc2/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c61709a844acc6bf0b7dce7daae75195a10aac96a596ea1b776996414791ede4", size = 1829112 }, + { url = "https://files.pythonhosted.org/packages/1c/90/1160d7ac700102effe11616e8119e268770f2a2aa5afb935f3ee6832987d/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:42c5f762659e47fdb7b16956c71598292f60a03aa92f8b6351504359dbdba6cf", size = 1866780 }, + { url = "https://files.pythonhosted.org/packages/ee/33/13983426df09a36d22c15980008f8d9c77674fc319351813b5a2739b70f3/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4c9775e339e42e79ec99c441d9730fccf07414af63eac2f0e48e08fd38a64d76", size = 2037943 }, + { url = "https://files.pythonhosted.org/packages/01/d7/ced164e376f6747e9158c89988c293cd524ab8d215ae4e185e9929655d5c/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:57762139821c31847cfb2df63c12f725788bd9f04bc2fb392790959b8f70f118", size = 2740492 }, + { url = "https://files.pythonhosted.org/packages/8b/1f/3dc6e769d5b7461040778816aab2b00422427bcaa4b56cc89e9c653b2605/pydantic_core-2.27.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d1e85068e818c73e048fe28cfc769040bb1f475524f4745a5dc621f75ac7630", size = 1995714 }, + { url = "https://files.pythonhosted.org/packages/07/d7/a0bd09bc39283530b3f7c27033a814ef254ba3bd0b5cfd040b7abf1fe5da/pydantic_core-2.27.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:097830ed52fd9e427942ff3b9bc17fab52913b2f50f2880dc4a5611446606a54", size = 1997163 }, + { url = "https://files.pythonhosted.org/packages/2d/bb/2db4ad1762e1c5699d9b857eeb41959191980de6feb054e70f93085e1bcd/pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:044a50963a614ecfae59bb1eaf7ea7efc4bc62f49ed594e18fa1e5d953c40e9f", size = 2005217 }, + { url = "https://files.pythonhosted.org/packages/53/5f/23a5a3e7b8403f8dd8fc8a6f8b49f6b55c7d715b77dcf1f8ae919eeb5628/pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:4e0b4220ba5b40d727c7f879eac379b822eee5d8fff418e9d3381ee45b3b0362", size = 2127899 }, + { url = "https://files.pythonhosted.org/packages/c2/ae/aa38bb8dd3d89c2f1d8362dd890ee8f3b967330821d03bbe08fa01ce3766/pydantic_core-2.27.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5e4f4bb20d75e9325cc9696c6802657b58bc1dbbe3022f32cc2b2b632c3fbb96", size = 2155726 }, + { url = "https://files.pythonhosted.org/packages/98/61/4f784608cc9e98f70839187117ce840480f768fed5d386f924074bf6213c/pydantic_core-2.27.2-cp39-cp39-win32.whl", hash = "sha256:cca63613e90d001b9f2f9a9ceb276c308bfa2a43fafb75c8031c4f66039e8c6e", size = 1817219 }, + { url = "https://files.pythonhosted.org/packages/57/82/bb16a68e4a1a858bb3768c2c8f1ff8d8978014e16598f001ea29a25bf1d1/pydantic_core-2.27.2-cp39-cp39-win_amd64.whl", hash = "sha256:77d1bca19b0f7021b3a982e6f903dcd5b2b06076def36a652e3907f596e29f67", size = 1985382 }, + { url = "https://files.pythonhosted.org/packages/46/72/af70981a341500419e67d5cb45abe552a7c74b66326ac8877588488da1ac/pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:2bf14caea37e91198329b828eae1618c068dfb8ef17bb33287a7ad4b61ac314e", size = 1891159 }, + { url = "https://files.pythonhosted.org/packages/ad/3d/c5913cccdef93e0a6a95c2d057d2c2cba347815c845cda79ddd3c0f5e17d/pydantic_core-2.27.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0cb791f5b45307caae8810c2023a184c74605ec3bcbb67d13846c28ff731ff8", size = 1768331 }, + { url = "https://files.pythonhosted.org/packages/f6/f0/a3ae8fbee269e4934f14e2e0e00928f9346c5943174f2811193113e58252/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:688d3fd9fcb71f41c4c015c023d12a79d1c4c0732ec9eb35d96e3388a120dcf3", size = 1822467 }, + { url = "https://files.pythonhosted.org/packages/d7/7a/7bbf241a04e9f9ea24cd5874354a83526d639b02674648af3f350554276c/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d591580c34f4d731592f0e9fe40f9cc1b430d297eecc70b962e93c5c668f15f", size = 1979797 }, + { url = "https://files.pythonhosted.org/packages/4f/5f/4784c6107731f89e0005a92ecb8a2efeafdb55eb992b8e9d0a2be5199335/pydantic_core-2.27.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:82f986faf4e644ffc189a7f1aafc86e46ef70372bb153e7001e8afccc6e54133", size = 1987839 }, + { url = "https://files.pythonhosted.org/packages/6d/a7/61246562b651dff00de86a5f01b6e4befb518df314c54dec187a78d81c84/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:bec317a27290e2537f922639cafd54990551725fc844249e64c523301d0822fc", size = 1998861 }, + { url = "https://files.pythonhosted.org/packages/86/aa/837821ecf0c022bbb74ca132e117c358321e72e7f9702d1b6a03758545e2/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:0296abcb83a797db256b773f45773da397da75a08f5fcaef41f2044adec05f50", size = 2116582 }, + { url = "https://files.pythonhosted.org/packages/81/b0/5e74656e95623cbaa0a6278d16cf15e10a51f6002e3ec126541e95c29ea3/pydantic_core-2.27.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:0d75070718e369e452075a6017fbf187f788e17ed67a3abd47fa934d001863d9", size = 2151985 }, + { url = "https://files.pythonhosted.org/packages/63/37/3e32eeb2a451fddaa3898e2163746b0cffbbdbb4740d38372db0490d67f3/pydantic_core-2.27.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7e17b560be3c98a8e3aa66ce828bdebb9e9ac6ad5466fba92eb74c4c95cb1151", size = 2004715 }, + { url = "https://files.pythonhosted.org/packages/29/0e/dcaea00c9dbd0348b723cae82b0e0c122e0fa2b43fa933e1622fd237a3ee/pydantic_core-2.27.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c33939a82924da9ed65dab5a65d427205a73181d8098e79b6b426bdf8ad4e656", size = 1891733 }, + { url = "https://files.pythonhosted.org/packages/86/d3/e797bba8860ce650272bda6383a9d8cad1d1c9a75a640c9d0e848076f85e/pydantic_core-2.27.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:00bad2484fa6bda1e216e7345a798bd37c68fb2d97558edd584942aa41b7d278", size = 1768375 }, + { url = "https://files.pythonhosted.org/packages/41/f7/f847b15fb14978ca2b30262548f5fc4872b2724e90f116393eb69008299d/pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c817e2b40aba42bac6f457498dacabc568c3b7a986fc9ba7c8d9d260b71485fb", size = 1822307 }, + { url = "https://files.pythonhosted.org/packages/9c/63/ed80ec8255b587b2f108e514dc03eed1546cd00f0af281e699797f373f38/pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:251136cdad0cb722e93732cb45ca5299fb56e1344a833640bf93b2803f8d1bfd", size = 1979971 }, + { url = "https://files.pythonhosted.org/packages/a9/6d/6d18308a45454a0de0e975d70171cadaf454bc7a0bf86b9c7688e313f0bb/pydantic_core-2.27.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d2088237af596f0a524d3afc39ab3b036e8adb054ee57cbb1dcf8e09da5b29cc", size = 1987616 }, + { url = "https://files.pythonhosted.org/packages/82/8a/05f8780f2c1081b800a7ca54c1971e291c2d07d1a50fb23c7e4aef4ed403/pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:d4041c0b966a84b4ae7a09832eb691a35aec90910cd2dbe7a208de59be77965b", size = 1998943 }, + { url = "https://files.pythonhosted.org/packages/5e/3e/fe5b6613d9e4c0038434396b46c5303f5ade871166900b357ada4766c5b7/pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:8083d4e875ebe0b864ffef72a4304827015cff328a1be6e22cc850753bfb122b", size = 2116654 }, + { url = "https://files.pythonhosted.org/packages/db/ad/28869f58938fad8cc84739c4e592989730bfb69b7c90a8fff138dff18e1e/pydantic_core-2.27.2-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f141ee28a0ad2123b6611b6ceff018039df17f32ada8b534e6aa039545a3efb2", size = 2152292 }, + { url = "https://files.pythonhosted.org/packages/a1/0c/c5c5cd3689c32ed1fe8c5d234b079c12c281c051759770c05b8bed6412b5/pydantic_core-2.27.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7d0c8399fcc1848491f00e0314bd59fb34a9c008761bcb422a057670c3f65e35", size = 2004961 }, ] [[package]] name = "pyhamcrest" version = "2.1.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/16/3f/f286caba4e64391a8dc9200e6de6ce0d07471e3f718248c3276843b7793b/pyhamcrest-2.1.0.tar.gz", hash = "sha256:c6acbec0923d0cb7e72c22af1926f3e7c97b8e8d69fc7498eabacaf7c975bd9c", size = 60538, upload_time = "2023-10-22T15:47:28.255Z" } +sdist = { url = "https://files.pythonhosted.org/packages/16/3f/f286caba4e64391a8dc9200e6de6ce0d07471e3f718248c3276843b7793b/pyhamcrest-2.1.0.tar.gz", hash = "sha256:c6acbec0923d0cb7e72c22af1926f3e7c97b8e8d69fc7498eabacaf7c975bd9c", size = 60538 } wheels = [ - { url = "https://files.pythonhosted.org/packages/0c/71/1b25d3797a24add00f6f8c1bb0ac03a38616e2ec6606f598c1d50b0b0ffb/pyhamcrest-2.1.0-py3-none-any.whl", hash = "sha256:f6913d2f392e30e0375b3ecbd7aee79e5d1faa25d345c8f4ff597665dcac2587", size = 54555, upload_time = "2023-10-22T15:47:25.08Z" }, + { url = "https://files.pythonhosted.org/packages/0c/71/1b25d3797a24add00f6f8c1bb0ac03a38616e2ec6606f598c1d50b0b0ffb/pyhamcrest-2.1.0-py3-none-any.whl", hash = "sha256:f6913d2f392e30e0375b3ecbd7aee79e5d1faa25d345c8f4ff597665dcac2587", size = 54555 }, ] [[package]] @@ -747,9 +748,9 @@ dependencies = [ { name = "pluggy" }, { name = "tomli", marker = "python_full_version < '3.11'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/8b/6c/62bbd536103af674e227c41a8f3dcd022d591f6eed5facb5a0f31ee33bbc/pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181", size = 1442487, upload_time = "2024-09-10T10:52:15.003Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/6c/62bbd536103af674e227c41a8f3dcd022d591f6eed5facb5a0f31ee33bbc/pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181", size = 1442487 } wheels = [ - { url = "https://files.pythonhosted.org/packages/6b/77/7440a06a8ead44c7757a64362dd22df5760f9b12dc5f11b6188cd2fc27a0/pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2", size = 342341, upload_time = "2024-09-10T10:52:12.54Z" }, + { url = "https://files.pythonhosted.org/packages/6b/77/7440a06a8ead44c7757a64362dd22df5760f9b12dc5f11b6188cd2fc27a0/pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2", size = 342341 }, ] [[package]] @@ -759,9 +760,9 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pytest" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/de/b4/0b378b7bf26a8ae161c3890c0b48a91a04106c5713ce81b4b080ea2f4f18/pytest_asyncio-0.23.8.tar.gz", hash = "sha256:759b10b33a6dc61cce40a8bd5205e302978bbbcc00e279a8b61d9a6a3c82e4d3", size = 46920, upload_time = "2024-07-17T17:39:34.617Z" } +sdist = { url = "https://files.pythonhosted.org/packages/de/b4/0b378b7bf26a8ae161c3890c0b48a91a04106c5713ce81b4b080ea2f4f18/pytest_asyncio-0.23.8.tar.gz", hash = "sha256:759b10b33a6dc61cce40a8bd5205e302978bbbcc00e279a8b61d9a6a3c82e4d3", size = 46920 } wheels = [ - { url = "https://files.pythonhosted.org/packages/ee/82/62e2d63639ecb0fbe8a7ee59ef0bc69a4669ec50f6d3459f74ad4e4189a2/pytest_asyncio-0.23.8-py3-none-any.whl", hash = "sha256:50265d892689a5faefb84df80819d1ecef566eb3549cf915dfb33569359d1ce2", size = 17663, upload_time = "2024-07-17T17:39:32.478Z" }, + { url = "https://files.pythonhosted.org/packages/ee/82/62e2d63639ecb0fbe8a7ee59ef0bc69a4669ec50f6d3459f74ad4e4189a2/pytest_asyncio-0.23.8-py3-none-any.whl", hash = "sha256:50265d892689a5faefb84df80819d1ecef566eb3549cf915dfb33569359d1ce2", size = 17663 }, ] [[package]] @@ -771,18 +772,18 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "six" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload_time = "2024-03-01T18:36:20.211Z" } +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } wheels = [ - { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload_time = "2024-03-01T18:36:18.57Z" }, + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, ] [[package]] name = "python-dotenv" version = "1.0.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/bc/57/e84d88dfe0aec03b7a2d4327012c1627ab5f03652216c63d49846d7a6c58/python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca", size = 39115, upload_time = "2024-01-23T06:33:00.505Z" } +sdist = { url = "https://files.pythonhosted.org/packages/bc/57/e84d88dfe0aec03b7a2d4327012c1627ab5f03652216c63d49846d7a6c58/python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca", size = 39115 } wheels = [ - { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863, upload_time = "2024-01-23T06:32:58.246Z" }, + { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863 }, ] [[package]] @@ -812,7 +813,6 @@ dependencies = [ [package.dev-dependencies] dev = [ { name = "ruff" }, - { name = "types-assertpy" }, ] [package.metadata] @@ -837,10 +837,7 @@ requires-dist = [ ] [package.metadata.requires-dev] -dev = [ - { name = "ruff", specifier = ">=0.9.10" }, - { name = "types-assertpy" }, -] +dev = [{ name = "ruff", specifier = ">=0.9.10" }] [[package]] name = "requests" @@ -853,9 +850,9 @@ dependencies = [ { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, { name = "urllib3", version = "2.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218, upload_time = "2024-05-29T15:37:49.536Z" } +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } wheels = [ - { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928, upload_time = "2024-05-29T15:37:47.027Z" }, + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, ] [[package]] @@ -865,34 +862,34 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pyasn1" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/aa/65/7d973b89c4d2351d7fb232c2e452547ddfa243e93131e7cfa766da627b52/rsa-4.9.tar.gz", hash = "sha256:e38464a49c6c85d7f1351b0126661487a7e0a14a50f1675ec50eb34d4f20ef21", size = 29711, upload_time = "2022-07-20T10:28:36.115Z" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/65/7d973b89c4d2351d7fb232c2e452547ddfa243e93131e7cfa766da627b52/rsa-4.9.tar.gz", hash = "sha256:e38464a49c6c85d7f1351b0126661487a7e0a14a50f1675ec50eb34d4f20ef21", size = 29711 } wheels = [ - { url = "https://files.pythonhosted.org/packages/49/97/fa78e3d2f65c02c8e1268b9aba606569fe97f6c8f7c2d74394553347c145/rsa-4.9-py3-none-any.whl", hash = "sha256:90260d9058e514786967344d0ef75fa8727eed8a7d2e43ce9f4bcf1b536174f7", size = 34315, upload_time = "2022-07-20T10:28:34.978Z" }, + { url = "https://files.pythonhosted.org/packages/49/97/fa78e3d2f65c02c8e1268b9aba606569fe97f6c8f7c2d74394553347c145/rsa-4.9-py3-none-any.whl", hash = "sha256:90260d9058e514786967344d0ef75fa8727eed8a7d2e43ce9f4bcf1b536174f7", size = 34315 }, ] [[package]] name = "ruff" version = "0.9.10" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/20/8e/fafaa6f15c332e73425d9c44ada85360501045d5ab0b81400076aff27cf6/ruff-0.9.10.tar.gz", hash = "sha256:9bacb735d7bada9cfb0f2c227d3658fc443d90a727b47f206fb33f52f3c0eac7", size = 3759776, upload_time = "2025-03-07T15:27:44.363Z" } +sdist = { url = "https://files.pythonhosted.org/packages/20/8e/fafaa6f15c332e73425d9c44ada85360501045d5ab0b81400076aff27cf6/ruff-0.9.10.tar.gz", hash = "sha256:9bacb735d7bada9cfb0f2c227d3658fc443d90a727b47f206fb33f52f3c0eac7", size = 3759776 } wheels = [ - { url = "https://files.pythonhosted.org/packages/73/b2/af7c2cc9e438cbc19fafeec4f20bfcd72165460fe75b2b6e9a0958c8c62b/ruff-0.9.10-py3-none-linux_armv6l.whl", hash = "sha256:eb4d25532cfd9fe461acc83498361ec2e2252795b4f40b17e80692814329e42d", size = 10049494, upload_time = "2025-03-07T15:26:51.268Z" }, - { url = "https://files.pythonhosted.org/packages/6d/12/03f6dfa1b95ddd47e6969f0225d60d9d7437c91938a310835feb27927ca0/ruff-0.9.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:188a6638dab1aa9bb6228a7302387b2c9954e455fb25d6b4470cb0641d16759d", size = 10853584, upload_time = "2025-03-07T15:26:56.104Z" }, - { url = "https://files.pythonhosted.org/packages/02/49/1c79e0906b6ff551fb0894168763f705bf980864739572b2815ecd3c9df0/ruff-0.9.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:5284dcac6b9dbc2fcb71fdfc26a217b2ca4ede6ccd57476f52a587451ebe450d", size = 10155692, upload_time = "2025-03-07T15:27:01.385Z" }, - { url = "https://files.pythonhosted.org/packages/5b/01/85e8082e41585e0e1ceb11e41c054e9e36fed45f4b210991052d8a75089f/ruff-0.9.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:47678f39fa2a3da62724851107f438c8229a3470f533894b5568a39b40029c0c", size = 10369760, upload_time = "2025-03-07T15:27:04.023Z" }, - { url = "https://files.pythonhosted.org/packages/a1/90/0bc60bd4e5db051f12445046d0c85cc2c617095c0904f1aa81067dc64aea/ruff-0.9.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:99713a6e2766b7a17147b309e8c915b32b07a25c9efd12ada79f217c9c778b3e", size = 9912196, upload_time = "2025-03-07T15:27:06.93Z" }, - { url = "https://files.pythonhosted.org/packages/66/ea/0b7e8c42b1ec608033c4d5a02939c82097ddcb0b3e393e4238584b7054ab/ruff-0.9.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:524ee184d92f7c7304aa568e2db20f50c32d1d0caa235d8ddf10497566ea1a12", size = 11434985, upload_time = "2025-03-07T15:27:10.082Z" }, - { url = "https://files.pythonhosted.org/packages/d5/86/3171d1eff893db4f91755175a6e1163c5887be1f1e2f4f6c0c59527c2bfd/ruff-0.9.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:df92aeac30af821f9acf819fc01b4afc3dfb829d2782884f8739fb52a8119a16", size = 12155842, upload_time = "2025-03-07T15:27:12.727Z" }, - { url = "https://files.pythonhosted.org/packages/89/9e/700ca289f172a38eb0bca752056d0a42637fa17b81649b9331786cb791d7/ruff-0.9.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de42e4edc296f520bb84954eb992a07a0ec5a02fecb834498415908469854a52", size = 11613804, upload_time = "2025-03-07T15:27:15.944Z" }, - { url = "https://files.pythonhosted.org/packages/f2/92/648020b3b5db180f41a931a68b1c8575cca3e63cec86fd26807422a0dbad/ruff-0.9.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d257f95b65806104b6b1ffca0ea53f4ef98454036df65b1eda3693534813ecd1", size = 13823776, upload_time = "2025-03-07T15:27:18.996Z" }, - { url = "https://files.pythonhosted.org/packages/5e/a6/cc472161cd04d30a09d5c90698696b70c169eeba2c41030344194242db45/ruff-0.9.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b60dec7201c0b10d6d11be00e8f2dbb6f40ef1828ee75ed739923799513db24c", size = 11302673, upload_time = "2025-03-07T15:27:21.655Z" }, - { url = "https://files.pythonhosted.org/packages/6c/db/d31c361c4025b1b9102b4d032c70a69adb9ee6fde093f6c3bf29f831c85c/ruff-0.9.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d838b60007da7a39c046fcdd317293d10b845001f38bcb55ba766c3875b01e43", size = 10235358, upload_time = "2025-03-07T15:27:24.72Z" }, - { url = "https://files.pythonhosted.org/packages/d1/86/d6374e24a14d4d93ebe120f45edd82ad7dcf3ef999ffc92b197d81cdc2a5/ruff-0.9.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ccaf903108b899beb8e09a63ffae5869057ab649c1e9231c05ae354ebc62066c", size = 9886177, upload_time = "2025-03-07T15:27:27.282Z" }, - { url = "https://files.pythonhosted.org/packages/00/62/a61691f6eaaac1e945a1f3f59f1eea9a218513139d5b6c2b8f88b43b5b8f/ruff-0.9.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:f9567d135265d46e59d62dc60c0bfad10e9a6822e231f5b24032dba5a55be6b5", size = 10864747, upload_time = "2025-03-07T15:27:30.637Z" }, - { url = "https://files.pythonhosted.org/packages/ee/94/2c7065e1d92a8a8a46d46d9c3cf07b0aa7e0a1e0153d74baa5e6620b4102/ruff-0.9.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5f202f0d93738c28a89f8ed9eaba01b7be339e5d8d642c994347eaa81c6d75b8", size = 11360441, upload_time = "2025-03-07T15:27:33.356Z" }, - { url = "https://files.pythonhosted.org/packages/a7/8f/1f545ea6f9fcd7bf4368551fb91d2064d8f0577b3079bb3f0ae5779fb773/ruff-0.9.10-py3-none-win32.whl", hash = "sha256:bfb834e87c916521ce46b1788fbb8484966e5113c02df216680102e9eb960029", size = 10247401, upload_time = "2025-03-07T15:27:35.994Z" }, - { url = "https://files.pythonhosted.org/packages/4f/18/fb703603ab108e5c165f52f5b86ee2aa9be43bb781703ec87c66a5f5d604/ruff-0.9.10-py3-none-win_amd64.whl", hash = "sha256:f2160eeef3031bf4b17df74e307d4c5fb689a6f3a26a2de3f7ef4044e3c484f1", size = 11366360, upload_time = "2025-03-07T15:27:38.66Z" }, - { url = "https://files.pythonhosted.org/packages/35/85/338e603dc68e7d9994d5d84f24adbf69bae760ba5efd3e20f5ff2cec18da/ruff-0.9.10-py3-none-win_arm64.whl", hash = "sha256:5fd804c0327a5e5ea26615550e706942f348b197d5475ff34c19733aee4b2e69", size = 10436892, upload_time = "2025-03-07T15:27:41.687Z" }, + { url = "https://files.pythonhosted.org/packages/73/b2/af7c2cc9e438cbc19fafeec4f20bfcd72165460fe75b2b6e9a0958c8c62b/ruff-0.9.10-py3-none-linux_armv6l.whl", hash = "sha256:eb4d25532cfd9fe461acc83498361ec2e2252795b4f40b17e80692814329e42d", size = 10049494 }, + { url = "https://files.pythonhosted.org/packages/6d/12/03f6dfa1b95ddd47e6969f0225d60d9d7437c91938a310835feb27927ca0/ruff-0.9.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:188a6638dab1aa9bb6228a7302387b2c9954e455fb25d6b4470cb0641d16759d", size = 10853584 }, + { url = "https://files.pythonhosted.org/packages/02/49/1c79e0906b6ff551fb0894168763f705bf980864739572b2815ecd3c9df0/ruff-0.9.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:5284dcac6b9dbc2fcb71fdfc26a217b2ca4ede6ccd57476f52a587451ebe450d", size = 10155692 }, + { url = "https://files.pythonhosted.org/packages/5b/01/85e8082e41585e0e1ceb11e41c054e9e36fed45f4b210991052d8a75089f/ruff-0.9.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:47678f39fa2a3da62724851107f438c8229a3470f533894b5568a39b40029c0c", size = 10369760 }, + { url = "https://files.pythonhosted.org/packages/a1/90/0bc60bd4e5db051f12445046d0c85cc2c617095c0904f1aa81067dc64aea/ruff-0.9.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:99713a6e2766b7a17147b309e8c915b32b07a25c9efd12ada79f217c9c778b3e", size = 9912196 }, + { url = "https://files.pythonhosted.org/packages/66/ea/0b7e8c42b1ec608033c4d5a02939c82097ddcb0b3e393e4238584b7054ab/ruff-0.9.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:524ee184d92f7c7304aa568e2db20f50c32d1d0caa235d8ddf10497566ea1a12", size = 11434985 }, + { url = "https://files.pythonhosted.org/packages/d5/86/3171d1eff893db4f91755175a6e1163c5887be1f1e2f4f6c0c59527c2bfd/ruff-0.9.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:df92aeac30af821f9acf819fc01b4afc3dfb829d2782884f8739fb52a8119a16", size = 12155842 }, + { url = "https://files.pythonhosted.org/packages/89/9e/700ca289f172a38eb0bca752056d0a42637fa17b81649b9331786cb791d7/ruff-0.9.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de42e4edc296f520bb84954eb992a07a0ec5a02fecb834498415908469854a52", size = 11613804 }, + { url = "https://files.pythonhosted.org/packages/f2/92/648020b3b5db180f41a931a68b1c8575cca3e63cec86fd26807422a0dbad/ruff-0.9.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d257f95b65806104b6b1ffca0ea53f4ef98454036df65b1eda3693534813ecd1", size = 13823776 }, + { url = "https://files.pythonhosted.org/packages/5e/a6/cc472161cd04d30a09d5c90698696b70c169eeba2c41030344194242db45/ruff-0.9.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b60dec7201c0b10d6d11be00e8f2dbb6f40ef1828ee75ed739923799513db24c", size = 11302673 }, + { url = "https://files.pythonhosted.org/packages/6c/db/d31c361c4025b1b9102b4d032c70a69adb9ee6fde093f6c3bf29f831c85c/ruff-0.9.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d838b60007da7a39c046fcdd317293d10b845001f38bcb55ba766c3875b01e43", size = 10235358 }, + { url = "https://files.pythonhosted.org/packages/d1/86/d6374e24a14d4d93ebe120f45edd82ad7dcf3ef999ffc92b197d81cdc2a5/ruff-0.9.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ccaf903108b899beb8e09a63ffae5869057ab649c1e9231c05ae354ebc62066c", size = 9886177 }, + { url = "https://files.pythonhosted.org/packages/00/62/a61691f6eaaac1e945a1f3f59f1eea9a218513139d5b6c2b8f88b43b5b8f/ruff-0.9.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:f9567d135265d46e59d62dc60c0bfad10e9a6822e231f5b24032dba5a55be6b5", size = 10864747 }, + { url = "https://files.pythonhosted.org/packages/ee/94/2c7065e1d92a8a8a46d46d9c3cf07b0aa7e0a1e0153d74baa5e6620b4102/ruff-0.9.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5f202f0d93738c28a89f8ed9eaba01b7be339e5d8d642c994347eaa81c6d75b8", size = 11360441 }, + { url = "https://files.pythonhosted.org/packages/a7/8f/1f545ea6f9fcd7bf4368551fb91d2064d8f0577b3079bb3f0ae5779fb773/ruff-0.9.10-py3-none-win32.whl", hash = "sha256:bfb834e87c916521ce46b1788fbb8484966e5113c02df216680102e9eb960029", size = 10247401 }, + { url = "https://files.pythonhosted.org/packages/4f/18/fb703603ab108e5c165f52f5b86ee2aa9be43bb781703ec87c66a5f5d604/ruff-0.9.10-py3-none-win_amd64.whl", hash = "sha256:f2160eeef3031bf4b17df74e307d4c5fb689a6f3a26a2de3f7ef4044e3c484f1", size = 11366360 }, + { url = "https://files.pythonhosted.org/packages/35/85/338e603dc68e7d9994d5d84f24adbf69bae760ba5efd3e20f5ff2cec18da/ruff-0.9.10-py3-none-win_arm64.whl", hash = "sha256:5fd804c0327a5e5ea26615550e706942f348b197d5475ff34c19733aee4b2e69", size = 10436892 }, ] [[package]] @@ -902,36 +899,36 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "botocore" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c4/2b/5c9562795c2eb2b5f63536961754760c25bf0f34af93d36aa28dea2fb303/s3transfer-0.11.5.tar.gz", hash = "sha256:8c8aad92784779ab8688a61aefff3e28e9ebdce43142808eaa3f0b0f402f68b7", size = 149107, upload_time = "2025-04-17T19:23:19.051Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c4/2b/5c9562795c2eb2b5f63536961754760c25bf0f34af93d36aa28dea2fb303/s3transfer-0.11.5.tar.gz", hash = "sha256:8c8aad92784779ab8688a61aefff3e28e9ebdce43142808eaa3f0b0f402f68b7", size = 149107 } wheels = [ - { url = "https://files.pythonhosted.org/packages/45/39/13402e323666d17850eca87e4cd6ecfcf9fd7809cac9efdcce10272fc29d/s3transfer-0.11.5-py3-none-any.whl", hash = "sha256:757af0f2ac150d3c75bc4177a32355c3862a98d20447b69a0161812992fe0bd4", size = 84782, upload_time = "2025-04-17T19:23:17.516Z" }, + { url = "https://files.pythonhosted.org/packages/45/39/13402e323666d17850eca87e4cd6ecfcf9fd7809cac9efdcce10272fc29d/s3transfer-0.11.5-py3-none-any.whl", hash = "sha256:757af0f2ac150d3c75bc4177a32355c3862a98d20447b69a0161812992fe0bd4", size = 84782 }, ] [[package]] name = "six" version = "1.17.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload_time = "2024-12-04T17:35:28.174Z" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload_time = "2024-12-04T17:35:26.475Z" }, + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, ] [[package]] name = "sniffio" version = "1.3.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload_time = "2024-02-25T23:20:04.057Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 } wheels = [ - { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload_time = "2024-02-25T23:20:01.196Z" }, + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, ] [[package]] name = "tomli" version = "2.0.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/35/b9/de2a5c0144d7d75a57ff355c0c24054f965b2dc3036456ae03a51ea6264b/tomli-2.0.2.tar.gz", hash = "sha256:d46d457a85337051c36524bc5349dd91b1877838e2979ac5ced3e710ed8a60ed", size = 16096, upload_time = "2024-10-02T10:46:13.208Z" } +sdist = { url = "https://files.pythonhosted.org/packages/35/b9/de2a5c0144d7d75a57ff355c0c24054f965b2dc3036456ae03a51ea6264b/tomli-2.0.2.tar.gz", hash = "sha256:d46d457a85337051c36524bc5349dd91b1877838e2979ac5ced3e710ed8a60ed", size = 16096 } wheels = [ - { url = "https://files.pythonhosted.org/packages/cf/db/ce8eda256fa131af12e0a76d481711abe4681b6923c27efb9a255c9e4594/tomli-2.0.2-py3-none-any.whl", hash = "sha256:2ebe24485c53d303f690b0ec092806a085f07af5a5aa1464f3931eec36caaa38", size = 13237, upload_time = "2024-10-02T10:46:11.806Z" }, + { url = "https://files.pythonhosted.org/packages/cf/db/ce8eda256fa131af12e0a76d481711abe4681b6923c27efb9a255c9e4594/tomli-2.0.2-py3-none-any.whl", hash = "sha256:2ebe24485c53d303f690b0ec092806a085f07af5a5aa1464f3931eec36caaa38", size = 13237 }, ] [[package]] @@ -939,29 +936,20 @@ name = "tqdm" version = "4.67.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "colorama", marker = "platform_system == 'Windows'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload_time = "2024-11-24T20:12:22.481Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload_time = "2024-11-24T20:12:19.698Z" }, -] - -[[package]] -name = "types-assertpy" -version = "1.1.0.20250502" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2d/51/98d2bf5a9f3a98a933f0bb598b0905531a3fec81ae7ba97625a46f8d57d4/types_assertpy-1.1.0.20250502.tar.gz", hash = "sha256:7735027f3e63f91a1f3a24819024991358f083a40aceb5dd117e5691e9d4a0de", size = 10387, upload_time = "2025-05-02T03:02:21.096Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737 } wheels = [ - { url = "https://files.pythonhosted.org/packages/19/15/04ac9cde31889ac1954d5d56fe10d695f6c8fe54ce4a833c5690d327e969/types_assertpy-1.1.0.20250502-py3-none-any.whl", hash = "sha256:dc025f53b74b7bd75ecb830755af10261908c57fb20df38fd42caaca427c5aac", size = 12848, upload_time = "2025-05-02T03:02:19.963Z" }, + { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540 }, ] [[package]] name = "typing-extensions" version = "4.12.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321, upload_time = "2024-06-07T18:52:15.995Z" } +sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } wheels = [ - { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438, upload_time = "2024-06-07T18:52:13.582Z" }, + { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, ] [[package]] @@ -971,9 +959,9 @@ source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version < '3.10'", ] -sdist = { url = "https://files.pythonhosted.org/packages/e4/e8/6ff5e6bc22095cfc59b6ea711b687e2b7ed4bdb373f7eeec370a97d7392f/urllib3-1.26.20.tar.gz", hash = "sha256:40c2dc0c681e47eb8f90e7e27bf6ff7df2e677421fd46756da1161c39ca70d32", size = 307380, upload_time = "2024-08-29T15:43:11.37Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/e8/6ff5e6bc22095cfc59b6ea711b687e2b7ed4bdb373f7eeec370a97d7392f/urllib3-1.26.20.tar.gz", hash = "sha256:40c2dc0c681e47eb8f90e7e27bf6ff7df2e677421fd46756da1161c39ca70d32", size = 307380 } wheels = [ - { url = "https://files.pythonhosted.org/packages/33/cf/8435d5a7159e2a9c83a95896ed596f68cf798005fe107cc655b5c5c14704/urllib3-1.26.20-py2.py3-none-any.whl", hash = "sha256:0ed14ccfbf1c30a9072c7ca157e4319b70d65f623e91e7b32fadb2853431016e", size = 144225, upload_time = "2024-08-29T15:43:08.921Z" }, + { url = "https://files.pythonhosted.org/packages/33/cf/8435d5a7159e2a9c83a95896ed596f68cf798005fe107cc655b5c5c14704/urllib3-1.26.20-py2.py3-none-any.whl", hash = "sha256:0ed14ccfbf1c30a9072c7ca157e4319b70d65f623e91e7b32fadb2853431016e", size = 144225 }, ] [[package]] @@ -983,85 +971,85 @@ source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.10'", ] -sdist = { url = "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", size = 300677, upload_time = "2024-09-12T10:52:18.401Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", size = 300677 } wheels = [ - { url = "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", size = 126338, upload_time = "2024-09-12T10:52:16.589Z" }, + { url = "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", size = 126338 }, ] [[package]] name = "websockets" version = "14.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/94/54/8359678c726243d19fae38ca14a334e740782336c9f19700858c4eb64a1e/websockets-14.2.tar.gz", hash = "sha256:5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5", size = 164394, upload_time = "2025-01-19T21:00:56.431Z" } +sdist = { url = "https://files.pythonhosted.org/packages/94/54/8359678c726243d19fae38ca14a334e740782336c9f19700858c4eb64a1e/websockets-14.2.tar.gz", hash = "sha256:5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5", size = 164394 } wheels = [ - { url = "https://files.pythonhosted.org/packages/28/fa/76607eb7dcec27b2d18d63f60a32e60e2b8629780f343bb83a4dbb9f4350/websockets-14.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e8179f95323b9ab1c11723e5d91a89403903f7b001828161b480a7810b334885", size = 163089, upload_time = "2025-01-19T20:58:43.399Z" }, - { url = "https://files.pythonhosted.org/packages/9e/00/ad2246b5030575b79e7af0721810fdaecaf94c4b2625842ef7a756fa06dd/websockets-14.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0d8c3e2cdb38f31d8bd7d9d28908005f6fa9def3324edb9bf336d7e4266fd397", size = 160741, upload_time = "2025-01-19T20:58:45.309Z" }, - { url = "https://files.pythonhosted.org/packages/72/f7/60f10924d333a28a1ff3fcdec85acf226281331bdabe9ad74947e1b7fc0a/websockets-14.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:714a9b682deb4339d39ffa674f7b674230227d981a37d5d174a4a83e3978a610", size = 160996, upload_time = "2025-01-19T20:58:47.563Z" }, - { url = "https://files.pythonhosted.org/packages/63/7c/c655789cf78648c01ac6ecbe2d6c18f91b75bdc263ffee4d08ce628d12f0/websockets-14.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2e53c72052f2596fb792a7acd9704cbc549bf70fcde8a99e899311455974ca3", size = 169974, upload_time = "2025-01-19T20:58:51.023Z" }, - { url = "https://files.pythonhosted.org/packages/fb/5b/013ed8b4611857ac92ac631079c08d9715b388bd1d88ec62e245f87a39df/websockets-14.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e3fbd68850c837e57373d95c8fe352203a512b6e49eaae4c2f4088ef8cf21980", size = 168985, upload_time = "2025-01-19T20:58:52.698Z" }, - { url = "https://files.pythonhosted.org/packages/cd/33/aa3e32fd0df213a5a442310754fe3f89dd87a0b8e5b4e11e0991dd3bcc50/websockets-14.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b27ece32f63150c268593d5fdb82819584831a83a3f5809b7521df0685cd5d8", size = 169297, upload_time = "2025-01-19T20:58:54.898Z" }, - { url = "https://files.pythonhosted.org/packages/93/17/dae0174883d6399f57853ac44abf5f228eaba86d98d160f390ffabc19b6e/websockets-14.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4daa0faea5424d8713142b33825fff03c736f781690d90652d2c8b053345b0e7", size = 169677, upload_time = "2025-01-19T20:58:56.36Z" }, - { url = "https://files.pythonhosted.org/packages/42/e2/0375af7ac00169b98647c804651c515054b34977b6c1354f1458e4116c1e/websockets-14.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:bc63cee8596a6ec84d9753fd0fcfa0452ee12f317afe4beae6b157f0070c6c7f", size = 169089, upload_time = "2025-01-19T20:58:58.824Z" }, - { url = "https://files.pythonhosted.org/packages/73/8d/80f71d2a351a44b602859af65261d3dde3a0ce4e76cf9383738a949e0cc3/websockets-14.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7a570862c325af2111343cc9b0257b7119b904823c675b22d4ac547163088d0d", size = 169026, upload_time = "2025-01-19T20:59:01.089Z" }, - { url = "https://files.pythonhosted.org/packages/48/97/173b1fa6052223e52bb4054a141433ad74931d94c575e04b654200b98ca4/websockets-14.2-cp310-cp310-win32.whl", hash = "sha256:75862126b3d2d505e895893e3deac0a9339ce750bd27b4ba515f008b5acf832d", size = 163967, upload_time = "2025-01-19T20:59:02.662Z" }, - { url = "https://files.pythonhosted.org/packages/c0/5b/2fcf60f38252a4562b28b66077e0d2b48f91fef645d5f78874cd1dec807b/websockets-14.2-cp310-cp310-win_amd64.whl", hash = "sha256:cc45afb9c9b2dc0852d5c8b5321759cf825f82a31bfaf506b65bf4668c96f8b2", size = 164413, upload_time = "2025-01-19T20:59:05.071Z" }, - { url = "https://files.pythonhosted.org/packages/15/b6/504695fb9a33df0ca56d157f5985660b5fc5b4bf8c78f121578d2d653392/websockets-14.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3bdc8c692c866ce5fefcaf07d2b55c91d6922ac397e031ef9b774e5b9ea42166", size = 163088, upload_time = "2025-01-19T20:59:06.435Z" }, - { url = "https://files.pythonhosted.org/packages/81/26/ebfb8f6abe963c795122439c6433c4ae1e061aaedfc7eff32d09394afbae/websockets-14.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c93215fac5dadc63e51bcc6dceca72e72267c11def401d6668622b47675b097f", size = 160745, upload_time = "2025-01-19T20:59:09.109Z" }, - { url = "https://files.pythonhosted.org/packages/a1/c6/1435ad6f6dcbff80bb95e8986704c3174da8866ddb751184046f5c139ef6/websockets-14.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1c9b6535c0e2cf8a6bf938064fb754aaceb1e6a4a51a80d884cd5db569886910", size = 160995, upload_time = "2025-01-19T20:59:12.816Z" }, - { url = "https://files.pythonhosted.org/packages/96/63/900c27cfe8be1a1f2433fc77cd46771cf26ba57e6bdc7cf9e63644a61863/websockets-14.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a52a6d7cf6938e04e9dceb949d35fbdf58ac14deea26e685ab6368e73744e4c", size = 170543, upload_time = "2025-01-19T20:59:15.026Z" }, - { url = "https://files.pythonhosted.org/packages/00/8b/bec2bdba92af0762d42d4410593c1d7d28e9bfd952c97a3729df603dc6ea/websockets-14.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9f05702e93203a6ff5226e21d9b40c037761b2cfb637187c9802c10f58e40473", size = 169546, upload_time = "2025-01-19T20:59:17.156Z" }, - { url = "https://files.pythonhosted.org/packages/6b/a9/37531cb5b994f12a57dec3da2200ef7aadffef82d888a4c29a0d781568e4/websockets-14.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22441c81a6748a53bfcb98951d58d1af0661ab47a536af08920d129b4d1c3473", size = 169911, upload_time = "2025-01-19T20:59:18.623Z" }, - { url = "https://files.pythonhosted.org/packages/60/d5/a6eadba2ed9f7e65d677fec539ab14a9b83de2b484ab5fe15d3d6d208c28/websockets-14.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd9b868d78b194790e6236d9cbc46d68aba4b75b22497eb4ab64fa640c3af56", size = 170183, upload_time = "2025-01-19T20:59:20.743Z" }, - { url = "https://files.pythonhosted.org/packages/76/57/a338ccb00d1df881c1d1ee1f2a20c9c1b5b29b51e9e0191ee515d254fea6/websockets-14.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1a5a20d5843886d34ff8c57424cc65a1deda4375729cbca4cb6b3353f3ce4142", size = 169623, upload_time = "2025-01-19T20:59:22.286Z" }, - { url = "https://files.pythonhosted.org/packages/64/22/e5f7c33db0cb2c1d03b79fd60d189a1da044e2661f5fd01d629451e1db89/websockets-14.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:34277a29f5303d54ec6468fb525d99c99938607bc96b8d72d675dee2b9f5bf1d", size = 169583, upload_time = "2025-01-19T20:59:23.656Z" }, - { url = "https://files.pythonhosted.org/packages/aa/2e/2b4662237060063a22e5fc40d46300a07142afe30302b634b4eebd717c07/websockets-14.2-cp311-cp311-win32.whl", hash = "sha256:02687db35dbc7d25fd541a602b5f8e451a238ffa033030b172ff86a93cb5dc2a", size = 163969, upload_time = "2025-01-19T20:59:26.004Z" }, - { url = "https://files.pythonhosted.org/packages/94/a5/0cda64e1851e73fc1ecdae6f42487babb06e55cb2f0dc8904b81d8ef6857/websockets-14.2-cp311-cp311-win_amd64.whl", hash = "sha256:862e9967b46c07d4dcd2532e9e8e3c2825e004ffbf91a5ef9dde519ee2effb0b", size = 164408, upload_time = "2025-01-19T20:59:28.105Z" }, - { url = "https://files.pythonhosted.org/packages/c1/81/04f7a397653dc8bec94ddc071f34833e8b99b13ef1a3804c149d59f92c18/websockets-14.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1f20522e624d7ffbdbe259c6b6a65d73c895045f76a93719aa10cd93b3de100c", size = 163096, upload_time = "2025-01-19T20:59:29.763Z" }, - { url = "https://files.pythonhosted.org/packages/ec/c5/de30e88557e4d70988ed4d2eabd73fd3e1e52456b9f3a4e9564d86353b6d/websockets-14.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:647b573f7d3ada919fd60e64d533409a79dcf1ea21daeb4542d1d996519ca967", size = 160758, upload_time = "2025-01-19T20:59:32.095Z" }, - { url = "https://files.pythonhosted.org/packages/e5/8c/d130d668781f2c77d106c007b6c6c1d9db68239107c41ba109f09e6c218a/websockets-14.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6af99a38e49f66be5a64b1e890208ad026cda49355661549c507152113049990", size = 160995, upload_time = "2025-01-19T20:59:33.527Z" }, - { url = "https://files.pythonhosted.org/packages/a6/bc/f6678a0ff17246df4f06765e22fc9d98d1b11a258cc50c5968b33d6742a1/websockets-14.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:091ab63dfc8cea748cc22c1db2814eadb77ccbf82829bac6b2fbe3401d548eda", size = 170815, upload_time = "2025-01-19T20:59:35.837Z" }, - { url = "https://files.pythonhosted.org/packages/d8/b2/8070cb970c2e4122a6ef38bc5b203415fd46460e025652e1ee3f2f43a9a3/websockets-14.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b374e8953ad477d17e4851cdc66d83fdc2db88d9e73abf755c94510ebddceb95", size = 169759, upload_time = "2025-01-19T20:59:38.216Z" }, - { url = "https://files.pythonhosted.org/packages/81/da/72f7caabd94652e6eb7e92ed2d3da818626e70b4f2b15a854ef60bf501ec/websockets-14.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a39d7eceeea35db85b85e1169011bb4321c32e673920ae9c1b6e0978590012a3", size = 170178, upload_time = "2025-01-19T20:59:40.423Z" }, - { url = "https://files.pythonhosted.org/packages/31/e0/812725b6deca8afd3a08a2e81b3c4c120c17f68c9b84522a520b816cda58/websockets-14.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0a6f3efd47ffd0d12080594f434faf1cd2549b31e54870b8470b28cc1d3817d9", size = 170453, upload_time = "2025-01-19T20:59:41.996Z" }, - { url = "https://files.pythonhosted.org/packages/66/d3/8275dbc231e5ba9bb0c4f93144394b4194402a7a0c8ffaca5307a58ab5e3/websockets-14.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:065ce275e7c4ffb42cb738dd6b20726ac26ac9ad0a2a48e33ca632351a737267", size = 169830, upload_time = "2025-01-19T20:59:44.669Z" }, - { url = "https://files.pythonhosted.org/packages/a3/ae/e7d1a56755ae15ad5a94e80dd490ad09e345365199600b2629b18ee37bc7/websockets-14.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e9d0e53530ba7b8b5e389c02282f9d2aa47581514bd6049d3a7cffe1385cf5fe", size = 169824, upload_time = "2025-01-19T20:59:46.932Z" }, - { url = "https://files.pythonhosted.org/packages/b6/32/88ccdd63cb261e77b882e706108d072e4f1c839ed723bf91a3e1f216bf60/websockets-14.2-cp312-cp312-win32.whl", hash = "sha256:20e6dd0984d7ca3037afcb4494e48c74ffb51e8013cac71cf607fffe11df7205", size = 163981, upload_time = "2025-01-19T20:59:49.228Z" }, - { url = "https://files.pythonhosted.org/packages/b3/7d/32cdb77990b3bdc34a306e0a0f73a1275221e9a66d869f6ff833c95b56ef/websockets-14.2-cp312-cp312-win_amd64.whl", hash = "sha256:44bba1a956c2c9d268bdcdf234d5e5ff4c9b6dc3e300545cbe99af59dda9dcce", size = 164421, upload_time = "2025-01-19T20:59:50.674Z" }, - { url = "https://files.pythonhosted.org/packages/82/94/4f9b55099a4603ac53c2912e1f043d6c49d23e94dd82a9ce1eb554a90215/websockets-14.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6f1372e511c7409a542291bce92d6c83320e02c9cf392223272287ce55bc224e", size = 163102, upload_time = "2025-01-19T20:59:52.177Z" }, - { url = "https://files.pythonhosted.org/packages/8e/b7/7484905215627909d9a79ae07070057afe477433fdacb59bf608ce86365a/websockets-14.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4da98b72009836179bb596a92297b1a61bb5a830c0e483a7d0766d45070a08ad", size = 160766, upload_time = "2025-01-19T20:59:54.368Z" }, - { url = "https://files.pythonhosted.org/packages/a3/a4/edb62efc84adb61883c7d2c6ad65181cb087c64252138e12d655989eec05/websockets-14.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8a86a269759026d2bde227652b87be79f8a734e582debf64c9d302faa1e9f03", size = 160998, upload_time = "2025-01-19T20:59:56.671Z" }, - { url = "https://files.pythonhosted.org/packages/f5/79/036d320dc894b96af14eac2529967a6fc8b74f03b83c487e7a0e9043d842/websockets-14.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86cf1aaeca909bf6815ea714d5c5736c8d6dd3a13770e885aafe062ecbd04f1f", size = 170780, upload_time = "2025-01-19T20:59:58.085Z" }, - { url = "https://files.pythonhosted.org/packages/63/75/5737d21ee4dd7e4b9d487ee044af24a935e36a9ff1e1419d684feedcba71/websockets-14.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9b0f6c3ba3b1240f602ebb3971d45b02cc12bd1845466dd783496b3b05783a5", size = 169717, upload_time = "2025-01-19T20:59:59.545Z" }, - { url = "https://files.pythonhosted.org/packages/2c/3c/bf9b2c396ed86a0b4a92ff4cdaee09753d3ee389be738e92b9bbd0330b64/websockets-14.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:669c3e101c246aa85bc8534e495952e2ca208bd87994650b90a23d745902db9a", size = 170155, upload_time = "2025-01-19T21:00:01.887Z" }, - { url = "https://files.pythonhosted.org/packages/75/2d/83a5aca7247a655b1da5eb0ee73413abd5c3a57fc8b92915805e6033359d/websockets-14.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eabdb28b972f3729348e632ab08f2a7b616c7e53d5414c12108c29972e655b20", size = 170495, upload_time = "2025-01-19T21:00:04.064Z" }, - { url = "https://files.pythonhosted.org/packages/79/dd/699238a92761e2f943885e091486378813ac8f43e3c84990bc394c2be93e/websockets-14.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2066dc4cbcc19f32c12a5a0e8cc1b7ac734e5b64ac0a325ff8353451c4b15ef2", size = 169880, upload_time = "2025-01-19T21:00:05.695Z" }, - { url = "https://files.pythonhosted.org/packages/c8/c9/67a8f08923cf55ce61aadda72089e3ed4353a95a3a4bc8bf42082810e580/websockets-14.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ab95d357cd471df61873dadf66dd05dd4709cae001dd6342edafc8dc6382f307", size = 169856, upload_time = "2025-01-19T21:00:07.192Z" }, - { url = "https://files.pythonhosted.org/packages/17/b1/1ffdb2680c64e9c3921d99db460546194c40d4acbef999a18c37aa4d58a3/websockets-14.2-cp313-cp313-win32.whl", hash = "sha256:a9e72fb63e5f3feacdcf5b4ff53199ec8c18d66e325c34ee4c551ca748623bbc", size = 163974, upload_time = "2025-01-19T21:00:08.698Z" }, - { url = "https://files.pythonhosted.org/packages/14/13/8b7fc4cb551b9cfd9890f0fd66e53c18a06240319915533b033a56a3d520/websockets-14.2-cp313-cp313-win_amd64.whl", hash = "sha256:b439ea828c4ba99bb3176dc8d9b933392a2413c0f6b149fdcba48393f573377f", size = 164420, upload_time = "2025-01-19T21:00:10.182Z" }, - { url = "https://files.pythonhosted.org/packages/6f/eb/367e0ed7b8a960b4fc12c7c6bf3ebddf06875037de641637994849560d47/websockets-14.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7cd5706caec1686c5d233bc76243ff64b1c0dc445339bd538f30547e787c11fe", size = 163087, upload_time = "2025-01-19T21:00:11.717Z" }, - { url = "https://files.pythonhosted.org/packages/96/f7/1f18d028ec4a2c14598dfec6a73381a915c27464b693873198c1de872095/websockets-14.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ec607328ce95a2f12b595f7ae4c5d71bf502212bddcea528290b35c286932b12", size = 160740, upload_time = "2025-01-19T21:00:13.219Z" }, - { url = "https://files.pythonhosted.org/packages/5c/db/b4b353fb9c3f0eaa8138ea4c76e6fa555b6d2821ed2d51d0ac3c320bc57e/websockets-14.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:da85651270c6bfb630136423037dd4975199e5d4114cae6d3066641adcc9d1c7", size = 160992, upload_time = "2025-01-19T21:00:15.54Z" }, - { url = "https://files.pythonhosted.org/packages/b9/b1/9149e420c61f375e432654d5c1545e563b90ac1f829ee1a8d1dccaf0869d/websockets-14.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3ecadc7ce90accf39903815697917643f5b7cfb73c96702318a096c00aa71f5", size = 169757, upload_time = "2025-01-19T21:00:17.589Z" }, - { url = "https://files.pythonhosted.org/packages/2b/33/0bb58204191e113212360f1392b6b1e9f85f62c7ca5b3b15f52f2f835516/websockets-14.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1979bee04af6a78608024bad6dfcc0cc930ce819f9e10342a29a05b5320355d0", size = 168762, upload_time = "2025-01-19T21:00:19.987Z" }, - { url = "https://files.pythonhosted.org/packages/be/3d/c3c192f16210d7b7535fbf4ee9a299612f4dccff665587617b13fa0a6aa3/websockets-14.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dddacad58e2614a24938a50b85969d56f88e620e3f897b7d80ac0d8a5800258", size = 169060, upload_time = "2025-01-19T21:00:21.414Z" }, - { url = "https://files.pythonhosted.org/packages/a6/73/75efa8d9e4b1b257818a7b7a0b9ac84a07c91120b52148941370ef2c8f16/websockets-14.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:89a71173caaf75fa71a09a5f614f450ba3ec84ad9fca47cb2422a860676716f0", size = 169457, upload_time = "2025-01-19T21:00:22.996Z" }, - { url = "https://files.pythonhosted.org/packages/a4/11/300cf36cfd6990ffb218394862f0513be8c21917c9ff5e362f94599caedd/websockets-14.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:6af6a4b26eea4fc06c6818a6b962a952441e0e39548b44773502761ded8cc1d4", size = 168860, upload_time = "2025-01-19T21:00:25.24Z" }, - { url = "https://files.pythonhosted.org/packages/c0/3d/5fd82500714ab7c09f003bde671dad1a3a131ac77b6b11ada72e466de4f6/websockets-14.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:80c8efa38957f20bba0117b48737993643204645e9ec45512579132508477cfc", size = 168825, upload_time = "2025-01-19T21:00:26.799Z" }, - { url = "https://files.pythonhosted.org/packages/88/16/715580eb6caaacc232f303e9619103a42dcd354b0854baa5ed26aacaf828/websockets-14.2-cp39-cp39-win32.whl", hash = "sha256:2e20c5f517e2163d76e2729104abc42639c41cf91f7b1839295be43302713661", size = 163960, upload_time = "2025-01-19T21:00:29.166Z" }, - { url = "https://files.pythonhosted.org/packages/63/a7/a1035cb198eaa12eaa9621aaaa3ec021b0e3bac96e1df9ceb6bfe5e53e5f/websockets-14.2-cp39-cp39-win_amd64.whl", hash = "sha256:b4c8cef610e8d7c70dea92e62b6814a8cd24fbd01d7103cc89308d2bfe1659ef", size = 164424, upload_time = "2025-01-19T21:00:30.614Z" }, - { url = "https://files.pythonhosted.org/packages/10/3d/91d3d2bb1325cd83e8e2c02d0262c7d4426dc8fa0831ef1aa4d6bf2041af/websockets-14.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d7d9cafbccba46e768be8a8ad4635fa3eae1ffac4c6e7cb4eb276ba41297ed29", size = 160773, upload_time = "2025-01-19T21:00:32.225Z" }, - { url = "https://files.pythonhosted.org/packages/33/7c/cdedadfef7381939577858b1b5718a4ab073adbb584e429dd9d9dc9bfe16/websockets-14.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:c76193c1c044bd1e9b3316dcc34b174bbf9664598791e6fb606d8d29000e070c", size = 161007, upload_time = "2025-01-19T21:00:33.784Z" }, - { url = "https://files.pythonhosted.org/packages/ca/35/7a20a3c450b27c04e50fbbfc3dfb161ed8e827b2a26ae31c4b59b018b8c6/websockets-14.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd475a974d5352390baf865309fe37dec6831aafc3014ffac1eea99e84e83fc2", size = 162264, upload_time = "2025-01-19T21:00:35.255Z" }, - { url = "https://files.pythonhosted.org/packages/e8/9c/e3f9600564b0c813f2448375cf28b47dc42c514344faed3a05d71fb527f9/websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2c6c0097a41968b2e2b54ed3424739aab0b762ca92af2379f152c1aef0187e1c", size = 161873, upload_time = "2025-01-19T21:00:37.377Z" }, - { url = "https://files.pythonhosted.org/packages/3f/37/260f189b16b2b8290d6ae80c9f96d8b34692cf1bb3475df54c38d3deb57d/websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d7ff794c8b36bc402f2e07c0b2ceb4a2424147ed4785ff03e2a7af03711d60a", size = 161818, upload_time = "2025-01-19T21:00:38.952Z" }, - { url = "https://files.pythonhosted.org/packages/ff/1e/e47dedac8bf7140e59aa6a679e850c4df9610ae844d71b6015263ddea37b/websockets-14.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dec254fcabc7bd488dab64846f588fc5b6fe0d78f641180030f8ea27b76d72c3", size = 164465, upload_time = "2025-01-19T21:00:40.456Z" }, - { url = "https://files.pythonhosted.org/packages/f7/c0/8e9325c4987dcf66d4a0d63ec380d4aefe8dcc1e521af71ad17adf2c1ae2/websockets-14.2-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:bbe03eb853e17fd5b15448328b4ec7fb2407d45fb0245036d06a3af251f8e48f", size = 160773, upload_time = "2025-01-19T21:00:42.145Z" }, - { url = "https://files.pythonhosted.org/packages/5a/6e/c9a7f2edd4afddc4f8cccfc4e12468b7f6ec40f28d1b1e966a8d0298b875/websockets-14.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a3c4aa3428b904d5404a0ed85f3644d37e2cb25996b7f096d77caeb0e96a3b42", size = 161006, upload_time = "2025-01-19T21:00:43.72Z" }, - { url = "https://files.pythonhosted.org/packages/f3/10/b90ece894828c954e674a81cb0db250e6c324c54db30a8b19e96431f928f/websockets-14.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:577a4cebf1ceaf0b65ffc42c54856214165fb8ceeba3935852fc33f6b0c55e7f", size = 162260, upload_time = "2025-01-19T21:00:46.33Z" }, - { url = "https://files.pythonhosted.org/packages/52/93/1147b6b5464a5fb6e8987da3ec7991dcc44f9090f67d9c841d7382fed429/websockets-14.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad1c1d02357b7665e700eca43a31d52814ad9ad9b89b58118bdabc365454b574", size = 161868, upload_time = "2025-01-19T21:00:48.683Z" }, - { url = "https://files.pythonhosted.org/packages/32/ab/f7d80b4049bff0aa617507330db3a27389d0e70df54e29f7a3d76bbd2086/websockets-14.2-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f390024a47d904613577df83ba700bd189eedc09c57af0a904e5c39624621270", size = 161813, upload_time = "2025-01-19T21:00:51.019Z" }, - { url = "https://files.pythonhosted.org/packages/cd/cc/adc9fb85f031b8df8e9f3d96cc004df25d2643e503953af5223c5b6825b7/websockets-14.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3c1426c021c38cf92b453cdf371228d3430acd775edee6bac5a4d577efc72365", size = 164457, upload_time = "2025-01-19T21:00:52.621Z" }, - { url = "https://files.pythonhosted.org/packages/7b/c8/d529f8a32ce40d98309f4470780631e971a5a842b60aec864833b3615786/websockets-14.2-py3-none-any.whl", hash = "sha256:7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b", size = 157416, upload_time = "2025-01-19T21:00:54.843Z" }, + { url = "https://files.pythonhosted.org/packages/28/fa/76607eb7dcec27b2d18d63f60a32e60e2b8629780f343bb83a4dbb9f4350/websockets-14.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e8179f95323b9ab1c11723e5d91a89403903f7b001828161b480a7810b334885", size = 163089 }, + { url = "https://files.pythonhosted.org/packages/9e/00/ad2246b5030575b79e7af0721810fdaecaf94c4b2625842ef7a756fa06dd/websockets-14.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0d8c3e2cdb38f31d8bd7d9d28908005f6fa9def3324edb9bf336d7e4266fd397", size = 160741 }, + { url = "https://files.pythonhosted.org/packages/72/f7/60f10924d333a28a1ff3fcdec85acf226281331bdabe9ad74947e1b7fc0a/websockets-14.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:714a9b682deb4339d39ffa674f7b674230227d981a37d5d174a4a83e3978a610", size = 160996 }, + { url = "https://files.pythonhosted.org/packages/63/7c/c655789cf78648c01ac6ecbe2d6c18f91b75bdc263ffee4d08ce628d12f0/websockets-14.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2e53c72052f2596fb792a7acd9704cbc549bf70fcde8a99e899311455974ca3", size = 169974 }, + { url = "https://files.pythonhosted.org/packages/fb/5b/013ed8b4611857ac92ac631079c08d9715b388bd1d88ec62e245f87a39df/websockets-14.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e3fbd68850c837e57373d95c8fe352203a512b6e49eaae4c2f4088ef8cf21980", size = 168985 }, + { url = "https://files.pythonhosted.org/packages/cd/33/aa3e32fd0df213a5a442310754fe3f89dd87a0b8e5b4e11e0991dd3bcc50/websockets-14.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b27ece32f63150c268593d5fdb82819584831a83a3f5809b7521df0685cd5d8", size = 169297 }, + { url = "https://files.pythonhosted.org/packages/93/17/dae0174883d6399f57853ac44abf5f228eaba86d98d160f390ffabc19b6e/websockets-14.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4daa0faea5424d8713142b33825fff03c736f781690d90652d2c8b053345b0e7", size = 169677 }, + { url = "https://files.pythonhosted.org/packages/42/e2/0375af7ac00169b98647c804651c515054b34977b6c1354f1458e4116c1e/websockets-14.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:bc63cee8596a6ec84d9753fd0fcfa0452ee12f317afe4beae6b157f0070c6c7f", size = 169089 }, + { url = "https://files.pythonhosted.org/packages/73/8d/80f71d2a351a44b602859af65261d3dde3a0ce4e76cf9383738a949e0cc3/websockets-14.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7a570862c325af2111343cc9b0257b7119b904823c675b22d4ac547163088d0d", size = 169026 }, + { url = "https://files.pythonhosted.org/packages/48/97/173b1fa6052223e52bb4054a141433ad74931d94c575e04b654200b98ca4/websockets-14.2-cp310-cp310-win32.whl", hash = "sha256:75862126b3d2d505e895893e3deac0a9339ce750bd27b4ba515f008b5acf832d", size = 163967 }, + { url = "https://files.pythonhosted.org/packages/c0/5b/2fcf60f38252a4562b28b66077e0d2b48f91fef645d5f78874cd1dec807b/websockets-14.2-cp310-cp310-win_amd64.whl", hash = "sha256:cc45afb9c9b2dc0852d5c8b5321759cf825f82a31bfaf506b65bf4668c96f8b2", size = 164413 }, + { url = "https://files.pythonhosted.org/packages/15/b6/504695fb9a33df0ca56d157f5985660b5fc5b4bf8c78f121578d2d653392/websockets-14.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3bdc8c692c866ce5fefcaf07d2b55c91d6922ac397e031ef9b774e5b9ea42166", size = 163088 }, + { url = "https://files.pythonhosted.org/packages/81/26/ebfb8f6abe963c795122439c6433c4ae1e061aaedfc7eff32d09394afbae/websockets-14.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c93215fac5dadc63e51bcc6dceca72e72267c11def401d6668622b47675b097f", size = 160745 }, + { url = "https://files.pythonhosted.org/packages/a1/c6/1435ad6f6dcbff80bb95e8986704c3174da8866ddb751184046f5c139ef6/websockets-14.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1c9b6535c0e2cf8a6bf938064fb754aaceb1e6a4a51a80d884cd5db569886910", size = 160995 }, + { url = "https://files.pythonhosted.org/packages/96/63/900c27cfe8be1a1f2433fc77cd46771cf26ba57e6bdc7cf9e63644a61863/websockets-14.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a52a6d7cf6938e04e9dceb949d35fbdf58ac14deea26e685ab6368e73744e4c", size = 170543 }, + { url = "https://files.pythonhosted.org/packages/00/8b/bec2bdba92af0762d42d4410593c1d7d28e9bfd952c97a3729df603dc6ea/websockets-14.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9f05702e93203a6ff5226e21d9b40c037761b2cfb637187c9802c10f58e40473", size = 169546 }, + { url = "https://files.pythonhosted.org/packages/6b/a9/37531cb5b994f12a57dec3da2200ef7aadffef82d888a4c29a0d781568e4/websockets-14.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22441c81a6748a53bfcb98951d58d1af0661ab47a536af08920d129b4d1c3473", size = 169911 }, + { url = "https://files.pythonhosted.org/packages/60/d5/a6eadba2ed9f7e65d677fec539ab14a9b83de2b484ab5fe15d3d6d208c28/websockets-14.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd9b868d78b194790e6236d9cbc46d68aba4b75b22497eb4ab64fa640c3af56", size = 170183 }, + { url = "https://files.pythonhosted.org/packages/76/57/a338ccb00d1df881c1d1ee1f2a20c9c1b5b29b51e9e0191ee515d254fea6/websockets-14.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1a5a20d5843886d34ff8c57424cc65a1deda4375729cbca4cb6b3353f3ce4142", size = 169623 }, + { url = "https://files.pythonhosted.org/packages/64/22/e5f7c33db0cb2c1d03b79fd60d189a1da044e2661f5fd01d629451e1db89/websockets-14.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:34277a29f5303d54ec6468fb525d99c99938607bc96b8d72d675dee2b9f5bf1d", size = 169583 }, + { url = "https://files.pythonhosted.org/packages/aa/2e/2b4662237060063a22e5fc40d46300a07142afe30302b634b4eebd717c07/websockets-14.2-cp311-cp311-win32.whl", hash = "sha256:02687db35dbc7d25fd541a602b5f8e451a238ffa033030b172ff86a93cb5dc2a", size = 163969 }, + { url = "https://files.pythonhosted.org/packages/94/a5/0cda64e1851e73fc1ecdae6f42487babb06e55cb2f0dc8904b81d8ef6857/websockets-14.2-cp311-cp311-win_amd64.whl", hash = "sha256:862e9967b46c07d4dcd2532e9e8e3c2825e004ffbf91a5ef9dde519ee2effb0b", size = 164408 }, + { url = "https://files.pythonhosted.org/packages/c1/81/04f7a397653dc8bec94ddc071f34833e8b99b13ef1a3804c149d59f92c18/websockets-14.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1f20522e624d7ffbdbe259c6b6a65d73c895045f76a93719aa10cd93b3de100c", size = 163096 }, + { url = "https://files.pythonhosted.org/packages/ec/c5/de30e88557e4d70988ed4d2eabd73fd3e1e52456b9f3a4e9564d86353b6d/websockets-14.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:647b573f7d3ada919fd60e64d533409a79dcf1ea21daeb4542d1d996519ca967", size = 160758 }, + { url = "https://files.pythonhosted.org/packages/e5/8c/d130d668781f2c77d106c007b6c6c1d9db68239107c41ba109f09e6c218a/websockets-14.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6af99a38e49f66be5a64b1e890208ad026cda49355661549c507152113049990", size = 160995 }, + { url = "https://files.pythonhosted.org/packages/a6/bc/f6678a0ff17246df4f06765e22fc9d98d1b11a258cc50c5968b33d6742a1/websockets-14.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:091ab63dfc8cea748cc22c1db2814eadb77ccbf82829bac6b2fbe3401d548eda", size = 170815 }, + { url = "https://files.pythonhosted.org/packages/d8/b2/8070cb970c2e4122a6ef38bc5b203415fd46460e025652e1ee3f2f43a9a3/websockets-14.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b374e8953ad477d17e4851cdc66d83fdc2db88d9e73abf755c94510ebddceb95", size = 169759 }, + { url = "https://files.pythonhosted.org/packages/81/da/72f7caabd94652e6eb7e92ed2d3da818626e70b4f2b15a854ef60bf501ec/websockets-14.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a39d7eceeea35db85b85e1169011bb4321c32e673920ae9c1b6e0978590012a3", size = 170178 }, + { url = "https://files.pythonhosted.org/packages/31/e0/812725b6deca8afd3a08a2e81b3c4c120c17f68c9b84522a520b816cda58/websockets-14.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0a6f3efd47ffd0d12080594f434faf1cd2549b31e54870b8470b28cc1d3817d9", size = 170453 }, + { url = "https://files.pythonhosted.org/packages/66/d3/8275dbc231e5ba9bb0c4f93144394b4194402a7a0c8ffaca5307a58ab5e3/websockets-14.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:065ce275e7c4ffb42cb738dd6b20726ac26ac9ad0a2a48e33ca632351a737267", size = 169830 }, + { url = "https://files.pythonhosted.org/packages/a3/ae/e7d1a56755ae15ad5a94e80dd490ad09e345365199600b2629b18ee37bc7/websockets-14.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e9d0e53530ba7b8b5e389c02282f9d2aa47581514bd6049d3a7cffe1385cf5fe", size = 169824 }, + { url = "https://files.pythonhosted.org/packages/b6/32/88ccdd63cb261e77b882e706108d072e4f1c839ed723bf91a3e1f216bf60/websockets-14.2-cp312-cp312-win32.whl", hash = "sha256:20e6dd0984d7ca3037afcb4494e48c74ffb51e8013cac71cf607fffe11df7205", size = 163981 }, + { url = "https://files.pythonhosted.org/packages/b3/7d/32cdb77990b3bdc34a306e0a0f73a1275221e9a66d869f6ff833c95b56ef/websockets-14.2-cp312-cp312-win_amd64.whl", hash = "sha256:44bba1a956c2c9d268bdcdf234d5e5ff4c9b6dc3e300545cbe99af59dda9dcce", size = 164421 }, + { url = "https://files.pythonhosted.org/packages/82/94/4f9b55099a4603ac53c2912e1f043d6c49d23e94dd82a9ce1eb554a90215/websockets-14.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6f1372e511c7409a542291bce92d6c83320e02c9cf392223272287ce55bc224e", size = 163102 }, + { url = "https://files.pythonhosted.org/packages/8e/b7/7484905215627909d9a79ae07070057afe477433fdacb59bf608ce86365a/websockets-14.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4da98b72009836179bb596a92297b1a61bb5a830c0e483a7d0766d45070a08ad", size = 160766 }, + { url = "https://files.pythonhosted.org/packages/a3/a4/edb62efc84adb61883c7d2c6ad65181cb087c64252138e12d655989eec05/websockets-14.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8a86a269759026d2bde227652b87be79f8a734e582debf64c9d302faa1e9f03", size = 160998 }, + { url = "https://files.pythonhosted.org/packages/f5/79/036d320dc894b96af14eac2529967a6fc8b74f03b83c487e7a0e9043d842/websockets-14.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86cf1aaeca909bf6815ea714d5c5736c8d6dd3a13770e885aafe062ecbd04f1f", size = 170780 }, + { url = "https://files.pythonhosted.org/packages/63/75/5737d21ee4dd7e4b9d487ee044af24a935e36a9ff1e1419d684feedcba71/websockets-14.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9b0f6c3ba3b1240f602ebb3971d45b02cc12bd1845466dd783496b3b05783a5", size = 169717 }, + { url = "https://files.pythonhosted.org/packages/2c/3c/bf9b2c396ed86a0b4a92ff4cdaee09753d3ee389be738e92b9bbd0330b64/websockets-14.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:669c3e101c246aa85bc8534e495952e2ca208bd87994650b90a23d745902db9a", size = 170155 }, + { url = "https://files.pythonhosted.org/packages/75/2d/83a5aca7247a655b1da5eb0ee73413abd5c3a57fc8b92915805e6033359d/websockets-14.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eabdb28b972f3729348e632ab08f2a7b616c7e53d5414c12108c29972e655b20", size = 170495 }, + { url = "https://files.pythonhosted.org/packages/79/dd/699238a92761e2f943885e091486378813ac8f43e3c84990bc394c2be93e/websockets-14.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2066dc4cbcc19f32c12a5a0e8cc1b7ac734e5b64ac0a325ff8353451c4b15ef2", size = 169880 }, + { url = "https://files.pythonhosted.org/packages/c8/c9/67a8f08923cf55ce61aadda72089e3ed4353a95a3a4bc8bf42082810e580/websockets-14.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ab95d357cd471df61873dadf66dd05dd4709cae001dd6342edafc8dc6382f307", size = 169856 }, + { url = "https://files.pythonhosted.org/packages/17/b1/1ffdb2680c64e9c3921d99db460546194c40d4acbef999a18c37aa4d58a3/websockets-14.2-cp313-cp313-win32.whl", hash = "sha256:a9e72fb63e5f3feacdcf5b4ff53199ec8c18d66e325c34ee4c551ca748623bbc", size = 163974 }, + { url = "https://files.pythonhosted.org/packages/14/13/8b7fc4cb551b9cfd9890f0fd66e53c18a06240319915533b033a56a3d520/websockets-14.2-cp313-cp313-win_amd64.whl", hash = "sha256:b439ea828c4ba99bb3176dc8d9b933392a2413c0f6b149fdcba48393f573377f", size = 164420 }, + { url = "https://files.pythonhosted.org/packages/6f/eb/367e0ed7b8a960b4fc12c7c6bf3ebddf06875037de641637994849560d47/websockets-14.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7cd5706caec1686c5d233bc76243ff64b1c0dc445339bd538f30547e787c11fe", size = 163087 }, + { url = "https://files.pythonhosted.org/packages/96/f7/1f18d028ec4a2c14598dfec6a73381a915c27464b693873198c1de872095/websockets-14.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ec607328ce95a2f12b595f7ae4c5d71bf502212bddcea528290b35c286932b12", size = 160740 }, + { url = "https://files.pythonhosted.org/packages/5c/db/b4b353fb9c3f0eaa8138ea4c76e6fa555b6d2821ed2d51d0ac3c320bc57e/websockets-14.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:da85651270c6bfb630136423037dd4975199e5d4114cae6d3066641adcc9d1c7", size = 160992 }, + { url = "https://files.pythonhosted.org/packages/b9/b1/9149e420c61f375e432654d5c1545e563b90ac1f829ee1a8d1dccaf0869d/websockets-14.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3ecadc7ce90accf39903815697917643f5b7cfb73c96702318a096c00aa71f5", size = 169757 }, + { url = "https://files.pythonhosted.org/packages/2b/33/0bb58204191e113212360f1392b6b1e9f85f62c7ca5b3b15f52f2f835516/websockets-14.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1979bee04af6a78608024bad6dfcc0cc930ce819f9e10342a29a05b5320355d0", size = 168762 }, + { url = "https://files.pythonhosted.org/packages/be/3d/c3c192f16210d7b7535fbf4ee9a299612f4dccff665587617b13fa0a6aa3/websockets-14.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dddacad58e2614a24938a50b85969d56f88e620e3f897b7d80ac0d8a5800258", size = 169060 }, + { url = "https://files.pythonhosted.org/packages/a6/73/75efa8d9e4b1b257818a7b7a0b9ac84a07c91120b52148941370ef2c8f16/websockets-14.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:89a71173caaf75fa71a09a5f614f450ba3ec84ad9fca47cb2422a860676716f0", size = 169457 }, + { url = "https://files.pythonhosted.org/packages/a4/11/300cf36cfd6990ffb218394862f0513be8c21917c9ff5e362f94599caedd/websockets-14.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:6af6a4b26eea4fc06c6818a6b962a952441e0e39548b44773502761ded8cc1d4", size = 168860 }, + { url = "https://files.pythonhosted.org/packages/c0/3d/5fd82500714ab7c09f003bde671dad1a3a131ac77b6b11ada72e466de4f6/websockets-14.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:80c8efa38957f20bba0117b48737993643204645e9ec45512579132508477cfc", size = 168825 }, + { url = "https://files.pythonhosted.org/packages/88/16/715580eb6caaacc232f303e9619103a42dcd354b0854baa5ed26aacaf828/websockets-14.2-cp39-cp39-win32.whl", hash = "sha256:2e20c5f517e2163d76e2729104abc42639c41cf91f7b1839295be43302713661", size = 163960 }, + { url = "https://files.pythonhosted.org/packages/63/a7/a1035cb198eaa12eaa9621aaaa3ec021b0e3bac96e1df9ceb6bfe5e53e5f/websockets-14.2-cp39-cp39-win_amd64.whl", hash = "sha256:b4c8cef610e8d7c70dea92e62b6814a8cd24fbd01d7103cc89308d2bfe1659ef", size = 164424 }, + { url = "https://files.pythonhosted.org/packages/10/3d/91d3d2bb1325cd83e8e2c02d0262c7d4426dc8fa0831ef1aa4d6bf2041af/websockets-14.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d7d9cafbccba46e768be8a8ad4635fa3eae1ffac4c6e7cb4eb276ba41297ed29", size = 160773 }, + { url = "https://files.pythonhosted.org/packages/33/7c/cdedadfef7381939577858b1b5718a4ab073adbb584e429dd9d9dc9bfe16/websockets-14.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:c76193c1c044bd1e9b3316dcc34b174bbf9664598791e6fb606d8d29000e070c", size = 161007 }, + { url = "https://files.pythonhosted.org/packages/ca/35/7a20a3c450b27c04e50fbbfc3dfb161ed8e827b2a26ae31c4b59b018b8c6/websockets-14.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd475a974d5352390baf865309fe37dec6831aafc3014ffac1eea99e84e83fc2", size = 162264 }, + { url = "https://files.pythonhosted.org/packages/e8/9c/e3f9600564b0c813f2448375cf28b47dc42c514344faed3a05d71fb527f9/websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2c6c0097a41968b2e2b54ed3424739aab0b762ca92af2379f152c1aef0187e1c", size = 161873 }, + { url = "https://files.pythonhosted.org/packages/3f/37/260f189b16b2b8290d6ae80c9f96d8b34692cf1bb3475df54c38d3deb57d/websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d7ff794c8b36bc402f2e07c0b2ceb4a2424147ed4785ff03e2a7af03711d60a", size = 161818 }, + { url = "https://files.pythonhosted.org/packages/ff/1e/e47dedac8bf7140e59aa6a679e850c4df9610ae844d71b6015263ddea37b/websockets-14.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dec254fcabc7bd488dab64846f588fc5b6fe0d78f641180030f8ea27b76d72c3", size = 164465 }, + { url = "https://files.pythonhosted.org/packages/f7/c0/8e9325c4987dcf66d4a0d63ec380d4aefe8dcc1e521af71ad17adf2c1ae2/websockets-14.2-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:bbe03eb853e17fd5b15448328b4ec7fb2407d45fb0245036d06a3af251f8e48f", size = 160773 }, + { url = "https://files.pythonhosted.org/packages/5a/6e/c9a7f2edd4afddc4f8cccfc4e12468b7f6ec40f28d1b1e966a8d0298b875/websockets-14.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a3c4aa3428b904d5404a0ed85f3644d37e2cb25996b7f096d77caeb0e96a3b42", size = 161006 }, + { url = "https://files.pythonhosted.org/packages/f3/10/b90ece894828c954e674a81cb0db250e6c324c54db30a8b19e96431f928f/websockets-14.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:577a4cebf1ceaf0b65ffc42c54856214165fb8ceeba3935852fc33f6b0c55e7f", size = 162260 }, + { url = "https://files.pythonhosted.org/packages/52/93/1147b6b5464a5fb6e8987da3ec7991dcc44f9090f67d9c841d7382fed429/websockets-14.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad1c1d02357b7665e700eca43a31d52814ad9ad9b89b58118bdabc365454b574", size = 161868 }, + { url = "https://files.pythonhosted.org/packages/32/ab/f7d80b4049bff0aa617507330db3a27389d0e70df54e29f7a3d76bbd2086/websockets-14.2-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f390024a47d904613577df83ba700bd189eedc09c57af0a904e5c39624621270", size = 161813 }, + { url = "https://files.pythonhosted.org/packages/cd/cc/adc9fb85f031b8df8e9f3d96cc004df25d2643e503953af5223c5b6825b7/websockets-14.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3c1426c021c38cf92b453cdf371228d3430acd775edee6bac5a4d577efc72365", size = 164457 }, + { url = "https://files.pythonhosted.org/packages/7b/c8/d529f8a32ce40d98309f4470780631e971a5a842b60aec864833b3615786/websockets-14.2-py3-none-any.whl", hash = "sha256:7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b", size = 157416 }, ] [[package]] @@ -1071,16 +1059,16 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "markupsafe" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d4/f9/0ba83eaa0df9b9e9d1efeb2ea351d0677c37d41ee5d0f91e98423c7281c9/werkzeug-3.0.6.tar.gz", hash = "sha256:a8dd59d4de28ca70471a34cba79bed5f7ef2e036a76b3ab0835474246eb41f8d", size = 805170, upload_time = "2024-10-25T18:52:31.688Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/f9/0ba83eaa0df9b9e9d1efeb2ea351d0677c37d41ee5d0f91e98423c7281c9/werkzeug-3.0.6.tar.gz", hash = "sha256:a8dd59d4de28ca70471a34cba79bed5f7ef2e036a76b3ab0835474246eb41f8d", size = 805170 } wheels = [ - { url = "https://files.pythonhosted.org/packages/6c/69/05837f91dfe42109203ffa3e488214ff86a6d68b2ed6c167da6cdc42349b/werkzeug-3.0.6-py3-none-any.whl", hash = "sha256:1bc0c2310d2fbb07b1dd1105eba2f7af72f322e1e455f2f93c993bee8c8a5f17", size = 227979, upload_time = "2024-10-25T18:52:30.129Z" }, + { url = "https://files.pythonhosted.org/packages/6c/69/05837f91dfe42109203ffa3e488214ff86a6d68b2ed6c167da6cdc42349b/werkzeug-3.0.6-py3-none-any.whl", hash = "sha256:1bc0c2310d2fbb07b1dd1105eba2f7af72f322e1e455f2f93c993bee8c8a5f17", size = 227979 }, ] [[package]] name = "zipp" version = "3.20.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/54/bf/5c0000c44ebc80123ecbdddba1f5dcd94a5ada602a9c225d84b5aaa55e86/zipp-3.20.2.tar.gz", hash = "sha256:bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29", size = 24199, upload_time = "2024-09-13T13:44:16.101Z" } +sdist = { url = "https://files.pythonhosted.org/packages/54/bf/5c0000c44ebc80123ecbdddba1f5dcd94a5ada602a9c225d84b5aaa55e86/zipp-3.20.2.tar.gz", hash = "sha256:bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29", size = 24199 } wheels = [ - { url = "https://files.pythonhosted.org/packages/62/8b/5ba542fa83c90e09eac972fc9baca7a88e7e7ca4b221a89251954019308b/zipp-3.20.2-py3-none-any.whl", hash = "sha256:a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350", size = 9200, upload_time = "2024-09-13T13:44:14.38Z" }, + { url = "https://files.pythonhosted.org/packages/62/8b/5ba542fa83c90e09eac972fc9baca7a88e7e7ca4b221a89251954019308b/zipp-3.20.2-py3-none-any.whl", hash = "sha256:a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350", size = 9200 }, ] diff --git a/integ-tests/react/baml_client/type_builder.ts b/integ-tests/react/baml_client/type_builder.ts index 0e7afd2bbd..d64e2b9241 100644 --- a/integ-tests/react/baml_client/type_builder.ts +++ b/integ-tests/react/baml_client/type_builder.ts @@ -19,772 +19,778 @@ $ pnpm add @boundaryml/baml // biome-ignore format: autogenerated code import { FieldType } from '@boundaryml/baml/native' -import { TypeBuilder as _TypeBuilder, EnumBuilder, EnumViewer, ClassBuilder, ClassViewer } from '@boundaryml/baml/type_builder' +import { TypeBuilder as _TypeBuilder, EnumBuilder, ClassBuilder } from '@boundaryml/baml/type_builder' import { DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME } from "./globals" export { FieldType, EnumBuilder, ClassBuilder } +type ClassProperties = { + + "AnotherObject": ["id", "thingy2", "thingy3", ], + + "BigNumbers": ["a", "b", ], + + "BinaryNode": ["data", "left", "right", ], + + "Blah": ["prop4", ], + + "BlockConstraint": ["foo", "bar", ], + + "BlockConstraintForParam": ["bcfp", "bcfp2", ], + + "BookOrder": ["orderId", "title", "quantity", "price", ], + + "ClassForNullLiteral": ["a", ], + + "ClassOptionalOutput": ["prop1", "prop2", ], + + "ClassOptionalOutput2": ["prop1", "prop2", "prop3", ], + + "ClassToRecAlias": ["list", ], + + "ClassWithBlockDone": ["i_16_digits", "s_20_words", ], + + "ClassWithImage": ["myImage", "param2", "fake_image", ], + + "ClassWithoutDone": ["i_16_digits", "s_20_words", ], + + "ClientDetails1559": ["client_name", "client_address", "client_postal_code", "client_city", "client_country", "client_phone", "client_email", ], + + "ComplexMemoryObject": ["id", "name", "description", "metadata", ], + + "CompoundBigNumbers": ["big", "big_nums", "another", ], + + "ContactInfo": ["primary", "secondary", ], + + "CustomStory": ["title", "characters", "content", ], + + "CustomTaskResult": ["bookOrder", "flightConfirmation", "groceryReceipt", ], + + "Document1559": ["client_details", "notes", ], + + "DummyOutput": ["nonce", "nonce2", ], + + "DynInputOutput": ["testKey", ], + + "DynamicClassOne": [], + + "DynamicClassTwo": ["hi", "some_class", "status", ], + + "DynamicOutput": [], + + "DynamicSchema": [], + + "Earthling": ["age", ], + + "Education": ["institution", "location", "degree", "major", "graduation_date", ], + + "Email": ["subject", "body", "from_address", ], + + "EmailAddress": ["value", ], + + "Event": ["title", "date", "location", "description", ], + + "FakeImage": ["url", ], + + "FlightConfirmation": ["confirmationNumber", "flightNumber", "departureTime", "arrivalTime", "seatNumber", ], + + "FooAny": ["planetary_age", "certainty", "species", ], + + "Forest": ["trees", ], + + "FormatterTest0": ["lorem", "ipsum", ], + + "FormatterTest1": ["lorem", "ipsum", ], + + "FormatterTest2": ["lorem", "ipsum", ], + + "FormatterTest3": ["lorem", "ipsum", ], + + "GroceryReceipt": ["receiptId", "storeName", "items", "totalAmount", ], + + "Haiku": ["line1", "line2", "line3", ], + + "InnerClass": ["prop1", "prop2", "inner", ], + + "InnerClass2": ["prop2", "prop3", ], + + "InputClass": ["key", "key2", ], + + "InputClassNested": ["key", "nested", ], + + "LinkedList": ["head", "len", ], + + "LinkedListAliasNode": ["value", "next", ], + + "LiteralClassHello": ["prop", ], + + "LiteralClassOne": ["prop", ], + + "LiteralClassTwo": ["prop", ], + + "MaintainFieldOrder": ["a", "b", "c", ], + + "MalformedConstraints": ["foo", ], + + "MalformedConstraints2": ["foo", ], + + "Martian": ["age", ], + + "MemoryObject": ["id", "name", "description", ], + + "MergeAttrs": ["amount", ], + + "NamedArgsSingleClass": ["key", "key_two", "key_three", ], + + "Nested": ["prop3", "prop4", "prop20", ], + + "Nested2": ["prop11", "prop12", ], + + "NestedBlockConstraint": ["nbc", ], + + "NestedBlockConstraintForParam": ["nbcfp", ], + + "Node": ["data", "next", ], + + "NodeWithAliasIndirection": ["value", "next", ], + + "Note1599": ["note_title", "note_description", "note_amount", ], + + "OptionalListAndMap": ["p", "q", ], + + "OptionalTest_Prop1": ["omega_a", "omega_b", ], + + "OptionalTest_ReturnType": ["omega_1", "omega_2", "omega_3", ], + + "OrderInfo": ["order_status", "tracking_number", "estimated_arrival_date", ], + + "OriginalA": ["value", ], + + "OriginalB": ["value", ], + + "Person": ["name", "hair_color", ], + + "PhoneNumber": ["value", ], + + "Quantity": ["amount", "unit", ], + + "RaysData": ["dataType", "value", ], + + "ReceiptInfo": ["items", "total_cost", "venue", ], + + "ReceiptItem": ["name", "description", "quantity", "price", ], + + "Recipe": ["ingredients", "recipe_type", ], + + "RecursiveAliasDependency": ["value", ], + + "RenderEnumInput": ["testKey", ], + + "RenderTestClass": ["name", "status", ], + + "Resume": ["name", "email", "phone", "experience", "education", "skills", ], + + "Schema": ["prop1", "prop2", "prop5", "prop6", "nested_attrs", "parens", "other_group", ], + + "SearchParams": ["dateRange", "location", "jobTitle", "company", "description", "tags", ], + + "SemanticContainer": ["sixteen_digit_number", "string_with_twenty_words", "class_1", "class_2", "class_done_needed", "class_needed", "three_small_things", "final_string", ], + + "SimpleTag": ["field", ], + + "SmallThing": ["i_16_digits", "i_8_digits", ], + + "SomeClassNestedDynamic": ["hi", ], + + "StringToClassEntry": ["word", ], + + "TestClassAlias": ["key", "key2", "key3", "key4", "key5", ], + + "TestClassNested": ["prop1", "prop2", ], + + "TestClassWithEnum": ["prop1", "prop2", ], + + "TestMemoryOutput": ["items", "more_items", ], + + "TestOutputClass": ["prop1", "prop2", ], + + "Tree": ["data", "children", ], + + "TwoStoriesOneTitle": ["title", "story_a", "story_b", ], + + "TwoStoriesOneTitleCheck": ["title", "story_a", "story_b", ], + + "UnionTest_ReturnType": ["prop1", "prop2", "prop3", ], + + "UniverseQuestion": ["question", "answer", ], + + "UniverseQuestionInput": ["question", ], + + "WithReasoning": ["value", "reasoning", ], + +} +type EnumValues = { + + "AliasedEnum": ["KEY_ONE", "KEY_TWO", ], + + "Category": ["Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ], + + "Category2": ["Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ], + + "Category3": ["Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ], + + "Color": ["RED", "BLUE", "GREEN", "YELLOW", "BLACK", "WHITE", ], + + "DataType": ["Resume", "Event", ], + + "DynEnumOne": [], + + "DynEnumThree": ["TRICYCLE", "TRIANGLE", ], + + "DynEnumTwo": [], + + "EnumInClass": ["ONE", "TWO", ], + + "EnumOutput": ["ONE", "TWO", "THREE", ], + + "Hobby": ["SPORTS", "MUSIC", "READING", ], + + "MapKey": ["A", "B", "C", ], + + "NamedArgsSingleEnum": ["ONE", "TWO", ], + + "NamedArgsSingleEnumList": ["ONE", "TWO", ], + + "OptionalTest_CategoryType": ["Aleph", "Beta", "Gamma", ], + + "OrderStatus": ["ORDERED", "SHIPPED", "DELIVERED", "CANCELLED", ], + + "RenderStatusEnum": ["ACTIVE", "INACTIVE", ], + + "RenderTestEnum": ["BIKE", "SCOOTER", ], + + "Tag": ["Security", "AI", "Blockchain", ], + + "TestEnum": ["A", "B", "C", "D", "E", "F", "G", ], + +} +type ClassNames = keyof ClassProperties; +type EnumNames = keyof EnumValues; + +type _ClassBuilder = ClassBuilder; +type _EnumBuilder = EnumBuilder; + +function _getEnum(tb: _TypeBuilder, name: Name): _EnumBuilder { + return tb.getEnum(name); +} + +function _getClass(tb: _TypeBuilder, name: Name): _ClassBuilder { + return tb.getClass(name); +} + export default class TypeBuilder { private tb: _TypeBuilder; - AnotherObject: ClassViewer<'AnotherObject', "id" | "thingy2" | "thingy3">; + AnotherObject: _ClassBuilder<'AnotherObject', false>; - BigNumbers: ClassViewer<'BigNumbers', "a" | "b">; + BigNumbers: _ClassBuilder<'BigNumbers', false>; - BinaryNode: ClassViewer<'BinaryNode', "data" | "left" | "right">; + BinaryNode: _ClassBuilder<'BinaryNode', false>; - Blah: ClassViewer<'Blah', "prop4">; + Blah: _ClassBuilder<'Blah', false>; - BlockConstraint: ClassViewer<'BlockConstraint', "foo" | "bar">; + BlockConstraint: _ClassBuilder<'BlockConstraint', false>; - BlockConstraintForParam: ClassViewer<'BlockConstraintForParam', "bcfp" | "bcfp2">; + BlockConstraintForParam: _ClassBuilder<'BlockConstraintForParam', false>; - BookOrder: ClassViewer<'BookOrder', "orderId" | "title" | "quantity" | "price">; + BookOrder: _ClassBuilder<'BookOrder', false>; - ClassForNullLiteral: ClassViewer<'ClassForNullLiteral', "a">; + ClassForNullLiteral: _ClassBuilder<'ClassForNullLiteral', false>; - ClassOptionalOutput: ClassViewer<'ClassOptionalOutput', "prop1" | "prop2">; + ClassOptionalOutput: _ClassBuilder<'ClassOptionalOutput', false>; - ClassOptionalOutput2: ClassViewer<'ClassOptionalOutput2', "prop1" | "prop2" | "prop3">; + ClassOptionalOutput2: _ClassBuilder<'ClassOptionalOutput2', false>; - ClassToRecAlias: ClassViewer<'ClassToRecAlias', "list">; + ClassToRecAlias: _ClassBuilder<'ClassToRecAlias', false>; - ClassWithBlockDone: ClassViewer<'ClassWithBlockDone', "i_16_digits" | "s_20_words">; + ClassWithBlockDone: _ClassBuilder<'ClassWithBlockDone', false>; - ClassWithImage: ClassViewer<'ClassWithImage', "myImage" | "param2" | "fake_image">; + ClassWithImage: _ClassBuilder<'ClassWithImage', false>; - ClassWithoutDone: ClassViewer<'ClassWithoutDone', "i_16_digits" | "s_20_words">; + ClassWithoutDone: _ClassBuilder<'ClassWithoutDone', false>; - ClientDetails1559: ClassViewer<'ClientDetails1559', "client_name" | "client_address" | "client_postal_code" | "client_city" | "client_country" | "client_phone" | "client_email">; + ClientDetails1559: _ClassBuilder<'ClientDetails1559', false>; - ComplexMemoryObject: ClassViewer<'ComplexMemoryObject', "id" | "name" | "description" | "metadata">; + ComplexMemoryObject: _ClassBuilder<'ComplexMemoryObject', false>; - CompoundBigNumbers: ClassViewer<'CompoundBigNumbers', "big" | "big_nums" | "another">; + CompoundBigNumbers: _ClassBuilder<'CompoundBigNumbers', false>; - ContactInfo: ClassViewer<'ContactInfo', "primary" | "secondary">; + ContactInfo: _ClassBuilder<'ContactInfo', false>; - CustomStory: ClassViewer<'CustomStory', "title" | "characters" | "content">; + CustomStory: _ClassBuilder<'CustomStory', false>; - CustomTaskResult: ClassViewer<'CustomTaskResult', "bookOrder" | "flightConfirmation" | "groceryReceipt">; + CustomTaskResult: _ClassBuilder<'CustomTaskResult', false>; - Document1559: ClassViewer<'Document1559', "client_details" | "notes">; + Document1559: _ClassBuilder<'Document1559', false>; - DummyOutput: ClassBuilder<'DummyOutput', "nonce" | "nonce2">; + DummyOutput: _ClassBuilder<'DummyOutput', true>; - DynInputOutput: ClassBuilder<'DynInputOutput', "testKey">; + DynInputOutput: _ClassBuilder<'DynInputOutput', true>; - DynamicClassOne: ClassBuilder<'DynamicClassOne'>; + DynamicClassOne: _ClassBuilder<'DynamicClassOne', true>; - DynamicClassTwo: ClassBuilder<'DynamicClassTwo', "hi" | "some_class" | "status">; + DynamicClassTwo: _ClassBuilder<'DynamicClassTwo', true>; - DynamicOutput: ClassBuilder<'DynamicOutput'>; + DynamicOutput: _ClassBuilder<'DynamicOutput', true>; - DynamicSchema: ClassBuilder<'DynamicSchema'>; + DynamicSchema: _ClassBuilder<'DynamicSchema', true>; - Earthling: ClassViewer<'Earthling', "age">; + Earthling: _ClassBuilder<'Earthling', false>; - Education: ClassViewer<'Education', "institution" | "location" | "degree" | "major" | "graduation_date">; + Education: _ClassBuilder<'Education', false>; - Email: ClassViewer<'Email', "subject" | "body" | "from_address">; + Email: _ClassBuilder<'Email', false>; - EmailAddress: ClassViewer<'EmailAddress', "value">; + EmailAddress: _ClassBuilder<'EmailAddress', false>; - Event: ClassViewer<'Event', "title" | "date" | "location" | "description">; + Event: _ClassBuilder<'Event', false>; - FakeImage: ClassViewer<'FakeImage', "url">; + FakeImage: _ClassBuilder<'FakeImage', false>; - FlightConfirmation: ClassViewer<'FlightConfirmation', "confirmationNumber" | "flightNumber" | "departureTime" | "arrivalTime" | "seatNumber">; + FlightConfirmation: _ClassBuilder<'FlightConfirmation', false>; - FooAny: ClassViewer<'FooAny', "planetary_age" | "certainty" | "species">; + FooAny: _ClassBuilder<'FooAny', false>; - Forest: ClassViewer<'Forest', "trees">; + Forest: _ClassBuilder<'Forest', false>; - FormatterTest0: ClassViewer<'FormatterTest0', "lorem" | "ipsum">; + FormatterTest0: _ClassBuilder<'FormatterTest0', false>; - FormatterTest1: ClassViewer<'FormatterTest1', "lorem" | "ipsum">; + FormatterTest1: _ClassBuilder<'FormatterTest1', false>; - FormatterTest2: ClassViewer<'FormatterTest2', "lorem" | "ipsum">; + FormatterTest2: _ClassBuilder<'FormatterTest2', false>; - FormatterTest3: ClassViewer<'FormatterTest3', "lorem" | "ipsum">; + FormatterTest3: _ClassBuilder<'FormatterTest3', false>; - GroceryReceipt: ClassViewer<'GroceryReceipt', "receiptId" | "storeName" | "items" | "totalAmount">; + GroceryReceipt: _ClassBuilder<'GroceryReceipt', false>; - Haiku: ClassViewer<'Haiku', "line1" | "line2" | "line3">; + Haiku: _ClassBuilder<'Haiku', false>; - InnerClass: ClassViewer<'InnerClass', "prop1" | "prop2" | "inner">; + InnerClass: _ClassBuilder<'InnerClass', false>; - InnerClass2: ClassViewer<'InnerClass2', "prop2" | "prop3">; + InnerClass2: _ClassBuilder<'InnerClass2', false>; - InputClass: ClassViewer<'InputClass', "key" | "key2">; + InputClass: _ClassBuilder<'InputClass', false>; - InputClassNested: ClassViewer<'InputClassNested', "key" | "nested">; + InputClassNested: _ClassBuilder<'InputClassNested', false>; - LinkedList: ClassViewer<'LinkedList', "head" | "len">; + LinkedList: _ClassBuilder<'LinkedList', false>; - LinkedListAliasNode: ClassViewer<'LinkedListAliasNode', "value" | "next">; + LinkedListAliasNode: _ClassBuilder<'LinkedListAliasNode', false>; - LiteralClassHello: ClassViewer<'LiteralClassHello', "prop">; + LiteralClassHello: _ClassBuilder<'LiteralClassHello', false>; - LiteralClassOne: ClassViewer<'LiteralClassOne', "prop">; + LiteralClassOne: _ClassBuilder<'LiteralClassOne', false>; - LiteralClassTwo: ClassViewer<'LiteralClassTwo', "prop">; + LiteralClassTwo: _ClassBuilder<'LiteralClassTwo', false>; - MaintainFieldOrder: ClassViewer<'MaintainFieldOrder', "a" | "b" | "c">; + MaintainFieldOrder: _ClassBuilder<'MaintainFieldOrder', false>; - MalformedConstraints: ClassViewer<'MalformedConstraints', "foo">; + MalformedConstraints: _ClassBuilder<'MalformedConstraints', false>; - MalformedConstraints2: ClassViewer<'MalformedConstraints2', "foo">; + MalformedConstraints2: _ClassBuilder<'MalformedConstraints2', false>; - Martian: ClassViewer<'Martian', "age">; + Martian: _ClassBuilder<'Martian', false>; - MemoryObject: ClassViewer<'MemoryObject', "id" | "name" | "description">; + MemoryObject: _ClassBuilder<'MemoryObject', false>; - MergeAttrs: ClassViewer<'MergeAttrs', "amount">; + MergeAttrs: _ClassBuilder<'MergeAttrs', false>; - NamedArgsSingleClass: ClassViewer<'NamedArgsSingleClass', "key" | "key_two" | "key_three">; + NamedArgsSingleClass: _ClassBuilder<'NamedArgsSingleClass', false>; - Nested: ClassViewer<'Nested', "prop3" | "prop4" | "prop20">; + Nested: _ClassBuilder<'Nested', false>; - Nested2: ClassViewer<'Nested2', "prop11" | "prop12">; + Nested2: _ClassBuilder<'Nested2', false>; - NestedBlockConstraint: ClassViewer<'NestedBlockConstraint', "nbc">; + NestedBlockConstraint: _ClassBuilder<'NestedBlockConstraint', false>; - NestedBlockConstraintForParam: ClassViewer<'NestedBlockConstraintForParam', "nbcfp">; + NestedBlockConstraintForParam: _ClassBuilder<'NestedBlockConstraintForParam', false>; - Node: ClassViewer<'Node', "data" | "next">; + Node: _ClassBuilder<'Node', false>; - NodeWithAliasIndirection: ClassViewer<'NodeWithAliasIndirection', "value" | "next">; + NodeWithAliasIndirection: _ClassBuilder<'NodeWithAliasIndirection', false>; - Note1599: ClassViewer<'Note1599', "note_title" | "note_description" | "note_amount">; + Note1599: _ClassBuilder<'Note1599', false>; - OptionalListAndMap: ClassViewer<'OptionalListAndMap', "p" | "q">; + OptionalListAndMap: _ClassBuilder<'OptionalListAndMap', false>; - OptionalTest_Prop1: ClassViewer<'OptionalTest_Prop1', "omega_a" | "omega_b">; + OptionalTest_Prop1: _ClassBuilder<'OptionalTest_Prop1', false>; - OptionalTest_ReturnType: ClassViewer<'OptionalTest_ReturnType', "omega_1" | "omega_2" | "omega_3">; + OptionalTest_ReturnType: _ClassBuilder<'OptionalTest_ReturnType', false>; - OrderInfo: ClassViewer<'OrderInfo', "order_status" | "tracking_number" | "estimated_arrival_date">; + OrderInfo: _ClassBuilder<'OrderInfo', false>; - OriginalA: ClassViewer<'OriginalA', "value">; + OriginalA: _ClassBuilder<'OriginalA', false>; - OriginalB: ClassBuilder<'OriginalB', "value">; + OriginalB: _ClassBuilder<'OriginalB', true>; - Person: ClassBuilder<'Person', "name" | "hair_color">; + Person: _ClassBuilder<'Person', true>; - PhoneNumber: ClassViewer<'PhoneNumber', "value">; + PhoneNumber: _ClassBuilder<'PhoneNumber', false>; - Quantity: ClassViewer<'Quantity', "amount" | "unit">; + Quantity: _ClassBuilder<'Quantity', false>; - RaysData: ClassViewer<'RaysData', "dataType" | "value">; + RaysData: _ClassBuilder<'RaysData', false>; - ReceiptInfo: ClassViewer<'ReceiptInfo', "items" | "total_cost" | "venue">; + ReceiptInfo: _ClassBuilder<'ReceiptInfo', false>; - ReceiptItem: ClassViewer<'ReceiptItem', "name" | "description" | "quantity" | "price">; + ReceiptItem: _ClassBuilder<'ReceiptItem', false>; - Recipe: ClassViewer<'Recipe', "ingredients" | "recipe_type">; + Recipe: _ClassBuilder<'Recipe', false>; - RecursiveAliasDependency: ClassViewer<'RecursiveAliasDependency', "value">; + RecursiveAliasDependency: _ClassBuilder<'RecursiveAliasDependency', false>; - RenderEnumInput: ClassBuilder<'RenderEnumInput', "testKey">; + RenderEnumInput: _ClassBuilder<'RenderEnumInput', true>; - RenderTestClass: ClassBuilder<'RenderTestClass', "name" | "status">; + RenderTestClass: _ClassBuilder<'RenderTestClass', true>; - Resume: ClassViewer<'Resume', "name" | "email" | "phone" | "experience" | "education" | "skills">; + Resume: _ClassBuilder<'Resume', false>; - Schema: ClassViewer<'Schema', "prop1" | "prop2" | "prop5" | "prop6" | "nested_attrs" | "parens" | "other_group">; + Schema: _ClassBuilder<'Schema', false>; - SearchParams: ClassViewer<'SearchParams', "dateRange" | "location" | "jobTitle" | "company" | "description" | "tags">; + SearchParams: _ClassBuilder<'SearchParams', false>; - SemanticContainer: ClassViewer<'SemanticContainer', "sixteen_digit_number" | "string_with_twenty_words" | "class_1" | "class_2" | "class_done_needed" | "class_needed" | "three_small_things" | "final_string">; + SemanticContainer: _ClassBuilder<'SemanticContainer', false>; - SimpleTag: ClassViewer<'SimpleTag', "field">; + SimpleTag: _ClassBuilder<'SimpleTag', false>; - SmallThing: ClassViewer<'SmallThing', "i_16_digits" | "i_8_digits">; + SmallThing: _ClassBuilder<'SmallThing', false>; - SomeClassNestedDynamic: ClassBuilder<'SomeClassNestedDynamic', "hi">; + SomeClassNestedDynamic: _ClassBuilder<'SomeClassNestedDynamic', true>; - StringToClassEntry: ClassViewer<'StringToClassEntry', "word">; + StringToClassEntry: _ClassBuilder<'StringToClassEntry', false>; - TestClassAlias: ClassViewer<'TestClassAlias', "key" | "key2" | "key3" | "key4" | "key5">; + TestClassAlias: _ClassBuilder<'TestClassAlias', false>; - TestClassNested: ClassViewer<'TestClassNested', "prop1" | "prop2">; + TestClassNested: _ClassBuilder<'TestClassNested', false>; - TestClassWithEnum: ClassViewer<'TestClassWithEnum', "prop1" | "prop2">; + TestClassWithEnum: _ClassBuilder<'TestClassWithEnum', false>; - TestMemoryOutput: ClassViewer<'TestMemoryOutput', "items" | "more_items">; + TestMemoryOutput: _ClassBuilder<'TestMemoryOutput', false>; - TestOutputClass: ClassViewer<'TestOutputClass', "prop1" | "prop2">; + TestOutputClass: _ClassBuilder<'TestOutputClass', false>; - Tree: ClassViewer<'Tree', "data" | "children">; + Tree: _ClassBuilder<'Tree', false>; - TwoStoriesOneTitle: ClassViewer<'TwoStoriesOneTitle', "title" | "story_a" | "story_b">; + TwoStoriesOneTitle: _ClassBuilder<'TwoStoriesOneTitle', false>; - TwoStoriesOneTitleCheck: ClassViewer<'TwoStoriesOneTitleCheck', "title" | "story_a" | "story_b">; + TwoStoriesOneTitleCheck: _ClassBuilder<'TwoStoriesOneTitleCheck', false>; - UnionTest_ReturnType: ClassViewer<'UnionTest_ReturnType', "prop1" | "prop2" | "prop3">; + UnionTest_ReturnType: _ClassBuilder<'UnionTest_ReturnType', false>; - UniverseQuestion: ClassViewer<'UniverseQuestion', "question" | "answer">; + UniverseQuestion: _ClassBuilder<'UniverseQuestion', false>; - UniverseQuestionInput: ClassViewer<'UniverseQuestionInput', "question">; + UniverseQuestionInput: _ClassBuilder<'UniverseQuestionInput', false>; - WithReasoning: ClassViewer<'WithReasoning', "value" | "reasoning">; + WithReasoning: _ClassBuilder<'WithReasoning', false>; - AliasedEnum: EnumViewer<'AliasedEnum', "KEY_ONE" | "KEY_TWO">; + AliasedEnum: _EnumBuilder<'AliasedEnum', false>; - Category: EnumViewer<'Category', "Refund" | "CancelOrder" | "TechnicalSupport" | "AccountIssue" | "Question">; + Category: _EnumBuilder<'Category', false>; - Category2: EnumViewer<'Category2', "Refund" | "CancelOrder" | "TechnicalSupport" | "AccountIssue" | "Question">; + Category2: _EnumBuilder<'Category2', false>; - Category3: EnumViewer<'Category3', "Refund" | "CancelOrder" | "TechnicalSupport" | "AccountIssue" | "Question">; + Category3: _EnumBuilder<'Category3', false>; - Color: EnumBuilder<'Color', "RED" | "BLUE" | "GREEN" | "YELLOW" | "BLACK" | "WHITE">; + Color: _EnumBuilder<'Color', true>; - DataType: EnumViewer<'DataType', "Resume" | "Event">; + DataType: _EnumBuilder<'DataType', false>; - DynEnumOne: EnumBuilder<'DynEnumOne'>; + DynEnumOne: _EnumBuilder<'DynEnumOne', true>; - DynEnumThree: EnumBuilder<'DynEnumThree', "TRICYCLE" | "TRIANGLE">; + DynEnumThree: _EnumBuilder<'DynEnumThree', true>; - DynEnumTwo: EnumBuilder<'DynEnumTwo'>; + DynEnumTwo: _EnumBuilder<'DynEnumTwo', true>; - EnumInClass: EnumViewer<'EnumInClass', "ONE" | "TWO">; + EnumInClass: _EnumBuilder<'EnumInClass', false>; - EnumOutput: EnumViewer<'EnumOutput', "ONE" | "TWO" | "THREE">; + EnumOutput: _EnumBuilder<'EnumOutput', false>; - Hobby: EnumBuilder<'Hobby', "SPORTS" | "MUSIC" | "READING">; + Hobby: _EnumBuilder<'Hobby', true>; - MapKey: EnumViewer<'MapKey', "A" | "B" | "C">; + MapKey: _EnumBuilder<'MapKey', false>; - NamedArgsSingleEnum: EnumViewer<'NamedArgsSingleEnum', "ONE" | "TWO">; + NamedArgsSingleEnum: _EnumBuilder<'NamedArgsSingleEnum', false>; - NamedArgsSingleEnumList: EnumViewer<'NamedArgsSingleEnumList', "ONE" | "TWO">; + NamedArgsSingleEnumList: _EnumBuilder<'NamedArgsSingleEnumList', false>; - OptionalTest_CategoryType: EnumViewer<'OptionalTest_CategoryType', "Aleph" | "Beta" | "Gamma">; + OptionalTest_CategoryType: _EnumBuilder<'OptionalTest_CategoryType', false>; - OrderStatus: EnumViewer<'OrderStatus', "ORDERED" | "SHIPPED" | "DELIVERED" | "CANCELLED">; + OrderStatus: _EnumBuilder<'OrderStatus', false>; - RenderStatusEnum: EnumBuilder<'RenderStatusEnum', "ACTIVE" | "INACTIVE">; + RenderStatusEnum: _EnumBuilder<'RenderStatusEnum', true>; - RenderTestEnum: EnumBuilder<'RenderTestEnum', "BIKE" | "SCOOTER">; + RenderTestEnum: _EnumBuilder<'RenderTestEnum', true>; - Tag: EnumViewer<'Tag', "Security" | "AI" | "Blockchain">; + Tag: _EnumBuilder<'Tag', false>; - TestEnum: EnumViewer<'TestEnum', "A" | "B" | "C" | "D" | "E" | "F" | "G">; + TestEnum: _EnumBuilder<'TestEnum', false>; constructor() { this.tb = new _TypeBuilder({ - classes: new Set([ - "AnotherObject","BigNumbers","BinaryNode","Blah","BlockConstraint","BlockConstraintForParam","BookOrder","ClassForNullLiteral","ClassOptionalOutput","ClassOptionalOutput2","ClassToRecAlias","ClassWithBlockDone","ClassWithImage","ClassWithoutDone","ClientDetails1559","ComplexMemoryObject","CompoundBigNumbers","ContactInfo","CustomStory","CustomTaskResult","Document1559","DummyOutput","DynInputOutput","DynamicClassOne","DynamicClassTwo","DynamicOutput","DynamicSchema","Earthling","Education","Email","EmailAddress","Event","FakeImage","FlightConfirmation","FooAny","Forest","FormatterTest0","FormatterTest1","FormatterTest2","FormatterTest3","GroceryReceipt","Haiku","InnerClass","InnerClass2","InputClass","InputClassNested","LinkedList","LinkedListAliasNode","LiteralClassHello","LiteralClassOne","LiteralClassTwo","MaintainFieldOrder","MalformedConstraints","MalformedConstraints2","Martian","MemoryObject","MergeAttrs","NamedArgsSingleClass","Nested","Nested2","NestedBlockConstraint","NestedBlockConstraintForParam","Node","NodeWithAliasIndirection","Note1599","OptionalListAndMap","OptionalTest_Prop1","OptionalTest_ReturnType","OrderInfo","OriginalA","OriginalB","Person","PhoneNumber","Quantity","RaysData","ReceiptInfo","ReceiptItem","Recipe","RecursiveAliasDependency","RenderEnumInput","RenderTestClass","Resume","Schema","SearchParams","SemanticContainer","SimpleTag","SmallThing","SomeClassNestedDynamic","StringToClassEntry","TestClassAlias","TestClassNested","TestClassWithEnum","TestMemoryOutput","TestOutputClass","Tree","TwoStoriesOneTitle","TwoStoriesOneTitleCheck","UnionTest_ReturnType","UniverseQuestion","UniverseQuestionInput","WithReasoning", - ]), - enums: new Set([ - "AliasedEnum","Category","Category2","Category3","Color","DataType","DynEnumOne","DynEnumThree","DynEnumTwo","EnumInClass","EnumOutput","Hobby","MapKey","NamedArgsSingleEnum","NamedArgsSingleEnumList","OptionalTest_CategoryType","OrderStatus","RenderStatusEnum","RenderTestEnum","Tag","TestEnum", - ]), runtime: DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME }); - this.AnotherObject = this.tb.classViewer("AnotherObject", [ - "id","thingy2","thingy3", - ]); + this.AnotherObject = _getClass(this.tb, "AnotherObject"); - this.BigNumbers = this.tb.classViewer("BigNumbers", [ - "a","b", - ]); + this.BigNumbers = _getClass(this.tb, "BigNumbers"); - this.BinaryNode = this.tb.classViewer("BinaryNode", [ - "data","left","right", - ]); + this.BinaryNode = _getClass(this.tb, "BinaryNode"); - this.Blah = this.tb.classViewer("Blah", [ - "prop4", - ]); + this.Blah = _getClass(this.tb, "Blah"); - this.BlockConstraint = this.tb.classViewer("BlockConstraint", [ - "foo","bar", - ]); + this.BlockConstraint = _getClass(this.tb, "BlockConstraint"); - this.BlockConstraintForParam = this.tb.classViewer("BlockConstraintForParam", [ - "bcfp","bcfp2", - ]); + this.BlockConstraintForParam = _getClass(this.tb, "BlockConstraintForParam"); - this.BookOrder = this.tb.classViewer("BookOrder", [ - "orderId","title","quantity","price", - ]); + this.BookOrder = _getClass(this.tb, "BookOrder"); - this.ClassForNullLiteral = this.tb.classViewer("ClassForNullLiteral", [ - "a", - ]); + this.ClassForNullLiteral = _getClass(this.tb, "ClassForNullLiteral"); - this.ClassOptionalOutput = this.tb.classViewer("ClassOptionalOutput", [ - "prop1","prop2", - ]); + this.ClassOptionalOutput = _getClass(this.tb, "ClassOptionalOutput"); - this.ClassOptionalOutput2 = this.tb.classViewer("ClassOptionalOutput2", [ - "prop1","prop2","prop3", - ]); + this.ClassOptionalOutput2 = _getClass(this.tb, "ClassOptionalOutput2"); - this.ClassToRecAlias = this.tb.classViewer("ClassToRecAlias", [ - "list", - ]); + this.ClassToRecAlias = _getClass(this.tb, "ClassToRecAlias"); - this.ClassWithBlockDone = this.tb.classViewer("ClassWithBlockDone", [ - "i_16_digits","s_20_words", - ]); + this.ClassWithBlockDone = _getClass(this.tb, "ClassWithBlockDone"); - this.ClassWithImage = this.tb.classViewer("ClassWithImage", [ - "myImage","param2","fake_image", - ]); + this.ClassWithImage = _getClass(this.tb, "ClassWithImage"); - this.ClassWithoutDone = this.tb.classViewer("ClassWithoutDone", [ - "i_16_digits","s_20_words", - ]); + this.ClassWithoutDone = _getClass(this.tb, "ClassWithoutDone"); - this.ClientDetails1559 = this.tb.classViewer("ClientDetails1559", [ - "client_name","client_address","client_postal_code","client_city","client_country","client_phone","client_email", - ]); + this.ClientDetails1559 = _getClass(this.tb, "ClientDetails1559"); - this.ComplexMemoryObject = this.tb.classViewer("ComplexMemoryObject", [ - "id","name","description","metadata", - ]); + this.ComplexMemoryObject = _getClass(this.tb, "ComplexMemoryObject"); - this.CompoundBigNumbers = this.tb.classViewer("CompoundBigNumbers", [ - "big","big_nums","another", - ]); + this.CompoundBigNumbers = _getClass(this.tb, "CompoundBigNumbers"); - this.ContactInfo = this.tb.classViewer("ContactInfo", [ - "primary","secondary", - ]); + this.ContactInfo = _getClass(this.tb, "ContactInfo"); - this.CustomStory = this.tb.classViewer("CustomStory", [ - "title","characters","content", - ]); + this.CustomStory = _getClass(this.tb, "CustomStory"); - this.CustomTaskResult = this.tb.classViewer("CustomTaskResult", [ - "bookOrder","flightConfirmation","groceryReceipt", - ]); + this.CustomTaskResult = _getClass(this.tb, "CustomTaskResult"); - this.Document1559 = this.tb.classViewer("Document1559", [ - "client_details","notes", - ]); + this.Document1559 = _getClass(this.tb, "Document1559"); - this.DummyOutput = this.tb.classBuilder("DummyOutput", [ - "nonce","nonce2", - ]); + this.DummyOutput = _getClass(this.tb, "DummyOutput"); - this.DynInputOutput = this.tb.classBuilder("DynInputOutput", [ - "testKey", - ]); + this.DynInputOutput = _getClass(this.tb, "DynInputOutput"); - this.DynamicClassOne = this.tb.classBuilder("DynamicClassOne", [ - - ]); + this.DynamicClassOne = _getClass(this.tb, "DynamicClassOne"); - this.DynamicClassTwo = this.tb.classBuilder("DynamicClassTwo", [ - "hi","some_class","status", - ]); + this.DynamicClassTwo = _getClass(this.tb, "DynamicClassTwo"); - this.DynamicOutput = this.tb.classBuilder("DynamicOutput", [ - - ]); + this.DynamicOutput = _getClass(this.tb, "DynamicOutput"); - this.DynamicSchema = this.tb.classBuilder("DynamicSchema", [ - - ]); + this.DynamicSchema = _getClass(this.tb, "DynamicSchema"); - this.Earthling = this.tb.classViewer("Earthling", [ - "age", - ]); + this.Earthling = _getClass(this.tb, "Earthling"); - this.Education = this.tb.classViewer("Education", [ - "institution","location","degree","major","graduation_date", - ]); + this.Education = _getClass(this.tb, "Education"); - this.Email = this.tb.classViewer("Email", [ - "subject","body","from_address", - ]); + this.Email = _getClass(this.tb, "Email"); - this.EmailAddress = this.tb.classViewer("EmailAddress", [ - "value", - ]); + this.EmailAddress = _getClass(this.tb, "EmailAddress"); - this.Event = this.tb.classViewer("Event", [ - "title","date","location","description", - ]); + this.Event = _getClass(this.tb, "Event"); - this.FakeImage = this.tb.classViewer("FakeImage", [ - "url", - ]); + this.FakeImage = _getClass(this.tb, "FakeImage"); - this.FlightConfirmation = this.tb.classViewer("FlightConfirmation", [ - "confirmationNumber","flightNumber","departureTime","arrivalTime","seatNumber", - ]); + this.FlightConfirmation = _getClass(this.tb, "FlightConfirmation"); - this.FooAny = this.tb.classViewer("FooAny", [ - "planetary_age","certainty","species", - ]); + this.FooAny = _getClass(this.tb, "FooAny"); - this.Forest = this.tb.classViewer("Forest", [ - "trees", - ]); + this.Forest = _getClass(this.tb, "Forest"); - this.FormatterTest0 = this.tb.classViewer("FormatterTest0", [ - "lorem","ipsum", - ]); + this.FormatterTest0 = _getClass(this.tb, "FormatterTest0"); - this.FormatterTest1 = this.tb.classViewer("FormatterTest1", [ - "lorem","ipsum", - ]); + this.FormatterTest1 = _getClass(this.tb, "FormatterTest1"); - this.FormatterTest2 = this.tb.classViewer("FormatterTest2", [ - "lorem","ipsum", - ]); + this.FormatterTest2 = _getClass(this.tb, "FormatterTest2"); - this.FormatterTest3 = this.tb.classViewer("FormatterTest3", [ - "lorem","ipsum", - ]); + this.FormatterTest3 = _getClass(this.tb, "FormatterTest3"); - this.GroceryReceipt = this.tb.classViewer("GroceryReceipt", [ - "receiptId","storeName","items","totalAmount", - ]); + this.GroceryReceipt = _getClass(this.tb, "GroceryReceipt"); - this.Haiku = this.tb.classViewer("Haiku", [ - "line1","line2","line3", - ]); + this.Haiku = _getClass(this.tb, "Haiku"); - this.InnerClass = this.tb.classViewer("InnerClass", [ - "prop1","prop2","inner", - ]); + this.InnerClass = _getClass(this.tb, "InnerClass"); - this.InnerClass2 = this.tb.classViewer("InnerClass2", [ - "prop2","prop3", - ]); + this.InnerClass2 = _getClass(this.tb, "InnerClass2"); - this.InputClass = this.tb.classViewer("InputClass", [ - "key","key2", - ]); + this.InputClass = _getClass(this.tb, "InputClass"); - this.InputClassNested = this.tb.classViewer("InputClassNested", [ - "key","nested", - ]); + this.InputClassNested = _getClass(this.tb, "InputClassNested"); - this.LinkedList = this.tb.classViewer("LinkedList", [ - "head","len", - ]); + this.LinkedList = _getClass(this.tb, "LinkedList"); - this.LinkedListAliasNode = this.tb.classViewer("LinkedListAliasNode", [ - "value","next", - ]); + this.LinkedListAliasNode = _getClass(this.tb, "LinkedListAliasNode"); - this.LiteralClassHello = this.tb.classViewer("LiteralClassHello", [ - "prop", - ]); + this.LiteralClassHello = _getClass(this.tb, "LiteralClassHello"); - this.LiteralClassOne = this.tb.classViewer("LiteralClassOne", [ - "prop", - ]); + this.LiteralClassOne = _getClass(this.tb, "LiteralClassOne"); - this.LiteralClassTwo = this.tb.classViewer("LiteralClassTwo", [ - "prop", - ]); + this.LiteralClassTwo = _getClass(this.tb, "LiteralClassTwo"); - this.MaintainFieldOrder = this.tb.classViewer("MaintainFieldOrder", [ - "a","b","c", - ]); + this.MaintainFieldOrder = _getClass(this.tb, "MaintainFieldOrder"); - this.MalformedConstraints = this.tb.classViewer("MalformedConstraints", [ - "foo", - ]); + this.MalformedConstraints = _getClass(this.tb, "MalformedConstraints"); - this.MalformedConstraints2 = this.tb.classViewer("MalformedConstraints2", [ - "foo", - ]); + this.MalformedConstraints2 = _getClass(this.tb, "MalformedConstraints2"); - this.Martian = this.tb.classViewer("Martian", [ - "age", - ]); + this.Martian = _getClass(this.tb, "Martian"); - this.MemoryObject = this.tb.classViewer("MemoryObject", [ - "id","name","description", - ]); + this.MemoryObject = _getClass(this.tb, "MemoryObject"); - this.MergeAttrs = this.tb.classViewer("MergeAttrs", [ - "amount", - ]); + this.MergeAttrs = _getClass(this.tb, "MergeAttrs"); - this.NamedArgsSingleClass = this.tb.classViewer("NamedArgsSingleClass", [ - "key","key_two","key_three", - ]); + this.NamedArgsSingleClass = _getClass(this.tb, "NamedArgsSingleClass"); - this.Nested = this.tb.classViewer("Nested", [ - "prop3","prop4","prop20", - ]); + this.Nested = _getClass(this.tb, "Nested"); - this.Nested2 = this.tb.classViewer("Nested2", [ - "prop11","prop12", - ]); + this.Nested2 = _getClass(this.tb, "Nested2"); - this.NestedBlockConstraint = this.tb.classViewer("NestedBlockConstraint", [ - "nbc", - ]); + this.NestedBlockConstraint = _getClass(this.tb, "NestedBlockConstraint"); - this.NestedBlockConstraintForParam = this.tb.classViewer("NestedBlockConstraintForParam", [ - "nbcfp", - ]); + this.NestedBlockConstraintForParam = _getClass(this.tb, "NestedBlockConstraintForParam"); - this.Node = this.tb.classViewer("Node", [ - "data","next", - ]); + this.Node = _getClass(this.tb, "Node"); - this.NodeWithAliasIndirection = this.tb.classViewer("NodeWithAliasIndirection", [ - "value","next", - ]); + this.NodeWithAliasIndirection = _getClass(this.tb, "NodeWithAliasIndirection"); - this.Note1599 = this.tb.classViewer("Note1599", [ - "note_title","note_description","note_amount", - ]); + this.Note1599 = _getClass(this.tb, "Note1599"); - this.OptionalListAndMap = this.tb.classViewer("OptionalListAndMap", [ - "p","q", - ]); + this.OptionalListAndMap = _getClass(this.tb, "OptionalListAndMap"); - this.OptionalTest_Prop1 = this.tb.classViewer("OptionalTest_Prop1", [ - "omega_a","omega_b", - ]); + this.OptionalTest_Prop1 = _getClass(this.tb, "OptionalTest_Prop1"); - this.OptionalTest_ReturnType = this.tb.classViewer("OptionalTest_ReturnType", [ - "omega_1","omega_2","omega_3", - ]); + this.OptionalTest_ReturnType = _getClass(this.tb, "OptionalTest_ReturnType"); - this.OrderInfo = this.tb.classViewer("OrderInfo", [ - "order_status","tracking_number","estimated_arrival_date", - ]); + this.OrderInfo = _getClass(this.tb, "OrderInfo"); - this.OriginalA = this.tb.classViewer("OriginalA", [ - "value", - ]); + this.OriginalA = _getClass(this.tb, "OriginalA"); - this.OriginalB = this.tb.classBuilder("OriginalB", [ - "value", - ]); + this.OriginalB = _getClass(this.tb, "OriginalB"); - this.Person = this.tb.classBuilder("Person", [ - "name","hair_color", - ]); + this.Person = _getClass(this.tb, "Person"); - this.PhoneNumber = this.tb.classViewer("PhoneNumber", [ - "value", - ]); + this.PhoneNumber = _getClass(this.tb, "PhoneNumber"); - this.Quantity = this.tb.classViewer("Quantity", [ - "amount","unit", - ]); + this.Quantity = _getClass(this.tb, "Quantity"); - this.RaysData = this.tb.classViewer("RaysData", [ - "dataType","value", - ]); + this.RaysData = _getClass(this.tb, "RaysData"); - this.ReceiptInfo = this.tb.classViewer("ReceiptInfo", [ - "items","total_cost","venue", - ]); + this.ReceiptInfo = _getClass(this.tb, "ReceiptInfo"); - this.ReceiptItem = this.tb.classViewer("ReceiptItem", [ - "name","description","quantity","price", - ]); + this.ReceiptItem = _getClass(this.tb, "ReceiptItem"); - this.Recipe = this.tb.classViewer("Recipe", [ - "ingredients","recipe_type", - ]); + this.Recipe = _getClass(this.tb, "Recipe"); - this.RecursiveAliasDependency = this.tb.classViewer("RecursiveAliasDependency", [ - "value", - ]); + this.RecursiveAliasDependency = _getClass(this.tb, "RecursiveAliasDependency"); - this.RenderEnumInput = this.tb.classBuilder("RenderEnumInput", [ - "testKey", - ]); + this.RenderEnumInput = _getClass(this.tb, "RenderEnumInput"); - this.RenderTestClass = this.tb.classBuilder("RenderTestClass", [ - "name","status", - ]); + this.RenderTestClass = _getClass(this.tb, "RenderTestClass"); - this.Resume = this.tb.classViewer("Resume", [ - "name","email","phone","experience","education","skills", - ]); + this.Resume = _getClass(this.tb, "Resume"); - this.Schema = this.tb.classViewer("Schema", [ - "prop1","prop2","prop5","prop6","nested_attrs","parens","other_group", - ]); + this.Schema = _getClass(this.tb, "Schema"); - this.SearchParams = this.tb.classViewer("SearchParams", [ - "dateRange","location","jobTitle","company","description","tags", - ]); + this.SearchParams = _getClass(this.tb, "SearchParams"); - this.SemanticContainer = this.tb.classViewer("SemanticContainer", [ - "sixteen_digit_number","string_with_twenty_words","class_1","class_2","class_done_needed","class_needed","three_small_things","final_string", - ]); + this.SemanticContainer = _getClass(this.tb, "SemanticContainer"); - this.SimpleTag = this.tb.classViewer("SimpleTag", [ - "field", - ]); + this.SimpleTag = _getClass(this.tb, "SimpleTag"); - this.SmallThing = this.tb.classViewer("SmallThing", [ - "i_16_digits","i_8_digits", - ]); + this.SmallThing = _getClass(this.tb, "SmallThing"); - this.SomeClassNestedDynamic = this.tb.classBuilder("SomeClassNestedDynamic", [ - "hi", - ]); + this.SomeClassNestedDynamic = _getClass(this.tb, "SomeClassNestedDynamic"); - this.StringToClassEntry = this.tb.classViewer("StringToClassEntry", [ - "word", - ]); + this.StringToClassEntry = _getClass(this.tb, "StringToClassEntry"); - this.TestClassAlias = this.tb.classViewer("TestClassAlias", [ - "key","key2","key3","key4","key5", - ]); + this.TestClassAlias = _getClass(this.tb, "TestClassAlias"); - this.TestClassNested = this.tb.classViewer("TestClassNested", [ - "prop1","prop2", - ]); + this.TestClassNested = _getClass(this.tb, "TestClassNested"); - this.TestClassWithEnum = this.tb.classViewer("TestClassWithEnum", [ - "prop1","prop2", - ]); + this.TestClassWithEnum = _getClass(this.tb, "TestClassWithEnum"); - this.TestMemoryOutput = this.tb.classViewer("TestMemoryOutput", [ - "items","more_items", - ]); + this.TestMemoryOutput = _getClass(this.tb, "TestMemoryOutput"); - this.TestOutputClass = this.tb.classViewer("TestOutputClass", [ - "prop1","prop2", - ]); + this.TestOutputClass = _getClass(this.tb, "TestOutputClass"); - this.Tree = this.tb.classViewer("Tree", [ - "data","children", - ]); + this.Tree = _getClass(this.tb, "Tree"); - this.TwoStoriesOneTitle = this.tb.classViewer("TwoStoriesOneTitle", [ - "title","story_a","story_b", - ]); + this.TwoStoriesOneTitle = _getClass(this.tb, "TwoStoriesOneTitle"); - this.TwoStoriesOneTitleCheck = this.tb.classViewer("TwoStoriesOneTitleCheck", [ - "title","story_a","story_b", - ]); + this.TwoStoriesOneTitleCheck = _getClass(this.tb, "TwoStoriesOneTitleCheck"); - this.UnionTest_ReturnType = this.tb.classViewer("UnionTest_ReturnType", [ - "prop1","prop2","prop3", - ]); + this.UnionTest_ReturnType = _getClass(this.tb, "UnionTest_ReturnType"); - this.UniverseQuestion = this.tb.classViewer("UniverseQuestion", [ - "question","answer", - ]); + this.UniverseQuestion = _getClass(this.tb, "UniverseQuestion"); - this.UniverseQuestionInput = this.tb.classViewer("UniverseQuestionInput", [ - "question", - ]); + this.UniverseQuestionInput = _getClass(this.tb, "UniverseQuestionInput"); - this.WithReasoning = this.tb.classViewer("WithReasoning", [ - "value","reasoning", - ]); + this.WithReasoning = _getClass(this.tb, "WithReasoning"); - this.AliasedEnum = this.tb.enumViewer("AliasedEnum", [ - "KEY_ONE","KEY_TWO", - ]); + this.AliasedEnum = _getEnum(this.tb, "AliasedEnum"); - this.Category = this.tb.enumViewer("Category", [ - "Refund","CancelOrder","TechnicalSupport","AccountIssue","Question", - ]); + this.Category = _getEnum(this.tb, "Category"); - this.Category2 = this.tb.enumViewer("Category2", [ - "Refund","CancelOrder","TechnicalSupport","AccountIssue","Question", - ]); + this.Category2 = _getEnum(this.tb, "Category2"); - this.Category3 = this.tb.enumViewer("Category3", [ - "Refund","CancelOrder","TechnicalSupport","AccountIssue","Question", - ]); + this.Category3 = _getEnum(this.tb, "Category3"); - this.Color = this.tb.enumBuilder("Color", [ - "RED","BLUE","GREEN","YELLOW","BLACK","WHITE", - ]); + this.Color = _getEnum(this.tb, "Color"); - this.DataType = this.tb.enumViewer("DataType", [ - "Resume","Event", - ]); + this.DataType = _getEnum(this.tb, "DataType"); - this.DynEnumOne = this.tb.enumBuilder("DynEnumOne", [ - - ]); + this.DynEnumOne = _getEnum(this.tb, "DynEnumOne"); - this.DynEnumThree = this.tb.enumBuilder("DynEnumThree", [ - "TRICYCLE","TRIANGLE", - ]); + this.DynEnumThree = _getEnum(this.tb, "DynEnumThree"); - this.DynEnumTwo = this.tb.enumBuilder("DynEnumTwo", [ - - ]); + this.DynEnumTwo = _getEnum(this.tb, "DynEnumTwo"); - this.EnumInClass = this.tb.enumViewer("EnumInClass", [ - "ONE","TWO", - ]); + this.EnumInClass = _getEnum(this.tb, "EnumInClass"); - this.EnumOutput = this.tb.enumViewer("EnumOutput", [ - "ONE","TWO","THREE", - ]); + this.EnumOutput = _getEnum(this.tb, "EnumOutput"); - this.Hobby = this.tb.enumBuilder("Hobby", [ - "SPORTS","MUSIC","READING", - ]); + this.Hobby = _getEnum(this.tb, "Hobby"); - this.MapKey = this.tb.enumViewer("MapKey", [ - "A","B","C", - ]); + this.MapKey = _getEnum(this.tb, "MapKey"); - this.NamedArgsSingleEnum = this.tb.enumViewer("NamedArgsSingleEnum", [ - "ONE","TWO", - ]); + this.NamedArgsSingleEnum = _getEnum(this.tb, "NamedArgsSingleEnum"); - this.NamedArgsSingleEnumList = this.tb.enumViewer("NamedArgsSingleEnumList", [ - "ONE","TWO", - ]); + this.NamedArgsSingleEnumList = _getEnum(this.tb, "NamedArgsSingleEnumList"); - this.OptionalTest_CategoryType = this.tb.enumViewer("OptionalTest_CategoryType", [ - "Aleph","Beta","Gamma", - ]); + this.OptionalTest_CategoryType = _getEnum(this.tb, "OptionalTest_CategoryType"); - this.OrderStatus = this.tb.enumViewer("OrderStatus", [ - "ORDERED","SHIPPED","DELIVERED","CANCELLED", - ]); + this.OrderStatus = _getEnum(this.tb, "OrderStatus"); - this.RenderStatusEnum = this.tb.enumBuilder("RenderStatusEnum", [ - "ACTIVE","INACTIVE", - ]); + this.RenderStatusEnum = _getEnum(this.tb, "RenderStatusEnum"); - this.RenderTestEnum = this.tb.enumBuilder("RenderTestEnum", [ - "BIKE","SCOOTER", - ]); + this.RenderTestEnum = _getEnum(this.tb, "RenderTestEnum"); - this.Tag = this.tb.enumViewer("Tag", [ - "Security","AI","Blockchain", - ]); + this.Tag = _getEnum(this.tb, "Tag"); - this.TestEnum = this.tb.enumViewer("TestEnum", [ - "A","B","C","D","E","F","G", - ]); + this.TestEnum = _getEnum(this.tb, "TestEnum"); } reset(): void { this.tb.reset(); - // TODO: This should happen in Rust. Problem is, when we construct the - // typebuilder we instantiate class builders once and it seems to make - // a JS copy, bypassing the Rust side? In Python however, every time we - // access a class builder with @property, we get a new instance that - // wraps over the Rust type builder, so we only need to call tb.reset(). - // In JS it's not possible unless we refactor the way class builders are - // accessed. - this.DummyOutput.reset(); this.DynInputOutput.reset(); this.DynamicClassOne.reset(); this.DynamicClassTwo.reset(); this.DynamicOutput.reset(); this.DynamicSchema.reset(); this.OriginalB.reset(); this.Person.reset(); this.RenderEnumInput.reset(); this.RenderTestClass.reset(); this.SomeClassNestedDynamic.reset(); } __tb() { @@ -835,11 +841,11 @@ export default class TypeBuilder { return this.tb.union(types) } - addClass(name: Name): ClassBuilder { + addClass(name: string): ClassBuilder { return this.tb.addClass(name); } - addEnum(name: Name): EnumBuilder { + addEnum(name: string): EnumBuilder { return this.tb.addEnum(name); } diff --git a/integ-tests/typescript-esm/baml_client/type_builder.ts b/integ-tests/typescript-esm/baml_client/type_builder.ts index bb8a576d26..87c51a97ff 100644 --- a/integ-tests/typescript-esm/baml_client/type_builder.ts +++ b/integ-tests/typescript-esm/baml_client/type_builder.ts @@ -19,772 +19,778 @@ $ pnpm add @boundaryml/baml // biome-ignore format: autogenerated code import { FieldType } from '@boundaryml/baml/native' -import { TypeBuilder as _TypeBuilder, EnumBuilder, EnumViewer, ClassBuilder, ClassViewer } from '@boundaryml/baml/type_builder' +import { TypeBuilder as _TypeBuilder, EnumBuilder, ClassBuilder } from '@boundaryml/baml/type_builder' import { DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME } from "./globals.js" export { FieldType, EnumBuilder, ClassBuilder } +type ClassProperties = { + + "AnotherObject": ["id", "thingy2", "thingy3", ], + + "BigNumbers": ["a", "b", ], + + "BinaryNode": ["data", "left", "right", ], + + "Blah": ["prop4", ], + + "BlockConstraint": ["foo", "bar", ], + + "BlockConstraintForParam": ["bcfp", "bcfp2", ], + + "BookOrder": ["orderId", "title", "quantity", "price", ], + + "ClassForNullLiteral": ["a", ], + + "ClassOptionalOutput": ["prop1", "prop2", ], + + "ClassOptionalOutput2": ["prop1", "prop2", "prop3", ], + + "ClassToRecAlias": ["list", ], + + "ClassWithBlockDone": ["i_16_digits", "s_20_words", ], + + "ClassWithImage": ["myImage", "param2", "fake_image", ], + + "ClassWithoutDone": ["i_16_digits", "s_20_words", ], + + "ClientDetails1559": ["client_name", "client_address", "client_postal_code", "client_city", "client_country", "client_phone", "client_email", ], + + "ComplexMemoryObject": ["id", "name", "description", "metadata", ], + + "CompoundBigNumbers": ["big", "big_nums", "another", ], + + "ContactInfo": ["primary", "secondary", ], + + "CustomStory": ["title", "characters", "content", ], + + "CustomTaskResult": ["bookOrder", "flightConfirmation", "groceryReceipt", ], + + "Document1559": ["client_details", "notes", ], + + "DummyOutput": ["nonce", "nonce2", ], + + "DynInputOutput": ["testKey", ], + + "DynamicClassOne": [], + + "DynamicClassTwo": ["hi", "some_class", "status", ], + + "DynamicOutput": [], + + "DynamicSchema": [], + + "Earthling": ["age", ], + + "Education": ["institution", "location", "degree", "major", "graduation_date", ], + + "Email": ["subject", "body", "from_address", ], + + "EmailAddress": ["value", ], + + "Event": ["title", "date", "location", "description", ], + + "FakeImage": ["url", ], + + "FlightConfirmation": ["confirmationNumber", "flightNumber", "departureTime", "arrivalTime", "seatNumber", ], + + "FooAny": ["planetary_age", "certainty", "species", ], + + "Forest": ["trees", ], + + "FormatterTest0": ["lorem", "ipsum", ], + + "FormatterTest1": ["lorem", "ipsum", ], + + "FormatterTest2": ["lorem", "ipsum", ], + + "FormatterTest3": ["lorem", "ipsum", ], + + "GroceryReceipt": ["receiptId", "storeName", "items", "totalAmount", ], + + "Haiku": ["line1", "line2", "line3", ], + + "InnerClass": ["prop1", "prop2", "inner", ], + + "InnerClass2": ["prop2", "prop3", ], + + "InputClass": ["key", "key2", ], + + "InputClassNested": ["key", "nested", ], + + "LinkedList": ["head", "len", ], + + "LinkedListAliasNode": ["value", "next", ], + + "LiteralClassHello": ["prop", ], + + "LiteralClassOne": ["prop", ], + + "LiteralClassTwo": ["prop", ], + + "MaintainFieldOrder": ["a", "b", "c", ], + + "MalformedConstraints": ["foo", ], + + "MalformedConstraints2": ["foo", ], + + "Martian": ["age", ], + + "MemoryObject": ["id", "name", "description", ], + + "MergeAttrs": ["amount", ], + + "NamedArgsSingleClass": ["key", "key_two", "key_three", ], + + "Nested": ["prop3", "prop4", "prop20", ], + + "Nested2": ["prop11", "prop12", ], + + "NestedBlockConstraint": ["nbc", ], + + "NestedBlockConstraintForParam": ["nbcfp", ], + + "Node": ["data", "next", ], + + "NodeWithAliasIndirection": ["value", "next", ], + + "Note1599": ["note_title", "note_description", "note_amount", ], + + "OptionalListAndMap": ["p", "q", ], + + "OptionalTest_Prop1": ["omega_a", "omega_b", ], + + "OptionalTest_ReturnType": ["omega_1", "omega_2", "omega_3", ], + + "OrderInfo": ["order_status", "tracking_number", "estimated_arrival_date", ], + + "OriginalA": ["value", ], + + "OriginalB": ["value", ], + + "Person": ["name", "hair_color", ], + + "PhoneNumber": ["value", ], + + "Quantity": ["amount", "unit", ], + + "RaysData": ["dataType", "value", ], + + "ReceiptInfo": ["items", "total_cost", "venue", ], + + "ReceiptItem": ["name", "description", "quantity", "price", ], + + "Recipe": ["ingredients", "recipe_type", ], + + "RecursiveAliasDependency": ["value", ], + + "RenderEnumInput": ["testKey", ], + + "RenderTestClass": ["name", "status", ], + + "Resume": ["name", "email", "phone", "experience", "education", "skills", ], + + "Schema": ["prop1", "prop2", "prop5", "prop6", "nested_attrs", "parens", "other_group", ], + + "SearchParams": ["dateRange", "location", "jobTitle", "company", "description", "tags", ], + + "SemanticContainer": ["sixteen_digit_number", "string_with_twenty_words", "class_1", "class_2", "class_done_needed", "class_needed", "three_small_things", "final_string", ], + + "SimpleTag": ["field", ], + + "SmallThing": ["i_16_digits", "i_8_digits", ], + + "SomeClassNestedDynamic": ["hi", ], + + "StringToClassEntry": ["word", ], + + "TestClassAlias": ["key", "key2", "key3", "key4", "key5", ], + + "TestClassNested": ["prop1", "prop2", ], + + "TestClassWithEnum": ["prop1", "prop2", ], + + "TestMemoryOutput": ["items", "more_items", ], + + "TestOutputClass": ["prop1", "prop2", ], + + "Tree": ["data", "children", ], + + "TwoStoriesOneTitle": ["title", "story_a", "story_b", ], + + "TwoStoriesOneTitleCheck": ["title", "story_a", "story_b", ], + + "UnionTest_ReturnType": ["prop1", "prop2", "prop3", ], + + "UniverseQuestion": ["question", "answer", ], + + "UniverseQuestionInput": ["question", ], + + "WithReasoning": ["value", "reasoning", ], + +} +type EnumValues = { + + "AliasedEnum": ["KEY_ONE", "KEY_TWO", ], + + "Category": ["Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ], + + "Category2": ["Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ], + + "Category3": ["Refund", "CancelOrder", "TechnicalSupport", "AccountIssue", "Question", ], + + "Color": ["RED", "BLUE", "GREEN", "YELLOW", "BLACK", "WHITE", ], + + "DataType": ["Resume", "Event", ], + + "DynEnumOne": [], + + "DynEnumThree": ["TRICYCLE", "TRIANGLE", ], + + "DynEnumTwo": [], + + "EnumInClass": ["ONE", "TWO", ], + + "EnumOutput": ["ONE", "TWO", "THREE", ], + + "Hobby": ["SPORTS", "MUSIC", "READING", ], + + "MapKey": ["A", "B", "C", ], + + "NamedArgsSingleEnum": ["ONE", "TWO", ], + + "NamedArgsSingleEnumList": ["ONE", "TWO", ], + + "OptionalTest_CategoryType": ["Aleph", "Beta", "Gamma", ], + + "OrderStatus": ["ORDERED", "SHIPPED", "DELIVERED", "CANCELLED", ], + + "RenderStatusEnum": ["ACTIVE", "INACTIVE", ], + + "RenderTestEnum": ["BIKE", "SCOOTER", ], + + "Tag": ["Security", "AI", "Blockchain", ], + + "TestEnum": ["A", "B", "C", "D", "E", "F", "G", ], + +} +type ClassNames = keyof ClassProperties; +type EnumNames = keyof EnumValues; + +type _ClassBuilder = ClassBuilder; +type _EnumBuilder = EnumBuilder; + +function _getEnum(tb: _TypeBuilder, name: Name): _EnumBuilder { + return tb.getEnum(name); +} + +function _getClass(tb: _TypeBuilder, name: Name): _ClassBuilder { + return tb.getClass(name); +} + export default class TypeBuilder { private tb: _TypeBuilder; - AnotherObject: ClassViewer<'AnotherObject', "id" | "thingy2" | "thingy3">; + AnotherObject: _ClassBuilder<'AnotherObject', false>; - BigNumbers: ClassViewer<'BigNumbers', "a" | "b">; + BigNumbers: _ClassBuilder<'BigNumbers', false>; - BinaryNode: ClassViewer<'BinaryNode', "data" | "left" | "right">; + BinaryNode: _ClassBuilder<'BinaryNode', false>; - Blah: ClassViewer<'Blah', "prop4">; + Blah: _ClassBuilder<'Blah', false>; - BlockConstraint: ClassViewer<'BlockConstraint', "foo" | "bar">; + BlockConstraint: _ClassBuilder<'BlockConstraint', false>; - BlockConstraintForParam: ClassViewer<'BlockConstraintForParam', "bcfp" | "bcfp2">; + BlockConstraintForParam: _ClassBuilder<'BlockConstraintForParam', false>; - BookOrder: ClassViewer<'BookOrder', "orderId" | "title" | "quantity" | "price">; + BookOrder: _ClassBuilder<'BookOrder', false>; - ClassForNullLiteral: ClassViewer<'ClassForNullLiteral', "a">; + ClassForNullLiteral: _ClassBuilder<'ClassForNullLiteral', false>; - ClassOptionalOutput: ClassViewer<'ClassOptionalOutput', "prop1" | "prop2">; + ClassOptionalOutput: _ClassBuilder<'ClassOptionalOutput', false>; - ClassOptionalOutput2: ClassViewer<'ClassOptionalOutput2', "prop1" | "prop2" | "prop3">; + ClassOptionalOutput2: _ClassBuilder<'ClassOptionalOutput2', false>; - ClassToRecAlias: ClassViewer<'ClassToRecAlias', "list">; + ClassToRecAlias: _ClassBuilder<'ClassToRecAlias', false>; - ClassWithBlockDone: ClassViewer<'ClassWithBlockDone', "i_16_digits" | "s_20_words">; + ClassWithBlockDone: _ClassBuilder<'ClassWithBlockDone', false>; - ClassWithImage: ClassViewer<'ClassWithImage', "myImage" | "param2" | "fake_image">; + ClassWithImage: _ClassBuilder<'ClassWithImage', false>; - ClassWithoutDone: ClassViewer<'ClassWithoutDone', "i_16_digits" | "s_20_words">; + ClassWithoutDone: _ClassBuilder<'ClassWithoutDone', false>; - ClientDetails1559: ClassViewer<'ClientDetails1559', "client_name" | "client_address" | "client_postal_code" | "client_city" | "client_country" | "client_phone" | "client_email">; + ClientDetails1559: _ClassBuilder<'ClientDetails1559', false>; - ComplexMemoryObject: ClassViewer<'ComplexMemoryObject', "id" | "name" | "description" | "metadata">; + ComplexMemoryObject: _ClassBuilder<'ComplexMemoryObject', false>; - CompoundBigNumbers: ClassViewer<'CompoundBigNumbers', "big" | "big_nums" | "another">; + CompoundBigNumbers: _ClassBuilder<'CompoundBigNumbers', false>; - ContactInfo: ClassViewer<'ContactInfo', "primary" | "secondary">; + ContactInfo: _ClassBuilder<'ContactInfo', false>; - CustomStory: ClassViewer<'CustomStory', "title" | "characters" | "content">; + CustomStory: _ClassBuilder<'CustomStory', false>; - CustomTaskResult: ClassViewer<'CustomTaskResult', "bookOrder" | "flightConfirmation" | "groceryReceipt">; + CustomTaskResult: _ClassBuilder<'CustomTaskResult', false>; - Document1559: ClassViewer<'Document1559', "client_details" | "notes">; + Document1559: _ClassBuilder<'Document1559', false>; - DummyOutput: ClassBuilder<'DummyOutput', "nonce" | "nonce2">; + DummyOutput: _ClassBuilder<'DummyOutput', true>; - DynInputOutput: ClassBuilder<'DynInputOutput', "testKey">; + DynInputOutput: _ClassBuilder<'DynInputOutput', true>; - DynamicClassOne: ClassBuilder<'DynamicClassOne'>; + DynamicClassOne: _ClassBuilder<'DynamicClassOne', true>; - DynamicClassTwo: ClassBuilder<'DynamicClassTwo', "hi" | "some_class" | "status">; + DynamicClassTwo: _ClassBuilder<'DynamicClassTwo', true>; - DynamicOutput: ClassBuilder<'DynamicOutput'>; + DynamicOutput: _ClassBuilder<'DynamicOutput', true>; - DynamicSchema: ClassBuilder<'DynamicSchema'>; + DynamicSchema: _ClassBuilder<'DynamicSchema', true>; - Earthling: ClassViewer<'Earthling', "age">; + Earthling: _ClassBuilder<'Earthling', false>; - Education: ClassViewer<'Education', "institution" | "location" | "degree" | "major" | "graduation_date">; + Education: _ClassBuilder<'Education', false>; - Email: ClassViewer<'Email', "subject" | "body" | "from_address">; + Email: _ClassBuilder<'Email', false>; - EmailAddress: ClassViewer<'EmailAddress', "value">; + EmailAddress: _ClassBuilder<'EmailAddress', false>; - Event: ClassViewer<'Event', "title" | "date" | "location" | "description">; + Event: _ClassBuilder<'Event', false>; - FakeImage: ClassViewer<'FakeImage', "url">; + FakeImage: _ClassBuilder<'FakeImage', false>; - FlightConfirmation: ClassViewer<'FlightConfirmation', "confirmationNumber" | "flightNumber" | "departureTime" | "arrivalTime" | "seatNumber">; + FlightConfirmation: _ClassBuilder<'FlightConfirmation', false>; - FooAny: ClassViewer<'FooAny', "planetary_age" | "certainty" | "species">; + FooAny: _ClassBuilder<'FooAny', false>; - Forest: ClassViewer<'Forest', "trees">; + Forest: _ClassBuilder<'Forest', false>; - FormatterTest0: ClassViewer<'FormatterTest0', "lorem" | "ipsum">; + FormatterTest0: _ClassBuilder<'FormatterTest0', false>; - FormatterTest1: ClassViewer<'FormatterTest1', "lorem" | "ipsum">; + FormatterTest1: _ClassBuilder<'FormatterTest1', false>; - FormatterTest2: ClassViewer<'FormatterTest2', "lorem" | "ipsum">; + FormatterTest2: _ClassBuilder<'FormatterTest2', false>; - FormatterTest3: ClassViewer<'FormatterTest3', "lorem" | "ipsum">; + FormatterTest3: _ClassBuilder<'FormatterTest3', false>; - GroceryReceipt: ClassViewer<'GroceryReceipt', "receiptId" | "storeName" | "items" | "totalAmount">; + GroceryReceipt: _ClassBuilder<'GroceryReceipt', false>; - Haiku: ClassViewer<'Haiku', "line1" | "line2" | "line3">; + Haiku: _ClassBuilder<'Haiku', false>; - InnerClass: ClassViewer<'InnerClass', "prop1" | "prop2" | "inner">; + InnerClass: _ClassBuilder<'InnerClass', false>; - InnerClass2: ClassViewer<'InnerClass2', "prop2" | "prop3">; + InnerClass2: _ClassBuilder<'InnerClass2', false>; - InputClass: ClassViewer<'InputClass', "key" | "key2">; + InputClass: _ClassBuilder<'InputClass', false>; - InputClassNested: ClassViewer<'InputClassNested', "key" | "nested">; + InputClassNested: _ClassBuilder<'InputClassNested', false>; - LinkedList: ClassViewer<'LinkedList', "head" | "len">; + LinkedList: _ClassBuilder<'LinkedList', false>; - LinkedListAliasNode: ClassViewer<'LinkedListAliasNode', "value" | "next">; + LinkedListAliasNode: _ClassBuilder<'LinkedListAliasNode', false>; - LiteralClassHello: ClassViewer<'LiteralClassHello', "prop">; + LiteralClassHello: _ClassBuilder<'LiteralClassHello', false>; - LiteralClassOne: ClassViewer<'LiteralClassOne', "prop">; + LiteralClassOne: _ClassBuilder<'LiteralClassOne', false>; - LiteralClassTwo: ClassViewer<'LiteralClassTwo', "prop">; + LiteralClassTwo: _ClassBuilder<'LiteralClassTwo', false>; - MaintainFieldOrder: ClassViewer<'MaintainFieldOrder', "a" | "b" | "c">; + MaintainFieldOrder: _ClassBuilder<'MaintainFieldOrder', false>; - MalformedConstraints: ClassViewer<'MalformedConstraints', "foo">; + MalformedConstraints: _ClassBuilder<'MalformedConstraints', false>; - MalformedConstraints2: ClassViewer<'MalformedConstraints2', "foo">; + MalformedConstraints2: _ClassBuilder<'MalformedConstraints2', false>; - Martian: ClassViewer<'Martian', "age">; + Martian: _ClassBuilder<'Martian', false>; - MemoryObject: ClassViewer<'MemoryObject', "id" | "name" | "description">; + MemoryObject: _ClassBuilder<'MemoryObject', false>; - MergeAttrs: ClassViewer<'MergeAttrs', "amount">; + MergeAttrs: _ClassBuilder<'MergeAttrs', false>; - NamedArgsSingleClass: ClassViewer<'NamedArgsSingleClass', "key" | "key_two" | "key_three">; + NamedArgsSingleClass: _ClassBuilder<'NamedArgsSingleClass', false>; - Nested: ClassViewer<'Nested', "prop3" | "prop4" | "prop20">; + Nested: _ClassBuilder<'Nested', false>; - Nested2: ClassViewer<'Nested2', "prop11" | "prop12">; + Nested2: _ClassBuilder<'Nested2', false>; - NestedBlockConstraint: ClassViewer<'NestedBlockConstraint', "nbc">; + NestedBlockConstraint: _ClassBuilder<'NestedBlockConstraint', false>; - NestedBlockConstraintForParam: ClassViewer<'NestedBlockConstraintForParam', "nbcfp">; + NestedBlockConstraintForParam: _ClassBuilder<'NestedBlockConstraintForParam', false>; - Node: ClassViewer<'Node', "data" | "next">; + Node: _ClassBuilder<'Node', false>; - NodeWithAliasIndirection: ClassViewer<'NodeWithAliasIndirection', "value" | "next">; + NodeWithAliasIndirection: _ClassBuilder<'NodeWithAliasIndirection', false>; - Note1599: ClassViewer<'Note1599', "note_title" | "note_description" | "note_amount">; + Note1599: _ClassBuilder<'Note1599', false>; - OptionalListAndMap: ClassViewer<'OptionalListAndMap', "p" | "q">; + OptionalListAndMap: _ClassBuilder<'OptionalListAndMap', false>; - OptionalTest_Prop1: ClassViewer<'OptionalTest_Prop1', "omega_a" | "omega_b">; + OptionalTest_Prop1: _ClassBuilder<'OptionalTest_Prop1', false>; - OptionalTest_ReturnType: ClassViewer<'OptionalTest_ReturnType', "omega_1" | "omega_2" | "omega_3">; + OptionalTest_ReturnType: _ClassBuilder<'OptionalTest_ReturnType', false>; - OrderInfo: ClassViewer<'OrderInfo', "order_status" | "tracking_number" | "estimated_arrival_date">; + OrderInfo: _ClassBuilder<'OrderInfo', false>; - OriginalA: ClassViewer<'OriginalA', "value">; + OriginalA: _ClassBuilder<'OriginalA', false>; - OriginalB: ClassBuilder<'OriginalB', "value">; + OriginalB: _ClassBuilder<'OriginalB', true>; - Person: ClassBuilder<'Person', "name" | "hair_color">; + Person: _ClassBuilder<'Person', true>; - PhoneNumber: ClassViewer<'PhoneNumber', "value">; + PhoneNumber: _ClassBuilder<'PhoneNumber', false>; - Quantity: ClassViewer<'Quantity', "amount" | "unit">; + Quantity: _ClassBuilder<'Quantity', false>; - RaysData: ClassViewer<'RaysData', "dataType" | "value">; + RaysData: _ClassBuilder<'RaysData', false>; - ReceiptInfo: ClassViewer<'ReceiptInfo', "items" | "total_cost" | "venue">; + ReceiptInfo: _ClassBuilder<'ReceiptInfo', false>; - ReceiptItem: ClassViewer<'ReceiptItem', "name" | "description" | "quantity" | "price">; + ReceiptItem: _ClassBuilder<'ReceiptItem', false>; - Recipe: ClassViewer<'Recipe', "ingredients" | "recipe_type">; + Recipe: _ClassBuilder<'Recipe', false>; - RecursiveAliasDependency: ClassViewer<'RecursiveAliasDependency', "value">; + RecursiveAliasDependency: _ClassBuilder<'RecursiveAliasDependency', false>; - RenderEnumInput: ClassBuilder<'RenderEnumInput', "testKey">; + RenderEnumInput: _ClassBuilder<'RenderEnumInput', true>; - RenderTestClass: ClassBuilder<'RenderTestClass', "name" | "status">; + RenderTestClass: _ClassBuilder<'RenderTestClass', true>; - Resume: ClassViewer<'Resume', "name" | "email" | "phone" | "experience" | "education" | "skills">; + Resume: _ClassBuilder<'Resume', false>; - Schema: ClassViewer<'Schema', "prop1" | "prop2" | "prop5" | "prop6" | "nested_attrs" | "parens" | "other_group">; + Schema: _ClassBuilder<'Schema', false>; - SearchParams: ClassViewer<'SearchParams', "dateRange" | "location" | "jobTitle" | "company" | "description" | "tags">; + SearchParams: _ClassBuilder<'SearchParams', false>; - SemanticContainer: ClassViewer<'SemanticContainer', "sixteen_digit_number" | "string_with_twenty_words" | "class_1" | "class_2" | "class_done_needed" | "class_needed" | "three_small_things" | "final_string">; + SemanticContainer: _ClassBuilder<'SemanticContainer', false>; - SimpleTag: ClassViewer<'SimpleTag', "field">; + SimpleTag: _ClassBuilder<'SimpleTag', false>; - SmallThing: ClassViewer<'SmallThing', "i_16_digits" | "i_8_digits">; + SmallThing: _ClassBuilder<'SmallThing', false>; - SomeClassNestedDynamic: ClassBuilder<'SomeClassNestedDynamic', "hi">; + SomeClassNestedDynamic: _ClassBuilder<'SomeClassNestedDynamic', true>; - StringToClassEntry: ClassViewer<'StringToClassEntry', "word">; + StringToClassEntry: _ClassBuilder<'StringToClassEntry', false>; - TestClassAlias: ClassViewer<'TestClassAlias', "key" | "key2" | "key3" | "key4" | "key5">; + TestClassAlias: _ClassBuilder<'TestClassAlias', false>; - TestClassNested: ClassViewer<'TestClassNested', "prop1" | "prop2">; + TestClassNested: _ClassBuilder<'TestClassNested', false>; - TestClassWithEnum: ClassViewer<'TestClassWithEnum', "prop1" | "prop2">; + TestClassWithEnum: _ClassBuilder<'TestClassWithEnum', false>; - TestMemoryOutput: ClassViewer<'TestMemoryOutput', "items" | "more_items">; + TestMemoryOutput: _ClassBuilder<'TestMemoryOutput', false>; - TestOutputClass: ClassViewer<'TestOutputClass', "prop1" | "prop2">; + TestOutputClass: _ClassBuilder<'TestOutputClass', false>; - Tree: ClassViewer<'Tree', "data" | "children">; + Tree: _ClassBuilder<'Tree', false>; - TwoStoriesOneTitle: ClassViewer<'TwoStoriesOneTitle', "title" | "story_a" | "story_b">; + TwoStoriesOneTitle: _ClassBuilder<'TwoStoriesOneTitle', false>; - TwoStoriesOneTitleCheck: ClassViewer<'TwoStoriesOneTitleCheck', "title" | "story_a" | "story_b">; + TwoStoriesOneTitleCheck: _ClassBuilder<'TwoStoriesOneTitleCheck', false>; - UnionTest_ReturnType: ClassViewer<'UnionTest_ReturnType', "prop1" | "prop2" | "prop3">; + UnionTest_ReturnType: _ClassBuilder<'UnionTest_ReturnType', false>; - UniverseQuestion: ClassViewer<'UniverseQuestion', "question" | "answer">; + UniverseQuestion: _ClassBuilder<'UniverseQuestion', false>; - UniverseQuestionInput: ClassViewer<'UniverseQuestionInput', "question">; + UniverseQuestionInput: _ClassBuilder<'UniverseQuestionInput', false>; - WithReasoning: ClassViewer<'WithReasoning', "value" | "reasoning">; + WithReasoning: _ClassBuilder<'WithReasoning', false>; - AliasedEnum: EnumViewer<'AliasedEnum', "KEY_ONE" | "KEY_TWO">; + AliasedEnum: _EnumBuilder<'AliasedEnum', false>; - Category: EnumViewer<'Category', "Refund" | "CancelOrder" | "TechnicalSupport" | "AccountIssue" | "Question">; + Category: _EnumBuilder<'Category', false>; - Category2: EnumViewer<'Category2', "Refund" | "CancelOrder" | "TechnicalSupport" | "AccountIssue" | "Question">; + Category2: _EnumBuilder<'Category2', false>; - Category3: EnumViewer<'Category3', "Refund" | "CancelOrder" | "TechnicalSupport" | "AccountIssue" | "Question">; + Category3: _EnumBuilder<'Category3', false>; - Color: EnumBuilder<'Color', "RED" | "BLUE" | "GREEN" | "YELLOW" | "BLACK" | "WHITE">; + Color: _EnumBuilder<'Color', true>; - DataType: EnumViewer<'DataType', "Resume" | "Event">; + DataType: _EnumBuilder<'DataType', false>; - DynEnumOne: EnumBuilder<'DynEnumOne'>; + DynEnumOne: _EnumBuilder<'DynEnumOne', true>; - DynEnumThree: EnumBuilder<'DynEnumThree', "TRICYCLE" | "TRIANGLE">; + DynEnumThree: _EnumBuilder<'DynEnumThree', true>; - DynEnumTwo: EnumBuilder<'DynEnumTwo'>; + DynEnumTwo: _EnumBuilder<'DynEnumTwo', true>; - EnumInClass: EnumViewer<'EnumInClass', "ONE" | "TWO">; + EnumInClass: _EnumBuilder<'EnumInClass', false>; - EnumOutput: EnumViewer<'EnumOutput', "ONE" | "TWO" | "THREE">; + EnumOutput: _EnumBuilder<'EnumOutput', false>; - Hobby: EnumBuilder<'Hobby', "SPORTS" | "MUSIC" | "READING">; + Hobby: _EnumBuilder<'Hobby', true>; - MapKey: EnumViewer<'MapKey', "A" | "B" | "C">; + MapKey: _EnumBuilder<'MapKey', false>; - NamedArgsSingleEnum: EnumViewer<'NamedArgsSingleEnum', "ONE" | "TWO">; + NamedArgsSingleEnum: _EnumBuilder<'NamedArgsSingleEnum', false>; - NamedArgsSingleEnumList: EnumViewer<'NamedArgsSingleEnumList', "ONE" | "TWO">; + NamedArgsSingleEnumList: _EnumBuilder<'NamedArgsSingleEnumList', false>; - OptionalTest_CategoryType: EnumViewer<'OptionalTest_CategoryType', "Aleph" | "Beta" | "Gamma">; + OptionalTest_CategoryType: _EnumBuilder<'OptionalTest_CategoryType', false>; - OrderStatus: EnumViewer<'OrderStatus', "ORDERED" | "SHIPPED" | "DELIVERED" | "CANCELLED">; + OrderStatus: _EnumBuilder<'OrderStatus', false>; - RenderStatusEnum: EnumBuilder<'RenderStatusEnum', "ACTIVE" | "INACTIVE">; + RenderStatusEnum: _EnumBuilder<'RenderStatusEnum', true>; - RenderTestEnum: EnumBuilder<'RenderTestEnum', "BIKE" | "SCOOTER">; + RenderTestEnum: _EnumBuilder<'RenderTestEnum', true>; - Tag: EnumViewer<'Tag', "Security" | "AI" | "Blockchain">; + Tag: _EnumBuilder<'Tag', false>; - TestEnum: EnumViewer<'TestEnum', "A" | "B" | "C" | "D" | "E" | "F" | "G">; + TestEnum: _EnumBuilder<'TestEnum', false>; constructor() { this.tb = new _TypeBuilder({ - classes: new Set([ - "AnotherObject","BigNumbers","BinaryNode","Blah","BlockConstraint","BlockConstraintForParam","BookOrder","ClassForNullLiteral","ClassOptionalOutput","ClassOptionalOutput2","ClassToRecAlias","ClassWithBlockDone","ClassWithImage","ClassWithoutDone","ClientDetails1559","ComplexMemoryObject","CompoundBigNumbers","ContactInfo","CustomStory","CustomTaskResult","Document1559","DummyOutput","DynInputOutput","DynamicClassOne","DynamicClassTwo","DynamicOutput","DynamicSchema","Earthling","Education","Email","EmailAddress","Event","FakeImage","FlightConfirmation","FooAny","Forest","FormatterTest0","FormatterTest1","FormatterTest2","FormatterTest3","GroceryReceipt","Haiku","InnerClass","InnerClass2","InputClass","InputClassNested","LinkedList","LinkedListAliasNode","LiteralClassHello","LiteralClassOne","LiteralClassTwo","MaintainFieldOrder","MalformedConstraints","MalformedConstraints2","Martian","MemoryObject","MergeAttrs","NamedArgsSingleClass","Nested","Nested2","NestedBlockConstraint","NestedBlockConstraintForParam","Node","NodeWithAliasIndirection","Note1599","OptionalListAndMap","OptionalTest_Prop1","OptionalTest_ReturnType","OrderInfo","OriginalA","OriginalB","Person","PhoneNumber","Quantity","RaysData","ReceiptInfo","ReceiptItem","Recipe","RecursiveAliasDependency","RenderEnumInput","RenderTestClass","Resume","Schema","SearchParams","SemanticContainer","SimpleTag","SmallThing","SomeClassNestedDynamic","StringToClassEntry","TestClassAlias","TestClassNested","TestClassWithEnum","TestMemoryOutput","TestOutputClass","Tree","TwoStoriesOneTitle","TwoStoriesOneTitleCheck","UnionTest_ReturnType","UniverseQuestion","UniverseQuestionInput","WithReasoning", - ]), - enums: new Set([ - "AliasedEnum","Category","Category2","Category3","Color","DataType","DynEnumOne","DynEnumThree","DynEnumTwo","EnumInClass","EnumOutput","Hobby","MapKey","NamedArgsSingleEnum","NamedArgsSingleEnumList","OptionalTest_CategoryType","OrderStatus","RenderStatusEnum","RenderTestEnum","Tag","TestEnum", - ]), runtime: DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME }); - this.AnotherObject = this.tb.classViewer("AnotherObject", [ - "id","thingy2","thingy3", - ]); + this.AnotherObject = _getClass(this.tb, "AnotherObject"); - this.BigNumbers = this.tb.classViewer("BigNumbers", [ - "a","b", - ]); + this.BigNumbers = _getClass(this.tb, "BigNumbers"); - this.BinaryNode = this.tb.classViewer("BinaryNode", [ - "data","left","right", - ]); + this.BinaryNode = _getClass(this.tb, "BinaryNode"); - this.Blah = this.tb.classViewer("Blah", [ - "prop4", - ]); + this.Blah = _getClass(this.tb, "Blah"); - this.BlockConstraint = this.tb.classViewer("BlockConstraint", [ - "foo","bar", - ]); + this.BlockConstraint = _getClass(this.tb, "BlockConstraint"); - this.BlockConstraintForParam = this.tb.classViewer("BlockConstraintForParam", [ - "bcfp","bcfp2", - ]); + this.BlockConstraintForParam = _getClass(this.tb, "BlockConstraintForParam"); - this.BookOrder = this.tb.classViewer("BookOrder", [ - "orderId","title","quantity","price", - ]); + this.BookOrder = _getClass(this.tb, "BookOrder"); - this.ClassForNullLiteral = this.tb.classViewer("ClassForNullLiteral", [ - "a", - ]); + this.ClassForNullLiteral = _getClass(this.tb, "ClassForNullLiteral"); - this.ClassOptionalOutput = this.tb.classViewer("ClassOptionalOutput", [ - "prop1","prop2", - ]); + this.ClassOptionalOutput = _getClass(this.tb, "ClassOptionalOutput"); - this.ClassOptionalOutput2 = this.tb.classViewer("ClassOptionalOutput2", [ - "prop1","prop2","prop3", - ]); + this.ClassOptionalOutput2 = _getClass(this.tb, "ClassOptionalOutput2"); - this.ClassToRecAlias = this.tb.classViewer("ClassToRecAlias", [ - "list", - ]); + this.ClassToRecAlias = _getClass(this.tb, "ClassToRecAlias"); - this.ClassWithBlockDone = this.tb.classViewer("ClassWithBlockDone", [ - "i_16_digits","s_20_words", - ]); + this.ClassWithBlockDone = _getClass(this.tb, "ClassWithBlockDone"); - this.ClassWithImage = this.tb.classViewer("ClassWithImage", [ - "myImage","param2","fake_image", - ]); + this.ClassWithImage = _getClass(this.tb, "ClassWithImage"); - this.ClassWithoutDone = this.tb.classViewer("ClassWithoutDone", [ - "i_16_digits","s_20_words", - ]); + this.ClassWithoutDone = _getClass(this.tb, "ClassWithoutDone"); - this.ClientDetails1559 = this.tb.classViewer("ClientDetails1559", [ - "client_name","client_address","client_postal_code","client_city","client_country","client_phone","client_email", - ]); + this.ClientDetails1559 = _getClass(this.tb, "ClientDetails1559"); - this.ComplexMemoryObject = this.tb.classViewer("ComplexMemoryObject", [ - "id","name","description","metadata", - ]); + this.ComplexMemoryObject = _getClass(this.tb, "ComplexMemoryObject"); - this.CompoundBigNumbers = this.tb.classViewer("CompoundBigNumbers", [ - "big","big_nums","another", - ]); + this.CompoundBigNumbers = _getClass(this.tb, "CompoundBigNumbers"); - this.ContactInfo = this.tb.classViewer("ContactInfo", [ - "primary","secondary", - ]); + this.ContactInfo = _getClass(this.tb, "ContactInfo"); - this.CustomStory = this.tb.classViewer("CustomStory", [ - "title","characters","content", - ]); + this.CustomStory = _getClass(this.tb, "CustomStory"); - this.CustomTaskResult = this.tb.classViewer("CustomTaskResult", [ - "bookOrder","flightConfirmation","groceryReceipt", - ]); + this.CustomTaskResult = _getClass(this.tb, "CustomTaskResult"); - this.Document1559 = this.tb.classViewer("Document1559", [ - "client_details","notes", - ]); + this.Document1559 = _getClass(this.tb, "Document1559"); - this.DummyOutput = this.tb.classBuilder("DummyOutput", [ - "nonce","nonce2", - ]); + this.DummyOutput = _getClass(this.tb, "DummyOutput"); - this.DynInputOutput = this.tb.classBuilder("DynInputOutput", [ - "testKey", - ]); + this.DynInputOutput = _getClass(this.tb, "DynInputOutput"); - this.DynamicClassOne = this.tb.classBuilder("DynamicClassOne", [ - - ]); + this.DynamicClassOne = _getClass(this.tb, "DynamicClassOne"); - this.DynamicClassTwo = this.tb.classBuilder("DynamicClassTwo", [ - "hi","some_class","status", - ]); + this.DynamicClassTwo = _getClass(this.tb, "DynamicClassTwo"); - this.DynamicOutput = this.tb.classBuilder("DynamicOutput", [ - - ]); + this.DynamicOutput = _getClass(this.tb, "DynamicOutput"); - this.DynamicSchema = this.tb.classBuilder("DynamicSchema", [ - - ]); + this.DynamicSchema = _getClass(this.tb, "DynamicSchema"); - this.Earthling = this.tb.classViewer("Earthling", [ - "age", - ]); + this.Earthling = _getClass(this.tb, "Earthling"); - this.Education = this.tb.classViewer("Education", [ - "institution","location","degree","major","graduation_date", - ]); + this.Education = _getClass(this.tb, "Education"); - this.Email = this.tb.classViewer("Email", [ - "subject","body","from_address", - ]); + this.Email = _getClass(this.tb, "Email"); - this.EmailAddress = this.tb.classViewer("EmailAddress", [ - "value", - ]); + this.EmailAddress = _getClass(this.tb, "EmailAddress"); - this.Event = this.tb.classViewer("Event", [ - "title","date","location","description", - ]); + this.Event = _getClass(this.tb, "Event"); - this.FakeImage = this.tb.classViewer("FakeImage", [ - "url", - ]); + this.FakeImage = _getClass(this.tb, "FakeImage"); - this.FlightConfirmation = this.tb.classViewer("FlightConfirmation", [ - "confirmationNumber","flightNumber","departureTime","arrivalTime","seatNumber", - ]); + this.FlightConfirmation = _getClass(this.tb, "FlightConfirmation"); - this.FooAny = this.tb.classViewer("FooAny", [ - "planetary_age","certainty","species", - ]); + this.FooAny = _getClass(this.tb, "FooAny"); - this.Forest = this.tb.classViewer("Forest", [ - "trees", - ]); + this.Forest = _getClass(this.tb, "Forest"); - this.FormatterTest0 = this.tb.classViewer("FormatterTest0", [ - "lorem","ipsum", - ]); + this.FormatterTest0 = _getClass(this.tb, "FormatterTest0"); - this.FormatterTest1 = this.tb.classViewer("FormatterTest1", [ - "lorem","ipsum", - ]); + this.FormatterTest1 = _getClass(this.tb, "FormatterTest1"); - this.FormatterTest2 = this.tb.classViewer("FormatterTest2", [ - "lorem","ipsum", - ]); + this.FormatterTest2 = _getClass(this.tb, "FormatterTest2"); - this.FormatterTest3 = this.tb.classViewer("FormatterTest3", [ - "lorem","ipsum", - ]); + this.FormatterTest3 = _getClass(this.tb, "FormatterTest3"); - this.GroceryReceipt = this.tb.classViewer("GroceryReceipt", [ - "receiptId","storeName","items","totalAmount", - ]); + this.GroceryReceipt = _getClass(this.tb, "GroceryReceipt"); - this.Haiku = this.tb.classViewer("Haiku", [ - "line1","line2","line3", - ]); + this.Haiku = _getClass(this.tb, "Haiku"); - this.InnerClass = this.tb.classViewer("InnerClass", [ - "prop1","prop2","inner", - ]); + this.InnerClass = _getClass(this.tb, "InnerClass"); - this.InnerClass2 = this.tb.classViewer("InnerClass2", [ - "prop2","prop3", - ]); + this.InnerClass2 = _getClass(this.tb, "InnerClass2"); - this.InputClass = this.tb.classViewer("InputClass", [ - "key","key2", - ]); + this.InputClass = _getClass(this.tb, "InputClass"); - this.InputClassNested = this.tb.classViewer("InputClassNested", [ - "key","nested", - ]); + this.InputClassNested = _getClass(this.tb, "InputClassNested"); - this.LinkedList = this.tb.classViewer("LinkedList", [ - "head","len", - ]); + this.LinkedList = _getClass(this.tb, "LinkedList"); - this.LinkedListAliasNode = this.tb.classViewer("LinkedListAliasNode", [ - "value","next", - ]); + this.LinkedListAliasNode = _getClass(this.tb, "LinkedListAliasNode"); - this.LiteralClassHello = this.tb.classViewer("LiteralClassHello", [ - "prop", - ]); + this.LiteralClassHello = _getClass(this.tb, "LiteralClassHello"); - this.LiteralClassOne = this.tb.classViewer("LiteralClassOne", [ - "prop", - ]); + this.LiteralClassOne = _getClass(this.tb, "LiteralClassOne"); - this.LiteralClassTwo = this.tb.classViewer("LiteralClassTwo", [ - "prop", - ]); + this.LiteralClassTwo = _getClass(this.tb, "LiteralClassTwo"); - this.MaintainFieldOrder = this.tb.classViewer("MaintainFieldOrder", [ - "a","b","c", - ]); + this.MaintainFieldOrder = _getClass(this.tb, "MaintainFieldOrder"); - this.MalformedConstraints = this.tb.classViewer("MalformedConstraints", [ - "foo", - ]); + this.MalformedConstraints = _getClass(this.tb, "MalformedConstraints"); - this.MalformedConstraints2 = this.tb.classViewer("MalformedConstraints2", [ - "foo", - ]); + this.MalformedConstraints2 = _getClass(this.tb, "MalformedConstraints2"); - this.Martian = this.tb.classViewer("Martian", [ - "age", - ]); + this.Martian = _getClass(this.tb, "Martian"); - this.MemoryObject = this.tb.classViewer("MemoryObject", [ - "id","name","description", - ]); + this.MemoryObject = _getClass(this.tb, "MemoryObject"); - this.MergeAttrs = this.tb.classViewer("MergeAttrs", [ - "amount", - ]); + this.MergeAttrs = _getClass(this.tb, "MergeAttrs"); - this.NamedArgsSingleClass = this.tb.classViewer("NamedArgsSingleClass", [ - "key","key_two","key_three", - ]); + this.NamedArgsSingleClass = _getClass(this.tb, "NamedArgsSingleClass"); - this.Nested = this.tb.classViewer("Nested", [ - "prop3","prop4","prop20", - ]); + this.Nested = _getClass(this.tb, "Nested"); - this.Nested2 = this.tb.classViewer("Nested2", [ - "prop11","prop12", - ]); + this.Nested2 = _getClass(this.tb, "Nested2"); - this.NestedBlockConstraint = this.tb.classViewer("NestedBlockConstraint", [ - "nbc", - ]); + this.NestedBlockConstraint = _getClass(this.tb, "NestedBlockConstraint"); - this.NestedBlockConstraintForParam = this.tb.classViewer("NestedBlockConstraintForParam", [ - "nbcfp", - ]); + this.NestedBlockConstraintForParam = _getClass(this.tb, "NestedBlockConstraintForParam"); - this.Node = this.tb.classViewer("Node", [ - "data","next", - ]); + this.Node = _getClass(this.tb, "Node"); - this.NodeWithAliasIndirection = this.tb.classViewer("NodeWithAliasIndirection", [ - "value","next", - ]); + this.NodeWithAliasIndirection = _getClass(this.tb, "NodeWithAliasIndirection"); - this.Note1599 = this.tb.classViewer("Note1599", [ - "note_title","note_description","note_amount", - ]); + this.Note1599 = _getClass(this.tb, "Note1599"); - this.OptionalListAndMap = this.tb.classViewer("OptionalListAndMap", [ - "p","q", - ]); + this.OptionalListAndMap = _getClass(this.tb, "OptionalListAndMap"); - this.OptionalTest_Prop1 = this.tb.classViewer("OptionalTest_Prop1", [ - "omega_a","omega_b", - ]); + this.OptionalTest_Prop1 = _getClass(this.tb, "OptionalTest_Prop1"); - this.OptionalTest_ReturnType = this.tb.classViewer("OptionalTest_ReturnType", [ - "omega_1","omega_2","omega_3", - ]); + this.OptionalTest_ReturnType = _getClass(this.tb, "OptionalTest_ReturnType"); - this.OrderInfo = this.tb.classViewer("OrderInfo", [ - "order_status","tracking_number","estimated_arrival_date", - ]); + this.OrderInfo = _getClass(this.tb, "OrderInfo"); - this.OriginalA = this.tb.classViewer("OriginalA", [ - "value", - ]); + this.OriginalA = _getClass(this.tb, "OriginalA"); - this.OriginalB = this.tb.classBuilder("OriginalB", [ - "value", - ]); + this.OriginalB = _getClass(this.tb, "OriginalB"); - this.Person = this.tb.classBuilder("Person", [ - "name","hair_color", - ]); + this.Person = _getClass(this.tb, "Person"); - this.PhoneNumber = this.tb.classViewer("PhoneNumber", [ - "value", - ]); + this.PhoneNumber = _getClass(this.tb, "PhoneNumber"); - this.Quantity = this.tb.classViewer("Quantity", [ - "amount","unit", - ]); + this.Quantity = _getClass(this.tb, "Quantity"); - this.RaysData = this.tb.classViewer("RaysData", [ - "dataType","value", - ]); + this.RaysData = _getClass(this.tb, "RaysData"); - this.ReceiptInfo = this.tb.classViewer("ReceiptInfo", [ - "items","total_cost","venue", - ]); + this.ReceiptInfo = _getClass(this.tb, "ReceiptInfo"); - this.ReceiptItem = this.tb.classViewer("ReceiptItem", [ - "name","description","quantity","price", - ]); + this.ReceiptItem = _getClass(this.tb, "ReceiptItem"); - this.Recipe = this.tb.classViewer("Recipe", [ - "ingredients","recipe_type", - ]); + this.Recipe = _getClass(this.tb, "Recipe"); - this.RecursiveAliasDependency = this.tb.classViewer("RecursiveAliasDependency", [ - "value", - ]); + this.RecursiveAliasDependency = _getClass(this.tb, "RecursiveAliasDependency"); - this.RenderEnumInput = this.tb.classBuilder("RenderEnumInput", [ - "testKey", - ]); + this.RenderEnumInput = _getClass(this.tb, "RenderEnumInput"); - this.RenderTestClass = this.tb.classBuilder("RenderTestClass", [ - "name","status", - ]); + this.RenderTestClass = _getClass(this.tb, "RenderTestClass"); - this.Resume = this.tb.classViewer("Resume", [ - "name","email","phone","experience","education","skills", - ]); + this.Resume = _getClass(this.tb, "Resume"); - this.Schema = this.tb.classViewer("Schema", [ - "prop1","prop2","prop5","prop6","nested_attrs","parens","other_group", - ]); + this.Schema = _getClass(this.tb, "Schema"); - this.SearchParams = this.tb.classViewer("SearchParams", [ - "dateRange","location","jobTitle","company","description","tags", - ]); + this.SearchParams = _getClass(this.tb, "SearchParams"); - this.SemanticContainer = this.tb.classViewer("SemanticContainer", [ - "sixteen_digit_number","string_with_twenty_words","class_1","class_2","class_done_needed","class_needed","three_small_things","final_string", - ]); + this.SemanticContainer = _getClass(this.tb, "SemanticContainer"); - this.SimpleTag = this.tb.classViewer("SimpleTag", [ - "field", - ]); + this.SimpleTag = _getClass(this.tb, "SimpleTag"); - this.SmallThing = this.tb.classViewer("SmallThing", [ - "i_16_digits","i_8_digits", - ]); + this.SmallThing = _getClass(this.tb, "SmallThing"); - this.SomeClassNestedDynamic = this.tb.classBuilder("SomeClassNestedDynamic", [ - "hi", - ]); + this.SomeClassNestedDynamic = _getClass(this.tb, "SomeClassNestedDynamic"); - this.StringToClassEntry = this.tb.classViewer("StringToClassEntry", [ - "word", - ]); + this.StringToClassEntry = _getClass(this.tb, "StringToClassEntry"); - this.TestClassAlias = this.tb.classViewer("TestClassAlias", [ - "key","key2","key3","key4","key5", - ]); + this.TestClassAlias = _getClass(this.tb, "TestClassAlias"); - this.TestClassNested = this.tb.classViewer("TestClassNested", [ - "prop1","prop2", - ]); + this.TestClassNested = _getClass(this.tb, "TestClassNested"); - this.TestClassWithEnum = this.tb.classViewer("TestClassWithEnum", [ - "prop1","prop2", - ]); + this.TestClassWithEnum = _getClass(this.tb, "TestClassWithEnum"); - this.TestMemoryOutput = this.tb.classViewer("TestMemoryOutput", [ - "items","more_items", - ]); + this.TestMemoryOutput = _getClass(this.tb, "TestMemoryOutput"); - this.TestOutputClass = this.tb.classViewer("TestOutputClass", [ - "prop1","prop2", - ]); + this.TestOutputClass = _getClass(this.tb, "TestOutputClass"); - this.Tree = this.tb.classViewer("Tree", [ - "data","children", - ]); + this.Tree = _getClass(this.tb, "Tree"); - this.TwoStoriesOneTitle = this.tb.classViewer("TwoStoriesOneTitle", [ - "title","story_a","story_b", - ]); + this.TwoStoriesOneTitle = _getClass(this.tb, "TwoStoriesOneTitle"); - this.TwoStoriesOneTitleCheck = this.tb.classViewer("TwoStoriesOneTitleCheck", [ - "title","story_a","story_b", - ]); + this.TwoStoriesOneTitleCheck = _getClass(this.tb, "TwoStoriesOneTitleCheck"); - this.UnionTest_ReturnType = this.tb.classViewer("UnionTest_ReturnType", [ - "prop1","prop2","prop3", - ]); + this.UnionTest_ReturnType = _getClass(this.tb, "UnionTest_ReturnType"); - this.UniverseQuestion = this.tb.classViewer("UniverseQuestion", [ - "question","answer", - ]); + this.UniverseQuestion = _getClass(this.tb, "UniverseQuestion"); - this.UniverseQuestionInput = this.tb.classViewer("UniverseQuestionInput", [ - "question", - ]); + this.UniverseQuestionInput = _getClass(this.tb, "UniverseQuestionInput"); - this.WithReasoning = this.tb.classViewer("WithReasoning", [ - "value","reasoning", - ]); + this.WithReasoning = _getClass(this.tb, "WithReasoning"); - this.AliasedEnum = this.tb.enumViewer("AliasedEnum", [ - "KEY_ONE","KEY_TWO", - ]); + this.AliasedEnum = _getEnum(this.tb, "AliasedEnum"); - this.Category = this.tb.enumViewer("Category", [ - "Refund","CancelOrder","TechnicalSupport","AccountIssue","Question", - ]); + this.Category = _getEnum(this.tb, "Category"); - this.Category2 = this.tb.enumViewer("Category2", [ - "Refund","CancelOrder","TechnicalSupport","AccountIssue","Question", - ]); + this.Category2 = _getEnum(this.tb, "Category2"); - this.Category3 = this.tb.enumViewer("Category3", [ - "Refund","CancelOrder","TechnicalSupport","AccountIssue","Question", - ]); + this.Category3 = _getEnum(this.tb, "Category3"); - this.Color = this.tb.enumBuilder("Color", [ - "RED","BLUE","GREEN","YELLOW","BLACK","WHITE", - ]); + this.Color = _getEnum(this.tb, "Color"); - this.DataType = this.tb.enumViewer("DataType", [ - "Resume","Event", - ]); + this.DataType = _getEnum(this.tb, "DataType"); - this.DynEnumOne = this.tb.enumBuilder("DynEnumOne", [ - - ]); + this.DynEnumOne = _getEnum(this.tb, "DynEnumOne"); - this.DynEnumThree = this.tb.enumBuilder("DynEnumThree", [ - "TRICYCLE","TRIANGLE", - ]); + this.DynEnumThree = _getEnum(this.tb, "DynEnumThree"); - this.DynEnumTwo = this.tb.enumBuilder("DynEnumTwo", [ - - ]); + this.DynEnumTwo = _getEnum(this.tb, "DynEnumTwo"); - this.EnumInClass = this.tb.enumViewer("EnumInClass", [ - "ONE","TWO", - ]); + this.EnumInClass = _getEnum(this.tb, "EnumInClass"); - this.EnumOutput = this.tb.enumViewer("EnumOutput", [ - "ONE","TWO","THREE", - ]); + this.EnumOutput = _getEnum(this.tb, "EnumOutput"); - this.Hobby = this.tb.enumBuilder("Hobby", [ - "SPORTS","MUSIC","READING", - ]); + this.Hobby = _getEnum(this.tb, "Hobby"); - this.MapKey = this.tb.enumViewer("MapKey", [ - "A","B","C", - ]); + this.MapKey = _getEnum(this.tb, "MapKey"); - this.NamedArgsSingleEnum = this.tb.enumViewer("NamedArgsSingleEnum", [ - "ONE","TWO", - ]); + this.NamedArgsSingleEnum = _getEnum(this.tb, "NamedArgsSingleEnum"); - this.NamedArgsSingleEnumList = this.tb.enumViewer("NamedArgsSingleEnumList", [ - "ONE","TWO", - ]); + this.NamedArgsSingleEnumList = _getEnum(this.tb, "NamedArgsSingleEnumList"); - this.OptionalTest_CategoryType = this.tb.enumViewer("OptionalTest_CategoryType", [ - "Aleph","Beta","Gamma", - ]); + this.OptionalTest_CategoryType = _getEnum(this.tb, "OptionalTest_CategoryType"); - this.OrderStatus = this.tb.enumViewer("OrderStatus", [ - "ORDERED","SHIPPED","DELIVERED","CANCELLED", - ]); + this.OrderStatus = _getEnum(this.tb, "OrderStatus"); - this.RenderStatusEnum = this.tb.enumBuilder("RenderStatusEnum", [ - "ACTIVE","INACTIVE", - ]); + this.RenderStatusEnum = _getEnum(this.tb, "RenderStatusEnum"); - this.RenderTestEnum = this.tb.enumBuilder("RenderTestEnum", [ - "BIKE","SCOOTER", - ]); + this.RenderTestEnum = _getEnum(this.tb, "RenderTestEnum"); - this.Tag = this.tb.enumViewer("Tag", [ - "Security","AI","Blockchain", - ]); + this.Tag = _getEnum(this.tb, "Tag"); - this.TestEnum = this.tb.enumViewer("TestEnum", [ - "A","B","C","D","E","F","G", - ]); + this.TestEnum = _getEnum(this.tb, "TestEnum"); } reset(): void { this.tb.reset(); - // TODO: This should happen in Rust. Problem is, when we construct the - // typebuilder we instantiate class builders once and it seems to make - // a JS copy, bypassing the Rust side? In Python however, every time we - // access a class builder with @property, we get a new instance that - // wraps over the Rust type builder, so we only need to call tb.reset(). - // In JS it's not possible unless we refactor the way class builders are - // accessed. - this.DummyOutput.reset(); this.DynInputOutput.reset(); this.DynamicClassOne.reset(); this.DynamicClassTwo.reset(); this.DynamicOutput.reset(); this.DynamicSchema.reset(); this.OriginalB.reset(); this.Person.reset(); this.RenderEnumInput.reset(); this.RenderTestClass.reset(); this.SomeClassNestedDynamic.reset(); } __tb() { @@ -835,11 +841,11 @@ export default class TypeBuilder { return this.tb.union(types) } - addClass(name: Name): ClassBuilder { + addClass(name: string): ClassBuilder { return this.tb.addClass(name); } - addEnum(name: Name): EnumBuilder { + addEnum(name: string): EnumBuilder { return this.tb.addEnum(name); } diff --git a/integ-tests/typescript/baml_client/type_builder.ts b/integ-tests/typescript/baml_client/type_builder.ts index 0e7afd2bbd..de50053fbb 100644 --- a/integ-tests/typescript/baml_client/type_builder.ts +++ b/integ-tests/typescript/baml_client/type_builder.ts @@ -18,832 +18,1008 @@ $ pnpm add @boundaryml/baml // @ts-nocheck // biome-ignore format: autogenerated code -import { FieldType } from '@boundaryml/baml/native' -import { TypeBuilder as _TypeBuilder, EnumBuilder, EnumViewer, ClassBuilder, ClassViewer } from '@boundaryml/baml/type_builder' -import { DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME } from "./globals" +import { FieldType } from "@boundaryml/baml/native"; +import { + TypeBuilder as _TypeBuilder, + EnumBuilder, + ClassBuilder, +} from "@boundaryml/baml/type_builder"; +import { DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME } from "./globals"; -export { FieldType, EnumBuilder, ClassBuilder } +export { FieldType, EnumBuilder, ClassBuilder }; + +type ClassProperties = { + AnotherObject: ["id", "thingy2", "thingy3"]; + + BigNumbers: ["a", "b"]; + + BinaryNode: ["data", "left", "right"]; + + Blah: ["prop4"]; + + BlockConstraint: ["foo", "bar"]; + + BlockConstraintForParam: ["bcfp", "bcfp2"]; + + BookOrder: ["orderId", "title", "quantity", "price"]; + + ClassForNullLiteral: ["a"]; + + ClassOptionalOutput: ["prop1", "prop2"]; + + ClassOptionalOutput2: ["prop1", "prop2", "prop3"]; + + ClassToRecAlias: ["list"]; + + ClassWithBlockDone: ["i_16_digits", "s_20_words"]; + + ClassWithImage: ["myImage", "param2", "fake_image"]; + + ClassWithoutDone: ["i_16_digits", "s_20_words"]; + + ClientDetails1559: [ + "client_name", + "client_address", + "client_postal_code", + "client_city", + "client_country", + "client_phone", + "client_email" + ]; + + ComplexMemoryObject: ["id", "name", "description", "metadata"]; + + CompoundBigNumbers: ["big", "big_nums", "another"]; + + ContactInfo: ["primary", "secondary"]; + + CustomStory: ["title", "characters", "content"]; + + CustomTaskResult: ["bookOrder", "flightConfirmation", "groceryReceipt"]; + + Document1559: ["client_details", "notes"]; + + DummyOutput: ["nonce", "nonce2"]; + + DynInputOutput: ["testKey"]; + + DynamicClassOne: []; + + DynamicClassTwo: ["hi", "some_class", "status"]; + + DynamicOutput: []; + + DynamicSchema: []; + + Earthling: ["age"]; + + Education: ["institution", "location", "degree", "major", "graduation_date"]; + + Email: ["subject", "body", "from_address"]; + + EmailAddress: ["value"]; + + Event: ["title", "date", "location", "description"]; + + FakeImage: ["url"]; + + FlightConfirmation: [ + "confirmationNumber", + "flightNumber", + "departureTime", + "arrivalTime", + "seatNumber" + ]; + + FooAny: ["planetary_age", "certainty", "species"]; + + Forest: ["trees"]; + + FormatterTest0: ["lorem", "ipsum"]; + + FormatterTest1: ["lorem", "ipsum"]; + + FormatterTest2: ["lorem", "ipsum"]; + + FormatterTest3: ["lorem", "ipsum"]; + + GroceryReceipt: ["receiptId", "storeName", "items", "totalAmount"]; + + Haiku: ["line1", "line2", "line3"]; + + InnerClass: ["prop1", "prop2", "inner"]; + + InnerClass2: ["prop2", "prop3"]; + + InputClass: ["key", "key2"]; + + InputClassNested: ["key", "nested"]; + + LinkedList: ["head", "len"]; + + LinkedListAliasNode: ["value", "next"]; + + LiteralClassHello: ["prop"]; + + LiteralClassOne: ["prop"]; + + LiteralClassTwo: ["prop"]; + + MaintainFieldOrder: ["a", "b", "c"]; + + MalformedConstraints: ["foo"]; + + MalformedConstraints2: ["foo"]; + + Martian: ["age"]; + + MemoryObject: ["id", "name", "description"]; + + MergeAttrs: ["amount"]; + + NamedArgsSingleClass: ["key", "key_two", "key_three"]; + + Nested: ["prop3", "prop4", "prop20"]; + + Nested2: ["prop11", "prop12"]; + + NestedBlockConstraint: ["nbc"]; + + NestedBlockConstraintForParam: ["nbcfp"]; + + Node: ["data", "next"]; + + NodeWithAliasIndirection: ["value", "next"]; + + Note1599: ["note_title", "note_description", "note_amount"]; + + OptionalListAndMap: ["p", "q"]; + + OptionalTest_Prop1: ["omega_a", "omega_b"]; + + OptionalTest_ReturnType: ["omega_1", "omega_2", "omega_3"]; + + OrderInfo: ["order_status", "tracking_number", "estimated_arrival_date"]; + + OriginalA: ["value"]; + + OriginalB: ["value"]; + + Person: ["name", "hair_color"]; + + PhoneNumber: ["value"]; + + Quantity: ["amount", "unit"]; + + RaysData: ["dataType", "value"]; + + ReceiptInfo: ["items", "total_cost", "venue"]; + + ReceiptItem: ["name", "description", "quantity", "price"]; + + Recipe: ["ingredients", "recipe_type"]; + + RecursiveAliasDependency: ["value"]; + + RenderEnumInput: ["testKey"]; + + RenderTestClass: ["name", "status"]; + + Resume: ["name", "email", "phone", "experience", "education", "skills"]; + + Schema: [ + "prop1", + "prop2", + "prop5", + "prop6", + "nested_attrs", + "parens", + "other_group" + ]; + + SearchParams: [ + "dateRange", + "location", + "jobTitle", + "company", + "description", + "tags" + ]; + + SemanticContainer: [ + "sixteen_digit_number", + "string_with_twenty_words", + "class_1", + "class_2", + "class_done_needed", + "class_needed", + "three_small_things", + "final_string" + ]; + + SimpleTag: ["field"]; + + SmallThing: ["i_16_digits", "i_8_digits"]; + + SomeClassNestedDynamic: ["hi"]; + + StringToClassEntry: ["word"]; + + TestClassAlias: ["key", "key2", "key3", "key4", "key5"]; + + TestClassNested: ["prop1", "prop2"]; + + TestClassWithEnum: ["prop1", "prop2"]; + + TestMemoryOutput: ["items", "more_items"]; + + TestOutputClass: ["prop1", "prop2"]; + + Tree: ["data", "children"]; + + TwoStoriesOneTitle: ["title", "story_a", "story_b"]; + + TwoStoriesOneTitleCheck: ["title", "story_a", "story_b"]; + + UnionTest_ReturnType: ["prop1", "prop2", "prop3"]; + + UniverseQuestion: ["question", "answer"]; + + UniverseQuestionInput: ["question"]; + + WithReasoning: ["value", "reasoning"]; +}; +type EnumValues = { + AliasedEnum: ["KEY_ONE", "KEY_TWO"]; + + Category: [ + "Refund", + "CancelOrder", + "TechnicalSupport", + "AccountIssue", + "Question" + ]; + + Category2: [ + "Refund", + "CancelOrder", + "TechnicalSupport", + "AccountIssue", + "Question" + ]; + + Category3: [ + "Refund", + "CancelOrder", + "TechnicalSupport", + "AccountIssue", + "Question" + ]; + + Color: ["RED", "BLUE", "GREEN", "YELLOW", "BLACK", "WHITE"]; + + DataType: ["Resume", "Event"]; + + DynEnumOne: []; + + DynEnumThree: ["TRICYCLE", "TRIANGLE"]; + + DynEnumTwo: []; + + EnumInClass: ["ONE", "TWO"]; + + EnumOutput: ["ONE", "TWO", "THREE"]; + + Hobby: ["SPORTS", "MUSIC", "READING"]; + + MapKey: ["A", "B", "C"]; + + NamedArgsSingleEnum: ["ONE", "TWO"]; + + NamedArgsSingleEnumList: ["ONE", "TWO"]; + + OptionalTest_CategoryType: ["Aleph", "Beta", "Gamma"]; + + OrderStatus: ["ORDERED", "SHIPPED", "DELIVERED", "CANCELLED"]; + + RenderStatusEnum: ["ACTIVE", "INACTIVE"]; + + RenderTestEnum: ["BIKE", "SCOOTER"]; + + Tag: ["Security", "AI", "Blockchain"]; + + TestEnum: ["A", "B", "C", "D", "E", "F", "G"]; +}; +type ClassNames = keyof ClassProperties; +type EnumNames = keyof EnumValues; + +type _ClassBuilder = ClassBuilder< + Name, + ClassProperties[Name][number], + Dynamic +>; +type _EnumBuilder = EnumBuilder< + Name, + EnumValues[Name][number], + Dynamic +>; + +function _getEnum( + tb: _TypeBuilder, + name: Name +): _EnumBuilder { + return tb.getEnum(name); +} + +function _getClass( + tb: _TypeBuilder, + name: Name +): _ClassBuilder { + return tb.getClass(name); +} export default class TypeBuilder { - private tb: _TypeBuilder; - - AnotherObject: ClassViewer<'AnotherObject', "id" | "thingy2" | "thingy3">; - - BigNumbers: ClassViewer<'BigNumbers', "a" | "b">; - - BinaryNode: ClassViewer<'BinaryNode', "data" | "left" | "right">; - - Blah: ClassViewer<'Blah', "prop4">; - - BlockConstraint: ClassViewer<'BlockConstraint', "foo" | "bar">; - - BlockConstraintForParam: ClassViewer<'BlockConstraintForParam', "bcfp" | "bcfp2">; - - BookOrder: ClassViewer<'BookOrder', "orderId" | "title" | "quantity" | "price">; - - ClassForNullLiteral: ClassViewer<'ClassForNullLiteral', "a">; - - ClassOptionalOutput: ClassViewer<'ClassOptionalOutput', "prop1" | "prop2">; - - ClassOptionalOutput2: ClassViewer<'ClassOptionalOutput2', "prop1" | "prop2" | "prop3">; - - ClassToRecAlias: ClassViewer<'ClassToRecAlias', "list">; - - ClassWithBlockDone: ClassViewer<'ClassWithBlockDone', "i_16_digits" | "s_20_words">; - - ClassWithImage: ClassViewer<'ClassWithImage', "myImage" | "param2" | "fake_image">; - - ClassWithoutDone: ClassViewer<'ClassWithoutDone', "i_16_digits" | "s_20_words">; - - ClientDetails1559: ClassViewer<'ClientDetails1559', "client_name" | "client_address" | "client_postal_code" | "client_city" | "client_country" | "client_phone" | "client_email">; - - ComplexMemoryObject: ClassViewer<'ComplexMemoryObject', "id" | "name" | "description" | "metadata">; - - CompoundBigNumbers: ClassViewer<'CompoundBigNumbers', "big" | "big_nums" | "another">; - - ContactInfo: ClassViewer<'ContactInfo', "primary" | "secondary">; - - CustomStory: ClassViewer<'CustomStory', "title" | "characters" | "content">; - - CustomTaskResult: ClassViewer<'CustomTaskResult', "bookOrder" | "flightConfirmation" | "groceryReceipt">; - - Document1559: ClassViewer<'Document1559', "client_details" | "notes">; - - DummyOutput: ClassBuilder<'DummyOutput', "nonce" | "nonce2">; - - DynInputOutput: ClassBuilder<'DynInputOutput', "testKey">; - - DynamicClassOne: ClassBuilder<'DynamicClassOne'>; - - DynamicClassTwo: ClassBuilder<'DynamicClassTwo', "hi" | "some_class" | "status">; - - DynamicOutput: ClassBuilder<'DynamicOutput'>; - - DynamicSchema: ClassBuilder<'DynamicSchema'>; - - Earthling: ClassViewer<'Earthling', "age">; - - Education: ClassViewer<'Education', "institution" | "location" | "degree" | "major" | "graduation_date">; - - Email: ClassViewer<'Email', "subject" | "body" | "from_address">; - - EmailAddress: ClassViewer<'EmailAddress', "value">; - - Event: ClassViewer<'Event', "title" | "date" | "location" | "description">; - - FakeImage: ClassViewer<'FakeImage', "url">; - - FlightConfirmation: ClassViewer<'FlightConfirmation', "confirmationNumber" | "flightNumber" | "departureTime" | "arrivalTime" | "seatNumber">; - - FooAny: ClassViewer<'FooAny', "planetary_age" | "certainty" | "species">; - - Forest: ClassViewer<'Forest', "trees">; - - FormatterTest0: ClassViewer<'FormatterTest0', "lorem" | "ipsum">; - - FormatterTest1: ClassViewer<'FormatterTest1', "lorem" | "ipsum">; - - FormatterTest2: ClassViewer<'FormatterTest2', "lorem" | "ipsum">; - - FormatterTest3: ClassViewer<'FormatterTest3', "lorem" | "ipsum">; - - GroceryReceipt: ClassViewer<'GroceryReceipt', "receiptId" | "storeName" | "items" | "totalAmount">; - - Haiku: ClassViewer<'Haiku', "line1" | "line2" | "line3">; - - InnerClass: ClassViewer<'InnerClass', "prop1" | "prop2" | "inner">; - - InnerClass2: ClassViewer<'InnerClass2', "prop2" | "prop3">; - - InputClass: ClassViewer<'InputClass', "key" | "key2">; - - InputClassNested: ClassViewer<'InputClassNested', "key" | "nested">; - - LinkedList: ClassViewer<'LinkedList', "head" | "len">; - - LinkedListAliasNode: ClassViewer<'LinkedListAliasNode', "value" | "next">; - - LiteralClassHello: ClassViewer<'LiteralClassHello', "prop">; - - LiteralClassOne: ClassViewer<'LiteralClassOne', "prop">; - - LiteralClassTwo: ClassViewer<'LiteralClassTwo', "prop">; - - MaintainFieldOrder: ClassViewer<'MaintainFieldOrder', "a" | "b" | "c">; - - MalformedConstraints: ClassViewer<'MalformedConstraints', "foo">; - - MalformedConstraints2: ClassViewer<'MalformedConstraints2', "foo">; - - Martian: ClassViewer<'Martian', "age">; - - MemoryObject: ClassViewer<'MemoryObject', "id" | "name" | "description">; - - MergeAttrs: ClassViewer<'MergeAttrs', "amount">; - - NamedArgsSingleClass: ClassViewer<'NamedArgsSingleClass', "key" | "key_two" | "key_three">; - - Nested: ClassViewer<'Nested', "prop3" | "prop4" | "prop20">; - - Nested2: ClassViewer<'Nested2', "prop11" | "prop12">; - - NestedBlockConstraint: ClassViewer<'NestedBlockConstraint', "nbc">; - - NestedBlockConstraintForParam: ClassViewer<'NestedBlockConstraintForParam', "nbcfp">; - - Node: ClassViewer<'Node', "data" | "next">; - - NodeWithAliasIndirection: ClassViewer<'NodeWithAliasIndirection', "value" | "next">; - - Note1599: ClassViewer<'Note1599', "note_title" | "note_description" | "note_amount">; - - OptionalListAndMap: ClassViewer<'OptionalListAndMap', "p" | "q">; - - OptionalTest_Prop1: ClassViewer<'OptionalTest_Prop1', "omega_a" | "omega_b">; - - OptionalTest_ReturnType: ClassViewer<'OptionalTest_ReturnType', "omega_1" | "omega_2" | "omega_3">; - - OrderInfo: ClassViewer<'OrderInfo', "order_status" | "tracking_number" | "estimated_arrival_date">; - - OriginalA: ClassViewer<'OriginalA', "value">; - - OriginalB: ClassBuilder<'OriginalB', "value">; - - Person: ClassBuilder<'Person', "name" | "hair_color">; - - PhoneNumber: ClassViewer<'PhoneNumber', "value">; - - Quantity: ClassViewer<'Quantity', "amount" | "unit">; - - RaysData: ClassViewer<'RaysData', "dataType" | "value">; - - ReceiptInfo: ClassViewer<'ReceiptInfo', "items" | "total_cost" | "venue">; - - ReceiptItem: ClassViewer<'ReceiptItem', "name" | "description" | "quantity" | "price">; - - Recipe: ClassViewer<'Recipe', "ingredients" | "recipe_type">; - - RecursiveAliasDependency: ClassViewer<'RecursiveAliasDependency', "value">; - - RenderEnumInput: ClassBuilder<'RenderEnumInput', "testKey">; - - RenderTestClass: ClassBuilder<'RenderTestClass', "name" | "status">; - - Resume: ClassViewer<'Resume', "name" | "email" | "phone" | "experience" | "education" | "skills">; - - Schema: ClassViewer<'Schema', "prop1" | "prop2" | "prop5" | "prop6" | "nested_attrs" | "parens" | "other_group">; - - SearchParams: ClassViewer<'SearchParams', "dateRange" | "location" | "jobTitle" | "company" | "description" | "tags">; - - SemanticContainer: ClassViewer<'SemanticContainer', "sixteen_digit_number" | "string_with_twenty_words" | "class_1" | "class_2" | "class_done_needed" | "class_needed" | "three_small_things" | "final_string">; - - SimpleTag: ClassViewer<'SimpleTag', "field">; - - SmallThing: ClassViewer<'SmallThing', "i_16_digits" | "i_8_digits">; - - SomeClassNestedDynamic: ClassBuilder<'SomeClassNestedDynamic', "hi">; - - StringToClassEntry: ClassViewer<'StringToClassEntry', "word">; - - TestClassAlias: ClassViewer<'TestClassAlias', "key" | "key2" | "key3" | "key4" | "key5">; - - TestClassNested: ClassViewer<'TestClassNested', "prop1" | "prop2">; - - TestClassWithEnum: ClassViewer<'TestClassWithEnum', "prop1" | "prop2">; - - TestMemoryOutput: ClassViewer<'TestMemoryOutput', "items" | "more_items">; - - TestOutputClass: ClassViewer<'TestOutputClass', "prop1" | "prop2">; - - Tree: ClassViewer<'Tree', "data" | "children">; - - TwoStoriesOneTitle: ClassViewer<'TwoStoriesOneTitle', "title" | "story_a" | "story_b">; - - TwoStoriesOneTitleCheck: ClassViewer<'TwoStoriesOneTitleCheck', "title" | "story_a" | "story_b">; - - UnionTest_ReturnType: ClassViewer<'UnionTest_ReturnType', "prop1" | "prop2" | "prop3">; - - UniverseQuestion: ClassViewer<'UniverseQuestion', "question" | "answer">; - - UniverseQuestionInput: ClassViewer<'UniverseQuestionInput', "question">; - - WithReasoning: ClassViewer<'WithReasoning', "value" | "reasoning">; - - - AliasedEnum: EnumViewer<'AliasedEnum', "KEY_ONE" | "KEY_TWO">; - - Category: EnumViewer<'Category', "Refund" | "CancelOrder" | "TechnicalSupport" | "AccountIssue" | "Question">; - - Category2: EnumViewer<'Category2', "Refund" | "CancelOrder" | "TechnicalSupport" | "AccountIssue" | "Question">; - - Category3: EnumViewer<'Category3', "Refund" | "CancelOrder" | "TechnicalSupport" | "AccountIssue" | "Question">; - - Color: EnumBuilder<'Color', "RED" | "BLUE" | "GREEN" | "YELLOW" | "BLACK" | "WHITE">; - - DataType: EnumViewer<'DataType', "Resume" | "Event">; - - DynEnumOne: EnumBuilder<'DynEnumOne'>; - - DynEnumThree: EnumBuilder<'DynEnumThree', "TRICYCLE" | "TRIANGLE">; - - DynEnumTwo: EnumBuilder<'DynEnumTwo'>; - - EnumInClass: EnumViewer<'EnumInClass', "ONE" | "TWO">; - - EnumOutput: EnumViewer<'EnumOutput', "ONE" | "TWO" | "THREE">; - - Hobby: EnumBuilder<'Hobby', "SPORTS" | "MUSIC" | "READING">; - - MapKey: EnumViewer<'MapKey', "A" | "B" | "C">; - - NamedArgsSingleEnum: EnumViewer<'NamedArgsSingleEnum', "ONE" | "TWO">; - - NamedArgsSingleEnumList: EnumViewer<'NamedArgsSingleEnumList', "ONE" | "TWO">; - - OptionalTest_CategoryType: EnumViewer<'OptionalTest_CategoryType', "Aleph" | "Beta" | "Gamma">; - - OrderStatus: EnumViewer<'OrderStatus', "ORDERED" | "SHIPPED" | "DELIVERED" | "CANCELLED">; - - RenderStatusEnum: EnumBuilder<'RenderStatusEnum', "ACTIVE" | "INACTIVE">; - - RenderTestEnum: EnumBuilder<'RenderTestEnum', "BIKE" | "SCOOTER">; - - Tag: EnumViewer<'Tag', "Security" | "AI" | "Blockchain">; - - TestEnum: EnumViewer<'TestEnum', "A" | "B" | "C" | "D" | "E" | "F" | "G">; - - - constructor() { - this.tb = new _TypeBuilder({ - classes: new Set([ - "AnotherObject","BigNumbers","BinaryNode","Blah","BlockConstraint","BlockConstraintForParam","BookOrder","ClassForNullLiteral","ClassOptionalOutput","ClassOptionalOutput2","ClassToRecAlias","ClassWithBlockDone","ClassWithImage","ClassWithoutDone","ClientDetails1559","ComplexMemoryObject","CompoundBigNumbers","ContactInfo","CustomStory","CustomTaskResult","Document1559","DummyOutput","DynInputOutput","DynamicClassOne","DynamicClassTwo","DynamicOutput","DynamicSchema","Earthling","Education","Email","EmailAddress","Event","FakeImage","FlightConfirmation","FooAny","Forest","FormatterTest0","FormatterTest1","FormatterTest2","FormatterTest3","GroceryReceipt","Haiku","InnerClass","InnerClass2","InputClass","InputClassNested","LinkedList","LinkedListAliasNode","LiteralClassHello","LiteralClassOne","LiteralClassTwo","MaintainFieldOrder","MalformedConstraints","MalformedConstraints2","Martian","MemoryObject","MergeAttrs","NamedArgsSingleClass","Nested","Nested2","NestedBlockConstraint","NestedBlockConstraintForParam","Node","NodeWithAliasIndirection","Note1599","OptionalListAndMap","OptionalTest_Prop1","OptionalTest_ReturnType","OrderInfo","OriginalA","OriginalB","Person","PhoneNumber","Quantity","RaysData","ReceiptInfo","ReceiptItem","Recipe","RecursiveAliasDependency","RenderEnumInput","RenderTestClass","Resume","Schema","SearchParams","SemanticContainer","SimpleTag","SmallThing","SomeClassNestedDynamic","StringToClassEntry","TestClassAlias","TestClassNested","TestClassWithEnum","TestMemoryOutput","TestOutputClass","Tree","TwoStoriesOneTitle","TwoStoriesOneTitleCheck","UnionTest_ReturnType","UniverseQuestion","UniverseQuestionInput","WithReasoning", - ]), - enums: new Set([ - "AliasedEnum","Category","Category2","Category3","Color","DataType","DynEnumOne","DynEnumThree","DynEnumTwo","EnumInClass","EnumOutput","Hobby","MapKey","NamedArgsSingleEnum","NamedArgsSingleEnumList","OptionalTest_CategoryType","OrderStatus","RenderStatusEnum","RenderTestEnum","Tag","TestEnum", - ]), - runtime: DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME - }); - - this.AnotherObject = this.tb.classViewer("AnotherObject", [ - "id","thingy2","thingy3", - ]); - - this.BigNumbers = this.tb.classViewer("BigNumbers", [ - "a","b", - ]); - - this.BinaryNode = this.tb.classViewer("BinaryNode", [ - "data","left","right", - ]); - - this.Blah = this.tb.classViewer("Blah", [ - "prop4", - ]); - - this.BlockConstraint = this.tb.classViewer("BlockConstraint", [ - "foo","bar", - ]); - - this.BlockConstraintForParam = this.tb.classViewer("BlockConstraintForParam", [ - "bcfp","bcfp2", - ]); - - this.BookOrder = this.tb.classViewer("BookOrder", [ - "orderId","title","quantity","price", - ]); - - this.ClassForNullLiteral = this.tb.classViewer("ClassForNullLiteral", [ - "a", - ]); - - this.ClassOptionalOutput = this.tb.classViewer("ClassOptionalOutput", [ - "prop1","prop2", - ]); - - this.ClassOptionalOutput2 = this.tb.classViewer("ClassOptionalOutput2", [ - "prop1","prop2","prop3", - ]); - - this.ClassToRecAlias = this.tb.classViewer("ClassToRecAlias", [ - "list", - ]); - - this.ClassWithBlockDone = this.tb.classViewer("ClassWithBlockDone", [ - "i_16_digits","s_20_words", - ]); - - this.ClassWithImage = this.tb.classViewer("ClassWithImage", [ - "myImage","param2","fake_image", - ]); - - this.ClassWithoutDone = this.tb.classViewer("ClassWithoutDone", [ - "i_16_digits","s_20_words", - ]); - - this.ClientDetails1559 = this.tb.classViewer("ClientDetails1559", [ - "client_name","client_address","client_postal_code","client_city","client_country","client_phone","client_email", - ]); - - this.ComplexMemoryObject = this.tb.classViewer("ComplexMemoryObject", [ - "id","name","description","metadata", - ]); - - this.CompoundBigNumbers = this.tb.classViewer("CompoundBigNumbers", [ - "big","big_nums","another", - ]); - - this.ContactInfo = this.tb.classViewer("ContactInfo", [ - "primary","secondary", - ]); - - this.CustomStory = this.tb.classViewer("CustomStory", [ - "title","characters","content", - ]); - - this.CustomTaskResult = this.tb.classViewer("CustomTaskResult", [ - "bookOrder","flightConfirmation","groceryReceipt", - ]); - - this.Document1559 = this.tb.classViewer("Document1559", [ - "client_details","notes", - ]); - - this.DummyOutput = this.tb.classBuilder("DummyOutput", [ - "nonce","nonce2", - ]); - - this.DynInputOutput = this.tb.classBuilder("DynInputOutput", [ - "testKey", - ]); - - this.DynamicClassOne = this.tb.classBuilder("DynamicClassOne", [ - - ]); - - this.DynamicClassTwo = this.tb.classBuilder("DynamicClassTwo", [ - "hi","some_class","status", - ]); - - this.DynamicOutput = this.tb.classBuilder("DynamicOutput", [ - - ]); - - this.DynamicSchema = this.tb.classBuilder("DynamicSchema", [ - - ]); - - this.Earthling = this.tb.classViewer("Earthling", [ - "age", - ]); - - this.Education = this.tb.classViewer("Education", [ - "institution","location","degree","major","graduation_date", - ]); - - this.Email = this.tb.classViewer("Email", [ - "subject","body","from_address", - ]); - - this.EmailAddress = this.tb.classViewer("EmailAddress", [ - "value", - ]); - - this.Event = this.tb.classViewer("Event", [ - "title","date","location","description", - ]); - - this.FakeImage = this.tb.classViewer("FakeImage", [ - "url", - ]); - - this.FlightConfirmation = this.tb.classViewer("FlightConfirmation", [ - "confirmationNumber","flightNumber","departureTime","arrivalTime","seatNumber", - ]); - - this.FooAny = this.tb.classViewer("FooAny", [ - "planetary_age","certainty","species", - ]); - - this.Forest = this.tb.classViewer("Forest", [ - "trees", - ]); - - this.FormatterTest0 = this.tb.classViewer("FormatterTest0", [ - "lorem","ipsum", - ]); - - this.FormatterTest1 = this.tb.classViewer("FormatterTest1", [ - "lorem","ipsum", - ]); - - this.FormatterTest2 = this.tb.classViewer("FormatterTest2", [ - "lorem","ipsum", - ]); - - this.FormatterTest3 = this.tb.classViewer("FormatterTest3", [ - "lorem","ipsum", - ]); - - this.GroceryReceipt = this.tb.classViewer("GroceryReceipt", [ - "receiptId","storeName","items","totalAmount", - ]); - - this.Haiku = this.tb.classViewer("Haiku", [ - "line1","line2","line3", - ]); - - this.InnerClass = this.tb.classViewer("InnerClass", [ - "prop1","prop2","inner", - ]); - - this.InnerClass2 = this.tb.classViewer("InnerClass2", [ - "prop2","prop3", - ]); - - this.InputClass = this.tb.classViewer("InputClass", [ - "key","key2", - ]); - - this.InputClassNested = this.tb.classViewer("InputClassNested", [ - "key","nested", - ]); - - this.LinkedList = this.tb.classViewer("LinkedList", [ - "head","len", - ]); - - this.LinkedListAliasNode = this.tb.classViewer("LinkedListAliasNode", [ - "value","next", - ]); - - this.LiteralClassHello = this.tb.classViewer("LiteralClassHello", [ - "prop", - ]); - - this.LiteralClassOne = this.tb.classViewer("LiteralClassOne", [ - "prop", - ]); - - this.LiteralClassTwo = this.tb.classViewer("LiteralClassTwo", [ - "prop", - ]); - - this.MaintainFieldOrder = this.tb.classViewer("MaintainFieldOrder", [ - "a","b","c", - ]); - - this.MalformedConstraints = this.tb.classViewer("MalformedConstraints", [ - "foo", - ]); - - this.MalformedConstraints2 = this.tb.classViewer("MalformedConstraints2", [ - "foo", - ]); - - this.Martian = this.tb.classViewer("Martian", [ - "age", - ]); - - this.MemoryObject = this.tb.classViewer("MemoryObject", [ - "id","name","description", - ]); - - this.MergeAttrs = this.tb.classViewer("MergeAttrs", [ - "amount", - ]); - - this.NamedArgsSingleClass = this.tb.classViewer("NamedArgsSingleClass", [ - "key","key_two","key_three", - ]); - - this.Nested = this.tb.classViewer("Nested", [ - "prop3","prop4","prop20", - ]); - - this.Nested2 = this.tb.classViewer("Nested2", [ - "prop11","prop12", - ]); - - this.NestedBlockConstraint = this.tb.classViewer("NestedBlockConstraint", [ - "nbc", - ]); - - this.NestedBlockConstraintForParam = this.tb.classViewer("NestedBlockConstraintForParam", [ - "nbcfp", - ]); - - this.Node = this.tb.classViewer("Node", [ - "data","next", - ]); - - this.NodeWithAliasIndirection = this.tb.classViewer("NodeWithAliasIndirection", [ - "value","next", - ]); - - this.Note1599 = this.tb.classViewer("Note1599", [ - "note_title","note_description","note_amount", - ]); - - this.OptionalListAndMap = this.tb.classViewer("OptionalListAndMap", [ - "p","q", - ]); - - this.OptionalTest_Prop1 = this.tb.classViewer("OptionalTest_Prop1", [ - "omega_a","omega_b", - ]); - - this.OptionalTest_ReturnType = this.tb.classViewer("OptionalTest_ReturnType", [ - "omega_1","omega_2","omega_3", - ]); - - this.OrderInfo = this.tb.classViewer("OrderInfo", [ - "order_status","tracking_number","estimated_arrival_date", - ]); - - this.OriginalA = this.tb.classViewer("OriginalA", [ - "value", - ]); - - this.OriginalB = this.tb.classBuilder("OriginalB", [ - "value", - ]); - - this.Person = this.tb.classBuilder("Person", [ - "name","hair_color", - ]); - - this.PhoneNumber = this.tb.classViewer("PhoneNumber", [ - "value", - ]); - - this.Quantity = this.tb.classViewer("Quantity", [ - "amount","unit", - ]); - - this.RaysData = this.tb.classViewer("RaysData", [ - "dataType","value", - ]); - - this.ReceiptInfo = this.tb.classViewer("ReceiptInfo", [ - "items","total_cost","venue", - ]); - - this.ReceiptItem = this.tb.classViewer("ReceiptItem", [ - "name","description","quantity","price", - ]); - - this.Recipe = this.tb.classViewer("Recipe", [ - "ingredients","recipe_type", - ]); - - this.RecursiveAliasDependency = this.tb.classViewer("RecursiveAliasDependency", [ - "value", - ]); - - this.RenderEnumInput = this.tb.classBuilder("RenderEnumInput", [ - "testKey", - ]); - - this.RenderTestClass = this.tb.classBuilder("RenderTestClass", [ - "name","status", - ]); - - this.Resume = this.tb.classViewer("Resume", [ - "name","email","phone","experience","education","skills", - ]); - - this.Schema = this.tb.classViewer("Schema", [ - "prop1","prop2","prop5","prop6","nested_attrs","parens","other_group", - ]); - - this.SearchParams = this.tb.classViewer("SearchParams", [ - "dateRange","location","jobTitle","company","description","tags", - ]); - - this.SemanticContainer = this.tb.classViewer("SemanticContainer", [ - "sixteen_digit_number","string_with_twenty_words","class_1","class_2","class_done_needed","class_needed","three_small_things","final_string", - ]); - - this.SimpleTag = this.tb.classViewer("SimpleTag", [ - "field", - ]); - - this.SmallThing = this.tb.classViewer("SmallThing", [ - "i_16_digits","i_8_digits", - ]); - - this.SomeClassNestedDynamic = this.tb.classBuilder("SomeClassNestedDynamic", [ - "hi", - ]); - - this.StringToClassEntry = this.tb.classViewer("StringToClassEntry", [ - "word", - ]); - - this.TestClassAlias = this.tb.classViewer("TestClassAlias", [ - "key","key2","key3","key4","key5", - ]); - - this.TestClassNested = this.tb.classViewer("TestClassNested", [ - "prop1","prop2", - ]); - - this.TestClassWithEnum = this.tb.classViewer("TestClassWithEnum", [ - "prop1","prop2", - ]); - - this.TestMemoryOutput = this.tb.classViewer("TestMemoryOutput", [ - "items","more_items", - ]); - - this.TestOutputClass = this.tb.classViewer("TestOutputClass", [ - "prop1","prop2", - ]); - - this.Tree = this.tb.classViewer("Tree", [ - "data","children", - ]); - - this.TwoStoriesOneTitle = this.tb.classViewer("TwoStoriesOneTitle", [ - "title","story_a","story_b", - ]); - - this.TwoStoriesOneTitleCheck = this.tb.classViewer("TwoStoriesOneTitleCheck", [ - "title","story_a","story_b", - ]); - - this.UnionTest_ReturnType = this.tb.classViewer("UnionTest_ReturnType", [ - "prop1","prop2","prop3", - ]); - - this.UniverseQuestion = this.tb.classViewer("UniverseQuestion", [ - "question","answer", - ]); - - this.UniverseQuestionInput = this.tb.classViewer("UniverseQuestionInput", [ - "question", - ]); - - this.WithReasoning = this.tb.classViewer("WithReasoning", [ - "value","reasoning", - ]); - - - this.AliasedEnum = this.tb.enumViewer("AliasedEnum", [ - "KEY_ONE","KEY_TWO", - ]); - - this.Category = this.tb.enumViewer("Category", [ - "Refund","CancelOrder","TechnicalSupport","AccountIssue","Question", - ]); - - this.Category2 = this.tb.enumViewer("Category2", [ - "Refund","CancelOrder","TechnicalSupport","AccountIssue","Question", - ]); - - this.Category3 = this.tb.enumViewer("Category3", [ - "Refund","CancelOrder","TechnicalSupport","AccountIssue","Question", - ]); - - this.Color = this.tb.enumBuilder("Color", [ - "RED","BLUE","GREEN","YELLOW","BLACK","WHITE", - ]); - - this.DataType = this.tb.enumViewer("DataType", [ - "Resume","Event", - ]); - - this.DynEnumOne = this.tb.enumBuilder("DynEnumOne", [ - - ]); - - this.DynEnumThree = this.tb.enumBuilder("DynEnumThree", [ - "TRICYCLE","TRIANGLE", - ]); - - this.DynEnumTwo = this.tb.enumBuilder("DynEnumTwo", [ - - ]); - - this.EnumInClass = this.tb.enumViewer("EnumInClass", [ - "ONE","TWO", - ]); - - this.EnumOutput = this.tb.enumViewer("EnumOutput", [ - "ONE","TWO","THREE", - ]); - - this.Hobby = this.tb.enumBuilder("Hobby", [ - "SPORTS","MUSIC","READING", - ]); - - this.MapKey = this.tb.enumViewer("MapKey", [ - "A","B","C", - ]); - - this.NamedArgsSingleEnum = this.tb.enumViewer("NamedArgsSingleEnum", [ - "ONE","TWO", - ]); - - this.NamedArgsSingleEnumList = this.tb.enumViewer("NamedArgsSingleEnumList", [ - "ONE","TWO", - ]); - - this.OptionalTest_CategoryType = this.tb.enumViewer("OptionalTest_CategoryType", [ - "Aleph","Beta","Gamma", - ]); - - this.OrderStatus = this.tb.enumViewer("OrderStatus", [ - "ORDERED","SHIPPED","DELIVERED","CANCELLED", - ]); - - this.RenderStatusEnum = this.tb.enumBuilder("RenderStatusEnum", [ - "ACTIVE","INACTIVE", - ]); - - this.RenderTestEnum = this.tb.enumBuilder("RenderTestEnum", [ - "BIKE","SCOOTER", - ]); - - this.Tag = this.tb.enumViewer("Tag", [ - "Security","AI","Blockchain", - ]); - - this.TestEnum = this.tb.enumViewer("TestEnum", [ - "A","B","C","D","E","F","G", - ]); - - } + private tb: _TypeBuilder; - reset(): void { - this.tb.reset(); - // TODO: This should happen in Rust. Problem is, when we construct the - // typebuilder we instantiate class builders once and it seems to make - // a JS copy, bypassing the Rust side? In Python however, every time we - // access a class builder with @property, we get a new instance that - // wraps over the Rust type builder, so we only need to call tb.reset(). - // In JS it's not possible unless we refactor the way class builders are - // accessed. - this.DummyOutput.reset(); this.DynInputOutput.reset(); this.DynamicClassOne.reset(); this.DynamicClassTwo.reset(); this.DynamicOutput.reset(); this.DynamicSchema.reset(); this.OriginalB.reset(); this.Person.reset(); this.RenderEnumInput.reset(); this.RenderTestClass.reset(); this.SomeClassNestedDynamic.reset(); - } + AnotherObject: _ClassBuilder<"AnotherObject", false>; - __tb() { - return this.tb._tb(); - } + BigNumbers: _ClassBuilder<"BigNumbers", false>; - string(): FieldType { - return this.tb.string() - } + BinaryNode: _ClassBuilder<"BinaryNode", false>; - literalString(value: string): FieldType { - return this.tb.literalString(value) - } + Blah: _ClassBuilder<"Blah", false>; - literalInt(value: number): FieldType { - return this.tb.literalInt(value) - } + BlockConstraint: _ClassBuilder<"BlockConstraint", false>; - literalBool(value: boolean): FieldType { - return this.tb.literalBool(value) - } + BlockConstraintForParam: _ClassBuilder<"BlockConstraintForParam", false>; - int(): FieldType { - return this.tb.int() - } + BookOrder: _ClassBuilder<"BookOrder", false>; - float(): FieldType { - return this.tb.float() - } + ClassForNullLiteral: _ClassBuilder<"ClassForNullLiteral", false>; - bool(): FieldType { - return this.tb.bool() - } + ClassOptionalOutput: _ClassBuilder<"ClassOptionalOutput", false>; - list(type: FieldType): FieldType { - return this.tb.list(type) - } + ClassOptionalOutput2: _ClassBuilder<"ClassOptionalOutput2", false>; - null(): FieldType { - return this.tb.null() - } + ClassToRecAlias: _ClassBuilder<"ClassToRecAlias", false>; - map(key: FieldType, value: FieldType): FieldType { - return this.tb.map(key, value) - } + ClassWithBlockDone: _ClassBuilder<"ClassWithBlockDone", false>; - union(types: FieldType[]): FieldType { - return this.tb.union(types) - } + ClassWithImage: _ClassBuilder<"ClassWithImage", false>; - addClass(name: Name): ClassBuilder { - return this.tb.addClass(name); - } + ClassWithoutDone: _ClassBuilder<"ClassWithoutDone", false>; + + ClientDetails1559: _ClassBuilder<"ClientDetails1559", false>; + + ComplexMemoryObject: _ClassBuilder<"ComplexMemoryObject", false>; + + CompoundBigNumbers: _ClassBuilder<"CompoundBigNumbers", false>; + + ContactInfo: _ClassBuilder<"ContactInfo", false>; + + CustomStory: _ClassBuilder<"CustomStory", false>; + + CustomTaskResult: _ClassBuilder<"CustomTaskResult", false>; + + Document1559: _ClassBuilder<"Document1559", false>; + + DummyOutput: _ClassBuilder<"DummyOutput", true>; + + DynInputOutput: _ClassBuilder<"DynInputOutput", true>; + + DynamicClassOne: _ClassBuilder<"DynamicClassOne", true>; + + DynamicClassTwo: _ClassBuilder<"DynamicClassTwo", true>; + + DynamicOutput: _ClassBuilder<"DynamicOutput", true>; + + DynamicSchema: _ClassBuilder<"DynamicSchema", true>; + + Earthling: _ClassBuilder<"Earthling", false>; + + Education: _ClassBuilder<"Education", false>; + + Email: _ClassBuilder<"Email", false>; + + EmailAddress: _ClassBuilder<"EmailAddress", false>; + + Event: _ClassBuilder<"Event", false>; + + FakeImage: _ClassBuilder<"FakeImage", false>; + + FlightConfirmation: _ClassBuilder<"FlightConfirmation", false>; + + FooAny: _ClassBuilder<"FooAny", false>; + + Forest: _ClassBuilder<"Forest", false>; + + FormatterTest0: _ClassBuilder<"FormatterTest0", false>; + + FormatterTest1: _ClassBuilder<"FormatterTest1", false>; + + FormatterTest2: _ClassBuilder<"FormatterTest2", false>; + + FormatterTest3: _ClassBuilder<"FormatterTest3", false>; + + GroceryReceipt: _ClassBuilder<"GroceryReceipt", false>; + + Haiku: _ClassBuilder<"Haiku", false>; + + InnerClass: _ClassBuilder<"InnerClass", false>; + + InnerClass2: _ClassBuilder<"InnerClass2", false>; + + InputClass: _ClassBuilder<"InputClass", false>; + + InputClassNested: _ClassBuilder<"InputClassNested", false>; + + LinkedList: _ClassBuilder<"LinkedList", false>; + + LinkedListAliasNode: _ClassBuilder<"LinkedListAliasNode", false>; + + LiteralClassHello: _ClassBuilder<"LiteralClassHello", false>; + + LiteralClassOne: _ClassBuilder<"LiteralClassOne", false>; + + LiteralClassTwo: _ClassBuilder<"LiteralClassTwo", false>; + + MaintainFieldOrder: _ClassBuilder<"MaintainFieldOrder", false>; + + MalformedConstraints: _ClassBuilder<"MalformedConstraints", false>; + + MalformedConstraints2: _ClassBuilder<"MalformedConstraints2", false>; + + Martian: _ClassBuilder<"Martian", false>; + + MemoryObject: _ClassBuilder<"MemoryObject", false>; + + MergeAttrs: _ClassBuilder<"MergeAttrs", false>; + + NamedArgsSingleClass: _ClassBuilder<"NamedArgsSingleClass", false>; + + Nested: _ClassBuilder<"Nested", false>; + + Nested2: _ClassBuilder<"Nested2", false>; + + NestedBlockConstraint: _ClassBuilder<"NestedBlockConstraint", false>; + + NestedBlockConstraintForParam: _ClassBuilder< + "NestedBlockConstraintForParam", + false + >; + + Node: _ClassBuilder<"Node", false>; + + NodeWithAliasIndirection: _ClassBuilder<"NodeWithAliasIndirection", false>; + + Note1599: _ClassBuilder<"Note1599", false>; + + OptionalListAndMap: _ClassBuilder<"OptionalListAndMap", false>; + + OptionalTest_Prop1: _ClassBuilder<"OptionalTest_Prop1", false>; - addEnum(name: Name): EnumBuilder { - return this.tb.addEnum(name); + OptionalTest_ReturnType: _ClassBuilder<"OptionalTest_ReturnType", false>; + + OrderInfo: _ClassBuilder<"OrderInfo", false>; + + OriginalA: _ClassBuilder<"OriginalA", false>; + + OriginalB: _ClassBuilder<"OriginalB", true>; + + Person: _ClassBuilder<"Person", true>; + + PhoneNumber: _ClassBuilder<"PhoneNumber", false>; + + Quantity: _ClassBuilder<"Quantity", false>; + + RaysData: _ClassBuilder<"RaysData", false>; + + ReceiptInfo: _ClassBuilder<"ReceiptInfo", false>; + + ReceiptItem: _ClassBuilder<"ReceiptItem", false>; + + Recipe: _ClassBuilder<"Recipe", false>; + + RecursiveAliasDependency: _ClassBuilder<"RecursiveAliasDependency", false>; + + RenderEnumInput: _ClassBuilder<"RenderEnumInput", true>; + + RenderTestClass: _ClassBuilder<"RenderTestClass", true>; + + Resume: _ClassBuilder<"Resume", false>; + + Schema: _ClassBuilder<"Schema", false>; + + SearchParams: _ClassBuilder<"SearchParams", false>; + + SemanticContainer: _ClassBuilder<"SemanticContainer", false>; + + SimpleTag: _ClassBuilder<"SimpleTag", false>; + + SmallThing: _ClassBuilder<"SmallThing", false>; + + SomeClassNestedDynamic: _ClassBuilder<"SomeClassNestedDynamic", true>; + + StringToClassEntry: _ClassBuilder<"StringToClassEntry", false>; + + TestClassAlias: _ClassBuilder<"TestClassAlias", false>; + + TestClassNested: _ClassBuilder<"TestClassNested", false>; + + TestClassWithEnum: _ClassBuilder<"TestClassWithEnum", false>; + + TestMemoryOutput: _ClassBuilder<"TestMemoryOutput", false>; + + TestOutputClass: _ClassBuilder<"TestOutputClass", false>; + + Tree: _ClassBuilder<"Tree", false>; + + TwoStoriesOneTitle: _ClassBuilder<"TwoStoriesOneTitle", false>; + + TwoStoriesOneTitleCheck: _ClassBuilder<"TwoStoriesOneTitleCheck", false>; + + UnionTest_ReturnType: _ClassBuilder<"UnionTest_ReturnType", false>; + + UniverseQuestion: _ClassBuilder<"UniverseQuestion", false>; + + UniverseQuestionInput: _ClassBuilder<"UniverseQuestionInput", false>; + + WithReasoning: _ClassBuilder<"WithReasoning", false>; + + AliasedEnum: _EnumBuilder<"AliasedEnum", false>; + + Category: _EnumBuilder<"Category", false>; + + Category2: _EnumBuilder<"Category2", false>; + + Category3: _EnumBuilder<"Category3", false>; + + Color: _EnumBuilder<"Color", true>; + + DataType: _EnumBuilder<"DataType", false>; + + DynEnumOne: _EnumBuilder<"DynEnumOne", true>; + + DynEnumThree: _EnumBuilder<"DynEnumThree", true>; + + DynEnumTwo: _EnumBuilder<"DynEnumTwo", true>; + + EnumInClass: _EnumBuilder<"EnumInClass", false>; + + EnumOutput: _EnumBuilder<"EnumOutput", false>; + + Hobby: _EnumBuilder<"Hobby", true>; + + MapKey: _EnumBuilder<"MapKey", false>; + + NamedArgsSingleEnum: _EnumBuilder<"NamedArgsSingleEnum", false>; + + NamedArgsSingleEnumList: _EnumBuilder<"NamedArgsSingleEnumList", false>; + + OptionalTest_CategoryType: _EnumBuilder<"OptionalTest_CategoryType", false>; + + OrderStatus: _EnumBuilder<"OrderStatus", false>; + + RenderStatusEnum: _EnumBuilder<"RenderStatusEnum", true>; + + RenderTestEnum: _EnumBuilder<"RenderTestEnum", true>; + + Tag: _EnumBuilder<"Tag", false>; + + TestEnum: _EnumBuilder<"TestEnum", false>; + + constructor() { + this.tb = new _TypeBuilder({ + runtime: DO_NOT_USE_DIRECTLY_UNLESS_YOU_KNOW_WHAT_YOURE_DOING_RUNTIME, + }); + + this.AnotherObject = _getClass(this.tb, "AnotherObject"); + + this.BigNumbers = _getClass(this.tb, "BigNumbers"); + + this.BinaryNode = _getClass(this.tb, "BinaryNode"); + + this.Blah = _getClass(this.tb, "Blah"); + + this.BlockConstraint = _getClass(this.tb, "BlockConstraint"); + + this.BlockConstraintForParam = _getClass( + this.tb, + "BlockConstraintForParam" + ); + + this.BookOrder = _getClass(this.tb, "BookOrder"); + + this.ClassForNullLiteral = _getClass(this.tb, "ClassForNullLiteral"); + + this.ClassOptionalOutput = _getClass(this.tb, "ClassOptionalOutput"); + + this.ClassOptionalOutput2 = _getClass( + this.tb, + "ClassOptionalOutput2" + ); + + this.ClassToRecAlias = _getClass(this.tb, "ClassToRecAlias"); + + this.ClassWithBlockDone = _getClass(this.tb, "ClassWithBlockDone"); + + this.ClassWithImage = _getClass(this.tb, "ClassWithImage"); + + this.ClassWithoutDone = _getClass(this.tb, "ClassWithoutDone"); + + this.ClientDetails1559 = _getClass(this.tb, "ClientDetails1559"); + + this.ComplexMemoryObject = _getClass(this.tb, "ComplexMemoryObject"); + + this.CompoundBigNumbers = _getClass(this.tb, "CompoundBigNumbers"); + + this.ContactInfo = _getClass(this.tb, "ContactInfo"); + + this.CustomStory = _getClass(this.tb, "CustomStory"); + + this.CustomTaskResult = _getClass(this.tb, "CustomTaskResult"); + + this.Document1559 = _getClass(this.tb, "Document1559"); + + this.DummyOutput = _getClass(this.tb, "DummyOutput"); + + this.DynInputOutput = _getClass(this.tb, "DynInputOutput"); + + this.DynamicClassOne = _getClass(this.tb, "DynamicClassOne"); + + this.DynamicClassTwo = _getClass(this.tb, "DynamicClassTwo"); + + this.DynamicOutput = _getClass(this.tb, "DynamicOutput"); + + this.DynamicSchema = _getClass(this.tb, "DynamicSchema"); + + this.Earthling = _getClass(this.tb, "Earthling"); + + this.Education = _getClass(this.tb, "Education"); + + this.Email = _getClass(this.tb, "Email"); + + this.EmailAddress = _getClass(this.tb, "EmailAddress"); + + this.Event = _getClass(this.tb, "Event"); + + this.FakeImage = _getClass(this.tb, "FakeImage"); + + this.FlightConfirmation = _getClass(this.tb, "FlightConfirmation"); + + this.FooAny = _getClass(this.tb, "FooAny"); + + this.Forest = _getClass(this.tb, "Forest"); + + this.FormatterTest0 = _getClass(this.tb, "FormatterTest0"); + + this.FormatterTest1 = _getClass(this.tb, "FormatterTest1"); + + this.FormatterTest2 = _getClass(this.tb, "FormatterTest2"); + + this.FormatterTest3 = _getClass(this.tb, "FormatterTest3"); + + this.GroceryReceipt = _getClass(this.tb, "GroceryReceipt"); + + this.Haiku = _getClass(this.tb, "Haiku"); + + this.InnerClass = _getClass(this.tb, "InnerClass"); + + this.InnerClass2 = _getClass(this.tb, "InnerClass2"); + + this.InputClass = _getClass(this.tb, "InputClass"); + + this.InputClassNested = _getClass(this.tb, "InputClassNested"); + + this.LinkedList = _getClass(this.tb, "LinkedList"); + + this.LinkedListAliasNode = _getClass(this.tb, "LinkedListAliasNode"); + + this.LiteralClassHello = _getClass(this.tb, "LiteralClassHello"); + + this.LiteralClassOne = _getClass(this.tb, "LiteralClassOne"); + + this.LiteralClassTwo = _getClass(this.tb, "LiteralClassTwo"); + + this.MaintainFieldOrder = _getClass(this.tb, "MaintainFieldOrder"); + + this.MalformedConstraints = _getClass( + this.tb, + "MalformedConstraints" + ); + + this.MalformedConstraints2 = _getClass( + this.tb, + "MalformedConstraints2" + ); + + this.Martian = _getClass(this.tb, "Martian"); + + this.MemoryObject = _getClass(this.tb, "MemoryObject"); + + this.MergeAttrs = _getClass(this.tb, "MergeAttrs"); + + this.NamedArgsSingleClass = _getClass( + this.tb, + "NamedArgsSingleClass" + ); + + this.Nested = _getClass(this.tb, "Nested"); + + this.Nested2 = _getClass(this.tb, "Nested2"); + + this.NestedBlockConstraint = _getClass( + this.tb, + "NestedBlockConstraint" + ); + + this.NestedBlockConstraintForParam = _getClass( + this.tb, + "NestedBlockConstraintForParam" + ); + + this.Node = _getClass(this.tb, "Node"); + + this.NodeWithAliasIndirection = _getClass( + this.tb, + "NodeWithAliasIndirection" + ); + + this.Note1599 = _getClass(this.tb, "Note1599"); + + this.OptionalListAndMap = _getClass(this.tb, "OptionalListAndMap"); + + this.OptionalTest_Prop1 = _getClass(this.tb, "OptionalTest_Prop1"); + + this.OptionalTest_ReturnType = _getClass( + this.tb, + "OptionalTest_ReturnType" + ); + + this.OrderInfo = _getClass(this.tb, "OrderInfo"); + + this.OriginalA = _getClass(this.tb, "OriginalA"); + + this.OriginalB = _getClass(this.tb, "OriginalB"); + + this.Person = _getClass(this.tb, "Person"); + + this.PhoneNumber = _getClass(this.tb, "PhoneNumber"); + + this.Quantity = _getClass(this.tb, "Quantity"); + + this.RaysData = _getClass(this.tb, "RaysData"); + + this.ReceiptInfo = _getClass(this.tb, "ReceiptInfo"); + + this.ReceiptItem = _getClass(this.tb, "ReceiptItem"); + + this.Recipe = _getClass(this.tb, "Recipe"); + + this.RecursiveAliasDependency = _getClass( + this.tb, + "RecursiveAliasDependency" + ); + + this.RenderEnumInput = _getClass(this.tb, "RenderEnumInput"); + + this.RenderTestClass = _getClass(this.tb, "RenderTestClass"); + + this.Resume = _getClass(this.tb, "Resume"); + + this.Schema = _getClass(this.tb, "Schema"); + + this.SearchParams = _getClass(this.tb, "SearchParams"); + + this.SemanticContainer = _getClass(this.tb, "SemanticContainer"); + + this.SimpleTag = _getClass(this.tb, "SimpleTag"); + + this.SmallThing = _getClass(this.tb, "SmallThing"); + + this.SomeClassNestedDynamic = _getClass( + this.tb, + "SomeClassNestedDynamic" + ); + + this.StringToClassEntry = _getClass(this.tb, "StringToClassEntry"); + + this.TestClassAlias = _getClass(this.tb, "TestClassAlias"); + + this.TestClassNested = _getClass(this.tb, "TestClassNested"); + + this.TestClassWithEnum = _getClass(this.tb, "TestClassWithEnum"); + + this.TestMemoryOutput = _getClass(this.tb, "TestMemoryOutput"); + + this.TestOutputClass = _getClass(this.tb, "TestOutputClass"); + + this.Tree = _getClass(this.tb, "Tree"); + + this.TwoStoriesOneTitle = _getClass(this.tb, "TwoStoriesOneTitle"); + + this.TwoStoriesOneTitleCheck = _getClass( + this.tb, + "TwoStoriesOneTitleCheck" + ); + + this.UnionTest_ReturnType = _getClass( + this.tb, + "UnionTest_ReturnType" + ); + + this.UniverseQuestion = _getClass(this.tb, "UniverseQuestion"); + + this.UniverseQuestionInput = _getClass( + this.tb, + "UniverseQuestionInput" + ); + + this.WithReasoning = _getClass(this.tb, "WithReasoning"); + + this.AliasedEnum = _getEnum(this.tb, "AliasedEnum"); + + this.Category = _getEnum(this.tb, "Category"); + + this.Category2 = _getEnum(this.tb, "Category2"); + + this.Category3 = _getEnum(this.tb, "Category3"); + + this.Color = _getEnum(this.tb, "Color"); + + this.DataType = _getEnum(this.tb, "DataType"); + + this.DynEnumOne = _getEnum(this.tb, "DynEnumOne"); + + this.DynEnumThree = _getEnum(this.tb, "DynEnumThree"); + + this.DynEnumTwo = _getEnum(this.tb, "DynEnumTwo"); + + this.EnumInClass = _getEnum(this.tb, "EnumInClass"); + + this.EnumOutput = _getEnum(this.tb, "EnumOutput"); + + this.Hobby = _getEnum(this.tb, "Hobby"); + + this.MapKey = _getEnum(this.tb, "MapKey"); + + this.NamedArgsSingleEnum = _getEnum(this.tb, "NamedArgsSingleEnum"); + + this.NamedArgsSingleEnumList = _getEnum( + this.tb, + "NamedArgsSingleEnumList" + ); + + this.OptionalTest_CategoryType = _getEnum( + this.tb, + "OptionalTest_CategoryType" + ); + + this.OrderStatus = _getEnum(this.tb, "OrderStatus"); + + this.RenderStatusEnum = _getEnum(this.tb, "RenderStatusEnum"); + + this.RenderTestEnum = _getEnum(this.tb, "RenderTestEnum"); + + this.Tag = _getEnum(this.tb, "Tag"); + + this.TestEnum = _getEnum(this.tb, "TestEnum"); + } + + reset(): void { + this.tb.reset(); + } + + __tb() { + return this.tb._tb(); + } + + string(): FieldType { + return this.tb.string(); + } + + literalString(value: string): FieldType { + return this.tb.literalString(value); + } + + literalInt(value: number): FieldType { + return this.tb.literalInt(value); + } + + literalBool(value: boolean): FieldType { + return this.tb.literalBool(value); + } + + int(): FieldType { + return this.tb.int(); + } + + float(): FieldType { + return this.tb.float(); + } + + bool(): FieldType { + return this.tb.bool(); + } + + list(type: FieldType): FieldType { + return this.tb.list(type); + } + + null(): FieldType { + return this.tb.null(); + } + + map(key: FieldType, value: FieldType): FieldType { + return this.tb.map(key, value); + } + + union(types: FieldType[]): FieldType { + return this.tb.union(types); + } + + addClass( + name: string, + properties?: Record< + string, + | FieldType + | { + type: FieldType; + description?: string | null; + alias?: string | null; + } + > + ): ClassBuilder { + let cb = this.tb.addClass(name); + if (properties) { + for (const [name, props] of Object.entries(properties)) { + if ("type" in props) { + let cpb = cb.addProperty(name, props.type); + if (props.description) { + cpb.setDescription(props.description); + } + if (props.alias) { + cpb.setAlias(props.alias); + } + } else { + cb.addProperty(name, props); + } + } } + return cb; + } - addBaml(baml: string): void { - this.tb.addBaml(baml); + addEnum( + name: string, + values?: ( + | string + | { + value: string; + description?: string | null; + alias?: string | null; + } + )[] + ): EnumBuilder { + let eb = this.tb.addEnum(name); + if (values) { + for (const value of values) { + if (typeof value === "string") { + eb.addValue(value); + } else { + let evb = eb.addValue(value.value); + if (value.description) { + evb.setDescription(value.description); + } + if (value.alias) { + evb.setAlias(value.alias); + } + } + } } -} \ No newline at end of file + return eb; + } + + addBaml(baml: string): void { + this.tb.addBaml(baml); + } +} diff --git a/integ-tests/typescript/tests/dynamic-types.test.ts b/integ-tests/typescript/tests/dynamic-types.test.ts index 853cfcc096..bfc15f62d1 100644 --- a/integ-tests/typescript/tests/dynamic-types.test.ts +++ b/integ-tests/typescript/tests/dynamic-types.test.ts @@ -24,19 +24,21 @@ describe("Dynamic Type Tests", () => { it("should work with dynamic types single", async () => { let tb = new TypeBuilder(); tb.Person.addProperty("last_name", tb.string().optional()); - tb.Person.addProperty("height", tb.float().optional()).description( - "Height in meters", + tb.Person.addProperty("height", tb.float().optional()).setDescription( + "Height in meters" ); tb.Hobby.addValue("CHESS"); - tb.Hobby.listValues().map(([name, v]) => v.alias(name.toLowerCase())); + let v = tb.Hobby.getValue("MUSIC"); + v.setAlias("Music"); + tb.Hobby.listValues().map(([name, v]) => v.setAlias(name.toLowerCase())); tb.Person.addProperty( "hobbies", - tb.Hobby.type().list().optional(), - ).description("Some suggested hobbies they might be good at"); + tb.Hobby.type().list().optional() + ).setDescription("Some suggested hobbies they might be good at"); const res = await b.ExtractPeople( "My name is Harrison. My hair is black and I'm 6 feet tall. I'm pretty good around the hoop.", - { tb }, + { tb } ); expect(res.length).toBeGreaterThan(0); }); @@ -51,7 +53,7 @@ describe("Dynamic Type Tests", () => { tb.Person.addProperty("animalLiked", fieldEnum.type()); const res = await b.ExtractPeople( "My name is Harrison. My hair is black and I'm 6 feet tall. I'm pretty good around the hoop. I like giraffes.", - { tb }, + { tb } ); expect(res.length).toBeGreaterThan(0); expect(res[0]["animalLiked"]).toEqual("GIRAFFE"); @@ -62,11 +64,11 @@ describe("Dynamic Type Tests", () => { const animalClass = tb.addClass("Animal"); animalClass .addProperty("animal", tb.string()) - .description("The animal mentioned, in singular form."); + .setDescription("The animal mentioned, in singular form."); tb.Person.addProperty("animalLiked", animalClass.type()); const res = await b.ExtractPeople( "My name is Harrison. My hair is black and I'm 6 feet tall. I'm pretty good around the hoop. I like giraffes.", - { tb }, + { tb } ); expect(res.length).toBeGreaterThan(0); const animalLiked = res[0]["animalLiked"]; @@ -77,13 +79,13 @@ describe("Dynamic Type Tests", () => { let tb = new TypeBuilder(); const animals = tb.union( ["giraffe", "elephant", "lion"].map((animal) => - tb.literalString(animal.toUpperCase()), - ), + tb.literalString(animal.toUpperCase()) + ) ); tb.Person.addProperty("animalLiked", animals); const res = await b.ExtractPeople( "My name is Harrison. My hair is black and I'm 6 feet tall. I'm pretty good around the hoop. I like giraffes.", - { tb }, + { tb } ); expect(res.length).toBeGreaterThan(0); expect(res[0]["animalLiked"]).toEqual("GIRAFFE"); @@ -95,7 +97,7 @@ describe("Dynamic Type Tests", () => { const res = await b.DynamicInputOutput( { "new-key": "hi", testKey: "myTest" }, - { tb }, + { tb } ); expect(res["new-key"]).toEqual("hi"); expect(res["testKey"]).toEqual("myTest"); @@ -109,7 +111,7 @@ describe("Dynamic Type Tests", () => { const res = await b.DynamicListInputOutput( [{ "new-key": "hi", testKey: "myTest" }], - { tb }, + { tb } ); expect(res[0]["new-key"]).toEqual("hi"); expect(res[0]["testKey"]).toEqual("myTest"); @@ -120,12 +122,12 @@ describe("Dynamic Type Tests", () => { tb.DynamicOutput.addProperty("hair_color", tb.string()); tb.DynamicOutput.addProperty( "attributes", - tb.map(tb.string(), tb.string()), - ).description("Things like 'eye_color' or 'facial_hair'"); + tb.map(tb.string(), tb.string()) + ).setDescription("Things like 'eye_color' or 'facial_hair'"); const res = await b.MyFunc( "My name is Harrison. My hair is black and I'm 6 feet tall. I have blue eyes and a beard.", - { tb }, + { tb } ); expect(res.hair_color).toEqual("black"); @@ -145,19 +147,19 @@ describe("Dynamic Type Tests", () => { tb.DynamicOutput.addProperty( "height", - tb.union([class1.type(), class2.type()]), + tb.union([class1.type(), class2.type()]) ); let res = await b.MyFunc( "My name is Harrison. My hair is black and I'm 6 feet tall.", - { tb }, + { tb } ); expect(res.height["feet"]).toEqual(6); res = await b.MyFunc( "My name is Harrison. My hair is black and I'm 1.8 meters tall.", - { tb }, + { tb } ); expect(res.height["meters"]).toEqual(1.8); @@ -180,7 +182,7 @@ describe("Dynamic Type Tests", () => { `); let res = await b.ExtractPeople( "My name is John Doe. I'm 30 years old. I'm 6 feet tall and weigh 180 pounds. My hair is yellow.", - { tb }, + { tb } ); expect(res).toEqual([ { @@ -236,7 +238,7 @@ describe("Dynamic Type Tests", () => { `); let res = await b.ExtractPeople( "My name is John Doe. I'm 30 years old. My height is 6 feet and I weigh 180 pounds. My hair is brown. I work as a programmer and enjoy bike riding.", - { tb }, + { tb } ); expect(res).toEqual([ { @@ -264,7 +266,7 @@ describe("Dynamic Type Tests", () => { `); let res = await b.ExtractPeople( "My name is John Doe. I'm 30 years old. I'm 6 feet tall and weigh 180 pounds. My hair is yellow.", - { tb }, + { tb } ); expect(res).toEqual([ { @@ -279,22 +281,40 @@ describe("Dynamic Type Tests", () => { describe("TypeBuilder APIs", () => { it("should list properties", () => { let tb = new TypeBuilder(); + + let adsf = tb.addEnum("adsf"); + adsf.addValue("asdf"); + adsf.getValue("myValue"); + + let defff = tb.addClass("defff", { + foo: tb.string(), + bar: tb.int(), + }); + defff.addProperty("myProperty", tb.string()); + defff.getProperty("myProperty"); + tb.Person.addProperty("last_name", tb.string().list()); - tb.Person.addProperty("height", tb.float().optional()).description("Height in meters"); + tb.Person.addProperty("height", tb.float().optional()).setDescription( + "Height in meters" + ); const props = Object.fromEntries(tb.Person.listProperties()); - expect(props["last_name"].getType().equals(tb.string().list())).toBeTruthy(); - expect(props["height"].getType().equals(tb.float().optional())).toBeTruthy(); + expect(props["last_name"].type().equals(tb.string().list())).toBeTruthy(); + expect(props["height"].type().equals(tb.float().optional())).toBeTruthy(); }); it("should reset", () => { let tb = new TypeBuilder(); tb.Person.addProperty("last_name", tb.string().list()); - tb.Person.addProperty("height", tb.float().optional()).description("Height in meters"); + tb.Person.addProperty("height", tb.float().optional()).setDescription( + "Height in meters" + ); tb.reset(); - const personPropsAfterTbReset = tb.Person.listProperties().map(([name, _]) => name); + const personPropsAfterTbReset = tb.Person.listProperties().map( + ([name, _]) => name + ); expect(personPropsAfterTbReset.includes("last_name")).toBeFalsy(); expect(personPropsAfterTbReset.includes("height")).toBeFalsy(); @@ -303,27 +323,39 @@ describe("Dynamic Type Tests", () => { it("should reset a class", () => { const tb = new TypeBuilder(); tb.Person.addProperty("last_name", tb.string().list()); - tb.Person.addProperty("height", tb.float().optional()).description("Height in meters"); + tb.Person.addProperty("height", tb.float().optional()).setDescription( + "Height in meters" + ); tb.DynamicOutput.addProperty("hair_color", tb.string()); - tb.DynamicOutput.addProperty("height", tb.float().optional()).description("Height in meters"); + tb.DynamicOutput.addProperty( + "height", + tb.float().optional() + ).setDescription("Height in meters"); tb.Person.reset(); - const personPropsAfterClassReset = tb.Person.listProperties().map(([name, _]) => name); - const dynamicOutputPropsAfterClassReset = tb.DynamicOutput.listProperties().map(([name, _]) => name); + const personPropsAfterClassReset = tb.Person.listProperties().map( + ([name, _]) => name + ); + const dynamicOutputPropsAfterClassReset = + tb.DynamicOutput.listProperties().map(([name, _]) => name); expect(personPropsAfterClassReset.includes("last_name")).toBeFalsy(); expect(personPropsAfterClassReset.includes("height")).toBeFalsy(); - expect(dynamicOutputPropsAfterClassReset.includes("hair_color")).toBeTruthy(); + expect( + dynamicOutputPropsAfterClassReset.includes("hair_color") + ).toBeTruthy(); expect(dynamicOutputPropsAfterClassReset.includes("height")).toBeTruthy(); }); it("should remove a property from a class", () => { const tb = new TypeBuilder(); tb.Person.addProperty("last_name", tb.string().list()); - tb.Person.addProperty("height", tb.float().optional()).description("Height in meters"); + tb.Person.addProperty("height", tb.float().optional()).setDescription( + "Height in meters" + ); tb.Person.removeProperty("last_name"); @@ -337,7 +369,9 @@ describe("Dynamic Type Tests", () => { const tb = new TypeBuilder(); const personClass = tb.addClass("AddedPerson"); personClass.addProperty("last_name", tb.string().list()); - personClass.addProperty("height", tb.float().optional()).description("Height in meters"); + personClass + .addProperty("height", tb.float().optional()) + .setDescription("Height in meters"); personClass.reset(); @@ -351,7 +385,9 @@ describe("Dynamic Type Tests", () => { const tb = new TypeBuilder(); const personClass = tb.addClass("AddedPerson"); personClass.addProperty("last_name", tb.string().list()); - personClass.addProperty("height", tb.float().optional()).description("Height in meters"); + personClass + .addProperty("height", tb.float().optional()) + .setDescription("Height in meters"); personClass.removeProperty("last_name"); const personProps = personClass.listProperties().map(([name, _]) => name); @@ -363,18 +399,22 @@ describe("Dynamic Type Tests", () => { it("should get property types from a class", () => { const tb = new TypeBuilder(); tb.Person.addProperty("last_name", tb.string().list()); - tb.Person.addProperty("height", tb.float().optional()).description("Height in meters"); + tb.Person.addProperty("height", tb.float().optional()).setDescription( + "Height in meters" + ); const props = Object.fromEntries(tb.Person.listProperties()); - expect(props["last_name"].getType().equals(tb.string().list())).toBeTruthy(); - expect(props["height"].getType().equals(tb.float().optional())).toBeTruthy(); + expect(props["last_name"].type().equals(tb.string().list())).toBeTruthy(); + expect(props["height"].type().equals(tb.float().optional())).toBeTruthy(); }); it("should set property types", () => { const tb = new TypeBuilder(); tb.Person.addProperty("last_name", tb.string().list()); - tb.Person.addProperty("height", tb.float().optional()).description("Height in meters"); + tb.Person.addProperty("height", tb.float().optional()).setDescription( + "Height in meters" + ); // Modify props let props = Object.fromEntries(tb.Person.listProperties()); @@ -383,8 +423,8 @@ describe("Dynamic Type Tests", () => { // Verify changes props = Object.fromEntries(tb.Person.listProperties()); - expect(props["last_name"].getType().equals(tb.string())).toBeTruthy(); - expect(props["height"].getType().equals(tb.int())).toBeTruthy(); + expect(props["last_name"].type().equals(tb.string())).toBeTruthy(); + expect(props["height"].type().equals(tb.int())).toBeTruthy(); }); }); });