pyarmor.cli 9.2.1__tar.gz → 9.2.2__tar.gz

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyarmor.cli
-Version: 9.2.1
+Version: 9.2.2
 Summary: A comand line tool to obfuscate python scripts
 Home-page: https://github.com/dashingsoft/pyarmor
 Author: Jondy Zhao

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor/cli/__init__.py

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

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor/cli/__main__.py

@@ -767,6 +767,9 @@ def main_entry(argv):
     if not (x == 3 and y > 6 and y < 16):
         raise CliError('Python %s.%s is not supported' % (x, y))
 
+    if ctx.py_gil_disabled:
+        raise CliError('Pyarmor does not support free-threading Python')
+
     if args.version:
         print_version(ctx)
         parser.exit()

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor/cli/command.py

@@ -167,9 +167,20 @@ class Commander:
         )
         group.add_argument(
             '--ecc-rft', dest='target', default='std',
-            action="store_const", const='ecc',
+            action="store_const", const='ecc-rft',
             help='generate scripts by combining --rft and --ecc'
         )
+        group.add_argument(
+            '--ecc-nogil', dest='target', default='std',
+            action="store_const", const='ecc-nogil',
+            help='genetate ECC scripts for free-threading Python'
+        )
+        group.add_argument(
+            '--ecc-rft-nogil', dest='target', default='std',
+            action="store_const", const='ecc-rft-nogil',
+            help=('generate scripts by combining --rft and --ecc'
+                  ' for free-threading Python')
+        )
         group.add_argument(
             '--list', dest='target', default='std',
             action="store_const", const='list',
@@ -348,7 +359,7 @@ class Commander:
             logger.info('%-20s: %s', key, value)
 
         makedirs(ctx.local_path, exist_ok=True)
-        with open(ctx.local_config, 'w') as f:
+        with open(ctx.local_config, 'w', encoding=ctx.encoding) as f:
             cfg.write(f)
         logger.info('project saved')
 
@@ -376,6 +387,10 @@ class Commander:
         )
         cfg.read([ctx.local_config], encoding=ctx.encoding)
 
+        x, y = ctx.python_version
+        if not (x == 3 and y > 8 and y < 16):
+            raise CliError('`pyarmor build` only works for Python 3.9+')
+
         sectname = 'project'
         if not cfg.has_section(sectname):
             raise CliError('no project information')

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor/cli/config.py

@@ -43,7 +43,7 @@ class Configer(object):
 
     def __init__(self, ctx, encoding=None):
         self.ctx = ctx
-        self._encoding = encoding
+        self._encoding = encoding or ctx.encoding
 
     def _read_config(self, filename):
         cfg = configparser.ConfigParser(empty_lines_in_values=False)
@@ -166,7 +166,7 @@ class Configer(object):
         cfg.set(sect, optname, optvalue)
 
         os.makedirs(os.path.dirname(filename), exist_ok=True)
-        with open(filename, 'w') as f:
+        with open(filename, 'w', encoding=self._encoding) as f:
             cfg.write(f)
 
         self._list_value(sect, optname, local=local, name=name)
@@ -196,7 +196,7 @@ class Configer(object):
                         logger.info('remove empty section "%s"', section)
                         cfg.remove_section(section)
 
-            with open(filename, 'w') as f:
+            with open(filename, 'w', encoding=self._encoding) as f:
                 cfg.write(f)
 
     def _clear(self, section=None, options=None, local=True, name=None):

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor/cli/context.py

@@ -164,9 +164,9 @@ class Context(object):
             os.path.join(self.home_path, rpath)
 
         # self.encoding is just for reading config file
-        self.encoding = encoding
+        self.encoding = encoding if encoding else 'utf-8'
         cfglist = self.default_config, self.global_config, self.local_config
-        self.cfg = self._read_config(cfglist, encoding=encoding)
+        self.cfg = self._read_config(cfglist, encoding=self.encoding)
 
         # self.runtime_package = 'pyarmor_runtime'
         # self.runtime_suffix = '_000000'
@@ -205,6 +205,7 @@ class Context(object):
             empty_lines_in_values=False,
             interpolation=configparser.ExtendedInterpolation(),
         )
+        encoding = encoding or self.encoding
         cfg.read(filelist, encoding=encoding)
         return cfg
 
@@ -330,6 +331,11 @@ class Context(object):
     def python_version(self):
         return sys.version_info[:2]
 
+    @property
+    def py_gil_disabled(self):
+        from sysconfig import get_config_var
+        return 1 if get_config_var("Py_GIL_DISABLED") else 0
+
     @property
     def default_config(self):
         return os.path.join(os.path.dirname(__file__), 'default.cfg')

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor/cli/default.cfg

@@ -3,7 +3,7 @@
 ;; Pyarmor version
 major = 9
 minor = 2
-patch = 1
+patch = 2
 
 ;; Compatible core version for package: pyarmor.cli.core
 cli.core = 8.1.0

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor/cli/model.py

@@ -401,6 +401,15 @@ SECTIONS = {
             cls='DictOption',
         ),
     ],
+    'mini': [
+        OptionModel(
+            name='import_from',
+            cls='NameOption',
+            value='pyarmor.mini.pyarmor_mini',
+        ),
+    ],
+    'vmc': [],
+    'ecc': [],
 }
 
 

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor/cli/plugin.py

@@ -186,7 +186,7 @@ class MultiPythonPlugin:
         os.makedirs(verpath)
 
         pkgscript = os.path.join(pkgpath, '__init__.py')
-        with open(pkgscript) as f:
+        with open(pkgscript, encoding=ctx.encoding) as f:
             lines = f.readlines()
         start = 1 if lines[0].startswith('#') else 0
 
@@ -196,13 +196,13 @@ class MultiPythonPlugin:
                 '{0} = __import__("py%d%d.pyarmor_runtime" % py_version[:2],'
                 ' globals(), locals(), ["{0}"], 1).{0}'.format('__pyarmor__')
             ])
-            with open(pkgscript, 'w') as f:
+            with open(pkgscript, 'w', encoding=ctx.encoding) as f:
                 f.write(''.join(lines))
             for x in MultiPythonPlugin.RUNTIME_FILES:
                 move(x, verpath)
         else:
             lines[start:start] = 'from sys import version_info as py_version\n'
-            with open(pkgscript, 'w') as f:
+            with open(pkgscript, 'w', encoding=ctx.encoding) as f:
                 f.write(''.join(lines).replace(
                     "join(['_'", "join(['py%d%d' % py_version[:2], '_'"))
             for x in MultiPythonPlugin.RUNTIME_FILES:
@@ -253,7 +253,7 @@ class DarwinUniversalPlugin:
             return
 
         def rebuild_init(oneplat, init_script):
-            with open(init_script, 'r') as f:
+            with open(init_script, 'r', encoding=ctx.encoding) as f:
                 lines = f.readlines()
             if oneplat:
                 lines[1:] = ['from .pyarmor_runtime import __pyarmor__']
@@ -262,7 +262,7 @@ class DarwinUniversalPlugin:
                     if lines[i].strip().startswith("# mach = 'universal'"):
                         lines[i] = lines[i].replace('# ', '')
                         break
-            with open(init_script, 'w') as f:
+            with open(init_script, 'w', encoding=ctx.encoding) as f:
                 f.write(''.join(lines))
 
         rtpath = find_runtime_package(ctx, outputs[0])

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor/cli/project.py

@@ -23,7 +23,7 @@
 #
 #   - Define project object for Pyarmor 9.
 #   - Define project commands: init, build
-#   - Define targets: std, fly, vmc, ecc, rft
+#   - Define targets: std, mini, vmc, ecc, rft
 
 """Manage projects
 
@@ -151,6 +151,8 @@ class Module:
         self._tree = None
         self._type = None
 
+        self._shebang = ''
+
     @property
     def name(self):
         return '' if self._name == '__init__' else self._name
@@ -190,14 +192,21 @@ class Module:
         s = self.qualname + ('' if self.name else '.__init__')
         return joinpath(*s.split('.')) + splitext(self.path)[-1]
 
-    def compile_file(self, force=False):
+    @property
+    def shebang(self):
+        return self._shebang
+
+    def compile_file(self, force=False, optimize=-1):
         if self._co is not None and not force:
             return
 
         self.parse_file(force=force)
 
+        options = {
+            'optimize': optimize
+        }
         logger.info('compile %s ...', self.qualname)
-        self._co = compile(self._tree, self.abspath, 'exec')
+        self._co = compile(self._tree, self.abspath, 'exec', **options)
         logger.info('compile %s end', self.qualname)
 
     def parse_file(self, force=False):
@@ -206,7 +215,9 @@ class Module:
 
         filename = self.abspath
         with open(filename, 'rb') as f:
-            encoding, _ = tokenize.detect_encoding(f.readline)
+            encoding, lines = tokenize.detect_encoding(f.readline)
+            if lines and lines[0].startswith(b'#!'):
+                self._shebang = lines[0].decode(encoding)
 
         with open(filename, 'r', encoding=encoding) as f:
             logger.info('parse %s ...', self.qualname)
@@ -385,6 +396,11 @@ class Project:
         self._rft_include_attrs = None
         self._used_external_types = None
 
+        self._std_options = None
+        self._mini_options = None
+        self._vmc_options = None
+        self._ecc_options = None
+
         # Log variable name in chain attributes
         #
         # For example, in module "foo.py":
@@ -496,6 +512,20 @@ class Project:
         for x in self._namespaces:
             yield x
 
+    @property
+    def std_options(self):
+        """Options got from ctx.builder, not in project"""
+        if self._std_options is None:
+            cfg = self.ctx.cfg
+            optimize = cfg['builder'].getint('optimize', -1)
+            self._std_options = {
+                'optimize': optimize
+            }
+        return self._std_options
+
+    def std_opt(self, name):
+        return self.std_options.get(name)
+
     @property
     def rft_options(self):
         """Refactor options:
@@ -764,6 +794,62 @@ class Project:
             self._rft_type_rules = vartypes
         return self._rft_type_rules
 
+    @property
+    def mini_options(self):
+        """MINI mode options:
+
+        - import_from: str
+
+          Default value is "pyarmor.mini.pyarmor_mini", it means from
+          package `pyarmor.mini` import extension `pyarmor_mini`
+
+          Set it to "pyarmor_mini" if it's distributed with obfuscated
+          scripts
+        """
+        if self._mini_options is None:
+            cfg = self.ctx.cfg
+            sect = 'mini'
+            if cfg.has_section(sect):
+                self._mini_options = dict(cfg.items(sect))
+            else:
+                self._mini_options = {}
+            self._mini_options.setdefault(
+                'import_from', 'pyarmor.mini.pyarmor_mini')
+        return self._mini_options
+
+    def mini_opt(self, name):
+        return self.mini_options.get(name)
+
+    @property
+    def vmc_options(self):
+        """VMC mode options"""
+        if self._vmc_options is None:
+            cfg = self.ctx.cfg
+            sect = 'vmc'
+            if cfg.has_section(sect):
+                self._vmc_options = dict(cfg.items(sect))
+            else:
+                self._vmc_options = {}
+        return self._vmc_options
+
+    def vmc_opt(self, name):
+        return self.vmc_options.get(name)
+
+    @property
+    def ecc_options(self):
+        """ECC mode options"""
+        if self._ecc_options is None:
+            cfg = self.ctx.cfg
+            sect = 'ecc'
+            if cfg.has_section(sect):
+                self._ecc_options = dict(cfg.items(sect))
+            else:
+                self._ecc_options = {}
+        return self._ecc_options
+
+    def ecc_opt(self, name):
+        return self.ecc_options.get(name)
+
     @property
     def builtins(self):
         if self._builtins is None:
@@ -780,7 +866,7 @@ class Project:
             for name in names.split():
                 if name.endswith('.json'):
                     if exists(name):
-                        with open(name) as f:
+                        with open(name, encoding='utf-8') as f:
                             used_types.update(jsonload(f))
                 else:
                     modname = name.split('::')[0]
@@ -819,19 +905,6 @@ class Project:
                 self._rft_include_attrs.update(value.split())
         return self._rft_include_attrs
 
-    def std_options(self):
-        """Obfuscation options only for std target
-
-        - std_assert_import
-        - std_assert_call
-        - std_restrict_module
-        - std_expired_date
-        - std_bind_devices
-
-        Got from command line, not in config file
-        """
-        pass
-
     def get_module(self, qualname):
         """Get module in the project by unique qualname
         It equals one dict: map_qualname_to_module
@@ -1013,7 +1086,7 @@ class Project:
         if not exists(rulefile):
             logger.info('no found %s', rulefile)
             return
-        with open(rulefile) as f:
+        with open(rulefile, encoding='utf-8') as f:
             fixtable = jsonload(f)
 
         if mode == 2:
@@ -1071,7 +1144,7 @@ class Project:
         inattrs = fixtable.get('include_attrs', [])
         rftattrs = header.substitute(attrs='\n'.join(
             [f'[[*{x}][{x}]]' for x in inattrs]))
-        with open(output, 'w') as fp:
+        with open(output, 'w', encoding='utf-8') as fp:
             fp.write(rftattrs)
             for attr in inattrs:
                 infos = attrinfo.get(attr)
@@ -1164,7 +1237,7 @@ class Project:
         """))
 
         attrs = sorted(rftattrs.keys())
-        with open(output, 'w') as fp:
+        with open(output, 'w', encoding='utf-8') as fp:
             fp.write(header.substitute(
                 attrs='\n'.join([f'[[*{x}][{x}]]' for x in attrs])
             ))

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor/cli/shell.py

@@ -86,7 +86,7 @@ class CfgEntity:
         self._reader = self._writer = None
 
     def save(self):
-        with open(self.cfgfile, 'w') as f:
+        with open(self.cfgfile, 'w', encoding=self._encoding) as f:
             self.writer.write(f)
 
 
@@ -260,7 +260,7 @@ class PyarmorShell(cmd.Cmd):
             ctx.default_config,
             ctx.global_config,
             ctx.local_config
-        ])
+        ], encoding=ctx.encoding)
         self._domains = self._init_domains()
         self._domain = self._section = self._domains[domain]
 
@@ -281,6 +281,9 @@ class PyarmorShell(cmd.Cmd):
                 domain.add_group(name, GROUPS[name])
 
         ps.add_section('rft')
+        ps.add_section('mini')
+        ps.add_section('vmc')
+        ps.add_section('ecc')
 
         return {'global': gs, 'local': ls, 'project': ps}
 

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/pyarmor.cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyarmor.cli
-Version: 9.2.1
+Version: 9.2.2
 Summary: A comand line tool to obfuscate python scripts
 Home-page: https://github.com/dashingsoft/pyarmor
 Author: Jondy Zhao

{pyarmor_cli-9.2.1 → pyarmor_cli-9.2.2}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup
 
-__VERSION__ = ' 9.2.1'
+__VERSION__ = ' 9.2.2'
 
 with open('README.rst') as f:
     long_description = f.read()