Format Python files using Black

Author: kelvins

.github/workflows/lint-checker.yml

@@ -23,5 +23,4 @@ jobs:
           VALIDATE_JAVASCRIPT_ES: true
           VALIDATE_GOOGLE_JAVA_FORMAT: true
           VALIDATE_PYTHON_BLACK: true
-          PYTHON_BLACK_CONFIG_FILE: "./pyproject.toml"
           VALIDATE_PYTHON_ISORT: true

pyproject.toml

@@ -15,10 +15,10 @@ def __init__(self, chave):
 # Metodos de Busca
 def busca_recursiva(no, chave):
     if no is None:
-        print(f'{chave} nao foi encontrado na arvore')
+        print(f"{chave} nao foi encontrado na arvore")
         return
     if no.chave == chave:
-        print(f'{chave} foi encontrado na arvore')
+        print(f"{chave} foi encontrado na arvore")
         return no
     if chave > no.chave:
         busca_recursiva(no.direita, chave)
@@ -50,14 +50,14 @@ def insere(no, chave):
 
 
 # Metodos de Impressao
-IMPRIME_ARVORE = ''
+IMPRIME_ARVORE = ""
 
 
 def pre_ordem(no):
     global IMPRIME_ARVORE
     if no is None:
         return
-    IMPRIME_ARVORE += str(no.chave) + ', '
+    IMPRIME_ARVORE += str(no.chave) + ", "
     pre_ordem(no.esquerda)
     pre_ordem(no.direita)
 
@@ -67,7 +67,7 @@ def em_ordem(no):
     if no is None:
         return
     em_ordem(no.esquerda)
-    IMPRIME_ARVORE += str(no.chave) + ', '
+    IMPRIME_ARVORE += str(no.chave) + ", "
     em_ordem(no.direita)
 
 
@@ -77,7 +77,7 @@ def pos_ordem(no):
         return
     pos_ordem(no.esquerda)
     pos_ordem(no.direita)
-    IMPRIME_ARVORE += str(no.chave) + ', '
+    IMPRIME_ARVORE += str(no.chave) + ", "
 
 
 # Acha a Altura da Arvore
@@ -142,7 +142,7 @@ def exclui(no, ch):
     return True
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     arvore = Arvore(3)  # Cria arvore (raiz)
     # Insere varios valores na arvore
     arvore = insere(arvore, 2)
@@ -157,11 +157,11 @@ def exclui(no, ch):
     busca_recursiva(arvore, 6)  # Busca que imprime na propria funcao
 
     if busca_linear(arvore, 6) is not None:  # Retorna o NO ou None se nao encontrou
-        print('Valor encontrado')
+        print("Valor encontrado")
     else:
-        print('Valor nao encontrado')
+        print("Valor nao encontrado")
 
-    print(f'Altura: {altura(arvore)}')
+    print(f"Altura: {altura(arvore)}")
 
     # Exclui varios valores
     exclui(arvore, 7)
@@ -172,13 +172,13 @@ def exclui(no, ch):
     # Chama os metodos de impressao
     IMPRIME = ""
     pre_ordem(arvore)
-    print(f'PreOrdem: {IMPRIME}')
+    print(f"PreOrdem: {IMPRIME}")
     IMPRIME = ""
     em_ordem(arvore)
-    print(f'EmOrdem: {IMPRIME}')
+    print(f"EmOrdem: {IMPRIME}")
     IMPRIME = ""
     pos_ordem(arvore)
-    print(f'PosOrdem: {IMPRIME}')
+    print(f"PosOrdem: {IMPRIME}")
 
     # Mostra a altura da arvore apos remover os itens
-    print(f'Altura: {altura(arvore)}')
+    print(f"Altura: {altura(arvore)}")

src/python/arvore_binaria_de_busca.py

@@ -129,7 +129,7 @@ def __print_level(self, node, level):
         if node is None:
             return
         if level == 1:
-            print("%d" % node.data, end=' ')
+            print("%d" % node.data, end=" ")
         elif level > 1:
             self.__print_level(node.left, level - 1)
             self.__print_level(node.right, level - 1)
@@ -138,13 +138,13 @@ def in_order(self, node):
         if node is None:
             return
         self.in_order(node.left)
-        print("%d" % node.data, end=' ')
+        print("%d" % node.data, end=" ")
         self.in_order(node.right)
 
     def pre_order(self, node):
         if node is None:
             return
-        print("%d" % node.data, end=' ')
+        print("%d" % node.data, end=" ")
         self.pre_order(node.left)
         self.pre_order(node.right)
 
@@ -153,7 +153,7 @@ def post_order(self, node):
             return
         self.post_order(node.left)
         self.post_order(node.right)
-        print("%d" % node.data, end=' ')
+        print("%d" % node.data, end=" ")
 
 
 b_tree = BinaryTree()
@@ -164,11 +164,11 @@ def post_order(self, node):
     b_tree.insert(curr_data)
 
 b_tree.in_order(b_tree.root)
-print('\n')
+print("\n")
 b_tree.pre_order(b_tree.root)
-print('\n')
+print("\n")
 b_tree.post_order(b_tree.root)
-print('\n')
+print("\n")
 b_tree.level_order()
-print('\n')
+print("\n")
 print(b_tree.get_height(b_tree.root))

src/python/binary_tree.py

@@ -20,7 +20,7 @@ def bubble_sort(data, size):
         bubble_sort(data, size - 1)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     lista_nao_ordenada = [2, 9, 8, 0, 1, 3, 5, 4, 6, 7]
     print(lista_nao_ordenada)
     bubble_sort(lista_nao_ordenada, len(lista_nao_ordenada))

src/python/bubble_sort.py

@@ -10,14 +10,14 @@
 
 
 class Cell(Enum):
-    EMPTY = ' '
-    BLOCKED = 'X'
-    START = 'S'
-    GOAL = 'G'
-    PATH = '*'
+    EMPTY = " "
+    BLOCKED = "X"
+    START = "S"
+    GOAL = "G"
+    PATH = "*"
 
 
-MazeLocation = namedtuple('MazeLocation', ['row', 'col'])
+MazeLocation = namedtuple("MazeLocation", ["row", "col"])
 
 
 class Maze:
@@ -46,7 +46,7 @@ def _randomly_fill(self, rows, cols, sparseness):
                     self._grid[row][col] = Cell.BLOCKED
 
     def __str__(self):
-        return '\n'.join(['|'.join([c.value for c in r]) for r in self._grid])
+        return "\n".join(["|".join([c.value for c in r]) for r in self._grid])
 
     def goal_test(self, maze_location):
         return maze_location == self.goal
@@ -187,27 +187,27 @@ def node_to_path(node):
     return path
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     maze = Maze()
 
     # Solucao utilizando busca em profundidade
     solution = dfs(maze.start, maze.goal_test, maze.successors)
     if solution is None:
-        print('No solution found using depth-first search')
+        print("No solution found using depth-first search")
     else:
         path = node_to_path(solution)
         maze.mark(path)
-        print('Solution using DFS:')
+        print("Solution using DFS:")
         print(maze)
         maze.clear(path)
 
     # Solucao utilizando busca em largura
     solution = bfs(maze.start, maze.goal_test, maze.successors)
     if solution is None:
-        print('No solution found using breath-first search')
+        print("No solution found using breath-first search")
     else:
         path = node_to_path(solution)
         maze.mark(path)
-        print('Solution using BFS:')
+        print("Solution using BFS:")
         print(maze)
         maze.clear(path)

src/python/busca_em_labirinto.py

@@ -15,8 +15,8 @@ def busca_sequencial(valor, lista, index):
     return busca_sequencial(valor, lista, index + 1)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     uma_lista = [1, 9, 39, 4, 12, 38, 94, 37]
     for indice, valor_na_lista in enumerate(uma_lista):
-        print('Testando valor {} no indice {}'.format(valor_na_lista, indice))
+        print("Testando valor {} no indice {}".format(valor_na_lista, indice))
         assert busca_sequencial(valor_na_lista, uma_lista, 0) == indice

src/python/busca_sequencial_recursiva.py

@@ -20,7 +20,7 @@ def calculate_pi(number):
     return pi
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     n_terms = [10, 1000, 100000, 10000000]
     for n in n_terms:
-        print(f'PI ({n}): {calculate_pi(n)}')
+        print(f"PI ({n}): {calculate_pi(n)}")

src/python/calculate_pi.py

@@ -24,9 +24,9 @@ def comb_sort(arr: list) -> list:
     return arr
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     from random import randint
 
     my_list = [randint(0, 100) for _ in range(10)]
-    print(f'Lista: {my_list}')
-    print(f'Ordenada: {comb_sort(my_list)}')
+    print(f"Lista: {my_list}")
+    print(f"Ordenada: {comb_sort(my_list)}")

src/python/comb_sort.py

@@ -14,15 +14,15 @@ def __init__(self, freq, symbol, left=None, right=None):
         self.right = right
 
         # direção da árvore (0/1)
-        self.huff = ''
+        self.huff = ""
 
 
 # Função utilitária para imprimir
 # códigos huffman para todos os símbolos
 # na nova árvore huffman que sera criada
 
 
-def printNodes(node, val=''):
+def printNodes(node, val=""):
     # código huffman para o nó atual
     newVal = val + str(node.huff)
 
@@ -41,15 +41,15 @@ def printNodes(node, val=''):
 
 
 # caracteres para à árvore huffman
-chars = ['a', 'b', 'c', 'd', 'e', 'f']
+chars = ["a", "b", "c", "d", "e", "f"]
 
 # frequência dos caracteres
 freq = [5, 9, 12, 13, 16, 45]
 
 # lista contendo os nós não utilizados
 nodes = []
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # convertendo caracteres e frequência em
     # nós da árvore huffman
     for x in range(len(chars)):

src/python/compressao_huffman.py

@@ -7,11 +7,11 @@ class BitArray:
     Classe para manipular bits como um array
     """
 
-    ENDIAN_TYPE = 'big'
+    ENDIAN_TYPE = "big"
     bits = []
     output = bytearray()
 
-    def __init__(self, input_data=None, endian='big'):
+    def __init__(self, input_data=None, endian="big"):
         self.ENDIAN_TYPE = endian
         # Se fornecido um bytearray converte
         # o mesmo para lista de bits
@@ -32,7 +32,7 @@ def fromint(self, value):
         Converte um inteiro para bits
         e adiciona-os à lista
         """
-        bitstring = '{:08b}'.format(value)
+        bitstring = "{:08b}".format(value)
         for bit in bitstring:
             self.append(int(bit, 2))
 
@@ -53,7 +53,7 @@ def dump(self):
         self.output = bytearray()
         bits_in_a_byte = 8
         for i in range(len(self.bits) // (bits_in_a_byte)):
-            bitstring = ''
+            bitstring = ""
             readed_bits = self.bits[i * bits_in_a_byte : i * bits_in_a_byte + 8]
             for bit in readed_bits:
                 bitstring += str(bit)
@@ -76,15 +76,15 @@ class LZ77:
     CURSOR = 0
 
     # Tipo de leitura binária (ENDIAN)
-    ENDIAN_TYPE = 'big'
+    ENDIAN_TYPE = "big"
 
     # Dados de Entrada
     data = None
 
-    def __init__(self, window_size=400, lookahed_buffer=15, endian='big', verbose=True):
+    def __init__(self, window_size=400, lookahed_buffer=15, endian="big", verbose=True):
         self.MAX_WINDOW_SIZE = window_size
         self.MAX_LOOKAHEAD_BUFFER = lookahed_buffer
-        self.ENDIAN_TYPE = 'big'
+        self.ENDIAN_TYPE = "big"
         self.ENABLE_DEBUG = verbose
 
     def find_longest_match(self):
@@ -325,20 +325,20 @@ def compress(self, input_data):
  "Lorem ipsum dolor sit amet..", comes from a line in\
  section 1.10.32."'''
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     lz = LZ77(verbose=False)
     print("Entrada:")
     entrada = bytearray(input_text.encode())
     print(entrada)
-    print('Tamanho: {}'.format(sys.getsizeof(entrada)))
+    print("Tamanho: {}".format(sys.getsizeof(entrada)))
     print("\n---\n")
     compressed = lz.compress(input_text)
     print("Dados Comprimidos com LZ77:")
     print(compressed)
-    print('Tamanho: {}'.format(sys.getsizeof(compressed)))
+    print("Tamanho: {}".format(sys.getsizeof(compressed)))
     print("\n---\n")
     decompressed = lz.decompress(compressed)
     print("Dados descomprimidos com LZ77:")
     print(decompressed)
-    print('Tamanho: {}'.format(sys.getsizeof(decompressed)))
+    print("Tamanho: {}".format(sys.getsizeof(decompressed)))
     print("\n---\n")

src/python/compressao_lz77.py

@@ -36,10 +36,10 @@ def counting_sort(arr):
 lista = [random.randint(0, 100) for _ in range(n)]
 
 # Imprime a lista original sem ordenação
-print(f'Lista Original: {lista}')
+print(f"Lista Original: {lista}")
 
 # Ordena a lista utilizando o algoritmo de Counting Sort
 lista_ordenada = counting_sort(lista)
 
 # Imprime a lista ordenada
-print(f'Lista Ordenada: {lista_ordenada}')
+print(f"Lista Ordenada: {lista_ordenada}")

src/python/counting_sort.py

@@ -17,6 +17,6 @@ def exponenciacao_recursiva(base, expoente):
     return base * exponenciacao_recursiva(base, expoente - 1)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     print(exponenciacao_recursiva(5, 2))
     print(exponenciacao_recursiva(5, 5))

src/python/exponenciacao_recursiva.py

@@ -16,5 +16,5 @@ def fatorial(num):
     return aux
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     print(fatorial(5))