pyarmor.cli 9.2.0__tar.gz → 9.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyarmor.cli
-Version: 9.2.0
+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.0 → pyarmor_cli-9.2.2}/pyarmor/cli/__init__.py

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

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

@@ -325,7 +325,7 @@ def cmd_reg(ctx, args):
 
     else:
         regsvr = WebRegister(ctx)
-        regsvr.check_request_interval()
+        regsvr.check_request_interval(activation=regfile)
         info, msg = regsvr.prepare(regfile, args.product, upgrade=upgrade)
         prompt = 'Are you sure to continue? (yes/no) '
         if args.confirm:
@@ -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.2/pyarmor/cli/batch.py

@@ -0,0 +1,62 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#############################################################
+#                                                           #
+#      Copyright @ 2025 -  Dashingsoft corp.                #
+#      All rights reserved.                                 #
+#                                                           #
+#      Pyarmor                                              #
+#                                                           #
+#      Version: 9.2.1 -                                     #
+#                                                           #
+#############################################################
+#
+#
+#  @File: cli/shell.py
+#
+#  @Author: Jondy Zhao (pyarmor@163.com)
+#
+#  @Create Date: Wed Nov  5 20:22:52 CST 2025
+#
+
+"""This script could run batch pyarmor commands.
+
+For example:
+
+    python3 -m pyarmor.cli.batch build-script.sh
+
+cd abc
+pyarmor
+
+The main purpose is to fix pyarmor CI License send too many request issues.
+
+"""
+import shlex
+import os
+
+from pyarmor.cli.__main__ import main_entry as pyarmor_run
+
+# Do not run `pyarmor reg pyarmor-ci-xxxx.zip` here, run it before this script
+
+build_commands = """
+pyarmor gen main.py
+cd ../package1
+pyarmor gen -R --enable-bcc src/
+cd ../package2
+pyarmor gen -R --enable-jit --private src/
+"""
+
+for cmd in build_commands.splitlines():
+    if cmd.startswith('#'):
+        continue
+
+    if cmd.startswith('cd '):
+        path = cmd[3:].strip()
+        print('Change current path:', path)
+        os.chdir(path)
+
+    elif cmd.startswith('pyarmor '):
+        print('Execute: ', cmd)
+        args = shlex.split(cmd[8:].strip())
+        pyarmor_run(args)

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

@@ -135,16 +135,6 @@ class Commander:
         #     action="store_const", const='std',
         #     help='genetate standard obfuscated scripts'
         # )
-        # group.add_argument(
-        #     '--ecc', dest='target', default='std',
-        #     action="store_const", const='ecc',
-        #     help='genetate scripts with embedded C code'
-        # )
-        # group.add_argument(
-        #     '--vmc', dest='target', default='std',
-        #     action="store_const", const='vmc',
-        #     help='genetate scripts with vm C code'
-        # )
         group.add_argument(
             '--rft', dest='target', default='std',
             action="store_const", const='rft',
@@ -158,7 +148,38 @@ class Commander:
         group.add_argument(
             '--mini-rft', dest='target', default='std',
             action="store_const", const='mini-rft',
-            help='genetate high performance refactor scripts'
+            help='generate scripts by combining --rft and --mini'
+        )
+        group.add_argument(
+            '--vmc', dest='target', default='std',
+            action="store_const", const='vmc',
+            help='genetate scripts with vmc code'
+        )
+        group.add_argument(
+            '--vmc-rft', dest='target', default='std',
+            action="store_const", const='vmc-rft',
+            help='generate scripts by combining --rft and --vmc'
+        )
+        group.add_argument(
+            '--ecc', dest='target', default='std',
+            action="store_const", const='ecc',
+            help='genetate scripts with embedded C code'
+        )
+        group.add_argument(
+            '--ecc-rft', dest='target', default='std',
+            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',
@@ -338,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')
 
@@ -366,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')
@@ -412,6 +437,8 @@ class Commander:
             logger.info('build target %s ...', args.target)
             output = args.output if args.output else 'dist'
             self._build(project, args.target, output)
+            if args.target.startswith('std'):
+                self._cmd_gen(args)
             logger.info('build target %s end', args.target)
 
     def _build(self, project, target, output, value=None):
@@ -420,6 +447,25 @@ class Commander:
         m = Pytransform3.init(self.ctx)
         m.pre_build(args)
 
+    def _cmd_gen(self, args):
+        """If build target is std, then call `pyarmor gen`
+
+        It will obfuscate the scripts with `pyarmor_runtime.so`
+
+        Most of obfuscated options are got from config file, not from
+        command line
+
+        Option `--pack` may be still got from command line
+        """
+        from .generate import Builder
+        from .plugin import Plugin
+
+        ctx = self.ctx
+        builder = Builder(ctx)
+        Plugin.install(ctx)
+        builder.process(args)
+        Plugin.post_build(ctx)
+
     def cmd_env(self, ctx, args):
         """Check and change pyarmor settings
 

{pyarmor_cli-9.2.0 → 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.0 → 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.0 → pyarmor_cli-9.2.2}/pyarmor/cli/default.cfg

@@ -3,14 +3,14 @@
 ;; Pyarmor version
 major = 9
 minor = 2
-patch = 0
+patch = 2
 
-;; Compatible core version
+;; Compatible core version for package: pyarmor.cli.core
 cli.core = 8.1.0
-mini.core = 2.0
 
-;; ecc.core = 1.0
-;; vmc.core = 1.0
+;; Compatible core version for package: pyarmor.mini
+;; Which is required to run MINI, VMC, or ECC mode scripts
+mini.core = 3.0
 
 ;; Deprecated since Pyarmor 8.2.5
 ; cli.runtime = 3.2.5

{pyarmor_cli-9.2.0 → 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.0 → 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.0 → 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.0 → pyarmor_cli-9.2.2}/pyarmor/cli/register.py

@@ -498,7 +498,7 @@ class WebRegister(Register):
         conn.request("GET", url[k:])
         return conn.getresponse()
 
-    def check_request_interval(self, delta=30.0):
+    def check_request_interval(self, delta=30.0, activation=False):
         """Make sure no more than 2 requests in 1 minute"""
         tspath = os.path.join(self.ctx.reg_path, 'last_register')
         try:
@@ -509,8 +509,10 @@ class WebRegister(Register):
             from time import sleep, time
             d = delta - (time() - st.st_mtime)
             if d > 0:
-                logger.warning('caution: this activation file can only '
-                               'be used no more than 10 times')
+                if activation:
+                    logger.warning(
+                        'caution: this activation file "%s" can only '
+                        'be used no more than 10 times', activation)
                 logger.info('waiting for %d seconds', d)
             while time() - st.st_mtime < delta:
                 logger.info('waiting ...')

{pyarmor_cli-9.2.0 → pyarmor_cli-9.2.2}/pyarmor/cli/resource.py

@@ -109,22 +109,34 @@ class FileResource(Resource):
         return self.pyext.lower() == '.pyc'
 
     def _get_encoding(self, encoding):
+        # Maybe: from tokenize import detect_encoding
         from codecs import BOM_UTF8
         from re import search as research
+
+        def find_encoding(line):
+            try:
+                pat = r'coding[=:]\s*([-\w.]+)'
+                n = line.find(b'\n')
+                if n > -1:
+                    m = research(pat, line[:n].decode())
+                    if m:
+                        return m.group(1)
+                    if line[n+1] == 35:
+                        k = n + 1
+                        n = line.find(b'\n', k)
+                        m = research(pat, line[k:n].decode())
+                        if m:
+                            return m.group(1)
+            except Exception:
+                # Ignore decoding error or index error
+                pass
+
         with open(self.fullpath, 'rb') as f:
             line = f.read(80)
             if line and line[:3] == BOM_UTF8:
                 return 'utf-8'
             if line and line[0] == 35:
-                n = line.find(b'\n')
-                m = research(r'coding[=:]\s*([-\w.]+)', line[:n].decode())
-                if m:
-                    return m.group(1)
-                if n > -1 and len(line) > (n+1) and line[n+1] == 35:
-                    k = n + 1
-                    n = line.find(b'\n', k)
-                    m = research(r'coding[=:]\s*([-\w.]+)', line[k:n].decode())
-                    return m and m.group(1)
+                encoding = find_encoding(line) or encoding
         return encoding
 
     def readlines(self, encoding=None):

{pyarmor_cli-9.2.0 → 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.0 → 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.0
+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.0 → pyarmor_cli-9.2.2}/pyarmor.cli.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ pyarmor.cli.egg-info/requires.txt
 pyarmor.cli.egg-info/top_level.txt
 pyarmor/cli/__init__.py
 pyarmor/cli/__main__.py
+pyarmor/cli/batch.py
 pyarmor/cli/bootstrap.py
 pyarmor/cli/bug.py
 pyarmor/cli/command.py

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

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