summaryrefslogtreecommitdiffstats
path: root/third_party/python/PyYAML/lib
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/python/PyYAML/lib')
-rw-r--r--third_party/python/PyYAML/lib/PyYAML.egg-info/PKG-INFO46
-rw-r--r--third_party/python/PyYAML/lib/PyYAML.egg-info/SOURCES.txt634
-rw-r--r--third_party/python/PyYAML/lib/PyYAML.egg-info/dependency_links.txt1
-rw-r--r--third_party/python/PyYAML/lib/PyYAML.egg-info/top_level.txt2
-rw-r--r--third_party/python/PyYAML/lib/yaml/__init__.py89
-rw-r--r--third_party/python/PyYAML/lib/yaml/composer.py18
-rw-r--r--third_party/python/PyYAML/lib/yaml/constructor.py224
-rw-r--r--third_party/python/PyYAML/lib/yaml/cyaml.py8
-rw-r--r--third_party/python/PyYAML/lib/yaml/dumper.py8
-rw-r--r--third_party/python/PyYAML/lib/yaml/emitter.py319
-rw-r--r--third_party/python/PyYAML/lib/yaml/error.py8
-rw-r--r--third_party/python/PyYAML/lib/yaml/loader.py12
-rw-r--r--third_party/python/PyYAML/lib/yaml/parser.py32
-rw-r--r--third_party/python/PyYAML/lib/yaml/reader.py60
-rw-r--r--third_party/python/PyYAML/lib/yaml/representer.py236
-rw-r--r--third_party/python/PyYAML/lib/yaml/resolver.py78
-rw-r--r--third_party/python/PyYAML/lib/yaml/scanner.py399
-rw-r--r--third_party/python/PyYAML/lib/yaml/serializer.py10
18 files changed, 1342 insertions, 842 deletions
diff --git a/third_party/python/PyYAML/lib/PyYAML.egg-info/PKG-INFO b/third_party/python/PyYAML/lib/PyYAML.egg-info/PKG-INFO
new file mode 100644
index 0000000000..c8905983e3
--- /dev/null
+++ b/third_party/python/PyYAML/lib/PyYAML.egg-info/PKG-INFO
@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: PyYAML
+Version: 6.0.1
+Summary: YAML parser and emitter for Python
+Home-page: https://pyyaml.org/
+Download-URL: https://pypi.org/project/PyYAML/
+Author: Kirill Simonov
+Author-email: xi@resolvent.net
+License: MIT
+Project-URL: Bug Tracker, https://github.com/yaml/pyyaml/issues
+Project-URL: CI, https://github.com/yaml/pyyaml/actions
+Project-URL: Documentation, https://pyyaml.org/wiki/PyYAMLDocumentation
+Project-URL: Mailing lists, http://lists.sourceforge.net/lists/listinfo/yaml-core
+Project-URL: Source Code, https://github.com/yaml/pyyaml
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.6
+License-File: LICENSE
+
+YAML is a data serialization format designed for human readability
+and interaction with scripting languages. PyYAML is a YAML parser
+and emitter for Python.
+
+PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
+support, capable extension API, and sensible error messages. PyYAML
+supports standard YAML tags and provides Python-specific tags that
+allow to represent an arbitrary Python object.
+
+PyYAML is applicable for a broad range of tasks from complex
+configuration files to object serialization and persistence.
diff --git a/third_party/python/PyYAML/lib/PyYAML.egg-info/SOURCES.txt b/third_party/python/PyYAML/lib/PyYAML.egg-info/SOURCES.txt
new file mode 100644
index 0000000000..d67072d4bf
--- /dev/null
+++ b/third_party/python/PyYAML/lib/PyYAML.egg-info/SOURCES.txt
@@ -0,0 +1,634 @@
+CHANGES
+LICENSE
+MANIFEST.in
+Makefile
+README.md
+pyproject.toml
+setup.py
+examples/pygments-lexer/example.yaml
+examples/pygments-lexer/yaml.py
+examples/yaml-highlight/yaml_hl.cfg
+examples/yaml-highlight/yaml_hl.py
+lib/PyYAML.egg-info/PKG-INFO
+lib/PyYAML.egg-info/SOURCES.txt
+lib/PyYAML.egg-info/dependency_links.txt
+lib/PyYAML.egg-info/top_level.txt
+lib/_yaml/__init__.py
+lib/yaml/__init__.py
+lib/yaml/composer.py
+lib/yaml/constructor.py
+lib/yaml/cyaml.py
+lib/yaml/dumper.py
+lib/yaml/emitter.py
+lib/yaml/error.py
+lib/yaml/events.py
+lib/yaml/loader.py
+lib/yaml/nodes.py
+lib/yaml/parser.py
+lib/yaml/reader.py
+lib/yaml/representer.py
+lib/yaml/resolver.py
+lib/yaml/scanner.py
+lib/yaml/serializer.py
+lib/yaml/tokens.py
+tests/data/a-nasty-libyaml-bug.loader-error
+tests/data/aliases-cdumper-bug.code
+tests/data/aliases.events
+tests/data/bool.data
+tests/data/bool.detect
+tests/data/construct-binary-py2.code
+tests/data/construct-binary-py2.data
+tests/data/construct-binary-py3.code
+tests/data/construct-binary-py3.data
+tests/data/construct-bool.code
+tests/data/construct-bool.data
+tests/data/construct-custom.code
+tests/data/construct-custom.data
+tests/data/construct-float.code
+tests/data/construct-float.data
+tests/data/construct-int.code
+tests/data/construct-int.data
+tests/data/construct-map.code
+tests/data/construct-map.data
+tests/data/construct-merge.code
+tests/data/construct-merge.data
+tests/data/construct-null.code
+tests/data/construct-null.data
+tests/data/construct-omap.code
+tests/data/construct-omap.data
+tests/data/construct-pairs.code
+tests/data/construct-pairs.data
+tests/data/construct-python-bool.code
+tests/data/construct-python-bool.data
+tests/data/construct-python-bytes-py3.code
+tests/data/construct-python-bytes-py3.data
+tests/data/construct-python-complex.code
+tests/data/construct-python-complex.data
+tests/data/construct-python-float.code
+tests/data/construct-python-float.data
+tests/data/construct-python-int.code
+tests/data/construct-python-int.data
+tests/data/construct-python-long-short-py2.code
+tests/data/construct-python-long-short-py2.data
+tests/data/construct-python-long-short-py3.code
+tests/data/construct-python-long-short-py3.data
+tests/data/construct-python-name-module.code
+tests/data/construct-python-name-module.data
+tests/data/construct-python-none.code
+tests/data/construct-python-none.data
+tests/data/construct-python-object.code
+tests/data/construct-python-object.data
+tests/data/construct-python-str-ascii.code
+tests/data/construct-python-str-ascii.data
+tests/data/construct-python-str-utf8-py2.code
+tests/data/construct-python-str-utf8-py2.data
+tests/data/construct-python-str-utf8-py3.code
+tests/data/construct-python-str-utf8-py3.data
+tests/data/construct-python-tuple-list-dict.code
+tests/data/construct-python-tuple-list-dict.data
+tests/data/construct-python-unicode-ascii-py2.code
+tests/data/construct-python-unicode-ascii-py2.data
+tests/data/construct-python-unicode-ascii-py3.code
+tests/data/construct-python-unicode-ascii-py3.data
+tests/data/construct-python-unicode-utf8-py2.code
+tests/data/construct-python-unicode-utf8-py2.data
+tests/data/construct-python-unicode-utf8-py3.code
+tests/data/construct-python-unicode-utf8-py3.data
+tests/data/construct-seq.code
+tests/data/construct-seq.data
+tests/data/construct-set.code
+tests/data/construct-set.data
+tests/data/construct-str-ascii.code
+tests/data/construct-str-ascii.data
+tests/data/construct-str-utf8-py2.code
+tests/data/construct-str-utf8-py2.data
+tests/data/construct-str-utf8-py3.code
+tests/data/construct-str-utf8-py3.data
+tests/data/construct-str.code
+tests/data/construct-str.data
+tests/data/construct-timestamp.code
+tests/data/construct-timestamp.data
+tests/data/construct-value.code
+tests/data/construct-value.data
+tests/data/document-separator-in-quoted-scalar.loader-error
+tests/data/documents.events
+tests/data/duplicate-anchor-1.loader-error
+tests/data/duplicate-anchor-2.loader-error
+tests/data/duplicate-key.former-loader-error.code
+tests/data/duplicate-key.former-loader-error.data
+tests/data/duplicate-mapping-key.former-loader-error.code
+tests/data/duplicate-mapping-key.former-loader-error.data
+tests/data/duplicate-merge-key.former-loader-error.code
+tests/data/duplicate-merge-key.former-loader-error.data
+tests/data/duplicate-tag-directive.loader-error
+tests/data/duplicate-value-key.former-loader-error.code
+tests/data/duplicate-value-key.former-loader-error.data
+tests/data/duplicate-yaml-directive.loader-error
+tests/data/emit-block-scalar-in-simple-key-context-bug.canonical
+tests/data/emit-block-scalar-in-simple-key-context-bug.data
+tests/data/emitting-unacceptable-unicode-character-bug-py3.code
+tests/data/emitting-unacceptable-unicode-character-bug-py3.data
+tests/data/emitting-unacceptable-unicode-character-bug-py3.skip-ext
+tests/data/emitting-unacceptable-unicode-character-bug.code
+tests/data/emitting-unacceptable-unicode-character-bug.data
+tests/data/emitting-unacceptable-unicode-character-bug.skip-ext
+tests/data/emoticons.unicode
+tests/data/emoticons2.unicode
+tests/data/empty-anchor.emitter-error
+tests/data/empty-document-bug.canonical
+tests/data/empty-document-bug.data
+tests/data/empty-document-bug.empty
+tests/data/empty-documents.single-loader-error
+tests/data/empty-python-module.loader-error
+tests/data/empty-python-name.loader-error
+tests/data/empty-tag-handle.emitter-error
+tests/data/empty-tag-prefix.emitter-error
+tests/data/empty-tag.emitter-error
+tests/data/expected-document-end.emitter-error
+tests/data/expected-document-start.emitter-error
+tests/data/expected-mapping.loader-error
+tests/data/expected-node-1.emitter-error
+tests/data/expected-node-2.emitter-error
+tests/data/expected-nothing.emitter-error
+tests/data/expected-scalar.loader-error
+tests/data/expected-sequence.loader-error
+tests/data/expected-stream-start.emitter-error
+tests/data/explicit-document.single-loader-error
+tests/data/fetch-complex-value-bug.loader-error
+tests/data/float-representer-2.3-bug.code
+tests/data/float-representer-2.3-bug.data
+tests/data/float.data
+tests/data/float.detect
+tests/data/forbidden-entry.loader-error
+tests/data/forbidden-key.loader-error
+tests/data/forbidden-value.loader-error
+tests/data/implicit-document.single-loader-error
+tests/data/int.data
+tests/data/int.detect
+tests/data/invalid-anchor-1.loader-error
+tests/data/invalid-anchor-2.loader-error
+tests/data/invalid-anchor.emitter-error
+tests/data/invalid-base64-data-2.loader-error
+tests/data/invalid-base64-data.loader-error
+tests/data/invalid-block-scalar-indicator.loader-error
+tests/data/invalid-character.loader-error
+tests/data/invalid-character.stream-error
+tests/data/invalid-directive-line.loader-error
+tests/data/invalid-directive-name-1.loader-error
+tests/data/invalid-directive-name-2.loader-error
+tests/data/invalid-escape-character.loader-error
+tests/data/invalid-escape-numbers.loader-error
+tests/data/invalid-indentation-indicator-1.loader-error
+tests/data/invalid-indentation-indicator-2.loader-error
+tests/data/invalid-item-without-trailing-break.loader-error
+tests/data/invalid-merge-1.loader-error
+tests/data/invalid-merge-2.loader-error
+tests/data/invalid-omap-1.loader-error
+tests/data/invalid-omap-2.loader-error
+tests/data/invalid-omap-3.loader-error
+tests/data/invalid-pairs-1.loader-error
+tests/data/invalid-pairs-2.loader-error
+tests/data/invalid-pairs-3.loader-error
+tests/data/invalid-python-bytes-2-py3.loader-error
+tests/data/invalid-python-bytes-py3.loader-error
+tests/data/invalid-python-module-kind.loader-error
+tests/data/invalid-python-module-value.loader-error
+tests/data/invalid-python-module.loader-error
+tests/data/invalid-python-name-kind.loader-error
+tests/data/invalid-python-name-module.loader-error
+tests/data/invalid-python-name-object.loader-error
+tests/data/invalid-python-name-value.loader-error
+tests/data/invalid-simple-key.loader-error
+tests/data/invalid-single-quote-bug.code
+tests/data/invalid-single-quote-bug.data
+tests/data/invalid-starting-character.loader-error
+tests/data/invalid-tag-1.loader-error
+tests/data/invalid-tag-2.loader-error
+tests/data/invalid-tag-directive-handle.loader-error
+tests/data/invalid-tag-directive-prefix.loader-error
+tests/data/invalid-tag-handle-1.emitter-error
+tests/data/invalid-tag-handle-1.loader-error
+tests/data/invalid-tag-handle-2.emitter-error
+tests/data/invalid-tag-handle-2.loader-error
+tests/data/invalid-uri-escapes-1.loader-error
+tests/data/invalid-uri-escapes-2.loader-error
+tests/data/invalid-uri-escapes-3.loader-error
+tests/data/invalid-uri.loader-error
+tests/data/invalid-utf8-byte.loader-error
+tests/data/invalid-utf8-byte.stream-error
+tests/data/invalid-yaml-directive-version-1.loader-error
+tests/data/invalid-yaml-directive-version-2.loader-error
+tests/data/invalid-yaml-directive-version-3.loader-error
+tests/data/invalid-yaml-directive-version-4.loader-error
+tests/data/invalid-yaml-directive-version-5.loader-error
+tests/data/invalid-yaml-directive-version-6.loader-error
+tests/data/invalid-yaml-version.loader-error
+tests/data/latin.unicode
+tests/data/mapping.sort
+tests/data/mapping.sorted
+tests/data/mappings.events
+tests/data/merge.data
+tests/data/merge.detect
+tests/data/more-floats.code
+tests/data/more-floats.data
+tests/data/multi-constructor.code
+tests/data/multi-constructor.multi
+tests/data/myfullloader.subclass_blacklist
+tests/data/negative-float-bug.code
+tests/data/negative-float-bug.data
+tests/data/no-alias-anchor.emitter-error
+tests/data/no-alias-anchor.skip-ext
+tests/data/no-block-collection-end.loader-error
+tests/data/no-block-mapping-end-2.loader-error
+tests/data/no-block-mapping-end.loader-error
+tests/data/no-document-start.loader-error
+tests/data/no-flow-mapping-end.loader-error
+tests/data/no-flow-sequence-end.loader-error
+tests/data/no-node-1.loader-error
+tests/data/no-node-2.loader-error
+tests/data/no-tag.emitter-error
+tests/data/null.data
+tests/data/null.detect
+tests/data/odd-utf16.stream-error
+tests/data/overwrite-state-new-constructor.loader-error
+tests/data/recursive-anchor.former-loader-error
+tests/data/recursive-dict.recursive
+tests/data/recursive-list.recursive
+tests/data/recursive-set.recursive
+tests/data/recursive-state.recursive
+tests/data/recursive-tuple.recursive
+tests/data/recursive.former-dumper-error
+tests/data/remove-possible-simple-key-bug.loader-error
+tests/data/resolver.data
+tests/data/resolver.path
+tests/data/run-parser-crash-bug.data
+tests/data/scalars.events
+tests/data/scan-document-end-bug.canonical
+tests/data/scan-document-end-bug.data
+tests/data/scan-line-break-bug.canonical
+tests/data/scan-line-break-bug.data
+tests/data/sequences.events
+tests/data/serializer-is-already-opened.dumper-error
+tests/data/serializer-is-closed-1.dumper-error
+tests/data/serializer-is-closed-2.dumper-error
+tests/data/serializer-is-not-opened-1.dumper-error
+tests/data/serializer-is-not-opened-2.dumper-error
+tests/data/single-dot-is-not-float-bug.code
+tests/data/single-dot-is-not-float-bug.data
+tests/data/sloppy-indentation.canonical
+tests/data/sloppy-indentation.data
+tests/data/spec-02-01.data
+tests/data/spec-02-01.structure
+tests/data/spec-02-01.tokens
+tests/data/spec-02-02.data
+tests/data/spec-02-02.structure
+tests/data/spec-02-02.tokens
+tests/data/spec-02-03.data
+tests/data/spec-02-03.structure
+tests/data/spec-02-03.tokens
+tests/data/spec-02-04.data
+tests/data/spec-02-04.structure
+tests/data/spec-02-04.tokens
+tests/data/spec-02-05.data
+tests/data/spec-02-05.structure
+tests/data/spec-02-05.tokens
+tests/data/spec-02-06.data
+tests/data/spec-02-06.structure
+tests/data/spec-02-06.tokens
+tests/data/spec-02-07.data
+tests/data/spec-02-07.structure
+tests/data/spec-02-07.tokens
+tests/data/spec-02-08.data
+tests/data/spec-02-08.structure
+tests/data/spec-02-08.tokens
+tests/data/spec-02-09.data
+tests/data/spec-02-09.structure
+tests/data/spec-02-09.tokens
+tests/data/spec-02-10.data
+tests/data/spec-02-10.structure
+tests/data/spec-02-10.tokens
+tests/data/spec-02-11.data
+tests/data/spec-02-11.structure
+tests/data/spec-02-11.tokens
+tests/data/spec-02-12.data
+tests/data/spec-02-12.structure
+tests/data/spec-02-12.tokens
+tests/data/spec-02-13.data
+tests/data/spec-02-13.structure
+tests/data/spec-02-13.tokens
+tests/data/spec-02-14.data
+tests/data/spec-02-14.structure
+tests/data/spec-02-14.tokens
+tests/data/spec-02-15.data
+tests/data/spec-02-15.structure
+tests/data/spec-02-15.tokens
+tests/data/spec-02-16.data
+tests/data/spec-02-16.structure
+tests/data/spec-02-16.tokens
+tests/data/spec-02-17.data
+tests/data/spec-02-17.structure
+tests/data/spec-02-17.tokens
+tests/data/spec-02-18.data
+tests/data/spec-02-18.structure
+tests/data/spec-02-18.tokens
+tests/data/spec-02-19.data
+tests/data/spec-02-19.structure
+tests/data/spec-02-19.tokens
+tests/data/spec-02-20.data
+tests/data/spec-02-20.structure
+tests/data/spec-02-20.tokens
+tests/data/spec-02-21.data
+tests/data/spec-02-21.structure
+tests/data/spec-02-21.tokens
+tests/data/spec-02-22.data
+tests/data/spec-02-22.structure
+tests/data/spec-02-22.tokens
+tests/data/spec-02-23.data
+tests/data/spec-02-23.structure
+tests/data/spec-02-23.tokens
+tests/data/spec-02-24.data
+tests/data/spec-02-24.structure
+tests/data/spec-02-24.tokens
+tests/data/spec-02-25.data
+tests/data/spec-02-25.structure
+tests/data/spec-02-25.tokens
+tests/data/spec-02-26.data
+tests/data/spec-02-26.structure
+tests/data/spec-02-26.tokens
+tests/data/spec-02-27.data
+tests/data/spec-02-27.structure
+tests/data/spec-02-27.tokens
+tests/data/spec-02-28.data
+tests/data/spec-02-28.structure
+tests/data/spec-02-28.tokens
+tests/data/spec-05-01-utf16be.data
+tests/data/spec-05-01-utf16be.empty
+tests/data/spec-05-01-utf16le.data
+tests/data/spec-05-01-utf16le.empty
+tests/data/spec-05-01-utf8.data
+tests/data/spec-05-01-utf8.empty
+tests/data/spec-05-02-utf16be.data
+tests/data/spec-05-02-utf16be.error
+tests/data/spec-05-02-utf16le.data
+tests/data/spec-05-02-utf16le.error
+tests/data/spec-05-02-utf8.data
+tests/data/spec-05-02-utf8.error
+tests/data/spec-05-03.canonical
+tests/data/spec-05-03.data
+tests/data/spec-05-04.canonical
+tests/data/spec-05-04.data
+tests/data/spec-05-05.data
+tests/data/spec-05-05.empty
+tests/data/spec-05-06.canonical
+tests/data/spec-05-06.data
+tests/data/spec-05-07.canonical
+tests/data/spec-05-07.data
+tests/data/spec-05-08.canonical
+tests/data/spec-05-08.data
+tests/data/spec-05-09.canonical
+tests/data/spec-05-09.data
+tests/data/spec-05-10.data
+tests/data/spec-05-10.error
+tests/data/spec-05-11.canonical
+tests/data/spec-05-11.data
+tests/data/spec-05-12.data
+tests/data/spec-05-12.error
+tests/data/spec-05-13.canonical
+tests/data/spec-05-13.data
+tests/data/spec-05-14.canonical
+tests/data/spec-05-14.data
+tests/data/spec-05-15.data
+tests/data/spec-05-15.error
+tests/data/spec-06-01.canonical
+tests/data/spec-06-01.data
+tests/data/spec-06-02.data
+tests/data/spec-06-02.empty
+tests/data/spec-06-03.canonical
+tests/data/spec-06-03.data
+tests/data/spec-06-04.canonical
+tests/data/spec-06-04.data
+tests/data/spec-06-05.canonical
+tests/data/spec-06-05.data
+tests/data/spec-06-06.canonical
+tests/data/spec-06-06.data
+tests/data/spec-06-07.canonical
+tests/data/spec-06-07.data
+tests/data/spec-06-08.canonical
+tests/data/spec-06-08.data
+tests/data/spec-07-01.canonical
+tests/data/spec-07-01.data
+tests/data/spec-07-01.skip-ext
+tests/data/spec-07-02.canonical
+tests/data/spec-07-02.data
+tests/data/spec-07-02.skip-ext
+tests/data/spec-07-03.data
+tests/data/spec-07-03.error
+tests/data/spec-07-04.canonical
+tests/data/spec-07-04.data
+tests/data/spec-07-05.data
+tests/data/spec-07-05.error
+tests/data/spec-07-06.canonical
+tests/data/spec-07-06.data
+tests/data/spec-07-07a.canonical
+tests/data/spec-07-07a.data
+tests/data/spec-07-07b.canonical
+tests/data/spec-07-07b.data
+tests/data/spec-07-08.canonical
+tests/data/spec-07-08.data
+tests/data/spec-07-09.canonical
+tests/data/spec-07-09.data
+tests/data/spec-07-10.canonical
+tests/data/spec-07-10.data
+tests/data/spec-07-11.data
+tests/data/spec-07-11.empty
+tests/data/spec-07-12a.canonical
+tests/data/spec-07-12a.data
+tests/data/spec-07-12b.canonical
+tests/data/spec-07-12b.data
+tests/data/spec-07-13.canonical
+tests/data/spec-07-13.data
+tests/data/spec-08-01.canonical
+tests/data/spec-08-01.data
+tests/data/spec-08-02.canonical
+tests/data/spec-08-02.data
+tests/data/spec-08-03.canonical
+tests/data/spec-08-03.data
+tests/data/spec-08-04.data
+tests/data/spec-08-04.error
+tests/data/spec-08-05.canonical
+tests/data/spec-08-05.data
+tests/data/spec-08-06.data
+tests/data/spec-08-06.error
+tests/data/spec-08-07.canonical
+tests/data/spec-08-07.data
+tests/data/spec-08-08.canonical
+tests/data/spec-08-08.data
+tests/data/spec-08-09.canonical
+tests/data/spec-08-09.data
+tests/data/spec-08-10.canonical
+tests/data/spec-08-10.data
+tests/data/spec-08-11.canonical
+tests/data/spec-08-11.data
+tests/data/spec-08-12.canonical
+tests/data/spec-08-12.data
+tests/data/spec-08-13.canonical
+tests/data/spec-08-13.data
+tests/data/spec-08-13.skip-ext
+tests/data/spec-08-14.canonical
+tests/data/spec-08-14.data
+tests/data/spec-08-15.canonical
+tests/data/spec-08-15.data
+tests/data/spec-09-01.canonical
+tests/data/spec-09-01.data
+tests/data/spec-09-02.canonical
+tests/data/spec-09-02.data
+tests/data/spec-09-03.canonical
+tests/data/spec-09-03.data
+tests/data/spec-09-04.canonical
+tests/data/spec-09-04.data
+tests/data/spec-09-05.canonical
+tests/data/spec-09-05.data
+tests/data/spec-09-06.canonical
+tests/data/spec-09-06.data
+tests/data/spec-09-07.canonical
+tests/data/spec-09-07.data
+tests/data/spec-09-08.canonical
+tests/data/spec-09-08.data
+tests/data/spec-09-09.canonical
+tests/data/spec-09-09.data
+tests/data/spec-09-10.canonical
+tests/data/spec-09-10.data
+tests/data/spec-09-11.canonical
+tests/data/spec-09-11.data
+tests/data/spec-09-12.canonical
+tests/data/spec-09-12.data
+tests/data/spec-09-13.canonical
+tests/data/spec-09-13.data
+tests/data/spec-09-14.data
+tests/data/spec-09-14.error
+tests/data/spec-09-15.canonical
+tests/data/spec-09-15.data
+tests/data/spec-09-16.canonical
+tests/data/spec-09-16.data
+tests/data/spec-09-17.canonical
+tests/data/spec-09-17.data
+tests/data/spec-09-18.canonical
+tests/data/spec-09-18.data
+tests/data/spec-09-19.canonical
+tests/data/spec-09-19.data
+tests/data/spec-09-20.canonical
+tests/data/spec-09-20.data
+tests/data/spec-09-20.skip-ext
+tests/data/spec-09-21.data
+tests/data/spec-09-21.error
+tests/data/spec-09-22.canonical
+tests/data/spec-09-22.data
+tests/data/spec-09-23.canonical
+tests/data/spec-09-23.data
+tests/data/spec-09-24.canonical
+tests/data/spec-09-24.data
+tests/data/spec-09-25.canonical
+tests/data/spec-09-25.data
+tests/data/spec-09-26.canonical
+tests/data/spec-09-26.data
+tests/data/spec-09-27.canonical
+tests/data/spec-09-27.data
+tests/data/spec-09-28.canonical
+tests/data/spec-09-28.data
+tests/data/spec-09-29.canonical
+tests/data/spec-09-29.data
+tests/data/spec-09-30.canonical
+tests/data/spec-09-30.data
+tests/data/spec-09-31.canonical
+tests/data/spec-09-31.data
+tests/data/spec-09-32.canonical
+tests/data/spec-09-32.data
+tests/data/spec-09-33.canonical
+tests/data/spec-09-33.data
+tests/data/spec-10-01.canonical
+tests/data/spec-10-01.data
+tests/data/spec-10-02.canonical
+tests/data/spec-10-02.data
+tests/data/spec-10-03.canonical
+tests/data/spec-10-03.data
+tests/data/spec-10-04.canonical
+tests/data/spec-10-04.data
+tests/data/spec-10-05.canonical
+tests/data/spec-10-05.data
+tests/data/spec-10-06.canonical
+tests/data/spec-10-06.data
+tests/data/spec-10-07.canonical
+tests/data/spec-10-07.data
+tests/data/spec-10-08.data
+tests/data/spec-10-08.error
+tests/data/spec-10-09.canonical
+tests/data/spec-10-09.data
+tests/data/spec-10-10.canonical
+tests/data/spec-10-10.data
+tests/data/spec-10-11.canonical
+tests/data/spec-10-11.data
+tests/data/spec-10-12.canonical
+tests/data/spec-10-12.data
+tests/data/spec-10-13.canonical
+tests/data/spec-10-13.data
+tests/data/spec-10-14.canonical
+tests/data/spec-10-14.data
+tests/data/spec-10-15.canonical
+tests/data/spec-10-15.data
+tests/data/str.data
+tests/data/str.detect
+tests/data/tags.events
+tests/data/test_mark.marks
+tests/data/timestamp-bugs.code
+tests/data/timestamp-bugs.data
+tests/data/timestamp.data
+tests/data/timestamp.detect
+tests/data/unacceptable-key.loader-error
+tests/data/unclosed-bracket.loader-error
+tests/data/unclosed-quoted-scalar.loader-error
+tests/data/undefined-anchor.loader-error
+tests/data/undefined-constructor.loader-error
+tests/data/undefined-tag-handle.loader-error
+tests/data/unknown.dumper-error
+tests/data/unsupported-version.emitter-error
+tests/data/utf16be.code
+tests/data/utf16be.data
+tests/data/utf16le.code
+tests/data/utf16le.data
+tests/data/utf8-implicit.code
+tests/data/utf8-implicit.data
+tests/data/utf8.code
+tests/data/utf8.data
+tests/data/value.data
+tests/data/value.detect
+tests/data/yaml.data
+tests/data/yaml.detect
+tests/data/yaml11.schema
+tests/data/yaml11.schema-skip
+tests/lib/canonical.py
+tests/lib/test_all.py
+tests/lib/test_appliance.py
+tests/lib/test_build.py
+tests/lib/test_build_ext.py
+tests/lib/test_canonical.py
+tests/lib/test_constructor.py
+tests/lib/test_dump_load.py
+tests/lib/test_emitter.py
+tests/lib/test_errors.py
+tests/lib/test_input_output.py
+tests/lib/test_mark.py
+tests/lib/test_multi_constructor.py
+tests/lib/test_reader.py
+tests/lib/test_recursive.py
+tests/lib/test_representer.py
+tests/lib/test_resolver.py
+tests/lib/test_schema.py
+tests/lib/test_sort_keys.py
+tests/lib/test_structure.py
+tests/lib/test_tokens.py
+tests/lib/test_yaml.py
+tests/lib/test_yaml_ext.py
+yaml/__init__.pxd
+yaml/_yaml.h
+yaml/_yaml.pxd
+yaml/_yaml.pyx \ No newline at end of file
diff --git a/third_party/python/PyYAML/lib/PyYAML.egg-info/dependency_links.txt b/third_party/python/PyYAML/lib/PyYAML.egg-info/dependency_links.txt
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/third_party/python/PyYAML/lib/PyYAML.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/third_party/python/PyYAML/lib/PyYAML.egg-info/top_level.txt b/third_party/python/PyYAML/lib/PyYAML.egg-info/top_level.txt
new file mode 100644
index 0000000000..e6475e911f
--- /dev/null
+++ b/third_party/python/PyYAML/lib/PyYAML.egg-info/top_level.txt
@@ -0,0 +1,2 @@
+_yaml
+yaml
diff --git a/third_party/python/PyYAML/lib/yaml/__init__.py b/third_party/python/PyYAML/lib/yaml/__init__.py
index 3c988198d5..8249361947 100644
--- a/third_party/python/PyYAML/lib/yaml/__init__.py
+++ b/third_party/python/PyYAML/lib/yaml/__init__.py
@@ -1,58 +1,29 @@
-from error import *
+from .error import *
-from tokens import *
-from events import *
-from nodes import *
+from .tokens import *
+from .events import *
+from .nodes import *
-from loader import *
-from dumper import *
-
-__version__ = '5.4.1'
+from .loader import *
+from .dumper import *
+__version__ = '6.0.1'
try:
- from cyaml import *
+ from .cyaml import *
__with_libyaml__ = True
except ImportError:
__with_libyaml__ = False
+import io
#------------------------------------------------------------------------------
-# Warnings control
+# XXX "Warnings control" is now deprecated. Leaving in the API function to not
+# break code that uses it.
#------------------------------------------------------------------------------
-
-# 'Global' warnings state:
-_warnings_enabled = {
- 'YAMLLoadWarning': True,
-}
-
-# Get or set global warnings' state
def warnings(settings=None):
if settings is None:
- return _warnings_enabled
-
- if type(settings) is dict:
- for key in settings:
- if key in _warnings_enabled:
- _warnings_enabled[key] = settings[key]
-
-# Warn when load() is called without Loader=...
-class YAMLLoadWarning(RuntimeWarning):
- pass
-
-def load_warning(method):
- if _warnings_enabled['YAMLLoadWarning'] is False:
- return
-
- import warnings
-
- message = (
- "calling yaml.%s() without Loader=... is deprecated, as the "
- "default Loader is unsafe. Please read "
- "https://msg.pyyaml.org/load for full details."
- ) % method
-
- warnings.warn(message, YAMLLoadWarning, stacklevel=3)
+ return {}
#------------------------------------------------------------------------------
def scan(stream, Loader=Loader):
@@ -100,30 +71,22 @@ def compose_all(stream, Loader=Loader):
finally:
loader.dispose()
-def load(stream, Loader=None):
+def load(stream, Loader):
"""
Parse the first YAML document in a stream
and produce the corresponding Python object.
"""
- if Loader is None:
- load_warning('load')
- Loader = FullLoader
-
loader = Loader(stream)
try:
return loader.get_single_data()
finally:
loader.dispose()
-def load_all(stream, Loader=None):
+def load_all(stream, Loader):
"""
Parse all YAML documents in a stream
and produce corresponding Python objects.
"""
- if Loader is None:
- load_warning('load_all')
- Loader = FullLoader
-
loader = Loader(stream)
try:
while loader.check_data():
@@ -200,8 +163,7 @@ def emit(events, stream=None, Dumper=Dumper,
"""
getvalue = None
if stream is None:
- from StringIO import StringIO
- stream = StringIO()
+ stream = io.StringIO()
getvalue = stream.getvalue
dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
allow_unicode=allow_unicode, line_break=line_break)
@@ -216,7 +178,7 @@ def emit(events, stream=None, Dumper=Dumper,
def serialize_all(nodes, stream=None, Dumper=Dumper,
canonical=None, indent=None, width=None,
allow_unicode=None, line_break=None,
- encoding='utf-8', explicit_start=None, explicit_end=None,
+ encoding=None, explicit_start=None, explicit_end=None,
version=None, tags=None):
"""
Serialize a sequence of representation trees into a YAML stream.
@@ -225,10 +187,9 @@ def serialize_all(nodes, stream=None, Dumper=Dumper,
getvalue = None
if stream is None:
if encoding is None:
- from StringIO import StringIO
+ stream = io.StringIO()
else:
- from cStringIO import StringIO
- stream = StringIO()
+ stream = io.BytesIO()
getvalue = stream.getvalue
dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
allow_unicode=allow_unicode, line_break=line_break,
@@ -255,7 +216,7 @@ def dump_all(documents, stream=None, Dumper=Dumper,
default_style=None, default_flow_style=False,
canonical=None, indent=None, width=None,
allow_unicode=None, line_break=None,
- encoding='utf-8', explicit_start=None, explicit_end=None,
+ encoding=None, explicit_start=None, explicit_end=None,
version=None, tags=None, sort_keys=True):
"""
Serialize a sequence of Python objects into a YAML stream.
@@ -264,10 +225,9 @@ def dump_all(documents, stream=None, Dumper=Dumper,
getvalue = None
if stream is None:
if encoding is None:
- from StringIO import StringIO
+ stream = io.StringIO()
else:
- from cStringIO import StringIO
- stream = StringIO()
+ stream = io.BytesIO()
getvalue = stream.getvalue
dumper = Dumper(stream, default_style=default_style,
default_flow_style=default_flow_style,
@@ -399,13 +359,12 @@ class YAMLObjectMetaclass(type):
cls.yaml_dumper.add_representer(cls, cls.to_yaml)
-class YAMLObject(object):
+class YAMLObject(metaclass=YAMLObjectMetaclass):
"""
An object that can dump itself to a YAML stream
and load itself from a YAML stream.
"""
- __metaclass__ = YAMLObjectMetaclass
__slots__ = () # no direct instantiation, so allow immutable subclasses
yaml_loader = [Loader, FullLoader, UnsafeLoader]
@@ -414,18 +373,18 @@ class YAMLObject(object):
yaml_tag = None
yaml_flow_style = None
+ @classmethod
def from_yaml(cls, loader, node):
"""
Convert a representation node to a Python object.
"""
return loader.construct_yaml_object(node, cls)
- from_yaml = classmethod(from_yaml)
+ @classmethod
def to_yaml(cls, dumper, data):
"""
Convert a Python object to a representation node.
"""
return dumper.represent_yaml_object(cls.yaml_tag, data, cls,
flow_style=cls.yaml_flow_style)
- to_yaml = classmethod(to_yaml)
diff --git a/third_party/python/PyYAML/lib/yaml/composer.py b/third_party/python/PyYAML/lib/yaml/composer.py
index df85ef653b..6d15cb40e3 100644
--- a/third_party/python/PyYAML/lib/yaml/composer.py
+++ b/third_party/python/PyYAML/lib/yaml/composer.py
@@ -1,14 +1,14 @@
__all__ = ['Composer', 'ComposerError']
-from error import MarkedYAMLError
-from events import *
-from nodes import *
+from .error import MarkedYAMLError
+from .events import *
+from .nodes import *
class ComposerError(MarkedYAMLError):
pass
-class Composer(object):
+class Composer:
def __init__(self):
self.anchors = {}
@@ -66,14 +66,14 @@ class Composer(object):
anchor = event.anchor
if anchor not in self.anchors:
raise ComposerError(None, None, "found undefined alias %r"
- % anchor.encode('utf-8'), event.start_mark)
+ % anchor, event.start_mark)
return self.anchors[anchor]
event = self.peek_event()
anchor = event.anchor
if anchor is not None:
if anchor in self.anchors:
raise ComposerError("found duplicate anchor %r; first occurrence"
- % anchor.encode('utf-8'), self.anchors[anchor].start_mark,
+ % anchor, self.anchors[anchor].start_mark,
"second occurrence", event.start_mark)
self.descend_resolver(parent, index)
if self.check_event(ScalarEvent):
@@ -88,7 +88,7 @@ class Composer(object):
def compose_scalar_node(self, anchor):
event = self.get_event()
tag = event.tag
- if tag is None or tag == u'!':
+ if tag is None or tag == '!':
tag = self.resolve(ScalarNode, event.value, event.implicit)
node = ScalarNode(tag, event.value,
event.start_mark, event.end_mark, style=event.style)
@@ -99,7 +99,7 @@ class Composer(object):
def compose_sequence_node(self, anchor):
start_event = self.get_event()
tag = start_event.tag
- if tag is None or tag == u'!':
+ if tag is None or tag == '!':
tag = self.resolve(SequenceNode, None, start_event.implicit)
node = SequenceNode(tag, [],
start_event.start_mark, None,
@@ -117,7 +117,7 @@ class Composer(object):
def compose_mapping_node(self, anchor):
start_event = self.get_event()
tag = start_event.tag
- if tag is None or tag == u'!':
+ if tag is None or tag == '!':
tag = self.resolve(MappingNode, None, start_event.implicit)
node = MappingNode(tag, [],
start_event.start_mark, None,
diff --git a/third_party/python/PyYAML/lib/yaml/constructor.py b/third_party/python/PyYAML/lib/yaml/constructor.py
index ff4e36828e..619acd3070 100644
--- a/third_party/python/PyYAML/lib/yaml/constructor.py
+++ b/third_party/python/PyYAML/lib/yaml/constructor.py
@@ -8,46 +8,15 @@ __all__ = [
'ConstructorError'
]
-from error import *
-from nodes import *
+from .error import *
+from .nodes import *
-import datetime
-
-import binascii, re, sys, types
+import collections.abc, datetime, base64, binascii, re, sys, types
class ConstructorError(MarkedYAMLError):
pass
-
-class timezone(datetime.tzinfo):
- def __init__(self, offset):
- self._offset = offset
- seconds = abs(offset).total_seconds()
- self._name = 'UTC%s%02d:%02d' % (
- '-' if offset.days < 0 else '+',
- seconds // 3600,
- seconds % 3600 // 60
- )
-
- def tzname(self, dt=None):
- return self._name
-
- def utcoffset(self, dt=None):
- return self._offset
-
- def dst(self, dt=None):
- return datetime.timedelta(0)
-
- def __copy__(self):
- return self.__deepcopy__()
-
- def __deepcopy__(self, memodict={}):
- return self.__class__(self.utcoffset())
-
- __repr__ = __str__ = tzname
-
-
-class BaseConstructor(object):
+class BaseConstructor:
yaml_constructors = {}
yaml_multi_constructors = {}
@@ -133,7 +102,7 @@ class BaseConstructor(object):
data = constructor(self, tag_suffix, node)
if isinstance(data, types.GeneratorType):
generator = data
- data = generator.next()
+ data = next(generator)
if self.deep_construct:
for dummy in generator:
pass
@@ -168,11 +137,9 @@ class BaseConstructor(object):
mapping = {}
for key_node, value_node in node.value:
key = self.construct_object(key_node, deep=deep)
- try:
- hash(key)
- except TypeError, exc:
+ if not isinstance(key, collections.abc.Hashable):
raise ConstructorError("while constructing a mapping", node.start_mark,
- "found unacceptable key (%s)" % exc, key_node.start_mark)
+ "found unhashable key", key_node.start_mark)
value = self.construct_object(value_node, deep=deep)
mapping[key] = value
return mapping
@@ -189,33 +156,33 @@ class BaseConstructor(object):
pairs.append((key, value))
return pairs
+ @classmethod
def add_constructor(cls, tag, constructor):
if not 'yaml_constructors' in cls.__dict__:
cls.yaml_constructors = cls.yaml_constructors.copy()
cls.yaml_constructors[tag] = constructor
- add_constructor = classmethod(add_constructor)
+ @classmethod
def add_multi_constructor(cls, tag_prefix, multi_constructor):
if not 'yaml_multi_constructors' in cls.__dict__:
cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy()
cls.yaml_multi_constructors[tag_prefix] = multi_constructor
- add_multi_constructor = classmethod(add_multi_constructor)
class SafeConstructor(BaseConstructor):
def construct_scalar(self, node):
if isinstance(node, MappingNode):
for key_node, value_node in node.value:
- if key_node.tag == u'tag:yaml.org,2002:value':
+ if key_node.tag == 'tag:yaml.org,2002:value':
return self.construct_scalar(value_node)
- return BaseConstructor.construct_scalar(self, node)
+ return super().construct_scalar(node)
def flatten_mapping(self, node):
merge = []
index = 0
while index < len(node.value):
key_node, value_node = node.value[index]
- if key_node.tag == u'tag:yaml.org,2002:merge':
+ if key_node.tag == 'tag:yaml.org,2002:merge':
del node.value[index]
if isinstance(value_node, MappingNode):
self.flatten_mapping(value_node)
@@ -237,8 +204,8 @@ class SafeConstructor(BaseConstructor):
raise ConstructorError("while constructing a mapping", node.start_mark,
"expected a mapping or list of mappings for merging, but found %s"
% value_node.id, value_node.start_mark)
- elif key_node.tag == u'tag:yaml.org,2002:value':
- key_node.tag = u'tag:yaml.org,2002:str'
+ elif key_node.tag == 'tag:yaml.org,2002:value':
+ key_node.tag = 'tag:yaml.org,2002:str'
index += 1
else:
index += 1
@@ -248,19 +215,19 @@ class SafeConstructor(BaseConstructor):
def construct_mapping(self, node, deep=False):
if isinstance(node, MappingNode):
self.flatten_mapping(node)
- return BaseConstructor.construct_mapping(self, node, deep=deep)
+ return super().construct_mapping(node, deep=deep)
def construct_yaml_null(self, node):
self.construct_scalar(node)
return None
bool_values = {
- u'yes': True,
- u'no': False,
- u'true': True,
- u'false': False,
- u'on': True,
- u'off': False,
+ 'yes': True,
+ 'no': False,
+ 'true': True,
+ 'false': False,
+ 'on': True,
+ 'off': False,
}
def construct_yaml_bool(self, node):
@@ -268,7 +235,7 @@ class SafeConstructor(BaseConstructor):
return self.bool_values[value.lower()]
def construct_yaml_int(self, node):
- value = str(self.construct_scalar(node))
+ value = self.construct_scalar(node)
value = value.replace('_', '')
sign = +1
if value[0] == '-':
@@ -301,7 +268,7 @@ class SafeConstructor(BaseConstructor):
nan_value = -inf_value/inf_value # Trying to make a quiet NaN (like C99).
def construct_yaml_float(self, node):
- value = str(self.construct_scalar(node))
+ value = self.construct_scalar(node)
value = value.replace('_', '').lower()
sign = +1
if value[0] == '-':
@@ -325,15 +292,23 @@ class SafeConstructor(BaseConstructor):
return sign*float(value)
def construct_yaml_binary(self, node):
- value = self.construct_scalar(node)
try:
- return str(value).decode('base64')
- except (binascii.Error, UnicodeEncodeError), exc:
+ value = self.construct_scalar(node).encode('ascii')
+ except UnicodeEncodeError as exc:
+ raise ConstructorError(None, None,
+ "failed to convert base64 data into ascii: %s" % exc,
+ node.start_mark)
+ try:
+ if hasattr(base64, 'decodebytes'):
+ return base64.decodebytes(value)
+ else:
+ return base64.decodestring(value)
+ except binascii.Error as exc:
raise ConstructorError(None, None,
"failed to decode base64 data: %s" % exc, node.start_mark)
timestamp_regexp = re.compile(
- ur'''^(?P<year>[0-9][0-9][0-9][0-9])
+ r'''^(?P<year>[0-9][0-9][0-9][0-9])
-(?P<month>[0-9][0-9]?)
-(?P<day>[0-9][0-9]?)
(?:(?:[Tt]|[ \t]+)
@@ -369,9 +344,9 @@ class SafeConstructor(BaseConstructor):
delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute)
if values['tz_sign'] == '-':
delta = -delta
- tzinfo = timezone(delta)
+ tzinfo = datetime.timezone(delta)
elif values['tz']:
- tzinfo = timezone(datetime.timedelta(0))
+ tzinfo = datetime.timezone.utc
return datetime.datetime(year, month, day, hour, minute, second, fraction,
tzinfo=tzinfo)
@@ -425,11 +400,7 @@ class SafeConstructor(BaseConstructor):
data.update(value)
def construct_yaml_str(self, node):
- value = self.construct_scalar(node)
- try:
- return value.encode('ascii')
- except UnicodeEncodeError:
- return value
+ return self.construct_scalar(node)
def construct_yaml_seq(self, node):
data = []
@@ -454,55 +425,55 @@ class SafeConstructor(BaseConstructor):
def construct_undefined(self, node):
raise ConstructorError(None, None,
- "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'),
+ "could not determine a constructor for the tag %r" % node.tag,
node.start_mark)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:null',
+ 'tag:yaml.org,2002:null',
SafeConstructor.construct_yaml_null)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:bool',
+ 'tag:yaml.org,2002:bool',
SafeConstructor.construct_yaml_bool)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:int',
+ 'tag:yaml.org,2002:int',
SafeConstructor.construct_yaml_int)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:float',
+ 'tag:yaml.org,2002:float',
SafeConstructor.construct_yaml_float)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:binary',
+ 'tag:yaml.org,2002:binary',
SafeConstructor.construct_yaml_binary)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:timestamp',
+ 'tag:yaml.org,2002:timestamp',
SafeConstructor.construct_yaml_timestamp)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:omap',
+ 'tag:yaml.org,2002:omap',
SafeConstructor.construct_yaml_omap)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:pairs',
+ 'tag:yaml.org,2002:pairs',
SafeConstructor.construct_yaml_pairs)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:set',
+ 'tag:yaml.org,2002:set',
SafeConstructor.construct_yaml_set)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:str',
+ 'tag:yaml.org,2002:str',
SafeConstructor.construct_yaml_str)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:seq',
+ 'tag:yaml.org,2002:seq',
SafeConstructor.construct_yaml_seq)
SafeConstructor.add_constructor(
- u'tag:yaml.org,2002:map',
+ 'tag:yaml.org,2002:map',
SafeConstructor.construct_yaml_map)
SafeConstructor.add_constructor(None,
@@ -521,13 +492,29 @@ class FullConstructor(SafeConstructor):
return self.state_keys_blacklist_regexp
def construct_python_str(self, node):
- return self.construct_scalar(node).encode('utf-8')
+ return self.construct_scalar(node)
def construct_python_unicode(self, node):
return self.construct_scalar(node)
+ def construct_python_bytes(self, node):
+ try:
+ value = self.construct_scalar(node).encode('ascii')
+ except UnicodeEncodeError as exc:
+ raise ConstructorError(None, None,
+ "failed to convert base64 data into ascii: %s" % exc,
+ node.start_mark)
+ try:
+ if hasattr(base64, 'decodebytes'):
+ return base64.decodebytes(value)
+ else:
+ return base64.decodestring(value)
+ except binascii.Error as exc:
+ raise ConstructorError(None, None,
+ "failed to decode base64 data: %s" % exc, node.start_mark)
+
def construct_python_long(self, node):
- return long(self.construct_yaml_int(node))
+ return self.construct_yaml_int(node)
def construct_python_complex(self, node):
return complex(self.construct_scalar(node))
@@ -542,57 +529,53 @@ class FullConstructor(SafeConstructor):
if unsafe:
try:
__import__(name)
- except ImportError, exc:
+ except ImportError as exc:
raise ConstructorError("while constructing a Python module", mark,
- "cannot find module %r (%s)" % (name.encode('utf-8'), exc), mark)
+ "cannot find module %r (%s)" % (name, exc), mark)
if name not in sys.modules:
raise ConstructorError("while constructing a Python module", mark,
- "module %r is not imported" % name.encode('utf-8'), mark)
+ "module %r is not imported" % name, mark)
return sys.modules[name]
def find_python_name(self, name, mark, unsafe=False):
if not name:
raise ConstructorError("while constructing a Python object", mark,
"expected non-empty name appended to the tag", mark)
- if u'.' in name:
+ if '.' in name:
module_name, object_name = name.rsplit('.', 1)
else:
- module_name = '__builtin__'
+ module_name = 'builtins'
object_name = name
if unsafe:
try:
__import__(module_name)
- except ImportError, exc:
+ except ImportError as exc:
raise ConstructorError("while constructing a Python object", mark,
- "cannot find module %r (%s)" % (module_name.encode('utf-8'), exc), mark)
+ "cannot find module %r (%s)" % (module_name, exc), mark)
if module_name not in sys.modules:
raise ConstructorError("while constructing a Python object", mark,
- "module %r is not imported" % module_name.encode('utf-8'), mark)
+ "module %r is not imported" % module_name, mark)
module = sys.modules[module_name]
if not hasattr(module, object_name):
raise ConstructorError("while constructing a Python object", mark,
- "cannot find %r in the module %r" % (object_name.encode('utf-8'),
- module.__name__), mark)
+ "cannot find %r in the module %r"
+ % (object_name, module.__name__), mark)
return getattr(module, object_name)
def construct_python_name(self, suffix, node):
value = self.construct_scalar(node)
if value:
raise ConstructorError("while constructing a Python name", node.start_mark,
- "expected the empty value, but found %r" % value.encode('utf-8'),
- node.start_mark)
+ "expected the empty value, but found %r" % value, node.start_mark)
return self.find_python_name(suffix, node.start_mark)
def construct_python_module(self, suffix, node):
value = self.construct_scalar(node)
if value:
raise ConstructorError("while constructing a Python module", node.start_mark,
- "expected the empty value, but found %r" % value.encode('utf-8'),
- node.start_mark)
+ "expected the empty value, but found %r" % value, node.start_mark)
return self.find_python_module(suffix, node.start_mark)
- class classobj: pass
-
def make_python_instance(self, suffix, node,
args=None, kwds=None, newobj=False, unsafe=False):
if not args:
@@ -600,16 +583,11 @@ class FullConstructor(SafeConstructor):
if not kwds:
kwds = {}
cls = self.find_python_name(suffix, node.start_mark)
- if not (unsafe or isinstance(cls, type) or isinstance(cls, type(self.classobj))):
+ if not (unsafe or isinstance(cls, type)):
raise ConstructorError("while constructing a Python instance", node.start_mark,
"expected a class, but found %r" % type(cls),
node.start_mark)
- if newobj and isinstance(cls, type(self.classobj)) \
- and not args and not kwds:
- instance = self.classobj()
- instance.__class__ = cls
- return instance
- elif newobj and isinstance(cls, type):
+ if newobj and isinstance(cls, type):
return cls.__new__(cls, *args, **kwds)
else:
return cls(*args, **kwds)
@@ -681,51 +659,55 @@ class FullConstructor(SafeConstructor):
return self.construct_python_object_apply(suffix, node, newobj=True)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/none',
+ 'tag:yaml.org,2002:python/none',
FullConstructor.construct_yaml_null)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/bool',
+ 'tag:yaml.org,2002:python/bool',
FullConstructor.construct_yaml_bool)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/str',
+ 'tag:yaml.org,2002:python/str',
FullConstructor.construct_python_str)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/unicode',
+ 'tag:yaml.org,2002:python/unicode',
FullConstructor.construct_python_unicode)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/int',
+ 'tag:yaml.org,2002:python/bytes',
+ FullConstructor.construct_python_bytes)
+
+FullConstructor.add_constructor(
+ 'tag:yaml.org,2002:python/int',
FullConstructor.construct_yaml_int)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/long',
+ 'tag:yaml.org,2002:python/long',
FullConstructor.construct_python_long)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/float',
+ 'tag:yaml.org,2002:python/float',
FullConstructor.construct_yaml_float)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/complex',
+ 'tag:yaml.org,2002:python/complex',
FullConstructor.construct_python_complex)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/list',
+ 'tag:yaml.org,2002:python/list',
FullConstructor.construct_yaml_seq)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/tuple',
+ 'tag:yaml.org,2002:python/tuple',
FullConstructor.construct_python_tuple)
FullConstructor.add_constructor(
- u'tag:yaml.org,2002:python/dict',
+ 'tag:yaml.org,2002:python/dict',
FullConstructor.construct_yaml_map)
FullConstructor.add_multi_constructor(
- u'tag:yaml.org,2002:python/name:',
+ 'tag:yaml.org,2002:python/name:',
FullConstructor.construct_python_name)
class UnsafeConstructor(FullConstructor):
@@ -745,19 +727,19 @@ class UnsafeConstructor(FullConstructor):
instance, state, unsafe=True)
UnsafeConstructor.add_multi_constructor(
- u'tag:yaml.org,2002:python/module:',
+ 'tag:yaml.org,2002:python/module:',
UnsafeConstructor.construct_python_module)
UnsafeConstructor.add_multi_constructor(
- u'tag:yaml.org,2002:python/object:',
+ 'tag:yaml.org,2002:python/object:',
UnsafeConstructor.construct_python_object)
UnsafeConstructor.add_multi_constructor(
- u'tag:yaml.org,2002:python/object/new:',
+ 'tag:yaml.org,2002:python/object/new:',
UnsafeConstructor.construct_python_object_new)
UnsafeConstructor.add_multi_constructor(
- u'tag:yaml.org,2002:python/object/apply:',
+ 'tag:yaml.org,2002:python/object/apply:',
UnsafeConstructor.construct_python_object_apply)
# Constructor is same as UnsafeConstructor. Need to leave this in place in case
diff --git a/third_party/python/PyYAML/lib/yaml/cyaml.py b/third_party/python/PyYAML/lib/yaml/cyaml.py
index 768b49d6b9..0c21345879 100644
--- a/third_party/python/PyYAML/lib/yaml/cyaml.py
+++ b/third_party/python/PyYAML/lib/yaml/cyaml.py
@@ -6,12 +6,12 @@ __all__ = [
from yaml._yaml import CParser, CEmitter
-from constructor import *
+from .constructor import *
-from serializer import *
-from representer import *
+from .serializer import *
+from .representer import *
-from resolver import *
+from .resolver import *
class CBaseLoader(CParser, BaseConstructor, BaseResolver):
diff --git a/third_party/python/PyYAML/lib/yaml/dumper.py b/third_party/python/PyYAML/lib/yaml/dumper.py
index f9cd49fda5..6aadba551f 100644
--- a/third_party/python/PyYAML/lib/yaml/dumper.py
+++ b/third_party/python/PyYAML/lib/yaml/dumper.py
@@ -1,10 +1,10 @@
__all__ = ['BaseDumper', 'SafeDumper', 'Dumper']
-from emitter import *
-from serializer import *
-from representer import *
-from resolver import *
+from .emitter import *
+from .serializer import *
+from .representer import *
+from .resolver import *
class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver):
diff --git a/third_party/python/PyYAML/lib/yaml/emitter.py b/third_party/python/PyYAML/lib/yaml/emitter.py
index 23c25ca80a..a664d01116 100644
--- a/third_party/python/PyYAML/lib/yaml/emitter.py
+++ b/third_party/python/PyYAML/lib/yaml/emitter.py
@@ -8,17 +8,13 @@
__all__ = ['Emitter', 'EmitterError']
-import sys
-
-from error import YAMLError
-from events import *
-
-has_ucs4 = sys.maxunicode > 0xffff
+from .error import YAMLError
+from .events import *
class EmitterError(YAMLError):
pass
-class ScalarAnalysis(object):
+class ScalarAnalysis:
def __init__(self, scalar, empty, multiline,
allow_flow_plain, allow_block_plain,
allow_single_quoted, allow_double_quoted,
@@ -32,11 +28,11 @@ class ScalarAnalysis(object):
self.allow_double_quoted = allow_double_quoted
self.allow_block = allow_block
-class Emitter(object):
+class Emitter:
DEFAULT_TAG_PREFIXES = {
- u'!' : u'!',
- u'tag:yaml.org,2002:' : u'!!',
+ '!' : '!',
+ 'tag:yaml.org,2002:' : '!!',
}
def __init__(self, stream, canonical=None, indent=None, width=None,
@@ -92,8 +88,8 @@ class Emitter(object):
self.best_width = 80
if width and width > self.best_indent*2:
self.best_width = width
- self.best_line_break = u'\n'
- if line_break in [u'\r', u'\n', u'\r\n']:
+ self.best_line_break = '\n'
+ if line_break in ['\r', '\n', '\r\n']:
self.best_line_break = line_break
# Tag prefixes.
@@ -163,7 +159,7 @@ class Emitter(object):
def expect_stream_start(self):
if isinstance(self.event, StreamStartEvent):
- if self.event.encoding and not getattr(self.stream, 'encoding', None):
+ if self.event.encoding and not hasattr(self.stream, 'encoding'):
self.encoding = self.event.encoding
self.write_stream_start()
self.state = self.expect_first_document_start
@@ -182,15 +178,14 @@ class Emitter(object):
def expect_document_start(self, first=False):
if isinstance(self.event, DocumentStartEvent):
if (self.event.version or self.event.tags) and self.open_ended:
- self.write_indicator(u'...', True)
+ self.write_indicator('...', True)
self.write_indent()
if self.event.version:
version_text = self.prepare_version(self.event.version)
self.write_version_directive(version_text)
self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy()
if self.event.tags:
- handles = self.event.tags.keys()
- handles.sort()
+ handles = sorted(self.event.tags.keys())
for handle in handles:
prefix = self.event.tags[handle]
self.tag_prefixes[prefix] = handle
@@ -202,13 +197,13 @@ class Emitter(object):
and not self.check_empty_document())
if not implicit:
self.write_indent()
- self.write_indicator(u'---', True)
+ self.write_indicator('---', True)
if self.canonical:
self.write_indent()
self.state = self.expect_document_root
elif isinstance(self.event, StreamEndEvent):
if self.open_ended:
- self.write_indicator(u'...', True)
+ self.write_indicator('...', True)
self.write_indent()
self.write_stream_end()
self.state = self.expect_nothing
@@ -220,7 +215,7 @@ class Emitter(object):
if isinstance(self.event, DocumentEndEvent):
self.write_indent()
if self.event.explicit:
- self.write_indicator(u'...', True)
+ self.write_indicator('...', True)
self.write_indent()
self.flush_stream()
self.state = self.expect_document_start
@@ -243,7 +238,7 @@ class Emitter(object):
if isinstance(self.event, AliasEvent):
self.expect_alias()
elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)):
- self.process_anchor(u'&')
+ self.process_anchor('&')
self.process_tag()
if isinstance(self.event, ScalarEvent):
self.expect_scalar()
@@ -265,7 +260,7 @@ class Emitter(object):
def expect_alias(self):
if self.event.anchor is None:
raise EmitterError("anchor is not specified for alias")
- self.process_anchor(u'*')
+ self.process_anchor('*')
self.state = self.states.pop()
def expect_scalar(self):
@@ -277,7 +272,7 @@ class Emitter(object):
# Flow sequence handlers.
def expect_flow_sequence(self):
- self.write_indicator(u'[', True, whitespace=True)
+ self.write_indicator('[', True, whitespace=True)
self.flow_level += 1
self.increase_indent(flow=True)
self.state = self.expect_first_flow_sequence_item
@@ -286,7 +281,7 @@ class Emitter(object):
if isinstance(self.event, SequenceEndEvent):
self.indent = self.indents.pop()
self.flow_level -= 1
- self.write_indicator(u']', False)
+ self.write_indicator(']', False)
self.state = self.states.pop()
else:
if self.canonical or self.column > self.best_width:
@@ -299,12 +294,12 @@ class Emitter(object):
self.indent = self.indents.pop()
self.flow_level -= 1
if self.canonical:
- self.write_indicator(u',', False)
+ self.write_indicator(',', False)
self.write_indent()
- self.write_indicator(u']', False)
+ self.write_indicator(']', False)
self.state = self.states.pop()
else:
- self.write_indicator(u',', False)
+ self.write_indicator(',', False)
if self.canonical or self.column > self.best_width:
self.write_indent()
self.states.append(self.expect_flow_sequence_item)
@@ -313,7 +308,7 @@ class Emitter(object):
# Flow mapping handlers.
def expect_flow_mapping(self):
- self.write_indicator(u'{', True, whitespace=True)
+ self.write_indicator('{', True, whitespace=True)
self.flow_level += 1
self.increase_indent(flow=True)
self.state = self.expect_first_flow_mapping_key
@@ -322,7 +317,7 @@ class Emitter(object):
if isinstance(self.event, MappingEndEvent):
self.indent = self.indents.pop()
self.flow_level -= 1
- self.write_indicator(u'}', False)
+ self.write_indicator('}', False)
self.state = self.states.pop()
else:
if self.canonical or self.column > self.best_width:
@@ -331,7 +326,7 @@ class Emitter(object):
self.states.append(self.expect_flow_mapping_simple_value)
self.expect_node(mapping=True, simple_key=True)
else:
- self.write_indicator(u'?', True)
+ self.write_indicator('?', True)
self.states.append(self.expect_flow_mapping_value)
self.expect_node(mapping=True)
@@ -340,31 +335,31 @@ class Emitter(object):
self.indent = self.indents.pop()
self.flow_level -= 1
if self.canonical:
- self.write_indicator(u',', False)
+ self.write_indicator(',', False)
self.write_indent()
- self.write_indicator(u'}', False)
+ self.write_indicator('}', False)
self.state = self.states.pop()
else:
- self.write_indicator(u',', False)
+ self.write_indicator(',', False)
if self.canonical or self.column > self.best_width:
self.write_indent()
if not self.canonical and self.check_simple_key():
self.states.append(self.expect_flow_mapping_simple_value)
self.expect_node(mapping=True, simple_key=True)
else:
- self.write_indicator(u'?', True)
+ self.write_indicator('?', True)
self.states.append(self.expect_flow_mapping_value)
self.expect_node(mapping=True)
def expect_flow_mapping_simple_value(self):
- self.write_indicator(u':', False)
+ self.write_indicator(':', False)
self.states.append(self.expect_flow_mapping_key)
self.expect_node(mapping=True)
def expect_flow_mapping_value(self):
if self.canonical or self.column > self.best_width:
self.write_indent()
- self.write_indicator(u':', True)
+ self.write_indicator(':', True)
self.states.append(self.expect_flow_mapping_key)
self.expect_node(mapping=True)
@@ -384,7 +379,7 @@ class Emitter(object):
self.state = self.states.pop()
else:
self.write_indent()
- self.write_indicator(u'-', True, indention=True)
+ self.write_indicator('-', True, indention=True)
self.states.append(self.expect_block_sequence_item)
self.expect_node(sequence=True)
@@ -407,18 +402,18 @@ class Emitter(object):
self.states.append(self.expect_block_mapping_simple_value)
self.expect_node(mapping=True, simple_key=True)
else:
- self.write_indicator(u'?', True, indention=True)
+ self.write_indicator('?', True, indention=True)
self.states.append(self.expect_block_mapping_value)
self.expect_node(mapping=True)
def expect_block_mapping_simple_value(self):
- self.write_indicator(u':', False)
+ self.write_indicator(':', False)
self.states.append(self.expect_block_mapping_key)
self.expect_node(mapping=True)
def expect_block_mapping_value(self):
self.write_indent()
- self.write_indicator(u':', True, indention=True)
+ self.write_indicator(':', True, indention=True)
self.states.append(self.expect_block_mapping_key)
self.expect_node(mapping=True)
@@ -437,7 +432,7 @@ class Emitter(object):
return False
event = self.events[0]
return (isinstance(event, ScalarEvent) and event.anchor is None
- and event.tag is None and event.implicit and event.value == u'')
+ and event.tag is None and event.implicit and event.value == '')
def check_simple_key(self):
length = 0
@@ -482,7 +477,7 @@ class Emitter(object):
self.prepared_tag = None
return
if self.event.implicit[0] and tag is None:
- tag = u'!'
+ tag = '!'
self.prepared_tag = None
else:
if (not self.canonical or tag is None) and self.event.implicit:
@@ -545,19 +540,18 @@ class Emitter(object):
major, minor = version
if major != 1:
raise EmitterError("unsupported YAML version: %d.%d" % (major, minor))
- return u'%d.%d' % (major, minor)
+ return '%d.%d' % (major, minor)
def prepare_tag_handle(self, handle):
if not handle:
raise EmitterError("tag handle must not be empty")
- if handle[0] != u'!' or handle[-1] != u'!':
- raise EmitterError("tag handle must start and end with '!': %r"
- % (handle.encode('utf-8')))
+ if handle[0] != '!' or handle[-1] != '!':
+ raise EmitterError("tag handle must start and end with '!': %r" % handle)
for ch in handle[1:-1]:
- if not (u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
- or ch in u'-_'):
+ if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-_'):
raise EmitterError("invalid character %r in the tag handle: %r"
- % (ch.encode('utf-8'), handle.encode('utf-8')))
+ % (ch, handle))
return handle
def prepare_tag_prefix(self, prefix):
@@ -565,12 +559,12 @@ class Emitter(object):
raise EmitterError("tag prefix must not be empty")
chunks = []
start = end = 0
- if prefix[0] == u'!':
+ if prefix[0] == '!':
end = 1
while end < len(prefix):
ch = prefix[end]
- if u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
- or ch in u'-;/?!:@&=+$,_.~*\'()[]':
+ if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-;/?!:@&=+$,_.~*\'()[]':
end += 1
else:
if start < end:
@@ -578,32 +572,31 @@ class Emitter(object):
start = end = end+1
data = ch.encode('utf-8')
for ch in data:
- chunks.append(u'%%%02X' % ord(ch))
+ chunks.append('%%%02X' % ord(ch))
if start < end:
chunks.append(prefix[start:end])
- return u''.join(chunks)
+ return ''.join(chunks)
def prepare_tag(self, tag):
if not tag:
raise EmitterError("tag must not be empty")
- if tag == u'!':
+ if tag == '!':
return tag
handle = None
suffix = tag
- prefixes = self.tag_prefixes.keys()
- prefixes.sort()
+ prefixes = sorted(self.tag_prefixes.keys())
for prefix in prefixes:
if tag.startswith(prefix) \
- and (prefix == u'!' or len(prefix) < len(tag)):
+ and (prefix == '!' or len(prefix) < len(tag)):
handle = self.tag_prefixes[prefix]
suffix = tag[len(prefix):]
chunks = []
start = end = 0
while end < len(suffix):
ch = suffix[end]
- if u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
- or ch in u'-;/?:@&=+$,_.~*\'()[]' \
- or (ch == u'!' and handle != u'!'):
+ if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-;/?:@&=+$,_.~*\'()[]' \
+ or (ch == '!' and handle != '!'):
end += 1
else:
if start < end:
@@ -611,23 +604,23 @@ class Emitter(object):
start = end = end+1
data = ch.encode('utf-8')
for ch in data:
- chunks.append(u'%%%02X' % ord(ch))
+ chunks.append('%%%02X' % ch)
if start < end:
chunks.append(suffix[start:end])
- suffix_text = u''.join(chunks)
+ suffix_text = ''.join(chunks)
if handle:
- return u'%s%s' % (handle, suffix_text)
+ return '%s%s' % (handle, suffix_text)
else:
- return u'!<%s>' % suffix_text
+ return '!<%s>' % suffix_text
def prepare_anchor(self, anchor):
if not anchor:
raise EmitterError("anchor must not be empty")
for ch in anchor:
- if not (u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
- or ch in u'-_'):
+ if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-_'):
raise EmitterError("invalid character %r in the anchor: %r"
- % (ch.encode('utf-8'), anchor.encode('utf-8')))
+ % (ch, anchor))
return anchor
def analyze_scalar(self, scalar):
@@ -654,7 +647,7 @@ class Emitter(object):
space_break = False
# Check document indicators.
- if scalar.startswith(u'---') or scalar.startswith(u'...'):
+ if scalar.startswith('---') or scalar.startswith('...'):
block_indicators = True
flow_indicators = True
@@ -663,7 +656,7 @@ class Emitter(object):
# Last character or followed by a whitespace.
followed_by_whitespace = (len(scalar) == 1 or
- scalar[1] in u'\0 \t\r\n\x85\u2028\u2029')
+ scalar[1] in '\0 \t\r\n\x85\u2028\u2029')
# The previous character is a space.
previous_space = False
@@ -678,35 +671,35 @@ class Emitter(object):
# Check for indicators.
if index == 0:
# Leading indicators are special characters.
- if ch in u'#,[]{}&*!|>\'\"%@`':
+ if ch in '#,[]{}&*!|>\'\"%@`':
flow_indicators = True
block_indicators = True
- if ch in u'?:':
+ if ch in '?:':
flow_indicators = True
if followed_by_whitespace:
block_indicators = True
- if ch == u'-' and followed_by_whitespace:
+ if ch == '-' and followed_by_whitespace:
flow_indicators = True
block_indicators = True
else:
# Some indicators cannot appear within a scalar as well.
- if ch in u',?[]{}':
+ if ch in ',?[]{}':
flow_indicators = True
- if ch == u':':
+ if ch == ':':
flow_indicators = True
if followed_by_whitespace:
block_indicators = True
- if ch == u'#' and preceded_by_whitespace:
+ if ch == '#' and preceded_by_whitespace:
flow_indicators = True
block_indicators = True
# Check for line breaks, special, and unicode characters.
- if ch in u'\n\x85\u2028\u2029':
+ if ch in '\n\x85\u2028\u2029':
line_breaks = True
- if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'):
- if (ch == u'\x85' or u'\xA0' <= ch <= u'\uD7FF'
- or u'\uE000' <= ch <= u'\uFFFD'
- or (u'\U00010000' <= ch < u'\U0010ffff')) and ch != u'\uFEFF':
+ if not (ch == '\n' or '\x20' <= ch <= '\x7E'):
+ if (ch == '\x85' or '\xA0' <= ch <= '\uD7FF'
+ or '\uE000' <= ch <= '\uFFFD'
+ or '\U00010000' <= ch < '\U0010ffff') and ch != '\uFEFF':
unicode_characters = True
if not self.allow_unicode:
special_characters = True
@@ -714,7 +707,7 @@ class Emitter(object):
special_characters = True
# Detect important whitespace combinations.
- if ch == u' ':
+ if ch == ' ':
if index == 0:
leading_space = True
if index == len(scalar)-1:
@@ -723,7 +716,7 @@ class Emitter(object):
break_space = True
previous_space = True
previous_break = False
- elif ch in u'\n\x85\u2028\u2029':
+ elif ch in '\n\x85\u2028\u2029':
if index == 0:
leading_break = True
if index == len(scalar)-1:
@@ -738,9 +731,9 @@ class Emitter(object):
# Prepare for the next character.
index += 1
- preceded_by_whitespace = (ch in u'\0 \t\r\n\x85\u2028\u2029')
+ preceded_by_whitespace = (ch in '\0 \t\r\n\x85\u2028\u2029')
followed_by_whitespace = (index+1 >= len(scalar) or
- scalar[index+1] in u'\0 \t\r\n\x85\u2028\u2029')
+ scalar[index+1] in '\0 \t\r\n\x85\u2028\u2029')
# Let's decide what styles are allowed.
allow_flow_plain = True
@@ -799,7 +792,7 @@ class Emitter(object):
def write_stream_start(self):
# Write BOM if needed.
if self.encoding and self.encoding.startswith('utf-16'):
- self.stream.write(u'\uFEFF'.encode(self.encoding))
+ self.stream.write('\uFEFF'.encode(self.encoding))
def write_stream_end(self):
self.flush_stream()
@@ -809,7 +802,7 @@ class Emitter(object):
if self.whitespace or not need_whitespace:
data = indicator
else:
- data = u' '+indicator
+ data = ' '+indicator
self.whitespace = whitespace
self.indention = self.indention and indention
self.column += len(data)
@@ -825,7 +818,7 @@ class Emitter(object):
self.write_line_break()
if self.column < indent:
self.whitespace = True
- data = u' '*(indent-self.column)
+ data = ' '*(indent-self.column)
self.column = indent
if self.encoding:
data = data.encode(self.encoding)
@@ -843,14 +836,14 @@ class Emitter(object):
self.stream.write(data)
def write_version_directive(self, version_text):
- data = u'%%YAML %s' % version_text
+ data = '%%YAML %s' % version_text
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
self.write_line_break()
def write_tag_directive(self, handle_text, prefix_text):
- data = u'%%TAG %s %s' % (handle_text, prefix_text)
+ data = '%%TAG %s %s' % (handle_text, prefix_text)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
@@ -859,7 +852,7 @@ class Emitter(object):
# Scalar streams.
def write_single_quoted(self, text, split=True):
- self.write_indicator(u'\'', True)
+ self.write_indicator('\'', True)
spaces = False
breaks = False
start = end = 0
@@ -868,7 +861,7 @@ class Emitter(object):
if end < len(text):
ch = text[end]
if spaces:
- if ch is None or ch != u' ':
+ if ch is None or ch != ' ':
if start+1 == end and self.column > self.best_width and split \
and start != 0 and end != len(text):
self.write_indent()
@@ -880,18 +873,18 @@ class Emitter(object):
self.stream.write(data)
start = end
elif breaks:
- if ch is None or ch not in u'\n\x85\u2028\u2029':
- if text[start] == u'\n':
+ if ch is None or ch not in '\n\x85\u2028\u2029':
+ if text[start] == '\n':
self.write_line_break()
for br in text[start:end]:
- if br == u'\n':
+ if br == '\n':
self.write_line_break()
else:
self.write_line_break(br)
self.write_indent()
start = end
else:
- if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u'\'':
+ if ch is None or ch in ' \n\x85\u2028\u2029' or ch == '\'':
if start < end:
data = text[start:end]
self.column += len(data)
@@ -899,49 +892,49 @@ class Emitter(object):
data = data.encode(self.encoding)
self.stream.write(data)
start = end
- if ch == u'\'':
- data = u'\'\''
+ if ch == '\'':
+ data = '\'\''
self.column += 2
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
start = end + 1
if ch is not None:
- spaces = (ch == u' ')
- breaks = (ch in u'\n\x85\u2028\u2029')
+ spaces = (ch == ' ')
+ breaks = (ch in '\n\x85\u2028\u2029')
end += 1
- self.write_indicator(u'\'', False)
+ self.write_indicator('\'', False)
ESCAPE_REPLACEMENTS = {
- u'\0': u'0',
- u'\x07': u'a',
- u'\x08': u'b',
- u'\x09': u't',
- u'\x0A': u'n',
- u'\x0B': u'v',
- u'\x0C': u'f',
- u'\x0D': u'r',
- u'\x1B': u'e',
- u'\"': u'\"',
- u'\\': u'\\',
- u'\x85': u'N',
- u'\xA0': u'_',
- u'\u2028': u'L',
- u'\u2029': u'P',
+ '\0': '0',
+ '\x07': 'a',
+ '\x08': 'b',
+ '\x09': 't',
+ '\x0A': 'n',
+ '\x0B': 'v',
+ '\x0C': 'f',
+ '\x0D': 'r',
+ '\x1B': 'e',
+ '\"': '\"',
+ '\\': '\\',
+ '\x85': 'N',
+ '\xA0': '_',
+ '\u2028': 'L',
+ '\u2029': 'P',
}
def write_double_quoted(self, text, split=True):
- self.write_indicator(u'"', True)
+ self.write_indicator('"', True)
start = end = 0
while end <= len(text):
ch = None
if end < len(text):
ch = text[end]
- if ch is None or ch in u'"\\\x85\u2028\u2029\uFEFF' \
- or not (u'\x20' <= ch <= u'\x7E'
+ if ch is None or ch in '"\\\x85\u2028\u2029\uFEFF' \
+ or not ('\x20' <= ch <= '\x7E'
or (self.allow_unicode
- and (u'\xA0' <= ch <= u'\uD7FF'
- or u'\uE000' <= ch <= u'\uFFFD'))):
+ and ('\xA0' <= ch <= '\uD7FF'
+ or '\uE000' <= ch <= '\uFFFD'))):
if start < end:
data = text[start:end]
self.column += len(data)
@@ -951,21 +944,21 @@ class Emitter(object):
start = end
if ch is not None:
if ch in self.ESCAPE_REPLACEMENTS:
- data = u'\\'+self.ESCAPE_REPLACEMENTS[ch]
- elif ch <= u'\xFF':
- data = u'\\x%02X' % ord(ch)
- elif ch <= u'\uFFFF':
- data = u'\\u%04X' % ord(ch)
+ data = '\\'+self.ESCAPE_REPLACEMENTS[ch]
+ elif ch <= '\xFF':
+ data = '\\x%02X' % ord(ch)
+ elif ch <= '\uFFFF':
+ data = '\\u%04X' % ord(ch)
else:
- data = u'\\U%08X' % ord(ch)
+ data = '\\U%08X' % ord(ch)
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
start = end+1
- if 0 < end < len(text)-1 and (ch == u' ' or start >= end) \
+ if 0 < end < len(text)-1 and (ch == ' ' or start >= end) \
and self.column+(end-start) > self.best_width and split:
- data = text[start:end]+u'\\'
+ data = text[start:end]+'\\'
if start < end:
start = end
self.column += len(data)
@@ -975,30 +968,30 @@ class Emitter(object):
self.write_indent()
self.whitespace = False
self.indention = False
- if text[start] == u' ':
- data = u'\\'
+ if text[start] == ' ':
+ data = '\\'
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
end += 1
- self.write_indicator(u'"', False)
+ self.write_indicator('"', False)
def determine_block_hints(self, text):
- hints = u''
+ hints = ''
if text:
- if text[0] in u' \n\x85\u2028\u2029':
- hints += unicode(self.best_indent)
- if text[-1] not in u'\n\x85\u2028\u2029':
- hints += u'-'
- elif len(text) == 1 or text[-2] in u'\n\x85\u2028\u2029':
- hints += u'+'
+ if text[0] in ' \n\x85\u2028\u2029':
+ hints += str(self.best_indent)
+ if text[-1] not in '\n\x85\u2028\u2029':
+ hints += '-'
+ elif len(text) == 1 or text[-2] in '\n\x85\u2028\u2029':
+ hints += '+'
return hints
def write_folded(self, text):
hints = self.determine_block_hints(text)
- self.write_indicator(u'>'+hints, True)
- if hints[-1:] == u'+':
+ self.write_indicator('>'+hints, True)
+ if hints[-1:] == '+':
self.open_ended = True
self.write_line_break()
leading_space = True
@@ -1010,13 +1003,13 @@ class Emitter(object):
if end < len(text):
ch = text[end]
if breaks:
- if ch is None or ch not in u'\n\x85\u2028\u2029':
- if not leading_space and ch is not None and ch != u' ' \
- and text[start] == u'\n':
+ if ch is None or ch not in '\n\x85\u2028\u2029':
+ if not leading_space and ch is not None and ch != ' ' \
+ and text[start] == '\n':
self.write_line_break()
- leading_space = (ch == u' ')
+ leading_space = (ch == ' ')
for br in text[start:end]:
- if br == u'\n':
+ if br == '\n':
self.write_line_break()
else:
self.write_line_break(br)
@@ -1024,7 +1017,7 @@ class Emitter(object):
self.write_indent()
start = end
elif spaces:
- if ch != u' ':
+ if ch != ' ':
if start+1 == end and self.column > self.best_width:
self.write_indent()
else:
@@ -1035,7 +1028,7 @@ class Emitter(object):
self.stream.write(data)
start = end
else:
- if ch is None or ch in u' \n\x85\u2028\u2029':
+ if ch is None or ch in ' \n\x85\u2028\u2029':
data = text[start:end]
self.column += len(data)
if self.encoding:
@@ -1045,14 +1038,14 @@ class Emitter(object):
self.write_line_break()
start = end
if ch is not None:
- breaks = (ch in u'\n\x85\u2028\u2029')
- spaces = (ch == u' ')
+ breaks = (ch in '\n\x85\u2028\u2029')
+ spaces = (ch == ' ')
end += 1
def write_literal(self, text):
hints = self.determine_block_hints(text)
- self.write_indicator(u'|'+hints, True)
- if hints[-1:] == u'+':
+ self.write_indicator('|'+hints, True)
+ if hints[-1:] == '+':
self.open_ended = True
self.write_line_break()
breaks = True
@@ -1062,9 +1055,9 @@ class Emitter(object):
if end < len(text):
ch = text[end]
if breaks:
- if ch is None or ch not in u'\n\x85\u2028\u2029':
+ if ch is None or ch not in '\n\x85\u2028\u2029':
for br in text[start:end]:
- if br == u'\n':
+ if br == '\n':
self.write_line_break()
else:
self.write_line_break(br)
@@ -1072,7 +1065,7 @@ class Emitter(object):
self.write_indent()
start = end
else:
- if ch is None or ch in u'\n\x85\u2028\u2029':
+ if ch is None or ch in '\n\x85\u2028\u2029':
data = text[start:end]
if self.encoding:
data = data.encode(self.encoding)
@@ -1081,7 +1074,7 @@ class Emitter(object):
self.write_line_break()
start = end
if ch is not None:
- breaks = (ch in u'\n\x85\u2028\u2029')
+ breaks = (ch in '\n\x85\u2028\u2029')
end += 1
def write_plain(self, text, split=True):
@@ -1090,7 +1083,7 @@ class Emitter(object):
if not text:
return
if not self.whitespace:
- data = u' '
+ data = ' '
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
@@ -1105,7 +1098,7 @@ class Emitter(object):
if end < len(text):
ch = text[end]
if spaces:
- if ch != u' ':
+ if ch != ' ':
if start+1 == end and self.column > self.best_width and split:
self.write_indent()
self.whitespace = False
@@ -1118,11 +1111,11 @@ class Emitter(object):
self.stream.write(data)
start = end
elif breaks:
- if ch not in u'\n\x85\u2028\u2029':
- if text[start] == u'\n':
+ if ch not in '\n\x85\u2028\u2029':
+ if text[start] == '\n':
self.write_line_break()
for br in text[start:end]:
- if br == u'\n':
+ if br == '\n':
self.write_line_break()
else:
self.write_line_break(br)
@@ -1131,7 +1124,7 @@ class Emitter(object):
self.indention = False
start = end
else:
- if ch is None or ch in u' \n\x85\u2028\u2029':
+ if ch is None or ch in ' \n\x85\u2028\u2029':
data = text[start:end]
self.column += len(data)
if self.encoding:
@@ -1139,6 +1132,6 @@ class Emitter(object):
self.stream.write(data)
start = end
if ch is not None:
- spaces = (ch == u' ')
- breaks = (ch in u'\n\x85\u2028\u2029')
+ spaces = (ch == ' ')
+ breaks = (ch in '\n\x85\u2028\u2029')
end += 1
diff --git a/third_party/python/PyYAML/lib/yaml/error.py b/third_party/python/PyYAML/lib/yaml/error.py
index 577686db5f..b796b4dc51 100644
--- a/third_party/python/PyYAML/lib/yaml/error.py
+++ b/third_party/python/PyYAML/lib/yaml/error.py
@@ -1,7 +1,7 @@
__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError']
-class Mark(object):
+class Mark:
def __init__(self, name, index, line, column, buffer, pointer):
self.name = name
@@ -16,7 +16,7 @@ class Mark(object):
return None
head = ''
start = self.pointer
- while start > 0 and self.buffer[start-1] not in u'\0\r\n\x85\u2028\u2029':
+ while start > 0 and self.buffer[start-1] not in '\0\r\n\x85\u2028\u2029':
start -= 1
if self.pointer-start > max_length/2-1:
head = ' ... '
@@ -24,13 +24,13 @@ class Mark(object):
break
tail = ''
end = self.pointer
- while end < len(self.buffer) and self.buffer[end] not in u'\0\r\n\x85\u2028\u2029':
+ while end < len(self.buffer) and self.buffer[end] not in '\0\r\n\x85\u2028\u2029':
end += 1
if end-self.pointer > max_length/2-1:
tail = ' ... '
end -= 5
break
- snippet = self.buffer[start:end].encode('utf-8')
+ snippet = self.buffer[start:end]
return ' '*indent + head + snippet + tail + '\n' \
+ ' '*(indent+self.pointer-start+len(head)) + '^'
diff --git a/third_party/python/PyYAML/lib/yaml/loader.py b/third_party/python/PyYAML/lib/yaml/loader.py
index 4d773c3cc1..e90c11224c 100644
--- a/third_party/python/PyYAML/lib/yaml/loader.py
+++ b/third_party/python/PyYAML/lib/yaml/loader.py
@@ -1,12 +1,12 @@
__all__ = ['BaseLoader', 'FullLoader', 'SafeLoader', 'Loader', 'UnsafeLoader']
-from reader import *
-from scanner import *
-from parser import *
-from composer import *
-from constructor import *
-from resolver import *
+from .reader import *
+from .scanner import *
+from .parser import *
+from .composer import *
+from .constructor import *
+from .resolver import *
class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver):
diff --git a/third_party/python/PyYAML/lib/yaml/parser.py b/third_party/python/PyYAML/lib/yaml/parser.py
index f9e3057f33..13a5995d29 100644
--- a/third_party/python/PyYAML/lib/yaml/parser.py
+++ b/third_party/python/PyYAML/lib/yaml/parser.py
@@ -61,21 +61,21 @@
__all__ = ['Parser', 'ParserError']
-from error import MarkedYAMLError
-from tokens import *
-from events import *
-from scanner import *
+from .error import MarkedYAMLError
+from .tokens import *
+from .events import *
+from .scanner import *
class ParserError(MarkedYAMLError):
pass
-class Parser(object):
+class Parser:
# Since writing a recursive-descendant parser is a straightforward task, we
# do not give many comments here.
DEFAULT_TAGS = {
- u'!': u'!',
- u'!!': u'tag:yaml.org,2002:',
+ '!': '!',
+ '!!': 'tag:yaml.org,2002:',
}
def __init__(self):
@@ -219,7 +219,7 @@ class Parser(object):
self.tag_handles = {}
while self.check_token(DirectiveToken):
token = self.get_token()
- if token.name == u'YAML':
+ if token.name == 'YAML':
if self.yaml_version is not None:
raise ParserError(None, None,
"found duplicate YAML directive", token.start_mark)
@@ -229,11 +229,11 @@ class Parser(object):
"found incompatible YAML document (version 1.* is required)",
token.start_mark)
self.yaml_version = token.value
- elif token.name == u'TAG':
+ elif token.name == 'TAG':
handle, prefix = token.value
if handle in self.tag_handles:
raise ParserError(None, None,
- "duplicate tag handle %r" % handle.encode('utf-8'),
+ "duplicate tag handle %r" % handle,
token.start_mark)
self.tag_handles[handle] = prefix
if self.tag_handles:
@@ -303,19 +303,19 @@ class Parser(object):
if handle is not None:
if handle not in self.tag_handles:
raise ParserError("while parsing a node", start_mark,
- "found undefined tag handle %r" % handle.encode('utf-8'),
+ "found undefined tag handle %r" % handle,
tag_mark)
tag = self.tag_handles[handle]+suffix
else:
tag = suffix
- #if tag == u'!':
+ #if tag == '!':
# raise ParserError("while parsing a node", start_mark,
# "found non-specific tag '!'", tag_mark,
# "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.")
if start_mark is None:
start_mark = end_mark = self.peek_token().start_mark
event = None
- implicit = (tag is None or tag == u'!')
+ implicit = (tag is None or tag == '!')
if indentless_sequence and self.check_token(BlockEntryToken):
end_mark = self.peek_token().end_mark
event = SequenceStartEvent(anchor, tag, implicit,
@@ -325,7 +325,7 @@ class Parser(object):
if self.check_token(ScalarToken):
token = self.get_token()
end_mark = token.end_mark
- if (token.plain and tag is None) or tag == u'!':
+ if (token.plain and tag is None) or tag == '!':
implicit = (True, False)
elif tag is None:
implicit = (False, True)
@@ -357,7 +357,7 @@ class Parser(object):
elif anchor is not None or tag is not None:
# Empty scalars are allowed even if a tag or an anchor is
# specified.
- event = ScalarEvent(anchor, tag, (implicit, False), u'',
+ event = ScalarEvent(anchor, tag, (implicit, False), '',
start_mark, end_mark)
self.state = self.states.pop()
else:
@@ -585,5 +585,5 @@ class Parser(object):
return self.process_empty_scalar(self.peek_token().start_mark)
def process_empty_scalar(self, mark):
- return ScalarEvent(None, None, (True, False), u'', mark, mark)
+ return ScalarEvent(None, None, (True, False), '', mark, mark)
diff --git a/third_party/python/PyYAML/lib/yaml/reader.py b/third_party/python/PyYAML/lib/yaml/reader.py
index 4c42150989..774b0219b5 100644
--- a/third_party/python/PyYAML/lib/yaml/reader.py
+++ b/third_party/python/PyYAML/lib/yaml/reader.py
@@ -17,11 +17,9 @@
__all__ = ['Reader', 'ReaderError']
-from error import YAMLError, Mark
+from .error import YAMLError, Mark
-import codecs, re, sys
-
-has_ucs4 = sys.maxunicode > 0xffff
+import codecs, re
class ReaderError(YAMLError):
@@ -33,7 +31,7 @@ class ReaderError(YAMLError):
self.reason = reason
def __str__(self):
- if isinstance(self.character, str):
+ if isinstance(self.character, bytes):
return "'%s' codec can't decode byte #x%02x: %s\n" \
" in \"%s\", position %d" \
% (self.encoding, ord(self.character), self.reason,
@@ -46,13 +44,13 @@ class ReaderError(YAMLError):
class Reader(object):
# Reader:
- # - determines the data encoding and converts it to unicode,
+ # - determines the data encoding and converts it to a unicode string,
# - checks if characters are in allowed range,
# - adds '\0' to the end.
# Reader accepts
+ # - a `bytes` object,
# - a `str` object,
- # - a `unicode` object,
# - a file-like object with its `read` method returning `str`,
# - a file-like object with its `read` method returning `unicode`.
@@ -63,7 +61,7 @@ class Reader(object):
self.stream = None
self.stream_pointer = 0
self.eof = True
- self.buffer = u''
+ self.buffer = ''
self.pointer = 0
self.raw_buffer = None
self.raw_decode = None
@@ -71,19 +69,19 @@ class Reader(object):
self.index = 0
self.line = 0
self.column = 0
- if isinstance(stream, unicode):
+ if isinstance(stream, str):
self.name = "<unicode string>"
self.check_printable(stream)
- self.buffer = stream+u'\0'
- elif isinstance(stream, str):
- self.name = "<string>"
+ self.buffer = stream+'\0'
+ elif isinstance(stream, bytes):
+ self.name = "<byte string>"
self.raw_buffer = stream
self.determine_encoding()
else:
self.stream = stream
self.name = getattr(stream, 'name', "<file>")
self.eof = False
- self.raw_buffer = ''
+ self.raw_buffer = None
self.determine_encoding()
def peek(self, index=0):
@@ -105,11 +103,11 @@ class Reader(object):
ch = self.buffer[self.pointer]
self.pointer += 1
self.index += 1
- if ch in u'\n\x85\u2028\u2029' \
- or (ch == u'\r' and self.buffer[self.pointer] != u'\n'):
+ if ch in '\n\x85\u2028\u2029' \
+ or (ch == '\r' and self.buffer[self.pointer] != '\n'):
self.line += 1
self.column = 0
- elif ch != u'\uFEFF':
+ elif ch != '\uFEFF':
self.column += 1
length -= 1
@@ -122,9 +120,9 @@ class Reader(object):
None, None)
def determine_encoding(self):
- while not self.eof and len(self.raw_buffer) < 2:
+ while not self.eof and (self.raw_buffer is None or len(self.raw_buffer) < 2):
self.update_raw()
- if not isinstance(self.raw_buffer, unicode):
+ if isinstance(self.raw_buffer, bytes):
if self.raw_buffer.startswith(codecs.BOM_UTF16_LE):
self.raw_decode = codecs.utf_16_le_decode
self.encoding = 'utf-16-le'
@@ -136,15 +134,7 @@ class Reader(object):
self.encoding = 'utf-8'
self.update(1)
- if has_ucs4:
- NON_PRINTABLE = u'[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD\U00010000-\U0010ffff]'
- elif sys.platform.startswith('java'):
- # Jython doesn't support lone surrogates https://bugs.jython.org/issue2048
- NON_PRINTABLE = u'[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD]'
- else:
- # Need to use eval here due to the above Jython issue
- NON_PRINTABLE = eval(r"u'[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uFFFD]|(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF](?:[^\uDC00-\uDFFF]|$)'")
- NON_PRINTABLE = re.compile(NON_PRINTABLE)
+ NON_PRINTABLE = re.compile('[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD\U00010000-\U0010ffff]')
def check_printable(self, data):
match = self.NON_PRINTABLE.search(data)
if match:
@@ -165,8 +155,8 @@ class Reader(object):
try:
data, converted = self.raw_decode(self.raw_buffer,
'strict', self.eof)
- except UnicodeDecodeError, exc:
- character = exc.object[exc.start]
+ except UnicodeDecodeError as exc:
+ character = self.raw_buffer[exc.start]
if self.stream is not None:
position = self.stream_pointer-len(self.raw_buffer)+exc.start
else:
@@ -180,14 +170,16 @@ class Reader(object):
self.buffer += data
self.raw_buffer = self.raw_buffer[converted:]
if self.eof:
- self.buffer += u'\0'
+ self.buffer += '\0'
self.raw_buffer = None
break
- def update_raw(self, size=1024):
+ def update_raw(self, size=4096):
data = self.stream.read(size)
- if data:
- self.raw_buffer += data
- self.stream_pointer += len(data)
+ if self.raw_buffer is None:
+ self.raw_buffer = data
else:
+ self.raw_buffer += data
+ self.stream_pointer += len(data)
+ if not data:
self.eof = True
diff --git a/third_party/python/PyYAML/lib/yaml/representer.py b/third_party/python/PyYAML/lib/yaml/representer.py
index 93e09b67b3..808ca06dfb 100644
--- a/third_party/python/PyYAML/lib/yaml/representer.py
+++ b/third_party/python/PyYAML/lib/yaml/representer.py
@@ -2,26 +2,23 @@
__all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer',
'RepresenterError']
-from error import *
+from .error import *
+from .nodes import *
-from nodes import *
-
-import datetime
-
-import copy_reg, types
+import datetime, copyreg, types, base64, collections
class RepresenterError(YAMLError):
pass
-class BaseRepresenter(object):
+class BaseRepresenter:
yaml_representers = {}
yaml_multi_representers = {}
def __init__(self, default_style=None, default_flow_style=False, sort_keys=True):
self.default_style = default_style
- self.default_flow_style = default_flow_style
self.sort_keys = sort_keys
+ self.default_flow_style = default_flow_style
self.represented_objects = {}
self.object_keeper = []
self.alias_key = None
@@ -33,12 +30,6 @@ class BaseRepresenter(object):
self.object_keeper = []
self.alias_key = None
- def get_classobj_bases(self, cls):
- bases = [cls]
- for base in cls.__bases__:
- bases.extend(self.get_classobj_bases(base))
- return bases
-
def represent_data(self, data):
if self.ignore_aliases(data):
self.alias_key = None
@@ -53,8 +44,6 @@ class BaseRepresenter(object):
#self.represented_objects[alias_key] = None
self.object_keeper.append(data)
data_types = type(data).__mro__
- if type(data) is types.InstanceType:
- data_types = self.get_classobj_bases(data.__class__)+list(data_types)
if data_types[0] in self.yaml_representers:
node = self.yaml_representers[data_types[0]](self, data)
else:
@@ -68,22 +57,22 @@ class BaseRepresenter(object):
elif None in self.yaml_representers:
node = self.yaml_representers[None](self, data)
else:
- node = ScalarNode(None, unicode(data))
+ node = ScalarNode(None, str(data))
#if alias_key is not None:
# self.represented_objects[alias_key] = node
return node
+ @classmethod
def add_representer(cls, data_type, representer):
if not 'yaml_representers' in cls.__dict__:
cls.yaml_representers = cls.yaml_representers.copy()
cls.yaml_representers[data_type] = representer
- add_representer = classmethod(add_representer)
+ @classmethod
def add_multi_representer(cls, data_type, representer):
if not 'yaml_multi_representers' in cls.__dict__:
cls.yaml_multi_representers = cls.yaml_multi_representers.copy()
cls.yaml_multi_representers[data_type] = representer
- add_multi_representer = classmethod(add_multi_representer)
def represent_scalar(self, tag, value, style=None):
if style is None:
@@ -118,9 +107,12 @@ class BaseRepresenter(object):
self.represented_objects[self.alias_key] = node
best_style = True
if hasattr(mapping, 'items'):
- mapping = mapping.items()
+ mapping = list(mapping.items())
if self.sort_keys:
- mapping.sort()
+ try:
+ mapping = sorted(mapping)
+ except TypeError:
+ pass
for item_key, item_value in mapping:
node_key = self.represent_data(item_key)
node_value = self.represent_data(item_value)
@@ -146,44 +138,31 @@ class SafeRepresenter(BaseRepresenter):
return True
if isinstance(data, tuple) and data == ():
return True
- if isinstance(data, (str, unicode, bool, int, float)):
+ if isinstance(data, (str, bytes, bool, int, float)):
return True
def represent_none(self, data):
- return self.represent_scalar(u'tag:yaml.org,2002:null',
- u'null')
+ return self.represent_scalar('tag:yaml.org,2002:null', 'null')
def represent_str(self, data):
- tag = None
- style = None
- try:
- data = unicode(data, 'ascii')
- tag = u'tag:yaml.org,2002:str'
- except UnicodeDecodeError:
- try:
- data = unicode(data, 'utf-8')
- tag = u'tag:yaml.org,2002:str'
- except UnicodeDecodeError:
- data = data.encode('base64')
- tag = u'tag:yaml.org,2002:binary'
- style = '|'
- return self.represent_scalar(tag, data, style=style)
-
- def represent_unicode(self, data):
- return self.represent_scalar(u'tag:yaml.org,2002:str', data)
+ return self.represent_scalar('tag:yaml.org,2002:str', data)
+
+ def represent_binary(self, data):
+ if hasattr(base64, 'encodebytes'):
+ data = base64.encodebytes(data).decode('ascii')
+ else:
+ data = base64.encodestring(data).decode('ascii')
+ return self.represent_scalar('tag:yaml.org,2002:binary', data, style='|')
def represent_bool(self, data):
if data:
- value = u'true'
+ value = 'true'
else:
- value = u'false'
- return self.represent_scalar(u'tag:yaml.org,2002:bool', value)
+ value = 'false'
+ return self.represent_scalar('tag:yaml.org,2002:bool', value)
def represent_int(self, data):
- return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data))
-
- def represent_long(self, data):
- return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data))
+ return self.represent_scalar('tag:yaml.org,2002:int', str(data))
inf_value = 1e300
while repr(inf_value) != repr(inf_value*inf_value):
@@ -191,13 +170,13 @@ class SafeRepresenter(BaseRepresenter):
def represent_float(self, data):
if data != data or (data == 0.0 and data == 1.0):
- value = u'.nan'
+ value = '.nan'
elif data == self.inf_value:
- value = u'.inf'
+ value = '.inf'
elif data == -self.inf_value:
- value = u'-.inf'
+ value = '-.inf'
else:
- value = unicode(repr(data)).lower()
+ value = repr(data).lower()
# Note that in some cases `repr(data)` represents a float number
# without the decimal parts. For instance:
# >>> repr(1e17)
@@ -205,9 +184,9 @@ class SafeRepresenter(BaseRepresenter):
# Unfortunately, this is not a valid float representation according
# to the definition of the `!!float` tag. We fix this by adding
# '.0' before the 'e' symbol.
- if u'.' not in value and u'e' in value:
- value = value.replace(u'e', u'.0e', 1)
- return self.represent_scalar(u'tag:yaml.org,2002:float', value)
+ if '.' not in value and 'e' in value:
+ value = value.replace('e', '.0e', 1)
+ return self.represent_scalar('tag:yaml.org,2002:float', value)
def represent_list(self, data):
#pairs = (len(data) > 0 and isinstance(data, list))
@@ -217,7 +196,7 @@ class SafeRepresenter(BaseRepresenter):
# pairs = False
# break
#if not pairs:
- return self.represent_sequence(u'tag:yaml.org,2002:seq', data)
+ return self.represent_sequence('tag:yaml.org,2002:seq', data)
#value = []
#for item_key, item_value in data:
# value.append(self.represent_mapping(u'tag:yaml.org,2002:map',
@@ -225,21 +204,21 @@ class SafeRepresenter(BaseRepresenter):
#return SequenceNode(u'tag:yaml.org,2002:pairs', value)
def represent_dict(self, data):
- return self.represent_mapping(u'tag:yaml.org,2002:map', data)
+ return self.represent_mapping('tag:yaml.org,2002:map', data)
def represent_set(self, data):
value = {}
for key in data:
value[key] = None
- return self.represent_mapping(u'tag:yaml.org,2002:set', value)
+ return self.represent_mapping('tag:yaml.org,2002:set', value)
def represent_date(self, data):
- value = unicode(data.isoformat())
- return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value)
+ value = data.isoformat()
+ return self.represent_scalar('tag:yaml.org,2002:timestamp', value)
def represent_datetime(self, data):
- value = unicode(data.isoformat(' '))
- return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value)
+ value = data.isoformat(' ')
+ return self.represent_scalar('tag:yaml.org,2002:timestamp', value)
def represent_yaml_object(self, tag, data, cls, flow_style=None):
if hasattr(data, '__getstate__'):
@@ -257,8 +236,8 @@ SafeRepresenter.add_representer(type(None),
SafeRepresenter.add_representer(str,
SafeRepresenter.represent_str)
-SafeRepresenter.add_representer(unicode,
- SafeRepresenter.represent_unicode)
+SafeRepresenter.add_representer(bytes,
+ SafeRepresenter.represent_binary)
SafeRepresenter.add_representer(bool,
SafeRepresenter.represent_bool)
@@ -266,9 +245,6 @@ SafeRepresenter.add_representer(bool,
SafeRepresenter.add_representer(int,
SafeRepresenter.represent_int)
-SafeRepresenter.add_representer(long,
- SafeRepresenter.represent_long)
-
SafeRepresenter.add_representer(float,
SafeRepresenter.represent_float)
@@ -295,99 +271,27 @@ SafeRepresenter.add_representer(None,
class Representer(SafeRepresenter):
- def represent_str(self, data):
- tag = None
- style = None
- try:
- data = unicode(data, 'ascii')
- tag = u'tag:yaml.org,2002:str'
- except UnicodeDecodeError:
- try:
- data = unicode(data, 'utf-8')
- tag = u'tag:yaml.org,2002:python/str'
- except UnicodeDecodeError:
- data = data.encode('base64')
- tag = u'tag:yaml.org,2002:binary'
- style = '|'
- return self.represent_scalar(tag, data, style=style)
-
- def represent_unicode(self, data):
- tag = None
- try:
- data.encode('ascii')
- tag = u'tag:yaml.org,2002:python/unicode'
- except UnicodeEncodeError:
- tag = u'tag:yaml.org,2002:str'
- return self.represent_scalar(tag, data)
-
- def represent_long(self, data):
- tag = u'tag:yaml.org,2002:int'
- if int(data) is not data:
- tag = u'tag:yaml.org,2002:python/long'
- return self.represent_scalar(tag, unicode(data))
-
def represent_complex(self, data):
if data.imag == 0.0:
- data = u'%r' % data.real
+ data = '%r' % data.real
elif data.real == 0.0:
- data = u'%rj' % data.imag
+ data = '%rj' % data.imag
elif data.imag > 0:
- data = u'%r+%rj' % (data.real, data.imag)
+ data = '%r+%rj' % (data.real, data.imag)
else:
- data = u'%r%rj' % (data.real, data.imag)
- return self.represent_scalar(u'tag:yaml.org,2002:python/complex', data)
+ data = '%r%rj' % (data.real, data.imag)
+ return self.represent_scalar('tag:yaml.org,2002:python/complex', data)
def represent_tuple(self, data):
- return self.represent_sequence(u'tag:yaml.org,2002:python/tuple', data)
+ return self.represent_sequence('tag:yaml.org,2002:python/tuple', data)
def represent_name(self, data):
- name = u'%s.%s' % (data.__module__, data.__name__)
- return self.represent_scalar(u'tag:yaml.org,2002:python/name:'+name, u'')
+ name = '%s.%s' % (data.__module__, data.__name__)
+ return self.represent_scalar('tag:yaml.org,2002:python/name:'+name, '')
def represent_module(self, data):
return self.represent_scalar(
- u'tag:yaml.org,2002:python/module:'+data.__name__, u'')
-
- def represent_instance(self, data):
- # For instances of classic classes, we use __getinitargs__ and
- # __getstate__ to serialize the data.
-
- # If data.__getinitargs__ exists, the object must be reconstructed by
- # calling cls(**args), where args is a tuple returned by
- # __getinitargs__. Otherwise, the cls.__init__ method should never be
- # called and the class instance is created by instantiating a trivial
- # class and assigning to the instance's __class__ variable.
-
- # If data.__getstate__ exists, it returns the state of the object.
- # Otherwise, the state of the object is data.__dict__.
-
- # We produce either a !!python/object or !!python/object/new node.
- # If data.__getinitargs__ does not exist and state is a dictionary, we
- # produce a !!python/object node . Otherwise we produce a
- # !!python/object/new node.
-
- cls = data.__class__
- class_name = u'%s.%s' % (cls.__module__, cls.__name__)
- args = None
- state = None
- if hasattr(data, '__getinitargs__'):
- args = list(data.__getinitargs__())
- if hasattr(data, '__getstate__'):
- state = data.__getstate__()
- else:
- state = data.__dict__
- if args is None and isinstance(state, dict):
- return self.represent_mapping(
- u'tag:yaml.org,2002:python/object:'+class_name, state)
- if isinstance(state, dict) and not state:
- return self.represent_sequence(
- u'tag:yaml.org,2002:python/object/new:'+class_name, args)
- value = {}
- if args:
- value['args'] = args
- value['state'] = state
- return self.represent_mapping(
- u'tag:yaml.org,2002:python/object/new:'+class_name, value)
+ 'tag:yaml.org,2002:python/module:'+data.__name__, '')
def represent_object(self, data):
# We use __reduce__ API to save the data. data.__reduce__ returns
@@ -407,8 +311,8 @@ class Representer(SafeRepresenter):
# !!python/object/apply node.
cls = type(data)
- if cls in copy_reg.dispatch_table:
- reduce = copy_reg.dispatch_table[cls](data)
+ if cls in copyreg.dispatch_table:
+ reduce = copyreg.dispatch_table[cls](data)
elif hasattr(data, '__reduce_ex__'):
reduce = data.__reduce_ex__(2)
elif hasattr(data, '__reduce__'):
@@ -427,16 +331,16 @@ class Representer(SafeRepresenter):
if function.__name__ == '__newobj__':
function = args[0]
args = args[1:]
- tag = u'tag:yaml.org,2002:python/object/new:'
+ tag = 'tag:yaml.org,2002:python/object/new:'
newobj = True
else:
- tag = u'tag:yaml.org,2002:python/object/apply:'
+ tag = 'tag:yaml.org,2002:python/object/apply:'
newobj = False
- function_name = u'%s.%s' % (function.__module__, function.__name__)
+ function_name = '%s.%s' % (function.__module__, function.__name__)
if not args and not listitems and not dictitems \
and isinstance(state, dict) and newobj:
return self.represent_mapping(
- u'tag:yaml.org,2002:python/object:'+function_name, state)
+ 'tag:yaml.org,2002:python/object:'+function_name, state)
if not listitems and not dictitems \
and isinstance(state, dict) and not state:
return self.represent_sequence(tag+function_name, args)
@@ -451,14 +355,13 @@ class Representer(SafeRepresenter):
value['dictitems'] = dictitems
return self.represent_mapping(tag+function_name, value)
-Representer.add_representer(str,
- Representer.represent_str)
-
-Representer.add_representer(unicode,
- Representer.represent_unicode)
-
-Representer.add_representer(long,
- Representer.represent_long)
+ def represent_ordered_dict(self, data):
+ # Provide uniform representation across different Python versions.
+ data_type = type(data)
+ tag = 'tag:yaml.org,2002:python/object/apply:%s.%s' \
+ % (data_type.__module__, data_type.__name__)
+ items = [[key, value] for key, value in data.items()]
+ return self.represent_sequence(tag, [items])
Representer.add_representer(complex,
Representer.represent_complex)
@@ -466,11 +369,11 @@ Representer.add_representer(complex,
Representer.add_representer(tuple,
Representer.represent_tuple)
-Representer.add_representer(type,
+Representer.add_multi_representer(type,
Representer.represent_name)
-Representer.add_representer(types.ClassType,
- Representer.represent_name)
+Representer.add_representer(collections.OrderedDict,
+ Representer.represent_ordered_dict)
Representer.add_representer(types.FunctionType,
Representer.represent_name)
@@ -481,9 +384,6 @@ Representer.add_representer(types.BuiltinFunctionType,
Representer.add_representer(types.ModuleType,
Representer.represent_module)
-Representer.add_multi_representer(types.InstanceType,
- Representer.represent_instance)
-
Representer.add_multi_representer(object,
Representer.represent_object)
diff --git a/third_party/python/PyYAML/lib/yaml/resolver.py b/third_party/python/PyYAML/lib/yaml/resolver.py
index ba9aeab21d..3522bdaaf6 100644
--- a/third_party/python/PyYAML/lib/yaml/resolver.py
+++ b/third_party/python/PyYAML/lib/yaml/resolver.py
@@ -1,19 +1,19 @@
__all__ = ['BaseResolver', 'Resolver']
-from error import *
-from nodes import *
+from .error import *
+from .nodes import *
import re
class ResolverError(YAMLError):
pass
-class BaseResolver(object):
+class BaseResolver:
- DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str'
- DEFAULT_SEQUENCE_TAG = u'tag:yaml.org,2002:seq'
- DEFAULT_MAPPING_TAG = u'tag:yaml.org,2002:map'
+ DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'
+ DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq'
+ DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'
yaml_implicit_resolvers = {}
yaml_path_resolvers = {}
@@ -22,6 +22,7 @@ class BaseResolver(object):
self.resolver_exact_paths = []
self.resolver_prefix_paths = []
+ @classmethod
def add_implicit_resolver(cls, tag, regexp, first):
if not 'yaml_implicit_resolvers' in cls.__dict__:
implicit_resolvers = {}
@@ -32,8 +33,8 @@ class BaseResolver(object):
first = [None]
for ch in first:
cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp))
- add_implicit_resolver = classmethod(add_implicit_resolver)
+ @classmethod
def add_path_resolver(cls, tag, path, kind=None):
# Note: `add_path_resolver` is experimental. The API could be changed.
# `new_path` is a pattern that is matched against the path from the
@@ -69,10 +70,10 @@ class BaseResolver(object):
elif node_check is dict:
node_check = MappingNode
elif node_check not in [ScalarNode, SequenceNode, MappingNode] \
- and not isinstance(node_check, basestring) \
+ and not isinstance(node_check, str) \
and node_check is not None:
raise ResolverError("Invalid node checker: %s" % node_check)
- if not isinstance(index_check, (basestring, int)) \
+ if not isinstance(index_check, (str, int)) \
and index_check is not None:
raise ResolverError("Invalid index checker: %s" % index_check)
new_path.append((node_check, index_check))
@@ -86,7 +87,6 @@ class BaseResolver(object):
and kind is not None:
raise ResolverError("Invalid node kind: %s" % kind)
cls.yaml_path_resolvers[tuple(new_path), kind] = tag
- add_path_resolver = classmethod(add_path_resolver)
def descend_resolver(self, current_node, current_index):
if not self.yaml_path_resolvers:
@@ -120,7 +120,7 @@ class BaseResolver(object):
def check_resolver_prefix(self, depth, path, kind,
current_node, current_index):
node_check, index_check = path[depth-1]
- if isinstance(node_check, basestring):
+ if isinstance(node_check, str):
if current_node.tag != node_check:
return
elif node_check is not None:
@@ -131,7 +131,7 @@ class BaseResolver(object):
if (index_check is False or index_check is None) \
and current_index is None:
return
- if isinstance(index_check, basestring):
+ if isinstance(index_check, str):
if not (isinstance(current_index, ScalarNode)
and index_check == current_index.value):
return
@@ -142,8 +142,8 @@ class BaseResolver(object):
def resolve(self, kind, value, implicit):
if kind is ScalarNode and implicit[0]:
- if value == u'':
- resolvers = self.yaml_implicit_resolvers.get(u'', [])
+ if value == '':
+ resolvers = self.yaml_implicit_resolvers.get('', [])
else:
resolvers = self.yaml_implicit_resolvers.get(value[0], [])
wildcard_resolvers = self.yaml_implicit_resolvers.get(None, [])
@@ -168,60 +168,60 @@ class Resolver(BaseResolver):
pass
Resolver.add_implicit_resolver(
- u'tag:yaml.org,2002:bool',
- re.compile(ur'''^(?:yes|Yes|YES|no|No|NO
+ 'tag:yaml.org,2002:bool',
+ re.compile(r'''^(?:yes|Yes|YES|no|No|NO
|true|True|TRUE|false|False|FALSE
|on|On|ON|off|Off|OFF)$''', re.X),
- list(u'yYnNtTfFoO'))
+ list('yYnNtTfFoO'))
Resolver.add_implicit_resolver(
- u'tag:yaml.org,2002:float',
- re.compile(ur'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?
- |\.[0-9_]+(?:[eE][-+][0-9]+)?
+ 'tag:yaml.org,2002:float',
+ re.compile(r'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?
+ |\.[0-9][0-9_]*(?:[eE][-+][0-9]+)?
|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
|[-+]?\.(?:inf|Inf|INF)
|\.(?:nan|NaN|NAN))$''', re.X),
- list(u'-+0123456789.'))
+ list('-+0123456789.'))
Resolver.add_implicit_resolver(
- u'tag:yaml.org,2002:int',
- re.compile(ur'''^(?:[-+]?0b[0-1_]+
+ 'tag:yaml.org,2002:int',
+ re.compile(r'''^(?:[-+]?0b[0-1_]+
|[-+]?0[0-7_]+
|[-+]?(?:0|[1-9][0-9_]*)
|[-+]?0x[0-9a-fA-F_]+
|[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X),
- list(u'-+0123456789'))
+ list('-+0123456789'))
Resolver.add_implicit_resolver(
- u'tag:yaml.org,2002:merge',
- re.compile(ur'^(?:<<)$'),
- [u'<'])
+ 'tag:yaml.org,2002:merge',
+ re.compile(r'^(?:<<)$'),
+ ['<'])
Resolver.add_implicit_resolver(
- u'tag:yaml.org,2002:null',
- re.compile(ur'''^(?: ~
+ 'tag:yaml.org,2002:null',
+ re.compile(r'''^(?: ~
|null|Null|NULL
| )$''', re.X),
- [u'~', u'n', u'N', u''])
+ ['~', 'n', 'N', ''])
Resolver.add_implicit_resolver(
- u'tag:yaml.org,2002:timestamp',
- re.compile(ur'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]
+ 'tag:yaml.org,2002:timestamp',
+ re.compile(r'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]
|[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]?
(?:[Tt]|[ \t]+)[0-9][0-9]?
:[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)?
(?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X),
- list(u'0123456789'))
+ list('0123456789'))
Resolver.add_implicit_resolver(
- u'tag:yaml.org,2002:value',
- re.compile(ur'^(?:=)$'),
- [u'='])
+ 'tag:yaml.org,2002:value',
+ re.compile(r'^(?:=)$'),
+ ['='])
# The following resolver is only for documentation purposes. It cannot work
# because plain scalars cannot start with '!', '&', or '*'.
Resolver.add_implicit_resolver(
- u'tag:yaml.org,2002:yaml',
- re.compile(ur'^(?:!|&|\*)$'),
- list(u'!&*'))
+ 'tag:yaml.org,2002:yaml',
+ re.compile(r'^(?:!|&|\*)$'),
+ list('!&*'))
diff --git a/third_party/python/PyYAML/lib/yaml/scanner.py b/third_party/python/PyYAML/lib/yaml/scanner.py
index 098ea7be82..de925b07f1 100644
--- a/third_party/python/PyYAML/lib/yaml/scanner.py
+++ b/third_party/python/PyYAML/lib/yaml/scanner.py
@@ -26,13 +26,13 @@
__all__ = ['Scanner', 'ScannerError']
-from error import MarkedYAMLError
-from tokens import *
+from .error import MarkedYAMLError
+from .tokens import *
class ScannerError(MarkedYAMLError):
pass
-class SimpleKey(object):
+class SimpleKey:
# See below simple keys treatment.
def __init__(self, token_number, required, index, line, column, mark):
@@ -43,7 +43,7 @@ class SimpleKey(object):
self.column = column
self.mark = mark
-class Scanner(object):
+class Scanner:
def __init__(self):
"""Initialize the scanner."""
@@ -169,85 +169,85 @@ class Scanner(object):
ch = self.peek()
# Is it the end of stream?
- if ch == u'\0':
+ if ch == '\0':
return self.fetch_stream_end()
# Is it a directive?
- if ch == u'%' and self.check_directive():
+ if ch == '%' and self.check_directive():
return self.fetch_directive()
# Is it the document start?
- if ch == u'-' and self.check_document_start():
+ if ch == '-' and self.check_document_start():
return self.fetch_document_start()
# Is it the document end?
- if ch == u'.' and self.check_document_end():
+ if ch == '.' and self.check_document_end():
return self.fetch_document_end()
# TODO: support for BOM within a stream.
- #if ch == u'\uFEFF':
+ #if ch == '\uFEFF':
# return self.fetch_bom() <-- issue BOMToken
# Note: the order of the following checks is NOT significant.
# Is it the flow sequence start indicator?
- if ch == u'[':
+ if ch == '[':
return self.fetch_flow_sequence_start()
# Is it the flow mapping start indicator?
- if ch == u'{':
+ if ch == '{':
return self.fetch_flow_mapping_start()
# Is it the flow sequence end indicator?
- if ch == u']':
+ if ch == ']':
return self.fetch_flow_sequence_end()
# Is it the flow mapping end indicator?
- if ch == u'}':
+ if ch == '}':
return self.fetch_flow_mapping_end()
# Is it the flow entry indicator?
- if ch == u',':
+ if ch == ',':
return self.fetch_flow_entry()
# Is it the block entry indicator?
- if ch == u'-' and self.check_block_entry():
+ if ch == '-' and self.check_block_entry():
return self.fetch_block_entry()
# Is it the key indicator?
- if ch == u'?' and self.check_key():
+ if ch == '?' and self.check_key():
return self.fetch_key()
# Is it the value indicator?
- if ch == u':' and self.check_value():
+ if ch == ':' and self.check_value():
return self.fetch_value()
# Is it an alias?
- if ch == u'*':
+ if ch == '*':
return self.fetch_alias()
# Is it an anchor?
- if ch == u'&':
+ if ch == '&':
return self.fetch_anchor()
# Is it a tag?
- if ch == u'!':
+ if ch == '!':
return self.fetch_tag()
# Is it a literal scalar?
- if ch == u'|' and not self.flow_level:
+ if ch == '|' and not self.flow_level:
return self.fetch_literal()
# Is it a folded scalar?
- if ch == u'>' and not self.flow_level:
+ if ch == '>' and not self.flow_level:
return self.fetch_folded()
# Is it a single quoted scalar?
- if ch == u'\'':
+ if ch == '\'':
return self.fetch_single()
# Is it a double quoted scalar?
- if ch == u'\"':
+ if ch == '\"':
return self.fetch_double()
# It must be a plain scalar then.
@@ -256,8 +256,8 @@ class Scanner(object):
# No? It's an error. Let's produce a nice error message.
raise ScannerError("while scanning for the next token", None,
- "found character %r that cannot start any token"
- % ch.encode('utf-8'), self.get_mark())
+ "found character %r that cannot start any token" % ch,
+ self.get_mark())
# Simple keys treatment.
@@ -283,7 +283,7 @@ class Scanner(object):
# - should be no longer than 1024 characters.
# Disabling this procedure will allow simple keys of any length and
# height (may cause problems if indentation is broken though).
- for level in self.possible_simple_keys.keys():
+ for level in list(self.possible_simple_keys):
key = self.possible_simple_keys[level]
if key.line != self.line \
or self.index-key.index > 1024:
@@ -691,22 +691,22 @@ class Scanner(object):
# DOCUMENT-START: ^ '---' (' '|'\n')
if self.column == 0:
- if self.prefix(3) == u'---' \
- and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+ if self.prefix(3) == '---' \
+ and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
return True
def check_document_end(self):
# DOCUMENT-END: ^ '...' (' '|'\n')
if self.column == 0:
- if self.prefix(3) == u'...' \
- and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+ if self.prefix(3) == '...' \
+ and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
return True
def check_block_entry(self):
# BLOCK-ENTRY: '-' (' '|'\n')
- return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+ return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
def check_key(self):
@@ -716,7 +716,7 @@ class Scanner(object):
# KEY(block context): '?' (' '|'\n')
else:
- return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+ return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
def check_value(self):
@@ -726,7 +726,7 @@ class Scanner(object):
# VALUE(block context): ':' (' '|'\n')
else:
- return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+ return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029'
def check_plain(self):
@@ -743,9 +743,9 @@ class Scanner(object):
# '-' character) because we want the flow context to be space
# independent.
ch = self.peek()
- return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`' \
- or (self.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029'
- and (ch == u'-' or (not self.flow_level and ch in u'?:')))
+ return ch not in '\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`' \
+ or (self.peek(1) not in '\0 \t\r\n\x85\u2028\u2029'
+ and (ch == '-' or (not self.flow_level and ch in '?:')))
# Scanners.
@@ -769,14 +769,14 @@ class Scanner(object):
# `unwind_indent` before issuing BLOCK-END.
# Scanners for block, flow, and plain scalars need to be modified.
- if self.index == 0 and self.peek() == u'\uFEFF':
+ if self.index == 0 and self.peek() == '\uFEFF':
self.forward()
found = False
while not found:
- while self.peek() == u' ':
+ while self.peek() == ' ':
self.forward()
- if self.peek() == u'#':
- while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+ if self.peek() == '#':
+ while self.peek() not in '\0\r\n\x85\u2028\u2029':
self.forward()
if self.scan_line_break():
if not self.flow_level:
@@ -790,15 +790,15 @@ class Scanner(object):
self.forward()
name = self.scan_directive_name(start_mark)
value = None
- if name == u'YAML':
+ if name == 'YAML':
value = self.scan_yaml_directive_value(start_mark)
end_mark = self.get_mark()
- elif name == u'TAG':
+ elif name == 'TAG':
value = self.scan_tag_directive_value(start_mark)
end_mark = self.get_mark()
else:
end_mark = self.get_mark()
- while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+ while self.peek() not in '\0\r\n\x85\u2028\u2029':
self.forward()
self.scan_directive_ignored_line(start_mark)
return DirectiveToken(name, value, start_mark, end_mark)
@@ -807,51 +807,48 @@ class Scanner(object):
# See the specification for details.
length = 0
ch = self.peek(length)
- while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
- or ch in u'-_':
+ while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-_':
length += 1
ch = self.peek(length)
if not length:
raise ScannerError("while scanning a directive", start_mark,
"expected alphabetic or numeric character, but found %r"
- % ch.encode('utf-8'), self.get_mark())
+ % ch, self.get_mark())
value = self.prefix(length)
self.forward(length)
ch = self.peek()
- if ch not in u'\0 \r\n\x85\u2028\u2029':
+ if ch not in '\0 \r\n\x85\u2028\u2029':
raise ScannerError("while scanning a directive", start_mark,
"expected alphabetic or numeric character, but found %r"
- % ch.encode('utf-8'), self.get_mark())
+ % ch, self.get_mark())
return value
def scan_yaml_directive_value(self, start_mark):
# See the specification for details.
- while self.peek() == u' ':
+ while self.peek() == ' ':
self.forward()
major = self.scan_yaml_directive_number(start_mark)
if self.peek() != '.':
raise ScannerError("while scanning a directive", start_mark,
- "expected a digit or '.', but found %r"
- % self.peek().encode('utf-8'),
+ "expected a digit or '.', but found %r" % self.peek(),
self.get_mark())
self.forward()
minor = self.scan_yaml_directive_number(start_mark)
- if self.peek() not in u'\0 \r\n\x85\u2028\u2029':
+ if self.peek() not in '\0 \r\n\x85\u2028\u2029':
raise ScannerError("while scanning a directive", start_mark,
- "expected a digit or ' ', but found %r"
- % self.peek().encode('utf-8'),
+ "expected a digit or ' ', but found %r" % self.peek(),
self.get_mark())
return (major, minor)
def scan_yaml_directive_number(self, start_mark):
# See the specification for details.
ch = self.peek()
- if not (u'0' <= ch <= u'9'):
+ if not ('0' <= ch <= '9'):
raise ScannerError("while scanning a directive", start_mark,
- "expected a digit, but found %r" % ch.encode('utf-8'),
- self.get_mark())
+ "expected a digit, but found %r" % ch, self.get_mark())
length = 0
- while u'0' <= self.peek(length) <= u'9':
+ while '0' <= self.peek(length) <= '9':
length += 1
value = int(self.prefix(length))
self.forward(length)
@@ -859,10 +856,10 @@ class Scanner(object):
def scan_tag_directive_value(self, start_mark):
# See the specification for details.
- while self.peek() == u' ':
+ while self.peek() == ' ':
self.forward()
handle = self.scan_tag_directive_handle(start_mark)
- while self.peek() == u' ':
+ while self.peek() == ' ':
self.forward()
prefix = self.scan_tag_directive_prefix(start_mark)
return (handle, prefix)
@@ -871,34 +868,32 @@ class Scanner(object):
# See the specification for details.
value = self.scan_tag_handle('directive', start_mark)
ch = self.peek()
- if ch != u' ':
+ if ch != ' ':
raise ScannerError("while scanning a directive", start_mark,
- "expected ' ', but found %r" % ch.encode('utf-8'),
- self.get_mark())
+ "expected ' ', but found %r" % ch, self.get_mark())
return value
def scan_tag_directive_prefix(self, start_mark):
# See the specification for details.
value = self.scan_tag_uri('directive', start_mark)
ch = self.peek()
- if ch not in u'\0 \r\n\x85\u2028\u2029':
+ if ch not in '\0 \r\n\x85\u2028\u2029':
raise ScannerError("while scanning a directive", start_mark,
- "expected ' ', but found %r" % ch.encode('utf-8'),
- self.get_mark())
+ "expected ' ', but found %r" % ch, self.get_mark())
return value
def scan_directive_ignored_line(self, start_mark):
# See the specification for details.
- while self.peek() == u' ':
+ while self.peek() == ' ':
self.forward()
- if self.peek() == u'#':
- while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+ if self.peek() == '#':
+ while self.peek() not in '\0\r\n\x85\u2028\u2029':
self.forward()
ch = self.peek()
- if ch not in u'\0\r\n\x85\u2028\u2029':
+ if ch not in '\0\r\n\x85\u2028\u2029':
raise ScannerError("while scanning a directive", start_mark,
"expected a comment or a line break, but found %r"
- % ch.encode('utf-8'), self.get_mark())
+ % ch, self.get_mark())
self.scan_line_break()
def scan_anchor(self, TokenClass):
@@ -912,28 +907,28 @@ class Scanner(object):
# Therefore we restrict aliases to numbers and ASCII letters.
start_mark = self.get_mark()
indicator = self.peek()
- if indicator == u'*':
+ if indicator == '*':
name = 'alias'
else:
name = 'anchor'
self.forward()
length = 0
ch = self.peek(length)
- while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
- or ch in u'-_':
+ while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-_':
length += 1
ch = self.peek(length)
if not length:
raise ScannerError("while scanning an %s" % name, start_mark,
"expected alphabetic or numeric character, but found %r"
- % ch.encode('utf-8'), self.get_mark())
+ % ch, self.get_mark())
value = self.prefix(length)
self.forward(length)
ch = self.peek()
- if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`':
+ if ch not in '\0 \t\r\n\x85\u2028\u2029?:,]}%@`':
raise ScannerError("while scanning an %s" % name, start_mark,
"expected alphabetic or numeric character, but found %r"
- % ch.encode('utf-8'), self.get_mark())
+ % ch, self.get_mark())
end_mark = self.get_mark()
return TokenClass(value, start_mark, end_mark)
@@ -941,40 +936,39 @@ class Scanner(object):
# See the specification for details.
start_mark = self.get_mark()
ch = self.peek(1)
- if ch == u'<':
+ if ch == '<':
handle = None
self.forward(2)
suffix = self.scan_tag_uri('tag', start_mark)
- if self.peek() != u'>':
+ if self.peek() != '>':
raise ScannerError("while parsing a tag", start_mark,
- "expected '>', but found %r" % self.peek().encode('utf-8'),
+ "expected '>', but found %r" % self.peek(),
self.get_mark())
self.forward()
- elif ch in u'\0 \t\r\n\x85\u2028\u2029':
+ elif ch in '\0 \t\r\n\x85\u2028\u2029':
handle = None
- suffix = u'!'
+ suffix = '!'
self.forward()
else:
length = 1
use_handle = False
- while ch not in u'\0 \r\n\x85\u2028\u2029':
- if ch == u'!':
+ while ch not in '\0 \r\n\x85\u2028\u2029':
+ if ch == '!':
use_handle = True
break
length += 1
ch = self.peek(length)
- handle = u'!'
+ handle = '!'
if use_handle:
handle = self.scan_tag_handle('tag', start_mark)
else:
- handle = u'!'
+ handle = '!'
self.forward()
suffix = self.scan_tag_uri('tag', start_mark)
ch = self.peek()
- if ch not in u'\0 \r\n\x85\u2028\u2029':
+ if ch not in '\0 \r\n\x85\u2028\u2029':
raise ScannerError("while scanning a tag", start_mark,
- "expected ' ', but found %r" % ch.encode('utf-8'),
- self.get_mark())
+ "expected ' ', but found %r" % ch, self.get_mark())
value = (handle, suffix)
end_mark = self.get_mark()
return TagToken(value, start_mark, end_mark)
@@ -1005,39 +999,39 @@ class Scanner(object):
else:
indent = min_indent+increment-1
breaks, end_mark = self.scan_block_scalar_breaks(indent)
- line_break = u''
+ line_break = ''
# Scan the inner part of the block scalar.
- while self.column == indent and self.peek() != u'\0':
+ while self.column == indent and self.peek() != '\0':
chunks.extend(breaks)
- leading_non_space = self.peek() not in u' \t'
+ leading_non_space = self.peek() not in ' \t'
length = 0
- while self.peek(length) not in u'\0\r\n\x85\u2028\u2029':
+ while self.peek(length) not in '\0\r\n\x85\u2028\u2029':
length += 1
chunks.append(self.prefix(length))
self.forward(length)
line_break = self.scan_line_break()
breaks, end_mark = self.scan_block_scalar_breaks(indent)
- if self.column == indent and self.peek() != u'\0':
+ if self.column == indent and self.peek() != '\0':
# Unfortunately, folding rules are ambiguous.
#
# This is the folding according to the specification:
- if folded and line_break == u'\n' \
- and leading_non_space and self.peek() not in u' \t':
+ if folded and line_break == '\n' \
+ and leading_non_space and self.peek() not in ' \t':
if not breaks:
- chunks.append(u' ')
+ chunks.append(' ')
else:
chunks.append(line_break)
# This is Clark Evans's interpretation (also in the spec
# examples):
#
- #if folded and line_break == u'\n':
+ #if folded and line_break == '\n':
# if not breaks:
# if self.peek() not in ' \t':
- # chunks.append(u' ')
+ # chunks.append(' ')
# else:
# chunks.append(line_break)
#else:
@@ -1052,7 +1046,7 @@ class Scanner(object):
chunks.extend(breaks)
# We are done.
- return ScalarToken(u''.join(chunks), False, start_mark, end_mark,
+ return ScalarToken(''.join(chunks), False, start_mark, end_mark,
style)
def scan_block_scalar_indicators(self, start_mark):
@@ -1060,21 +1054,21 @@ class Scanner(object):
chomping = None
increment = None
ch = self.peek()
- if ch in u'+-':
+ if ch in '+-':
if ch == '+':
chomping = True
else:
chomping = False
self.forward()
ch = self.peek()
- if ch in u'0123456789':
+ if ch in '0123456789':
increment = int(ch)
if increment == 0:
raise ScannerError("while scanning a block scalar", start_mark,
"expected indentation indicator in the range 1-9, but found 0",
self.get_mark())
self.forward()
- elif ch in u'0123456789':
+ elif ch in '0123456789':
increment = int(ch)
if increment == 0:
raise ScannerError("while scanning a block scalar", start_mark,
@@ -1082,31 +1076,31 @@ class Scanner(object):
self.get_mark())
self.forward()
ch = self.peek()
- if ch in u'+-':
+ if ch in '+-':
if ch == '+':
chomping = True
else:
chomping = False
self.forward()
ch = self.peek()
- if ch not in u'\0 \r\n\x85\u2028\u2029':
+ if ch not in '\0 \r\n\x85\u2028\u2029':
raise ScannerError("while scanning a block scalar", start_mark,
"expected chomping or indentation indicators, but found %r"
- % ch.encode('utf-8'), self.get_mark())
+ % ch, self.get_mark())
return chomping, increment
def scan_block_scalar_ignored_line(self, start_mark):
# See the specification for details.
- while self.peek() == u' ':
+ while self.peek() == ' ':
self.forward()
- if self.peek() == u'#':
- while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+ if self.peek() == '#':
+ while self.peek() not in '\0\r\n\x85\u2028\u2029':
self.forward()
ch = self.peek()
- if ch not in u'\0\r\n\x85\u2028\u2029':
+ if ch not in '\0\r\n\x85\u2028\u2029':
raise ScannerError("while scanning a block scalar", start_mark,
- "expected a comment or a line break, but found %r"
- % ch.encode('utf-8'), self.get_mark())
+ "expected a comment or a line break, but found %r" % ch,
+ self.get_mark())
self.scan_line_break()
def scan_block_scalar_indentation(self):
@@ -1114,8 +1108,8 @@ class Scanner(object):
chunks = []
max_indent = 0
end_mark = self.get_mark()
- while self.peek() in u' \r\n\x85\u2028\u2029':
- if self.peek() != u' ':
+ while self.peek() in ' \r\n\x85\u2028\u2029':
+ if self.peek() != ' ':
chunks.append(self.scan_line_break())
end_mark = self.get_mark()
else:
@@ -1128,12 +1122,12 @@ class Scanner(object):
# See the specification for details.
chunks = []
end_mark = self.get_mark()
- while self.column < indent and self.peek() == u' ':
+ while self.column < indent and self.peek() == ' ':
self.forward()
- while self.peek() in u'\r\n\x85\u2028\u2029':
+ while self.peek() in '\r\n\x85\u2028\u2029':
chunks.append(self.scan_line_break())
end_mark = self.get_mark()
- while self.column < indent and self.peek() == u' ':
+ while self.column < indent and self.peek() == ' ':
self.forward()
return chunks, end_mark
@@ -1158,34 +1152,34 @@ class Scanner(object):
chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
self.forward()
end_mark = self.get_mark()
- return ScalarToken(u''.join(chunks), False, start_mark, end_mark,
+ return ScalarToken(''.join(chunks), False, start_mark, end_mark,
style)
ESCAPE_REPLACEMENTS = {
- u'0': u'\0',
- u'a': u'\x07',
- u'b': u'\x08',
- u't': u'\x09',
- u'\t': u'\x09',
- u'n': u'\x0A',
- u'v': u'\x0B',
- u'f': u'\x0C',
- u'r': u'\x0D',
- u'e': u'\x1B',
- u' ': u'\x20',
- u'\"': u'\"',
- u'\\': u'\\',
- u'/': u'/',
- u'N': u'\x85',
- u'_': u'\xA0',
- u'L': u'\u2028',
- u'P': u'\u2029',
+ '0': '\0',
+ 'a': '\x07',
+ 'b': '\x08',
+ 't': '\x09',
+ '\t': '\x09',
+ 'n': '\x0A',
+ 'v': '\x0B',
+ 'f': '\x0C',
+ 'r': '\x0D',
+ 'e': '\x1B',
+ ' ': '\x20',
+ '\"': '\"',
+ '\\': '\\',
+ '/': '/',
+ 'N': '\x85',
+ '_': '\xA0',
+ 'L': '\u2028',
+ 'P': '\u2029',
}
ESCAPE_CODES = {
- u'x': 2,
- u'u': 4,
- u'U': 8,
+ 'x': 2,
+ 'u': 4,
+ 'U': 8,
}
def scan_flow_scalar_non_spaces(self, double, start_mark):
@@ -1193,19 +1187,19 @@ class Scanner(object):
chunks = []
while True:
length = 0
- while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029':
+ while self.peek(length) not in '\'\"\\\0 \t\r\n\x85\u2028\u2029':
length += 1
if length:
chunks.append(self.prefix(length))
self.forward(length)
ch = self.peek()
- if not double and ch == u'\'' and self.peek(1) == u'\'':
- chunks.append(u'\'')
+ if not double and ch == '\'' and self.peek(1) == '\'':
+ chunks.append('\'')
self.forward(2)
- elif (double and ch == u'\'') or (not double and ch in u'\"\\'):
+ elif (double and ch == '\'') or (not double and ch in '\"\\'):
chunks.append(ch)
self.forward()
- elif double and ch == u'\\':
+ elif double and ch == '\\':
self.forward()
ch = self.peek()
if ch in self.ESCAPE_REPLACEMENTS:
@@ -1215,19 +1209,19 @@ class Scanner(object):
length = self.ESCAPE_CODES[ch]
self.forward()
for k in range(length):
- if self.peek(k) not in u'0123456789ABCDEFabcdef':
+ if self.peek(k) not in '0123456789ABCDEFabcdef':
raise ScannerError("while scanning a double-quoted scalar", start_mark,
- "expected escape sequence of %d hexdecimal numbers, but found %r" %
- (length, self.peek(k).encode('utf-8')), self.get_mark())
+ "expected escape sequence of %d hexadecimal numbers, but found %r" %
+ (length, self.peek(k)), self.get_mark())
code = int(self.prefix(length), 16)
- chunks.append(unichr(code))
+ chunks.append(chr(code))
self.forward(length)
- elif ch in u'\r\n\x85\u2028\u2029':
+ elif ch in '\r\n\x85\u2028\u2029':
self.scan_line_break()
chunks.extend(self.scan_flow_scalar_breaks(double, start_mark))
else:
raise ScannerError("while scanning a double-quoted scalar", start_mark,
- "found unknown escape character %r" % ch.encode('utf-8'), self.get_mark())
+ "found unknown escape character %r" % ch, self.get_mark())
else:
return chunks
@@ -1235,21 +1229,21 @@ class Scanner(object):
# See the specification for details.
chunks = []
length = 0
- while self.peek(length) in u' \t':
+ while self.peek(length) in ' \t':
length += 1
whitespaces = self.prefix(length)
self.forward(length)
ch = self.peek()
- if ch == u'\0':
+ if ch == '\0':
raise ScannerError("while scanning a quoted scalar", start_mark,
"found unexpected end of stream", self.get_mark())
- elif ch in u'\r\n\x85\u2028\u2029':
+ elif ch in '\r\n\x85\u2028\u2029':
line_break = self.scan_line_break()
breaks = self.scan_flow_scalar_breaks(double, start_mark)
- if line_break != u'\n':
+ if line_break != '\n':
chunks.append(line_break)
elif not breaks:
- chunks.append(u' ')
+ chunks.append(' ')
chunks.extend(breaks)
else:
chunks.append(whitespaces)
@@ -1262,13 +1256,13 @@ class Scanner(object):
# Instead of checking indentation, we check for document
# separators.
prefix = self.prefix(3)
- if (prefix == u'---' or prefix == u'...') \
- and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+ if (prefix == '---' or prefix == '...') \
+ and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
raise ScannerError("while scanning a quoted scalar", start_mark,
"found unexpected document separator", self.get_mark())
- while self.peek() in u' \t':
+ while self.peek() in ' \t':
self.forward()
- if self.peek() in u'\r\n\x85\u2028\u2029':
+ if self.peek() in '\r\n\x85\u2028\u2029':
chunks.append(self.scan_line_break())
else:
return chunks
@@ -1290,15 +1284,15 @@ class Scanner(object):
spaces = []
while True:
length = 0
- if self.peek() == u'#':
+ if self.peek() == '#':
break
while True:
ch = self.peek(length)
- if ch in u'\0 \t\r\n\x85\u2028\u2029' \
- or (ch == u':' and
- self.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029'
+ if ch in '\0 \t\r\n\x85\u2028\u2029' \
+ or (ch == ':' and
+ self.peek(length+1) in '\0 \t\r\n\x85\u2028\u2029'
+ (u',[]{}' if self.flow_level else u''))\
- or (self.flow_level and ch in u',?[]{}'):
+ or (self.flow_level and ch in ',?[]{}'):
break
length += 1
if length == 0:
@@ -1309,10 +1303,10 @@ class Scanner(object):
self.forward(length)
end_mark = self.get_mark()
spaces = self.scan_plain_spaces(indent, start_mark)
- if not spaces or self.peek() == u'#' \
+ if not spaces or self.peek() == '#' \
or (not self.flow_level and self.column < indent):
break
- return ScalarToken(u''.join(chunks), True, start_mark, end_mark)
+ return ScalarToken(''.join(chunks), True, start_mark, end_mark)
def scan_plain_spaces(self, indent, start_mark):
# See the specification for details.
@@ -1320,32 +1314,32 @@ class Scanner(object):
# We just forbid them completely. Do not use tabs in YAML!
chunks = []
length = 0
- while self.peek(length) in u' ':
+ while self.peek(length) in ' ':
length += 1
whitespaces = self.prefix(length)
self.forward(length)
ch = self.peek()
- if ch in u'\r\n\x85\u2028\u2029':
+ if ch in '\r\n\x85\u2028\u2029':
line_break = self.scan_line_break()
self.allow_simple_key = True
prefix = self.prefix(3)
- if (prefix == u'---' or prefix == u'...') \
- and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+ if (prefix == '---' or prefix == '...') \
+ and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
return
breaks = []
- while self.peek() in u' \r\n\x85\u2028\u2029':
+ while self.peek() in ' \r\n\x85\u2028\u2029':
if self.peek() == ' ':
self.forward()
else:
breaks.append(self.scan_line_break())
prefix = self.prefix(3)
- if (prefix == u'---' or prefix == u'...') \
- and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+ if (prefix == '---' or prefix == '...') \
+ and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029':
return
- if line_break != u'\n':
+ if line_break != '\n':
chunks.append(line_break)
elif not breaks:
- chunks.append(u' ')
+ chunks.append(' ')
chunks.extend(breaks)
elif whitespaces:
chunks.append(whitespaces)
@@ -1356,22 +1350,20 @@ class Scanner(object):
# For some strange reasons, the specification does not allow '_' in
# tag handles. I have allowed it anyway.
ch = self.peek()
- if ch != u'!':
+ if ch != '!':
raise ScannerError("while scanning a %s" % name, start_mark,
- "expected '!', but found %r" % ch.encode('utf-8'),
- self.get_mark())
+ "expected '!', but found %r" % ch, self.get_mark())
length = 1
ch = self.peek(length)
- if ch != u' ':
- while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
- or ch in u'-_':
+ if ch != ' ':
+ while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-_':
length += 1
ch = self.peek(length)
- if ch != u'!':
+ if ch != '!':
self.forward(length)
raise ScannerError("while scanning a %s" % name, start_mark,
- "expected '!', but found %r" % ch.encode('utf-8'),
- self.get_mark())
+ "expected '!', but found %r" % ch, self.get_mark())
length += 1
value = self.prefix(length)
self.forward(length)
@@ -1383,9 +1375,9 @@ class Scanner(object):
chunks = []
length = 0
ch = self.peek(length)
- while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
- or ch in u'-;/?:@&=+$,_.!~*\'()[]%':
- if ch == u'%':
+ while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
+ or ch in '-;/?:@&=+$,_.!~*\'()[]%':
+ if ch == '%':
chunks.append(self.prefix(length))
self.forward(length)
length = 0
@@ -1399,26 +1391,25 @@ class Scanner(object):
length = 0
if not chunks:
raise ScannerError("while parsing a %s" % name, start_mark,
- "expected URI, but found %r" % ch.encode('utf-8'),
- self.get_mark())
- return u''.join(chunks)
+ "expected URI, but found %r" % ch, self.get_mark())
+ return ''.join(chunks)
def scan_uri_escapes(self, name, start_mark):
# See the specification for details.
- bytes = []
+ codes = []
mark = self.get_mark()
- while self.peek() == u'%':
+ while self.peek() == '%':
self.forward()
for k in range(2):
- if self.peek(k) not in u'0123456789ABCDEFabcdef':
+ if self.peek(k) not in '0123456789ABCDEFabcdef':
raise ScannerError("while scanning a %s" % name, start_mark,
- "expected URI escape sequence of 2 hexdecimal numbers, but found %r" %
- (self.peek(k).encode('utf-8')), self.get_mark())
- bytes.append(chr(int(self.prefix(2), 16)))
+ "expected URI escape sequence of 2 hexadecimal numbers, but found %r"
+ % self.peek(k), self.get_mark())
+ codes.append(int(self.prefix(2), 16))
self.forward(2)
try:
- value = unicode(''.join(bytes), 'utf-8')
- except UnicodeDecodeError, exc:
+ value = bytes(codes).decode('utf-8')
+ except UnicodeDecodeError as exc:
raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark)
return value
@@ -1432,13 +1423,13 @@ class Scanner(object):
# '\u2029 : '\u2029'
# default : ''
ch = self.peek()
- if ch in u'\r\n\x85':
- if self.prefix(2) == u'\r\n':
+ if ch in '\r\n\x85':
+ if self.prefix(2) == '\r\n':
self.forward(2)
else:
self.forward()
- return u'\n'
- elif ch in u'\u2028\u2029':
+ return '\n'
+ elif ch in '\u2028\u2029':
self.forward()
return ch
- return u''
+ return ''
diff --git a/third_party/python/PyYAML/lib/yaml/serializer.py b/third_party/python/PyYAML/lib/yaml/serializer.py
index 0bf1e96dc1..fe911e67ae 100644
--- a/third_party/python/PyYAML/lib/yaml/serializer.py
+++ b/third_party/python/PyYAML/lib/yaml/serializer.py
@@ -1,16 +1,16 @@
__all__ = ['Serializer', 'SerializerError']
-from error import YAMLError
-from events import *
-from nodes import *
+from .error import YAMLError
+from .events import *
+from .nodes import *
class SerializerError(YAMLError):
pass
-class Serializer(object):
+class Serializer:
- ANCHOR_TEMPLATE = u'id%03d'
+ ANCHOR_TEMPLATE = 'id%03d'
def __init__(self, encoding=None,
explicit_start=None, explicit_end=None, version=None, tags=None):