chore: update pyo3 deprecetations

src/archs4/python.rs

@@ -31,7 +31,7 @@ pub fn python_archs4_tissue<'py>(
 
 /// Wraps `ARCHS4` specific functions into a python submodule
 pub fn python_archs4(py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
-    let submodule = PyModule::new_bound(py, "archs4")?;
+    let submodule = PyModule::new(py, "archs4")?;
     submodule.add_function(wrap_pyfunction!(python_archs4_tissue, module)?)?;
     submodule.add_function(wrap_pyfunction!(python_archs4_correlate, module)?)?;
     module.add_submodule(&submodule)?;

src/archs4/types/correlation.rs

@@ -52,7 +52,7 @@ impl fmt::Display for Correlations {
 }
 impl Correlations {
     pub fn as_pydict<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item(
             "correlations",
             self.correlations
@@ -90,7 +90,7 @@ impl fmt::Display for Correlation {
 }
 impl Correlation {
     pub fn as_pydict<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item("gene_symbol", &self.gene_symbol)?;
         dict.set_item("pearson_correlation", self.pearson_correlation)?;
         Ok(dict)

src/archs4/types/tissue.rs

@@ -53,7 +53,7 @@ impl ResponseTissue {
             .collect()
     }
     pub fn as_pydict<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item(
             "tissues",
             self.results
@@ -124,7 +124,7 @@ impl ResultTissue {
     }
 
     pub fn as_pydict<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item("id", &self.id)?;
         dict.set_item("min", self.min)?;
         dict.set_item("q1", self.q1)?;

src/blast/python.rs

@@ -15,7 +15,6 @@ use pyo3::{
     signature = (query, program = None, database = None, limit = None, expect = None, low_comp_filter = None, megablast = None)
 )]
 #[allow(clippy::too_many_arguments)]
-
 pub fn python_blast<'py>(
     py: Python<'py>,
     query: &str,
@@ -61,5 +60,5 @@ pub fn python_blast<'py>(
         low_comp_filter,
         megablast,
     )?;
-    Ok(response.into_py_dict_bound(py))
+    Ok(response.into_py_dict(py)?)
 }

src/cli/cli.rs

@@ -116,7 +116,7 @@ pub enum Commands {
         #[clap(required = true)]
         search_terms: Vec<String>,
 
-        /// Species name to use: currently this MUST match the taxon_id
+        /// Species name to use: currently this MUST match the `taxon_id`
         #[clap(short, long, default_value = "homo_sapiens")]
         species: String,
 
@@ -129,7 +129,7 @@ pub enum Commands {
         output: Option<String>,
     },
 
-    /// Queries sequences from ensembl and UniProt
+    /// Queries sequences from ensembl and `UniProt`
     Seq {
         /// Search terms to query (can be Ensembl IDs or Gene Symbols)
         #[clap(value_parser, required = true)]

src/cli/enrichr.rs

@@ -4,7 +4,7 @@ use clap::Subcommand;
 pub enum ModEnrichr {
     /// Perform the Enrichr gene set enrichment analysis
     Enrichr {
-        /// any database listed at: https://maayanlab.cloud/Enrichr/#libraries
+        /// any database listed at: <https://maayanlab.cloud/Enrichr/#libraries>
         /// some shorthands include: pathway, transcription, ontology, diseases_drugs, celltypes,
         /// and kinase_interactions.
         #[clap(short, long)]

src/enrichr/types/enrich.rs

@@ -23,12 +23,15 @@ impl fmt::Display for ResponseEnrich {
 }
 impl ResponseEnrich {
     pub fn as_pydict<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         for (key, results) in &self.0 {
-            let all_results: Vec<Bound<'py, PyDict>> = results
-                .iter()
-                .map(|x| x.as_pydict(py).expect("could not create dictionary"))
-                .collect();
+            let all_results =
+                results
+                    .iter()
+                    .try_fold(Vec::new(), |mut acc, x| -> PyResult<Vec<_>> {
+                        acc.push(x.as_pydict(py)?);
+                        Ok(acc)
+                    })?;
             dict.set_item(key, all_results)?;
         }
         Ok(dict)
@@ -72,7 +75,7 @@ impl fmt::Display for ResultEnrichr {
 }
 impl ResultEnrichr {
     pub fn as_pydict<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item("rank", self.rank)?;
         dict.set_item("term_name", &self.term_name)?;
         dict.set_item("pvalue", self.pvalue)?;

src/ensembl/functions/database.rs

@@ -6,7 +6,7 @@ use mysql::{prelude::Queryable, Conn, OptsBuilder};
 pub fn database(filter: &Option<String>) -> anyhow::Result<ResponseDatabases> {
     let opts = get_mysql_options();
     let mut conn = Conn::new(opts)?;
-    let query = build_search_query(filter);
+    let query = build_search_query(filter.as_ref());
     let results: Vec<Database> = conn.query_map(query, Database)?;
     if results.is_empty() {
         match filter {
@@ -28,7 +28,7 @@ fn get_mysql_options() -> OptsBuilder {
 /// Generates the search query.
 ///
 /// Searches through databases for a related token
-fn build_search_query(search_term: &Option<String>) -> String {
+fn build_search_query(search_term: Option<&String>) -> String {
     if let Some(token) = search_term {
         format!("SHOW databases LIKE '%{token}%'")
     } else {

src/ensembl/python.rs

@@ -107,7 +107,7 @@ pub fn python_ensembl_species(
 }
 
 pub fn python_ensembl(py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
-    let submodule = PyModule::new_bound(py, "ensembl")?;
+    let submodule = PyModule::new(py, "ensembl")?;
     submodule.add_function(wrap_pyfunction!(python_ensembl_search, module)?)?;
     submodule.add_function(wrap_pyfunction!(python_ensembl_database, module)?)?;
     submodule.add_function(wrap_pyfunction!(python_ensembl_release, module)?)?;

src/ensembl/types/ftpfile.rs

@@ -41,7 +41,7 @@ impl FtpFile {
     }
 
     pub fn as_pydict<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item("url", &self.url)?;
         dict.set_item("ensembl_release", self.ensembl_release)?;
         dict.set_item("release_date", &self.release_date)?;

src/ensembl/types/search_results.rs

@@ -21,7 +21,7 @@ impl fmt::Display for SearchResults {
 }
 impl SearchResults {
     pub fn as_pydict<'py>(&self, py: Python<'py>) -> Result<Bound<'py, PyDict>> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item(
             "results",
             self.0
@@ -82,7 +82,7 @@ impl SearchResult {
     }
 
     pub fn as_pydict<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item("stable_id", &self.stable_id)?;
         dict.set_item("display_label", &self.display_label)?;
         dict.set_item("ensembl_description", &self.ensembl_description)?;

src/lib.rs

@@ -53,18 +53,18 @@ pub mod seq;
 pub type RequestError = Box<dyn std::error::Error + Send + Sync>;
 
 #[pymodule]
-fn ggetrs(py: Python<'_>, module: Bound<'_, PyModule>) -> PyResult<()> {
-    module.add_function(wrap_pyfunction!(enrichr::python_enrichr, &module)?)?;
+fn ggetrs(py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add_function(wrap_pyfunction!(enrichr::python_enrichr, module)?)?;
     module.add_function(wrap_pyfunction!(
         enrichr::python_enrichr_background,
-        &module
+        module
     )?)?;
-    archs4::python_archs4(py, &module)?;
-    ensembl::python_ensembl(py, &module)?;
-    ucsc::python_ucsc(py, &module)?;
-    module.add_function(wrap_pyfunction!(ensembl::python_ensembl_search, &module)?)?;
-    module.add_function(wrap_pyfunction!(seq::python_seq, &module)?)?;
-    module.add_function(wrap_pyfunction!(info::python_info, &module)?)?;
-    module.add_function(wrap_pyfunction!(blast::python_blast, &module)?)?;
+    archs4::python_archs4(py, module)?;
+    ensembl::python_ensembl(py, module)?;
+    ucsc::python_ucsc(py, module)?;
+    module.add_function(wrap_pyfunction!(ensembl::python_ensembl_search, module)?)?;
+    module.add_function(wrap_pyfunction!(seq::python_seq, module)?)?;
+    module.add_function(wrap_pyfunction!(info::python_info, module)?)?;
+    module.add_function(wrap_pyfunction!(blast::python_blast, module)?)?;
     Ok(())
 }

src/main.rs

@@ -17,7 +17,11 @@ use ggetrs::{
     ncbi::{launch_ncbi_query_ids, launch_ncbi_query_symbols, launch_ncbi_taxons},
     pdb::{launch_pdb_resource, launch_pdb_structure},
     seq::launch_seq,
-    string::*,
+    string::{
+        launch_string_annotations, launch_string_enrichment, launch_string_homology,
+        launch_string_interactions, launch_string_mapping, launch_string_network,
+        launch_string_ppi_enrichment,
+    },
     ucsc::launch_ucsc_blat,
     uniprot::launch_uniprot_query,
     utils::autocomplete::print_completions,
@@ -250,7 +254,7 @@ fn main() -> Result<(), RequestError> {
             ModString::Enrichment { args, output } => launch_string_enrichment(args, output)?,
             ModString::Annotations { args, output } => launch_string_annotations(args, output)?,
             ModString::PpiEnrichment { args, output } => {
-                launch_string_ppi_enrichment(args, output)?
+                launch_string_ppi_enrichment(args, output)?;
             }
         },
         Commands::Autocomplete { shell } => print_completions(*shell, &mut Cli::command()),

src/ucsc/python.rs

@@ -42,7 +42,7 @@ pub fn python_ucsc_blat<'py>(
 }
 
 pub fn python_ucsc(py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
-    let submodule = PyModule::new_bound(py, "ucsc")?;
+    let submodule = PyModule::new(py, "ucsc")?;
     submodule.add_function(wrap_pyfunction!(python_ucsc_blat, module)?)?;
     module.add_submodule(&submodule)?;
     Ok(())

src/ucsc/types/blat.rs

@@ -28,13 +28,15 @@ impl BlatResults {
         Self(results)
     }
     pub fn as_pylist<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyList>> {
-        let vec_dict: Vec<Bound<'py, PyDict>> = self
-            .0
-            .iter()
-            .cloned()
-            .map(|x| x.into_py_dict(py).unwrap())
-            .collect();
-        Ok(PyList::new(py, vec_dict)?)
+        let vec_dict =
+            self.0
+                .iter()
+                .cloned()
+                .try_fold(Vec::new(), |mut acc, x| -> PyResult<Vec<_>> {
+                    acc.push(x.into_py_dict(py)?);
+                    Ok(acc)
+                })?;
+        PyList::new(py, vec_dict)
     }
 }
 
@@ -75,27 +77,27 @@ impl fmt::Display for Blat {
 impl<'py> IntoPyDict<'py> for Blat {
     fn into_py_dict(self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
         let dict = PyDict::new(py);
-        dict.set_item("matches", self.matches).unwrap();
-        dict.set_item("mismatches", self.mismatches).unwrap();
-        dict.set_item("repmatches", self.repmatches).unwrap();
-        dict.set_item("n_count", self.n_count).unwrap();
-        dict.set_item("q_num_insert", self.q_num_insert).unwrap();
-        dict.set_item("q_base_insert", self.q_base_insert).unwrap();
-        dict.set_item("t_num_insert", self.t_num_insert).unwrap();
-        dict.set_item("t_base_insert", self.t_base_insert).unwrap();
-        dict.set_item("strand", &self.strand).unwrap();
-        dict.set_item("q_name", &self.q_name).unwrap();
-        dict.set_item("q_size", self.q_size).unwrap();
-        dict.set_item("q_start", self.q_start).unwrap();
-        dict.set_item("q_end", self.q_end).unwrap();
-        dict.set_item("t_name", &self.t_name).unwrap();
-        dict.set_item("t_size", self.t_size).unwrap();
-        dict.set_item("t_start", self.t_start).unwrap();
-        dict.set_item("t_end", self.t_end).unwrap();
-        dict.set_item("block_count", self.block_count).unwrap();
-        dict.set_item("block_sizes", &self.block_sizes).unwrap();
-        dict.set_item("q_starts", &self.q_starts).unwrap();
-        dict.set_item("q_starts", &self.t_starts).unwrap();
+        dict.set_item("matches", self.matches)?;
+        dict.set_item("mismatches", self.mismatches)?;
+        dict.set_item("repmatches", self.repmatches)?;
+        dict.set_item("n_count", self.n_count)?;
+        dict.set_item("q_num_insert", self.q_num_insert)?;
+        dict.set_item("q_base_insert", self.q_base_insert)?;
+        dict.set_item("t_num_insert", self.t_num_insert)?;
+        dict.set_item("t_base_insert", self.t_base_insert)?;
+        dict.set_item("strand", &self.strand)?;
+        dict.set_item("q_name", &self.q_name)?;
+        dict.set_item("q_size", self.q_size)?;
+        dict.set_item("q_start", self.q_start)?;
+        dict.set_item("q_end", self.q_end)?;
+        dict.set_item("t_name", &self.t_name)?;
+        dict.set_item("t_size", self.t_size)?;
+        dict.set_item("t_start", self.t_start)?;
+        dict.set_item("t_end", self.t_end)?;
+        dict.set_item("block_count", self.block_count)?;
+        dict.set_item("block_sizes", &self.block_sizes)?;
+        dict.set_item("q_starts", &self.q_starts)?;
+        dict.set_item("q_starts", &self.t_starts)?;
         Ok(dict)
     }
 }

src/uniprot/functions/query.rs

@@ -5,7 +5,7 @@ use reqwest::Client;
 use serde_json::Value;
 use std::collections::HashMap;
 
-fn build_query_string(gene: &str, freeform: bool, taxon: &Option<usize>) -> String {
+fn build_query_string(gene: &str, freeform: bool, taxon: Option<&usize>) -> String {
     let gene_query = if gene.starts_with("ENS") || freeform {
         format!("({gene})")
     } else {
@@ -26,7 +26,7 @@ pub async fn async_query_uniprot(
     freeform: bool,
     taxon: &Option<usize>,
 ) -> Result<Option<UniprotInfo>> {
-    let query = build_query_string(gene, freeform, taxon);
+    let query = build_query_string(gene, freeform, taxon.as_ref());
     let url = format!("https://rest.uniprot.org/uniprotkb/search?query={query}+AND+reviewed:true",);
     let value = Client::new()
         .get(&url) // Updated to pass the URL by reference

src/utils/fasta.rs

@@ -9,13 +9,15 @@ use std::fmt::Display;
 pub struct FastaRecords(pub Vec<FastaRecord>);
 impl FastaRecords {
     pub fn as_pylist<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyList>> {
-        let vec_dict: Vec<Bound<'py, PyDict>> = self
-            .0
-            .iter()
-            .cloned()
-            .map(|x| x.into_py_dict(py).unwrap())
-            .collect();
-        Ok(PyList::new(py, vec_dict)?)
+        let vec_dict =
+            self.0
+                .iter()
+                .cloned()
+                .try_fold(Vec::default(), |mut acc, x| -> PyResult<Vec<_>> {
+                    acc.push(x.into_py_dict(py)?);
+                    Ok(acc)
+                })?;
+        PyList::new(py, vec_dict)
     }
 }
 
@@ -33,8 +35,8 @@ impl Display for FastaRecord {
 impl<'py> IntoPyDict<'py> for FastaRecord {
     fn into_py_dict(self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
         let map = PyDict::new(py);
-        map.set_item("header", self.header).unwrap();
-        map.set_item("sequence", self.sequence).unwrap();
+        map.set_item("header", self.header)?;
+        map.set_item("sequence", self.sequence)?;
         Ok(map)
     }
 }