Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-llguidance for openSUSE:Factory checked in at 2026-10-02 23:04:25 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-llguidance (Old) and /work/SRC/openSUSE:Factory/.python-llguidance.new.1631729 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-llguidance" Fri Oct 2 23:04:25 2026 rev:4 rq:1382004 version:1.9.1 Changes: -------- --- /work/SRC/openSUSE:Factory/python-llguidance/python-llguidance.changes 2026-10-01 16:46:09.663817722 +0200 +++ /work/SRC/openSUSE:Factory/.python-llguidance.new.1631729/python-llguidance.changes 2026-10-02 23:05:28.020624810 +0200 @@ -1,0 +2,15 @@ +Fri Oct 2 05:45:42 UTC 2026 - Martin Pluskal <[email protected]> + +- Update to 1.9.1: + * Expose cooperative cancellation on TokenParser: + enable_cancellation() is idempotent and cancellation_handle() + returns the parser's existing cancellation state once + enabled. Cancellation stays opt-in and parser behaviour is + unchanged when it is not enabled +- Re-generate registry.tar.zst for 1.9.1 via the cargo_vendor + service: pyo3 0.29.2 -> 0.29.3 and lazy_static 1.5.0 -> + 1.5.1, all permissive. License is unchanged, but correct the + Legal-Review-Notice MIT count, which understated it: 22 of + the 111 linked crates grant MIT, not 21 + +------------------------------------------------------------------- Old: ---- llguidance-1.9.0.tar.gz New: ---- llguidance-1.9.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-llguidance.spec ++++++ --- /var/tmp/diff_new_pack.7RCAR8/_old 2026-10-02 23:05:35.082920026 +0200 +++ /var/tmp/diff_new_pack.7RCAR8/_new 2026-10-02 23:05:35.086920193 +0200 @@ -18,28 +18,30 @@ %{?sle15_python_module_pythons} Name: python-llguidance -Version: 1.9.0 +Version: 1.9.1 Release: 0 Summary: Low-level Guidance (llguidance) bindings for constrained decoding -# Legal-Review-Notice: re-derived for 1.9.0 against the regenerated +# Legal-Review-Notice: re-derived for 1.9.1 against the regenerated # registry.tar.zst. maturin builds only python_ext/Cargo.toml, so the tag # covers the 111 crates the build actually compiles (the 108 normal # dependencies of llguidance_py plus the build-only pyo3-build-config, # target-lexicon and version_check). None of them is copyleft or weak -# copyleft. Mandatory terms: MIT (the workspace members themselves plus 21 -# crates), Apache-2.0 (tokenizers, esaxx-rs, spm_precompiled), MIT-0 -# (borrow-or-share) and Unicode-3.0 (unicode-ident, "(MIT OR Apache-2.0) -# AND Unicode-3.0"); every remaining crate offers MIT or Apache-2.0 among +# copyleft. Mandatory terms: MIT (22 of the 111: the five workspace +# members plus 17 crates, one of which, unicode-ident, grants it as +# "(MIT OR Apache-2.0) AND Unicode-3.0"), Apache-2.0 (tokenizers, +# esaxx-rs, spm_precompiled), MIT-0 (borrow-or-share) and Unicode-3.0 +# (unicode-ident); every remaining crate offers MIT or Apache-2.0 among # its choices, so its Zlib, BSL-1.0, BSD-2-Clause, Unlicense or 0BSD # alternative never becomes the mandatory term. # target-lexicon is "Apache-2.0 WITH LLVM-exception", build-time only and # covered by the declared Apache-2.0. # The MPL-2.0 (cbindgen, option-ext, smartstring), BSD-3-Clause -# (encoding_rs, instant, subtle), CDLA-Permissive-2.0 (webpki-roots) and -# ISC (ring, untrusted, rustls-webpki) crates in the registry are never -# compiled here: they belong to the HTTP/TLS stack of the -# toktrie_hf_downloader member and to the cbindgen header generator and -# impose no obligation on the shipped extension module. +# (encoding_rs, instant, subtle), CDLA-Permissive-2.0 (webpki-roots), ISC +# (ring, untrusted, rustls-webpki) and LGPL-2.1-or-later (r-efi, an +# alternative term) crates in the registry are never compiled here: they +# belong to the HTTP/TLS stack of the toktrie_hf_downloader member and to +# the cbindgen header generator and impose no obligation on the shipped +# extension module. License: Apache-2.0 AND MIT AND MIT-0 AND Unicode-3.0 URL: https://github.com/guidance-ai/llguidance Source0: https://github.com/guidance-ai/llguidance/archive/refs/tags/v%{version}.tar.gz#/llguidance-%{version}.tar.gz ++++++ _service ++++++ --- /var/tmp/diff_new_pack.7RCAR8/_old 2026-10-02 23:05:35.162923370 +0200 +++ /var/tmp/diff_new_pack.7RCAR8/_new 2026-10-02 23:05:35.168923621 +0200 @@ -1,7 +1,7 @@ <?xml version="1.0"?> <services> <service name="cargo_vendor" mode="manual"> - <param name="src">llguidance-1.9.0.tar.gz</param> + <param name="src">llguidance-1.9.1.tar.gz</param> <param name="method">registry</param> <param name="update">true</param> <param name="compression">zst</param> ++++++ llguidance-1.9.0.tar.gz -> llguidance-1.9.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/CHANGELOG.md new/llguidance-1.9.1/CHANGELOG.md --- old/llguidance-1.9.0/CHANGELOG.md 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/CHANGELOG.md 2026-09-30 20:51:46.000000000 +0200 @@ -4,6 +4,10 @@ If a release doesn't introduce any interesting changes (build fixes etc.), it's skipped. +#### [v1.9.1](https://github.com/guidance-ai/llguidance/compare/v1.9.0...v1.9.1) 2026-09-30 + +- Expose cooperative cancellation on TokenParser [`#387`](https://github.com/guidance-ai/llguidance/pull/387) + #### [v1.9.0](https://github.com/guidance-ai/llguidance/compare/v1.8.0...v1.9.0) 2026-09-29 - Add opt-in cancellation for abandoned matcher computations [`#382`](https://github.com/guidance-ai/llguidance/pull/382); fixes [`#261`](https://github.com/guidance-ai/llguidance/issues/261) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/Cargo.lock new/llguidance-1.9.1/Cargo.lock --- old/llguidance-1.9.0/Cargo.lock 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/Cargo.lock 2026-09-30 20:51:46.000000000 +0200 @@ -1394,7 +1394,7 @@ [[package]] name = "llguidance" -version = "1.9.0" +version = "1.9.1" dependencies = [ "anyhow", "cbindgen", @@ -1420,7 +1420,7 @@ [[package]] name = "llguidance_py" -version = "1.9.0" +version = "1.9.1" dependencies = [ "anyhow", "bytemuck", @@ -2715,7 +2715,7 @@ [[package]] name = "toktrie" -version = "1.9.0" +version = "1.9.1" dependencies = [ "anyhow", "bytemuck", @@ -2726,7 +2726,7 @@ [[package]] name = "toktrie_hf_downloader" -version = "1.9.0" +version = "1.9.1" dependencies = [ "anyhow", "hf-hub", @@ -2737,7 +2737,7 @@ [[package]] name = "toktrie_hf_tokenizers" -version = "1.9.0" +version = "1.9.1" dependencies = [ "anyhow", "log", @@ -2750,7 +2750,7 @@ [[package]] name = "toktrie_tiktoken" -version = "1.9.0" +version = "1.9.1" dependencies = [ "anyhow", "log", diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/parser/Cargo.toml new/llguidance-1.9.1/parser/Cargo.toml --- old/llguidance-1.9.0/parser/Cargo.toml 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/parser/Cargo.toml 2026-09-30 20:51:46.000000000 +0200 @@ -1,6 +1,6 @@ [package] name = "llguidance" -version = "1.9.0" +version = "1.9.1" edition = "2021" license = "MIT" description = "Super-fast Structured Outputs" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/parser/src/cancellation.rs new/llguidance-1.9.1/parser/src/cancellation.rs --- old/llguidance-1.9.0/parser/src/cancellation.rs 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/parser/src/cancellation.rs 2026-09-30 20:51:46.000000000 +0200 @@ -3,10 +3,11 @@ Arc, }; -/// A permanent cancellation request for one matcher. +/// A permanent cancellation request for one parser or matcher. /// -/// Cloned handles control the same matcher. The handle can outlive its matcher. -/// Cancellation does not wait for the worker. Join the worker before accessing the matcher. +/// Cloned handles control the same cancellation state. The handle can outlive the parser or +/// matcher. Cancellation does not wait for the worker; join it before accessing the cancelled +/// object. #[derive(Clone, Debug, Default)] pub struct CancellationHandle(Arc<AtomicBool>); @@ -29,7 +30,7 @@ } } -/// The matcher observed a permanent cancellation request. +/// A parser or matcher observed a permanent cancellation request. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Cancelled; @@ -112,6 +113,45 @@ matcher } + fn token_parser(grammar: &str) -> crate::TokenParser { + let env = ApproximateTokEnv::single_byte_env(); + let factory = ParserFactory::new(&env, InferenceCapabilities::default(), &[]).unwrap(); + let mut parser = factory + .create_parser(TopLevelGrammar::from_lark(grammar.to_string())) + .unwrap(); + parser.start_without_prompt(); + parser + } + + fn interrupt_token_parser<T: Send + 'static>( + mut parser: crate::TokenParser, + operation: fn(&mut crate::TokenParser) -> anyhow::Result<T>, + ) -> (anyhow::Result<T>, crate::TokenParser) { + let handle = parser.cancellation_handle().unwrap(); + let (reached_tx, reached_rx) = mpsc::sync_channel(0); + let (resume_tx, resume_rx) = mpsc::sync_channel(0); + let worker = thread::spawn(move || { + PROGRESS.with_borrow_mut(|progress| { + *progress = Some(Progress { + point: "trie", + work: 0, + threshold: 1, + reached: reached_tx, + resume: resume_rx, + }); + }); + let result = operation(&mut parser); + (result, parser) + }); + + let reached = reached_rx.recv_timeout(Duration::from_secs(10)); + handle.cancel(); + let _ = resume_tx.send(()); + let result = worker.join().unwrap(); + reached.unwrap(); + result + } + #[test] fn forced_results_keep_failure_in_matcher_state() { let mut tested = matcher(r#"start: "abcdef""#, &[], true); @@ -170,6 +210,63 @@ } #[test] + fn token_parser_clones_snapshot_cancellation_independently() { + let mut parser = token_parser("start: /[a-z]+/"); + assert!(parser.cancellation_handle().is_none()); + + let first = parser.enable_cancellation(); + let second = parser.enable_cancellation(); + let mut shallow = parser.clone(); + + first.cancel(); + let mut deep = parser.deep_clone(); + let shallow_handle = shallow.cancellation_handle().unwrap(); + let deep_handle = deep.cancellation_handle().unwrap(); + assert!(second.is_cancelled()); + assert!(!shallow_handle.is_cancelled()); + assert!(deep_handle.is_cancelled()); + assert_cancelled(parser.compute_mask()); + assert!(shallow.compute_mask().is_ok()); + assert_cancelled(deep.compute_mask()); + } + + #[test] + fn token_parser_does_not_publish_mask_after_in_flight_cancellation() { + let mut parser = token_parser("start: /[a-z]+/"); + parser.enable_cancellation(); + let (result, parser) = interrupt_token_parser(parser, crate::TokenParser::compute_mask); + + assert_cancelled(result); + assert_eq!(parser.stop_reason(), StopReason::Cancelled); + } + + #[test] + fn token_parser_does_not_publish_partial_validation_after_cancellation() { + let mut parser = token_parser("start: /[a-z]+/"); + parser.enable_cancellation(); + let (result, parser) = interrupt_token_parser(parser, |parser| { + parser.validate_tokens_raw(&[b'a' as u32; 32]) + }); + + assert_cancelled(result); + assert_eq!(parser.stop_reason(), StopReason::Cancelled); + } + + #[test] + fn matcher_adopts_token_parser_cancellation() { + let mut parser = token_parser("start: /[a-z]+/"); + let handle = parser.enable_cancellation(); + let mut matcher = Matcher::new(Ok(parser)); + let mut independent = matcher.clone(); + + assert!(matcher.cancellation_handle().is_some()); + handle.cancel(); + assert!(matcher.is_cancelled()); + assert_cancelled(matcher.compute_mask()); + assert!(independent.compute_mask().is_ok()); + } + + #[test] fn terminal_cancellation_and_clone_ownership() { let mut original = matcher("start: /[a-z]+/", &[], false); let mut shallow = original.clone(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/parser/src/earley/parser.rs new/llguidance-1.9.1/parser/src/earley/parser.rs --- old/llguidance-1.9.0/parser/src/earley/parser.rs 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/parser/src/earley/parser.rs 2026-09-30 20:51:46.000000000 +0200 @@ -424,12 +424,25 @@ } } -#[derive(Clone)] pub struct Parser { shared: Arc<Mutex<Box<SharedState>>>, state: ParserState, } +impl Clone for Parser { + fn clone(&self) -> Self { + let mut state = self.state.clone(); + state.cancellation = state + .cancellation + .as_ref() + .map(CancellationHandle::snapshot); + Self { + shared: self.shared.clone(), + state, + } + } +} + impl Scratch { fn new(grammar: Arc<CGrammar>) -> Self { Scratch { @@ -2908,6 +2921,19 @@ self.state.cancellation = Some(handle); } + pub(crate) fn enable_cancellation(&mut self) -> CancellationHandle { + if let Some(handle) = self.state.cancellation.as_ref() { + return handle.clone(); + } + let handle = CancellationHandle::default(); + self.state.cancellation = Some(handle.clone()); + handle + } + + pub(crate) fn cancellation_handle(&self) -> Option<CancellationHandle> { + self.state.cancellation.clone() + } + pub(crate) fn check_cancelled(&self) -> Result<()> { self.state.check_cancelled() } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/parser/src/matcher.rs new/llguidance-1.9.1/parser/src/matcher.rs --- old/llguidance-1.9.0/parser/src/matcher.rs 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/parser/src/matcher.rs 2026-09-30 20:51:46.000000000 +0200 @@ -38,7 +38,8 @@ if parser.is_fresh() { parser.start_without_prompt(); } - Matcher(MatcherState::Normal(MatcherInner { parser }), None) + let cancellation = parser.cancellation_handle(); + Matcher(MatcherState::Normal(MatcherInner { parser }), cancellation) } } Err(e) => Matcher(MatcherState::Error(e.to_string()), None), @@ -55,13 +56,10 @@ if self.1.is_some() { return; } - let cancellation = CancellationHandle::default(); - if let MatcherState::Normal(inner) = &mut self.0 { - inner - .parser - .parser - .set_cancellation_handle(cancellation.clone()); - } + let cancellation = match &mut self.0 { + MatcherState::Normal(inner) => inner.parser.enable_cancellation(), + _ => CancellationHandle::default(), + }; self.1 = Some(cancellation); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/parser/src/tokenparser.rs new/llguidance-1.9.1/parser/src/tokenparser.rs --- old/llguidance-1.9.0/parser/src/tokenparser.rs 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/parser/src/tokenparser.rs 2026-09-30 20:51:46.000000000 +0200 @@ -3,7 +3,7 @@ use crate::{ api::{GrammarInit, ParserLimits, StopReason}, earley::{BiasComputer, Parser, ParserError, ParserStats}, - infoln, panic_utils, warn, Instant, Logger, ParserFactory, + infoln, panic_utils, warn, CancellationHandle, Instant, Logger, ParserFactory, }; use anyhow::{ensure, Result}; use toktrie::{InferenceCapabilities, SimpleVob, TokEnv, TokenId, INVALID_TOKEN}; @@ -13,6 +13,9 @@ /// Created by [`ParserFactory::create_parser()`] and typically wrapped in a /// [`crate::Constraint`] for the sampling loop. Maintains the grammar state, /// computes token masks, and processes sampled tokens. +/// +/// Cloning snapshots current cancellation into independent cancellation state. Clone the handle +/// explicitly when multiple owners should share future cancellation requests. #[derive(Clone)] pub struct TokenParser { pub token_env: TokEnv, @@ -136,13 +139,32 @@ self.parser.captures() } - // regular .clone() uses a shared lexer state + /// Clone the parser and its lexer caches for independent execution. + /// + /// The clone snapshots current cancellation into independent cancellation state. Parser state + /// already changed by an observed cancellation is still cloned. Regular [`Clone::clone`] uses + /// shared lexer state. pub fn deep_clone(&self) -> Self { let mut copy = self.clone(); copy.parser = self.parser.deep_clone(); copy } + /// Enable cooperative cancellation and return a handle for requesting it. + /// + /// This is idempotent: repeated calls return handles for the same permanent cancellation + /// state. The handle may outlive the parser. Call this while the parser is idle; cancellation + /// may then be requested while a parser operation is running. Once requested, cancellation is + /// permanent for this parser. + pub fn enable_cancellation(&mut self) -> CancellationHandle { + self.parser.enable_cancellation() + } + + /// Return the current cancellation handle, if cancellation has been enabled. + pub fn cancellation_handle(&self) -> Option<CancellationHandle> { + self.parser.cancellation_handle() + } + pub fn stop_reason(&self) -> StopReason { self.stop_reason } @@ -347,8 +369,16 @@ self.error_message.clone() } - fn check_initialized(&self, lbl: &str) -> Result<()> { - self.parser.check_cancelled()?; + fn check_cancellation(&mut self) -> Result<()> { + if let Err(error) = self.parser.check_cancelled() { + self.stop_reason = StopReason::Cancelled; + return Err(error); + } + Ok(()) + } + + fn check_initialized(&mut self, lbl: &str) -> Result<()> { + self.check_cancellation()?; ensure!(!self.is_fresh, "process_prompt() not called in {}", lbl); ensure!( !self.stopped(), @@ -447,6 +477,7 @@ } let n_valid = self.parser.validate_tokens(tokens); + self.check_cancellation()?; Ok(n_valid) } @@ -466,6 +497,7 @@ .perf_counters() .compute_mask .record(self.compute_mask_start_time.elapsed()); + self.check_cancellation()?; r } @@ -588,7 +620,7 @@ // now apply normally match self.parser.apply_token(tok_bytes, tok_id) { Err(e) => { - self.parser.check_cancelled()?; + self.check_cancellation()?; return Err(self.stop( &format!("Parser Error: {e}"), StopReason::ParserTooComplex, // TODO - there are other reasons @@ -862,7 +894,7 @@ /// Otherwise, returns false. /// This generally should be called after consume_token(). pub fn check_stop(&mut self) -> Result<bool> { - self.parser.check_cancelled()?; + self.check_cancellation()?; let empty_token_prefix = !self.has_ff_bytes(); let pending_eos = self .llm_tokens @@ -870,7 +902,7 @@ .is_some_and(|t| self.eos_tokens.contains(t)); let lexer_bytes = self.parser.has_pending_lexeme_bytes(); let is_accepting = self.is_accepting(); - self.parser.check_cancelled()?; + self.check_cancellation()?; let can_advance = self.parser.can_advance(); let parser_done = is_accepting && (!can_advance || pending_eos); infoln!( diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/pyproject.toml new/llguidance-1.9.1/pyproject.toml --- old/llguidance-1.9.0/pyproject.toml 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/pyproject.toml 2026-09-30 20:51:46.000000000 +0200 @@ -1,6 +1,6 @@ [project] name = "llguidance" -version = "1.9.0" +version = "1.9.1" description = "Bindings for the Low-level Guidance (llguidance) Rust library for use within Guidance" requires-python = ">=3.10" license = "MIT" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/python_ext/Cargo.toml new/llguidance-1.9.1/python_ext/Cargo.toml --- old/llguidance-1.9.0/python_ext/Cargo.toml 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/python_ext/Cargo.toml 2026-09-30 20:51:46.000000000 +0200 @@ -1,6 +1,6 @@ [package] name = "llguidance_py" -version = "1.9.0" +version = "1.9.1" edition = "2021" license = "MIT" description = "Super-fast Structured Outputs" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/toktrie/Cargo.toml new/llguidance-1.9.1/toktrie/Cargo.toml --- old/llguidance-1.9.0/toktrie/Cargo.toml 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/toktrie/Cargo.toml 2026-09-30 20:51:46.000000000 +0200 @@ -1,6 +1,6 @@ [package] name = "toktrie" -version = "1.9.0" +version = "1.9.1" edition = "2021" license = "MIT" description = "LLM Token Trie library" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/toktrie_hf_downloader/Cargo.toml new/llguidance-1.9.1/toktrie_hf_downloader/Cargo.toml --- old/llguidance-1.9.0/toktrie_hf_downloader/Cargo.toml 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/toktrie_hf_downloader/Cargo.toml 2026-09-30 20:51:46.000000000 +0200 @@ -1,6 +1,6 @@ [package] name = "toktrie_hf_downloader" -version = "1.9.0" +version = "1.9.1" edition = "2021" license = "MIT" description = "HuggingFace Hub download library support for toktrie and llguidance" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/toktrie_hf_tokenizers/Cargo.toml new/llguidance-1.9.1/toktrie_hf_tokenizers/Cargo.toml --- old/llguidance-1.9.0/toktrie_hf_tokenizers/Cargo.toml 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/toktrie_hf_tokenizers/Cargo.toml 2026-09-30 20:51:46.000000000 +0200 @@ -1,6 +1,6 @@ [package] name = "toktrie_hf_tokenizers" -version = "1.9.0" +version = "1.9.1" edition = "2021" license = "MIT" description = "HuggingFace tokenizers library support for toktrie and llguidance" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/llguidance-1.9.0/toktrie_tiktoken/Cargo.toml new/llguidance-1.9.1/toktrie_tiktoken/Cargo.toml --- old/llguidance-1.9.0/toktrie_tiktoken/Cargo.toml 2026-09-29 18:05:30.000000000 +0200 +++ new/llguidance-1.9.1/toktrie_tiktoken/Cargo.toml 2026-09-30 20:51:46.000000000 +0200 @@ -1,6 +1,6 @@ [package] name = "toktrie_tiktoken" -version = "1.9.0" +version = "1.9.1" edition = "2021" license = "MIT" description = "tiktoken (OpenAI BPE) library support for toktrie and llguidance" ++++++ registry.tar.zst ++++++ /work/SRC/openSUSE:Factory/python-llguidance/registry.tar.zst /work/SRC/openSUSE:Factory/.python-llguidance.new.1631729/registry.tar.zst differ: char 7790859, line 30295
