File Manager

X7ROOT File Manager

Current Path: /opt/alt/python33/lib64/python3.3

opt / alt / python33 / lib64 / python3.3 /

?? ..
?? __future__.py(4.48 KB)
?? __phello__.foo.py(64 B)
?? __pycache__
?? _compat_pickle.py(4.24 KB)
?? _dummy_thread.py(4.66 KB)
?? _markupbase.py(14.26 KB)
?? _osx_support.py(18.41 KB)
?? _pyio.py(71.2 KB)
?? _strptime.py(21.17 KB)
?? _sysconfigdata.py(22.31 KB)
?? _threading_local.py(7.24 KB)
?? _weakrefset.py(5.57 KB)
?? abc.py(7.87 KB)
?? aifc.py(30.33 KB)
?? antigravity.py(475 B)
?? argparse.py(86.98 KB)
?? ast.py(11.86 KB)
?? asynchat.py(11.32 KB)
?? asyncore.py(20.27 KB)
?? base64.py(13.66 KB)
?? bdb.py(21.38 KB)
?? binhex.py(13.39 KB)
?? bisect.py(2.53 KB)
?? bz2.py(18.04 KB)
?? cProfile.py(6.21 KB)
?? calendar.py(22.4 KB)
?? cgi.py(34.72 KB)
?? cgitb.py(11.76 KB)
?? chunk.py(5.25 KB)
?? cmd.py(14.51 KB)
?? code.py(9.79 KB)
?? codecs.py(35.11 KB)
?? codeop.py(5.85 KB)
?? collections
?? colorsys.py(3.6 KB)
?? compileall.py(9.51 KB)
?? concurrent
?? config-3.3m
?? configparser.py(48.28 KB)
?? contextlib.py(8.91 KB)
?? copy.py(8.78 KB)
?? copyreg.py(6.46 KB)
?? crypt.py(1.83 KB)
?? csv.py(15.81 KB)
?? ctypes
?? curses
?? datetime.py(73.2 KB)
?? dbm
?? decimal.py(223.2 KB)
?? difflib.py(80.58 KB)
?? dis.py(9.9 KB)
?? distutils
?? doctest.py(100.52 KB)
?? dummy_threading.py(2.75 KB)
?? email
?? encodings
?? filecmp.py(9.37 KB)
?? fileinput.py(13.92 KB)
?? fnmatch.py(3.09 KB)
?? formatter.py(14.58 KB)
?? fractions.py(22.49 KB)
?? ftplib.py(39.31 KB)
?? functools.py(13.28 KB)
?? genericpath.py(3.02 KB)
?? getopt.py(7.31 KB)
?? getpass.py(5.66 KB)
?? gettext.py(20.15 KB)
?? glob.py(2.77 KB)
?? gzip.py(23.83 KB)
?? hashlib.py(6.05 KB)
?? heapq.py(17.58 KB)
?? hmac.py(4.34 KB)
?? html
?? http
?? idlelib
?? imaplib.py(48.94 KB)
?? imghdr.py(3.45 KB)
?? imp.py(9.5 KB)
?? importlib
?? inspect.py(77.11 KB)
?? io.py(3.2 KB)
?? ipaddress.py(68.66 KB)
?? json
?? keyword.py(2.01 KB)
?? lib-dynload
?? lib2to3
?? linecache.py(3.77 KB)
?? locale.py(91.03 KB)
?? logging
?? lzma.py(17.04 KB)
?? macpath.py(5.49 KB)
?? macurl2path.py(2.67 KB)
?? mailbox.py(77.24 KB)
?? mailcap.py(7.26 KB)
?? mimetypes.py(20.25 KB)
?? modulefinder.py(22.65 KB)
?? multiprocessing
?? netrc.py(5.61 KB)
?? nntplib.py(41.78 KB)
?? ntpath.py(19.96 KB)
?? nturl2path.py(2.34 KB)
?? numbers.py(10.15 KB)
?? opcode.py(4.98 KB)
?? optparse.py(58.93 KB)
?? os.py(33.96 KB)
?? os2emxpath.py(4.55 KB)
?? pdb.py(59.23 KB)
?? pickle.py(46.74 KB)
?? pickletools.py(79.44 KB)
?? pipes.py(8.71 KB)
?? pkgutil.py(21.03 KB)
?? plat-linux
?? platform.py(49.55 KB)
?? plistlib.py(14.43 KB)
?? poplib.py(11.11 KB)
?? posixpath.py(13.92 KB)
?? pprint.py(12.4 KB)
?? profile.py(20.95 KB)
?? pstats.py(25.75 KB)
?? pty.py(4.94 KB)
?? py_compile.py(6.56 KB)
?? pyclbr.py(13.12 KB)
?? pydoc.py(99.26 KB)
?? pydoc_data
?? queue.py(8.63 KB)
?? quopri.py(7.14 KB)
?? random.py(25.06 KB)
?? re.py(14.62 KB)
?? reprlib.py(4.99 KB)
?? rlcompleter.py(5.4 KB)
?? runpy.py(10.17 KB)
?? sched.py(6.25 KB)
?? shelve.py(8.05 KB)
?? shlex.py(11.23 KB)
?? shutil.py(38.23 KB)
?? site-packages
?? site.py(21.46 KB)
?? smtpd.py(29.5 KB)
?? smtplib.py(37.13 KB)
?? sndhdr.py(6.07 KB)
?? socket.py(14.56 KB)
?? socketserver.py(23.63 KB)
?? sqlite3
?? sre_compile.py(15.96 KB)
?? sre_constants.py(7.06 KB)
?? sre_parse.py(29.5 KB)
?? ssl.py(23.9 KB)
?? stat.py(4.2 KB)
?? string.py(9.19 KB)
?? stringprep.py(12.61 KB)
?? struct.py(238 B)
?? subprocess.py(65.99 KB)
?? sunau.py(17.11 KB)
?? symbol.py(2 KB)
?? symtable.py(7.21 KB)
?? sysconfig.py(24.58 KB)
?? tabnanny.py(11.14 KB)
?? tarfile.py(86.78 KB)
?? telnetlib.py(26.71 KB)
?? tempfile.py(22.47 KB)
?? test
?? textwrap.py(16.1 KB)
?? this.py(1003 B)
?? threading.py(44.57 KB)
?? timeit.py(12.1 KB)
?? token.py(2.96 KB)
?? tokenize.py(24.29 KB)
?? trace.py(30.75 KB)
?? traceback.py(11.7 KB)
?? tty.py(879 B)
?? types.py(3.09 KB)
?? unittest
?? urllib
?? uu.py(6.61 KB)
?? uuid.py(21.83 KB)
?? venv
?? warnings.py(13.5 KB)
?? wave.py(18.14 KB)
?? weakref.py(11.23 KB)
?? webbrowser.py(22.38 KB)
?? wsgiref
?? xdrlib.py(5.25 KB)
?? xml
?? xmlrpc
?? zipfile.py(64.87 KB)

Editing: contextlib.py

"""Utilities for with-statement contexts.  See PEP 343."""

import sys
from collections import deque
from functools import wraps

__all__ = ["contextmanager", "closing", "ContextDecorator", "ExitStack"]

class ContextDecorator(object):
    "A base class or mixin that enables context managers to work as decorators."

def _recreate_cm(self):
        """Return a recreated instance of self.

Allows an otherwise one-shot context manager like
        _GeneratorContextManager to support use as
        a decorator via implicit recreation.

This is a private interface just for _GeneratorContextManager.
        See issue #11647 for details.
        """
        return self

def __call__(self, func):
        @wraps(func)
        def inner(*args, **kwds):
            with self._recreate_cm():
                return func(*args, **kwds)
        return inner

class _GeneratorContextManager(ContextDecorator):
    """Helper for @contextmanager decorator."""

def __init__(self, func, *args, **kwds):
        self.gen = func(*args, **kwds)
        self.func, self.args, self.kwds = func, args, kwds

def _recreate_cm(self):
        # _GCM instances are one-shot context managers, so the
        # CM must be recreated each time a decorated function is
        # called
        return self.__class__(self.func, *self.args, **self.kwds)

def __enter__(self):
        try:
            return next(self.gen)
        except StopIteration:
            raise RuntimeError("generator didn't yield")

def __exit__(self, type, value, traceback):
        if type is None:
            try:
                next(self.gen)
            except StopIteration:
                return
            else:
                raise RuntimeError("generator didn't stop")
        else:
            if value is None:
                # Need to force instantiation so we can reliably
                # tell if we get the same exception back
                value = type()
            try:
                self.gen.throw(type, value, traceback)
                raise RuntimeError("generator didn't stop after throw()")
            except StopIteration as exc:
                # Suppress the exception *unless* it's the same exception that
                # was passed to throw().  This prevents a StopIteration
                # raised inside the "with" statement from being suppressed
                return exc is not value
            except:
                # only re-raise if it's *not* the exception that was
                # passed to throw(), because __exit__() must not raise
                # an exception unless __exit__() itself failed.  But throw()
                # has to raise the exception to signal propagation, so this
                # fixes the impedance mismatch between the throw() protocol
                # and the __exit__() protocol.
                #
                if sys.exc_info()[1] is not value:
                    raise

def contextmanager(func):
    """@contextmanager decorator.

Typical usage:

@contextmanager
        def some_generator(<arguments>):
            <setup>
            try:
                yield <value>
            finally:
                <cleanup>

This makes this:

with some_generator(<arguments>) as <variable>:
            <body>

equivalent to this:

<setup>
        try:
            <variable> = <value>
            <body>
        finally:
            <cleanup>

"""
    @wraps(func)
    def helper(*args, **kwds):
        return _GeneratorContextManager(func, *args, **kwds)
    return helper

class closing(object):
    """Context to automatically close something at the end of a block.

Code like this:

with closing(<module>.open(<arguments>)) as f:
            <block>

is equivalent to this:

f = <module>.open(<arguments>)
        try:
            <block>
        finally:
            f.close()

"""
    def __init__(self, thing):
        self.thing = thing
    def __enter__(self):
        return self.thing
    def __exit__(self, *exc_info):
        self.thing.close()

# Inspired by discussions on http://bugs.python.org/issue13585
class ExitStack(object):
    """Context manager for dynamic management of a stack of exit callbacks

For example:

with ExitStack() as stack:
            files = [stack.enter_context(open(fname)) for fname in filenames]
            # All opened files will automatically be closed at the end of
            # the with statement, even if attempts to open files later
            # in the list raise an exception

"""
    def __init__(self):
        self._exit_callbacks = deque()

def pop_all(self):
        """Preserve the context stack by transferring it to a new instance"""
        new_stack = type(self)()
        new_stack._exit_callbacks = self._exit_callbacks
        self._exit_callbacks = deque()
        return new_stack

def _push_cm_exit(self, cm, cm_exit):
        """Helper to correctly register callbacks to __exit__ methods"""
        def _exit_wrapper(*exc_details):
            return cm_exit(cm, *exc_details)
        _exit_wrapper.__self__ = cm
        self.push(_exit_wrapper)

def push(self, exit):
        """Registers a callback with the standard __exit__ method signature

Can suppress exceptions the same way __exit__ methods can.

Also accepts any object with an __exit__ method (registering a call
        to the method instead of the object itself)
        """
        # We use an unbound method rather than a bound method to follow
        # the standard lookup behaviour for special methods
        _cb_type = type(exit)
        try:
            exit_method = _cb_type.__exit__
        except AttributeError:
            # Not a context manager, so assume its a callable
            self._exit_callbacks.append(exit)
        else:
            self._push_cm_exit(exit, exit_method)
        return exit # Allow use as a decorator

def callback(self, callback, *args, **kwds):
        """Registers an arbitrary callback and arguments.

Cannot suppress exceptions.
        """
        def _exit_wrapper(exc_type, exc, tb):
            callback(*args, **kwds)
        # We changed the signature, so using @wraps is not appropriate, but
        # setting __wrapped__ may still help with introspection
        _exit_wrapper.__wrapped__ = callback
        self.push(_exit_wrapper)
        return callback # Allow use as a decorator

def enter_context(self, cm):
        """Enters the supplied context manager

If successful, also pushes its __exit__ method as a callback and
        returns the result of the __enter__ method.
        """
        # We look up the special methods on the type to match the with statement
        _cm_type = type(cm)
        _exit = _cm_type.__exit__
        result = _cm_type.__enter__(cm)
        self._push_cm_exit(cm, _exit)
        return result

def close(self):
        """Immediately unwind the context stack"""
        self.__exit__(None, None, None)

def __enter__(self):
        return self

def __exit__(self, *exc_details):
        received_exc = exc_details[0] is not None

# We manipulate the exception state so it behaves as though
        # we were actually nesting multiple with statements
        frame_exc = sys.exc_info()[1]
        def _fix_exception_context(new_exc, old_exc):
            # Context may not be correct, so find the end of the chain
            while 1:
                exc_context = new_exc.__context__
                if exc_context is old_exc:
                    # Context is already set correctly (see issue 20317)
                    return
                if exc_context is None or exc_context is frame_exc:
                    break
                new_exc = exc_context
            # Change the end of the chain to point to the exception
            # we expect it to reference
            new_exc.__context__ = old_exc

# Callbacks are invoked in LIFO order to match the behaviour of
        # nested context managers
        suppressed_exc = False
        pending_raise = False
        while self._exit_callbacks:
            cb = self._exit_callbacks.pop()
            try:
                if cb(*exc_details):
                    suppressed_exc = True
                    pending_raise = False
                    exc_details = (None, None, None)
            except:
                new_exc_details = sys.exc_info()
                # simulate the stack of exceptions by setting the context
                _fix_exception_context(new_exc_details[1], exc_details[1])
                pending_raise = True
                exc_details = new_exc_details
        if pending_raise:
            try:
                # bare "raise exc_details[1]" replaces our carefully
                # set-up context
                fixed_ctx = exc_details[1].__context__
                raise exc_details[1]
            except BaseException:
                exc_details[1].__context__ = fixed_ctx
                raise
        return received_exc and suppressed_exc

X7ROOT File Manager

Editing: contextlib.py

Upload File

Create Folder