From 3674a9827469957b454f8dc323d1308ffe2002f5 Mon Sep 17 00:00:00 2001 From: retepsnave <57339232+retepsnave@users.noreply.github.com> Date: Tue, 25 Feb 2020 21:54:41 +0900 Subject: [PATCH 01/23] Create example.py --- example.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 example.py diff --git a/example.py b/example.py new file mode 100644 index 000000000..ec7eab77c --- /dev/null +++ b/example.py @@ -0,0 +1,21 @@ +import math, sys; + +def example1(): + ####This is a long comment. This should be wrapped to fit within 72 characters. + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} + return (some_tuple, some_variable) +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ + Indentation in multiline strings should not be touched. +Only actual code should be reindented. +""" + return (sys.path, some_string) From f25e31468b81a0bb0695c9cc6901f67369e4eac4 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Tue, 25 Feb 2020 12:57:46 +0000 Subject: [PATCH 02/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 676b90d70c0c6b3f184a314513495b9c29e57af2 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Tue, 25 Feb 2020 12:58:31 +0000 Subject: [PATCH 03/23] [reset-demo-command] revert last commit --- example.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/example.py b/example.py index e7bca8b12..ec7eab77c 100644 --- a/example.py +++ b/example.py @@ -1,41 +1,21 @@ -import math, sys - +import math, sys; def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple = (1, 2, 3, "a") - some_variable = { - "long": "Long code lines should be wrapped within 79 characters.", - "other": [ - math.pi, - 100, - 200, - 300, - 9876543210, - "This is a long string that goes on", - ], - "more": { - "inner": "This whole logical line should be wrapped.", - some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], - }, - } + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} return (some_tuple, some_variable) - - -def example2(): - return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) - - -class Example3(object): - def __init__(self, bar): - # Comments should have a space after the hash. - if bar: - bar += 1 - bar = bar * bar - return bar - else: - some_string = """ +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 8026b95d171e5042b432fe101a1af5115bc22d76 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Mon, 15 Jun 2020 11:13:04 +0000 Subject: [PATCH 04/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From d42860739a638674e8823c0dc1c3d1402ac1cc35 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Mon, 15 Jun 2020 13:05:07 +0000 Subject: [PATCH 05/23] [reset-demo-command] revert last commit --- example.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/example.py b/example.py index e7bca8b12..ec7eab77c 100644 --- a/example.py +++ b/example.py @@ -1,41 +1,21 @@ -import math, sys - +import math, sys; def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple = (1, 2, 3, "a") - some_variable = { - "long": "Long code lines should be wrapped within 79 characters.", - "other": [ - math.pi, - 100, - 200, - 300, - 9876543210, - "This is a long string that goes on", - ], - "more": { - "inner": "This whole logical line should be wrapped.", - some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], - }, - } + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} return (some_tuple, some_variable) - - -def example2(): - return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) - - -class Example3(object): - def __init__(self, bar): - # Comments should have a space after the hash. - if bar: - bar += 1 - bar = bar * bar - return bar - else: - some_string = """ +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From cac0b53ac5e4e25b2f7e82d3cf43e55aed47d8c8 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Fri, 10 Jul 2020 00:05:03 +0000 Subject: [PATCH 06/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 43b13d9ff07045d4e448120390b715244d78b5fd Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Mon, 25 Jan 2021 01:26:53 +0000 Subject: [PATCH 07/23] [reset-demo-command] revert last commit --- example.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/example.py b/example.py index e7bca8b12..ec7eab77c 100644 --- a/example.py +++ b/example.py @@ -1,41 +1,21 @@ -import math, sys - +import math, sys; def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple = (1, 2, 3, "a") - some_variable = { - "long": "Long code lines should be wrapped within 79 characters.", - "other": [ - math.pi, - 100, - 200, - 300, - 9876543210, - "This is a long string that goes on", - ], - "more": { - "inner": "This whole logical line should be wrapped.", - some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], - }, - } + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} return (some_tuple, some_variable) - - -def example2(): - return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) - - -class Example3(object): - def __init__(self, bar): - # Comments should have a space after the hash. - if bar: - bar += 1 - bar = bar * bar - return bar - else: - some_string = """ +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From dc7bfa398b01eef17c9949c4187b57866db9a895 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Mon, 23 Aug 2021 23:24:56 +0000 Subject: [PATCH 08/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 8af8e95a36197679059de559631a45ee01a9877b Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Mon, 23 Aug 2021 23:26:10 +0000 Subject: [PATCH 09/23] [reset-demo-command] revert last commit --- example.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/example.py b/example.py index e7bca8b12..ec7eab77c 100644 --- a/example.py +++ b/example.py @@ -1,41 +1,21 @@ -import math, sys - +import math, sys; def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple = (1, 2, 3, "a") - some_variable = { - "long": "Long code lines should be wrapped within 79 characters.", - "other": [ - math.pi, - 100, - 200, - 300, - 9876543210, - "This is a long string that goes on", - ], - "more": { - "inner": "This whole logical line should be wrapped.", - some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], - }, - } + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} return (some_tuple, some_variable) - - -def example2(): - return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) - - -class Example3(object): - def __init__(self, bar): - # Comments should have a space after the hash. - if bar: - bar += 1 - bar = bar * bar - return bar - else: - some_string = """ +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 80da78eb7aefec85c5f19e2982dd91e7550801eb Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Tue, 9 Nov 2021 09:52:04 +0000 Subject: [PATCH 10/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 0a776174d194fdafadc4ceaf22f962d242fdd17b Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Tue, 16 Nov 2021 04:07:19 +0000 Subject: [PATCH 11/23] [reset-demo-command] revert last commit --- example.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/example.py b/example.py index e7bca8b12..ec7eab77c 100644 --- a/example.py +++ b/example.py @@ -1,41 +1,21 @@ -import math, sys - +import math, sys; def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple = (1, 2, 3, "a") - some_variable = { - "long": "Long code lines should be wrapped within 79 characters.", - "other": [ - math.pi, - 100, - 200, - 300, - 9876543210, - "This is a long string that goes on", - ], - "more": { - "inner": "This whole logical line should be wrapped.", - some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], - }, - } + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} return (some_tuple, some_variable) - - -def example2(): - return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) - - -class Example3(object): - def __init__(self, bar): - # Comments should have a space after the hash. - if bar: - bar += 1 - bar = bar * bar - return bar - else: - some_string = """ +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 5bb9c13ebd95752f09499b34cb85fd6dc2394e4d Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Tue, 28 Dec 2021 12:21:35 +0000 Subject: [PATCH 12/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 9e3438f17b9cb2a678bdd37c28197b0b7f5a6328 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Tue, 28 Dec 2021 12:22:03 +0000 Subject: [PATCH 13/23] [reset-demo-command] revert last commit --- example.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/example.py b/example.py index e7bca8b12..ec7eab77c 100644 --- a/example.py +++ b/example.py @@ -1,41 +1,21 @@ -import math, sys - +import math, sys; def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple = (1, 2, 3, "a") - some_variable = { - "long": "Long code lines should be wrapped within 79 characters.", - "other": [ - math.pi, - 100, - 200, - 300, - 9876543210, - "This is a long string that goes on", - ], - "more": { - "inner": "This whole logical line should be wrapped.", - some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], - }, - } + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} return (some_tuple, some_variable) - - -def example2(): - return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) - - -class Example3(object): - def __init__(self, bar): - # Comments should have a space after the hash. - if bar: - bar += 1 - bar = bar * bar - return bar - else: - some_string = """ +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 1330805ed4fba10d62d7eb999d8517dc190ddb2c Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Tue, 18 Oct 2022 07:37:16 +0000 Subject: [PATCH 14/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From e77cc415962ba56c6b0bf160ec9c803f49eefe6c Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Tue, 18 Oct 2022 07:38:35 +0000 Subject: [PATCH 15/23] [reset-demo-command] revert last commit --- example.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/example.py b/example.py index e7bca8b12..ec7eab77c 100644 --- a/example.py +++ b/example.py @@ -1,41 +1,21 @@ -import math, sys - +import math, sys; def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple = (1, 2, 3, "a") - some_variable = { - "long": "Long code lines should be wrapped within 79 characters.", - "other": [ - math.pi, - 100, - 200, - 300, - 9876543210, - "This is a long string that goes on", - ], - "more": { - "inner": "This whole logical line should be wrapped.", - some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], - }, - } + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} return (some_tuple, some_variable) - - -def example2(): - return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) - - -class Example3(object): - def __init__(self, bar): - # Comments should have a space after the hash. - if bar: - bar += 1 - bar = bar * bar - return bar - else: - some_string = """ +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From f6da78bd876448fc46d1490134207f76e34e4cc2 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Tue, 15 Nov 2022 22:39:31 +0000 Subject: [PATCH 16/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 4e722409b6834b047d45b8efb0339ef02be14be5 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Tue, 15 Nov 2022 22:39:49 +0000 Subject: [PATCH 17/23] [reset-demo-command] revert last commit --- example.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/example.py b/example.py index e7bca8b12..ec7eab77c 100644 --- a/example.py +++ b/example.py @@ -1,41 +1,21 @@ -import math, sys - +import math, sys; def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple = (1, 2, 3, "a") - some_variable = { - "long": "Long code lines should be wrapped within 79 characters.", - "other": [ - math.pi, - 100, - 200, - 300, - 9876543210, - "This is a long string that goes on", - ], - "more": { - "inner": "This whole logical line should be wrapped.", - some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], - }, - } + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} return (some_tuple, some_variable) - - -def example2(): - return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) - - -class Example3(object): - def __init__(self, bar): - # Comments should have a space after the hash. - if bar: - bar += 1 - bar = bar * bar - return bar - else: - some_string = """ +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 5ac43ecac63ae80c1b2a69412b20244f49bdbcba Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Wed, 18 Jan 2023 12:07:27 +0000 Subject: [PATCH 18/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From cde2e69adb47bdab81f88f4aadd066b3545c114d Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Mon, 1 May 2023 14:53:19 +0000 Subject: [PATCH 19/23] [reset-demo-command] revert last commit --- example.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/example.py b/example.py index e7bca8b12..ec7eab77c 100644 --- a/example.py +++ b/example.py @@ -1,41 +1,21 @@ -import math, sys - +import math, sys; def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple = (1, 2, 3, "a") - some_variable = { - "long": "Long code lines should be wrapped within 79 characters.", - "other": [ - math.pi, - 100, - 200, - 300, - 9876543210, - "This is a long string that goes on", - ], - "more": { - "inner": "This whole logical line should be wrapped.", - some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], - }, - } + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} return (some_tuple, some_variable) - - -def example2(): - return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) - - -class Example3(object): - def __init__(self, bar): - # Comments should have a space after the hash. - if bar: - bar += 1 - bar = bar * bar - return bar - else: - some_string = """ +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 20cb33ffb0c855817fefe48e49eec42718919cfd Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Wed, 31 Jan 2024 07:50:00 +0000 Subject: [PATCH 20/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 8dfd13c8ce9be8ab5d19268cd3374976ea641bf0 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Sat, 10 Feb 2024 21:33:00 +0000 Subject: [PATCH 21/23] [reset-demo-command] revert last commit --- example.py | 48 ++++++++++++++---------------------------------- 1 file changed, 14 insertions(+), 34 deletions(-) diff --git a/example.py b/example.py index e7bca8b12..ec7eab77c 100644 --- a/example.py +++ b/example.py @@ -1,41 +1,21 @@ -import math, sys - +import math, sys; def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple = (1, 2, 3, "a") - some_variable = { - "long": "Long code lines should be wrapped within 79 characters.", - "other": [ - math.pi, - 100, - 200, - 300, - 9876543210, - "This is a long string that goes on", - ], - "more": { - "inner": "This whole logical line should be wrapped.", - some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], - }, - } + some_tuple=( 1,2, 3,'a' ); + some_variable={'long':'Long code lines should be wrapped within 79 characters.', + 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], + 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, + 20,300,40000,500000000,60000000000000000]}} return (some_tuple, some_variable) - - -def example2(): - return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) - - -class Example3(object): - def __init__(self, bar): - # Comments should have a space after the hash. - if bar: - bar += 1 - bar = bar * bar - return bar - else: - some_string = """ +def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); +class Example3( object ): + def __init__ ( self, bar ): + #Comments should have a space after the hash. + if bar : bar+=1; bar=bar* bar ; return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From e3ea698b239e320848ae16da320a700b70525737 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Thu, 23 May 2024 07:49:20 +0000 Subject: [PATCH 22/23] [black-command] fixes --- example.py | 48 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/example.py b/example.py index ec7eab77c..e7bca8b12 100644 --- a/example.py +++ b/example.py @@ -1,21 +1,41 @@ -import math, sys; +import math, sys + def example1(): ####This is a long comment. This should be wrapped to fit within 72 characters. - some_tuple=( 1,2, 3,'a' ); - some_variable={'long':'Long code lines should be wrapped within 79 characters.', - 'other':[math.pi, 100,200,300,9876543210,'This is a long string that goes on'], - 'more':{'inner':'This whole logical line should be wrapped.',some_tuple:[1, - 20,300,40000,500000000,60000000000000000]}} + some_tuple = (1, 2, 3, "a") + some_variable = { + "long": "Long code lines should be wrapped within 79 characters.", + "other": [ + math.pi, + 100, + 200, + 300, + 9876543210, + "This is a long string that goes on", + ], + "more": { + "inner": "This whole logical line should be wrapped.", + some_tuple: [1, 20, 300, 40000, 500000000, 60000000000000000], + }, + } return (some_tuple, some_variable) -def example2(): return {'has_key() is deprecated':True}.has_key({'f':2}.has_key('')); -class Example3( object ): - def __init__ ( self, bar ): - #Comments should have a space after the hash. - if bar : bar+=1; bar=bar* bar ; return bar - else: - some_string = """ + + +def example2(): + return {"has_key() is deprecated": True}.has_key({"f": 2}.has_key("")) + + +class Example3(object): + def __init__(self, bar): + # Comments should have a space after the hash. + if bar: + bar += 1 + bar = bar * bar + return bar + else: + some_string = """ Indentation in multiline strings should not be touched. Only actual code should be reindented. """ - return (sys.path, some_string) + return (sys.path, some_string) From 9f881ff1ee41844ba5e33087ee9305f8f42e2756 Mon Sep 17 00:00:00 2001 From: actions-bot <58130806+actions-bot@users.noreply.github.com> Date: Fri, 31 May 2024 20:02:40 +0000 Subject: [PATCH 23/23] [hello-world-pr-command] Add hello response --- hello-world.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 hello-world.txt diff --git a/hello-world.txt b/hello-world.txt new file mode 100644 index 000000000..470ff70c2 --- /dev/null +++ b/hello-world.txt @@ -0,0 +1 @@ +Hello @shellymiron!