theopendictionary 2.0.0__tar.gz → 2.1.0__tar.gz

{theopendictionary-2.0.0 → theopendictionary-2.1.0}/Cargo.lock

@@ -592,9 +592,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.49"
+version = "4.5.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4512b90fa68d3a9932cea5184017c5d200f5921df706d45e853537dea51508f"
+checksum = "0c2cfd7bf8a6017ddaa4e32ffe7403d547790db06bd171c1c53926faab501623"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -602,9 +602,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.49"
+version = "4.5.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0025e98baa12e766c67ba13ff4695a887a1eba19569aad00a472546795bd6730"
+checksum = "0a4c05b9e80c5ccd3a7ef080ad7b6ba7d6fc00a985b8b157197075677c82c7a0"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1212,7 +1212,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2098,7 +2098,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667"
 dependencies = [
  "cfg-if",
- "windows-targets 0.53.3",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -2553,7 +2553,7 @@ dependencies = [
 
 [[package]]
 name = "odict"
-version = "3.0.0"
+version = "3.1.0"
 dependencies = [
  "brotli",
  "byteorder",
@@ -2587,7 +2587,7 @@ dependencies = [
 
 [[package]]
 name = "odict-cli"
-version = "3.0.0"
+version = "3.1.0"
 dependencies = [
  "actix-web",
  "anyhow",
@@ -2620,7 +2620,7 @@ dependencies = [
 
 [[package]]
 name = "odict_python"
-version = "2.0.0"
+version = "2.1.0"
 dependencies = [
  "either",
  "internal",
@@ -3101,7 +3101,7 @@ dependencies = [
  "once_cell",
  "socket2 0.5.10",
  "tracing",
- "windows-sys 0.60.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3454,7 +3454,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.60.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4573,7 +4573,7 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0978bf7171b3d90bac376700cb56d606feb40f251a475a5d6634613564460b22"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]

{theopendictionary-2.0.0 → theopendictionary-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: theopendictionary
-Version: 2.0.0
+Version: 2.1.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

theopendictionary-2.1.0/internal/src/load.rs

@@ -0,0 +1,55 @@
+use odict::{
+    OpenDictionary,
+    alias::{AliasManager, AliasOptions},
+    remote::RemoteOptions,
+};
+
+pub struct LoadDictionaryOptions<'a> {
+    alias_options: odict::alias::AliasOptions,
+    remote_options: odict::remote::RemoteOptions<'a>,
+}
+
+impl<'a> Default for LoadDictionaryOptions<'a> {
+    fn default() -> Self {
+        LoadDictionaryOptions {
+            alias_options: AliasOptions::default(),
+            remote_options: RemoteOptions::default(),
+        }
+    }
+}
+
+impl<'a> LoadDictionaryOptions<'a> {
+    pub fn with_alias_manager(mut self, manager: AliasManager) -> Self {
+        self.alias_options = AliasOptions::default().with_manager(manager);
+        self
+    }
+
+    pub fn with_remote_options(mut self, options: RemoteOptions<'a>) -> Self {
+        self.remote_options = options;
+        self
+    }
+}
+
+pub async fn load_dictionary_with_options<'a>(
+    name: &str,
+    options: LoadDictionaryOptions<'a>,
+) -> odict::Result<OpenDictionary> {
+    // Attempt to load first from the remote if the request matches the regex
+    match OpenDictionary::from_remote_with_options(name, options.remote_options).await {
+        Ok(dictionary) => Ok(dictionary),
+        // If the name is invalid, try loading from an alias
+        Err(odict::Error::InvalidDictionaryName(_)) => {
+            match OpenDictionary::from_alias_with_options(name, options.alias_options) {
+                Ok(dictionary) => Ok(dictionary),
+                // If no alias found, try loading from path
+                Err(odict::Error::AliasNotFound(_)) => OpenDictionary::from_path(name),
+                Err(e) => Err(e),
+            }
+        }
+        Err(e) => Err(e),
+    }
+}
+
+pub async fn load_dictionary(name: &str) -> odict::Result<OpenDictionary> {
+    load_dictionary_with_options(name, LoadDictionaryOptions::default()).await
+}

{theopendictionary-2.0.0 → theopendictionary-2.1.0}/lib/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [3.1.0](https://github.com/TheOpenDictionary/odict/compare/lib/v3.0.0...lib/v3.1.0) (2025-10-20)
+
+
+### Features
+
+* Allow passing remote load options to Node and Python ([#1315](https://github.com/TheOpenDictionary/odict/issues/1315)) ([80a8361](https://github.com/TheOpenDictionary/odict/commit/80a8361e1cff88bffb5bf36cb354ca04ad89a343))
+* Remove backwards compatibility for legacy follow for Node and Python ([#1308](https://github.com/TheOpenDictionary/odict/issues/1308)) ([785fac5](https://github.com/TheOpenDictionary/odict/commit/785fac54001df45841fa18d0c6822e36a337b5ec))
+* Remove backwards compatibility for legacy follow for Node and Python ([#1310](https://github.com/TheOpenDictionary/odict/issues/1310)) ([2efe45d](https://github.com/TheOpenDictionary/odict/commit/2efe45d44babc1357bd10650360b4edd671513dd))
+* String interning ([#1313](https://github.com/TheOpenDictionary/odict/issues/1313)) ([a1ce402](https://github.com/TheOpenDictionary/odict/commit/a1ce4025950f840674e1e4e159b60311672febc2))
+
+
+### Bug Fixes
+
+* Inline interning library ([5833965](https://github.com/TheOpenDictionary/odict/commit/583396596017cc2a979d45de3237885671c136e7))
+
 ## [3.0.0](https://github.com/TheOpenDictionary/odict/compare/lib/v2.9.1...lib/v3.0.0) (2025-10-17)
 
 

{theopendictionary-2.0.0 → theopendictionary-2.1.0}/lib/Cargo.toml

@@ -3,7 +3,7 @@ name = "odict"
 description = "A blazingly-fast dictionary file format for human languages"
 homepage = "https://odict.org"
 repository = "https://github.com/TheOpenDictionary/odict"
-version = "3.0.0"
+version = "3.1.0"
 edition = "2021"
 license = "MIT"
 exclude = ["benches/*", "tests/*"]
@@ -77,6 +77,7 @@ reqwest = { version = "0.12.24", optional = true, default-features = false, feat
   "http2",
   "stream",
 ] }
+strum = { version = "0.27.2", features = ["derive"] }
 reqwest-middleware = { version = "0.4.2", optional = true }
 reqwest-retry = { version = "0.7.0", optional = true }
 futures-util = { version = "0.3", optional = true }
@@ -87,7 +88,7 @@ tantivy = { version = "0.25.0", optional = true }
 dirs = { version = "6.0.0", optional = true }
 # feature=sql
 sea-query = { version = "0.32.7", optional = true }
-strum = { version = "0.27.2", features = ["derive"] }
+
 
 [dev-dependencies]
 criterion = { version = "0.7.0", features = ["async_tokio", "html_reports"] }

{theopendictionary-2.0.0 → theopendictionary-2.1.0}/lib/src/core/lookup.rs

@@ -13,7 +13,6 @@ pub enum LookupStrategy {
 #[derive(Debug, Clone)]
 pub struct LookupOptions {
     /// Whether to follow see_also links until finding an entry with etymologies.
-    /// true means follow redirects until etymology found, false means no following.
     pub follow: bool,
     pub strategy: LookupStrategy,
     pub insensitive: bool,
@@ -118,7 +117,6 @@ macro_rules! lookup {
 
                     // Only try lowercase if it's different from the original query
                     if query_lower != query {
-                        // Try direct lookup with lowercase (keep insensitive flag for redirect following)
                         if let Ok($opt::Some(result)) =
                             self.find_entry(follow, insensitive, &query_lower, directed_from, path)
                         {
@@ -150,51 +148,52 @@ macro_rules! lookup {
 
                 let mut path = Vec::new();
 
-                return match self.find_entry(follow, insensitive, query, None, &mut path)? {
-                    $opt::Some(result) => Ok(vec![result]),
-                    $opt::None => {
-                        let mut results: Vec<LookupResult<&$ret>> = Vec::new();
-
-                        if let LookupStrategy::Split(min_length) = strategy {
-                            let chars: Vec<_> = query.chars().collect();
-                            let mut start = 0;
-                            let mut end = chars.len();
-
-                            while start < end {
-                                let substr: String = chars[start..end].iter().collect();
-                                let mut substr_path = Vec::new();
-                                let maybe_entry = self.find_entry(
-                                    follow,
-                                    insensitive,
-                                    substr.as_str(),
-                                    None,
-                                    &mut substr_path,
-                                );
+                if let $opt::Some(result) =
+                    self.find_entry(follow, insensitive, query, None, &mut path)?
+                {
+                    return Ok(vec![result]);
+                }
 
-                                match maybe_entry {
-                                    Ok($opt::Some(result)) => {
-                                        results.push(result);
-                                        start = end;
-                                        end = chars.len();
-                                        continue;
-                                    }
-                                    Ok($opt::None) => {
-                                        if substr.len() <= *min_length {
-                                            start = end;
-                                            end = chars.len();
-                                            continue;
-                                        }
-                                    }
-                                    Err(e) => return Err(e),
+                let mut results: Vec<LookupResult<&$ret>> = Vec::new();
+
+                if let LookupStrategy::Split(min_length) = strategy {
+                    let chars: Vec<_> = query.chars().collect();
+                    let mut start = 0;
+                    let mut end = chars.len();
+
+                    while start < end {
+                        let substr: String = chars[start..end].iter().collect();
+                        let mut substr_path = Vec::new();
+                        let maybe_entry = self.find_entry(
+                            follow,
+                            insensitive,
+                            substr.as_str(),
+                            None,
+                            &mut substr_path,
+                        );
+
+                        match maybe_entry {
+                            Ok($opt::Some(result)) => {
+                                results.push(result);
+                                start = end;
+                                end = chars.len();
+                                continue;
+                            }
+                            Ok($opt::None) => {
+                                if substr.len() <= *min_length {
+                                    start = end;
+                                    end = chars.len();
+                                    continue;
                                 }
-
-                                end -= 1;
                             }
+                            Err(e) => return Err(e),
                         }
 
-                        Ok(results)
+                        end -= 1;
                     }
-                };
+                }
+
+                Ok(results)
             }
 
             pub fn lookup<'a, 'b, Query, Options>(

{theopendictionary-2.0.0 → theopendictionary-2.1.0}/lib/src/download/download.rs

@@ -235,7 +235,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_download_with_caching_enabled() {
+    async fn test_download_caching_enabled() {
         let mock_server = MockServer::start().await;
         let test_data = b"cached dictionary data";
 
@@ -267,7 +267,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_download_with_caching_disabled() {
+    async fn test_download_caching_disabled() {
         let mock_server = MockServer::start().await;
         let test_data = b"non-cached dictionary data";
 

{theopendictionary-2.0.0 → theopendictionary-2.1.0}/lib/src/download/mod.rs

@@ -3,10 +3,8 @@ use crate::error::Result;
 mod download;
 mod metadata;
 mod options;
-mod remote;
 mod utils;
 
 pub use download::DictionaryDownloader;
 pub use options::DownloadOptions;
-pub use remote::*;
 pub use utils::{classify_reqwest_error, parse_remote_dictionary_name, NetworkError};

theopendictionary-2.1.0/lib/src/intern/interner.rs

@@ -0,0 +1,83 @@
+extern crate alloc;
+
+use alloc::borrow::ToOwned;
+use core::{borrow::Borrow, error::Error, fmt, hash::Hash};
+use std::collections::HashMap;
+
+use rkyv::{
+    rancor::{fail, Source},
+    ser::sharing::SharingState,
+};
+
+use super::Interning;
+
+/// A general-purpose value interner.
+pub struct Interner<T> {
+    value_to_pos: HashMap<T, Option<usize>>,
+}
+
+impl<T> Interner<T> {
+    /// Returns a new, empty interner.
+    pub fn new() -> Self {
+        Self {
+            value_to_pos: HashMap::new(),
+        }
+    }
+}
+
+impl<T> Default for Interner<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug)]
+struct NotStarted;
+
+impl fmt::Display for NotStarted {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "value was not started interning")
+    }
+}
+
+impl Error for NotStarted {}
+
+#[derive(Debug)]
+struct AlreadyFinished;
+
+impl fmt::Display for AlreadyFinished {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "value was already finished interning")
+    }
+}
+
+impl Error for AlreadyFinished {}
+
+impl<T, E> Interning<T, E> for Interner<T::Owned>
+where
+    T::Owned: Hash + Eq + Borrow<T>,
+    T: Hash + Eq + ToOwned + ?Sized,
+    E: Source,
+{
+    fn start_interning(&mut self, value: &T) -> SharingState {
+        match self.value_to_pos.get(value) {
+            None => {
+                self.value_to_pos.insert(value.to_owned(), None);
+                SharingState::Started
+            }
+            Some(None) => SharingState::Pending,
+            Some(Some(pos)) => SharingState::Finished(*pos),
+        }
+    }
+
+    fn finish_interning(&mut self, value: &T, pos: usize) -> Result<(), E> {
+        match self.value_to_pos.get_mut(value) {
+            None => fail!(NotStarted),
+            Some(Some(_)) => fail!(AlreadyFinished),
+            Some(x) => {
+                *x = Some(pos);
+                Ok(())
+            }
+        }
+    }
+}