Changeset 761

Timestamp:

07/21/07 23:21:58 (1 year ago)

Author:

robin

Message:

Default pyrun method (runex) provides help and extended features.

Files:

• pyrun/trunk/examples/command_line_use.rst (added)
• pyrun/trunk/pyrun.html (modified) (3 diffs)
• pyrun/trunk/pyrun.py (modified) (7 diffs)
• pyrun/trunk/pyrun.rst (modified) (1 diff)
• pyrun/trunk/pyrun.wpr (added)

pyrun/trunk/pyrun.html

@@ -337 +337 @@
-<li><a class="reference" href="#pyrun" id="id1" name="id1">pyrun</a></li>
-<li><a class="reference" href="#installation" id="id2" name="id2">Installation</a></li>
-
-
+
+
+
-</ul>
-</li>
-
+
+
+
+
+
-</ul>
-</div>
@@ -407 +412 @@
-</div>
-<div class="section">
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-<p>All of the command line programs provided by this package are essentially thin
-wrappers around the <cite>pyrun.discover_and_run</cite> function. This section provides
@@ -559 +620 @@
-</div>
-<div class="section">
-5
+8
-<p>NEXTREVISION</p>
-<blockquote>

pyrun/trunk/pyrun.py

@@ -1 @@
-
+types, 
-
-from os.path import abspath, normpath, join, expanduser, expandvars, dirname
@@ -232 +232 @@
-        ia = i + startpos
-        a = argv[ia]
-
-
-
-
+
+
+
+
+
-            return
-        else:
@@ -284 +285 @@
-    pthset = set([])
-
-
+
+
-    for ia, a in enumerate_argv_args(args, offset):
-
-
+
-        minfo = path_moduleinfo(a)
-        if minfo:
-            # if its a legitemate python module file, import it with the
-            # path we have discovered so far.
-            if minfo[1] in sys.modules:
-                continue
-
-            minfos.append(minfo)
-            a = minfo[0]
@@ -308 +304 @@
-    pthextend.extend(newpaths)
-
-
-
-
-
+ + 1
+
+
+, modify_sys=True
-    """Discover package paths and run the last module listed in argv.
-
@@ -319 +315 @@
-    Uses runpy.run_module to run the module as though it was '__main__'.
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    argv = argv or sys.argv[:]
-
-    pthextend, minfos, ia = discover_path(1, *argv)
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    return pthextend, minfos, ia
-
-
+def runex(argv=None):
+    """Provides Extened `pyrun` features on the command line."""
+
+    # Process the command line arguments.
+    import optparse
+    parser = optparse.OptionParser(usage=USAGE_runex)
+    default_opts = {}
+    for shrt, kw in OPTIONS_runex:
+        default_opts[shrt[1]] = kw['default']
+        parser.add_option(shrt, **kw)
+
+    parser.disable_interspersed_args()
+
+    opts, args = parser.parse_args()
+    argv = args[:]
+    argv.insert(0, None)
+
+    try:
+        pthextend, minfos, ia = discover_path(1, *argv)
+
+        # If there are no unconsumed arguments: We have already determined
+        # the user does not want to run a module. So we are done.
+
+        assert ia <= len(argv), (
+                'ia=%s, argv="%s"'
+                ) % (ia, str(argv)
+                        )
+        if ia == len(argv):
+            argv.append('--')
+
+        # Unconsumed arguments exist and start at index `ia` in `argv` As a
+        # convenience we allow any *one* of the pyrun options to be used as to
+        # delimit the end of the discovery path. This means that we need to
+        # examine the first remaining option and determine whether its intended
+        # for pyrun and if so whether it means we have more to do. But, and
+        # this is *IMPORTANT*, if any option was set before the discovery path
+        # it is assumed to be for the target module and hence is ignored. For
+        # example ``pyrun -m bar ~/foo -m 12`` means search under `~/foo` for
+        # package paths, then run module `bar` with an argv of:
+        #   ``['bar', '-m', '12']``
+        #
+
+        if argv[ia] == '--':
+            del argv[ia]
+        else:
+            # All pyrun options are short options.
+            nextopt = argv[ia][1:]
+            if nextopt in default_opts:
+
+                # It's possibly a pyrun option.
+
+                # Distinguish between those arguments that require values and
+                # those that don't
+                if nextopt in flagOPTIONS_runex:
+
+                    setattr(opts, nextopt, not default_opts[nextopt])
+                    del argv[ia]
+
+                else:
+                    # if its not a flag and it is a pyrun option then it
+                    # takes a single argument.
+                    if len(argv) < ia+1:
+                        print ('The `-%s` pyrun option requires a module name'
+                                ) % nextopt
+                        return -1
+
+                    setattr(opts, nextopt, argv[ia+1])
+                    del argv[ia:ia+2]
+
+            # else: its definitely *not* a pyrun option
+
+        modname = opts.m or (minfos and minfos[0][1]) or ''
+
+        target_argv = []
+        if modname:
+            target_argv.append(modname)
+            target_argv.extend(argv[ia:])
+        def run_module():
+            if opts.n:
+                print 'execution of module disabled by user options'
+                return 0
+            if not target_argv:
+                print 'argv is empty'
+                return 0
+            import runpy
+            sys.argv[:] = target_argv[:]
+            sys.path[0:0] = pthextend[:]
+            return runpy.run_module(
+                    modname, run_name='__main__', alter_sys=True
+                    )
+        if opts.d:
+            import pdb
+            pdb.set_trace()
+        if opts.i:
+            banner=''
+            if opts.p:
+                banner += 'Discovered paths:\n\t%s' % '\n\t'.join(
+                        pthextend
+                        )
+            if opts.P:
+                banner += '\n\nPYTONPATH=%s' % os.pathsep.join(
+                        pthextend
+                        )
+            if opts.p or opts.P:
+                banner += '\n\n'
+            banner += """\
+Call `run_module` with no arguments to execute the implied or explicit
+module. You can safely manipulate the target sys.path and sys.argv before
+calling `run_module` by updating `target_argv` and `pthextend` in place.
+`minfos` is a list of tuples describing any module files you listed in
+the discovery path."""
+            import code
+            code.interact(banner=banner, local=locals())
+        if pthextend and opts.p and not opts.i:
+            for p in pthextend:
+                print p
+        if pthextend and opts.P and not opts.i:
+            print os.pathsep.join(pthextend)
+
+        if not (opts.n or opts.d or opts.i) and opts.m:
+            return run_module()
+        return 0
+
+    except SystemExit:
+        raise
+    except:
+        einfo = sys.exc_info()
+        msg = exc_string(einfo=einfo)
+        print msg
+        if opts.d:
+            import pdb
+            pdb.post_mortem(einfo[2])
+        return -1
+
+
-def run(argv=None):
-
-
-
-
+
+
+
+
+
+
+
+
+
-    """
-
@@ -345 +520 @@
-        rval = discover_and_run(argv)
-        if not isinstance(rval, int):
+            if isinstance(rval, tuple) and isinstance(rval[0], list):
+                for p in rval[0]:
+                    print p
-            rval = 0
-    except SystemExit:
@@ -354 +532 @@
-    return rval
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-if __name__=='__main__':
-
-
+ex
+

pyrun/trunk/pyrun.rst

@@ -10 +10 @@
-.. include:: INSTALL.txt
-
+.. include:: examples/command_line_use.rst
-.. include:: examples/discover_and_run.rst
-