urlpattern 0.2.0__tar.gz → 0.3.0__tar.gz

{urlpattern-0.2.0 → urlpattern-0.3.0}/Cargo.lock

@@ -389,9 +389,11 @@ dependencies = [
 
 [[package]]
 name = "urlpattern"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "pyo3",
+ "regex",
+ "url",
  "urlpattern 0.6.0",
 ]
 

{urlpattern-0.2.0 → urlpattern-0.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "urlpattern"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["방성범 (Bang Seongbeom) <bangseongbeom@gmail.com>"]
 edition = "2024"
 description = "An implementation of the URL Pattern Standard for Python written in Rust."
@@ -15,5 +15,7 @@ readme = "README.md"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = "0.28.2"
 deno-urlpattern = { version = "0.6.0", package = "urlpattern" }
+pyo3 = "0.28.2"
+regex = "1.12.3"
+url = "2.5.8"

{urlpattern-0.2.0 → urlpattern-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urlpattern
-Version: 0.2.0
+Version: 0.3.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -158,3 +158,9 @@ Due to limitations in the dependency [denoland/rust-urlpattern](https://github.c
 
 Check `pytest.skip` in [`tests/test_lib.py`](https://github.com/urlpattern/python-urlpattern/blob/main/tests/test_lib.py).
 
+## Why camelCase?
+
+In this library, some names such as `baseURL` and `hasRegExpGroups` do not use snake_case.
+
+Like [`xml.dom`](https://docs.python.org/3/library/xml.dom.html), Python wrappers around web standards typically preserve the original camelCase rather than converting names to snake_case. This library follows that convention as well.
+

{urlpattern-0.2.0 → urlpattern-0.3.0}/README.md

@@ -125,3 +125,9 @@ with make_server("", 8000, app) as httpd:
 Due to limitations in the dependency [denoland/rust-urlpattern](https://github.com/denoland/rust-urlpattern), it may not support all features specified in [the standard](https://urlpattern.spec.whatwg.org/).
 
 Check `pytest.skip` in [`tests/test_lib.py`](https://github.com/urlpattern/python-urlpattern/blob/main/tests/test_lib.py).
+
+## Why camelCase?
+
+In this library, some names such as `baseURL` and `hasRegExpGroups` do not use snake_case.
+
+Like [`xml.dom`](https://docs.python.org/3/library/xml.dom.html), Python wrappers around web standards typically preserve the original camelCase rather than converting names to snake_case. This library follows that convention as well.

urlpattern-0.3.0/src/lib.rs

@@ -0,0 +1,479 @@
+#![allow(non_snake_case)]
+
+use pyo3::{
+    BoundObject,
+    exceptions::{PyTypeError, PyValueError},
+    prelude::*,
+    types::{PyDict, PyList, PyString},
+};
+use std::collections::HashMap;
+
+#[pyclass(name = "URLPattern")]
+struct UrlPattern(deno_urlpattern::UrlPattern);
+
+#[pymethods]
+impl UrlPattern {
+    #[new]
+    #[pyo3(signature = (input=None, baseURL=None, options=None))]
+    fn new(
+        input: Option<UrlPatternInput>,
+        baseURL: Option<&Bound<'_, PyAny>>,
+        options: Option<&Bound<'_, PyDict>>,
+    ) -> PyResult<Self> {
+        let (base_url, options) = match baseURL {
+            Some(value) => {
+                if let Ok(options_dict) = value.cast::<PyDict>() {
+                    (None, Some(options_dict))
+                } else if value.is_none() {
+                    (None, options)
+                } else {
+                    (
+                        Some(
+                            value
+                                .extract::<String>()?
+                                .parse::<url::Url>()
+                                .map_err(deno_urlpattern::Error::Url)
+                                .map_err(Error)?,
+                        ),
+                        options,
+                    )
+                }
+            }
+            None => (None, options),
+        };
+
+        if let Some(UrlPatternInput::Init(_)) = input {
+            if let Some(_) = base_url {
+                return Err(PyTypeError::new_err("cannot use dict input with baseURL"));
+            }
+        }
+
+        let init: deno_urlpattern::UrlPatternInit = match input {
+            Some(input) => match input {
+                UrlPatternInput::String(input) => {
+                    deno_urlpattern::UrlPatternInit::parse_constructor_string::<regex::Regex>(
+                        input.as_str(),
+                        base_url,
+                    )
+                    .map_err(Error)?
+                }
+                UrlPatternInput::Init(init) => deno_urlpattern::UrlPatternInit {
+                    protocol: init
+                        .get_item("protocol")?
+                        .map(|v| v.extract::<String>())
+                        .transpose()?,
+                    username: init
+                        .get_item("username")?
+                        .map(|v| v.extract::<String>())
+                        .transpose()?,
+                    password: init
+                        .get_item("password")?
+                        .map(|v| v.extract::<String>())
+                        .transpose()?,
+                    hostname: init
+                        .get_item("hostname")?
+                        .map(|v| v.extract::<String>())
+                        .transpose()?,
+                    port: init
+                        .get_item("port")?
+                        .map(|v| v.extract::<String>())
+                        .transpose()?,
+                    pathname: init
+                        .get_item("pathname")?
+                        .map(|v| v.extract::<String>())
+                        .transpose()?,
+                    search: init
+                        .get_item("search")?
+                        .map(|v| v.extract::<String>())
+                        .transpose()?,
+                    hash: init
+                        .get_item("hash")?
+                        .map(|v| v.extract::<String>())
+                        .transpose()?,
+                    base_url: init
+                        .get_item("baseURL")?
+                        .map(|v| v.extract::<String>())
+                        .transpose()?
+                        .map(|v| v.parse::<url::Url>())
+                        .transpose()
+                        .map_err(deno_urlpattern::Error::Url)
+                        .map_err(Error)?,
+                },
+            },
+            None => deno_urlpattern::UrlPatternInit::default(),
+        };
+        let options = if let Some(options) = options {
+            deno_urlpattern::UrlPatternOptions {
+                ignore_case: options
+                    .get_item("ignoreCase")?
+                    .map(|v| v.extract::<bool>())
+                    .transpose()?
+                    .unwrap_or(false),
+                ..deno_urlpattern::UrlPatternOptions::default()
+            }
+        } else {
+            deno_urlpattern::UrlPatternOptions::default()
+        };
+        Ok(UrlPattern(
+            deno_urlpattern::UrlPattern::parse(init, options).map_err(Error)?,
+        ))
+    }
+
+    fn __repr__(&self, py: Python) -> String {
+        let dict = PyDict::new(py);
+        dict.set_item("protocol", self.0.protocol()).unwrap();
+        dict.set_item("username", self.0.username()).unwrap();
+        dict.set_item("password", self.0.password()).unwrap();
+        dict.set_item("hostname", self.0.hostname()).unwrap();
+        dict.set_item("port", self.0.port()).unwrap();
+        dict.set_item("pathname", self.0.pathname()).unwrap();
+        dict.set_item("search", self.0.search()).unwrap();
+        dict.set_item("hash", self.0.hash()).unwrap();
+        dict.set_item("hasRegExpGroups", self.0.has_regexp_groups())
+            .unwrap();
+        format!("URLPattern({})", dict)
+    }
+
+    #[pyo3(signature = (input=None, baseURL=None))]
+    fn test(&self, input: Option<UrlPatternInput>, baseURL: Option<&str>) -> PyResult<bool> {
+        let input: deno_urlpattern::UrlPatternMatchInput = match input {
+            Some(input) => match input {
+                UrlPatternInput::String(input) => match baseURL {
+                    Some(base_url) => {
+                        let base_url = match url::Url::parse(base_url) {
+                            Ok(url) => url,
+                            Err(_) => return Ok(false),
+                        };
+                        deno_urlpattern::UrlPatternMatchInput::Url(
+                            match url::Url::options()
+                                .base_url(Some(&base_url))
+                                .parse(input.as_ref())
+                            {
+                                Ok(url) => url,
+                                Err(_) => return Ok(false),
+                            },
+                        )
+                    }
+                    None => deno_urlpattern::UrlPatternMatchInput::Url(
+                        match input.parse::<url::Url>() {
+                            Ok(url) => url,
+                            Err(_) => return Ok(false),
+                        },
+                    ),
+                },
+                UrlPatternInput::Init(init) => {
+                    if let Some(_) = baseURL {
+                        return Err(PyTypeError::new_err("cannot use dict input with baseURL"));
+                    }
+
+                    deno_urlpattern::UrlPatternMatchInput::Init(deno_urlpattern::UrlPatternInit {
+                        protocol: init
+                            .get_item("protocol")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        username: init
+                            .get_item("username")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        password: init
+                            .get_item("password")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        hostname: init
+                            .get_item("hostname")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        port: init
+                            .get_item("port")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        pathname: init
+                            .get_item("pathname")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        search: init
+                            .get_item("search")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        hash: init
+                            .get_item("hash")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        base_url: init
+                            .get_item("baseURL")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?
+                            .map(|v| v.parse::<url::Url>())
+                            .transpose()
+                            .map_err(deno_urlpattern::Error::Url)
+                            .map_err(Error)?,
+                    })
+                }
+            },
+            None => deno_urlpattern::UrlPatternMatchInput::Init(
+                deno_urlpattern::UrlPatternInit::default(),
+            ),
+        };
+        Ok(self.0.test(input).map_err(Error)?)
+    }
+
+    #[pyo3(signature = (input=None, baseURL=None))]
+    fn exec<'py>(
+        &self,
+        py: Python<'py>,
+        input: Option<&Bound<'py, PyAny>>,
+        baseURL: Option<&Bound<'py, PyString>>,
+    ) -> PyResult<Option<UrlPatternResult<'py>>> {
+        let urlpattern_input: Option<UrlPatternInput> = input.map(|i| i.extract()).transpose()?;
+        let input: deno_urlpattern::UrlPatternMatchInput = match &urlpattern_input {
+            Some(input) => match input {
+                UrlPatternInput::String(input) => match baseURL {
+                    Some(base_url) => {
+                        let base_url = match url::Url::parse(base_url.to_str()?) {
+                            Ok(url) => url,
+                            Err(_) => return Ok(None),
+                        };
+                        deno_urlpattern::UrlPatternMatchInput::Url(
+                            match url::Url::options()
+                                .base_url(Some(&base_url))
+                                .parse(input.as_ref())
+                            {
+                                Ok(url) => url,
+                                Err(_) => return Ok(None),
+                            },
+                        )
+                    }
+                    None => deno_urlpattern::UrlPatternMatchInput::Url(
+                        match input.parse::<url::Url>() {
+                            Ok(url) => url,
+                            Err(_) => return Ok(None),
+                        },
+                    ),
+                },
+                UrlPatternInput::Init(init) => {
+                    if let Some(_) = baseURL {
+                        return Err(PyTypeError::new_err("cannot use dict input with baseURL"));
+                    }
+
+                    deno_urlpattern::UrlPatternMatchInput::Init(deno_urlpattern::UrlPatternInit {
+                        protocol: init
+                            .get_item("protocol")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        username: init
+                            .get_item("username")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        password: init
+                            .get_item("password")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        hostname: init
+                            .get_item("hostname")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        port: init
+                            .get_item("port")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        pathname: init
+                            .get_item("pathname")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        search: init
+                            .get_item("search")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        hash: init
+                            .get_item("hash")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?,
+                        base_url: init
+                            .get_item("baseURL")?
+                            .map(|v| v.extract::<String>())
+                            .transpose()?
+                            .map(|v| v.parse::<url::Url>())
+                            .transpose()
+                            .map_err(deno_urlpattern::Error::Url)
+                            .map_err(Error)?,
+                    })
+                }
+            },
+            None => deno_urlpattern::UrlPatternMatchInput::Init(
+                deno_urlpattern::UrlPatternInit::default(),
+            ),
+        };
+
+        let Some(result) = self.0.exec(input).map_err(Error)? else {
+            return Ok(None);
+        };
+
+        Ok(Some(UrlPatternResult {
+            inputs: {
+                let mut vec = Vec::new();
+                vec.push(
+                    urlpattern_input.unwrap_or(UrlPatternInput::Init(PyDict::new(py).into_bound())),
+                );
+                if let Some(base_url) = baseURL {
+                    vec.push(UrlPatternInput::String(base_url.to_string()));
+                }
+                vec
+            },
+            protocol: UrlPatternComponentResult {
+                input: result.protocol.input,
+                groups: result.protocol.groups,
+            },
+            username: UrlPatternComponentResult {
+                input: result.username.input,
+                groups: result.username.groups,
+            },
+            password: UrlPatternComponentResult {
+                input: result.password.input,
+                groups: result.password.groups,
+            },
+            hostname: UrlPatternComponentResult {
+                input: result.hostname.input,
+                groups: result.hostname.groups,
+            },
+            port: UrlPatternComponentResult {
+                input: result.port.input,
+                groups: result.port.groups,
+            },
+            pathname: UrlPatternComponentResult {
+                input: result.pathname.input,
+                groups: result.pathname.groups,
+            },
+            search: UrlPatternComponentResult {
+                input: result.search.input,
+                groups: result.search.groups,
+            },
+            hash: UrlPatternComponentResult {
+                input: result.hash.input,
+                groups: result.hash.groups,
+            },
+        }))
+    }
+
+    #[getter]
+    fn protocol(&self) -> PyResult<&str> {
+        Ok(self.0.protocol())
+    }
+
+    #[getter]
+    fn username(&self) -> PyResult<&str> {
+        Ok(self.0.username())
+    }
+
+    #[getter]
+    fn password(&self) -> PyResult<&str> {
+        Ok(self.0.password())
+    }
+
+    #[getter]
+    fn hostname(&self) -> PyResult<&str> {
+        Ok(self.0.hostname())
+    }
+
+    #[getter]
+    fn port(&self) -> PyResult<&str> {
+        Ok(self.0.port())
+    }
+
+    #[getter]
+    fn pathname(&self) -> PyResult<&str> {
+        Ok(self.0.pathname())
+    }
+
+    #[getter]
+    fn search(&self) -> PyResult<&str> {
+        Ok(self.0.search())
+    }
+
+    #[getter]
+    fn hash(&self) -> PyResult<&str> {
+        Ok(self.0.hash())
+    }
+
+    #[getter(hasRegExpGroups)]
+    fn has_regexp_groups(&self) -> PyResult<bool> {
+        Ok(self.0.has_regexp_groups())
+    }
+}
+
+#[derive(FromPyObject)]
+enum UrlPatternInput<'py> {
+    String(String),
+    Init(Bound<'py, PyDict>),
+}
+
+struct UrlPatternResult<'py> {
+    inputs: Vec<UrlPatternInput<'py>>,
+    protocol: UrlPatternComponentResult,
+    username: UrlPatternComponentResult,
+    password: UrlPatternComponentResult,
+    hostname: UrlPatternComponentResult,
+    port: UrlPatternComponentResult,
+    pathname: UrlPatternComponentResult,
+    search: UrlPatternComponentResult,
+    hash: UrlPatternComponentResult,
+}
+
+impl<'py> IntoPyObject<'py> for UrlPatternResult<'py> {
+    type Target = PyDict;
+    type Output = Bound<'py, Self::Target>;
+    type Error = std::convert::Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let dict = PyDict::new(py);
+
+        let inputs = PyList::empty(py);
+        for input in self.inputs {
+            match input {
+                UrlPatternInput::String(string) => {
+                    inputs.append(string).unwrap();
+                }
+                UrlPatternInput::Init(init) => {
+                    inputs.append(init).unwrap();
+                }
+            }
+        }
+
+        dict.set_item("inputs", inputs).unwrap();
+        dict.set_item("protocol", self.protocol).unwrap();
+        dict.set_item("username", self.username).unwrap();
+        dict.set_item("password", self.password).unwrap();
+        dict.set_item("hostname", self.hostname).unwrap();
+        dict.set_item("port", self.port).unwrap();
+        dict.set_item("pathname", self.pathname).unwrap();
+        dict.set_item("search", self.search).unwrap();
+        dict.set_item("hash", self.hash).unwrap();
+        Ok(dict.into_bound())
+    }
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+struct UrlPatternComponentResult {
+    input: String,
+    groups: HashMap<String, Option<String>>,
+}
+
+struct Error(deno_urlpattern::Error);
+
+impl From<Error> for PyErr {
+    fn from(error: Error) -> Self {
+        PyValueError::new_err(error.0.to_string())
+    }
+}
+
+impl From<deno_urlpattern::Error> for Error {
+    fn from(other: deno_urlpattern::Error) -> Self {
+        Self(other)
+    }
+}
+
+/// A Python module implemented in Rust.
+#[pymodule]
+mod urlpattern {
+    #[pymodule_export]
+    use super::UrlPattern;
+}

urlpattern-0.2.0/src/lib.rs

@@ -1,370 +0,0 @@
-#![allow(non_snake_case)]
-
-use std::borrow::Cow;
-use std::collections::HashMap;
-
-use pyo3::{
-    BoundObject,
-    exceptions::PyValueError,
-    prelude::*,
-    types::{PyDict, PyList},
-};
-
-#[pyclass(name = "URLPattern")]
-struct UrlPattern(deno_urlpattern::UrlPattern);
-
-#[pymethods]
-impl UrlPattern {
-    #[new]
-    #[pyo3(signature = (input=None, baseURL=None, options=None))]
-    pub fn new(
-        input: Option<UrlPatternInput>,
-        baseURL: Option<&Bound<'_, PyAny>>,
-        options: Option<&Bound<'_, PyDict>>,
-    ) -> PyResult<Self> {
-        let (base_url, options) = match baseURL {
-            Some(value) => {
-                if let Ok(options_dict) = value.cast::<PyDict>() {
-                    (None, Some(options_dict))
-                } else if value.is_none() {
-                    (None, options)
-                } else {
-                    (Some(value.extract::<String>()?), options)
-                }
-            }
-            None => (None, options),
-        };
-
-        let string_or_init_input = match input {
-            Some(input) => deno_urlpattern::quirks::StringOrInit::try_from(input)?,
-            None => deno_urlpattern::quirks::StringOrInit::Init(
-                deno_urlpattern::quirks::UrlPatternInit::default(),
-            ),
-        };
-        let options = if let Some(options) = options {
-            deno_urlpattern::UrlPatternOptions {
-                ignore_case: options
-                    .get_item("ignoreCase")?
-                    .map(|v| v.extract::<bool>())
-                    .transpose()?
-                    .unwrap_or(false),
-                ..deno_urlpattern::UrlPatternOptions::default()
-            }
-        } else {
-            deno_urlpattern::UrlPatternOptions::default()
-        };
-        Ok(UrlPattern(
-            <deno_urlpattern::UrlPattern>::parse(
-                deno_urlpattern::quirks::process_construct_pattern_input(
-                    string_or_init_input,
-                    base_url.as_deref(),
-                )
-                .map_err(Error)?,
-                options,
-            )
-            .map_err(Error)?,
-        ))
-    }
-
-    pub fn __repr__(&self, py: Python) -> String {
-        let dict = PyDict::new(py);
-        dict.set_item("protocol", self.0.protocol()).unwrap();
-        dict.set_item("username", self.0.username()).unwrap();
-        dict.set_item("password", self.0.password()).unwrap();
-        dict.set_item("hostname", self.0.hostname()).unwrap();
-        dict.set_item("port", self.0.port()).unwrap();
-        dict.set_item("pathname", self.0.pathname()).unwrap();
-        dict.set_item("search", self.0.search()).unwrap();
-        dict.set_item("hash", self.0.hash()).unwrap();
-        dict.set_item("hasRegExpGroups", self.0.has_regexp_groups()).unwrap();
-        format!("URLPattern({})", dict)
-    }
-
-    #[pyo3(signature = (input=None, baseURL=None))]
-    pub fn test(&self, input: Option<UrlPatternInput>, baseURL: Option<&str>) -> PyResult<bool> {
-        let string_or_init_input = match input {
-            Some(input) => deno_urlpattern::quirks::StringOrInit::try_from(input)?,
-            None => deno_urlpattern::quirks::StringOrInit::Init(
-                deno_urlpattern::quirks::UrlPatternInit::default(),
-            ),
-        };
-        let Some((match_input, _)) =
-            deno_urlpattern::quirks::process_match_input(string_or_init_input, baseURL)
-                .map_err(Error)?
-        else {
-            return Ok(false);
-        };
-        Ok(self.0.test(match_input).map_err(Error)?)
-    }
-
-    #[pyo3(signature = (input=None, baseURL=None))]
-    pub fn exec(
-        &self,
-        input: Option<UrlPatternInput>,
-        baseURL: Option<&str>,
-    ) -> PyResult<Option<UrlPatternResult>> {
-        let string_or_init_input = match input {
-            Some(input) => deno_urlpattern::quirks::StringOrInit::try_from(input)?,
-            None => deno_urlpattern::quirks::StringOrInit::Init(
-                deno_urlpattern::quirks::UrlPatternInit::default(),
-            ),
-        };
-        let Some((match_input, inputs)) =
-            deno_urlpattern::quirks::process_match_input(string_or_init_input, baseURL)
-                .map_err(Error)?
-        else {
-            return Ok(None);
-        };
-        let Some(result) = self.0.exec(match_input).map_err(Error)? else {
-            return Ok(None);
-        };
-
-        Ok(Some(UrlPatternResult {
-            inputs,
-            protocol: UrlPatternComponentResult {
-                input: result.protocol.input,
-                groups: result.protocol.groups,
-            },
-            username: UrlPatternComponentResult {
-                input: result.username.input,
-                groups: result.username.groups,
-            },
-            password: UrlPatternComponentResult {
-                input: result.password.input,
-                groups: result.password.groups,
-            },
-            hostname: UrlPatternComponentResult {
-                input: result.hostname.input,
-                groups: result.hostname.groups,
-            },
-            port: UrlPatternComponentResult {
-                input: result.port.input,
-                groups: result.port.groups,
-            },
-            pathname: UrlPatternComponentResult {
-                input: result.pathname.input,
-                groups: result.pathname.groups,
-            },
-            search: UrlPatternComponentResult {
-                input: result.search.input,
-                groups: result.search.groups,
-            },
-            hash: UrlPatternComponentResult {
-                input: result.hash.input,
-                groups: result.hash.groups,
-            },
-        }))
-    }
-
-    #[getter]
-    pub fn get_protocol(&self) -> PyResult<&str> {
-        Ok(self.0.protocol())
-    }
-
-    #[getter]
-    pub fn get_username(&self) -> PyResult<&str> {
-        Ok(self.0.username())
-    }
-
-    #[getter]
-    pub fn get_password(&self) -> PyResult<&str> {
-        Ok(self.0.password())
-    }
-
-    #[getter]
-    pub fn get_hostname(&self) -> PyResult<&str> {
-        Ok(self.0.hostname())
-    }
-
-    #[getter]
-    pub fn get_port(&self) -> PyResult<&str> {
-        Ok(self.0.port())
-    }
-
-    #[getter]
-    pub fn get_pathname(&self) -> PyResult<&str> {
-        Ok(self.0.pathname())
-    }
-
-    #[getter]
-    pub fn get_search(&self) -> PyResult<&str> {
-        Ok(self.0.search())
-    }
-
-    #[getter]
-    pub fn get_hash(&self) -> PyResult<&str> {
-        Ok(self.0.hash())
-    }
-
-    #[getter]
-    pub fn get_hasRegExpGroups(&self) -> PyResult<bool> {
-        Ok(self.0.has_regexp_groups())
-    }
-}
-
-#[derive(FromPyObject)]
-pub enum UrlPatternInput<'py> {
-    String(String),
-    Init(Bound<'py, PyDict>),
-}
-
-impl<'py> TryFrom<UrlPatternInput<'py>> for deno_urlpattern::quirks::StringOrInit<'static> {
-    type Error = pyo3::PyErr;
-
-    fn try_from(input: UrlPatternInput<'py>) -> Result<Self, Self::Error> {
-        Ok(match input {
-            UrlPatternInput::String(pattern) => {
-                deno_urlpattern::quirks::StringOrInit::String(Cow::Owned(pattern))
-            }
-            UrlPatternInput::Init(init) => deno_urlpattern::quirks::StringOrInit::Init(
-                deno_urlpattern::quirks::UrlPatternInit {
-                    protocol: init
-                        .get_item("protocol")?
-                        .map(|v| v.extract::<String>())
-                        .transpose()?,
-                    username: init
-                        .get_item("username")?
-                        .map(|v| v.extract::<String>())
-                        .transpose()?,
-                    password: init
-                        .get_item("password")?
-                        .map(|v| v.extract::<String>())
-                        .transpose()?,
-                    hostname: init
-                        .get_item("hostname")?
-                        .map(|v| v.extract::<String>())
-                        .transpose()?,
-                    port: init
-                        .get_item("port")?
-                        .map(|v| v.extract::<String>())
-                        .transpose()?,
-                    pathname: init
-                        .get_item("pathname")?
-                        .map(|v| v.extract::<String>())
-                        .transpose()?,
-                    search: init
-                        .get_item("search")?
-                        .map(|v| v.extract::<String>())
-                        .transpose()?,
-                    hash: init
-                        .get_item("hash")?
-                        .map(|v| v.extract::<String>())
-                        .transpose()?,
-                    base_url: init
-                        .get_item("baseURL")?
-                        .map(|v| v.extract::<String>())
-                        .transpose()?,
-                },
-            ),
-        })
-    }
-}
-
-pub struct UrlPatternResult {
-    pub inputs: (
-        deno_urlpattern::quirks::StringOrInit<'static>,
-        Option<String>,
-    ),
-    pub protocol: UrlPatternComponentResult,
-    pub username: UrlPatternComponentResult,
-    pub password: UrlPatternComponentResult,
-    pub hostname: UrlPatternComponentResult,
-    pub port: UrlPatternComponentResult,
-    pub pathname: UrlPatternComponentResult,
-    pub search: UrlPatternComponentResult,
-    pub hash: UrlPatternComponentResult,
-}
-
-impl<'py> IntoPyObject<'py> for UrlPatternResult {
-    type Target = PyDict;
-    type Output = Bound<'py, Self::Target>;
-    type Error = std::convert::Infallible;
-
-    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
-        let dict = PyDict::new(py);
-
-        let (string_or_init, base_url) = self.inputs;
-        let list = PyList::empty(py);
-
-        match string_or_init {
-            deno_urlpattern::quirks::StringOrInit::String(string) => {
-                list.append(string.into_owned()).unwrap();
-            }
-            deno_urlpattern::quirks::StringOrInit::Init(init) => {
-                let init_dict = PyDict::new(py);
-                if let Some(protocol) = init.protocol {
-                    init_dict.set_item("protocol", protocol).unwrap();
-                }
-                if let Some(username) = init.username {
-                    init_dict.set_item("username", username).unwrap();
-                }
-                if let Some(password) = init.password {
-                    init_dict.set_item("password", password).unwrap();
-                }
-                if let Some(hostname) = init.hostname {
-                    init_dict.set_item("hostname", hostname).unwrap();
-                }
-                if let Some(port) = init.port {
-                    init_dict.set_item("port", port).unwrap();
-                }
-                if let Some(pathname) = init.pathname {
-                    init_dict.set_item("pathname", pathname).unwrap();
-                }
-                if let Some(search) = init.search {
-                    init_dict.set_item("search", search).unwrap();
-                }
-                if let Some(hash) = init.hash {
-                    init_dict.set_item("hash", hash).unwrap();
-                }
-                if let Some(base_url) = init.base_url {
-                    init_dict.set_item("baseURL", base_url).unwrap();
-                }
-                list.append(init_dict).unwrap();
-            }
-        }
-
-        if let Some(base_url) = base_url {
-            list.append(base_url).unwrap();
-        }
-
-        dict.set_item("inputs", list).unwrap();
-
-        dict.set_item("protocol", self.protocol).unwrap();
-        dict.set_item("username", self.username).unwrap();
-        dict.set_item("password", self.password).unwrap();
-        dict.set_item("hostname", self.hostname).unwrap();
-        dict.set_item("port", self.port).unwrap();
-        dict.set_item("pathname", self.pathname).unwrap();
-        dict.set_item("search", self.search).unwrap();
-        dict.set_item("hash", self.hash).unwrap();
-
-        Ok(dict.into_bound())
-    }
-}
-
-#[derive(IntoPyObject, IntoPyObjectRef)]
-pub struct UrlPatternComponentResult {
-    input: String,
-    groups: HashMap<String, Option<String>>,
-}
-
-pub struct Error(deno_urlpattern::Error);
-
-impl From<Error> for PyErr {
-    fn from(error: Error) -> Self {
-        PyValueError::new_err(error.0.to_string())
-    }
-}
-
-impl From<deno_urlpattern::Error> for Error {
-    fn from(other: deno_urlpattern::Error) -> Self {
-        Self(other)
-    }
-}
-
-/// A Python module implemented in Rust.
-#[pymodule]
-mod urlpattern {
-    #[pymodule_export]
-    use super::UrlPattern;
-}