Format Python files using Black

Author: kelvins

src/python/arvore_binaria_de_busca.py

@@ -156,9 +156,7 @@ 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
+    if busca_linear(arvore, 6) is not None:  # Retorna o NO ou None se nao encontrou
         print('Valor encontrado')
     else:
         print('Valor nao encontrado')

src/python/busca_em_grafo.py

@@ -5,12 +5,12 @@
 from collections import deque
 
 
-class Grafo():
+class Grafo:
     """Define um grafo utilizando matriz de adjacências.
 
-        Args:
-            arestas (list): uma lista de listas onde o indice é o 
-                            vértice e cada elemento da lista é o vizinho
+    Args:
+        arestas (list): uma lista de listas onde o indice é o
+                        vértice e cada elemento da lista é o vizinho
     """
 
     def __init__(self, arestas: list):
@@ -47,7 +47,7 @@ def bfs(self, start: int) -> list:
             start (int): vértice start
 
         Returns:
-            list: lista com a ordem de vértices visitados 
+            list: lista com a ordem de vértices visitados
         """
         fila = deque()
         fila.append(start)
@@ -71,7 +71,7 @@ def dfs(self, start: int) -> list:
             start (int): vértice start
 
         Returns:
-            list: lista com a ordem de vértices visitados 
+            list: lista com a ordem de vértices visitados
         """
         visitados = []
         visitados.append(start)
@@ -90,13 +90,14 @@ def dfs(self, start: int) -> list:
         return visitados
 
 
-arestas = [[1, 2, 5],     # Vizinhos do vértice 0.
-           [0, 2],        # Vizinhos do vértice 1.
-           [0, 1, 3, 4],  # Vizinhos do vértice 2.
-           [2, 4, 5],     # Vizinhos do vértice 3.
-           [2, 3],        # Vizinhos do vértice 4.
-           [0, 3]         # Vizinhos do vértice 5.
-           ]
+arestas = [
+    [1, 2, 5],  # Vizinhos do vértice 0.
+    [0, 2],  # Vizinhos do vértice 1.
+    [0, 1, 3, 4],  # Vizinhos do vértice 2.
+    [2, 4, 5],  # Vizinhos do vértice 3.
+    [2, 3],  # Vizinhos do vértice 4.
+    [0, 3],  # Vizinhos do vértice 5.
+]
 
 grafo = Grafo(arestas)
 print(grafo.adj)

src/python/busca_em_labirinto.py

@@ -54,17 +54,11 @@ def goal_test(self, maze_location):
     def successors(self, ml):
         """Calcula as possiveis localizacoes onde eh possivel se mover."""
         locations = list()
-        if (
-            ml.row + 1 < self._rows
-            and self._grid[ml.row + 1][ml.col] != Cell.BLOCKED
-        ):
+        if ml.row + 1 < self._rows and self._grid[ml.row + 1][ml.col] != Cell.BLOCKED:
             locations.append(MazeLocation(ml.row + 1, ml.col))
         if ml.row - 1 >= 0 and self._grid[ml.row - 1][ml.col] != Cell.BLOCKED:
             locations.append(MazeLocation(ml.row - 1, ml.col))
-        if (
-            ml.col + 1 < self._cols
-            and self._grid[ml.row][ml.col + 1] != Cell.BLOCKED
-        ):
+        if ml.col + 1 < self._cols and self._grid[ml.row][ml.col + 1] != Cell.BLOCKED:
             locations.append(MazeLocation(ml.row, ml.col + 1))
         if ml.col - 1 >= 0 and self._grid[ml.row][ml.col - 1] != Cell.BLOCKED:
             locations.append(MazeLocation(ml.row, ml.col - 1))

src/python/busca_sentinela.py

@@ -27,10 +27,6 @@ def busca_sentinela(list_to_search, value):
     NUMBER_INDEX = busca_sentinela(some_list, NUMBER_TO_FIND)
     print(some_list)
     if NUMBER_INDEX >= 0:
-        print(
-            "Found value {} at position {}.".format(
-                NUMBER_TO_FIND, NUMBER_INDEX
-            )
-        )
+        print("Found value {} at position {}.".format(NUMBER_TO_FIND, NUMBER_INDEX))
     else:
         print("Could not find value {}.".format(NUMBER_TO_FIND))

src/python/comb_sort.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-#----------------------------------------------------------------------------
+# ----------------------------------------------------------------------------
 # Created By  : octaviolage
 # Created Date: 2022-05-15
 # version ='1.0'
@@ -23,8 +23,10 @@ def comb_sort(arr: list) -> list:
                 swapped = True
     return arr
 
+
 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'Ordenada: {comb_sort(my_list)}')

src/python/compressao_huffman.py

@@ -16,6 +16,7 @@ def __init__(self, freq, symbol, left=None, right=None):
         # direção da árvore (0/1)
         self.huff = ''
 
+
 # Função utilitária para imprimir
 # códigos huffman para todos os símbolos
 # na nova árvore huffman que sera criada
@@ -28,14 +29,14 @@ def printNodes(node, val=''):
     # se o nó não pertence á ponta da
     # árvore então caminha dentro do mesmo
     # até a ponta
-    if(node.left):
+    if node.left:
         printNodes(node.left, newVal)
-    if(node.right):
+    if node.right:
         printNodes(node.right, newVal)
 
     # Se o nó estiver na ponta da árore
     # então exibe o código huffman
-    if(not node.left and not node.right):
+    if not node.left and not node.right:
         print(f"{node.symbol} -> {newVal}")
 
 
@@ -70,13 +71,7 @@ def printNodes(node, val=''):
 
         # Combina os 2 nós menores para um novo nó pai
         # para eles.
-        newNode = node(
-            left.freq +
-            right.freq,
-            left.symbol +
-            right.symbol,
-            left,
-            right)
+        newNode = node(left.freq + right.freq, left.symbol + right.symbol, left, right)
 
         # remove os 2 nós e adiciona o nó pai
         # como um novo só sobre os outros

src/python/compressao_lz77.py

@@ -1,10 +1,12 @@
 import io
 import sys
 
+
 class BitArray:
     """
-        Classe para manipular bits como um array
+    Classe para manipular bits como um array
     """
+
     ENDIAN_TYPE = 'big'
     bits = []
     output = bytearray()
@@ -21,40 +23,38 @@ def __init__(self, input_data=None, endian='big'):
 
     def append(self, bit):
         """
-            Adiciona um bit à lista
+        Adiciona um bit à lista
         """
         self.bits.append(int(bit))
 
     def fromint(self, value):
         """
-            Converte um inteiro para bits
-            e adiciona-os à lista
+        Converte um inteiro para bits
+        e adiciona-os à lista
         """
         bitstring = '{:08b}'.format(value)
         for bit in bitstring:
             self.append(int(bit, 2))
 
     def frombytes(self, byte):
         """
-            Converte um byte para bits
-            e adiciona-os à lista
+        Converte um byte para bits
+        e adiciona-os à lista
         """
-        bitstring = "{:08b}".format(
-            int.from_bytes(byte, self.ENDIAN_TYPE)
-        )
+        bitstring = "{:08b}".format(int.from_bytes(byte, self.ENDIAN_TYPE))
         for bit in bitstring:
             self.append(int(bit, 2))
 
     def dump(self):
         """
-            Transforma à lista com os bits em um
-            bytearray e retorna seu valor
+        Transforma à lista com os bits em um
+        bytearray e retorna seu valor
         """
         self.output = bytearray()
         bits_in_a_byte = 8
         for i in range(len(self.bits) // (bits_in_a_byte)):
             bitstring = ''
-            readed_bits = self.bits[i * bits_in_a_byte: i * bits_in_a_byte + 8]
+            readed_bits = self.bits[i * bits_in_a_byte : i * bits_in_a_byte + 8]
             for bit in readed_bits:
                 bitstring += str(bit)
             byte = int(bitstring, 2)
@@ -81,29 +81,21 @@ class LZ77:
     # 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.ENABLE_DEBUG = verbose
 
     def find_longest_match(self):
         """
-            Encontra a maior ocorrência compatível com a cadeia consultada iniciando
-            da posição atual do cursor: current_position; e posteriomente
-            consultando o histórico existente dentro da janela para encontrar
-            uma ocorrência compatível.
+        Encontra a maior ocorrência compatível com a cadeia consultada iniciando
+        da posição atual do cursor: current_position; e posteriomente
+        consultando o histórico existente dentro da janela para encontrar
+        uma ocorrência compatível.
         """
         # Define o endereço limite do buffer baseado no cursor atual
-        end_of_buffer = min(
-            self.CURSOR + self.MAX_LOOKAHEAD_BUFFER,
-            len(self.data) + 1
-        )
+        end_of_buffer = min(self.CURSOR + self.MAX_LOOKAHEAD_BUFFER, len(self.data) + 1)
         # Define a distancia e o tamanho da melhor ocorrencia para seu
         # estado inicial (nenhum ocorrencia encontrada)
         best_match_distance = -1
@@ -120,23 +112,22 @@ def find_longest_match(self):
             # respeitando o tamanho máximo da janela
             start_index = max(0, self.CURSOR - self.MAX_WINDOW_SIZE)
             # Armazena a ocorrencia a ser pesquisada
-            ocurrence = self.data[self.CURSOR:i]
+            ocurrence = self.data[self.CURSOR : i]
 
             # Percorre o arquivo apartir do início da ocorrência
             # em busca da maior cadeia compativel existente no arquivo
             for j in range(start_index, self.CURSOR):
                 compatible_chain_length = len(ocurrence) // (self.CURSOR - j)
                 compatible_chain_last = len(ocurrence) % (self.CURSOR - j)
-                compatible_chain = self.data[j:self.CURSOR]
+                compatible_chain = self.data[j : self.CURSOR]
                 compatible_chain *= compatible_chain_length
-                compatible_chain += self.data[j:j + compatible_chain_last]
+                compatible_chain += self.data[j : j + compatible_chain_last]
 
                 # Se alguma cadeia compativel for encontrada e
                 # seu tamanho for MAIOR que o do ultimo
                 # resultado definido como melhor
                 # então aceita a mesma como sendo a melhor opção.
-                if compatible_chain == ocurrence and len(
-                        ocurrence) > best_match_length:
+                if compatible_chain == ocurrence and len(ocurrence) > best_match_length:
                     best_match_distance = self.CURSOR - j
                     best_match_length = len(ocurrence)
 
@@ -148,10 +139,10 @@ def find_longest_match(self):
 
     def decompress(self, input_data):
         """
-            Fornecido um arquivo de entrada comprimido, o seu conteúdo é descomprimido de
-            volta ao seu formato original, e escrito no arquivo de saída caso este seja
-            também fornecido. Se nenhum arquivo de saída for forncedido, os dados
-            descomprimidos são retornados como uma string
+        Fornecido um arquivo de entrada comprimido, o seu conteúdo é descomprimido de
+        volta ao seu formato original, e escrito no arquivo de saída caso este seja
+        também fornecido. Se nenhum arquivo de saída for forncedido, os dados
+        descomprimidos são retornados como uma string
         """
         # Define a posição inicial do CURSOR como sendo 0
         # ou seja inicio do arquivo
@@ -208,7 +199,7 @@ def decompress(self, input_data):
                 # Executa o bitshift pra separar os bits
                 # de distancia dos bits de tamanho
                 distance = (byte1 << 4) | (byte2 >> 4)
-                length = (byte2 & 0xf)
+                length = byte2 & 0xF
 
                 # Copia a cadeia indicada para a posição atual
                 # do cursor na janela de decompressão
@@ -223,18 +214,18 @@ def decompress(self, input_data):
 
     def compress(self, input_data):
         """
-            Fornecido o arquivo de entrada, seu contéudo é comprimido aplicando um algoritmo
-            de compressão LZ77 simples.
-            O formato de compressão tem o seguinte padrão:
-            - bit de valor 0 seguido por 8 bits (1 byte por caracter) quando não existem ocorrências
-            prévias na janela de compressão.
-            - bit de valor 1 seguido pelo ponteiro de 12 bits (distância entre o inicio da ocorrência
-            até a posição atual do cursor) e mais 4 bits (responsaveis pelo tamanho da ocorrência)
-
-            Se o arquivo de saída for fornecido, os dados comprimidos serão escritos em
-            formato binário dentro do mesmo. Do contrário será retornado um bitarray.
-
-            Se o parâmetro verbose estiver habilitado, a descrição da compressão é exibida.
+        Fornecido o arquivo de entrada, seu contéudo é comprimido aplicando um algoritmo
+        de compressão LZ77 simples.
+        O formato de compressão tem o seguinte padrão:
+        - bit de valor 0 seguido por 8 bits (1 byte por caracter) quando não existem ocorrências
+        prévias na janela de compressão.
+        - bit de valor 1 seguido pelo ponteiro de 12 bits (distância entre o inicio da ocorrência
+        até a posição atual do cursor) e mais 4 bits (responsaveis pelo tamanho da ocorrência)
+
+        Se o arquivo de saída for fornecido, os dados comprimidos serão escritos em
+        formato binário dentro do mesmo. Do contrário será retornado um bitarray.
+
+        Se o parâmetro verbose estiver habilitado, a descrição da compressão é exibida.
         """
         # Define a posição inicial do CURSOR como sendo 0
         # ou seja inicio do arquivo
@@ -249,7 +240,6 @@ def compress(self, input_data):
 
         # Percorre o arquivo inteiro
         while self.CURSOR < len(self.data):
-
             # Procura pela melhor e maior ocorrência
             # compativel com a ocorrência existente
             # no cursor atual
@@ -264,8 +254,9 @@ def compress(self, input_data):
                 x = (best_match_distance >> 0x4).to_bytes(1, self.ENDIAN_TYPE)
                 # Segundo nibble da distancia acrescido do tamanho
                 # formando assim o par LZ
-                y = (((best_match_distance & 0xf) << 4) |
-                     best_match_length).to_bytes(1, self.ENDIAN_TYPE)
+                y = (((best_match_distance & 0xF) << 4) | best_match_length).to_bytes(
+                    1, self.ENDIAN_TYPE
+                )
 
                 lz_window.append(1)
                 lz_window.frombytes(x)
@@ -274,8 +265,11 @@ def compress(self, input_data):
                 # Se o debug estiver ativo, exibe as informações da cadeia
                 # encontrada
                 if self.ENABLE_DEBUG:
-                    print("<COMPRESSED, {}, {}>".format(
-                        best_match_distance, best_match_length))
+                    print(
+                        "<COMPRESSED, {}, {}>".format(
+                            best_match_distance, best_match_length
+                        )
+                    )
 
                 # Incrementa a posição do cursor
                 self.CURSOR += best_match_length
@@ -290,8 +284,7 @@ def compress(self, input_data):
 
                 # Se o debug estiver ativo, exibe o byte decomprimido
                 if self.ENABLE_DEBUG:
-                    print("<UNCOMPRESSED, {:c}>".format(
-                        self.data[self.CURSOR]))
+                    print("<UNCOMPRESSED, {:c}>".format(self.data[self.CURSOR]))
 
                 # Incrementa em 1 a posição do cursor
                 self.CURSOR += 1