Merge pull request #71 from RustPython/master

Sync Fork from Upstream

Author: sthagen

Lib/pprint.py

@@ -41,33 +41,38 @@
 from io import StringIO as _StringIO
 
 __all__ = ["pprint","pformat","isreadable","isrecursive","saferepr",
-           "PrettyPrinter"]
+           "PrettyPrinter", "pp"]
 
 
 def pprint(object, stream=None, indent=1, width=80, depth=None, *,
-           compact=False):
+           compact=False, sort_dicts=True):
     """Pretty-print a Python object to a stream [default is sys.stdout]."""
     printer = PrettyPrinter(
         stream=stream, indent=indent, width=width, depth=depth,
-        compact=compact)
+        compact=compact, sort_dicts=sort_dicts)
     printer.pprint(object)
 
-def pformat(object, indent=1, width=80, depth=None, *, compact=False):
+def pformat(object, indent=1, width=80, depth=None, *,
+            compact=False, sort_dicts=True):
     """Format a Python object into a pretty-printed representation."""
     return PrettyPrinter(indent=indent, width=width, depth=depth,
-                         compact=compact).pformat(object)
+                         compact=compact, sort_dicts=sort_dicts).pformat(object)
+
+def pp(object, *args, sort_dicts=False, **kwargs):
+    """Pretty-print a Python object"""
+    pprint(object, *args, sort_dicts=sort_dicts, **kwargs)
 
 def saferepr(object):
     """Version of repr() which can handle recursive data structures."""
-    return _safe_repr(object, {}, None, 0)[0]
+    return _safe_repr(object, {}, None, 0, True)[0]
 
 def isreadable(object):
     """Determine if saferepr(object) is readable by eval()."""
-    return _safe_repr(object, {}, None, 0)[1]
+    return _safe_repr(object, {}, None, 0, True)[1]
 
 def isrecursive(object):
     """Determine if object requires a recursive representation."""
-    return _safe_repr(object, {}, None, 0)[2]
+    return _safe_repr(object, {}, None, 0, True)[2]
 
 class _safe_key:
     """Helper function for key functions when sorting unorderable objects.
@@ -97,7 +102,7 @@ def _safe_tuple(t):
 
 class PrettyPrinter:
     def __init__(self, indent=1, width=80, depth=None, stream=None, *,
-                 compact=False):
+                 compact=False, sort_dicts=True):
         """Handle pretty printing operations onto a stream using a set of
         configured parameters.
 
@@ -117,6 +122,9 @@ def __init__(self, indent=1, width=80, depth=None, stream=None, *,
         compact
             If true, several items will be combined in one line.
 
+        sort_dicts
+            If true, dict keys are sorted.
+
         """
         indent = int(indent)
         width = int(width)
@@ -134,6 +142,7 @@ def __init__(self, indent=1, width=80, depth=None, stream=None, *,
         else:
             self._stream = _sys.stdout
         self._compact = bool(compact)
+        self._sort_dicts = sort_dicts
 
     def pprint(self, object):
         self._format(object, self._stream, 0, 0, {}, 0)
@@ -184,7 +193,10 @@ def _pprint_dict(self, object, stream, indent, allowance, context, level):
             write((self._indent_per_level - 1) * ' ')
         length = len(object)
         if length:
-            items = sorted(object.items(), key=_safe_tuple)
+            if self._sort_dicts:
+                items = sorted(object.items(), key=_safe_tuple)
+            else:
+                items = object.items()
             self._format_dict_items(items, stream, indent, allowance + 1,
                                     context, level)
         write('}')
@@ -402,7 +414,7 @@ def format(self, object, context, maxlevels, level):
         and flags indicating whether the representation is 'readable'
         and whether the object represents a recursive construct.
         """
-        return _safe_repr(object, context, maxlevels, level)
+        return _safe_repr(object, context, maxlevels, level, self._sort_dicts)
 
     def _pprint_default_dict(self, object, stream, indent, allowance, context, level):
         if not len(object):
@@ -487,7 +499,7 @@ def _pprint_user_string(self, object, stream, indent, allowance, context, level)
 
 # Return triple (repr_string, isreadable, isrecursive).
 
-def _safe_repr(object, context, maxlevels, level):
+def _safe_repr(object, context, maxlevels, level, sort_dicts):
     typ = type(object)
     if typ in _builtin_scalars:
         return repr(object), True, False
@@ -507,11 +519,13 @@ def _safe_repr(object, context, maxlevels, level):
         components = []
         append = components.append
         level += 1
-        saferepr = _safe_repr
-        items = sorted(object.items(), key=_safe_tuple)
+        if sort_dicts:
+            items = sorted(object.items(), key=_safe_tuple)
+        else:
+            items = object.items()
         for k, v in items:
-            krepr, kreadable, krecur = saferepr(k, context, maxlevels, level)
-            vrepr, vreadable, vrecur = saferepr(v, context, maxlevels, level)
+            krepr, kreadable, krecur = _safe_repr(k, context, maxlevels, level, sort_dicts)
+            vrepr, vreadable, vrecur = _safe_repr(v, context, maxlevels, level, sort_dicts)
             append("%s: %s" % (krepr, vrepr))
             readable = readable and kreadable and vreadable
             if krecur or vrecur:
@@ -543,7 +557,7 @@ def _safe_repr(object, context, maxlevels, level):
         append = components.append
         level += 1
         for o in object:
-            orepr, oreadable, orecur = _safe_repr(o, context, maxlevels, level)
+            orepr, oreadable, orecur = _safe_repr(o, context, maxlevels, level, sort_dicts)
             append(orepr)
             if not oreadable:
                 readable = False
@@ -568,9 +582,9 @@ def _perfcheck(object=None):
     if object is None:
         object = [("string", (1, 2), [3, 4], {5: 6, 7: 8})] * 100000
     p = PrettyPrinter()
-    t1 = time.time()
-    _safe_repr(object, {}, None, 0)
-    t2 = time.time()
+    t1 = time.perf_counter()
+    _safe_repr(object, {}, None, 0, True)
+    t2 = time.perf_counter()
     p.pformat(object)
     t3 = time.time()
     print("_safe_repr:", t2 - t1)

Lib/test/test_pprint.py

@@ -76,8 +76,6 @@ def setUp(self):
         self.b = list(range(200))
         self.a[-12] = self.b
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_init(self):
         pp = pprint.PrettyPrinter()
         pp = pprint.PrettyPrinter(indent=4, width=40, depth=5,
@@ -300,8 +298,6 @@ def test_sorted_dict(self):
         self.assertEqual(pprint.pformat({"xy\tab\n": (3,), 5: [[]], (): {}}),
             r"{5: [[]], 'xy\tab\n': (3,), (): {}}")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_sort_dict(self):
         d = dict.fromkeys('cba')
         self.assertEqual(pprint.pformat(d, sort_dicts=False), "{'c': None, 'b': None, 'a': None}")

vm/src/builtins/int.rs

@@ -19,8 +19,9 @@ use crate::slots::{Comparable, Hashable, PyComparisonOp};
 use crate::VirtualMachine;
 use crate::{bytesinner::PyBytesInner, byteslike::try_bytes_like};
 use crate::{
-    IdProtocol, IntoPyObject, IntoPyResult, PyArithmaticValue, PyClassImpl, PyComparisonValue,
-    PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol,
+    try_value_from_borrowed_object, IdProtocol, IntoPyObject, IntoPyResult, PyArithmaticValue,
+    PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue,
+    TryFromBorrowedObject, TypeProtocol,
 };
 use rustpython_common::hash;
 
@@ -101,10 +102,11 @@ where
 
 macro_rules! impl_try_from_object_int {
     ($(($t:ty, $to_prim:ident),)*) => {$(
-        impl TryFromObject for $t {
-            fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-                let int = PyIntRef::try_from_object(vm, obj)?;
-                try_to_primitive(&int.value, vm)
+        impl TryFromBorrowedObject for $t {
+            fn try_from_borrowed_object(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<Self> {
+                try_value_from_borrowed_object(vm, obj, |int: &PyInt| {
+                    try_to_primitive(int.as_bigint(), vm)
+                })
             }
         }
     )*};

vm/src/builtins/make_module.rs

@@ -13,7 +13,7 @@ mod decl {
     use crate::builtins::code::PyCodeRef;
     use crate::builtins::dict::PyDictRef;
     use crate::builtins::function::{PyCellRef, PyFunctionRef};
-    use crate::builtins::int::PyIntRef;
+    use crate::builtins::int::{self, PyIntRef};
     use crate::builtins::iter::{PyCallableIterator, PySequenceIterator};
     use crate::builtins::list::{PyList, SortOptions};
     use crate::builtins::pybool::IntoPyBool;
@@ -161,7 +161,7 @@ mod decl {
 
                 let flags = args
                     .flags
-                    .map_or(Ok(0), |v| i32::try_from_object(vm, v.into_object()))?;
+                    .map_or(Ok(0), |v| int::try_to_primitive(v.as_bigint(), vm))?;
 
                 if (flags & ast::PY_COMPILE_FLAG_AST_ONLY).is_zero() {
                     #[cfg(not(feature = "rustpython-compiler"))]

vm/src/builtins/pybool.rs

@@ -6,8 +6,8 @@ use super::pystr::PyStrRef;
 use crate::function::OptionalArg;
 use crate::vm::VirtualMachine;
 use crate::{
-    IdProtocol, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyResult, TryFromObject,
-    TypeProtocol,
+    IdProtocol, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyResult, TryFromBorrowedObject,
+    TryFromObject, TypeProtocol,
 };
 
 impl IntoPyObject for bool {
@@ -16,10 +16,10 @@ impl IntoPyObject for bool {
     }
 }
 
-impl TryFromObject for bool {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<bool> {
+impl TryFromBorrowedObject for bool {
+    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<bool> {
         if obj.isinstance(&vm.ctx.types.int_type) {
-            Ok(get_value(&obj))
+            Ok(get_value(obj))
         } else {
             Err(vm.new_type_error(format!("Expected type bool, not {}", obj.class().name)))
         }

vm/src/pyobject.rs

@@ -406,6 +406,28 @@ impl Default for PyContext {
     }
 }
 
+pub(crate) fn try_value_from_borrowed_object<T, F, R>(
+    vm: &VirtualMachine,
+    obj: &PyObjectRef,
+    f: F,
+) -> PyResult<R>
+where
+    T: PyValue,
+    F: Fn(&T) -> PyResult<R>,
+{
+    let class = T::class(vm);
+    let special;
+    let py_ref = if obj.isinstance(class) {
+        obj.downcast_ref()
+            .ok_or_else(|| pyref_payload_error(vm, class, obj))?
+    } else {
+        special = T::special_retrieve(vm, obj)
+            .unwrap_or_else(|| Err(pyref_type_error(vm, class, obj)))?;
+        &special
+    };
+    f(py_ref)
+}
+
 impl<T> TryFromObject for PyRef<T>
 where
     T: PyValue,
@@ -433,7 +455,8 @@ fn pyref_payload_error(
         &*obj.borrow().class().name,
     ))
 }
-fn pyref_type_error(
+
+pub(crate) fn pyref_type_error(
     vm: &VirtualMachine,
     class: &PyTypeRef,
     obj: impl std::borrow::Borrow<PyObjectRef>,

vm/src/stdlib/codecs.rs

@@ -11,7 +11,7 @@ mod _codecs {
     use crate::exceptions::PyBaseExceptionRef;
     use crate::function::FuncArgs;
     use crate::VirtualMachine;
-    use crate::{IdProtocol, PyObjectRef, PyResult, TryFromObject};
+    use crate::{IdProtocol, PyObjectRef, PyResult, TryFromBorrowedObject};
 
     #[pyfunction]
     fn register(search_function: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
@@ -156,7 +156,7 @@ mod _codecs {
                         .ok_or_else(tuple_err)?
                         .clone();
                     let restart =
-                        isize::try_from_object(vm, restart.clone()).map_err(|_| tuple_err())?;
+                        isize::try_from_borrowed_object(vm, restart).map_err(|_| tuple_err())?;
                     let restart = if restart < 0 {
                         // will still be out of bounds if it underflows ¯\_(ツ)_/¯
                         data.len().wrapping_sub(restart.unsigned_abs())

vm/src/stdlib/os.rs

@@ -30,7 +30,7 @@ use crate::utils::Either;
 use crate::vm::{ReprGuard, VirtualMachine};
 use crate::{
     IntoPyObject, ItemProtocol, PyObjectRef, PyRef, PyResult, PyStructSequence, PyValue,
-    StaticType, TryFromObject, TypeProtocol,
+    StaticType, TryFromBorrowedObject, TryFromObject, TypeProtocol,
 };
 
 #[cfg(unix)]
@@ -1654,7 +1654,7 @@ mod _os {
 
     #[pyfunction]
     fn truncate(path: PyObjectRef, length: Offset, vm: &VirtualMachine) -> PyResult<()> {
-        if let Ok(fd) = i32::try_from_object(vm, path.clone()) {
+        if let Ok(fd) = i32::try_from_borrowed_object(vm, &path) {
             return ftruncate(fd, length, vm);
         }
         let path = PyPathLike::try_from_object(vm, path)?;
@@ -2867,7 +2867,7 @@ mod posix {
                             "Each file_actions element must be a non-empty tuple".to_owned(),
                         )
                     })?;
-                    let id = i32::try_from_object(vm, id.clone())?;
+                    let id = i32::try_from_borrowed_object(vm, id)?;
                     let id = PosixSpawnFileActionIdentifier::try_from(id).map_err(|_| {
                         vm.new_type_error("Unknown file_actions identifier".to_owned())
                     })?;

vm/src/stdlib/resource.rs

@@ -5,7 +5,7 @@ mod resource {
     use super::super::os;
     use crate::exceptions::IntoPyException;
     use crate::VirtualMachine;
-    use crate::{IntoPyObject, PyObjectRef, PyResult, PyStructSequence, TryFromObject};
+    use crate::{IntoPyObject, PyObjectRef, PyResult, PyStructSequence, TryFromBorrowedObject};
     use std::{io, mem};
 
     cfg_if::cfg_if! {
@@ -111,9 +111,9 @@ mod resource {
     }
 
     struct Limits(libc::rlimit);
-    impl TryFromObject for Limits {
-        fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-            let seq = vm.extract_elements::<libc::rlim_t>(&obj)?;
+    impl TryFromBorrowedObject for Limits {
+        fn try_from_borrowed_object(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<Self> {
+            let seq = vm.extract_elements::<libc::rlim_t>(obj)?;
             match *seq {
                 [cur, max] => Ok(Self(libc::rlimit {
                     rlim_cur: cur & RLIM_INFINITY,

vm/src/stdlib/select.rs

@@ -1,5 +1,5 @@
 use crate::vm::VirtualMachine;
-use crate::{PyObjectRef, PyResult, TryFromObject};
+use crate::{PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject};
 use std::{io, mem};
 
 pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
@@ -72,7 +72,7 @@ struct Selectable {
 
 impl TryFromObject for Selectable {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let fno = RawFd::try_from_object(vm, obj.clone()).or_else(|_| {
+        let fno = RawFd::try_from_borrowed_object(vm, &obj).or_else(|_| {
             let meth = vm.get_method_or_type_error(obj.clone(), "fileno", || {
                 "select arg must be an int or object with a fileno() method".to_owned()
             })?;