Merge pull request #10 from manthey/refactor-args

Refactor some argument parsing.

Author: manthey

.gitignore

@@ -101,4 +101,5 @@ ENV/
 .mypy_cache/
 
 # Our list
+.pytest_cache/
 modules_pyexe_list.py

CHANGELOG.md

@@ -0,0 +1,91 @@
+# Release Notes
+
+## Version 12
+
+### Changes
+
+- Removed some modules that can't be imported without Scintilla.DLL.
+- Ignore standard Python command line options that aren't implemented.
+- The banner in interactive mode better matches native Python.
+
+### Bug Fixes
+
+- Fixed raw input on Python 3.
+- Fixed handling - on the command line.
+- Fixed combining -i with -c or -m.
+- Unbuffered interactive mode fixed on Python 3.
+
+### Build
+
+- Added tests to show that pyexe's behavior is the same as native Python.
+- Added tests for help, reading from stdin, reading in tty mode, hyphen mode, and the `--all` flag.
+
+## Version 11
+
+### Changes
+
+- Explicitly include `six`, `pip`, and `setuptools`
+- Update to the Python 2.7.14, 3.5.3, 3.6.4.
+- Update to pywin32 223, pip 10.0.1, psutil 5.4.5, setuptools 39.0.1, six 1.11.0
+- Improved version reporting (PR #9)
+- More of pywin32 is included thanks to PyInstaller
+
+### Build
+
+- Moved to GitHub
+- Built for Python 2.7, 3.5, 3.6 in 32-bit and 64-bit variants
+- Built on appveyor using PyInstaller
+- Add CI tests for installing and importing pip libraries, testing multiprocessing.
+
+## Version 10
+
+- Upgraded to Python 2.7.9
+- Added psutil 2.1.3 
+- Added support for the `-m` option.
+- Turned off the optimization flag when building.  Having it on interferes with some modules (such as sympy) which rely on docstring manipulation.
+
+## Version 9:
+- Revert changes to global dictionaries to fix multiprocessing forking.
+
+## Version 8
+
+- Fixed a bug introduced in version 7 when renaming the variable `loc`.
+
+## Version 7:
+
+- Added support for `-E`, `-x`, and `--version` options.
+- Changed how the globals / locals dictionaries are used for greater consistency in different execution modes.
+- Accept multiple single letter command line options grouped together.
+
+## Version 6
+
+- Added support for multiprocessing forking
+- Added support for non-tty direct usage (input and output pipes, for instance)
+- Added support for `-i` option and `PYTHONINSPECT` environment variable.
+- Turned off "frozen" flag in the executable.
+- Upgraded pywin32 to build 219 (was 218).
+- Upgraded to Python 2.7.8
+- Added `import site` to interactive prompts to get help and other commands added to the builtins.
+- Added support for unbuffered `-u` option and `PYTHONUNBUFFERED` environment variable.
+
+## Version 5
+
+- Imported submodules, such as logging.handlers, since they weren't included implicitly.
+
+## Version 4
+
+- Upgraded to Python 2.7.5
+
+## Version 3
+
+- Added the program path to `sys.path` when running a program, and `''` to `sys.path` when running direct or interpreted.
+
+## Version 2
+
+- fixed an issue with __file__ and __name__
+
+## Version 1
+
+- initial release
+
+

appveyor.yml

@@ -51,7 +51,14 @@ test_script:
   - SET PATH=%ORIGPATH%
   - pip install pytest
   - cd tests
-  - "python -m pytest -l --exe=..\\%OUTPUT%"
+  # Make sure we only have original files here.
+  - git clean -fxd .
+  - "python -m pytest -l --cache-clear --exe=..\\%OUTPUT%"
+  # We can test the tests against the master python.  We have to exclude a few
+  # tests that only work on the stand-alone build.  
+  # Make sure we only have original files here.
+  - git clean -fxd .
+  - 'python -m pytest -l --cache-clear --exe=%PYTHON%\python -k "not Version and not Help and not AllFlag"'
 
 deploy:
   - provider: GitHub

modules_pyexe.py

@@ -27,6 +27,14 @@
     'turtledemo', 'tcl', 'tk', 'Tkinter',
     # These cause test importation fail
     'idlelib', 'win32traceutil',
+    # These cause --all flag to fail
+    'pywin.debugger', 'pywin.dialogs.ideoptions',
+    'pywin.framework.dbgcommands', 'pywin.framework.editor',
+    'pywin.framework.interact', 'pywin.framework.intpyapp',
+    'pywin.framework.startup', 'pywin.framework.stdin',
+    'pywin.framework.winout', 'pywin.scintilla', 'pywin.tools.TraceCollector',
+    'win32com.axdebug.debugger', 'win32com.axdebug.dump',
+    'win32com.axscript.client.debug',
 ]
 # Exclude examples, tests, and Tk.  Some of these won't exist in the default
 # installation

py_version.py

@@ -2,5 +2,5 @@
 
 import sys
 
-Version = sys.version.split()[0] + '.11'
+Version = sys.version.split()[0] + '.12'
 Description = 'Stand-Alone Python Interpreter'

pyexe.py

@@ -15,6 +15,8 @@
     import modules_pyexe_list  # noqa, this is the output of modules_pyexe
     print(dir(modules_pyexe_list))  # for installers to include submodules
     # END IMPORT ALL MODULES
+    # Import modules which failed to be included in the auto-generated list.
+    import setuptools._vendor.pyparsing  # noqa
 
 
 def alternate_raw_input(prompt=None):
@@ -27,25 +29,26 @@ def alternate_raw_input(prompt=None):
     if prompt and len(prompt):
         sys.stderr.write(prompt)
         sys.stderr.flush()
-    return raw_input('')
+    return six.moves.input('')
 
 
 def print_version(details=1):
     """
     Print the current version.
 
-    Enter: details: if 2, print more details.
+    Enter: details: 0 if part of help, 1 for basic verison, 2 for more details.
     """
     from py_version import Version, Description
 
     print('%s, Version %s' % (Description, Version))
     if details > 1:
         print('Python %s' % (sys.version))
-        import importlib
         # pywin32
         import win32api
         fileinfo = win32api.GetFileVersionInfo(win32api.__file__, '\\')
         print('pywin32: %s' % str(fileinfo['FileVersionLS'] >> 16))
+        # Others
+        import importlib
         for module_name in ('pip', 'psutil', 'setuptools', 'six'):
             module = importlib.import_module(module_name)
             print('%s: %s' % (module_name, module.__version__))
@@ -54,65 +57,78 @@ def print_version(details=1):
 if hasattr(sys, 'frozen'):
     delattr(sys, 'frozen')
 Help = False
-DirectCmd = None
-ImportSite = True
-Interactive = 'check'
+NoSiteFlag = False
+Interactive = None
+InteractiveArgv = None
 PrintVersion = 0
-RunModule = False
+RunCommand = None
+RunModule = None
 SkipFirstLine = False
 Start = None
 Unbuffered = False
 UseEnvironment = True
 skip = 0
 for i in six.moves.range(1, len(sys.argv)):  # noqa
-    if DirectCmd is not None:
-        break
     if skip:
         skip -= 1
         continue
     arg = sys.argv[i]
-    if arg.startswith('-') and arg[1:2] != '-':
+    if arg.startswith('-') and len(arg) > 1 and arg[1:2] != '-':
         for let in arg[1:]:
             if let == 'c':
-                DirectCmd = sys.argv[i+1+skip]
-                DirectArgv = ['-c'] + sys.argv[i+2+skip:]
+                RunCommand = sys.argv[i+1+skip]
+                RunCommandArgv = ['-c'] + sys.argv[i+2+skip:]
                 skip = len(sys.argv)
             elif let == 'E':
                 UseEnvironment = False
+            elif let == 'h':
+                Help = True
             elif let == 'i':
                 Interactive = True
             elif let == 'm' and i+1 < len(sys.argv):
                 RunModule = sys.argv[i+1+skip]
-                RunArgv = sys.argv[i+1+skip:]
+                RunModuleArgv = sys.argv[i+1+skip:]
                 skip = len(sys.argv)
                 break
             elif let == 'S':
-                ImportSite = False
+                NoSiteFlag = True
             elif let == 'u':
                 Unbuffered = True
             elif let == 'V':
                 PrintVersion += 1
             elif let == 'x':
                 SkipFirstLine = True
-            elif let in ('B', 'E', 'O', 's'):
+            elif let in ('b', 'B', 'd', 'I', 'O', 'q', 's', 'v'):
+                # ignore these options
+                pass
+            elif let in ('W', 'X'):
                 # ignore these options
+                skip += 1
                 pass
             else:
                 Help = True
+    elif arg == '--check-hash-based-pycs':
+        # ignore this option
+        skip += 1
+        pass
     elif arg == '--all':
         continue
-    elif arg == '--help' or arg == '-h' or arg == '/?':
+    elif arg == '--help' or arg == '/?':
         Help = True
     elif arg == '--version':
         PrintVersion += 1
+    elif arg == '-':
+        Interactive = 'check'
+        InteractiveArgv = ['-'] + sys.argv[i+1+skip:]
+        skip = len(sys.argv)
+        break
     elif arg.startswith('-'):
         Help = True
     elif not Start:
-        Start = i
+        Start = i + skip
         break
 if Help:
-    from py_version import Version, Description
-    print('%s, Version %s' % (Description, Version))
+    print_version(0)
     print('usage: %s [option] ... [-c cmd | -m mod | file | -] [arg] ...' % sys.argv[0])
     print("""Stand-alone specific options:
 --all attempts to import all modules.
@@ -129,24 +145,23 @@ def print_version(details=1):
 -x skips the first line of a source file.
 If no file is specified and stdin is a terminal, the interactive interpreter is
   started.""")
-    print(repr(sys.argv))
     sys.exit(0)
 if PrintVersion:
     print_version(PrintVersion)
     sys.exit(0)
-if Interactive == 'check' and UseEnvironment:
+if Interactive is not True and UseEnvironment:
     if os.environ.get('PYTHONINSPECT'):
-        Interactive = True
+        Interactive = 'check'
 if Unbuffered is False and UseEnvironment:
     if os.environ.get('PYTHONUNBUFFERED'):
         Unbuffered = True
+bufsize = 1 if sys.version_info >= (3, ) else 0
 if Unbuffered:
-    bufsize = 1 if sys.version_info >= (3, ) else 0
     sys.stdin = os.fdopen(sys.stdin.fileno(), 'r', bufsize)
     sys.stdout = os.fdopen(sys.stdout.fileno(), 'a+', bufsize)
     sys.stderr = os.fdopen(sys.stderr.fileno(), 'a+', bufsize)
 globenv = {}
-if ImportSite:
+if not NoSiteFlag:
     import site
     site.main()
 # Generate the globals/locals environment
@@ -162,52 +177,45 @@ def print_version(details=1):
         if SkipFirstLine:
             discard = fptr.readline()
         src = fptr.read()
-        # If we the simplified global dictionary, multiprocessing doesn't work
+        # If we use the simplified global dictionary, multiprocessing doesn't
+        # work (this should be investigated further)
         six.exec_(src)
 elif RunModule:
     import runpy
-    sys.argv[:] = RunArgv
+    sys.argv[:] = RunModuleArgv
     runpy.run_module(RunModule, run_name='__main__')
-elif DirectCmd:
+elif RunCommand is not None:
     sys.path[0:0] = ['']
-    sys.argv[:] = DirectArgv
-    six.exec_(DirectCmd, globenv)
-else:
-    if Interactive == 'check':
-        Interactive = sys.stdin.isatty()
+    sys.argv[:] = RunCommandArgv
+    six.exec_(RunCommand, globenv)
+elif Interactive is None:
+    Interactive = 'check'
+if Interactive:
     sys.path[0:0] = ['']
-    if Interactive:
+    if InteractiveArgv:
+        sys.argv[:] = InteractiveArgv
+    if Interactive is True or sys.stdin.isatty():
         import code
         cons = code.InteractiveConsole(locals=globenv)
         if not sys.stdout.isatty():
             cons.raw_input = alternate_raw_input
             if not Unbuffered:
-                sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
-                sys.stderr = os.fdopen(sys.stderr.fileno(), 'w', 0)
-        cons.interact()
-    elif False:
-        # This will run code as it comes it, rather than wait until it has
-        # parsed it all; it doesn't seem to be what the main python interpreter
-        # ever does, however.
-        import code
-        interp = code.InteractiveInterpreter(locals=globenv)
-        src = []
-        for line in sys.stdin:
-            if not len(line.rstrip('\r\n')):
-                continue
-            if line.startswith('#'):
-                continue
-            if line.rstrip('\r\n')[0:1] not in (' ', '\t'):
-                if len(src):
-                    interp.runsource(''.join(src), '<stdin>')
-                    src = []
-            src.append(line)
-        if len(src):
-            interp.runsource(''.join(src))
-    elif not Start:
+                sys.stdout = os.fdopen(sys.stdout.fileno(), 'a+', bufsize)
+                sys.stderr = os.fdopen(sys.stderr.fileno(), 'a+', bufsize)
+        banner = 'Python %s' % sys.version
+        if not NoSiteFlag:
+            banner += '\nType "help", "copyright", "credits" or "license" for more information.'
+        if RunModule or RunCommand:
+            banner = ''
+        kwargs = {}
+        if sys.version_info >= (3, 6):
+            kwargs['exitmsg'] = ''
+        cons.interact(banner=banner, **kwargs)
+    else:
         src = sys.stdin.read()
         # This doesn't work the way I expect for some reason
         #  interp = code.InteractiveInterpreter(locals=globenv)
         #  interp.runsource(src, '<stdin>')
         # But an exec works fine
+        globenv['__file__'] = '<stdin>'
         six.exec_(src, globenv)