style: 💄 format code using yapf and isort

Author: ZhaoQi99

README.md

@@ -62,4 +62,14 @@ Options:
 ```python
 import loader
 from test import *
-```
+```
+
+## Development
+
+### Format Code
+
+```shell
+yapf --recursive -i pyencrypt 
+isort pyencrypt
+```
+

a.py

@@ -0,0 +1,5 @@
+import loader
+from test.test2.abc import *
+print(DEMO1)
+# from test.abc import *
+# print(DEMO1)

dev-requirement.txt

@@ -0,0 +1,3 @@
+-r requirement.txt
+isort==5.10.1
+yapf==0.31.0

pyencrypt/__init__.py

@@ -1,4 +1,2 @@
 __version__ = '0.1.0'
 __description__ = 'encrypt python source code and import dynamically.'
-
-

pyencrypt/aes.py

@@ -35,8 +35,7 @@
     major=PYTHON_MAJOR,
     minor=PYTHON_MINOR,
     abi=sys.abiflags,
-    platform=sys.platform
-)
+    platform=sys.platform)
 
 FINISH_ENCRYPT_MSG = f"""
 Encryption completed successfully.
@@ -64,27 +63,24 @@ def cli():
               '--in-place',
               'delete',
               default=False,
-              help='make changes to files in place',is_flag=True)
+              help='make changes to files in place',
+              is_flag=True)
 @click.option('-k',
               '--key',
               default=None,
               help=KEY_OPTION_HELP,
               type=click.STRING)
-@click.option('-y',
-              '--yes',
-              default=False,
-              help='yes',
-              is_flag=True)
+@click.option('-y', '--yes', default=False, help='yes', is_flag=True)
 @click.help_option('-h', '--help')
-def encrypt_command(pathname, delete, key,yes):
+def encrypt_command(pathname, delete, key, yes):
     """Encrypt your python code"""
     if key is None:
         key = generate_aes_key().decode()
         click.echo(f'Your randomly encryption key is {key}')
 
     if not yes:
         click.confirm('Are you sure you want to encrypt your python file?',
-                  abort=True)
+                      abort=True)
     path = Path(pathname)
     work_dir = Path(os.getcwd()) / 'encrypted' / 'src'
 
@@ -94,7 +90,8 @@ def encrypt_command(pathname, delete, key,yes):
     elif path.is_dir():
         work_dir.exists() and shutil.rmtree(work_dir)
         shutil.copytree(path, work_dir)
-        files = set(path.glob('**/*.py')) - set(path.glob(f'encrypted/**/*.py'))
+        files = set(path.glob('**/*.py')) - set(
+            path.glob(f'encrypted/**/*.py'))
         for file in files:
             if can_encrypt(file):
                 print(file)

pyencrypt/cli.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+
 from pyencrypt.aes import aes_decrypt
 from pyencrypt.ntt import intt
 
@@ -11,18 +12,17 @@ def decrypt_key(cipher_key: str, n: int, d: int) -> str:
     return ''.join(map(chr, filter(lambda x: x != 0, intt(plain_ls))))
 
 
-
-def _decrypt_file(data:bytes, key:str) -> bytes:
-    return aes_decrypt(data,key)
+def _decrypt_file(data: bytes, key: str) -> bytes:
+    return aes_decrypt(data, key)
 
 
 def decrypt_file(path: Path, key: str, new_path: Path = None) -> bytes:
     if path.suffix != '.pye':
         raise Exception(f"{path.name} can't be decrypted.")
-    data =  _decrypt_file(path.read_bytes(),key)
+    data = _decrypt_file(path.read_bytes(), key)
     if new_path:
         if new_path.suffix != '.py':
             raise Exception("Origin file path must be py suffix.")
         new_path.touch(exist_ok=True)
         new_path.write_bytes(data)
-    return data
+    return data

pyencrypt/decrypt.py

@@ -3,13 +3,18 @@
 from pathlib import Path
 
 from pyencrypt.aes import aes_encrypt
-from pyencrypt.generate import  generate_rsa_number
+from pyencrypt.generate import generate_rsa_number
 from pyencrypt.ntt import ntt
 
-NOT_ALLOWED_ENCRYPT_FILES = ['__init__.py',]
+NOT_ALLOWED_ENCRYPT_FILES = [
+    '__init__.py',
+]
 
 
-def _encrypt_file(data: bytes, key: bytes,) -> None:
+def _encrypt_file(
+    data: bytes,
+    key: bytes,
+) -> None:
     return aes_encrypt(data, key)
 
 
@@ -34,16 +39,17 @@ def encrypt_key(key: bytes) -> str:
     return 'O'.join(map(str, cipher_ls)), numbers['d'], numbers['n']
 
 
-def generate_so_file(cipher_key: str, d: int, n:int):
+def generate_so_file(cipher_key: str, d: int, n: int):
     private_key = f'{n}O{d}'
     path = Path(os.path.abspath(__file__)).parent
 
     decrypt_source_ls = list()
-    need_import_files = ['ntt.py','aes.py','decrypt.py']
+    need_import_files = ['ntt.py', 'aes.py', 'decrypt.py']
     for file in need_import_files:
         file_path = path / file
         decrypt_source_ls.append(file_path.read_text().replace(
-            'from pyencrypt.ntt import intt', '').replace('from pyencrypt.aes import aes_decrypt',''))
+            'from pyencrypt.ntt import intt',
+            '').replace('from pyencrypt.aes import aes_decrypt', ''))
 
     loader_source_path = path / 'loader.py'
     loader_source = loader_source_path.read_text().replace(
@@ -66,22 +72,32 @@ def generate_so_file(cipher_key: str, d: int, n:int):
 
     setup_file_path = Path(os.path.abspath(__file__)).parent / 'setup.py'
     args = [
-        'pyminifier', '--obfuscate-classes' ,'--obfuscate-import-methods', '--replacement-length', '20', '-o',
+        'pyminifier', '--obfuscate-classes', '--obfuscate-import-methods',
+        '--replacement-length', '20', '-o',
         loader_file_path.as_posix(),
         loader_file_path.as_posix()
     ]
     ret = subprocess.run(args, shell=False, encoding='utf-8')
     if ret.returncode == 0:
         pass
 
-    args = ['python', setup_file_path.as_posix(), 'build_ext','--build-lib', temp_dir.as_posix()]
-    ret = subprocess.run(args, shell=False, stderr=subprocess.PIPE,encoding='utf-8')
+    args = [
+        'python',
+        setup_file_path.as_posix(), 'build_ext', '--build-lib',
+        temp_dir.as_posix()
+    ]
+    ret = subprocess.run(args,
+                         shell=False,
+                         stderr=subprocess.PIPE,
+                         encoding='utf-8')
     if ret.returncode == 0:
         pass
 
 
-
-def encrypt_file(path: Path, key: str, delete_origin: bool = False, new_path: Path = None):
+def encrypt_file(path: Path,
+                 key: str,
+                 delete_origin: bool = False,
+                 new_path: Path = None):
     if not can_encrypt(path):
         raise Exception(f"{path.name} can't be encrypted.")
     encrypted_data = _encrypt_file(path.read_bytes(), key)

pyencrypt/encrypt.py

@@ -1,20 +1,18 @@
-from Crypto.PublicKey import RSA
 import base64
 import os
 
-def generate_aes_key(size:str = 32) -> str:
+from Crypto.PublicKey import RSA
+
+
+def generate_aes_key(size: str = 32) -> str:
     return base64.b64encode(os.urandom(size))
 
-def generate_rsa_number(bits:int):
+
+def generate_rsa_number(bits: int):
     r = RSA.generate(bits)
-    return {
-        'p':r.p,
-        'q':r.q,
-        'n': r.n,
-        'e': r.e,
-        'd':r.d
-    }
+    return {'p': r.p, 'q': r.q, 'n': r.n, 'e': r.e, 'd': r.d}
+
 
 if __name__ == '__main__':
     print(generate_aes_key(32))
-    print(generate_rsa_number(2048))
+    print(generate_rsa_number(2048))

pyencrypt/generate.py

@@ -14,43 +14,51 @@
 _Path = Union[bytes, str]
 sys.dont_write_bytecode = True
 
+
 class Base:
     def __dir__(self) -> Iterable[str]:
         return []
 
-class EncryptFileLoader(abc.SourceLoader,Base):
 
-    def __init__(self,path) -> None:
+class EncryptFileLoader(abc.SourceLoader, Base):
+    def __init__(self, path) -> None:
         self.path = path or ''
         self.__private_key = ''
         self.__cipher_key = ''
-        
 
     def get_filename(self, fullname: str) -> _Path:
         return self.path
 
     def get_data(self, path: _Path) -> bytes:
         try:
             __n, __d = self.__private_key.split('O', 1)
-            return decrypt_file(Path(path), decrypt_key(self.__cipher_key, int(__n), int(__d)))
+            return decrypt_file(
+                Path(path), decrypt_key(self.__cipher_key, int(__n), int(__d)))
         except Exception:
             traceback.print_exc()
             return b''
 
 
-class EncryptFileFinder(abc.MetaPathFinder,Base):
-    def find_spec(self, fullname: str, path: Sequence[_Path], target: types.ModuleType = None) -> ModuleSpec:
+class EncryptFileFinder(abc.MetaPathFinder, Base):
+    def find_spec(self,
+                  fullname: str,
+                  path: Sequence[_Path],
+                  target: types.ModuleType = None) -> ModuleSpec:
         if path:
             if isinstance(path, _NamespacePath):
-                file_path = Path(path._path[0])/ f'{fullname.rsplit(".",1)[-1]}.pye'
+                file_path = Path(
+                    path._path[0]) / f'{fullname.rsplit(".",1)[-1]}.pye'
             else:
                 file_path = Path(path[0]) / f'{fullname.rsplit(".",1)[-1]}.pye'
         else:
             file_path = f'{fullname}.pye'
         if not os.path.exists(file_path):
             return None
         loader = EncryptFileLoader(file_path)
-        return spec_from_loader(name=fullname, loader=loader, origin='origin-encrypt')
+        return spec_from_loader(name=fullname,
+                                loader=loader,
+                                origin='origin-encrypt')
+
 
 # TODO: generate randomly AES Class
 sys.meta_path.append(EncryptFileFinder())