pyarmor 8.5.6__zip → 8.5.8__zip

{pyarmor-8.5.6 → pyarmor-8.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: pyarmor
-Version: 8.5.6
+Version: 8.5.8
 Summary: A tool used to obfuscate python scripts, bind obfuscated scripts to fixed machine or expire obfuscated scripts.
 Home-page: https://github.com/dashingsoft/pyarmor
 Author: Jondy Zhao

{pyarmor-8.5.6 → pyarmor-8.5.8}/pyarmor/cli/__init__.py

@@ -1,6 +1,6 @@
 import logging
 
-__VERSION__ = '8.5.6'
+__VERSION__ = '8.5.8'
 
 logger = logging.getLogger('cli')
 

{pyarmor-8.5.6 → pyarmor-8.5.8}/pyarmor/cli/__main__.py

@@ -209,10 +209,10 @@ def check_gen_context(ctx, args):
         raise CliError('--outer conflicts with any -e, --period, -b')
 
     if args.pack:
-        choices = 'auto', 'onefile', 'onedir', 'F', 'D', 'FC', 'DC'
+        choices = 'onefile', 'onedir', 'F', 'D', 'FC', 'DC'
         if args.pack not in choices and not os.path.isfile(args.pack):
-            raise CliError('--pack must be an executable file, '
-                           '"auto", "onefile" or "onedir"')
+            raise CliError('--pack must be an executable file, specfile, '
+                           '"onefile" or "onedir"')
         if args.no_runtime:
             raise CliError('--pack conficts with --no-runtime, --use-runtime')
         if ctx.import_prefix:
@@ -232,18 +232,13 @@ def cmd_gen(ctx, args):
         return _cmd_gen_key(builder, options)
     elif args.inputs[0].lower() in ('runtime', 'run', 'r'):
         _cmd_gen_runtime(builder, options)
-    elif args.pack in ('auto', 'onefile', 'onedir', 'F', 'D', 'FC', 'DC'):
-        from .repack import Repacker6
-        packer = Repacker6(ctx, args.pack, options['inputs'], args.output)
-        packer.check()
-        builder.process(options, packer)
-        Plugin.post_build(ctx, pack=args.pack)
     elif args.pack:
-        from .repack import Repacker
-        codesign = ctx.cfg['pack'].get('codesign_identify', None)
-        packer = Repacker(args.pack, ctx.pack_basepath, codesign=codesign)
+        from .repack import find_packer
+        Repacker = find_packer(args.pack)
+        packer = Repacker(ctx, args.pack, options['inputs'], args.output)
         packer.check()
         builder.process(options, packer=packer)
+        packer.build()
         Plugin.post_build(ctx, pack=args.pack)
     else:
         builder.process(options)

{pyarmor-8.5.6 → pyarmor-8.5.8}/pyarmor/cli/bug.py

@@ -36,7 +36,7 @@ $tracelog
 $tb
 ''')
 
-ENABLE_DEBUG_HINTS = '''somthing is wrong
+ENABLE_DEBUG_HINTS = '''something is wrong
 *=============================================================*
 *  Please enable debug option `-d` to run it again            *
 *    pyarmor -d gen options ...                               *
@@ -49,7 +49,7 @@ ENABLE_DEBUG_HINTS = '''somthing is wrong
 *=============================================================*
 '''
 
-SOLUTION_HINTS = Template('''somthing is wrong
+SOLUTION_HINTS = Template('''something is wrong
 *=============================================================*
 *  Please check                                               *
 *    https://pyarmor.readthedocs.io/en/latest/questions.html  *

{pyarmor-8.5.6 → pyarmor-8.5.8}/pyarmor/cli/default.cfg

@@ -3,7 +3,7 @@
 ;; Pyarmor version
 major = 8
 minor = 5
-patch = 6
+patch = 8
 
 ;; Compatible core version
 cli.core = 6.5.1

{pyarmor-8.5.6 → pyarmor-8.5.8}/pyarmor/cli/generate.py

@@ -67,7 +67,7 @@ class Finder(object):
         for res in self._build_resource(resources):
             if res.pkgname not in resnames:
                 self.ctx.obfuscated_modules.add(res.pkgname)
-                self.ctx.extra_resources.append(res)
+                self.ctx.resources.append(res)
 
     def process(self):
         logger.info('search inputs ...')
@@ -156,13 +156,10 @@ class Builder(object):
         finder = Finder(self.ctx)
         finder.process()
 
-        if packer:
-            if options.get('self_contained'):
-                finder.process_extra(packer.contents)
-            if hasattr(packer, 'analysis'):
-                auto_resources = packer.analysis()
-                logger.info('find extra resources: %s', auto_resources)
-                finder.append(auto_resources)
+        if packer and hasattr(packer, 'analysis'):
+            auto_resources = packer.analysis()
+            logger.info('find extra resources: %s', auto_resources)
+            finder.append(auto_resources)
 
         Pytransform3.pre_build(self.ctx)
 
@@ -177,6 +174,3 @@ class Builder(object):
         logger.info('obfuscate scripts OK')
 
         Pytransform3.post_build(self.ctx)
-
-        if packer:
-            packer.repack(output, self.ctx.runtime_package_name)

{pyarmor-8.5.6 → pyarmor-8.5.8}/pyarmor/cli/repack.py

@@ -6,19 +6,363 @@ import struct
 import sys
 import tempfile
 
-from importlib._bootstrap_external import _code_to_timestamp_pyc
-from subprocess import check_call, check_output, DEVNULL
+from fnmatch import fnmatch
+from subprocess import check_call, DEVNULL
 
+# Only used by BundleRepacker, they could be removed with deprecated routines
+from importlib._bootstrap_external import _code_to_timestamp_pyc
 from PyInstaller.archive.writers import ZlibArchiveWriter, CArchiveWriter
 from PyInstaller.archive.readers import CArchiveReader
-try:
-    from PyInstaller.loader.pyimod02_archive import ZlibArchiveReader
-except ModuleNotFoundError:
-    # Since 5.3
-    from PyInstaller.loader.pyimod01_archive import ZlibArchiveReader
 from PyInstaller.compat import is_darwin, is_linux, is_win
 
 
+logger = logging.getLogger('repack')
+
+
+def find_packer(mode):
+    if mode in ('onefile', 'onedir', 'F', 'D', 'FC', 'DC'):
+        return AutoRepacker
+
+    if isinstance(mode, str) and mode.endswith('.spec'):
+        return SpecRepacker
+
+    return BundleRepacker
+
+
+def autoclean_output(output, autoclean=True):
+    if os.path.exists(output) and autoclean:
+        n = len(os.path.abspath(output).split(os.sep))
+        if n < 3:
+            prompt = 'Are you sure to remove path "%s" (y/n)? '
+            choice = input(prompt % output).lower()[:1]
+            if not choice == 'y':
+                return
+        logger.info('clean output path "%s"', output)
+        shutil.rmtree(output)
+
+
+# This patch is used to modify the specfile generate by PyInstaller
+#
+# It mainly does:
+#
+# 1. Find all the imported modules and packages, save to hook script
+#
+# 2. Find imported modules and packages in the same path of main
+#    script, and save their names to one list (all of them will be
+#    obfuscated automatically)
+#
+spec_patch_code = '''
+import marshal
+import os
+
+from PyInstaller.compat import base_prefix, EXTENSION_SUFFIXES
+from sys import prefix, exec_prefix
+from fnmatch import fnmatch
+
+exlist = set([base_prefix, prefix, exec_prefix])
+expats = [os.path.join(os.path.normpath(x), '*') for x in exlist]
+
+src = {src!r}
+resfile = {resfile!r}
+hookscript = {hookscript!r}
+
+nsrc = len(src) + 1
+rsrc = os.path.relpath(src)
+rsrc = '' if rsrc == '.' else rsrc
+psrc = os.path.join(src, '*')
+
+hiddenimports = set([])
+plist = set([])
+mlist = []
+
+for name, path, kind in a.pure:
+    if name.startswith('pyi_rth'):
+        continue
+    hiddenimports.add(name)
+    if fnmatch(path, psrc) and not any([fnmatch(path, x) for x in expats]):
+        if name.find('.') == -1 and os.path.basename(path) != '__init__.py':
+            mlist.append(os.path.join(rsrc, path[nsrc:]))
+        else:
+            pkgname = os.path.dirname(path[nsrc:]).split(os.sep)[0]
+            plist.add(os.path.join(rsrc, pkgname))
+
+for name, path, kind in a.binaries:
+    if kind == 'EXTENSION':
+        for x in EXTENSION_SUFFIXES:
+            if fnmatch(name, '*' + x):
+                name = name[:-len(x)]
+                break
+        hiddenimports.add(name.replace(os.sep, '.'))
+
+with open(resfile, 'wb') as f:
+    marshal.dump(mlist + list(plist), f)
+with open(hookscript, 'w') as f:
+    f.write("hiddenimports=[%s]" % ", ".join([repr(x) for x in hiddenimports]))
+'''
+
+
+class AutoRepacker:
+    """New repacker to support PyInstaller 6.0+
+
+    Args:
+        ctx: build context
+        mode: onefile or onedir
+        inputs: main script to pack
+        output: path to store final bundle, default is `dist`
+    """
+
+    def __init__(self, ctx, mode, inputs, output):
+        self.ctx = ctx
+        self.script = inputs[0]
+        self.output = os.path.normpath(output) if output else 'dist'
+
+        self.name = os.path.splitext(os.path.basename(self.script))[0]
+        self.obfpath = os.path.normpath(self.ctx.pack_obfpath)
+        self.packpath = os.path.normpath(self.ctx.pack_basepath)
+        self.workpath = os.path.join(self.packpath, 'build')
+        self.pyicmd = [sys.executable, '-m', 'PyInstaller']
+        self.autoclean = mode in ('FC', 'DC')
+        self.modeopt = '-F' if mode in ('onefile', 'F', 'FC') else '-D'
+        self.init_opts()
+
+    def init_opts(self):
+        self.pyiopts = []
+
+        opts = self.ctx.pyi_options
+        exopts = '--noconfirm', '-y', '--onefile', '-F', '--onedir', '-D'
+        exvalues = '--distpath', '--specpath', '--workpath'
+
+        n = 0
+        while n < len(opts):
+            x = opts[n]
+            if x in ('--name', '-n'):
+                self.name = opts[n+1]
+
+            if x in ('--noconfirm', '-y'):
+                self.autoclean = True
+
+            if x in exvalues:
+                n += 1
+            elif x not in exopts:
+                self.pyiopts.append(x)
+            n += 1
+
+    def analysis(self):
+        """Got imported modules and packages by PyInstaller
+
+        Generate hook script
+        Return file/dir list need to be obfuscated
+        """
+        cmdspec = [sys.executable, '-m', 'PyInstaller.utils.cliutils.makespec']
+        cmdspec.extend(self.pyiopts)
+        cmdspec.append(self.script)
+        logger.debug('%s', ' '.join(cmdspec))
+        logger.info('call PyInstaller to generate specfile')
+        check_call(cmdspec, stdout=DEVNULL, stderr=DEVNULL)
+
+        specfile = self.name + '.spec'
+        rtname = self.ctx.runtime_package_name
+        resfile = os.path.join(self.packpath, 'resources.list')
+        hookscript = os.path.join(self.packpath, 'hook-%s.py' % rtname)
+        self.patch_specfile(specfile, hookscript, resfile)
+
+        cmdlist = self.pyicmd + ['--clean', '--workpath', self.workpath]
+        cmdlist.append(specfile)
+        logger.debug('%s', ' '.join(cmdlist))
+        logger.info('call PyInstaller to analysis, '
+                    'it may take several minutes ...')
+        check_call(cmdlist, stdout=DEVNULL, stderr=DEVNULL)
+
+        with open(resfile, 'rb') as f:
+            reslist = marshal.load(f)
+
+        resoptions = self.ctx.get_res_options('')
+        excludes = resoptions.get('excludes', '').split()
+        if excludes:
+            reslist = [x for x in reslist
+                       if not any([fnmatch(x, pat) for pat in excludes])]
+        return reslist
+
+    def build(self):
+        """Generate final bundle to output"""
+        obfscript = os.path.join(self.obfpath, os.path.basename(self.script))
+        cmdlist = self.pyicmd + [
+            '--clean',
+            '--distpath', self.output,
+            '--workpath', self.workpath,
+            '--additional-hooks-dir', self.packpath,
+            self.modeopt
+        ]
+        cmdlist.extend(self.pyiopts)
+        cmdlist.append(obfscript)
+
+        logger.debug('%s', ' '.join(cmdlist))
+        logger.info('call PyInstaller to generate final bundle ...\n')
+        check_call(cmdlist)
+        logger.info('')
+        logger.info('the final bundle has been generated to "%s" successfully',
+                    self.output)
+
+    def patch_specfile(self, specfile, hookscript, resfile):
+        lines = []
+        with open(specfile, 'r', encoding='utf-8') as f:
+            for line in f:
+                if line.startswith('pyz = PYZ'):
+                    break
+                lines.append(line)
+            else:
+                logger.error('no found line starts with "pyz = PYZ"')
+                raise RuntimeError('unsupported specfile "%s"' % specfile)
+
+        lines.append(spec_patch_code.format(
+            src=os.path.abspath(os.path.dirname(self.script)),
+            hookscript=os.path.abspath(hookscript),
+            resfile=os.path.abspath(resfile)))
+
+        with open(specfile, 'w', encoding='utf-8') as f:
+            f.write(''.join(lines))
+
+    def check(self):
+        autoclean_output(self.output, self.autoclean)
+
+
+manual_spec_patch = '''
+# Pyarmor patch start:
+
+def apply_pyarmor_patch():
+
+    srcpath = {srcpath!r}
+    obfpath = {obfpath!r}
+    pkgname = {rtname!r}
+    pkgpath = os.path.join(obfpath, pkgname)
+    extpath = os.path.join(pkgname, {extname!r})
+
+    if hasattr(a.pure, '_code_cache'):
+        code_cache = a.pure._code_cache
+    else:
+        from PyInstaller.config import CONF
+        code_cache = CONF['code_cache'].get(id(a.pure))
+
+    srclist = [os.path.normcase(x) for x in srcpath]
+    def match_obfuscated_script(orgpath):
+        for x in srclist:
+            if os.path.normcase(orgpath).startswith(x):
+                return os.path.join(obfpath, orgpath[len(x)+1:])
+
+    count = 0
+    for i in range(len(a.scripts)):
+        x = match_obfuscated_script(a.scripts[i][1])
+        if x and os.path.exists(x):
+            a.scripts[i] = a.scripts[i][0], x, a.scripts[i][2]
+            count += 1
+    if count == 0:
+        raise RuntimeError('No obfuscated script found')
+
+    for i in range(len(a.pure)):
+        x = match_obfuscated_script(a.pure[i][1])
+        if x and os.path.exists(x):
+            code_cache.pop(a.pure[i][0], None)
+            a.pure[i] = a.pure[i][0], x, a.pure[i][2]
+
+    a.pure.append((pkgname, os.path.join(pkgpath, '__init__.py'), 'PYMODULE'))
+    a.binaries.append((extpath, os.path.join(obfpath, extpath), 'EXTENSION'))
+
+apply_pyarmor_patch()
+
+# Pyarmor patch end.
+'''
+
+
+class SpecRepacker:
+    """Patch specfile and use it to pack obfuscated scripts
+
+    Args:
+        ctx: build context
+        specfile: specfile need to be patched
+        inputs: main script to pack
+        output: path to store final bundle, default is `dist`
+    """
+
+    def __init__(self, ctx, specfile, inputs, output):
+        self.ctx = ctx
+        self.specfile = specfile
+        self.script = inputs[0]
+        self.output = os.path.normpath(output) if output else 'dist'
+
+        self.pyicmd = [sys.executable, '-m', 'PyInstaller']
+        self.obfpath = os.path.normpath(self.ctx.pack_obfpath)
+
+    def build(self):
+        """Generate patched specfile and pack obfuscated scripts"""
+        specfile = self.specfile[:-5] + '.patched.spec'
+        logger.info('generate patched specfile "%s"', specfile)
+
+        rtpkg = self.ctx.runtime_package_name
+        for x in os.listdir(os.path.join(self.obfpath, rtpkg)):
+            if x.startswith('pyarmor_runtime'):
+                extname = x
+                break
+        else:
+            raise RuntimeError('no found extension `pyarmor_runtime`')
+
+        patch = manual_spec_patch.format(
+            srcpath=[os.path.abspath(os.path.dirname(self.script))],
+            obfpath=os.path.abspath(self.obfpath),
+            rtname=self.ctx.runtime_package_name,
+            extname=extname)
+
+        with open(self.specfile, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+
+        n = 0
+        for line in lines:
+            if line.startswith('pyz = PYZ'):
+                lines[n:n] = [patch]
+                break
+            n += 1
+        else:
+            logger.error('no found line starts with "pyz = PYZ"')
+            raise RuntimeError('unsupported specfile "%s"' % self.specfile)
+
+        with open(specfile, 'w', encoding='utf-8') as f:
+            f.write(''.join(lines))
+
+        cmdlist = self.pyicmd + [
+            '--clean',
+            '--distpath', self.output,
+            '--workpath', os.path.join(self.ctx.pack_basepath, 'build'),
+            specfile
+        ]
+        logger.info('call PyInstaller to generate final bundle ...'
+                    '\n\n%s\n', ' '.join(cmdlist))
+        check_call(cmdlist)
+        logger.info('')
+        logger.info('the final bundle has been generated to "%s" successfully',
+                    self.output)
+
+    def check(self):
+        options = self.ctx.pyi_options
+        autoclean = '-y' in options or '--noconfirm' in options
+        autoclean_output(self.output, autoclean)
+
+
+##############################################################
+#
+# Deprecated routines
+#
+# This is the old method to repack executable generated by PyInstaller
+#
+# Why is it deprecated?
+#
+# 1. It need hack PyInstaller bundle structure which may be changed in
+#    different PyInstaller version.
+#
+#    Actually, it doesn't work for PyInstaller 5.13+ because of this
+#
+# 2. Not friend to junior users
+#
+##
+
 # Type codes for PYZ PYZ entries
 PYZ_ITEM_MODULE = 0
 PYZ_ITEM_PKG = 1
@@ -41,9 +385,6 @@ PKG_ITEM_SPLASH = 'l'  # splash resources
 EXTRACT_SUFFIX = '_extracted'
 
 
-logger = logging.getLogger('repack')
-
-
 class CArchiveReader2(CArchiveReader):
 
     def find_magic_pattern(self, fp, magic_pattern):
@@ -93,6 +434,12 @@ class CArchiveReader2(CArchiveReader):
         if hasattr(self, 'open_embedded_archive'):
             return self.open_embedded_archive(name)
 
+        try:
+            from PyInstaller.loader.pyimod02_archive import ZlibArchiveReader
+        except ModuleNotFoundError:
+            # Since 5.3
+            from PyInstaller.loader.pyimod01_archive import ZlibArchiveReader
+
         ndx = self.toc.find(name)
         (dpos, dlen, ulen, flag, typcd, nm) = self.toc.get(ndx)
         return ZlibArchiveReader(self.path, self.pkg_start + dpos)
@@ -306,13 +653,16 @@ def repack_executable(executable, buildpath, obfpath, rtentry, codesign=None):
     logger.info('generate patched bundle "%s" successfully', executable)
 
 
-class Repacker:
+class BundleRepacker:
+    """Deprecated method since v8.5.8"""
 
-    def __init__(self, executable, buildpath, codesign=None):
+    def __init__(self, ctx, executable, inputs, output):
+        self.ctx = ctx
         self.executable = executable
-        self.buildpath = buildpath
-        self.codesign = codesign
-        self.extract_carchive(executable, buildpath)
+        self.output = os.path.normpath(output) if output else 'dist'
+        self.buildpath = ctx.pack_basepath
+        self.codesign = ctx.cfg['pack'].get('codesign_identify', None)
+        self.extract_carchive(executable, self.buildpath)
 
     def check(self):
         try:
@@ -360,6 +710,9 @@ class Repacker:
             for x in os.scandir(os.path.dirname(executable))])
         logger.debug('one file mode is %s', bool(self.one_file_mode))
 
+    def build(self):
+        self.repack(self.output, self.ctx.runtime_package_name)
+
     def repack(self, obfpath, rtname, entry=None):
         buildpath = self.buildpath
         executable = self.executable
@@ -414,6 +767,7 @@ class Repacker:
     def _fixup_darwin_rtbinary(self, rtbinary, pylib_name):
         '''Unused since Pyarmor 8.3.0'''
         from sys import version_info as pyver
+        from subprocess import check_output
         pylib = os.path.normpath(os.path.join('@rpath', pylib_name))
         output = check_output(['otool', '-L', rtbinary])
         for line in output.splitlines():
@@ -436,183 +790,3 @@ class Repacker:
             check_call(cmdlist, stdout=DEVNULL, stderr=DEVNULL)
         except Exception as e:
             logger.warning('%s', e)
-
-
-# This patch is used to modify the specfile generate by PyInstaller
-#
-# It has 2 goals:
-#
-# 1. Find all the imported modules and packages
-#
-#    Save them to hook script
-#
-# 2. Search scripts and packages in the path of entry script
-#
-#    All of them will be obfuscated automatically
-#
-spec_patch_code = '''
-from PyInstaller.compat import base_prefix
-import marshal
-import os
-
-hiddenimports = set([])
-plist = set([])
-mlist = []
-src = {src}
-sn = len(src) + 1
-prefix = os.path.relpath(src)
-prefix = '' if prefix == '.' else prefix
-
-for name, path, kind in a.pure:
-    if name.startswith('pyi_rth'):
-        continue
-    if path.startswith(src) and not path.startswith(base_prefix):
-        hiddenimports.add(name)
-        if name.find('.') == -1 and os.path.basename(path) != '__init__.py':
-            mlist.append(os.path.join(prefix, path[sn:]))
-        else:
-            pkgname = os.path.dirname(path[sn:]).split(os.sep)[0]
-            plist.add(os.path.join(prefix, pkgname))
-    else:
-        hiddenimports.add(name.split('.')[0])
-
-with open({resfile}, 'wb') as f:
-    marshal.dump(mlist + list(plist), f)
-with open({hookscript}, 'w') as f:
-    f.write("hiddenimports=[%s]" % ", ".join([repr(x) for x in hiddenimports]))
-'''
-
-
-class Repacker6:
-    """New repacker to support PyInstaller 6.0+
-
-    Args:
-        ctx: build context
-        mode: onefile or onefolder
-        inputs: main script to pack
-    """
-
-    def __init__(self, ctx, mode, inputs, output):
-        self.ctx = ctx
-        self.inputs = inputs
-        self.output = 'dist' if output is None else os.path.normpath(output)
-
-        self.script = self.inputs[0]
-        self.obfpath = os.path.normpath(self.ctx.pack_obfpath)
-        self.packpath = os.path.normpath(self.ctx.pack_basepath)
-        self.workpath = os.path.join(self.packpath, 'build')
-        self.pyicmd = [sys.executable, '-m', 'PyInstaller']
-        self.pyiopts = self.init_opts(mode)
-        self.autoclean = mode in ('FC', 'DC')
-
-    def init_opts(self, mode):
-        opts = []
-        exopts = '--noconfirm', '-y'
-        if mode == 'auto':
-            exopts += ('--onefile', '-F', '--onefolder', '-D')
-        else:
-            opts.append('-F' if mode in ('onefile', 'F', 'FC') else '-D')
-        opts.extend(self.ctx.pyi_options)
-
-        exvalues = '--distpath', '--specpath', '--workpath'
-        return self.filter_opts(opts, exvalues, exopts)
-
-    def filter_opts(self, opts, exvalues, exopts=None):
-        result = []
-        isvalue = False
-        for x in opts:
-            if isvalue:
-                isvalue = False
-            elif x in exvalues:
-                isvalue = True
-            elif exopts is None or x not in exopts:
-                result.append(x)
-        return result
-
-    def analysis(self):
-        """Got imported modules and packages by PyInstaller
-
-        Generate hook script
-        Return file/dir list need to be obfuscated
-        """
-        cmdspec = [
-            sys.executable, '-m', 'PyInstaller.utils.cliutils.makespec',
-            '--specpath', self.packpath
-        ]
-        exvalues = '--name', '-N'
-        exopts = '-F', '--onefile', '-D', '--onefolder'
-        cmdspec.extend(self.filter_opts(self.pyiopts, exvalues, exopts))
-        cmdspec.append(self.script)
-        logger.debug('%s', ' '.join(cmdspec))
-        logger.info('call PyInstaller to generate specfile')
-        check_call(cmdspec, stdout=DEVNULL, stderr=DEVNULL)
-
-        name = os.path.splitext(os.path.basename(self.script))[0]
-        rtname = self.ctx.runtime_package_name
-        specfile = os.path.join(self.packpath, name + '.spec')
-        resfile = os.path.join(self.packpath, 'resources.list')
-        hookscript = os.path.join(self.packpath, 'hook-%s.py' % rtname)
-        self.patch_specfile(specfile, hookscript, resfile)
-
-        cmdlist = self.pyicmd + ['--clean', '--workpath', self.workpath]
-        cmdlist.extend(self.filter_opts(self.pyiopts, exvalues, exopts))
-        cmdlist.append(specfile)
-        logger.debug('%s', ' '.join(cmdlist))
-        logger.info('call PyInstaller to analysis, '
-                    'it may take several minutes ...')
-        check_call(cmdlist, stdout=DEVNULL, stderr=DEVNULL)
-
-        with open(resfile, 'rb') as f:
-            return marshal.load(f)
-
-    def build(self):
-        """Generate final bundle to output"""
-        script = os.path.join(self.obfpath, os.path.basename(self.inputs[0]))
-        cmdlist = self.pyicmd + [
-            '--clean',
-            '--distpath', self.output,
-            '--workpath', self.workpath,
-            '--specpath', self.packpath,
-            '--additional-hooks-dir', self.packpath,
-        ]
-        cmdlist.extend(self.pyiopts)
-        cmdlist.append(script)
-
-        logger.debug('%s', ' '.join(cmdlist))
-        logger.info('call PyInstaller to generate final bundle ...\n')
-        check_call(cmdlist)
-        logger.info('')
-        logger.info('the final bundle "%s" has been generate successfully',
-                    self.output)
-
-    def repack(self, *unused):
-        """Only for compatible with Repacker"""
-        self.build()
-
-    def patch_specfile(self, specfile, hookscript, resfile):
-        # TODO: non-ascii need specify encoding to open file
-        lines = []
-        with open(specfile, 'r') as f:
-            for line in f:
-                if line.startswith('pyz = PYZ'):
-                    break
-                lines.append(line)
-
-        lines.append(spec_patch_code.format(
-            src=repr(os.path.abspath(os.path.dirname(self.script))),
-            hookscript=repr(os.path.abspath(hookscript)),
-            resfile=repr(os.path.abspath(resfile))))
-
-        with open(specfile, 'w') as f:
-            f.write(''.join(lines))
-
-    def check(self):
-        if os.path.exists(self.output) and self.autoclean:
-            n = len(os.path.abspath(self.output).split(os.sep))
-            if n < 3:
-                prompt = 'Are you sure to remove path "%s" (y/n)? '
-                choice = input(prompt % self.output).lower()[:1]
-                if not choice == 'y':
-                    return
-            logger.info('clean output path "%s"', self.output)
-            shutil.rmtree(self.output)

{pyarmor-8.5.6 → pyarmor-8.5.8}/pyarmor/config.py

@@ -1,6 +1,6 @@
 from sys import platform
 
-version = '8.5.6'
+version = '8.5.8'
 
 # The corresponding version of pytransform.so
 core_version = 'r52.6'

{pyarmor-8.5.6 → pyarmor-8.5.8}/pyarmor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: pyarmor
-Version: 8.5.6
+Version: 8.5.8
 Summary: A tool used to obfuscate python scripts, bind obfuscated scripts to fixed machine or expire obfuscated scripts.
 Home-page: https://github.com/dashingsoft/pyarmor
 Author: Jondy Zhao