File Manager

X7ROOT File Manager

Current Path: /opt/alt/python35/lib64/python3.5

opt / alt / python35 / lib64 / python3.5 /

?? ..
?? __future__.py(4.73 KB)
?? __phello__.foo.py(64 B)
?? __pycache__
?? _bootlocale.py(1.27 KB)
?? _collections_abc.py(24.21 KB)
?? _compat_pickle.py(8.36 KB)
?? _compression.py(5.21 KB)
?? _dummy_thread.py(5 KB)
?? _markupbase.py(14.26 KB)
?? _osx_support.py(18.67 KB)
?? _pydecimal.py(223.27 KB)
?? _pyio.py(85.91 KB)
?? _sitebuiltins.py(3.04 KB)
?? _strptime.py(21.67 KB)
?? _sysconfigdata.py(26.32 KB)
?? _threading_local.py(7.24 KB)
?? _weakrefset.py(5.57 KB)
?? abc.py(8.43 KB)
?? aifc.py(31.22 KB)
?? antigravity.py(476 B)
?? argparse.py(88.03 KB)
?? ast.py(11.72 KB)
?? asynchat.py(11.69 KB)
?? asyncio
?? asyncore.py(19.63 KB)
?? base64.py(20.04 KB)
?? bdb.py(22.81 KB)
?? binhex.py(13.63 KB)
?? bisect.py(2.53 KB)
?? bz2.py(12.13 KB)
?? cProfile.py(5.2 KB)
?? calendar.py(22.46 KB)
?? cgi.py(35.2 KB)
?? cgitb.py(11.74 KB)
?? chunk.py(5.3 KB)
?? cmd.py(14.51 KB)
?? code.py(9.88 KB)
?? codecs.py(35.38 KB)
?? codeop.py(5.85 KB)
?? collections
?? colorsys.py(3.97 KB)
?? compileall.py(11.44 KB)
?? concurrent
?? config-3.5m
?? configparser.py(52.2 KB)
?? contextlib.py(12.16 KB)
?? copy.py(8.74 KB)
?? copyreg.py(6.67 KB)
?? crypt.py(1.83 KB)
?? csv.py(15.75 KB)
?? ctypes
?? curses
?? datetime.py(74.12 KB)
?? dbm
?? decimal.py(320 B)
?? difflib.py(82.23 KB)
?? dis.py(16.94 KB)
?? distutils
?? doctest.py(101.6 KB)
?? dummy_threading.py(2.75 KB)
?? email
?? encodings
?? ensurepip
?? enum.py(21.71 KB)
?? filecmp.py(9.6 KB)
?? fileinput.py(13.92 KB)
?? fnmatch.py(3.09 KB)
?? formatter.py(14.79 KB)
?? fractions.py(24.04 KB)
?? ftplib.py(34.13 KB)
?? functools.py(28.27 KB)
?? genericpath.py(4.26 KB)
?? getopt.py(7.31 KB)
?? getpass.py(5.85 KB)
?? gettext.py(21.03 KB)
?? glob.py(4.95 KB)
?? gzip.py(19.79 KB)
?? hashlib.py(7.79 KB)
?? heapq.py(22.39 KB)
?? hmac.py(4.94 KB)
?? html
?? http
?? idlelib
?? imaplib.py(50.96 KB)
?? imghdr.py(3.67 KB)
?? imp.py(10.43 KB)
?? importlib
?? inspect.py(111.52 KB)
?? io.py(3.32 KB)
?? ipaddress.py(73.96 KB)
?? json
?? keyword.py(2.17 KB)
?? lib-dynload
?? lib2to3
?? linecache.py(5.19 KB)
?? locale.py(72.96 KB)
?? logging
?? lzma.py(12.62 KB)
?? macpath.py(5.77 KB)
?? macurl2path.py(2.67 KB)
?? mailbox.py(76.58 KB)
?? mailcap.py(7.91 KB)
?? mimetypes.py(20.36 KB)
?? modulefinder.py(22.54 KB)
?? multiprocessing
?? netrc.py(5.61 KB)
?? nntplib.py(42.07 KB)
?? ntpath.py(22.26 KB)
?? nturl2path.py(2.39 KB)
?? numbers.py(10 KB)
?? opcode.py(5.75 KB)
?? operator.py(10.61 KB)
?? optparse.py(58.93 KB)
?? os.py(36.17 KB)
?? pathlib.py(45.9 KB)
?? pdb.py(59.72 KB)
?? pickle.py(54.86 KB)
?? pickletools.py(89.61 KB)
?? pipes.py(8.71 KB)
?? pkgutil.py(20.85 KB)
?? plat-linux
?? platform.py(45.07 KB)
?? plistlib.py(31.06 KB)
?? poplib.py(14.37 KB)
?? posixpath.py(14.56 KB)
?? pprint.py(20.37 KB)
?? profile.py(21.52 KB)
?? pstats.py(25.94 KB)
?? pty.py(4.65 KB)
?? py_compile.py(7.01 KB)
?? pyclbr.py(13.25 KB)
?? pydoc.py(101.22 KB)
?? pydoc_data
?? queue.py(8.57 KB)
?? quopri.py(7.09 KB)
?? random.py(25.84 KB)
?? re.py(15.14 KB)
?? reprlib.py(5.21 KB)
?? rlcompleter.py(6.16 KB)
?? runpy.py(11.68 KB)
?? sched.py(6.07 KB)
?? selectors.py(18.98 KB)
?? shelve.py(8.33 KB)
?? shlex.py(11.18 KB)
?? shutil.py(39.11 KB)
?? signal.py(2.07 KB)
?? site-packages
?? site.py(21 KB)
?? smtpd.py(34.54 KB)
?? smtplib.py(42.61 KB)
?? sndhdr.py(6.27 KB)
?? socket.py(26.5 KB)
?? socketserver.py(24.09 KB)
?? sqlite3
?? sre_compile.py(17.98 KB)
?? sre_constants.py(6.66 KB)
?? sre_parse.py(34.29 KB)
?? ssl.py(41.36 KB)
?? stat.py(4.92 KB)
?? statistics.py(19.08 KB)
?? string.py(11.58 KB)
?? stringprep.py(12.61 KB)
?? struct.py(257 B)
?? subprocess.py(57.53 KB)
?? sunau.py(17.67 KB)
?? symbol.py(2.06 KB)
?? symtable.py(7.02 KB)
?? sysconfig.py(23.89 KB)
?? tabnanny.py(11.15 KB)
?? tarfile.py(90.89 KB)
?? telnetlib.py(22.48 KB)
?? tempfile.py(26.01 KB)
?? test
?? textwrap.py(19.1 KB)
?? this.py(1003 B)
?? threading.py(47.88 KB)
?? timeit.py(12.11 KB)
?? token.py(3 KB)
?? tokenize.py(27.14 KB)
?? trace.py(30.81 KB)
?? traceback.py(21.66 KB)
?? tracemalloc.py(15.27 KB)
?? tty.py(879 B)
?? types.py(8.59 KB)
?? typing.py(78.26 KB)
?? unittest
?? urllib
?? uu.py(6.61 KB)
?? uuid.py(22.72 KB)
?? venv
?? warnings.py(15.48 KB)
?? wave.py(17.27 KB)
?? weakref.py(19.99 KB)
?? webbrowser.py(21.32 KB)
?? wsgiref
?? xdrlib.py(5.77 KB)
?? xml
?? xmlrpc
?? zipapp.py(6.99 KB)
?? zipfile.py(71.95 KB)

Editing: shlex.py

"""A lexical analyzer class for simple shell-like syntaxes."""

# Module and documentation by Eric S. Raymond, 21 Dec 1998
# Input stacking and error message cleanup added by ESR, March 2000
# push_source() and pop_source() made explicit by ESR, January 2001.
# Posix compliance, split(), string arguments, and
# iterator interface by Gustavo Niemeyer, April 2003.

import os
import re
import sys
from collections import deque

from io import StringIO

__all__ = ["shlex", "split", "quote"]

class shlex:
    "A lexical analyzer class for simple shell-like syntaxes."
    def __init__(self, instream=None, infile=None, posix=False):
        if isinstance(instream, str):
            instream = StringIO(instream)
        if instream is not None:
            self.instream = instream
            self.infile = infile
        else:
            self.instream = sys.stdin
            self.infile = None
        self.posix = posix
        if posix:
            self.eof = None
        else:
            self.eof = ''
        self.commenters = '#'
        self.wordchars = ('abcdfeghijklmnopqrstuvwxyz'
                          'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_')
        if self.posix:
            self.wordchars += ('ßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ'
                               'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ')
        self.whitespace = ' \t\r\n'
        self.whitespace_split = False
        self.quotes = '\'"'
        self.escape = '\\'
        self.escapedquotes = '"'
        self.state = ' '
        self.pushback = deque()
        self.lineno = 1
        self.debug = 0
        self.token = ''
        self.filestack = deque()
        self.source = None

def push_token(self, tok):
        "Push a token onto the stack popped by the get_token method"
        if self.debug >= 1:
            print("shlex: pushing token " + repr(tok))
        self.pushback.appendleft(tok)

def push_source(self, newstream, newfile=None):
        "Push an input source onto the lexer's input source stack."
        if isinstance(newstream, str):
            newstream = StringIO(newstream)
        self.filestack.appendleft((self.infile, self.instream, self.lineno))
        self.infile = newfile
        self.instream = newstream
        self.lineno = 1
        if self.debug:
            if newfile is not None:
                print('shlex: pushing to file %s' % (self.infile,))
            else:
                print('shlex: pushing to stream %s' % (self.instream,))

def pop_source(self):
        "Pop the input source stack."
        self.instream.close()
        (self.infile, self.instream, self.lineno) = self.filestack.popleft()
        if self.debug:
            print('shlex: popping to %s, line %d' \
                  % (self.instream, self.lineno))
        self.state = ' '

def get_token(self):
        "Get a token from the input stream (or from stack if it's nonempty)"
        if self.pushback:
            tok = self.pushback.popleft()
            if self.debug >= 1:
                print("shlex: popping token " + repr(tok))
            return tok
        # No pushback.  Get a token.
        raw = self.read_token()
        # Handle inclusions
        if self.source is not None:
            while raw == self.source:
                spec = self.sourcehook(self.read_token())
                if spec:
                    (newfile, newstream) = spec
                    self.push_source(newstream, newfile)
                raw = self.get_token()
        # Maybe we got EOF instead?
        while raw == self.eof:
            if not self.filestack:
                return self.eof
            else:
                self.pop_source()
                raw = self.get_token()
        # Neither inclusion nor EOF
        if self.debug >= 1:
            if raw != self.eof:
                print("shlex: token=" + repr(raw))
            else:
                print("shlex: token=EOF")
        return raw

def read_token(self):
        quoted = False
        escapedstate = ' '
        while True:
            nextchar = self.instream.read(1)
            if nextchar == '\n':
                self.lineno = self.lineno + 1
            if self.debug >= 3:
                print("shlex: in state", repr(self.state), \
                      "I see character:", repr(nextchar))
            if self.state is None:
                self.token = ''        # past end of file
                break
            elif self.state == ' ':
                if not nextchar:
                    self.state = None  # end of file
                    break
                elif nextchar in self.whitespace:
                    if self.debug >= 2:
                        print("shlex: I see whitespace in whitespace state")
                    if self.token or (self.posix and quoted):
                        break   # emit current token
                    else:
                        continue
                elif nextchar in self.commenters:
                    self.instream.readline()
                    self.lineno = self.lineno + 1
                elif self.posix and nextchar in self.escape:
                    escapedstate = 'a'
                    self.state = nextchar
                elif nextchar in self.wordchars:
                    self.token = nextchar
                    self.state = 'a'
                elif nextchar in self.quotes:
                    if not self.posix:
                        self.token = nextchar
                    self.state = nextchar
                elif self.whitespace_split:
                    self.token = nextchar
                    self.state = 'a'
                else:
                    self.token = nextchar
                    if self.token or (self.posix and quoted):
                        break   # emit current token
                    else:
                        continue
            elif self.state in self.quotes:
                quoted = True
                if not nextchar:      # end of file
                    if self.debug >= 2:
                        print("shlex: I see EOF in quotes state")
                    # XXX what error should be raised here?
                    raise ValueError("No closing quotation")
                if nextchar == self.state:
                    if not self.posix:
                        self.token = self.token + nextchar
                        self.state = ' '
                        break
                    else:
                        self.state = 'a'
                elif self.posix and nextchar in self.escape and \
                     self.state in self.escapedquotes:
                    escapedstate = self.state
                    self.state = nextchar
                else:
                    self.token = self.token + nextchar
            elif self.state in self.escape:
                if not nextchar:      # end of file
                    if self.debug >= 2:
                        print("shlex: I see EOF in escape state")
                    # XXX what error should be raised here?
                    raise ValueError("No escaped character")
                # In posix shells, only the quote itself or the escape
                # character may be escaped within quotes.
                if escapedstate in self.quotes and \
                   nextchar != self.state and nextchar != escapedstate:
                    self.token = self.token + self.state
                self.token = self.token + nextchar
                self.state = escapedstate
            elif self.state == 'a':
                if not nextchar:
                    self.state = None   # end of file
                    break
                elif nextchar in self.whitespace:
                    if self.debug >= 2:
                        print("shlex: I see whitespace in word state")
                    self.state = ' '
                    if self.token or (self.posix and quoted):
                        break   # emit current token
                    else:
                        continue
                elif nextchar in self.commenters:
                    self.instream.readline()
                    self.lineno = self.lineno + 1
                    if self.posix:
                        self.state = ' '
                        if self.token or (self.posix and quoted):
                            break   # emit current token
                        else:
                            continue
                elif self.posix and nextchar in self.quotes:
                    self.state = nextchar
                elif self.posix and nextchar in self.escape:
                    escapedstate = 'a'
                    self.state = nextchar
                elif nextchar in self.wordchars or nextchar in self.quotes \
                    or self.whitespace_split:
                    self.token = self.token + nextchar
                else:
                    self.pushback.appendleft(nextchar)
                    if self.debug >= 2:
                        print("shlex: I see punctuation in word state")
                    self.state = ' '
                    if self.token or (self.posix and quoted):
                        break   # emit current token
                    else:
                        continue
        result = self.token
        self.token = ''
        if self.posix and not quoted and result == '':
            result = None
        if self.debug > 1:
            if result:
                print("shlex: raw token=" + repr(result))
            else:
                print("shlex: raw token=EOF")
        return result

def sourcehook(self, newfile):
        "Hook called on a filename to be sourced."
        if newfile[0] == '"':
            newfile = newfile[1:-1]
        # This implements cpp-like semantics for relative-path inclusion.
        if isinstance(self.infile, str) and not os.path.isabs(newfile):
            newfile = os.path.join(os.path.dirname(self.infile), newfile)
        return (newfile, open(newfile, "r"))

def error_leader(self, infile=None, lineno=None):
        "Emit a C-compiler-like, Emacs-friendly error-message leader."
        if infile is None:
            infile = self.infile
        if lineno is None:
            lineno = self.lineno
        return "\"%s\", line %d: " % (infile, lineno)

def __iter__(self):
        return self

def __next__(self):
        token = self.get_token()
        if token == self.eof:
            raise StopIteration
        return token

def split(s, comments=False, posix=True):
    lex = shlex(s, posix=posix)
    lex.whitespace_split = True
    if not comments:
        lex.commenters = ''
    return list(lex)

_find_unsafe = re.compile(r'[^\w@%+=:,./-]', re.ASCII).search

def quote(s):
    """Return a shell-escaped version of the string *s*."""
    if not s:
        return "''"
    if _find_unsafe(s) is None:
        return s

# use single quotes, and put single quotes into double quotes
    # the string $'b is then quoted as '$'"'"'b'
    return "'" + s.replace("'", "'\"'\"'") + "'"

def _print_tokens(lexer):
    while 1:
        tt = lexer.get_token()
        if not tt:
            break
        print("Token: " + repr(tt))

if __name__ == '__main__':
    if len(sys.argv) == 1:
        _print_tokens(shlex())
    else:
        fn = sys.argv[1]
        with open(fn) as f:
            _print_tokens(shlex(f, fn))

X7ROOT File Manager

Editing: shlex.py

Upload File

Create Folder