fixing tests

Author: sydney-runkle

src/url.rs

@@ -5,13 +5,12 @@ use std::hash::{Hash, Hasher};
 
 use idna::punycode::decode_to_string;
 use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
 use pyo3::pyclass::CompareOp;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyType};
-use pyo3::{intern, prelude::*};
 use url::Url;
 
-use crate::tools::SchemaDict;
 use crate::SchemaValidator;
 
 static SCHEMA_DEFINITION_URL: GILOnceCell<SchemaValidator> = GILOnceCell::new();
@@ -423,6 +422,9 @@ impl PyMultiHostUrl {
     }
 }
 
+#[derive(FromPyObject)]
+#[pyo3(from_item_all)]
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct UrlHostParts {
     username: Option<String>,
     password: Option<String>,
@@ -436,19 +438,6 @@ impl UrlHostParts {
     }
 }
 
-impl FromPyObject<'_> for UrlHostParts {
-    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
-        let py = ob.py();
-        let dict = ob.downcast::<PyDict>()?;
-        Ok(UrlHostParts {
-            username: dict.get_as(intern!(py, "username"))?,
-            password: dict.get_as(intern!(py, "password"))?,
-            host: dict.get_as(intern!(py, "host"))?,
-            port: dict.get_as(intern!(py, "port"))?,
-        })
-    }
-}
-
 impl fmt::Display for UrlHostParts {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match (&self.username, &self.password) {

src/validators/url.rs

@@ -15,7 +15,6 @@ use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
 use crate::input::downcast_python_input;
 use crate::input::Input;
 use crate::tools::SchemaDict;
-use crate::url::UrlHostParts;
 use crate::url::{schema_is_special, PyMultiHostUrl, PyUrl};
 
 use super::literal::expected_repr_name;
@@ -297,22 +296,16 @@ impl Validator for MultiHostUrlValidator {
                         EitherMultiHostUrl::Rust(rust_url) => rust_url,
                     };
 
-                    let hosts = py_url.hosts(py).map_or(None, |hosts| {
-                        let mut host_parts_vec = Vec::new();
-                        for host in &hosts {
-                            if let Ok(py_dict) = host.downcast::<PyDict>() {
-                                if let Ok(host_parts) = UrlHostParts::extract_bound(py_dict) {
-                                    host_parts_vec.push(host_parts);
-                                }
-                            }
-                        }
-                        Some(host_parts_vec)
-                    });
+                    let hosts = py_url
+                        .hosts(py)?
+                        .into_iter()
+                        .map(|host| host.extract().expect("host should be a valid UrlHostParts"))
+                        .collect();
 
                     let py_url = PyMultiHostUrl::build(
                         url_subclass.bind(py),
                         py_url.scheme(),
-                        hosts,
+                        Some(hosts),
                         py_url.path().filter(|path| *path != "/"),
                         py_url.query(),
                         py_url.fragment(),