File Manager

X7ROOT File Manager

Current Path: /opt/alt/python37/lib64/python3.7

opt / alt / python37 / lib64 / python3.7 /

ðŸ“ ..
ðŸ“„ __future__.py(4.98 KB)
ðŸ“„ __phello__.foo.py(64 B)
ðŸ“ __pycache__
ðŸ“„ _bootlocale.py(1.76 KB)
ðŸ“„ _collections_abc.py(25.8 KB)
ðŸ“„ _compat_pickle.py(8.54 KB)
ðŸ“„ _compression.py(5.21 KB)
ðŸ“„ _dummy_thread.py(5.89 KB)
ðŸ“„ _markupbase.py(14.26 KB)
ðŸ“„ _osx_support.py(19.14 KB)
ðŸ“„ _py_abc.py(6.04 KB)
ðŸ“„ _pydecimal.py(223.33 KB)
ðŸ“„ _pyio.py(89.47 KB)
ðŸ“„ _sitebuiltins.py(3.04 KB)
ðŸ“„ _strptime.py(24.91 KB)
ðŸ“„ _sysconfigdata_dm_linux_x86_64-linux-gnu.py(30.59 KB)
ðŸ“„ _sysconfigdata_m_linux_x86_64-linux-gnu.py(27.93 KB)
ðŸ“„ _threading_local.py(7.04 KB)
ðŸ“„ _weakrefset.py(5.55 KB)
ðŸ“„ abc.py(5.45 KB)
ðŸ“„ aifc.py(32.04 KB)
ðŸ“„ antigravity.py(477 B)
ðŸ“„ argparse.py(93.14 KB)
ðŸ“„ ast.py(12.54 KB)
ðŸ“„ asynchat.py(11.06 KB)
ðŸ“ asyncio
ðŸ“„ asyncore.py(19.65 KB)
ðŸ“„ base64.py(19.92 KB)
ðŸ“„ bdb.py(30.99 KB)
ðŸ“„ binhex.py(13.63 KB)
ðŸ“„ bisect.py(2.5 KB)
ðŸ“„ bz2.py(12.12 KB)
ðŸ“„ cProfile.py(6.11 KB)
ðŸ“„ calendar.py(24.24 KB)
ðŸ“„ cgi.py(34.23 KB)
ðŸ“„ cgitb.py(11.74 KB)
ðŸ“„ chunk.py(5.31 KB)
ðŸ“„ cmd.py(14.51 KB)
ðŸ“„ code.py(10.37 KB)
ðŸ“„ codecs.py(35.76 KB)
ðŸ“„ codeop.py(6.13 KB)
ðŸ“ collections
ðŸ“„ colorsys.py(3.97 KB)
ðŸ“„ compileall.py(13.46 KB)
ðŸ“ concurrent
ðŸ“ config-3.7m
ðŸ“„ configparser.py(53.01 KB)
ðŸ“„ contextlib.py(24.18 KB)
ðŸ“„ contextvars.py(129 B)
ðŸ“„ copy.py(8.65 KB)
ðŸ“„ copyreg.py(6.85 KB)
ðŸ“„ crypt.py(3.27 KB)
ðŸ“„ csv.py(15.8 KB)
ðŸ“ ctypes
ðŸ“ curses
ðŸ“„ dataclasses.py(48.36 KB)
ðŸ“„ datetime.py(84.52 KB)
ðŸ“ dbm
ðŸ“„ decimal.py(320 B)
ðŸ“„ difflib.py(82.42 KB)
ðŸ“„ dis.py(19.42 KB)
ðŸ“ distutils
ðŸ“„ doctest.py(102.11 KB)
ðŸ“„ dummy_threading.py(2.75 KB)
ðŸ“ email
ðŸ“ encodings
ðŸ“ ensurepip
ðŸ“„ enum.py(34.22 KB)
ðŸ“„ filecmp.py(9.6 KB)
ðŸ“„ fileinput.py(14.28 KB)
ðŸ“„ fnmatch.py(3.96 KB)
ðŸ“„ formatter.py(14.79 KB)
ðŸ“„ fractions.py(23.2 KB)
ðŸ“„ ftplib.py(34.78 KB)
ðŸ“„ functools.py(32.16 KB)
ðŸ“„ genericpath.py(4.8 KB)
ðŸ“„ getopt.py(7.31 KB)
ðŸ“„ getpass.py(5.85 KB)
ðŸ“„ gettext.py(21.45 KB)
ðŸ“„ glob.py(5.51 KB)
ðŸ“„ gzip.py(20.15 KB)
ðŸ“„ hashlib.py(9.31 KB)
ðŸ“„ heapq.py(22.48 KB)
ðŸ“„ hmac.py(6.36 KB)
ðŸ“ html
ðŸ“ http
ðŸ“ idlelib
ðŸ“„ imaplib.py(52.04 KB)
ðŸ“„ imghdr.py(3.71 KB)
ðŸ“„ imp.py(10.29 KB)
ðŸ“ importlib
ðŸ“„ inspect.py(114.88 KB)
ðŸ“„ io.py(3.43 KB)
ðŸ“„ ipaddress.py(71.85 KB)
ðŸ“ json
ðŸ“„ keyword.py(2.2 KB)
ðŸ“ lib-dynload
ðŸ“ lib2to3
ðŸ“„ linecache.py(5.21 KB)
ðŸ“„ locale.py(76.36 KB)
ðŸ“ logging
ðŸ“„ lzma.py(12.68 KB)
ðŸ“„ macpath.py(5.98 KB)
ðŸ“„ mailbox.py(76.81 KB)
ðŸ“„ mailcap.py(8.85 KB)
ðŸ“„ mimetypes.py(20.99 KB)
ðŸ“„ modulefinder.py(22.5 KB)
ðŸ“ multiprocessing
ðŸ“„ netrc.py(5.44 KB)
ðŸ“„ nntplib.py(42.08 KB)
ðŸ“„ ntpath.py(21.82 KB)
ðŸ“„ nturl2path.py(2.52 KB)
ðŸ“„ numbers.py(10 KB)
ðŸ“„ opcode.py(5.69 KB)
ðŸ“„ operator.py(10.61 KB)
ðŸ“„ optparse.py(58.96 KB)
ðŸ“„ os.py(37.01 KB)
ðŸ“„ pathlib.py(49.15 KB)
ðŸ“„ pdb.py(61.04 KB)
ðŸ“„ pickle.py(56.63 KB)
ðŸ“„ pickletools.py(89.08 KB)
ðŸ“„ pipes.py(8.71 KB)
ðŸ“„ pkgutil.py(20.96 KB)
ðŸ“„ platform.py(45.89 KB)
ðŸ“„ plistlib.py(29.99 KB)
ðŸ“„ poplib.py(14.61 KB)
ðŸ“„ posixpath.py(15.4 KB)
ðŸ“„ pprint.py(20.39 KB)
ðŸ“„ profile.py(21.97 KB)
ðŸ“„ pstats.py(26.67 KB)
ðŸ“„ pty.py(4.65 KB)
ðŸ“„ py_compile.py(7.81 KB)
ðŸ“„ pyclbr.py(14.78 KB)
ðŸ“„ pydoc.py(103.39 KB)
ðŸ“ pydoc_data
ðŸ“„ queue.py(11.09 KB)
ðŸ“„ quopri.py(7.09 KB)
ðŸ“„ random.py(26.91 KB)
ðŸ“„ re.py(14.95 KB)
ðŸ“„ reprlib.py(5.14 KB)
ðŸ“„ rlcompleter.py(6.93 KB)
ðŸ“„ runpy.py(11.68 KB)
ðŸ“„ sched.py(6.29 KB)
ðŸ“„ secrets.py(1.99 KB)
ðŸ“„ selectors.py(18.13 KB)
ðŸ“„ shelve.py(8.33 KB)
ðŸ“„ shlex.py(12.79 KB)
ðŸ“„ shutil.py(40.97 KB)
ðŸ“„ signal.py(2.07 KB)
ðŸ“ site-packages
ðŸ“„ site.py(21.07 KB)
ðŸ“„ smtpd.py(33.91 KB)
ðŸ“„ smtplib.py(43.4 KB)
ðŸ“„ sndhdr.py(6.92 KB)
ðŸ“„ socket.py(26.83 KB)
ðŸ“„ socketserver.py(26.29 KB)
ðŸ“ sqlite3
ðŸ“„ sre_compile.py(26.24 KB)
ðŸ“„ sre_constants.py(7.01 KB)
ðŸ“„ sre_parse.py(38.24 KB)
ðŸ“„ ssl.py(44.43 KB)
ðŸ“„ stat.py(5.26 KB)
ðŸ“„ statistics.py(20.17 KB)
ðŸ“„ string.py(11.29 KB)
ðŸ“„ stringprep.py(12.61 KB)
ðŸ“„ struct.py(257 B)
ðŸ“„ subprocess.py(70.95 KB)
ðŸ“„ sunau.py(17.94 KB)
ðŸ“„ symbol.py(2.09 KB)
ðŸ“„ symtable.py(7.11 KB)
ðŸ“„ sysconfig.py(23.87 KB)
ðŸ“„ tabnanny.py(11.15 KB)
ðŸ“„ tarfile.py(90.5 KB)
ðŸ“„ telnetlib.py(22.59 KB)
ðŸ“„ tempfile.py(26.1 KB)
ðŸ“ test
ðŸ“„ textwrap.py(18.95 KB)
ðŸ“„ this.py(1003 B)
ðŸ“„ threading.py(48.13 KB)
ðŸ“„ timeit.py(13.18 KB)
ðŸ“„ token.py(3.67 KB)
ðŸ“„ tokenize.py(26.4 KB)
ðŸ“„ trace.py(28.23 KB)
ðŸ“„ traceback.py(22.89 KB)
ðŸ“„ tracemalloc.py(16.68 KB)
ðŸ“„ tty.py(879 B)
ðŸ“„ types.py(9.67 KB)
ðŸ“„ typing.py(55.12 KB)
ðŸ“ unittest
ðŸ“ urllib
ðŸ“„ uu.py(7.11 KB)
ðŸ“„ uuid.py(28.83 KB)
ðŸ“ venv
ðŸ“„ warnings.py(19.61 KB)
ðŸ“„ wave.py(17.8 KB)
ðŸ“„ weakref.py(21 KB)
ðŸ“„ webbrowser.py(23.16 KB)
ðŸ“ wsgiref
ðŸ“„ xdrlib.py(5.77 KB)
ðŸ“ xml
ðŸ“ xmlrpc
ðŸ“„ zipapp.py(7.36 KB)
ðŸ“„ zipfile.py(79.19 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.
# changes to tokenize more like Posix shells by Vinay Sajip, July 2016.

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,
                 punctuation_chars=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
        if not punctuation_chars:
            punctuation_chars = ''
        elif punctuation_chars is True:
            punctuation_chars = '();<>|&'
        self._punctuation_chars = punctuation_chars
        if punctuation_chars:
            # _pushback_chars is a push back queue used by lookahead logic
            self._pushback_chars = deque()
            # these chars added because allowed in file names, args, wildcards
            self.wordchars += '~-./*?='
            #remove any punctuation chars from wordchars
            t = self.wordchars.maketrans(dict.fromkeys(punctuation_chars))
            self.wordchars = self.wordchars.translate(t)

@property
    def punctuation_chars(self):
        return self._punctuation_chars

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:
            if self.punctuation_chars and self._pushback_chars:
                nextchar = self._pushback_chars.pop()
            else:
                nextchar = self.instream.read(1)
            if nextchar == '\n':
                self.lineno += 1
            if self.debug >= 3:
                print("shlex: in state %r I see character: %r" % (self.state,
                                                                  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 += 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.punctuation_chars:
                    self.token = nextchar
                    self.state = 'c'
                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 += 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 += 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.state
                self.token += nextchar
                self.state = escapedstate
            elif self.state in ('a', 'c'):
                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 += 1
                    if self.posix:
                        self.state = ' '
                        if self.token or (self.posix and quoted):
                            break   # emit current token
                        else:
                            continue
                elif self.state == 'c':
                    if nextchar in self.punctuation_chars:
                        self.token += nextchar
                    else:
                        if nextchar not in self.whitespace:
                            self._pushback_chars.append(nextchar)
                        self.state = ' '
                        break
                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 += nextchar
                else:
                    if self.punctuation_chars:
                        self._pushback_chars.append(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):
    """Split the string *s* using shell-like syntax."""
    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