RustPython
diff --git a/‎vm/src/stdlib/io.rs‎
Lines changed: 22 additions & 17 deletions b/‎vm/src/stdlib/io.rs‎
Lines changed: 22 additions & 17 deletions
@@ -365,43 +365,48 @@ pub fn io_open(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
         }
     };
 
-    let module = import::import_module(vm, PathBuf::default(), "io").unwrap();
-
-    // Class objects (potentially) consumed by io.open
-    // RawIO: FileIO
-    // Buffered: BufferedWriter, BufferedReader
-    // Text: TextIOWrapper
-    let file_io_class = vm.get_attribute(module.clone(), "FileIO").unwrap();
-    let buffered_writer_class = vm.get_attribute(module.clone(), "BufferedWriter").unwrap();
-    let buffered_reader_class = vm.get_attribute(module.clone(), "BufferedReader").unwrap();
-    let text_io_wrapper_class = vm.get_attribute(module, "TextIOWrapper").unwrap();
+    let io_module = import::import_module(vm, PathBuf::default(), "io").unwrap();
 
     // Construct a FileIO (subclass of RawIOBase)
     // This is subsequently consumed by a Buffered Class.
-    let file_args = vec![file.clone(), vm.ctx.new_str(mode.clone())];
-    let file_io_obj = vm.invoke(file_io_class, file_args)?;
+    let file_io_class = vm.get_attribute(io_module.clone(), "FileIO").unwrap();
+    let file_io_obj = vm.invoke(
+        file_io_class,
+        vec![file.clone(), vm.ctx.new_str(mode.clone())],
+    )?;
 
     // Create Buffered class to consume FileIO. The type of buffered class depends on
     // the operation in the mode.
     // There are 3 possible classes here, each inheriting from the RawBaseIO
     // creating || writing || appending => BufferedWriter
     let buffered = match mode.chars().next().unwrap() {
-        'w' => vm.invoke(buffered_writer_class, vec![file_io_obj.clone()]),
-        'r' => vm.invoke(buffered_reader_class, vec![file_io_obj.clone()]),
+        'w' => {
+            let buffered_writer_class = vm
+                .get_attribute(io_module.clone(), "BufferedWriter")
+                .unwrap();
+            vm.invoke(buffered_writer_class, vec![file_io_obj.clone()])
+        }
+        'r' => {
+            let buffered_reader_class = vm
+                .get_attribute(io_module.clone(), "BufferedReader")
+                .unwrap();
+            vm.invoke(buffered_reader_class, vec![file_io_obj.clone()])
+        }
         //TODO: updating => PyBufferedRandom
         _ => unimplemented!("'a' mode is not yet implemented"),
     };
 
     let io_obj = match typ.chars().next().unwrap() {
         // If the mode is text this buffer type is consumed on construction of
         // a TextIOWrapper which is subsequently returned.
-        't' => vm.invoke(text_io_wrapper_class, vec![buffered.unwrap()]),
-
+        't' => {
+            let text_io_wrapper_class = vm.get_attribute(io_module, "TextIOWrapper").unwrap();
+            vm.invoke(text_io_wrapper_class, vec![buffered.unwrap()])
+        }
         // If the mode is binary this Buffered class is returned directly at
         // this point.
         // For Buffered class construct "raw" IO class e.g. FileIO and pass this into corresponding field
         'b' => buffered,
-
         _ => unreachable!(),
     };
     io_obj