hypertor 0.2.2

Tor HTTP client and onion service library with Python bindings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Python response bindings

use pyo3::prelude::*;
use pyo3::types::PyBytes;

use crate::response::Response;

/// HTTP Response for Python
#[pyclass(name = "Response")]
pub struct PyResponse {
    status: u16,
    headers: Vec<(String, String)>,
    body: Vec<u8>,
}

impl From<Response> for PyResponse {
    fn from(resp: Response) -> Self {
        let headers = resp
            .headers()
            .iter()
            .filter_map(|(k, v)| {
                v.to_str()
                    .ok()
                    .map(|v| (k.as_str().to_string(), v.to_string()))
            })
            .collect();

        Self {
            status: resp.status_code(),
            headers,
            body: resp.into_bytes().to_vec(),
        }
    }
}

#[pymethods]
impl PyResponse {
    /// Get the HTTP status code
    #[getter]
    fn status_code(&self) -> u16 {
        self.status
    }

    /// Check if the response is successful (2xx)
    #[getter]
    fn ok(&self) -> bool {
        (200..300).contains(&self.status)
    }

    /// Check if the response is a redirect (3xx)
    #[getter]
    fn is_redirect(&self) -> bool {
        (300..400).contains(&self.status)
    }

    /// Get the response headers as a list of tuples
    #[getter]
    fn headers(&self) -> Vec<(String, String)> {
        self.headers.clone()
    }

    /// Get a specific header value
    fn header(&self, name: &str) -> Option<String> {
        let name_lower = name.to_lowercase();
        self.headers
            .iter()
            .find(|(k, _)| k.to_lowercase() == name_lower)
            .map(|(_, v)| v.clone())
    }

    /// Get the Content-Type header
    #[getter]
    fn content_type(&self) -> Option<String> {
        self.header("content-type")
    }

    /// Get the response body as text
    fn text(&self) -> PyResult<String> {
        String::from_utf8(self.body.clone())
            .map_err(|e| pyo3::exceptions::PyUnicodeDecodeError::new_err(e.to_string()))
    }

    /// Get the response body as bytes
    fn content<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {
        PyBytes::new(py, &self.body)
    }

    /// Get the length of the response body
    fn __len__(&self) -> usize {
        self.body.len()
    }

    /// String representation
    fn __repr__(&self) -> String {
        format!("<Response [{}]>", self.status)
    }

    /// Get the response body as JSON (parsed by Python's json module)
    fn json<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
        let text = self.text()?;
        let json_module = py.import("json")?;
        json_module.call_method1("loads", (text,))
    }
}