Add pre-commit hooks configuration

.pre-commit-config.yaml

@@ -0,0 +1,22 @@
+-   repo: git://github.com/pre-commit/pre-commit-hooks
+    sha: 7539d8bd1a00a3c1bfd34cdb606d3a6372e83469
+    hooks:
+    -   id: check-added-large-files
+    -   id: check-case-conflict
+    -   id: check-merge-conflict
+    -   id: check-symlinks
+    -   id: check-yaml
+    -   id: double-quote-string-fixer
+    -   id: end-of-file-fixer
+    -   id: name-tests-test
+    -   id: trailing-whitespace
+-   repo: git://github.com/pre-commit/mirrors-yapf
+    sha: v0.11.1
+    hooks:
+    -   id: yapf
+-   repo: git://github.com/FalconSocial/pre-commit-python-sorter
+    sha: 1.0.4
+    hooks:
+    -   id: python-import-sorter
+        args:
+        - --silent-overwrite

telethon_tests/crypto_tests.py → telethon_tests/crypto_test.py

@@ -1,8 +1,7 @@
 import unittest
 
-from telethon.crypto import AES
 import telethon.helpers as utils
-from telethon.crypto import Factorizator
+from telethon.crypto import AES, Factorizator
 
 
 class CryptoTests(unittest.TestCase):
@@ -38,14 +37,16 @@ def test_aes_encrypt(self):
              .format(value[:take], self.cipher_text[:take]))
 
         value = AES.encrypt_ige(self.plain_text_padded, self.key, self.iv)
-        assert value == self.cipher_text_padded, ('Ciphered text ("{}") does not equal expected ("{}")'
-                                                  .format(value, self.cipher_text_padded))
+        assert value == self.cipher_text_padded, (
+            'Ciphered text ("{}") does not equal expected ("{}")'
+            .format(value, self.cipher_text_padded))
 
     def test_aes_decrypt(self):
         # The ciphered text must always be padded
         value = AES.decrypt_ige(self.cipher_text_padded, self.key, self.iv)
-        assert value == self.plain_text_padded, ('Decrypted text ("{}") does not equal expected ("{}")'
-                                                 .format(value, self.plain_text_padded))
+        assert value == self.plain_text_padded, (
+            'Decrypted text ("{}") does not equal expected ("{}")'
+            .format(value, self.plain_text_padded))
 
     @staticmethod
     def test_calc_key():
@@ -69,8 +70,10 @@ def test_calc_key():
         expected_key = b"\xaf\xe3\x84Qm\xe0!\x0c\xd91\xe4\x9a\xa0v_gcx\xa1\xb0\xc9\xbc\x16'v\xcf,\x9dM\xae\xc6\xa5"
         expected_iv = b'\xb8Q\xf3\xc5\xa3]\xc6\xdf\x9e\xe0Q\xbd"\x8d\x13\t\x0e\x9a\x9d^8\xa2\xf8\xe7\x00w\xd9\xc1\xa7\xa0\xf7\x0f'
 
-        assert key == expected_key, 'Invalid key (expected ("{}"), got ("{}"))'.format(expected_key, key)
-        assert iv == expected_iv, 'Invalid IV (expected ("{}"), got ("{}"))'.format(expected_iv, iv)
+        assert key == expected_key, 'Invalid key (expected ("{}"), got ("{}"))'.format(
+            expected_key, key)
+        assert iv == expected_iv, 'Invalid IV (expected ("{}"), got ("{}"))'.format(
+            expected_iv, iv)
 
         # Calculate key being the server
         msg_key = b'\x86m\x92i\xcf\x8b\x93\xaa\x86K\x1fi\xd04\x83]'
@@ -79,14 +82,17 @@ def test_calc_key():
         expected_key = b'\xdd0X\xb6\x93\x8e\xc9y\xef\x83\xf8\x8cj\xa7h\x03\xe2\xc6\xb16\xc5\xbb\xfc\xe7\xdf\xd6\xb1g\xf7u\xcfk'
         expected_iv = b'\xdcL\xc2\x18\x01J"X\x86lb\xb6\xb547\xfd\xe2a4\xb6\xaf}FS\xd7[\xe0N\r\x19\xfb\xbc'
 
-        assert key == expected_key, 'Invalid key (expected ("{}"), got ("{}"))'.format(expected_key, key)
-        assert iv == expected_iv, 'Invalid IV (expected ("{}"), got ("{}"))'.format(expected_iv, iv)
+        assert key == expected_key, 'Invalid key (expected ("{}"), got ("{}"))'.format(
+            expected_key, key)
+        assert iv == expected_iv, 'Invalid IV (expected ("{}"), got ("{}"))'.format(
+            expected_iv, iv)
 
     @staticmethod
     def test_calc_msg_key():
         value = utils.calc_msg_key(b'Some random message')
         expected = b'\xdfAa\xfc\x10\xab\x89\xd2\xfe\x19C\xf1\xdd~\xbf\x81'
-        assert value == expected, 'Value ("{}") does not equal expected ("{}")'.format(value, expected)
+        assert value == expected, 'Value ("{}") does not equal expected ("{}")'.format(
+            value, expected)
 
     @staticmethod
     def test_generate_key_data_from_nonces():
@@ -97,8 +103,10 @@ def test_generate_key_data_from_nonces():
         expected_key = b'?\xc4\xbd\xdf\rWU\x8a\xf5\x0f+V\xdc\x96up\x1d\xeeG\x00\x81|\x1eg\x8a\x8f{\xf0y\x80\xda\xde'
         expected_iv = b'Q\x9dpZ\xb7\xdd\xcb\x82_\xfa\xf4\x90\xecn\x10\x9cD\xd2\x01\x8d\x83\xa0\xa4^\xb8\x91,\x7fI am'
 
-        assert key == expected_key, 'Key ("{}") does not equal expected ("{}")'.format(key, expected_key)
-        assert iv == expected_iv, 'Key ("{}") does not equal expected ("{}")'.format(key, expected_iv)
+        assert key == expected_key, 'Key ("{}") does not equal expected ("{}")'.format(
+            key, expected_key)
+        assert iv == expected_iv, 'Key ("{}") does not equal expected ("{}")'.format(
+            key, expected_iv)
 
     @staticmethod
     def test_factorizator():

telethon_tests/network_tests.py → telethon_tests/network_test.py

@@ -3,8 +3,8 @@
 import threading
 import unittest
 
-from telethon.network import TcpTransport, TcpClient
 import telethon.network.authenticator as authenticator
+from telethon.network import TcpClient, TcpTransport
 
 
 def run_server_echo_thread(port):
@@ -31,7 +31,8 @@ def test_tcp_client():
         client = TcpClient()
         client.connect('localhost', port)
         client.write(msg)
-        assert msg == client.read(16), 'Read message does not equal sent message'
+        assert msg == client.read(
+            16), 'Read message does not equal sent message'
         client.close()
 
     @staticmethod

telethon_tests/utils_tests.py → telethon_tests/utils_test.py

@@ -14,7 +14,7 @@ def test_binary_writer_reader():
             writer.write_float(17.0)
             writer.write_double(25.0)
             writer.write(bytes([26, 27, 28, 29, 30, 31, 32]))
-            writer.write_large_int(2 ** 127, 128, signed=False)
+            writer.write_large_int(2**127, 128, signed=False)
 
             data = writer.get_bytes()
             expected = b'\x01\x05\x00\x00\x00\r\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88A\x00\x00\x00\x00\x00\x00' \
@@ -24,39 +24,47 @@ def test_binary_writer_reader():
 
         with BinaryReader(data) as reader:
             value = reader.read_byte()
-            assert value == 1, 'Example byte should be 1 but is {}'.format(value)
+            assert value == 1, 'Example byte should be 1 but is {}'.format(
+                value)
 
             value = reader.read_int()
-            assert value == 5, 'Example integer should be 5 but is {}'.format(value)
+            assert value == 5, 'Example integer should be 5 but is {}'.format(
+                value)
 
             value = reader.read_long()
-            assert value == 13, 'Example long integer should be 13 but is {}'.format(value)
+            assert value == 13, 'Example long integer should be 13 but is {}'.format(
+                value)
 
             value = reader.read_float()
-            assert value == 17.0, 'Example float should be 17.0 but is {}'.format(value)
+            assert value == 17.0, 'Example float should be 17.0 but is {}'.format(
+                value)
 
             value = reader.read_double()
-            assert value == 25.0, 'Example double should be 25.0 but is {}'.format(value)
+            assert value == 25.0, 'Example double should be 25.0 but is {}'.format(
+                value)
 
             value = reader.read(7)
             assert value == bytes([26, 27, 28, 29, 30, 31, 32]), 'Example bytes should be {} but is {}' \
                 .format(bytes([26, 27, 28, 29, 30, 31, 32]), value)
 
             value = reader.read_large_int(128, signed=False)
-            assert value == 2 ** 127, 'Example large integer should be {} but is {}'.format(2 ** 127, value)
+            assert value == 2**127, 'Example large integer should be {} but is {}'.format(
+                2**127, value)
 
         # Test Telegram that types are written right
         with BinaryWriter() as writer:
             writer.write_int(0x60469778)
             buffer = writer.get_bytes()
             valid = b'\x78\x97\x46\x60'  # Tested written bytes using C#'s MemoryStream
 
-            assert buffer == valid, "Written type should be {} but is {}".format(list(valid), list(buffer))
+            assert buffer == valid, 'Written type should be {} but is {}'.format(
+                list(valid), list(buffer))
 
     @staticmethod
     def test_binary_tgwriter_tgreader():
         small_data = os.urandom(33)
-        small_data_padded = os.urandom(19)  # +1 byte for length = 20 (evenly divisible by 4)
+        small_data_padded = os.urandom(
+            19)  # +1 byte for length = 20 (evenly divisible by 4)
 
         large_data = os.urandom(999)
         large_data_padded = os.urandom(1024)
@@ -74,7 +82,9 @@ def test_binary_tgwriter_tgreader():
                 # And then try reading it without errors (it should be unharmed!)
                 for datum in data:
                     value = reader.tgread_bytes()
-                    assert value == datum, 'Example bytes should be {} but is {}'.format(datum, value)
+                    assert value == datum, 'Example bytes should be {} but is {}'.format(
+                        datum, value)
 
                 value = reader.tgread_string()
-                assert value == string, 'Example string should be {} but is {}'.format(string, value)
+                assert value == string, 'Example string should be {} but is {}'.format(
+                    string, value)