Upgrade pyo3, add .expect to dictionary access

Author: Fahad Zubair

rust-runtime/aws-smithy-http-server-python/Cargo.toml

@@ -29,8 +29,8 @@ lambda_http = { version = "0.8.3" }
 num_cpus = "1.13.1"
 parking_lot = "0.12.1"
 pin-project-lite = "0.2.14"
-pyo3 = "0.18.2"
-pyo3-asyncio = { version = "0.18.0", features = ["tokio-runtime"] }
+pyo3 = "0.20"
+pyo3-asyncio = { version = "0.20.0", features = ["tokio-runtime"] }
 signal-hook = { version = "0.3.14", features = ["extended-siginfo"] }
 socket2 = { version = "0.5.5", features = ["all"] }
 thiserror = "1.0.40"
@@ -46,7 +46,7 @@ pretty_assertions = "1"
 futures-util = { version = "0.3.29", default-features = false }
 tower-test = "0.4"
 tokio-test = "0.4"
-pyo3-asyncio = { version = "0.18.0", features = ["testing", "attributes", "tokio-runtime", "unstable-streams"] }
+pyo3-asyncio = { version = "0.20.0", features = ["testing", "attributes", "tokio-runtime", "unstable-streams"] }
 rcgen = "0.10.0"
 hyper-rustls = { version = "0.24", features = ["http2"] }
 

rust-runtime/aws-smithy-http-server-python/src/context/layer.rs

@@ -107,8 +107,16 @@ counter = ctx.counter
                     .unwrap();
 
                     (
-                        locals.get_item("req_id").unwrap().to_string(),
-                        locals.get_item("counter").unwrap().to_string(),
+                        locals
+                            .get_item("req_id")
+                            .expect("Python exception occurred during dictionary lookup")
+                            .unwrap()
+                            .to_string(),
+                        locals
+                            .get_item("counter")
+                            .expect("Python exception occurred during dictionary lookup")
+                            .unwrap()
+                            .to_string(),
                     )
                 });
                 Ok::<_, Infallible>(Response::new((req_id, counter)))

rust-runtime/aws-smithy-http-server-python/src/error.rs

@@ -44,7 +44,6 @@ impl From<PyError> for PyErr {
 /// :param status_code typing.Optional\[int\]:
 /// :rtype None:
 #[pyclass(name = "MiddlewareException", extends = BasePyException)]
-#[pyo3(text_signature = "($self, message, status_code=None)")]
 #[derive(Debug, Clone)]
 pub struct PyMiddlewareException {
     /// :type str:
@@ -59,6 +58,7 @@ pub struct PyMiddlewareException {
 #[pymethods]
 impl PyMiddlewareException {
     /// Create a new [PyMiddlewareException].
+    #[pyo3(text_signature = "($self, message, status_code=None)")]
     #[new]
     fn newpy(message: String, status_code: Option<u16>) -> Self {
         Self {

rust-runtime/aws-smithy-http-server-python/src/logging.rs

@@ -127,14 +127,14 @@ fn setup_tracing_subscriber(
 /// :param format typing.Optional\[typing.Literal\['compact', 'pretty', 'json'\]\]:
 /// :rtype None:
 #[pyclass(name = "TracingHandler")]
-#[pyo3(text_signature = "($self, level=None, logfile=None, format=None)")]
 #[derive(Debug)]
 pub struct PyTracingHandler {
     _guard: Option<WorkerGuard>,
 }
 
 #[pymethods]
 impl PyTracingHandler {
+    #[pyo3(text_signature = "($self, level=None, logfile=None, format=None)")]
     #[new]
     fn newpy(
         py: Python,

rust-runtime/aws-smithy-http-server-python/src/middleware/pytests/layer.rs

@@ -321,6 +321,7 @@ fn py_handler(code: &str) -> PyMiddlewareHandler {
         py.run(code, Some(globals), Some(locals))?;
         let handler = locals
             .get_item("middleware")
+            .expect("Python exception occurred during dictionary lookup")
             .expect("your handler must be named `middleware`")
             .into();
         PyMiddlewareHandler::new(py, handler)

rust-runtime/aws-smithy-http-server-python/src/middleware/pytests/response.rs

@@ -27,7 +27,12 @@ response = Response(200, {"Content-Type": "application/json"}, b"hello world")
         )
         .unwrap();
 
-        let py_response: Py<PyResponse> = locals.get_item("response").unwrap().extract().unwrap();
+        let py_response: Py<PyResponse> = locals
+            .get_item("response")
+            .expect("Python exception occurred during dictionary lookup")
+            .unwrap()
+            .extract()
+            .unwrap();
         let response = py_response.borrow_mut(py).take_inner();
         response.unwrap()
     });

rust-runtime/aws-smithy-http-server-python/src/middleware/response.rs

@@ -23,7 +23,6 @@ use super::{PyHeaderMap, PyMiddlewareError};
 /// :param body typing.Optional[bytes]:
 /// :rtype None:
 #[pyclass(name = "Response")]
-#[pyo3(text_signature = "($self, status, headers=None, body=None)")]
 pub struct PyResponse {
     parts: Option<Parts>,
     headers: PyHeaderMap,
@@ -61,6 +60,7 @@ impl PyResponse {
 #[pymethods]
 impl PyResponse {
     /// Python-compatible [Response] object from the Python side.
+    #[pyo3(text_signature = "($self, status, headers=None, body=None)")]
     #[new]
     fn newpy(
         status: u16,

rust-runtime/aws-smithy-http-server-python/src/socket.rs

@@ -25,7 +25,7 @@ use std::net::SocketAddr;
 /// :param port int:
 /// :param backlog typing.Optional\[int\]:
 /// :rtype None:
-#[pyclass(text_signature = "($self, address, port, backlog=None)")]
+#[pyclass]
 #[derive(Debug)]
 pub struct PySocket {
     pub(crate) inner: Socket,
@@ -35,6 +35,7 @@ pub struct PySocket {
 impl PySocket {
     /// Create a new UNIX `SharedSocket` from an address, port and backlog.
     /// If not specified, the backlog defaults to 1024 connections.
+    #[pyo3(text_signature = "($self, address, port, backlog=None)")]
     #[new]
     pub fn new(address: String, port: i32, backlog: Option<i32>) -> PyResult<Self> {
         let address: SocketAddr = format!("{}:{}", address, port).parse()?;

rust-runtime/aws-smithy-http-server-python/src/tls.rs

@@ -25,10 +25,7 @@ pub mod listener;
 /// :param cert_path pathlib.Path:
 /// :param reload_secs int:
 /// :rtype None:
-#[pyclass(
-    name = "TlsConfig",
-    text_signature = "($self, *, key_path, cert_path, reload_secs=86400)"
-)]
+#[pyclass(name = "TlsConfig")]
 #[derive(Clone)]
 pub struct PyTlsConfig {
     /// Absolute path of the RSA or PKCS private key.
@@ -105,6 +102,7 @@ impl PyTlsConfig {
 #[pymethods]
 impl PyTlsConfig {
     #[new]
+    #[pyo3(text_signature = "($self, *, key_path, cert_path, reload_secs=86400)")]
     #[pyo3(signature = (key_path, cert_path, reload_secs=86400))]
     fn py_new(key_path: PathBuf, cert_path: PathBuf, reload_secs: u64) -> Self {
         // TODO(BugOnUpstream): `reload: &PyDelta` segfaults, create an issue on PyO3
@@ -172,7 +170,11 @@ config = TlsConfig(key_path=TEST_KEY, cert_path=TEST_CERT, reload_secs=1000)
                 Some(globals),
                 Some(locals),
             )?;
-            locals.get_item("config").unwrap().extract::<PyTlsConfig>()
+            locals
+                .get_item("config")
+                .expect("Python exception occurred during dictionary lookup")
+                .unwrap()
+                .extract::<PyTlsConfig>()
         })?;
 
         assert_eq!(PathBuf::from_str(TEST_KEY).unwrap(), config.key_path);

rust-runtime/aws-smithy-http-server-python/src/util.rs

@@ -158,19 +158,43 @@ class Types:
 
             assert_eq!(
                 true,
-                is_optional_of::<PyString>(py, type_hints.get_item("opt_of_str").unwrap())?
+                is_optional_of::<PyString>(
+                    py,
+                    type_hints
+                        .get_item("opt_of_str")
+                        .expect("Python exception occurred during dictionary lookup")
+                        .unwrap()
+                )?
             );
             assert_eq!(
                 false,
-                is_optional_of::<PyString>(py, type_hints.get_item("regular_str").unwrap())?
+                is_optional_of::<PyString>(
+                    py,
+                    type_hints
+                        .get_item("regular_str")
+                        .expect("Python exception occurred during dictionary lookup")
+                        .unwrap()
+                )?
             );
             assert_eq!(
                 true,
-                is_optional_of::<PyBool>(py, type_hints.get_item("opt_of_bool").unwrap())?
+                is_optional_of::<PyBool>(
+                    py,
+                    type_hints
+                        .get_item("opt_of_bool")
+                        .expect("Python exception occurred during dictionary lookup")
+                        .unwrap()
+                )?
             );
             assert_eq!(
                 false,
-                is_optional_of::<PyString>(py, type_hints.get_item("opt_of_bool").unwrap())?
+                is_optional_of::<PyString>(
+                    py,
+                    type_hints
+                        .get_item("opt_of_bool")
+                        .expect("Python exception occurred during dictionary lookup")
+                        .unwrap()
+                )?
             );
 
             Ok(())