Skip to main content

a3s_search/
lib.rs

1//! # a3s-search
2//!
3//! An embeddable meta search engine library inspired by SearXNG.
4//!
5//! This library provides a framework for aggregating search results from multiple
6//! search engines, with support for:
7//!
8//! - Async parallel search execution
9//! - Result deduplication and merging
10//! - Configurable ranking algorithms
11//! - Extensible engine interface
12//! - Dynamic proxy IP pool for anti-crawler protection
13//!
14//! ## Example
15//!
16//! ```rust,no_run
17//! use a3s_search::{Search, SearchQuery, engines::DuckDuckGo};
18//!
19//! #[tokio::main]
20//! async fn main() -> anyhow::Result<()> {
21//!     let mut search = Search::new();
22//!     search.add_engine(DuckDuckGo::new());
23//!
24//!     let query = SearchQuery::new("rust programming");
25//!     let results = search.search(query).await?;
26//!
27//!     for result in results.items() {
28//!         println!("{}: {}", result.title, result.url);
29//!     }
30//!     Ok(())
31//! }
32//! ```
33//!
34//! ## Using Proxy
35//!
36//! ```rust,no_run
37//! use a3s_search::{Search, SearchQuery, engines::DuckDuckGo, HttpFetcher, PageFetcher};
38//! use std::sync::Arc;
39//!
40//! #[tokio::main]
41//! async fn main() -> anyhow::Result<()> {
42//!     let fetcher: Arc<dyn PageFetcher> = Arc::new(
43//!         HttpFetcher::with_proxy("http://proxy1.example.com:8080")?
44//!     );
45//!
46//!     let mut search = Search::new();
47//!     search.add_engine(DuckDuckGo::with_fetcher(
48//!         a3s_search::engines::DuckDuckGoParser, fetcher,
49//!     ));
50//!
51//!     let query = SearchQuery::new("rust programming");
52//!     let results = search.search(query).await?;
53//!
54//!     Ok(())
55//! }
56//! ```
57//!
58//! ## Using Dynamic Proxy Pool
59//!
60//! ```rust,no_run
61//! use std::sync::Arc;
62//! use a3s_search::{Search, SearchQuery, PooledHttpFetcher, PageFetcher};
63//! use a3s_search::engines::{DuckDuckGo, DuckDuckGoParser};
64//! use a3s_search::proxy::{ProxyPool, ProxyProvider, ProxyConfig, spawn_auto_refresh};
65//!
66//! // Implement your own provider to fetch proxies from any source
67//! struct MyProxyProvider { /* ... */ }
68//!
69//! #[async_trait::async_trait]
70//! impl ProxyProvider for MyProxyProvider {
71//!     async fn fetch_proxies(&self) -> a3s_search::Result<Vec<ProxyConfig>> {
72//!         // Fetch from your proxy API, database, etc.
73//!         Ok(vec![ProxyConfig::new("10.0.0.1", 8080)])
74//!     }
75//!     fn refresh_interval(&self) -> std::time::Duration {
76//!         std::time::Duration::from_secs(60) // refresh every minute
77//!     }
78//! }
79//!
80//! #[tokio::main]
81//! async fn main() -> anyhow::Result<()> {
82//!     let pool = Arc::new(ProxyPool::with_provider(MyProxyProvider { /* ... */ }));
83//!     let _refresh_handle = spawn_auto_refresh(Arc::clone(&pool));
84//!
85//!     let fetcher: Arc<dyn PageFetcher> = Arc::new(PooledHttpFetcher::new(Arc::clone(&pool)));
86//!
87//!     let mut search = Search::new();
88//!     search.add_engine(DuckDuckGo::with_fetcher(DuckDuckGoParser, fetcher));
89//!
90//!     let query = SearchQuery::new("rust programming");
91//!     let results = search.search(query).await?;
92//!     Ok(())
93//! }
94//! ```
95
96mod aggregator;
97mod config;
98mod engine;
99mod error;
100mod fetcher;
101mod fetcher_http;
102mod health;
103mod html_engine;
104pub mod proxy;
105mod query;
106mod result;
107mod search;
108
109pub mod engines;
110
111#[cfg(feature = "headless")]
112pub mod browser;
113
114#[cfg(feature = "headless")]
115pub mod browser_setup;
116
117#[cfg(feature = "lightpanda")]
118pub mod browser_setup_lp;
119
120pub use aggregator::Aggregator;
121pub use config::{EngineEntry, HealthEntry, SearchConfig};
122pub use engine::{Engine, EngineCategory, EngineConfig};
123pub use error::{Result, SearchError};
124pub use fetcher::{PageFetcher, WaitStrategy};
125pub use fetcher_http::{HttpFetcher, PooledHttpFetcher};
126pub use health::{HealthConfig, HealthMonitor};
127pub use html_engine::{selector, HtmlEngine, HtmlParser};
128pub use query::{SafeSearch, SearchQuery, TimeRange};
129pub use result::{ResultType, SearchResult, SearchResults};
130pub use search::Search;
131
132#[cfg(feature = "headless")]
133pub use browser::{BrowserBackend, BrowserFetcher, BrowserPool, BrowserPoolConfig};