Adding upstream version 0.91.0.upstream/0.91.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 957 insertions, 0 deletions

diff --git a/_test/test_issues.py b/_test/test_issues.py
new file mode 100644
index 0000000..65efa95
--- /dev/null
+++ b/_test/test_issues.py
@@ -0,0 +1,957 @@
+# coding: utf-8
+
+import pytest  # NOQA
+
+from .roundtrip import (  # NOQA
+    YAML,
+    dedent,
+    na_round_trip,
+    round_trip,
+    round_trip_dump,
+    round_trip_load,
+    save_and_run,
+)
+
+
+class TestIssues:
+    def test_issue_61(self):
+        s = dedent(
+            """
+        def1: &ANCHOR1
+            key1: value1
+        def: &ANCHOR
+            <<: *ANCHOR1
+            key: value
+        comb:
+            <<: *ANCHOR
+        """
+        )
+        data = round_trip_load(s)
+        assert str(data['comb']) == str(data['def'])
+        assert (
+            str(data['comb']) == "ordereddict([('key', 'value'), ('key1', 'value1')])"
+        )
+
+    def test_issue_82(self, tmpdir):
+        program_src = r'''
+        import ruyaml as yaml
+        import re
+
+        class SINumber(yaml.YAMLObject):
+            PREFIXES = {'k': 1e3, 'M': 1e6, 'G': 1e9}
+            yaml_loader = yaml.Loader
+            yaml_dumper = yaml.Dumper
+            yaml_tag = '!si'
+            yaml_implicit_pattern = re.compile(
+                r'^(?P<value>[0-9]+(?:\.[0-9]+)?)(?P<prefix>[kMG])$')
+
+            @classmethod
+            def from_yaml(cls, loader, node):
+                return cls(node.value)
+
+            @classmethod
+            def to_yaml(cls, dumper, data):
+                return dumper.represent_scalar(cls.yaml_tag, str(data))
+
+            def __init__(self, *args):
+                m = self.yaml_implicit_pattern.match(args[0])
+                self.value = float(m.groupdict()['value'])
+                self.prefix = m.groupdict()['prefix']
+
+            def __str__(self):
+                return str(self.value)+self.prefix
+
+            def __int__(self):
+                return int(self.value*self.PREFIXES[self.prefix])
+
+        # This fails:
+        yaml.add_implicit_resolver(SINumber.yaml_tag, SINumber.yaml_implicit_pattern)
+
+        ret = yaml.load("""
+        [1,2,3, !si 10k, 100G]
+        """, Loader=yaml.Loader)
+        for idx, l in enumerate([1, 2, 3, 10000, 100000000000]):
+            assert int(ret[idx]) == l
+        '''
+        assert save_and_run(dedent(program_src), tmpdir) == 0
+
+    def test_issue_82rt(self, tmpdir):
+        yaml_str = '[1, 2, 3, !si 10k, 100G]\n'
+        x = round_trip(yaml_str, preserve_quotes=True)  # NOQA
+
+    def test_issue_102(self):
+        yaml_str = dedent(
+            """
+        var1: #empty
+        var2: something #notempty
+        var3: {} #empty object
+        var4: {a: 1} #filled object
+        var5: [] #empty array
+        """
+        )
+        x = round_trip(yaml_str, preserve_quotes=True)  # NOQA
+
+    def test_issue_150(self):
+        from ruyaml import YAML
+
+        inp = """\
+        base: &base_key
+          first: 123
+          second: 234
+
+        child:
+          <<: *base_key
+          third: 345
+        """
+        yaml = YAML()
+        data = yaml.load(inp)
+        child = data['child']
+        assert 'second' in dict(**child)
+
+    def test_issue_160(self):
+        from io import StringIO
+
+        s = dedent(
+            """\
+        root:
+            # a comment
+            - {some_key: "value"}
+
+        foo: 32
+        bar: 32
+        """
+        )
+        a = round_trip_load(s)
+        del a['root'][0]['some_key']
+        buf = StringIO()
+        round_trip_dump(a, buf, block_seq_indent=4)
+        exp = dedent(
+            """\
+        root:
+            # a comment
+            - {}
+
+        foo: 32
+        bar: 32
+        """
+        )
+        assert buf.getvalue() == exp
+
+    def test_issue_161(self):
+        yaml_str = dedent(
+            """\
+        mapping-A:
+          key-A:{}
+        mapping-B:
+        """
+        )
+        for comment in ['', ' # no-newline', '  # some comment\n', '\n']:
+            s = yaml_str.format(comment)
+            res = round_trip(s)  # NOQA
+
+    def test_issue_161a(self):
+        yaml_str = dedent(
+            """\
+        mapping-A:
+          key-A:{}
+        mapping-B:
+        """
+        )
+        for comment in ['\n# between']:
+            s = yaml_str.format(comment)
+            res = round_trip(s)  # NOQA
+
+    def test_issue_163(self):
+        s = dedent(
+            """\
+        some-list:
+        # List comment
+        - {}
+        """
+        )
+        x = round_trip(s, preserve_quotes=True)  # NOQA
+
+    json_str = (
+        r'{"sshKeys":[{"name":"AETROS\/google-k80-1","uses":0,"getLastUse":0,'
+        '"fingerprint":"MD5:19:dd:41:93:a1:a3:f5:91:4a:8e:9b:d0:ae:ce:66:4c",'
+        '"created":1509497961}]}'
+    )
+
+    json_str2 = '{"abc":[{"a":"1", "uses":0}]}'
+
+    def test_issue_172(self):
+        x = round_trip_load(TestIssues.json_str2)  # NOQA
+        x = round_trip_load(TestIssues.json_str)  # NOQA
+
+    def test_issue_176(self):
+        # basic request by Stuart Berg
+        from ruyaml import YAML
+
+        yaml = YAML()
+        seq = yaml.load('[1,2,3]')
+        seq[:] = [1, 2, 3, 4]
+
+    def test_issue_176_preserve_comments_on_extended_slice_assignment(self):
+        yaml_str = dedent(
+            """\
+        - a
+        - b  # comment
+        - c  # commment c
+        # comment c+
+        - d
+
+        - e # comment
+        """
+        )
+        seq = round_trip_load(yaml_str)
+        seq[1::2] = ['B', 'D']
+        res = round_trip_dump(seq)
+        assert res == yaml_str.replace(' b ', ' B ').replace(' d\n', ' D\n')
+
+    def test_issue_176_test_slicing(self):
+        mss = round_trip_load('[0, 1, 2, 3, 4]')
+        assert len(mss) == 5
+        assert mss[2:2] == []
+        assert mss[2:4] == [2, 3]
+        assert mss[1::2] == [1, 3]
+
+        # slice assignment
+        m = mss[:]
+        m[2:2] = [42]
+        assert m == [0, 1, 42, 2, 3, 4]
+
+        m = mss[:]
+        m[:3] = [42, 43, 44]
+        assert m == [42, 43, 44, 3, 4]
+        m = mss[:]
+        m[2:] = [42, 43, 44]
+        assert m == [0, 1, 42, 43, 44]
+        m = mss[:]
+        m[:] = [42, 43, 44]
+        assert m == [42, 43, 44]
+
+        # extend slice assignment
+        m = mss[:]
+        m[2:4] = [42, 43, 44]
+        assert m == [0, 1, 42, 43, 44, 4]
+        m = mss[:]
+        m[1::2] = [42, 43]
+        assert m == [0, 42, 2, 43, 4]
+        m = mss[:]
+        with pytest.raises(TypeError, match='too many'):
+            m[1::2] = [42, 43, 44]
+        with pytest.raises(TypeError, match='not enough'):
+            m[1::2] = [42]
+        m = mss[:]
+        m += [5]
+        m[1::2] = [42, 43, 44]
+        assert m == [0, 42, 2, 43, 4, 44]
+
+        # deleting
+        m = mss[:]
+        del m[1:3]
+        assert m == [0, 3, 4]
+        m = mss[:]
+        del m[::2]
+        assert m == [1, 3]
+        m = mss[:]
+        del m[:]
+        assert m == []
+
+    def test_issue_184(self):
+        yaml_str = dedent(
+            """\
+        test::test:
+          # test
+          foo:
+            bar: baz
+        """
+        )
+        d = round_trip_load(yaml_str)
+        d['bar'] = 'foo'
+        d.yaml_add_eol_comment('test1', 'bar')
+        assert round_trip_dump(d) == yaml_str + 'bar: foo # test1\n'
+
+    def test_issue_219(self):
+        yaml_str = dedent(
+            """\
+        [StackName: AWS::StackName]
+        """
+        )
+        d = round_trip_load(yaml_str)  # NOQA
+
+    def test_issue_219a(self):
+        yaml_str = dedent(
+            """\
+        [StackName:
+        AWS::StackName]
+        """
+        )
+        d = round_trip_load(yaml_str)  # NOQA
+
+    def test_issue_220(self, tmpdir):
+        program_src = r'''
+        from ruyaml import YAML
+
+        yaml_str = """\
+        ---
+        foo: ["bar"]
+        """
+
+        yaml = YAML(typ='safe', pure=True)
+        d = yaml.load(yaml_str)
+        print(d)
+        '''
+        assert save_and_run(dedent(program_src), tmpdir, optimized=True) == 0
+
+    def test_issue_221_add(self):
+        from ruyaml.comments import CommentedSeq
+
+        a = CommentedSeq([1, 2, 3])
+        a + [4, 5]
+
+    def test_issue_221_sort(self):
+        from io import StringIO
+
+        from ruyaml import YAML
+
+        yaml = YAML()
+        inp = dedent(
+            """\
+        - d
+        - a  # 1
+        - c  # 3
+        - e  # 5
+        - b  # 2
+        """
+        )
+        a = yaml.load(dedent(inp))
+        a.sort()
+        buf = StringIO()
+        yaml.dump(a, buf)
+        exp = dedent(
+            """\
+        - a  # 1
+        - b  # 2
+        - c  # 3
+        - d
+        - e  # 5
+        """
+        )
+        assert buf.getvalue() == exp
+
+    def test_issue_221_sort_reverse(self):
+        from io import StringIO
+
+        from ruyaml import YAML
+
+        yaml = YAML()
+        inp = dedent(
+            """\
+        - d
+        - a  # 1
+        - c  # 3
+        - e  # 5
+        - b  # 2
+        """
+        )
+        a = yaml.load(dedent(inp))
+        a.sort(reverse=True)
+        buf = StringIO()
+        yaml.dump(a, buf)
+        exp = dedent(
+            """\
+        - e  # 5
+        - d
+        - c  # 3
+        - b  # 2
+        - a  # 1
+        """
+        )
+        assert buf.getvalue() == exp
+
+    def test_issue_221_sort_key(self):
+        from io import StringIO
+
+        from ruyaml import YAML
+
+        yaml = YAML()
+        inp = dedent(
+            """\
+        - four
+        - One    # 1
+        - Three  # 3
+        - five   # 5
+        - two    # 2
+        """
+        )
+        a = yaml.load(dedent(inp))
+        a.sort(key=str.lower)
+        buf = StringIO()
+        yaml.dump(a, buf)
+        exp = dedent(
+            """\
+        - five   # 5
+        - four
+        - One    # 1
+        - Three  # 3
+        - two    # 2
+        """
+        )
+        assert buf.getvalue() == exp
+
+    def test_issue_221_sort_key_reverse(self):
+        from io import StringIO
+
+        from ruyaml import YAML
+
+        yaml = YAML()
+        inp = dedent(
+            """\
+        - four
+        - One    # 1
+        - Three  # 3
+        - five   # 5
+        - two    # 2
+        """
+        )
+        a = yaml.load(dedent(inp))
+        a.sort(key=str.lower, reverse=True)
+        buf = StringIO()
+        yaml.dump(a, buf)
+        exp = dedent(
+            """\
+        - two    # 2
+        - Three  # 3
+        - One    # 1
+        - four
+        - five   # 5
+        """
+        )
+        assert buf.getvalue() == exp
+
+    def test_issue_222(self):
+        from io import StringIO
+
+        import ruyaml
+
+        yaml = ruyaml.YAML(typ='safe')
+        buf = StringIO()
+        yaml.dump(['012923'], buf)
+        assert buf.getvalue() == "['012923']\n"
+
+    def test_issue_223(self):
+        import ruyaml
+
+        yaml = ruyaml.YAML(typ='safe')
+        yaml.load('phone: 0123456789')
+
+    def test_issue_232(self):
+        import ruyaml
+
+        yaml = ruyaml.YAML(typ='safe', pure=True)
+
+        with pytest.raises(ruyaml.parser.ParserError):
+            yaml.load(']')
+        with pytest.raises(ruyaml.parser.ParserError):
+            yaml.load('{]')
+
+    def test_issue_233(self):
+        import json
+
+        from ruyaml import YAML
+
+        yaml = YAML()
+        data = yaml.load('{}')
+        json_str = json.dumps(data)  # NOQA
+
+    def test_issue_233a(self):
+        import json
+
+        from ruyaml import YAML
+
+        yaml = YAML()
+        data = yaml.load('[]')
+        json_str = json.dumps(data)  # NOQA
+
+    def test_issue_234(self):
+        from ruyaml import YAML
+
+        inp = dedent(
+            """\
+        - key: key1
+          ctx: [one, two]
+          help: one
+          cmd: >
+            foo bar
+            foo bar
+        """
+        )
+        yaml = YAML(typ='safe', pure=True)
+        data = yaml.load(inp)
+        fold = data[0]['cmd']
+        print(repr(fold))
+        assert '\a' not in fold
+
+    def test_issue_236(self):
+        inp = """
+        conf:
+          xx: {a: "b", c: []}
+          asd: "nn"
+        """
+        d = round_trip(inp, preserve_quotes=True)  # NOQA
+
+    def test_issue_238(self, tmpdir):
+        program_src = r"""
+        import ruyaml
+        from io import StringIO
+
+        yaml = ruyaml.YAML(typ='unsafe')
+
+
+        class A:
+            def __setstate__(self, d):
+                self.__dict__ = d
+
+
+        class B:
+            pass
+
+
+        a = A()
+        b = B()
+
+        a.x = b
+        b.y = [b]
+        assert a.x.y[0] == a.x
+
+        buf = StringIO()
+        yaml.dump(a, buf)
+
+        data = yaml.load(buf.getvalue())
+        assert data.x.y[0] == data.x
+        """
+        assert save_and_run(dedent(program_src), tmpdir) == 0
+
+    def test_issue_239(self):
+        inp = """
+        first_name: Art
+        occupation: Architect
+        # I'm safe
+        about: Art Vandelay is a fictional character that George invents...
+        # we are not :(
+        # help me!
+        ---
+        # what?!
+        hello: world
+        # someone call the Batman
+        foo: bar # or quz
+        # Lost again
+        ---
+        I: knew
+        # final words
+        """
+        d = YAML().round_trip_all(inp)  # NOQA
+
+    def test_issue_242(self):
+        from ruyaml.comments import CommentedMap
+
+        d0 = CommentedMap([('a', 'b')])
+        assert d0['a'] == 'b'
+
+    def test_issue_245(self):
+        from ruyaml import YAML
+
+        inp = """
+        d: yes
+        """
+        for typ in ['safepure', 'rt', 'safe']:
+            if typ.endswith('pure'):
+                pure = True
+                typ = typ[:-4]
+            else:
+                pure = None
+
+            yaml = YAML(typ=typ, pure=pure)
+            yaml.version = (1, 1)
+            d = yaml.load(inp)
+            print(typ, yaml.parser, yaml.resolver)
+            assert d['d'] is True
+
+    def test_issue_249(self):
+        yaml = YAML()
+        inp = dedent(
+            """\
+        # comment
+        -
+          - 1
+          - 2
+          - 3
+        """
+        )
+        exp = dedent(
+            """\
+        # comment
+        - - 1
+          - 2
+          - 3
+        """
+        )
+        yaml.round_trip(inp, outp=exp)  # NOQA
+
+    def test_issue_250(self):
+        inp = """
+        # 1.
+        - - 1
+        # 2.
+        - map: 2
+        # 3.
+        - 4
+        """
+        d = round_trip(inp)  # NOQA
+
+    # @pytest.mark.xfail(strict=True, reason='bla bla', raises=AssertionError)
+    def test_issue_279(self):
+        from io import StringIO
+
+        from ruyaml import YAML
+
+        yaml = YAML()
+        yaml.indent(sequence=4, offset=2)
+        inp = dedent(
+            """\
+        experiments:
+          - datasets:
+        # ATLAS EWK
+              - {dataset: ATLASWZRAP36PB, frac: 1.0}
+              - {dataset: ATLASZHIGHMASS49FB, frac: 1.0}
+        """
+        )
+        a = yaml.load(inp)
+        buf = StringIO()
+        yaml.dump(a, buf)
+        print(buf.getvalue())
+        assert buf.getvalue() == inp
+
+    def test_issue_280(self):
+        from collections import namedtuple
+        from sys import stdout
+
+        from ruyaml import YAML
+        from ruyaml.representer import RepresenterError
+
+        T = namedtuple('T', ('a', 'b'))
+        t = T(1, 2)
+        yaml = YAML()
+        with pytest.raises(RepresenterError, match='cannot represent'):
+            yaml.dump({'t': t}, stdout)
+
+    def test_issue_282(self):
+        # update from list of tuples caused AttributeError
+        import ruyaml
+
+        yaml_data = ruyaml.comments.CommentedMap([('a', 'apple'), ('b', 'banana')])
+        yaml_data.update([('c', 'cantaloupe')])
+        yaml_data.update({'d': 'date', 'k': 'kiwi'})
+        assert 'c' in yaml_data.keys()
+        assert 'c' in yaml_data._ok
+
+    def test_issue_284(self):
+        import ruyaml
+
+        inp = dedent(
+            """\
+        plain key: in-line value
+        : # Both empty
+        "quoted key":
+        - entry
+        """
+        )
+        yaml = ruyaml.YAML(typ='rt')
+        yaml.version = (1, 2)
+        d = yaml.load(inp)
+        assert d[None] is None
+
+        yaml = ruyaml.YAML(typ='rt')
+        yaml.version = (1, 1)
+        with pytest.raises(ruyaml.parser.ParserError, match='expected <block end>'):
+            d = yaml.load(inp)
+
+    def test_issue_285(self):
+        from ruyaml import YAML
+
+        yaml = YAML()
+        inp = dedent(
+            """\
+        %YAML 1.1
+        ---
+        - y
+        - n
+        - Y
+        - N
+        """
+        )
+        a = yaml.load(inp)
+        assert a[0]
+        assert a[2]
+        assert not a[1]
+        assert not a[3]
+
+    def test_issue_286(self):
+        from io import StringIO
+
+        from ruyaml import YAML
+
+        yaml = YAML()
+        inp = dedent(
+            """\
+        parent_key:
+        - sub_key: sub_value
+
+        # xxx"""
+        )
+        a = yaml.load(inp)
+        a['new_key'] = 'new_value'
+        buf = StringIO()
+        yaml.dump(a, buf)
+        assert buf.getvalue().endswith('xxx\nnew_key: new_value\n')
+
+    def test_issue_288(self):
+        import sys
+        from io import StringIO
+
+        from ruyaml import YAML
+
+        yamldoc = dedent(
+            """\
+        ---
+        # Reusable values
+        aliases:
+          # First-element comment
+          - &firstEntry First entry
+          # Second-element comment
+          - &secondEntry Second entry
+
+          # Third-element comment is
+          # a multi-line value
+          - &thirdEntry Third entry
+
+        # EOF Comment
+        """
+        )
+
+        yaml = YAML()
+        yaml.indent(mapping=2, sequence=4, offset=2)
+        yaml.explicit_start = True
+        yaml.preserve_quotes = True
+        yaml.width = sys.maxsize
+        data = yaml.load(yamldoc)
+        buf = StringIO()
+        yaml.dump(data, buf)
+        assert buf.getvalue() == yamldoc
+
+    def test_issue_288a(self):
+        import sys
+        from io import StringIO
+
+        from ruyaml import YAML
+
+        yamldoc = dedent(
+            """\
+        ---
+        # Reusable values
+        aliases:
+          # First-element comment
+          - &firstEntry First entry
+          # Second-element comment
+          - &secondEntry Second entry
+
+          # Third-element comment is
+           # a multi-line value
+          - &thirdEntry Third entry
+
+        # EOF Comment
+        """
+        )
+
+        yaml = YAML()
+        yaml.indent(mapping=2, sequence=4, offset=2)
+        yaml.explicit_start = True
+        yaml.preserve_quotes = True
+        yaml.width = sys.maxsize
+        data = yaml.load(yamldoc)
+        buf = StringIO()
+        yaml.dump(data, buf)
+        assert buf.getvalue() == yamldoc
+
+    def test_issue_290(self):
+        import sys
+        from io import StringIO
+
+        from ruyaml import YAML
+
+        yamldoc = dedent(
+            """\
+        ---
+        aliases:
+          # Folded-element comment
+          # for a multi-line value
+          - &FoldedEntry >
+            THIS IS A
+            FOLDED, MULTI-LINE
+            VALUE
+
+          # Literal-element comment
+          # for a multi-line value
+          - &literalEntry |
+            THIS IS A
+            LITERAL, MULTI-LINE
+            VALUE
+
+          # Plain-element comment
+          - &plainEntry Plain entry
+        """
+        )
+
+        yaml = YAML()
+        yaml.indent(mapping=2, sequence=4, offset=2)
+        yaml.explicit_start = True
+        yaml.preserve_quotes = True
+        yaml.width = sys.maxsize
+        data = yaml.load(yamldoc)
+        buf = StringIO()
+        yaml.dump(data, buf)
+        assert buf.getvalue() == yamldoc
+
+    def test_issue_290a(self):
+        import sys
+        from io import StringIO
+
+        from ruyaml import YAML
+
+        yamldoc = dedent(
+            """\
+        ---
+        aliases:
+          # Folded-element comment
+          # for a multi-line value
+          - &FoldedEntry >
+            THIS IS A
+            FOLDED, MULTI-LINE
+            VALUE
+
+          # Literal-element comment
+          # for a multi-line value
+          - &literalEntry |
+            THIS IS A
+            LITERAL, MULTI-LINE
+            VALUE
+
+          # Plain-element comment
+          - &plainEntry Plain entry
+        """
+        )
+
+        yaml = YAML()
+        yaml.indent(mapping=2, sequence=4, offset=2)
+        yaml.explicit_start = True
+        yaml.preserve_quotes = True
+        yaml.width = sys.maxsize
+        data = yaml.load(yamldoc)
+        buf = StringIO()
+        yaml.dump(data, buf)
+        assert buf.getvalue() == yamldoc
+
+    # @pytest.mark.xfail(strict=True, reason='should fail pre 0.15.100', raises=AssertionError)
+    def test_issue_295(self):
+        # deepcopy also makes a copy of the start and end mark, and these did not
+        # have any comparison beyond their ID, which of course changed, breaking
+        # some old merge_comment code
+        import copy
+
+        inp = dedent(
+            """
+        A:
+          b:
+          # comment
+          - l1
+          - l2
+
+        C:
+          d: e
+          f:
+          # comment2
+          - - l31
+            - l32
+            - l33: '5'
+        """
+        )
+        data = round_trip_load(inp)  # NOQA
+        dc = copy.deepcopy(data)
+        assert round_trip_dump(dc) == inp
+
+    def test_issue_300(self):
+        from ruyaml import YAML
+
+        inp = dedent(
+            """
+        %YAML 1.2
+        %TAG ! tag:example.com,2019/path#fragment
+        ---
+        null
+        """
+        )
+        YAML().load(inp)
+
+    def test_issue_300a(self):
+        import ruyaml
+
+        inp = dedent(
+            """
+        %YAML 1.1
+        %TAG ! tag:example.com,2019/path#fragment
+        ---
+        null
+        """
+        )
+        yaml = YAML()
+        with pytest.raises(
+            ruyaml.scanner.ScannerError, match='while scanning a directive'
+        ):
+            yaml.load(inp)
+
+    def test_issue_304(self):
+        inp = """
+        %YAML 1.2
+        %TAG ! tag:example.com,2019:
+        ---
+        !foo null
+        ...
+        """
+        d = na_round_trip(inp)  # NOQA
+
+    def test_issue_305(self):
+        inp = """
+        %YAML 1.2
+        ---
+        !<tag:example.com,2019/path#foo> null
+        ...
+        """
+        d = na_round_trip(inp)  # NOQA
+
+    def test_issue_307(self):
+        inp = """
+        %YAML 1.2
+        %TAG ! tag:example.com,2019/path#
+        ---
+        null
+        ...
+        """
+        d = na_round_trip(inp)  # NOQA
+
+
+#    @pytest.mark.xfail(strict=True, reason='bla bla', raises=AssertionError)
+#    def test_issue_ xxx(self):
+#        inp = """
+#        """
+#        d = round_trip(inp)  # NOQA