RestrictedPython 8.3__py3-none-any.whl → 8.4__py3-none-any.whl

RestrictedPython/Eval.py

@@ -13,8 +13,12 @@
 """Restricted Python Expressions."""
 
 import ast
+import collections
+import types
+import typing
 
-from .compile import compile_restricted_eval
+from RestrictedPython._types import cast_not_none
+from RestrictedPython.compile import compile_restricted_eval
 
 
 nltosp = str.maketrans('\r\n', '  ')
@@ -22,13 +26,21 @@ nltosp = str.maketrans('\r\n', '  ')
 # No restrictions.
 default_guarded_getattr = getattr
 
+_T = typing.TypeVar('_T')
+_TK = typing.TypeVar('_TK', contravariant=True)
+_TV = typing.TypeVar('_TV', covariant=True)
 
-def default_guarded_getitem(ob, index):
+
+class _GetItem(typing.Protocol[_TK, _TV]):
+    def __getitem__(self, key: _TK) -> _TV: ...
+
+
+def default_guarded_getitem(ob: _GetItem[_TK, _TV], index: _TK) -> _TV:
     # No restrictions.
     return ob[index]
 
 
-def default_guarded_getiter(ob):
+def default_guarded_getiter(ob: _T) -> _T:
     # No restrictions.
     return ob
 
@@ -36,17 +48,18 @@ def default_guarded_getiter(ob):
 class RestrictionCapableEval:
     """A base class for restricted code."""
 
-    globals = {'__builtins__': None}
+    globals: dict[str, typing.Any] = {'__builtins__': None}
+
     # restricted
-    rcode = None
+    rcode: types.CodeType | None = None
 
     # unrestricted
-    ucode = None
+    ucode: types.CodeType | None = None
 
     # Names used by the expression
-    used = None
+    used: tuple[str, ...] | None = None
 
-    def __init__(self, expr):
+    def __init__(self, expr: str):
         """Create a restricted expression
 
         where:
@@ -60,7 +73,7 @@ class RestrictionCapableEval:
         # Catch syntax errors.
         self.prepUnrestrictedCode()
 
-    def prepRestrictedCode(self):
+    def prepRestrictedCode(self) -> None:
         if self.rcode is None:
             result = compile_restricted_eval(self.expr, '<string>')
             if result.errors:
@@ -68,13 +81,12 @@ class RestrictionCapableEval:
             self.used = tuple(result.used_names)
             self.rcode = result.code
 
-    def prepUnrestrictedCode(self):
+    def prepUnrestrictedCode(self) -> None:
         if self.ucode is None:
-            exp_node = compile(
+            exp_node = ast.parse(
                 self.expr,
                 '<string>',
-                'eval',
-                ast.PyCF_ONLY_AST)
+                'eval')
 
             co = compile(exp_node, '<string>', 'eval')
 
@@ -90,7 +102,9 @@ class RestrictionCapableEval:
 
             self.ucode = co
 
-    def eval(self, mapping):
+    def eval(self,
+             mapping: collections.abc.Mapping[str,
+                                              typing.Any]) -> typing.Any:
         # This default implementation is probably not very useful. :-(
         # This is meant to be overridden.
         self.prepRestrictedCode()
@@ -103,11 +117,11 @@ class RestrictionCapableEval:
 
         global_scope.update(self.globals)
 
-        for name in self.used:
+        for name in cast_not_none(self.used):
             if (name not in global_scope) and (name in mapping):
                 global_scope[name] = mapping[name]
 
-        return eval(self.rcode, global_scope)
+        return eval(cast_not_none(self.rcode), global_scope)
 
-    def __call__(self, **kw):
+    def __call__(self, **kw: typing.Any) -> typing.Any:
         return self.eval(kw)

RestrictedPython/Guards.py

@@ -16,6 +16,7 @@
 # DocumentTemplate.DT_UTil contains a few.
 
 import builtins
+import string
 
 from RestrictedPython.transformer import INSPECT_ATTRIBUTES
 
@@ -220,7 +221,7 @@ def _full_write_guard():
     return guard
 
 
-full_write_guard = _full_write_guard()
+full_write_guard = _full_write_guard()  # type: ignore[no-untyped-call]
 
 
 def guarded_setattr(object, name, value):
@@ -238,6 +239,8 @@ safe_builtins['delattr'] = guarded_delattr
 
 
 raise_ = object()
+_FORMATTER_UNSAFE_METHODS = frozenset(('format', 'get_field', 'get_value',
+                                       'vformat'))
 
 
 def safer_getattr(object, name, default=None, getattr=getattr):
@@ -254,6 +257,14 @@ def safer_getattr(object, name, default=None, getattr=getattr):
             (isinstance(object, type) and issubclass(object, str))):
         raise NotImplementedError(
             'Using the format*() methods of `str` is not safe')
+    if object is string and name == 'Formatter':
+        raise NotImplementedError('string.Formatter is not safe')
+    if name in _FORMATTER_UNSAFE_METHODS and (
+            isinstance(object, string.Formatter) or
+            (isinstance(object, type) and
+             issubclass(object, string.Formatter))):
+        raise NotImplementedError(
+            'Using string.Formatter methods is not safe')
     if name in INSPECT_ATTRIBUTES:
         raise AttributeError(
             f'"{name}" is a restricted name,'

RestrictedPython/Limits.py

@@ -10,11 +10,28 @@
 # FOR A PARTICULAR PURPOSE
 #
 ##############################################################################
+import collections.abc
+import typing
 
-limited_builtins = {}
 
+limited_builtins: dict[str, typing.Any] = {}
 
-def limited_range(iFirst, *args):
+
+@typing.overload
+def limited_range(iFirst: int) -> collections.abc.Sequence[int]: ...
+
+
+@typing.overload
+def limited_range(iStart: int, iEnd: int, /
+                  ) -> collections.abc.Sequence[int]: ...
+
+
+@typing.overload
+def limited_range(iStart: int, iEnd: int, iStep: int, /
+                  ) -> collections.abc.Sequence[int]: ...
+
+
+def limited_range(iFirst: int, *args: int) -> collections.abc.Sequence[int]:
     # limited range function from Martijn Pieters
     RANGELIMIT = 1000
     if not len(args):
@@ -41,8 +58,10 @@ def limited_range(iFirst, *args):
 
 limited_builtins['range'] = limited_range
 
+_T = typing.TypeVar('_T')
+
 
-def limited_list(seq):
+def limited_list(seq: collections.abc.Iterable[_T]) -> list[_T]:
     if isinstance(seq, str):
         raise TypeError('cannot convert string to list')
     return list(seq)
@@ -51,7 +70,7 @@ def limited_list(seq):
 limited_builtins['list'] = limited_list
 
 
-def limited_tuple(seq):
+def limited_tuple(seq: collections.abc.Iterable[_T]) -> tuple[_T, ...]:
     if isinstance(seq, str):
         raise TypeError('cannot convert string to tuple')
     return tuple(seq)

RestrictedPython/PrintCollector.py

@@ -15,17 +15,17 @@
 class PrintCollector:
     """Collect written text, and return it when called."""
 
-    def __init__(self, _getattr_=None):
+    def __init__(self, _getattr_=None):  # type: ignore[no-untyped-def]
         self.txt = []
         self._getattr_ = _getattr_
 
-    def write(self, text):
+    def write(self, text: str) -> None:
         self.txt.append(text)
 
-    def __call__(self):
+    def __call__(self) -> str:
         return ''.join(self.txt)
 
-    def _call_print(self, *objects, **kwargs):
+    def _call_print(self, *objects, **kwargs):  # type: ignore[no-untyped-def]
         if kwargs.get('file', None) is None:
             kwargs['file'] = self
         else:

RestrictedPython/Utilities.py

@@ -11,21 +11,24 @@
 #
 ##############################################################################
 
+import collections.abc
 import math
 import random
 import string
+import types
+import typing
 
 
-utility_builtins = {}
+utility_builtins: dict[str, typing.Any] = {}
 
 
 class _AttributeDelegator:
-    def __init__(self, mod, *excludes):
+    def __init__(self, mod: types.ModuleType, *excludes: str):
         """delegate attribute lookups outside *excludes* to module *mod*."""
         self.__mod = mod
         self.__excludes = excludes
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr: str) -> typing.Any:
         if attr in self.__excludes:
             raise NotImplementedError(
                 f"{self.__mod.__name__}.{attr} is not safe")
@@ -50,7 +53,7 @@ except ImportError:
     pass
 
 
-def same_type(arg1, *args):
+def same_type(arg1: object, *args: object) -> bool:
     """Compares the class or type of two or more objects."""
     t = getattr(arg1, '__class__', type(arg1))
     for arg in args:
@@ -61,8 +64,10 @@ def same_type(arg1, *args):
 
 utility_builtins['same_type'] = same_type
 
+_T = typing.TypeVar('_T')
 
-def test(*args):
+
+def test(*args: _T) -> _T | None:
     length = len(args)
     for i in range(1, length, 2):
         if args[i - 1]:
@@ -70,12 +75,22 @@ def test(*args):
 
     if length % 2:
         return args[-1]
+    return None
 
 
 utility_builtins['test'] = test
 
+_TK = typing.TypeVar('_TK')
+_TV = typing.TypeVar('_TV')
+_T_in: typing.TypeAlias = collections.abc.Iterable[_TK | tuple[_TK, _TV]]
+_T_out: typing.TypeAlias = list[tuple[_TK, _TK | _TV]]
+
 
-def reorder(s, with_=None, without=()):
+def reorder(
+        s: _T_in[_TK, _TV],
+        with_: collections.abc.Iterable[typing.Any] | None = None,
+        without: collections.abc.Iterable[typing.Any] = ()
+) -> _T_out[_TK, _TV]:
     # s, with_, and without are sequences treated as sets.
     # The result is subtract(intersect(s, with_), without),
     # unless with_ is None, in which case it is subtract(s, without).

RestrictedPython/_types.py

@@ -0,0 +1,25 @@
+import ast
+import sys
+import typing
+
+
+_T = typing.TypeVar('_T')
+
+
+def cast_not_none(var: _T | None) -> _T:
+    return typing.cast(_T, var)
+
+
+# T_pos_ast are subtypes of ast.AST that have a position
+# (have attributes: lineno, end_lineno, col_offset, and end_col_offset).
+#
+# ast.type_param is a new type in python 3.12 that has a position.
+# TODO: Remove `else` when Support for Python 3.11 is dropped.
+if sys.version_info >= (3, 12):
+    T_pos_ast: typing.TypeAlias = (
+        ast.stmt | ast.expr | ast.excepthandler | ast.arg | ast.keyword
+        | ast.alias | ast.pattern | ast.type_param)
+else:
+    T_pos_ast: typing.TypeAlias = (
+        ast.stmt | ast.expr | ast.excepthandler | ast.arg | ast.keyword
+        | ast.alias | ast.pattern)

RestrictedPython/compile.py

@@ -1,55 +1,84 @@
+from __future__ import annotations
+
 import ast
+import collections.abc
+import os
+import types
+import typing
 import warnings
-from collections import namedtuple
 
 from RestrictedPython._compat import IS_CPYTHON
+from RestrictedPython._types import cast_not_none
 from RestrictedPython.transformer import RestrictingNodeTransformer
+from RestrictedPython.transformer import copy_locations
+
+
+# Temporary workaround for missing _typeshed
+ReadableBuffer: typing.TypeAlias = bytes | bytearray
+
+
+class CompileResult(typing.NamedTuple):
+    code: types.CodeType | None
+    errors: collections.abc.Sequence[str]
+    warnings: collections.abc.Sequence[str]
+    used_names: collections.abc.Mapping[str, bool]
 
 
-CompileResult = namedtuple(
-    'CompileResult', 'code, errors, warnings, used_names')
 syntax_error_template = (
-    'Line {lineno}: {type}: {msg} at statement: {statement!r}')
+    'Line {lineno}: {type}: {msg} at statement: {statement!r}'
+)
 
 NOT_CPYTHON_WARNING = (
     'RestrictedPython is only supported on CPython: use on other Python '
     'implementations may create security issues.'
 )
 
+_T_ast_compilable: typing.TypeAlias = (
+    ast.Module | ast.Expression | ast.Interactive)
+_T_source: typing.TypeAlias = str | ReadableBuffer | _T_ast_compilable
+
 
 def _compile_restricted_mode(
-        source,
-        filename='<string>',
-        mode="exec",
-        flags=0,
-        dont_inherit=False,
-        policy=RestrictingNodeTransformer):
+        source: _T_source,
+        filename: str | bytes | os.PathLike[typing.Any] = '<string>',
+        mode: typing.Literal["exec", "eval", "single"] = "exec",
+        flags: int = 0,
+        dont_inherit: bool = False,
+        policy: type[ast.NodeTransformer] | None = RestrictingNodeTransformer,
+) -> CompileResult:
 
     if not IS_CPYTHON:
         warnings.warn_explicit(
             NOT_CPYTHON_WARNING, RuntimeWarning, 'RestrictedPython', 0)
 
     byte_code = None
-    collected_errors = []
-    collected_warnings = []
-    used_names = {}
+    collected_errors: list[str] = []
+    collected_warnings: list[str] = []
+    used_names: dict[str, bool] = {}
     if policy is None:
         # Unrestricted Source Checks
         byte_code = compile(source, filename, mode=mode, flags=flags,
                             dont_inherit=dont_inherit)
     elif issubclass(policy, RestrictingNodeTransformer):
-        c_ast = None
-        allowed_source_types = [str, ast.Module]
+        allowed_source_types = [
+            str,
+            bytes,
+            bytearray,
+            ast.Module,
+            ast.Expression,
+            ast.Interactive]
         if not issubclass(type(source), tuple(allowed_source_types)):
             raise TypeError('Not allowed source type: '
                             '"{0.__class__.__name__}".'.format(source))
-        c_ast = None
+        c_ast: _T_ast_compilable | None = None
         # workaround for pypy issue https://bitbucket.org/pypy/pypy/issues/2552
-        if isinstance(source, ast.Module):
+        if isinstance(source, (ast.Module, ast.Expression, ast.Interactive)):
             c_ast = source
         else:
             try:
-                c_ast = ast.parse(source, filename, mode)
+                c_ast = typing.cast(
+                    _T_ast_compilable, ast.parse(
+                        source, filename, mode))
             except (TypeError, ValueError) as e:
                 collected_errors.append(str(e))
             except SyntaxError as v:
@@ -78,11 +107,12 @@ def _compile_restricted_mode(
 
 
 def compile_restricted_exec(
-        source,
-        filename='<string>',
-        flags=0,
-        dont_inherit=False,
-        policy=RestrictingNodeTransformer):
+        source: _T_source,
+        filename: str | bytes | os.PathLike[typing.Any] = '<string>',
+        flags: int = 0,
+        dont_inherit: bool = False,
+        policy: type[ast.NodeTransformer] | None = RestrictingNodeTransformer,
+) -> CompileResult:
     """Compile restricted for the mode `exec`."""
     return _compile_restricted_mode(
         source,
@@ -94,11 +124,12 @@ def compile_restricted_exec(
 
 
 def compile_restricted_eval(
-        source,
-        filename='<string>',
-        flags=0,
-        dont_inherit=False,
-        policy=RestrictingNodeTransformer):
+        source: _T_source,
+        filename: str | bytes | os.PathLike[typing.Any] = '<string>',
+        flags: int = 0,
+        dont_inherit: bool = False,
+        policy: type[ast.NodeTransformer] | None = RestrictingNodeTransformer,
+) -> CompileResult:
     """Compile restricted for the mode `eval`."""
     return _compile_restricted_mode(
         source,
@@ -110,11 +141,12 @@ def compile_restricted_eval(
 
 
 def compile_restricted_single(
-        source,
-        filename='<string>',
-        flags=0,
-        dont_inherit=False,
-        policy=RestrictingNodeTransformer):
+        source: _T_source,
+        filename: str | bytes | os.PathLike[typing.Any] = '<string>',
+        flags: int = 0,
+        dont_inherit: bool = False,
+        policy: type[ast.NodeTransformer] | None = RestrictingNodeTransformer,
+) -> CompileResult:
     """Compile restricted for the mode `single`."""
     return _compile_restricted_mode(
         source,
@@ -126,30 +158,40 @@ def compile_restricted_single(
 
 
 def compile_restricted_function(
-        p,  # parameters
-        body,
-        name,
-        filename='<string>',
-        globalize=None,  # List of globals (e.g. ['here', 'context', ...])
-        flags=0,
-        dont_inherit=False,
-        policy=RestrictingNodeTransformer):
+        p: str,  # parameters
+        body: _T_source,
+        name: str,
+        filename: str | bytes | os.PathLike[typing.Any] = '<string>',
+        # List of globals (e.g. ['here', 'context', ...])
+        globalize: list[str] | None = None,
+        flags: int = 0,
+        dont_inherit: bool = False,
+        policy: type[ast.NodeTransformer] | None = RestrictingNodeTransformer,
+) -> CompileResult:
     """Compile a restricted code object for a function.
 
     Documentation see:
     http://restrictedpython.readthedocs.io/en/latest/usage/index.html#RestrictedPython.compile_restricted_function
     """
     # Parse the parameters and body, then combine them.
-    try:
-        body_ast = ast.parse(body, '<func code>', 'exec')
-    except SyntaxError as v:
-        error = syntax_error_template.format(
-            lineno=v.lineno,
-            type=v.__class__.__name__,
-            msg=v.msg,
-            statement=v.text.strip() if v.text else None)
-        return CompileResult(
-            code=None, errors=(error,), warnings=(), used_names=())
+    body_ast: list[ast.stmt]
+    if isinstance(body, ast.Expression):
+        _body_ast = ast.Expr(body.body)
+        copy_locations(_body_ast, body.body)
+        body_ast = [_body_ast]
+    elif isinstance(body, (ast.Module, ast.Interactive)):
+        body_ast = body.body
+    else:
+        try:
+            body_ast = ast.parse(body, '<func code>', 'exec').body
+        except SyntaxError as v:
+            error = syntax_error_template.format(
+                lineno=v.lineno,
+                type=v.__class__.__name__,
+                msg=v.msg,
+                statement=v.text.strip() if v.text else None)
+            return CompileResult(
+                code=None, errors=(error,), warnings=(), used_names={})
 
     # The compiled code is actually executed inside a function
     # (that is called when the code is called) so reading and assigning to a
@@ -157,7 +199,7 @@ def compile_restricted_function(
     # UnboundLocalError.
     # We don't want the user to need to understand this.
     if globalize:
-        body_ast.body.insert(0, ast.Global(globalize))
+        body_ast.insert(0, ast.Global(globalize))
     wrapper_ast = ast.parse('def masked_function_name(%s): pass' % p,
                             '<func wrapper>', 'exec')
     # In case the name you chose for your generated function is not a
@@ -166,7 +208,7 @@ def compile_restricted_function(
     assert isinstance(function_ast, ast.FunctionDef)
     function_ast.name = name
 
-    wrapper_ast.body[0].body = body_ast.body
+    function_ast.body = body_ast
     wrapper_ast = ast.fix_missing_locations(wrapper_ast)
 
     result = _compile_restricted_mode(
@@ -181,18 +223,19 @@ def compile_restricted_function(
 
 
 def compile_restricted(
-        source,
-        filename='<unknown>',
-        mode='exec',
-        flags=0,
-        dont_inherit=False,
-        policy=RestrictingNodeTransformer):
+        source: _T_source,
+        filename: str | bytes | os.PathLike[typing.Any] = '<unknown>',
+        mode: typing.Literal["exec", "eval", "single"] = 'exec',
+        flags: int = 0,
+        dont_inherit: bool = False,
+        policy: type[ast.NodeTransformer] | None = RestrictingNodeTransformer,
+) -> types.CodeType:
     """Replacement for the built-in compile() function.
 
     policy ... `ast.NodeTransformer` class defining the restrictions.
 
     """
-    if mode in ['exec', 'eval', 'single', 'function']:
+    if mode in ['exec', 'eval', 'single']:
         result = _compile_restricted_mode(
             source,
             filename=filename,
@@ -209,4 +252,4 @@ def compile_restricted(
         )
     if result.errors:
         raise SyntaxError(result.errors)
-    return result.code
+    return cast_not_none(result.code)