pyarmor.cli 9.2.6__3-py3-none-any.whl

pyarmor/cli/shell.py

@@ -0,0 +1,481 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#############################################################
+#                                                           #
+#      Copyright @ 2024 -  Dashingsoft corp.                #
+#      All rights reserved.                                 #
+#                                                           #
+#      Pyarmor                                              #
+#                                                           #
+#      Version: 9.1.0 -                                     #
+#                                                           #
+#############################################################
+#
+#
+#  @File: cli/shell.py
+#
+#  @Author: Jondy Zhao (pyarmor@163.com)
+#
+#  @Create Date: Fri Nov 15 10:52:00 CST 2024
+#
+import configparser
+import cmd
+import shlex
+
+from .model import SECTIONS, GROUPS
+
+
+class CfgEntity:
+    """Store option to cfg file"""
+
+    def __init__(self, cfgfiles, encoding=None):
+        self._cfgfiles = cfgfiles
+        self._reader = None
+        self._writer = None
+        self._index = -1
+        self._encoding = encoding
+
+    def _load_cfg(self, filenames):
+        cfg = configparser.ConfigParser(
+            empty_lines_in_values=False,
+            interpolation=configparser.ExtendedInterpolation(),
+        )
+        cfg.read(filenames, encoding=self._encoding)
+        return cfg
+
+    @property
+    def cfgfile(self):
+        return self._cfgfiles[self._index]
+
+    @property
+    def reader(self):
+        if self._reader is None:
+            self._reader = self._load_cfg(self._cfgfiles)
+        return self._reader
+
+    @property
+    def writer(self):
+        if self._writer is None:
+            self._writer = self._load_cfg(self.cfgfile)
+        return self._writer
+
+    def store(self, sect, opt, value):
+        for cfg in (self.writer, self.reader):
+            if not cfg.has_section(sect):
+                cfg.add_section(sect)
+            cfg.set(sect, opt, value)
+
+    def fetch(self, sect, opt):
+        cfg = self.reader
+        if cfg.has_section(sect):
+            return cfg[sect].get(opt, None)
+
+    def remove(self, sect, opt=None):
+        for cfg in (self.writer, self.reader):
+            if cfg.has_section(sect):
+                if opt is None:
+                    cfg.remove_section(sect)
+                else:
+                    cfg.remove_option(sect, opt)
+
+    def reset(self, index):
+        if self._index == index:
+            return
+        self._index = index
+        self._reader = self._writer = None
+
+    def save(self):
+        with open(self.cfgfile, 'w', encoding=self._encoding) as f:
+            self.writer.write(f)
+
+
+class Domain:
+
+    def __init__(self, name, default='pyarmor'):
+        self.name = name
+        self._dirty = False
+
+        self._sections = []
+        self._groups = []
+
+        self._default = Section(default, parent=self)
+        self._cfgentity = None
+        self._children = None
+
+    @property
+    def qualname(self):
+        return self.name
+
+    @property
+    def title(self):
+        return '(%s) ' % self.name
+
+    @property
+    def dirty(self):
+        return self._dirty
+
+    @dirty.setter
+    def dirty(self, value):
+        self._dirty = value
+
+    @property
+    def groups(self):
+        for x in self._groups:
+            yield x
+
+    @property
+    def sections(self):
+        for x in self._sections:
+            yield x
+
+    @property
+    def options(self):
+        if self._default:
+            for x in self._default.options:
+                yield x
+
+    @property
+    def children(self):
+        if self._children is None:
+            items = {x.name: x for x in self.groups}
+            items.update({x.name: x for x in self.sections})
+            self._children = items
+        return self._children
+
+    @property
+    def cfgentity(self):
+        return self._cfgentity
+
+    def link(self, cfgentity):
+        self._cfgentity = cfgentity
+
+    def save(self, force=False):
+        cfgentity = self._cfgentity
+        if (self.dirty or force) and cfgentity:
+            cfgentity.save()
+            self._dirty = False
+
+    def add_section(self, name):
+        if self._default and self._default.name == name:
+            return
+        self._sections.append(Section(name, parent=self))
+
+    def add_group(self, name, sections):
+        group = Group(name, parent=self)
+        group.add_sections(sections)
+        self._groups.append(group)
+
+
+class Section:
+
+    def __init__(self, name, parent=None):
+        self.parent = parent
+        self.name = name
+        self.models = SECTIONS.get(name, [])
+        self._options = None
+        self._children = {}
+
+    @property
+    def qualname(self):
+        parent = self.parent
+        name = self.name
+        return ':'.join([parent.qualname, name])
+
+    @property
+    def title(self):
+        return '({0})[{1}] '.format(*self.qualname.split(':', 1))
+
+    @property
+    def options(self):
+        if self._options is None:
+            self._options = [x.factory(self) for x in self.models]
+
+        for x in self._options:
+            yield x
+
+    @property
+    def children(self):
+        return self._children
+
+    @property
+    def cfgentity(self):
+        return self.parent.cfgentity
+
+    def store(self, opt, value):
+        self.cfgentity.store(self.name, opt, value)
+
+    def fetch(self, opt):
+        return self.cfgentity.fetch(self.name, opt)
+
+    def remove(self, opt):
+        self.cfgentity.remove(self.name, opt)
+
+
+class Group(Section):
+
+    def __init__(self, name, parent=None, sections=None):
+        super().__init__(name, parent=parent)
+        self._groups = []
+        self._sections = []
+
+    @property
+    def group(self):
+        for x in self._group:
+            yield x
+
+    @property
+    def sections(self):
+        for x in self._sections:
+            yield x
+
+    @property
+    def children(self):
+        if self._children is None:
+            items = {x.name: x for x in self.groups}
+            items.update({x.name: x for x in self.sections})
+            self._children = items
+        return self._children
+
+    def add_group(self, name, sections):
+        group = Group(name, parent=self)
+        group.add_sections(sections)
+        self._group.append(group)
+
+    def add_sections(self, sections):
+        self._sections.extend([
+            Section(x, parent=self) for x in sections
+        ])
+
+
+class PyarmorShell(cmd.Cmd):
+
+    intro = 'Type help or ? to list commands.\n'
+    col = 60
+
+    def __init__(self, ctx, domain='local'):
+        super().__init__()
+        self.ctx = ctx
+        self._entity = CfgEntity([
+            ctx.default_config,
+            ctx.global_config,
+            ctx.local_config
+        ], encoding=ctx.encoding)
+        self._domains = self._init_domains()
+        self._domain = self._section = self._domains[domain]
+
+    def _init_domains(self):
+        gs = Domain('global')
+        ls = Domain('local')
+        ps = Domain('project', default='project')
+
+        gs.link(self._entity)
+        ls.link(self._entity)
+        ps.link(self._entity)
+
+        sections = 'finder', 'builder', 'runtime', 'pack'
+        [(gs.add_section(x), ls.add_section(x)) for x in sections]
+
+        for domain in (gs, ls):
+            for name in ('filter', 'bcc'):
+                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}
+
+    @property
+    def section(self):
+        return self._section
+
+    @property
+    def prompt(self):
+        return self.section.title
+
+    def get_sections(self, name=''):
+        obj = self.section
+        sects = [x for x in getattr(obj, 'groups', [])]
+        sects.extend([x for x in getattr(obj, 'sections', [])])
+        return (sects if name in ('-a', '*', '') else
+                [x for x in sects if x.name.startswith(name)])
+
+    def get_options(self, name=''):
+        options = [x for x in self.section.options]
+        return (options if name in ('-a', '*', '') else
+                [x for x in options if x.name.startswith(name)])
+
+    def printf(self, *args):
+        print(*args)
+
+    def find(self, opt):
+        for item in self.section.options:
+            if item.name == opt:
+                return item
+
+    def save(self):
+        self._domain.save()
+
+    def do_exit(self, arg=None):
+        """Finish config and exit"""
+        self.save()
+        self.printf('')
+        self.printf('Thank you for using Pyarmor')
+        return True
+    do_EOF = do_q = do_exit
+
+    def do_use(self, arg):
+        """Switch domain: global, local, project"""
+        names = list(self._domains.keys())
+        if arg not in names:
+            self.printf('Invalid name: ', arg)
+            self.printf('Please type one of', str(names))
+        elif self._domain.name == arg:
+            pass
+        else:
+            self._domain.save()
+            if arg == 'global':
+                self._entity.reset(index=1)
+            elif self._domain.name == 'global':
+                self._entity.reset(index=-1)
+            self._domain = self._domains[arg]
+            self._section = self._domain
+
+    def do_ls(self, arg):
+        """List all the available items in current domain"""
+        sections = self.get_sections(arg)
+        if sections:
+            self.printf('Sections:')
+            self.columnize([x.name for x in sections], self.col)
+            self.printf('')
+
+        options = self.get_options(arg)
+        if options:
+            self.printf('Options:')
+            self.columnize([x.name for x in options], self.col)
+            self.printf('')
+
+    def do_cd(self, arg):
+        """Switch to section, .. to parent, blank to top"""
+        if arg == '..':
+            if self._section is not self._domain:
+                self._section = self._section.parent
+        elif arg:
+            item = self.section.children.get(arg)
+            if item:
+                self._section = item
+            else:
+                self.printf('No item', repr(arg))
+        else:
+            self._section = self._domain
+
+    def do_get(self, arg):
+        """Show option value"""
+        options = self.get_options(arg)
+        if not options:
+            self.printf('No found any', repr(arg))
+            return
+        for opt in options:
+            value = opt.value
+            if value is not None:
+                self.printf('%-20s= %s' % (opt.name, value))
+
+    def do_info(self, arg):
+        """List sections, options, and all the values"""
+        if arg == '':
+            self.do_ls('')
+            self.do_get('')
+            return
+        item = self.section.children.get(arg)
+        if item:
+            self.do_cd(arg)
+            self.do_ls('')
+            self.do_get('')
+            self.do_cd('..')
+        else:
+            item = self.find(arg)
+            if item:
+                self.printf(item.usage())
+                self.do_get(arg)
+            else:
+                self.printf('No found', arg)
+
+    def do_set(self, arg):
+        """Set option value"""
+        if arg.find(' ') == -1:
+            self.printf('Missing value')
+            return
+        name, value = arg.split(None, 1)
+        item = self.find(name)
+        if item:
+            c = value[:1]
+            if c in ('"', "'"):
+                value = value.strip(c)
+            try:
+                item.value = value
+                self._domain.dirty = True
+            except ValueError as e:
+                self.printf(str(e))
+        else:
+            self.printf('No found', name)
+
+    def do_reset(self, arg):
+        """Reset option in the domain"""
+        if arg in ('', '*'):
+            self.printf('Please specify one option')
+            return
+        item = self.find(arg)
+        if item:
+            item.reset()
+            self._domain.dirty = True
+        else:
+            self.printf('No found', arg)
+
+    def do_push(self, arg, silent=False):
+        """Append new value to option"""
+        if arg.find(' ') == -1:
+            self.printf('Missing value')
+            return
+        name, value = arg.split(None, 1)
+        item = self.find(name)
+        if item:
+            for x in shlex.split(value):
+                try:
+                    item.push(x)
+                except ValueError as e:
+                    self.printf(str(e))
+                    break
+            else:
+                self._domain.dirty = True
+                self.do_get(name)
+        else:
+            self.printf('No found', name)
+
+    def do_pop(self, arg):
+        """Remove one choice from option"""
+        if arg.find(' ') == -1:
+            self.printf('Missing value')
+            return
+        name, value = arg.split(None, 1)
+        item = self.find(name)
+        if item:
+            for x in shlex.split(value):
+                item.pop(x)
+            self._domain.dirty = True
+            self.do_get(name)
+        else:
+            self.printf('No found', name)
+
+
+if __name__ == '__main__':
+    from os.path import join as joinpath, abspath, expanduser
+
+    from .context import Context
+
+    home = joinpath('~', '.pyarmor')
+    home = abspath(expanduser(home))
+
+    ctx = Context(home)
+    PyarmorShell(ctx).cmdloop()

pyarmor_cli-9.2.6.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.1
+Name: pyarmor.cli
+Version: 9.2.6
+Summary: A comand line tool to obfuscate python scripts
+Home-page: https://github.com/dashingsoft/pyarmor
+Author: Jondy Zhao
+Author-email: pyarmor@163.com
+License: Free To Use But Restricted
+Keywords: protect obfuscate encrypt obfuscation distribute
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: Free To Use But Restricted
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Software Distribution
+Requires-Dist: pyarmor.cli.core ~=8.1.1
+
+Protect Python Scripts By Pyarmor
+=================================
+
+Pyarmor is a command line tool used to obfuscate python scripts, bind obfuscated scripts to fixed machine or expire obfuscated scripts.
+
+Key Features
+------------
+
+* The obfuscated script is still a normal `.py` script, in most of cases the original python scripts can be replaced with obfuscated scripts seamlessly.
+* Provide many ways to obfuscate the scripts to balance security and performance
+* Rename functions/methods/classes/variables/arguments, irreversible obfuscation
+* Convert part of Python functions to C function, compile to binary by high optimize option, irreversible obfuscation
+* Bind obfuscated scripts to fixed machine or expire obfuscted scripts
+* Protect obfuscated scripts by Themida (Only for Windows)
+
+Support Platforms
+-----------------
+
+* Python 3.7~3.15
+* Windows
+* Many linuxs, include embedded systems
+* Apple Intel and Apple Silicon
+
+Quick Start
+-----------
+
+Install::
+
+    pip install pyarmor
+
+Obfuscate the script `foo.py`::
+
+    pyarmor gen foo.py
+
+This command generates an obfuscated script `dist/foo.py` like this:
+
+.. code:: python
+
+    from pyarmor_runtime import __pyarmor__
+    __pyarmor__(__name__, __file__, b'\x28\x83\x20\x58....')
+
+Run it::
+
+    python dist/foo.py
+
+More Resources
+--------------
+
+- `Home <https://github.com/dashingsoft/pyarmor>`_
+- `Website <http://pyarmor.dashingsoft.com>`_
+- `中文网站 <http://pyarmor.dashingsoft.com/index-zh.html>`_
+- `Issues <https://github.com/dashingsoft/pyarmor/issues>`_
+- `Documentation <https://pyarmor.readthedocs.io/>`_

pyarmor_cli-9.2.6.dist-info/RECORD

@@ -0,0 +1,30 @@
+pyarmor/cli/__init__.py,sha256=hsPY2kypxxO4MlApFlgRoO1rRjzUr2r8jZxWZxibXrc,1153
+pyarmor/cli/__main__.py,sha256=0IhOmOhs91SSYOALE-hz84LjAVxfe0XtokLSn3xxUvU,26604
+pyarmor/cli/batch.py,sha256=51uBFWRdQk3Fa1l1EdLj-KwN7fwY9D6tfJXpR2WRSg8,1671
+pyarmor/cli/bootstrap.py,sha256=C0RIl-PxJVEVISMGMgotZo8Q-jZQ8ztN7-IYxu4O-C0,7189
+pyarmor/cli/bug.py,sha256=fwT_2oPi4rcLN5ziYEuZS2IKLljt05hKEbQM1fjkM88,4872
+pyarmor/cli/command.py,sha256=n2j0Luwm5WXf5wt_NBmmbhzi7fmwnr9X_tgw7fhcSXg,18212
+pyarmor/cli/config.py,sha256=Roti0bOPzUELm3zp_XLCUphZ_eFzhTGTZVcN_dJ1_lc,10795
+pyarmor/cli/context.py,sha256=TogVCF9-jDyYJgLn9YQVlIYgtzB50OC5dOSKvOsHcww,24388
+pyarmor/cli/core.data.1,sha256=TwImKy17vfR04b_Za6rN6DPDGtx8fdHz1ANAbDUllho,299632
+pyarmor/cli/core.data.2,sha256=43qFFxPg_50oMcx1GETBMOZqKYKy1le8bsE1VeJz2wg,231091
+pyarmor/cli/core.data.3,sha256=So9jEsfw2H3QEMkzR6IffB1fWPCAhxMtP1wuPl160G8,171453
+pyarmor/cli/default.cfg,sha256=xG-o3LgzIrZpwWumaWsuizdqTP_xpEfBQ9tTKUtz4YE,14080
+pyarmor/cli/docker.py,sha256=f82zF2LgLXtCLI0w_EtMGoKDuejJFDQbSb_zhoHDSss,6469
+pyarmor/cli/generate.py,sha256=zLp5bqYffrRA_uEJzcXsydaWvVIadiZoEXzRzAvSmrM,9445
+pyarmor/cli/hdinfo.py,sha256=JK9i-4UrU-4bljzi3Z_0pKKHqHlT9sZde8wx4SP8BG8,2537
+pyarmor/cli/merge.py,sha256=0QqQ8idac5OVvzw6tOtdx5qWlSdD1NzvmWeCiLkvLns,7282
+pyarmor/cli/mixer.py,sha256=i4IrXukoG5L3V3Wv5BgDSTkNU5NB03-Q4bgsWwug6LY,3956
+pyarmor/cli/model.py,sha256=K6Fec0tgRYtoXZgsmoaEq-k0-ZOg1YQPQS6ahTUFsDE,10933
+pyarmor/cli/plugin.py,sha256=Nxm249i9UbwUhLuirwIlKw9k_FnVzd0mlo4_ATPYjz4,11117
+pyarmor/cli/project.py,sha256=FNNxKI4dHliW6ziPDrYILeOM9-gQW89rY72GE2ixI70,37463
+pyarmor/cli/public_capsule.zip,sha256=1r4u42ixfocGPMQc0OklpoHF3nvVW6GA1f4SwcEJWVI,2487
+pyarmor/cli/register.py,sha256=OuBjyD8uxGRJhs2ke29zqKW3ee3_JR5FqbkSufkbdkM,39973
+pyarmor/cli/repack.py,sha256=J9okR-1NdgROcRvpsvDTir11eDAH0JXfbiOGl51gphE,28679
+pyarmor/cli/resource.py,sha256=NVVkn2VNfv8K55pRPWaGfvchl3Nu9JLaoifm6qohcWw,8630
+pyarmor/cli/shell.py,sha256=W5fcMbYXdTKB77loHsPeg2vEVoWJPHLfNYHG-4DT-Y4,13268
+pyarmor_cli-9.2.6.dist-info/METADATA,sha256=gy2eI0LKdxZVRIcjHQ2sZKZ6sPwP0hGZ23EDoy1LsS8,2375
+pyarmor_cli-9.2.6.dist-info/WHEEL,sha256=kaMOOuGDRs3OZA3I9YTs0dJFtrnzzh8BHRx5jSb3e54,100
+pyarmor_cli-9.2.6.dist-info/entry_points.txt,sha256=QDU0TXJn8QG3tkLK4_hoSVW7bvbrMca8hDkIMyIDwow,93
+pyarmor_cli-9.2.6.dist-info/top_level.txt,sha256=UE1ovZ_90YzwF_lZ3LV7o8HKLe-RgzUaUUvdH5UTUus,8
+pyarmor_cli-9.2.6.dist-info/RECORD,,

pyarmor_cli-9.2.6.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Build: 3
+Tag: py3-none-any
+

pyarmor_cli-9.2.6.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pyarmor = pyarmor.cli.__main__:main
+pyarmor-auth = pyarmor.cli.docker:main

pyarmor_cli-9.2.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyarmor