Rename read_only_list/dict to frozen_list/dict

Since GraphQL.js now uses frozen objects instead of ReadOnlyArrays,
this is a better analogy, and Python already has frozenset().

Replicates graphql/graphql-js@f55c2a3

Author: Cito

docs/modules/pyutils.rst

@@ -20,6 +20,6 @@ PyUtils
 .. autofunction:: or_list
 .. autofunction:: quoted_or_list
 .. autofunction:: suggestion_list
-.. autoclass:: ReadOnlyError
-.. autoclass:: ReadOnlyList
-.. autoclass:: ReadOnlyDict
+.. autoclass:: FrozenError
+.. autoclass:: FrozenList
+.. autoclass:: FrozenDict

docs/modules/validation.rst

@@ -28,7 +28,7 @@ rules in this list has been adjusted to lead to the most clear output when encou
 multiple validation errors:
 
 .. autodata:: specified_rules
-   :annotation: = ReadOnlyList([...])
+   :annotation: = FrozenList([...])
 
 Spec Section: "Executable Definitions"
 

graphql/pyutils/__init__.py

@@ -21,9 +21,9 @@
 from .or_list import or_list
 from .quoted_or_list import quoted_or_list
 from .suggestion_list import suggestion_list
-from .read_only_error import ReadOnlyError
-from .read_only_list import ReadOnlyList
-from .read_only_dict import ReadOnlyDict
+from .frozen_error import FrozenError
+from .frozen_list import FrozenList
+from .frozen_dict import FrozenDict
 
 __all__ = [
     "camel_to_snake",
@@ -41,7 +41,7 @@
     "or_list",
     "quoted_or_list",
     "suggestion_list",
-    "ReadOnlyError",
-    "ReadOnlyList",
-    "ReadOnlyDict",
+    "FrozenError",
+    "FrozenList",
+    "FrozenDict",
 ]

graphql/pyutils/read_only_dict.py renamed to graphql/pyutils/frozen_dict.py

@@ -1,34 +1,34 @@
-__all__ = ["ReadOnlyDict"]
+__all__ = ["FrozenDict"]
 
-from .read_only_error import ReadOnlyError
+from .frozen_error import FrozenError
 
 
-class ReadOnlyDict(dict):
+class FrozenDict(dict):
     """Dictionary that can only be read, but not changed."""
 
     def __delitem__(self, key):
-        raise ReadOnlyError
+        raise FrozenError
 
     def __setitem__(self, key, value):
-        raise ReadOnlyError
+        raise FrozenError
 
     def __add__(self, value):
         return dict.__add__(self, value)
 
     def __iadd__(self, value):
-        raise ReadOnlyError
+        raise FrozenError
 
     def clear(self):
-        raise ReadOnlyError
+        raise FrozenError
 
     def pop(self, key, default=None):
-        raise ReadOnlyError
+        raise FrozenError
 
     def popitem(self):
-        raise ReadOnlyError
+        raise FrozenError
 
     def setdefault(self, key, default=None):
-        raise ReadOnlyError
+        raise FrozenError
 
     def update(self, other=None):
-        raise ReadOnlyError
+        raise FrozenError

graphql/pyutils/frozen_error.py

@@ -0,0 +1,5 @@
+__all__ = ["FrozenError"]
+
+
+class FrozenError(TypeError):
+    """Error when trying to change a frozen (read only) collection."""

graphql/pyutils/read_only_list.py renamed to graphql/pyutils/frozen_list.py

@@ -1,51 +1,51 @@
-__all__ = ["ReadOnlyList"]
+__all__ = ["FrozenList"]
 
-from .read_only_error import ReadOnlyError
+from .frozen_error import FrozenError
 
 
-class ReadOnlyList(list):
+class FrozenList(list):
     """List that can only be read, but not changed."""
 
     def __delitem__(self, key):
-        raise ReadOnlyError
+        raise FrozenError
 
     def __setitem__(self, key, value):
-        raise ReadOnlyError
+        raise FrozenError
 
     def __add__(self, value):
         if isinstance(value, tuple):
             value = list(value)
         return list.__add__(self, value)
 
     def __iadd__(self, value):
-        raise ReadOnlyError
+        raise FrozenError
 
     def __mul__(self, value):
         return list.__mul__(self, value)
 
     def __imul__(self, value):
-        raise ReadOnlyError
+        raise FrozenError
 
     def append(self, x):
-        raise ReadOnlyError
+        raise FrozenError
 
     def extend(self, iterable):
-        raise ReadOnlyError
+        raise FrozenError
 
     def insert(self, i, x):
-        raise ReadOnlyError
+        raise FrozenError
 
     def remove(self, x):
-        raise ReadOnlyError
+        raise FrozenError
 
     def pop(self, i=None):
-        raise ReadOnlyError
+        raise FrozenError
 
     def clear(self):
-        raise ReadOnlyError
+        raise FrozenError
 
     def sort(self, *, key=None, reverse=False):
-        raise ReadOnlyError
+        raise FrozenError
 
     def reverse(self):
-        raise ReadOnlyError
+        raise FrozenError

graphql/pyutils/read_only_error.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, Sequence, cast
 
 from ..language import ast, DirectiveLocation
-from ..pyutils import inspect, ReadOnlyList
+from ..pyutils import inspect, FrozenList
 from .definition import GraphQLArgument, GraphQLInputType, GraphQLNonNull, is_input_type
 from .scalars import GraphQLBoolean, GraphQLString
 
@@ -165,7 +165,7 @@ def assert_directive(directive: Any) -> GraphQLDirective:
 )
 
 
-specified_directives = ReadOnlyList(
+specified_directives = FrozenList(
     [GraphQLIncludeDirective, GraphQLSkipDirective, GraphQLDeprecatedDirective]
 )
 specified_directives.__doc__ = """The full list of specified directives."""

graphql/type/directives.py

@@ -21,7 +21,7 @@
     is_union_type,
 )
 from ..language import DirectiveLocation, print_ast
-from ..pyutils import inspect, ReadOnlyDict
+from ..pyutils import inspect, FrozenDict
 from .scalars import GraphQLBoolean, GraphQLString
 
 __all__ = [
@@ -492,7 +492,7 @@ class TypeKind(Enum):
 
 # Since double underscore names are subject to name mangling in Python,
 # the introspection classes are best imported via this dictionary:
-introspection_types = ReadOnlyDict(
+introspection_types = FrozenDict(
     {
         "__Schema": __Schema,
         "__Directive": __Directive,

graphql/type/introspection.py

@@ -2,7 +2,7 @@
 from typing import Any
 
 from ..error import INVALID
-from ..pyutils import inspect, is_finite, is_integer, ReadOnlyDict
+from ..pyutils import inspect, is_finite, is_integer, FrozenDict
 from ..language.ast import (
     BooleanValueNode,
     FloatValueNode,
@@ -241,7 +241,7 @@ def parse_id_literal(ast, _variables=None):
 )
 
 
-specified_scalar_types = ReadOnlyDict(
+specified_scalar_types = FrozenDict(
     {
         type_.name: type_
         for type_ in (

graphql/type/scalars.py

@@ -1,6 +1,6 @@
 from typing import List
 
-from ..pyutils import ReadOnlyList
+from ..pyutils import FrozenList
 
 from .rules import RuleType
 
@@ -101,7 +101,7 @@
 # The order of the rules in this list has been adjusted to lead to the
 # most clear output when encountering multiple validation errors.
 
-specified_rules: List[RuleType] = ReadOnlyList(
+specified_rules: List[RuleType] = FrozenList(
     [
         ExecutableDefinitionsRule,
         UniqueOperationNamesRule,
@@ -138,7 +138,7 @@
     most clear output when encountering multiple validation errors.
     """
 
-specified_sdl_rules: List[RuleType] = ReadOnlyList(
+specified_sdl_rules: List[RuleType] = FrozenList(
     [
         LoneSchemaDefinitionRule,
         UniqueOperationTypesRule,

graphql/validation/specified_rules.py

@@ -0,0 +1,50 @@
+from pytest import raises
+
+from graphql.pyutils import FrozenError, FrozenDict
+
+
+def describe_frozen_list():
+    def can_read():
+        fd = FrozenDict({1: 2, 3: 4})
+        assert fd == {1: 2, 3: 4}
+        assert list(i for i in fd) == [1, 3]
+        assert fd.copy() == fd
+        assert 3 in fd
+        assert 2 not in fd
+        assert fd[1] == 2
+        with raises(KeyError):
+            fd[2]
+        assert len(fd) == 2
+        assert fd.get(1) == 2
+        assert fd.get(2, 5) == 5
+        assert list(fd.items()) == [(1, 2), (3, 4)]
+        assert list(fd.keys()) == [1, 3]
+        assert list(fd.values()) == [2, 4]
+
+    def cannot_write():
+        fd = FrozenDict({1: 2, 3: 4})
+        with raises(FrozenError):
+            fd[1] = 2
+        with raises(FrozenError):
+            fd[4] = 5
+        with raises(FrozenError):
+            del fd[1]
+        with raises(FrozenError):
+            del fd[3]
+        with raises(FrozenError):
+            fd.clear()
+        with raises(FrozenError):
+            fd.pop(1)
+        with raises(FrozenError):
+            fd.pop(4, 5)
+        with raises(FrozenError):
+            fd.popitem()
+        with raises(FrozenError):
+            fd.setdefault(1, 2)
+        with raises(FrozenError):
+            fd.setdefault(4, 5)
+        with raises(FrozenError):
+            fd.update({1: 2})
+        with raises(FrozenError):
+            fd.update({4: 5})
+        assert fd == {1: 2, 3: 4}

tests/pyutils/test_frozen_dict.py

@@ -0,0 +1,6 @@
+from graphql.pyutils import FrozenError
+
+
+def describe_frozen_error():
+    def frozen_error_is_type_error():
+        assert issubclass(FrozenError, TypeError)

tests/pyutils/test_frozen_error.py

@@ -0,0 +1,78 @@
+from pytest import raises
+
+from graphql.pyutils import FrozenError, FrozenList
+
+
+def describe_frozen_list():
+    def can_read():
+        fl = FrozenList([1, 2, 3])
+        assert fl == [1, 2, 3]
+        assert list(i for i in fl) == fl
+        assert fl.copy() == fl
+        assert 2 in fl
+        assert 4 not in fl
+        assert fl + [4, 5] == [1, 2, 3, 4, 5]
+        assert [4, 5] + fl == [4, 5, 1, 2, 3]
+        assert fl * 2 == [1, 2, 3, 1, 2, 3]
+        assert 2 * fl == [1, 2, 3, 1, 2, 3]
+        assert fl[1] == 2
+        with raises(IndexError):
+            fl[3]
+        assert fl[1:4] == [2, 3]
+        assert fl[::2] == [1, 3]
+        assert len(fl) == 3
+        assert min(fl) == 1
+        assert max(fl) == 3
+        assert sum(fl) == 6
+        assert fl.index(2) == 1
+        with raises(ValueError):
+            fl.index(4)
+        assert fl.count(2) == 1
+        assert fl.count(4) == 0
+        assert list(reversed(fl)) == [3, 2, 1]
+        assert sorted(fl) == [1, 2, 3]
+
+    def cannot_write():
+        fl = FrozenList([1, 2, 3])
+        with raises(FrozenError):
+            fl[1] = 4
+        with raises(FrozenError):
+            fl[1:4] = [4]
+        with raises(FrozenError):
+            del fl[1]
+        with raises(FrozenError):
+            del fl[1:4]
+        with raises(FrozenError):
+            fl[1::2] = [4]
+        with raises(FrozenError):
+            del fl[::2]
+        with raises(FrozenError):
+            fl.append(4)
+        with raises(FrozenError):
+            fl.clear()
+        with raises(FrozenError):
+            fl.extend([4])
+        with raises(FrozenError):
+            fl += [4]
+        with raises(FrozenError):
+            fl *= 2
+        with raises(FrozenError):
+            fl.insert(1, 4)
+        with raises(FrozenError):
+            fl.pop()
+        with raises(FrozenError):
+            fl.remove(2)
+        with raises(FrozenError):
+            fl.sort()
+        with raises(FrozenError):
+            fl.reverse()
+        assert fl == [1, 2, 3]
+
+    def can_add_rol():
+        fl1 = FrozenList([1, 2])
+        rol2 = FrozenList([3, 4])
+        assert fl1 + rol2 == [1, 2, 3, 4]
+
+    def can_add_tuple():
+        fl = FrozenList([1, 2])
+        assert fl + (3, 4) == [1, 2, 3, 4]