diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-pyupgrade.spec | 1696 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 1698 insertions, 0 deletions
@@ -0,0 +1 @@ +/pyupgrade-3.3.1.tar.gz diff --git a/python-pyupgrade.spec b/python-pyupgrade.spec new file mode 100644 index 0000000..390a073 --- /dev/null +++ b/python-pyupgrade.spec @@ -0,0 +1,1696 @@ +%global _empty_manifest_terminate_build 0 +Name: python-pyupgrade +Version: 3.3.1 +Release: 1 +Summary: A tool to automatically upgrade syntax for newer versions. +License: MIT +URL: https://github.com/asottile/pyupgrade +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/b4/e8/4c3f29d281a6dcf7ffe19a19a446fd385b34802b3b33d25ebcc5ec03d285/pyupgrade-3.3.1.tar.gz +BuildArch: noarch + +Requires: python3-tokenize-rt + +%description +A tool (and pre-commit hook) to automatically upgrade syntax for newer +versions of the language. +## Installation +```bash +pip install pyupgrade +``` +## As a pre-commit hook +See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions +Sample `.pre-commit-config.yaml`: +```yaml +- repo: https://github.com/asottile/pyupgrade + rev: v3.3.1 + hooks: + - id: pyupgrade +``` +## Implemented features +### Set literals +```diff +-set(()) ++set() +-set([]) ++set() +-set((1,)) ++{1} +-set((1, 2)) ++{1, 2} +-set([1, 2]) ++{1, 2} +-set(x for x in y) ++{x for x in y} +-set([x for x in y]) ++{x for x in y} +``` +### Dictionary comprehensions +```diff +-dict((a, b) for a, b in y) ++{a: b for a, b in y} +-dict([(a, b) for a, b in y]) ++{a: b for a, b in y} +``` +### Format Specifiers +```diff +-'{0} {1}'.format(1, 2) ++'{} {}'.format(1, 2) +-'{0}' '{1}'.format(1, 2) ++'{}' '{}'.format(1, 2) +``` +### printf-style string formatting +Availability: +- Unless `--keep-percent-format` is passed. +```diff +-'%s %s' % (a, b) ++'{} {}'.format(a, b) +-'%r %2f' % (a, b) ++'{!r} {:2f}'.format(a, b) +-'%(a)s %(b)s' % {'a': 1, 'b': 2} ++'{a} {b}'.format(a=1, b=2) +``` +### Unicode literals +```diff +-u'foo' ++'foo' +-u"foo" ++'foo' +-u'''foo''' ++'''foo''' +``` +### Invalid escape sequences +```diff + # strings with only invalid sequences become raw strings +-'\d' ++r'\d' + # strings with mixed valid / invalid sequences get escaped +-'\n\d' ++'\n\\d' +-u'\d' ++r'\d' + # this fixes a syntax error in python3.3+ +-'\N' ++r'\N' +# note: pyupgrade is timid in one case (that's usually a mistake) +# in python2.x `'\u2603'` is the same as `'\\u2603'` without `unicode_literals` +# but in python3.x, that's our friend ☃ +``` +### `is` / `is not` comparison to constant literals +In python3.8+, comparison to literals becomes a `SyntaxWarning` as the success +of those comparisons is implementation specific (due to common object caching). +```diff +-x is 5 ++x == 5 +-x is not 5 ++x != 5 +-x is 'foo' ++x == 'foo' +``` +### `.encode()` to bytes literals +```diff +-'foo'.encode() ++b'foo' +-'foo'.encode('ascii') ++b'foo' +-'foo'.encode('utf-8') ++b'foo' +-u'foo'.encode() ++b'foo' +-'\xa0'.encode('latin1') ++b'\xa0' +``` +### extraneous parens in `print(...)` +A fix for [python-modernize/python-modernize#178] +```diff + # ok: printing an empty tuple + print(()) + # ok: printing a tuple + print((1,)) + # ok: parenthesized generator argument + sum((i for i in range(3)), []) + # fixed: +-print(("foo")) ++print("foo") +``` +[python-modernize/python-modernize#178]: https://github.com/python-modernize/python-modernize/issues/178 +### unittest deprecated aliases +Rewrites [deprecated unittest method aliases](https://docs.python.org/3/library/unittest.html#deprecated-aliases) to their non-deprecated forms. +```diff + from unittest import TestCase + class MyTests(TestCase): + def test_something(self): +- self.failUnlessEqual(1, 1) ++ self.assertEqual(1, 1) +- self.assertEquals(1, 1) ++ self.assertEqual(1, 1) +``` +### `super()` calls +```diff + class C(Base): + def f(self): +- super(C, self).f() ++ super().f() +``` +### "new style" classes +#### rewrites class declaration +```diff +-class C(object): pass ++class C: pass +-class C(B, object): pass ++class C(B): pass +``` +#### removes `__metaclass__ = type` declaration +```diff + class C: +- __metaclass__ = type +``` +### forced `str("native")` literals +```diff +-str() ++'' +-str("foo") ++"foo" +``` +### `.encode("utf-8")` +```diff +-"foo".encode("utf-8") ++"foo".encode() +``` +### `# coding: ...` comment +as of [PEP 3120], the default encoding for python source is UTF-8 +```diff +-# coding: utf-8 + x = 1 +``` +[PEP 3120]: https://www.python.org/dev/peps/pep-3120/ +### `__future__` import removal +Availability: +- by default removes `nested_scopes`, `generators`, `with_statement`, + `absolute_import`, `division`, `print_function`, `unicode_literals` +- `--py37-plus` will also remove `generator_stop` +```diff +-from __future__ import with_statement +``` +### Remove unnecessary py3-compat imports +```diff +-from io import open +-from six.moves import map +-from builtins import object # python-future +``` +### import replacements +Availability: +- `--py36-plus` (and others) will replace imports +see also [reorder-python-imports](https://github.com/asottile/reorder_python_imports#removing--rewriting-obsolete-six-imports) +some examples: +```diff +-from collections import deque, Mapping ++from collections import deque ++from collections.abc import Mapping +``` +```diff +-from typing import Sequence ++from collections.abc import Sequence +``` +```diff +-from typing_extensions import Concatenate ++from typing import Concatenate +``` +### rewrite `mock` imports +Availability: +- [Unless `--keep-mock` is passed on the commandline](https://github.com/asottile/pyupgrade/issues/314). +```diff +-from mock import patch ++from unittest.mock import patch +``` +### `yield` => `yield from` +```diff + def f(): +- for x in y: +- yield x ++ yield from y +- for a, b in c: +- yield (a, b) ++ yield from c +``` +### Python2 and old Python3.x blocks +```diff + import sys +-if sys.version_info < (3,): # also understands `six.PY2` (and `not`), `six.PY3` (and `not`) +- print('py2') +-else: +- print('py3') ++print('py3') +``` +Availability: +- `--py36-plus` will remove Python <= 3.5 only blocks +- `--py37-plus` will remove Python <= 3.6 only blocks +- so on and so forth +```diff + # using --py36-plus for this example + import sys +-if sys.version_info < (3, 6): +- print('py3.5') +-else: +- print('py3.6+') ++print('py3.6+') +-if sys.version_info <= (3, 5): +- print('py3.5') +-else: +- print('py3.6+') ++print('py3.6+') +-if sys.version_info >= (3, 6): +- print('py3.6+') +-else: +- print('py3.5') ++print('py3.6+') +``` +Note that `if` blocks without an `else` will not be rewritten as it could introduce a syntax error. +### remove `six` compatibility code +```diff +-six.text_type ++str +-six.binary_type ++bytes +-six.class_types ++(type,) +-six.string_types ++(str,) +-six.integer_types ++(int,) +-six.unichr ++chr +-six.iterbytes ++iter +-six.print_(...) ++print(...) +-six.exec_(c, g, l) ++exec(c, g, l) +-six.advance_iterator(it) ++next(it) +-six.next(it) ++next(it) +-six.callable(x) ++callable(x) +-six.moves.range(x) ++range(x) +-six.moves.xrange(x) ++range(x) +-from six import text_type +-text_type ++str +-@six.python_2_unicode_compatible + class C: + def __str__(self): + return u'C()' +-class C(six.Iterator): pass ++class C: pass +-class C(six.with_metaclass(M, B)): pass ++class C(B, metaclass=M): pass +-@six.add_metaclass(M) +-class C(B): pass ++class C(B, metaclass=M): pass +-isinstance(..., six.class_types) ++isinstance(..., type) +-issubclass(..., six.integer_types) ++issubclass(..., int) +-isinstance(..., six.string_types) ++isinstance(..., str) +-six.b('...') ++b'...' +-six.u('...') ++'...' +-six.byte2int(bs) ++bs[0] +-six.indexbytes(bs, i) ++bs[i] +-six.int2byte(i) ++bytes((i,)) +-six.iteritems(dct) ++dct.items() +-six.iterkeys(dct) ++dct.keys() +-six.itervalues(dct) ++dct.values() +-next(six.iteritems(dct)) ++next(iter(dct.items())) +-next(six.iterkeys(dct)) ++next(iter(dct.keys())) +-next(six.itervalues(dct)) ++next(iter(dct.values())) +-six.viewitems(dct) ++dct.items() +-six.viewkeys(dct) ++dct.keys() +-six.viewvalues(dct) ++dct.values() +-six.create_unbound_method(fn, cls) ++fn +-six.get_unbound_function(meth) ++meth +-six.get_method_function(meth) ++meth.__func__ +-six.get_method_self(meth) ++meth.__self__ +-six.get_function_closure(fn) ++fn.__closure__ +-six.get_function_code(fn) ++fn.__code__ +-six.get_function_defaults(fn) ++fn.__defaults__ +-six.get_function_globals(fn) ++fn.__globals__ +-six.raise_from(exc, exc_from) ++raise exc from exc_from +-six.reraise(tp, exc, tb) ++raise exc.with_traceback(tb) +-six.reraise(*sys.exc_info()) ++raise +-six.assertCountEqual(self, a1, a2) ++self.assertCountEqual(a1, a2) +-six.assertRaisesRegex(self, e, r, fn) ++self.assertRaisesRegex(e, r, fn) +-six.assertRegex(self, s, r) ++self.assertRegex(s, r) + # note: only for *literals* +-six.ensure_binary('...') ++b'...' +-six.ensure_str('...') ++'...' +-six.ensure_text('...') ++'...' +``` +### `open` alias +```diff +-with io.open('f.txt') as f: ++with open('f.txt') as f: +``` +### redundant `open` modes +```diff +-open("foo", "U") ++open("foo") +-open("foo", "Ur") ++open("foo") +-open("foo", "Ub") ++open("foo", "rb") +-open("foo", "rUb") ++open("foo", "rb") +-open("foo", "r") ++open("foo") +-open("foo", "rt") ++open("foo") +-open("f", "r", encoding="UTF-8") ++open("f", encoding="UTF-8") +-open("f", "wt") ++open("f", "w") +``` +### `OSError` aliases +```diff + # also understands: + # - IOError + # - WindowsError + # - mmap.error and uses of `from mmap import error` + # - select.error and uses of `from select import error` + # - socket.error and uses of `from socket import error` + def throw(): +- raise EnvironmentError('boom') ++ raise OSError('boom') + def catch(): + try: + throw() +- except EnvironmentError: ++ except OSError: + handle_error() +``` +### `typing.Text` str alias +```diff +-def f(x: Text) -> None: ++def f(x: str) -> None: +``` +### Unpacking list comprehensions +```diff +-foo, bar, baz = [fn(x) for x in items] ++foo, bar, baz = (fn(x) for x in items) +``` +### Rewrite `xml.etree.cElementTree` to `xml.etree.ElementTree` +```diff +-import xml.etree.cElementTree as ET ++import xml.etree.ElementTree as ET +-from xml.etree.cElementTree import XML ++from xml.etree.ElementTree import XML +``` +### Rewrite `type` of primitive +```diff +-type('') ++str +-type(b'') ++bytes +-type(0) ++int +-type(0.) ++float +``` +### `typing.NamedTuple` / `typing.TypedDict` py36+ syntax +Availability: +- `--py36-plus` is passed on the commandline. +```diff +-NT = typing.NamedTuple('NT', [('a', int), ('b', Tuple[str, ...])]) ++class NT(typing.NamedTuple): ++ a: int ++ b: Tuple[str, ...] +-D1 = typing.TypedDict('D1', a=int, b=str) ++class D1(typing.TypedDict): ++ a: int ++ b: str +-D2 = typing.TypedDict('D2', {'a': int, 'b': str}) ++class D2(typing.TypedDict): ++ a: int ++ b: str +``` +### f-strings +Availability: +- `--py36-plus` is passed on the commandline. +```diff +-'{foo} {bar}'.format(foo=foo, bar=bar) ++f'{foo} {bar}' +-'{} {}'.format(foo, bar) ++f'{foo} {bar}' +-'{} {}'.format(foo.bar, baz.womp) ++f'{foo.bar} {baz.womp}' +-'{} {}'.format(f(), g()) ++f'{f()} {g()}' +-'{x}'.format(**locals()) ++f'{x}' +``` +_note_: `pyupgrade` is intentionally timid and will not create an f-string +if it would make the expression longer or if the substitution parameters are +sufficiently complicated (as this can decrease readability). +### `subprocess.run`: replace `universal_newlines` with `text` +Availability: +- `--py37-plus` is passed on the commandline. +```diff +-output = subprocess.run(['foo'], universal_newlines=True) ++output = subprocess.run(['foo'], text=True) +``` +### `subprocess.run`: replace `stdout=subprocess.PIPE, stderr=subprocess.PIPE` with `capture_output=True` +Availability: +- `--py37-plus` is passed on the commandline. +```diff +-output = subprocess.run(['foo'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) ++output = subprocess.run(['foo'], capture_output=True) +``` +### remove parentheses from `@functools.lru_cache()` +Availability: +- `--py38-plus` is passed on the commandline. +```diff + import functools +-@functools.lru_cache() ++@functools.lru_cache + def expensive(): +``` +### replace `@functools.lru_cache(maxsize=None)` with shorthand +Availability: +- `--py39-plus` is passed on the commandline. +```diff + import functools +-@functools.lru_cache(maxsize=None) ++@functools.cache + def expensive(): +``` +### pep 585 typing rewrites +Availability: +- File imports `from __future__ import annotations` + - Unless `--keep-runtime-typing` is passed on the commandline. +- `--py39-plus` is passed on the commandline. +```diff +-def f(x: List[str]) -> None: ++def f(x: list[str]) -> None: +``` +### pep 604 typing rewrites +Availability: +- File imports `from __future__ import annotations` + - Unless `--keep-runtime-typing` is passed on the commandline. +- `--py310-plus` is passed on the commandline. +```diff +-def f() -> Optional[str]: ++def f() -> str | None: +``` +```diff +-def f() -> Union[int, str]: ++def f() -> int | str: +``` +### remove quoted annotations +Availability: +- File imports `from __future__ import annotations` +```diff +-def f(x: 'queue.Queue[int]') -> C: ++def f(x: queue.Queue[int]) -> C: +``` +### use `datetime.UTC` alias +Availability: +- `--py311-plus` is passed on the commandline. +```diff + import datetime +-datetime.timezone.utc ++datetime.UTC +``` + +%package -n python3-pyupgrade +Summary: A tool to automatically upgrade syntax for newer versions. +Provides: python-pyupgrade +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-pyupgrade +A tool (and pre-commit hook) to automatically upgrade syntax for newer +versions of the language. +## Installation +```bash +pip install pyupgrade +``` +## As a pre-commit hook +See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions +Sample `.pre-commit-config.yaml`: +```yaml +- repo: https://github.com/asottile/pyupgrade + rev: v3.3.1 + hooks: + - id: pyupgrade +``` +## Implemented features +### Set literals +```diff +-set(()) ++set() +-set([]) ++set() +-set((1,)) ++{1} +-set((1, 2)) ++{1, 2} +-set([1, 2]) ++{1, 2} +-set(x for x in y) ++{x for x in y} +-set([x for x in y]) ++{x for x in y} +``` +### Dictionary comprehensions +```diff +-dict((a, b) for a, b in y) ++{a: b for a, b in y} +-dict([(a, b) for a, b in y]) ++{a: b for a, b in y} +``` +### Format Specifiers +```diff +-'{0} {1}'.format(1, 2) ++'{} {}'.format(1, 2) +-'{0}' '{1}'.format(1, 2) ++'{}' '{}'.format(1, 2) +``` +### printf-style string formatting +Availability: +- Unless `--keep-percent-format` is passed. +```diff +-'%s %s' % (a, b) ++'{} {}'.format(a, b) +-'%r %2f' % (a, b) ++'{!r} {:2f}'.format(a, b) +-'%(a)s %(b)s' % {'a': 1, 'b': 2} ++'{a} {b}'.format(a=1, b=2) +``` +### Unicode literals +```diff +-u'foo' ++'foo' +-u"foo" ++'foo' +-u'''foo''' ++'''foo''' +``` +### Invalid escape sequences +```diff + # strings with only invalid sequences become raw strings +-'\d' ++r'\d' + # strings with mixed valid / invalid sequences get escaped +-'\n\d' ++'\n\\d' +-u'\d' ++r'\d' + # this fixes a syntax error in python3.3+ +-'\N' ++r'\N' +# note: pyupgrade is timid in one case (that's usually a mistake) +# in python2.x `'\u2603'` is the same as `'\\u2603'` without `unicode_literals` +# but in python3.x, that's our friend ☃ +``` +### `is` / `is not` comparison to constant literals +In python3.8+, comparison to literals becomes a `SyntaxWarning` as the success +of those comparisons is implementation specific (due to common object caching). +```diff +-x is 5 ++x == 5 +-x is not 5 ++x != 5 +-x is 'foo' ++x == 'foo' +``` +### `.encode()` to bytes literals +```diff +-'foo'.encode() ++b'foo' +-'foo'.encode('ascii') ++b'foo' +-'foo'.encode('utf-8') ++b'foo' +-u'foo'.encode() ++b'foo' +-'\xa0'.encode('latin1') ++b'\xa0' +``` +### extraneous parens in `print(...)` +A fix for [python-modernize/python-modernize#178] +```diff + # ok: printing an empty tuple + print(()) + # ok: printing a tuple + print((1,)) + # ok: parenthesized generator argument + sum((i for i in range(3)), []) + # fixed: +-print(("foo")) ++print("foo") +``` +[python-modernize/python-modernize#178]: https://github.com/python-modernize/python-modernize/issues/178 +### unittest deprecated aliases +Rewrites [deprecated unittest method aliases](https://docs.python.org/3/library/unittest.html#deprecated-aliases) to their non-deprecated forms. +```diff + from unittest import TestCase + class MyTests(TestCase): + def test_something(self): +- self.failUnlessEqual(1, 1) ++ self.assertEqual(1, 1) +- self.assertEquals(1, 1) ++ self.assertEqual(1, 1) +``` +### `super()` calls +```diff + class C(Base): + def f(self): +- super(C, self).f() ++ super().f() +``` +### "new style" classes +#### rewrites class declaration +```diff +-class C(object): pass ++class C: pass +-class C(B, object): pass ++class C(B): pass +``` +#### removes `__metaclass__ = type` declaration +```diff + class C: +- __metaclass__ = type +``` +### forced `str("native")` literals +```diff +-str() ++'' +-str("foo") ++"foo" +``` +### `.encode("utf-8")` +```diff +-"foo".encode("utf-8") ++"foo".encode() +``` +### `# coding: ...` comment +as of [PEP 3120], the default encoding for python source is UTF-8 +```diff +-# coding: utf-8 + x = 1 +``` +[PEP 3120]: https://www.python.org/dev/peps/pep-3120/ +### `__future__` import removal +Availability: +- by default removes `nested_scopes`, `generators`, `with_statement`, + `absolute_import`, `division`, `print_function`, `unicode_literals` +- `--py37-plus` will also remove `generator_stop` +```diff +-from __future__ import with_statement +``` +### Remove unnecessary py3-compat imports +```diff +-from io import open +-from six.moves import map +-from builtins import object # python-future +``` +### import replacements +Availability: +- `--py36-plus` (and others) will replace imports +see also [reorder-python-imports](https://github.com/asottile/reorder_python_imports#removing--rewriting-obsolete-six-imports) +some examples: +```diff +-from collections import deque, Mapping ++from collections import deque ++from collections.abc import Mapping +``` +```diff +-from typing import Sequence ++from collections.abc import Sequence +``` +```diff +-from typing_extensions import Concatenate ++from typing import Concatenate +``` +### rewrite `mock` imports +Availability: +- [Unless `--keep-mock` is passed on the commandline](https://github.com/asottile/pyupgrade/issues/314). +```diff +-from mock import patch ++from unittest.mock import patch +``` +### `yield` => `yield from` +```diff + def f(): +- for x in y: +- yield x ++ yield from y +- for a, b in c: +- yield (a, b) ++ yield from c +``` +### Python2 and old Python3.x blocks +```diff + import sys +-if sys.version_info < (3,): # also understands `six.PY2` (and `not`), `six.PY3` (and `not`) +- print('py2') +-else: +- print('py3') ++print('py3') +``` +Availability: +- `--py36-plus` will remove Python <= 3.5 only blocks +- `--py37-plus` will remove Python <= 3.6 only blocks +- so on and so forth +```diff + # using --py36-plus for this example + import sys +-if sys.version_info < (3, 6): +- print('py3.5') +-else: +- print('py3.6+') ++print('py3.6+') +-if sys.version_info <= (3, 5): +- print('py3.5') +-else: +- print('py3.6+') ++print('py3.6+') +-if sys.version_info >= (3, 6): +- print('py3.6+') +-else: +- print('py3.5') ++print('py3.6+') +``` +Note that `if` blocks without an `else` will not be rewritten as it could introduce a syntax error. +### remove `six` compatibility code +```diff +-six.text_type ++str +-six.binary_type ++bytes +-six.class_types ++(type,) +-six.string_types ++(str,) +-six.integer_types ++(int,) +-six.unichr ++chr +-six.iterbytes ++iter +-six.print_(...) ++print(...) +-six.exec_(c, g, l) ++exec(c, g, l) +-six.advance_iterator(it) ++next(it) +-six.next(it) ++next(it) +-six.callable(x) ++callable(x) +-six.moves.range(x) ++range(x) +-six.moves.xrange(x) ++range(x) +-from six import text_type +-text_type ++str +-@six.python_2_unicode_compatible + class C: + def __str__(self): + return u'C()' +-class C(six.Iterator): pass ++class C: pass +-class C(six.with_metaclass(M, B)): pass ++class C(B, metaclass=M): pass +-@six.add_metaclass(M) +-class C(B): pass ++class C(B, metaclass=M): pass +-isinstance(..., six.class_types) ++isinstance(..., type) +-issubclass(..., six.integer_types) ++issubclass(..., int) +-isinstance(..., six.string_types) ++isinstance(..., str) +-six.b('...') ++b'...' +-six.u('...') ++'...' +-six.byte2int(bs) ++bs[0] +-six.indexbytes(bs, i) ++bs[i] +-six.int2byte(i) ++bytes((i,)) +-six.iteritems(dct) ++dct.items() +-six.iterkeys(dct) ++dct.keys() +-six.itervalues(dct) ++dct.values() +-next(six.iteritems(dct)) ++next(iter(dct.items())) +-next(six.iterkeys(dct)) ++next(iter(dct.keys())) +-next(six.itervalues(dct)) ++next(iter(dct.values())) +-six.viewitems(dct) ++dct.items() +-six.viewkeys(dct) ++dct.keys() +-six.viewvalues(dct) ++dct.values() +-six.create_unbound_method(fn, cls) ++fn +-six.get_unbound_function(meth) ++meth +-six.get_method_function(meth) ++meth.__func__ +-six.get_method_self(meth) ++meth.__self__ +-six.get_function_closure(fn) ++fn.__closure__ +-six.get_function_code(fn) ++fn.__code__ +-six.get_function_defaults(fn) ++fn.__defaults__ +-six.get_function_globals(fn) ++fn.__globals__ +-six.raise_from(exc, exc_from) ++raise exc from exc_from +-six.reraise(tp, exc, tb) ++raise exc.with_traceback(tb) +-six.reraise(*sys.exc_info()) ++raise +-six.assertCountEqual(self, a1, a2) ++self.assertCountEqual(a1, a2) +-six.assertRaisesRegex(self, e, r, fn) ++self.assertRaisesRegex(e, r, fn) +-six.assertRegex(self, s, r) ++self.assertRegex(s, r) + # note: only for *literals* +-six.ensure_binary('...') ++b'...' +-six.ensure_str('...') ++'...' +-six.ensure_text('...') ++'...' +``` +### `open` alias +```diff +-with io.open('f.txt') as f: ++with open('f.txt') as f: +``` +### redundant `open` modes +```diff +-open("foo", "U") ++open("foo") +-open("foo", "Ur") ++open("foo") +-open("foo", "Ub") ++open("foo", "rb") +-open("foo", "rUb") ++open("foo", "rb") +-open("foo", "r") ++open("foo") +-open("foo", "rt") ++open("foo") +-open("f", "r", encoding="UTF-8") ++open("f", encoding="UTF-8") +-open("f", "wt") ++open("f", "w") +``` +### `OSError` aliases +```diff + # also understands: + # - IOError + # - WindowsError + # - mmap.error and uses of `from mmap import error` + # - select.error and uses of `from select import error` + # - socket.error and uses of `from socket import error` + def throw(): +- raise EnvironmentError('boom') ++ raise OSError('boom') + def catch(): + try: + throw() +- except EnvironmentError: ++ except OSError: + handle_error() +``` +### `typing.Text` str alias +```diff +-def f(x: Text) -> None: ++def f(x: str) -> None: +``` +### Unpacking list comprehensions +```diff +-foo, bar, baz = [fn(x) for x in items] ++foo, bar, baz = (fn(x) for x in items) +``` +### Rewrite `xml.etree.cElementTree` to `xml.etree.ElementTree` +```diff +-import xml.etree.cElementTree as ET ++import xml.etree.ElementTree as ET +-from xml.etree.cElementTree import XML ++from xml.etree.ElementTree import XML +``` +### Rewrite `type` of primitive +```diff +-type('') ++str +-type(b'') ++bytes +-type(0) ++int +-type(0.) ++float +``` +### `typing.NamedTuple` / `typing.TypedDict` py36+ syntax +Availability: +- `--py36-plus` is passed on the commandline. +```diff +-NT = typing.NamedTuple('NT', [('a', int), ('b', Tuple[str, ...])]) ++class NT(typing.NamedTuple): ++ a: int ++ b: Tuple[str, ...] +-D1 = typing.TypedDict('D1', a=int, b=str) ++class D1(typing.TypedDict): ++ a: int ++ b: str +-D2 = typing.TypedDict('D2', {'a': int, 'b': str}) ++class D2(typing.TypedDict): ++ a: int ++ b: str +``` +### f-strings +Availability: +- `--py36-plus` is passed on the commandline. +```diff +-'{foo} {bar}'.format(foo=foo, bar=bar) ++f'{foo} {bar}' +-'{} {}'.format(foo, bar) ++f'{foo} {bar}' +-'{} {}'.format(foo.bar, baz.womp) ++f'{foo.bar} {baz.womp}' +-'{} {}'.format(f(), g()) ++f'{f()} {g()}' +-'{x}'.format(**locals()) ++f'{x}' +``` +_note_: `pyupgrade` is intentionally timid and will not create an f-string +if it would make the expression longer or if the substitution parameters are +sufficiently complicated (as this can decrease readability). +### `subprocess.run`: replace `universal_newlines` with `text` +Availability: +- `--py37-plus` is passed on the commandline. +```diff +-output = subprocess.run(['foo'], universal_newlines=True) ++output = subprocess.run(['foo'], text=True) +``` +### `subprocess.run`: replace `stdout=subprocess.PIPE, stderr=subprocess.PIPE` with `capture_output=True` +Availability: +- `--py37-plus` is passed on the commandline. +```diff +-output = subprocess.run(['foo'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) ++output = subprocess.run(['foo'], capture_output=True) +``` +### remove parentheses from `@functools.lru_cache()` +Availability: +- `--py38-plus` is passed on the commandline. +```diff + import functools +-@functools.lru_cache() ++@functools.lru_cache + def expensive(): +``` +### replace `@functools.lru_cache(maxsize=None)` with shorthand +Availability: +- `--py39-plus` is passed on the commandline. +```diff + import functools +-@functools.lru_cache(maxsize=None) ++@functools.cache + def expensive(): +``` +### pep 585 typing rewrites +Availability: +- File imports `from __future__ import annotations` + - Unless `--keep-runtime-typing` is passed on the commandline. +- `--py39-plus` is passed on the commandline. +```diff +-def f(x: List[str]) -> None: ++def f(x: list[str]) -> None: +``` +### pep 604 typing rewrites +Availability: +- File imports `from __future__ import annotations` + - Unless `--keep-runtime-typing` is passed on the commandline. +- `--py310-plus` is passed on the commandline. +```diff +-def f() -> Optional[str]: ++def f() -> str | None: +``` +```diff +-def f() -> Union[int, str]: ++def f() -> int | str: +``` +### remove quoted annotations +Availability: +- File imports `from __future__ import annotations` +```diff +-def f(x: 'queue.Queue[int]') -> C: ++def f(x: queue.Queue[int]) -> C: +``` +### use `datetime.UTC` alias +Availability: +- `--py311-plus` is passed on the commandline. +```diff + import datetime +-datetime.timezone.utc ++datetime.UTC +``` + +%package help +Summary: Development documents and examples for pyupgrade +Provides: python3-pyupgrade-doc +%description help +A tool (and pre-commit hook) to automatically upgrade syntax for newer +versions of the language. +## Installation +```bash +pip install pyupgrade +``` +## As a pre-commit hook +See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions +Sample `.pre-commit-config.yaml`: +```yaml +- repo: https://github.com/asottile/pyupgrade + rev: v3.3.1 + hooks: + - id: pyupgrade +``` +## Implemented features +### Set literals +```diff +-set(()) ++set() +-set([]) ++set() +-set((1,)) ++{1} +-set((1, 2)) ++{1, 2} +-set([1, 2]) ++{1, 2} +-set(x for x in y) ++{x for x in y} +-set([x for x in y]) ++{x for x in y} +``` +### Dictionary comprehensions +```diff +-dict((a, b) for a, b in y) ++{a: b for a, b in y} +-dict([(a, b) for a, b in y]) ++{a: b for a, b in y} +``` +### Format Specifiers +```diff +-'{0} {1}'.format(1, 2) ++'{} {}'.format(1, 2) +-'{0}' '{1}'.format(1, 2) ++'{}' '{}'.format(1, 2) +``` +### printf-style string formatting +Availability: +- Unless `--keep-percent-format` is passed. +```diff +-'%s %s' % (a, b) ++'{} {}'.format(a, b) +-'%r %2f' % (a, b) ++'{!r} {:2f}'.format(a, b) +-'%(a)s %(b)s' % {'a': 1, 'b': 2} ++'{a} {b}'.format(a=1, b=2) +``` +### Unicode literals +```diff +-u'foo' ++'foo' +-u"foo" ++'foo' +-u'''foo''' ++'''foo''' +``` +### Invalid escape sequences +```diff + # strings with only invalid sequences become raw strings +-'\d' ++r'\d' + # strings with mixed valid / invalid sequences get escaped +-'\n\d' ++'\n\\d' +-u'\d' ++r'\d' + # this fixes a syntax error in python3.3+ +-'\N' ++r'\N' +# note: pyupgrade is timid in one case (that's usually a mistake) +# in python2.x `'\u2603'` is the same as `'\\u2603'` without `unicode_literals` +# but in python3.x, that's our friend ☃ +``` +### `is` / `is not` comparison to constant literals +In python3.8+, comparison to literals becomes a `SyntaxWarning` as the success +of those comparisons is implementation specific (due to common object caching). +```diff +-x is 5 ++x == 5 +-x is not 5 ++x != 5 +-x is 'foo' ++x == 'foo' +``` +### `.encode()` to bytes literals +```diff +-'foo'.encode() ++b'foo' +-'foo'.encode('ascii') ++b'foo' +-'foo'.encode('utf-8') ++b'foo' +-u'foo'.encode() ++b'foo' +-'\xa0'.encode('latin1') ++b'\xa0' +``` +### extraneous parens in `print(...)` +A fix for [python-modernize/python-modernize#178] +```diff + # ok: printing an empty tuple + print(()) + # ok: printing a tuple + print((1,)) + # ok: parenthesized generator argument + sum((i for i in range(3)), []) + # fixed: +-print(("foo")) ++print("foo") +``` +[python-modernize/python-modernize#178]: https://github.com/python-modernize/python-modernize/issues/178 +### unittest deprecated aliases +Rewrites [deprecated unittest method aliases](https://docs.python.org/3/library/unittest.html#deprecated-aliases) to their non-deprecated forms. +```diff + from unittest import TestCase + class MyTests(TestCase): + def test_something(self): +- self.failUnlessEqual(1, 1) ++ self.assertEqual(1, 1) +- self.assertEquals(1, 1) ++ self.assertEqual(1, 1) +``` +### `super()` calls +```diff + class C(Base): + def f(self): +- super(C, self).f() ++ super().f() +``` +### "new style" classes +#### rewrites class declaration +```diff +-class C(object): pass ++class C: pass +-class C(B, object): pass ++class C(B): pass +``` +#### removes `__metaclass__ = type` declaration +```diff + class C: +- __metaclass__ = type +``` +### forced `str("native")` literals +```diff +-str() ++'' +-str("foo") ++"foo" +``` +### `.encode("utf-8")` +```diff +-"foo".encode("utf-8") ++"foo".encode() +``` +### `# coding: ...` comment +as of [PEP 3120], the default encoding for python source is UTF-8 +```diff +-# coding: utf-8 + x = 1 +``` +[PEP 3120]: https://www.python.org/dev/peps/pep-3120/ +### `__future__` import removal +Availability: +- by default removes `nested_scopes`, `generators`, `with_statement`, + `absolute_import`, `division`, `print_function`, `unicode_literals` +- `--py37-plus` will also remove `generator_stop` +```diff +-from __future__ import with_statement +``` +### Remove unnecessary py3-compat imports +```diff +-from io import open +-from six.moves import map +-from builtins import object # python-future +``` +### import replacements +Availability: +- `--py36-plus` (and others) will replace imports +see also [reorder-python-imports](https://github.com/asottile/reorder_python_imports#removing--rewriting-obsolete-six-imports) +some examples: +```diff +-from collections import deque, Mapping ++from collections import deque ++from collections.abc import Mapping +``` +```diff +-from typing import Sequence ++from collections.abc import Sequence +``` +```diff +-from typing_extensions import Concatenate ++from typing import Concatenate +``` +### rewrite `mock` imports +Availability: +- [Unless `--keep-mock` is passed on the commandline](https://github.com/asottile/pyupgrade/issues/314). +```diff +-from mock import patch ++from unittest.mock import patch +``` +### `yield` => `yield from` +```diff + def f(): +- for x in y: +- yield x ++ yield from y +- for a, b in c: +- yield (a, b) ++ yield from c +``` +### Python2 and old Python3.x blocks +```diff + import sys +-if sys.version_info < (3,): # also understands `six.PY2` (and `not`), `six.PY3` (and `not`) +- print('py2') +-else: +- print('py3') ++print('py3') +``` +Availability: +- `--py36-plus` will remove Python <= 3.5 only blocks +- `--py37-plus` will remove Python <= 3.6 only blocks +- so on and so forth +```diff + # using --py36-plus for this example + import sys +-if sys.version_info < (3, 6): +- print('py3.5') +-else: +- print('py3.6+') ++print('py3.6+') +-if sys.version_info <= (3, 5): +- print('py3.5') +-else: +- print('py3.6+') ++print('py3.6+') +-if sys.version_info >= (3, 6): +- print('py3.6+') +-else: +- print('py3.5') ++print('py3.6+') +``` +Note that `if` blocks without an `else` will not be rewritten as it could introduce a syntax error. +### remove `six` compatibility code +```diff +-six.text_type ++str +-six.binary_type ++bytes +-six.class_types ++(type,) +-six.string_types ++(str,) +-six.integer_types ++(int,) +-six.unichr ++chr +-six.iterbytes ++iter +-six.print_(...) ++print(...) +-six.exec_(c, g, l) ++exec(c, g, l) +-six.advance_iterator(it) ++next(it) +-six.next(it) ++next(it) +-six.callable(x) ++callable(x) +-six.moves.range(x) ++range(x) +-six.moves.xrange(x) ++range(x) +-from six import text_type +-text_type ++str +-@six.python_2_unicode_compatible + class C: + def __str__(self): + return u'C()' +-class C(six.Iterator): pass ++class C: pass +-class C(six.with_metaclass(M, B)): pass ++class C(B, metaclass=M): pass +-@six.add_metaclass(M) +-class C(B): pass ++class C(B, metaclass=M): pass +-isinstance(..., six.class_types) ++isinstance(..., type) +-issubclass(..., six.integer_types) ++issubclass(..., int) +-isinstance(..., six.string_types) ++isinstance(..., str) +-six.b('...') ++b'...' +-six.u('...') ++'...' +-six.byte2int(bs) ++bs[0] +-six.indexbytes(bs, i) ++bs[i] +-six.int2byte(i) ++bytes((i,)) +-six.iteritems(dct) ++dct.items() +-six.iterkeys(dct) ++dct.keys() +-six.itervalues(dct) ++dct.values() +-next(six.iteritems(dct)) ++next(iter(dct.items())) +-next(six.iterkeys(dct)) ++next(iter(dct.keys())) +-next(six.itervalues(dct)) ++next(iter(dct.values())) +-six.viewitems(dct) ++dct.items() +-six.viewkeys(dct) ++dct.keys() +-six.viewvalues(dct) ++dct.values() +-six.create_unbound_method(fn, cls) ++fn +-six.get_unbound_function(meth) ++meth +-six.get_method_function(meth) ++meth.__func__ +-six.get_method_self(meth) ++meth.__self__ +-six.get_function_closure(fn) ++fn.__closure__ +-six.get_function_code(fn) ++fn.__code__ +-six.get_function_defaults(fn) ++fn.__defaults__ +-six.get_function_globals(fn) ++fn.__globals__ +-six.raise_from(exc, exc_from) ++raise exc from exc_from +-six.reraise(tp, exc, tb) ++raise exc.with_traceback(tb) +-six.reraise(*sys.exc_info()) ++raise +-six.assertCountEqual(self, a1, a2) ++self.assertCountEqual(a1, a2) +-six.assertRaisesRegex(self, e, r, fn) ++self.assertRaisesRegex(e, r, fn) +-six.assertRegex(self, s, r) ++self.assertRegex(s, r) + # note: only for *literals* +-six.ensure_binary('...') ++b'...' +-six.ensure_str('...') ++'...' +-six.ensure_text('...') ++'...' +``` +### `open` alias +```diff +-with io.open('f.txt') as f: ++with open('f.txt') as f: +``` +### redundant `open` modes +```diff +-open("foo", "U") ++open("foo") +-open("foo", "Ur") ++open("foo") +-open("foo", "Ub") ++open("foo", "rb") +-open("foo", "rUb") ++open("foo", "rb") +-open("foo", "r") ++open("foo") +-open("foo", "rt") ++open("foo") +-open("f", "r", encoding="UTF-8") ++open("f", encoding="UTF-8") +-open("f", "wt") ++open("f", "w") +``` +### `OSError` aliases +```diff + # also understands: + # - IOError + # - WindowsError + # - mmap.error and uses of `from mmap import error` + # - select.error and uses of `from select import error` + # - socket.error and uses of `from socket import error` + def throw(): +- raise EnvironmentError('boom') ++ raise OSError('boom') + def catch(): + try: + throw() +- except EnvironmentError: ++ except OSError: + handle_error() +``` +### `typing.Text` str alias +```diff +-def f(x: Text) -> None: ++def f(x: str) -> None: +``` +### Unpacking list comprehensions +```diff +-foo, bar, baz = [fn(x) for x in items] ++foo, bar, baz = (fn(x) for x in items) +``` +### Rewrite `xml.etree.cElementTree` to `xml.etree.ElementTree` +```diff +-import xml.etree.cElementTree as ET ++import xml.etree.ElementTree as ET +-from xml.etree.cElementTree import XML ++from xml.etree.ElementTree import XML +``` +### Rewrite `type` of primitive +```diff +-type('') ++str +-type(b'') ++bytes +-type(0) ++int +-type(0.) ++float +``` +### `typing.NamedTuple` / `typing.TypedDict` py36+ syntax +Availability: +- `--py36-plus` is passed on the commandline. +```diff +-NT = typing.NamedTuple('NT', [('a', int), ('b', Tuple[str, ...])]) ++class NT(typing.NamedTuple): ++ a: int ++ b: Tuple[str, ...] +-D1 = typing.TypedDict('D1', a=int, b=str) ++class D1(typing.TypedDict): ++ a: int ++ b: str +-D2 = typing.TypedDict('D2', {'a': int, 'b': str}) ++class D2(typing.TypedDict): ++ a: int ++ b: str +``` +### f-strings +Availability: +- `--py36-plus` is passed on the commandline. +```diff +-'{foo} {bar}'.format(foo=foo, bar=bar) ++f'{foo} {bar}' +-'{} {}'.format(foo, bar) ++f'{foo} {bar}' +-'{} {}'.format(foo.bar, baz.womp) ++f'{foo.bar} {baz.womp}' +-'{} {}'.format(f(), g()) ++f'{f()} {g()}' +-'{x}'.format(**locals()) ++f'{x}' +``` +_note_: `pyupgrade` is intentionally timid and will not create an f-string +if it would make the expression longer or if the substitution parameters are +sufficiently complicated (as this can decrease readability). +### `subprocess.run`: replace `universal_newlines` with `text` +Availability: +- `--py37-plus` is passed on the commandline. +```diff +-output = subprocess.run(['foo'], universal_newlines=True) ++output = subprocess.run(['foo'], text=True) +``` +### `subprocess.run`: replace `stdout=subprocess.PIPE, stderr=subprocess.PIPE` with `capture_output=True` +Availability: +- `--py37-plus` is passed on the commandline. +```diff +-output = subprocess.run(['foo'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) ++output = subprocess.run(['foo'], capture_output=True) +``` +### remove parentheses from `@functools.lru_cache()` +Availability: +- `--py38-plus` is passed on the commandline. +```diff + import functools +-@functools.lru_cache() ++@functools.lru_cache + def expensive(): +``` +### replace `@functools.lru_cache(maxsize=None)` with shorthand +Availability: +- `--py39-plus` is passed on the commandline. +```diff + import functools +-@functools.lru_cache(maxsize=None) ++@functools.cache + def expensive(): +``` +### pep 585 typing rewrites +Availability: +- File imports `from __future__ import annotations` + - Unless `--keep-runtime-typing` is passed on the commandline. +- `--py39-plus` is passed on the commandline. +```diff +-def f(x: List[str]) -> None: ++def f(x: list[str]) -> None: +``` +### pep 604 typing rewrites +Availability: +- File imports `from __future__ import annotations` + - Unless `--keep-runtime-typing` is passed on the commandline. +- `--py310-plus` is passed on the commandline. +```diff +-def f() -> Optional[str]: ++def f() -> str | None: +``` +```diff +-def f() -> Union[int, str]: ++def f() -> int | str: +``` +### remove quoted annotations +Availability: +- File imports `from __future__ import annotations` +```diff +-def f(x: 'queue.Queue[int]') -> C: ++def f(x: queue.Queue[int]) -> C: +``` +### use `datetime.UTC` alias +Availability: +- `--py311-plus` is passed on the commandline. +```diff + import datetime +-datetime.timezone.utc ++datetime.UTC +``` + +%prep +%autosetup -n pyupgrade-3.3.1 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-pyupgrade -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Mon Apr 10 2023 Python_Bot <Python_Bot@openeuler.org> - 3.3.1-1 +- Package Spec generated @@ -0,0 +1 @@ +f7374565f6cc4bec821a76359ce20ee2 pyupgrade-3.3.1.tar.gz |