ModuleNotFoundError.
try:
import _thread
- except ImportError:
+ except ModuleNotFoundError:
import _dummy_thread as _thread
"""
try:
import tempfile
fp = tempfile.NamedTemporaryFile()
- except ImportError:
+ except ModuleNotFoundError:
fp = open("/tmp/_osx_support.%s"%(
os.getpid(),), "w+b")
# Import _thread instead of threading to reduce startup cost
try:
from _thread import allocate_lock as Lock
-except ImportError:
+except ModuleNotFoundError:
from _dummy_thread import allocate_lock as Lock
import io
if encoding is None:
try:
import locale
- except ImportError:
+ except ModuleNotFoundError:
# Importing locale may fail if Python is being built
encoding = "ascii"
else:
timezone as datetime_timezone)
try:
from _thread import allocate_lock as _thread_allocate_lock
-except ImportError:
+except ModuleNotFoundError:
from _dummy_thread import allocate_lock as _thread_allocate_lock
__all__ = []
# Overwrite above definitions with a fast C implementation
try:
from _bisect import *
-except ImportError:
+except ModuleNotFoundError:
pass
try:
from threading import RLock
-except ImportError:
+except ModuleNotFoundError:
from dummy_threading import RLock
from _bz2 import BZ2Compressor, BZ2Decompressor
self.old_completer = readline.get_completer()
readline.set_completer(self.complete)
readline.parse_and_bind(self.completekey+": complete")
- except ImportError:
+ except ModuleNotFoundError:
pass
try:
if intro is not None:
try:
import readline
readline.set_completer(self.old_completer)
- except ImportError:
+ except ModuleNotFoundError:
pass
else:
try:
import readline
- except ImportError:
+ except ModuleNotFoundError:
pass
console.interact(banner)
try: # Load C helper function if available
from _collections import _count_elements
-except ImportError:
+except ModuleNotFoundError:
pass
class Counter(dict):
try:
from org.python.core import PyStringMap
-except ImportError:
+except ModuleNotFoundError:
PyStringMap = None
__all__ = ["Error", "copy", "deepcopy"]
try:
from _datetime import *
-except ImportError:
+except ModuleNotFoundError:
pass
else:
# Clean up unused names
try:
from collections import namedtuple as _namedtuple
DecimalTuple = _namedtuple('DecimalTuple', 'sign digits exponent')
-except ImportError:
+except ModuleNotFoundError:
DecimalTuple = lambda *args: args
# Rounding
try:
import threading
-except ImportError:
+except ModuleNotFoundError:
# Python was compiled without threads; create a mock object instead
class MockThreading(object):
def local(self, sys=sys):
# don't care too much if locale isn't present.
try:
import locale as _locale
-except ImportError:
+except ModuleNotFoundError:
pass
def _parse_format_specifier(format_spec, _localeconv=None):
try:
import _decimal
-except ImportError:
+except ModuleNotFoundError:
pass
else:
s1 = set(dir())
try:
import zipfile
-except ImportError:
+except ModuleNotFoundError:
zipfile = None
Contains CCompiler, an abstract base class that defines the interface
for the Distutils compiler abstraction model."""
-import sys, os, re
+import importlib, sys, os, re
from distutils.errors import *
from distutils.spawn import spawn
from distutils.file_util import move_file
try:
module_name = "distutils." + module_name
- __import__ (module_name)
- module = sys.modules[module_name]
+ module = importlib.import_module(module_name)
klass = vars(module)[class_name]
- except ImportError:
+ except ModuleNotFoundError:
raise DistutilsModuleError(
"can't compile C/C++ code: unable to load module '%s'" % \
module_name)
being built/installed/distributed.
"""
-import sys, os, re
+import importlib, sys, os, re
try:
import warnings
-except ImportError:
+except ModuleNotFoundError:
warnings = None
from distutils.errors import *
klass_name = command
try:
- __import__ (module_name)
- module = sys.modules[module_name]
- except ImportError:
+ module = importlib.import_module(module_name)
+ except ModuleNotFoundError:
continue
try:
RegEnumValue = winreg.EnumValue
RegError = winreg.error
-except ImportError:
+except ModuleNotFoundError:
try:
import win32api
import win32con
RegEnumKey = win32api.RegEnumKey
RegEnumValue = win32api.RegEnumValue
RegError = win32api.error
- except ImportError:
+ except ModuleNotFoundError:
log.info("Warning: Can't read registry to find the "
"necessary compiler setting\n"
"Make sure that Python modules winreg, "
try:
from tempfile import mkstemp
(script_fd, script_name) = mkstemp(".py")
- except ImportError:
+ except ModuleNotFoundError:
from tempfile import mktemp
(script_fd, script_name) = None, mktemp(".py")
log.info("writing byte-compilation script '%s'", script_name)
"""#"
import codecs
+import importlib
from . import aliases
_cache = {}
_unknown = '--unknown--'
-_import_tail = ['*']
_aliases = aliases.aliases
class CodecRegistryError(LookupError, SystemError):
try:
# Import is absolute to prevent the possibly malicious import of a
# module with side-effects that is not in the 'encodings' package.
- mod = __import__('encodings.' + modname, fromlist=_import_tail,
- level=0)
- except ImportError:
+ mod = importlib.import_module('encodings.' + modname)
+ except ModuleNotFoundError:
pass
else:
break
try:
import ssl
-except ImportError:
+except ModuleNotFoundError:
_SSLSocket = None
else:
_SSLSocket = ssl.SSLSocket
try:
from _functools import reduce
-except ImportError:
+except ModuleNotFoundError:
pass
from abc import get_cache_token
from collections import namedtuple
try:
from _functools import cmp_to_key
-except ImportError:
+except ModuleNotFoundError:
pass
try:
from _functools import partial
-except ImportError:
+except ModuleNotFoundError:
pass
import os
try:
from gettext import gettext as _
-except ImportError:
+except ModuleNotFoundError:
# Bootstrapping Python: gettext's dependencies not built yet
def _(s): return s
except (ImportError, AttributeError):
try:
import msvcrt
- except ImportError:
+ except ModuleNotFoundError:
getpass = fallback_getpass
else:
getpass = win_getpass
return _sha3.sha3_384
elif bs == '512':
return _sha3.sha3_512
- except ImportError:
+ except ModuleNotFoundError:
pass # no extension module, this hash is unsupported.
raise ValueError('unsupported hash type ' + name)
__get_hash = __get_openssl_constructor
algorithms_available = algorithms_available.union(
_hashlib.openssl_md_meth_names)
-except ImportError:
+except ModuleNotFoundError:
new = __py_new
__get_hash = __get_builtin_constructor
# If available, use C implementation
try:
from _heapq import *
-except ImportError:
+except ModuleNotFoundError:
pass
def merge(*iterables):
try:
import ssl
-except ImportError:
+except ModuleNotFoundError:
pass
else:
class HTTPSConnection(HTTPConnection):
import urllib.parse, urllib.request
try:
import threading as _threading
-except ImportError:
+except ModuleNotFoundError:
import dummy_threading as _threading
import http.client # only for the default HTTP port
from calendar import timegm
return nobody
try:
import pwd
- except ImportError:
+ except ModuleNotFoundError:
return -1
try:
nobody = pwd.getpwnam('nobody')[2]
try:
import ssl
HAVE_SSL = True
-except ImportError:
+except ModuleNotFoundError:
HAVE_SSL = False
__all__ = ["IMAP4", "IMAP4_stream", "Internaldate2tuple",
_fix_co_filename)
try:
from _imp import load_dynamic
-except ImportError:
+except ModuleNotFoundError:
# Platform doesn't support dynamic loading.
load_dynamic = None
try:
import _frozen_importlib as _bootstrap
-except ImportError:
+except ModuleNotFoundError:
from . import _bootstrap
_bootstrap._setup(sys, _imp)
else:
from . import machinery
try:
import _frozen_importlib
-except ImportError as exc:
+except ModuleNotFoundError as exc:
if exc.name != '_frozen_importlib':
raise
_frozen_importlib = None
# back to hardcording so the dependency is optional
try:
from dis import COMPILER_FLAG_NAMES as _flag_names
-except ImportError:
+except ModuleNotFoundError:
CO_OPTIMIZED, CO_NEWLOCALS = 0x1, 0x2
CO_VARARGS, CO_VARKEYWORDS = 0x4, 0x8
CO_NESTED, CO_GENERATOR, CO_NOFREE = 0x10, 0x20, 0x40
from json import scanner
try:
from _json import scanstring as c_scanstring
-except ImportError:
+except ModuleNotFoundError:
c_scanstring = None
__all__ = ['JSONDecoder']
try:
from _json import encode_basestring_ascii as c_encode_basestring_ascii
-except ImportError:
+except ModuleNotFoundError:
c_encode_basestring_ascii = None
try:
from _json import make_encoder as c_make_encoder
-except ImportError:
+except ModuleNotFoundError:
c_make_encoder = None
ESCAPE = re.compile(r'[\x00-\x1f\\"\b\f\n\r\t]')
import re
try:
from _json import make_scanner as c_make_scanner
-except ImportError:
+except ModuleNotFoundError:
c_make_scanner = None
__all__ = ['make_scanner']
items, write, doctests_only)
try:
import multiprocessing
- except ImportError:
+ except ModuleNotFoundError:
raise MultiprocessingUnsupported
if self.queue is not None:
raise RuntimeError("already doing multiple processes")
from _locale import *
-except ImportError:
+except ModuleNotFoundError:
# Locale emulation
try:
import threading
-except ImportError: #pragma: no cover
+except ModuleNotFoundError: #pragma: no cover
threading = None
__author__ = "Vinay Sajip <vinay_sajip@red-dove.com>"
try:
import _thread as thread
import threading
-except ImportError: #pragma: no cover
+except ModuleNotFoundError: #pragma: no cover
thread = None
from socketserver import ThreadingTCPServer, StreamRequestHandler
import queue
try:
import threading
-except ImportError: #pragma: no cover
+except ModuleNotFoundError: #pragma: no cover
threading = None
#
logging.ERROR : win32evtlog.EVENTLOG_ERROR_TYPE,
logging.CRITICAL: win32evtlog.EVENTLOG_ERROR_TYPE,
}
- except ImportError:
+ except ModuleNotFoundError:
print("The Python Win32 extensions for NT (service, event "\
"logging) appear not to be available.")
self._welu = None
path = abspath(path)
try:
import Carbon.File
- except ImportError:
+ except ModuleNotFoundError:
return path
if not path:
return path
import contextlib
try:
import fcntl
-except ImportError:
+except ModuleNotFoundError:
fcntl = None
__all__ = [ 'Mailbox', 'Maildir', 'mbox', 'MH', 'Babyl', 'MMDF',
import urllib.parse
try:
import winreg as _winreg
-except ImportError:
+except ModuleNotFoundError:
_winreg = None
__all__ = [
try:
import _winapi
from _winapi import WAIT_OBJECT_0, WAIT_TIMEOUT, INFINITE
-except ImportError:
+except ModuleNotFoundError:
if sys.platform == 'win32':
raise
_winapi = None
try:
from functools import partial
-except ImportError:
+except ModuleNotFoundError:
pass
else:
def _reduce_partial(p):
try:
import ssl
-except ImportError:
+except ModuleNotFoundError:
_have_ssl = False
else:
_have_ssl = True
try:
from nt import _getfullpathname
-except ImportError: # not running on Windows - mock up something sensible
+except ModuleNotFoundError: # not running on Windows - mock up something sensible
def abspath(path):
"""Return the absolute version of a path."""
if not isabs(path):
# This is overkill on Windows - just pass the path to GetFileAttributes
# and check the attribute from there.
from nt import _isdir as isdir
-except ImportError:
+except ModuleNotFoundError:
# Use genericpath.isdir as imported above.
pass
try:
from _operator import *
-except ImportError:
+except ModuleNotFoundError:
pass
else:
from _operator import __doc__
try:
from gettext import gettext, ngettext
-except ImportError:
+except ModuleNotFoundError:
def gettext(message):
return message
try:
from posix import _exit
__all__.append('_exit')
- except ImportError:
+ except ModuleNotFoundError:
pass
import posixpath as path
try:
from posix import _have_functions
- except ImportError:
+ except ModuleNotFoundError:
pass
elif 'nt' in _names:
try:
from nt import _exit
__all__.append('_exit')
- except ImportError:
+ except ModuleNotFoundError:
pass
import ntpath as path
try:
from nt import _have_functions
- except ImportError:
+ except ModuleNotFoundError:
pass
elif 'ce' in _names:
try:
from ce import _exit
__all__.append('_exit')
- except ImportError:
+ except ModuleNotFoundError:
pass
# We can use the standard Windows path.
import ntpath as path
try:
from ce import _have_functions
- except ImportError:
+ except ModuleNotFoundError:
pass
else:
- raise ImportError('no os specific module found')
+ raise ModuleNotFoundError('no os specific module found')
sys.modules['os.path'] = path
from os.path import (curdir, pardir, sep, pathsep, defpath, extsep, altsep,
import readline
# remove some common file name delimiters
readline.set_completer_delims(' \t\n`@#$%^&*()=+[{]}\\|;:\'",<>?')
- except ImportError:
+ except ModuleNotFoundError:
pass
self.allow_kbdint = False
self.nosigint = nosigint
# Jython has PyStringMap; it's a dict subclass with string keys
try:
from org.python.core import PyStringMap
-except ImportError:
+except ModuleNotFoundError:
PyStringMap = None
# Pickle opcodes. See pickletools.py for extensive docs. The listing
# Use the faster _pickle if possible
try:
from _pickle import *
-except ImportError:
+except ModuleNotFoundError:
Pickler, Unpickler = _Pickler, _Unpickler
# Doctest
try:
# Use win32api if available
from win32api import RegQueryValueEx
- except ImportError:
+ except ModuleNotFoundError:
# On Python 2.0 and later, emulate using winreg
import winreg
RegQueryValueEx = winreg.QueryValueEx
RegCloseKey, GetVersionEx
from win32con import HKEY_LOCAL_MACHINE, VER_PLATFORM_WIN32_NT, \
VER_PLATFORM_WIN32_WINDOWS, VER_NT_WORKSTATION
- except ImportError:
+ except ModuleNotFoundError:
# Emulate the win32api module using Python APIs
try:
sys.getwindowsversion
# Check whether the version info module is available
try:
import _gestalt
- except ImportError:
+ except ModuleNotFoundError:
return None
# Get the infos
sysv, sysa = _mac_ver_lookup(('sysv','sysa'))
try:
import plistlib
- except ImportError:
+ except ModuleNotFoundError:
return None
pl = plistlib.readPlist(fn)
# Import the needed APIs
try:
import java.lang
- except ImportError:
+ except ModuleNotFoundError:
return release,vendor,vminfo,osinfo
vendor = _java_getprop('java.vendor', vendor)
"""
try:
import socket
- except ImportError:
+ except ModuleNotFoundError:
# No sockets...
return default
try:
# Get processor information
try:
import vms_lib
- except ImportError:
+ except ModuleNotFoundError:
pass
else:
csid, cpu_number = vms_lib.getsyi('SYI$_CPU',0)
try:
import ssl
HAVE_SSL = True
-except ImportError:
+except ModuleNotFoundError:
HAVE_SSL = False
__all__ = ["POP3","error_proto"]
import cmd
try:
import readline
- except ImportError:
+ except ModuleNotFoundError:
pass
class ProfileBrowser(cmd.Cmd):
result = os.open(tty_name, os.O_RDWR)
try:
from fcntl import ioctl, I_PUSH
- except ImportError:
+ except ModuleNotFoundError:
return result
try:
ioctl(result, I_PUSH, "ptem")
def showtopic(self, topic, more_xrefs=''):
try:
import pydoc_data.topics
- except ImportError:
+ except ModuleNotFoundError:
self.output.write('''
Sorry, topic and keyword documentation is not available because the
module "pydoc_data.topics" could not be found.
"""
try:
import pydoc_data.topics
- except ImportError:
+ except ModuleNotFoundError:
return('''
Sorry, topic and keyword documentation is not available because the
module "pydoc_data.topics" could not be found.
try:
import threading
-except ImportError:
+except ModuleNotFoundError:
import dummy_threading as threading
from collections import deque
from heapq import heappush, heappop
try:
from time import monotonic as time
-except ImportError:
+except ModuleNotFoundError:
from time import time
__all__ = ['Empty', 'Full', 'Queue', 'PriorityQueue', 'LifoQueue']
try:
from binascii import a2b_qp, b2a_qp
-except ImportError:
+except ModuleNotFoundError:
a2b_qp = None
b2a_qp = None
from itertools import islice
try:
from _thread import get_ident
-except ImportError:
+except ModuleNotFoundError:
from _dummy_thread import get_ident
def recursive_repr(fillvalue='...'):
try:
import readline
-except ImportError:
+except ModuleNotFoundError:
pass
else:
readline.set_completer(Completer().complete)
from collections import namedtuple
try:
import threading
-except ImportError:
+except ModuleNotFoundError:
import dummy_threading as threading
try:
from time import monotonic as _time
-except ImportError:
+except ModuleNotFoundError:
from time import time as _time
__all__ = ["scheduler"]
import bz2
del bz2
_BZ2_SUPPORTED = True
-except ImportError:
+except ModuleNotFoundError:
_BZ2_SUPPORTED = False
try:
from pwd import getpwnam
-except ImportError:
+except ModuleNotFoundError:
getpwnam = None
try:
from grp import getgrnam
-except ImportError:
+except ModuleNotFoundError:
getgrnam = None
__all__ = ["copyfileobj", "copyfile", "copymode", "copystat", "copy", "copy2",
# command.
try:
import zipfile
- except ImportError:
+ except ModuleNotFoundError:
zipfile = None
if zipfile is None:
"""
try:
import zipfile
- except ImportError:
+ except ModuleNotFoundError:
raise ReadError('zlib not supported, cannot unpack this archive.')
if not zipfile.is_zipfile(filename):
try:
import readline
import rlcompleter
- except ImportError:
+ except ModuleNotFoundError:
return
# Reading the initialization (config) file may not be enough to set a
"""Run custom site specific code, if available."""
try:
import sitecustomize
- except ImportError:
+ except ModuleNotFoundError:
pass
except Exception as err:
if os.environ.get("PYTHONVERBOSE"):
"""Run custom user specific code, if available."""
try:
import usercustomize
- except ImportError:
+ except ModuleNotFoundError:
pass
except Exception as err:
if os.environ.get("PYTHONVERBOSE"):
if options.setuid:
try:
import pwd
- except ImportError:
+ except ModuleNotFoundError:
print('Cannot import module "pwd"; try running with -n option.', file=sys.stderr)
sys.exit(1)
nobody = pwd.getpwnam('nobody')[2]
try:
import ssl
-except ImportError:
+except ModuleNotFoundError:
_have_ssl = False
else:
_have_ssl = True
try:
import errno
-except ImportError:
+except ModuleNotFoundError:
errno = None
EBADF = getattr(errno, 'EBADF', 9)
EAGAIN = getattr(errno, 'EAGAIN', 11)
import errno
try:
import threading
-except ImportError:
+except ModuleNotFoundError:
import dummy_threading as threading
__all__ = ["TCPServer","UDPServer","ForkingUDPServer","ForkingTCPServer",
import sqlite3 as sqlite
try:
import threading
-except ImportError:
+except ModuleNotFoundError:
threading = None
from test.support import TESTFN, unlink
import sqlite3 as sqlite
try:
import zlib
-except ImportError:
+except ModuleNotFoundError:
zlib = None
def _optimize_unicode(charset, fixup):
try:
import array
- except ImportError:
+ except ModuleNotFoundError:
return charset
charmap = [0]*65536
negate = 0
try:
from _ssl import PROTOCOL_SSLv2
_SSLv2_IF_EXISTS = PROTOCOL_SSLv2
-except ImportError:
+except ModuleNotFoundError:
_SSLv2_IF_EXISTS = None
else:
_PROTOCOL_NAMES[PROTOCOL_SSLv2] = "SSLv2"
try:
from _ssl import PROTOCOL_TLSv1_1, PROTOCOL_TLSv1_2
-except ImportError:
+except ModuleNotFoundError:
pass
else:
_PROTOCOL_NAMES[PROTOCOL_TLSv1_1] = "TLSv1.1"
import errno
try:
from time import monotonic as _time
-except ImportError:
+except ModuleNotFoundError:
from time import time as _time
# Exception classes used by this module.
try:
import grp, pwd
-except ImportError:
+except ModuleNotFoundError:
grp = pwd = None
# os.symlink on Windows prior to 6.0 raises NotImplementedError
if comptype == "gz":
try:
import zlib
- except ImportError:
+ except ModuleNotFoundError:
raise CompressionError("zlib module is not available")
self.zlib = zlib
self.crc = zlib.crc32(b"")
elif comptype == "bz2":
try:
import bz2
- except ImportError:
+ except ModuleNotFoundError:
raise CompressionError("bz2 module is not available")
if mode == "r":
self.dbuf = b""
elif comptype == "xz":
try:
import lzma
- except ImportError:
+ except ModuleNotFoundError:
raise CompressionError("lzma module is not available")
if mode == "r":
self.dbuf = b""
try:
import bz2
- except ImportError:
+ except ModuleNotFoundError:
raise CompressionError("bz2 module is not available")
fileobj = bz2.BZ2File(fileobj or name, mode,
try:
import lzma
- except ImportError:
+ except ModuleNotFoundError:
raise CompressionError("lzma module is not available")
fileobj = lzma.LZMAFile(fileobj or name, mode, preset=preset)
try:
import fcntl as _fcntl
-except ImportError:
+except ModuleNotFoundError:
def _set_cloexec(fd):
pass
else:
try:
import _thread
-except ImportError:
+except ModuleNotFoundError:
import _dummy_thread as _thread
_allocate_lock = _thread.allocate_lock
from time import sleep as _sleep
try:
from time import monotonic as _time
-except ImportError:
+except ModuleNotFoundError:
from time import time as _time
from traceback import format_exc as _format_exc
from _weakrefset import WeakSet
from itertools import islice as _islice
try:
from _collections import deque as _deque
-except ImportError:
+except ModuleNotFoundError:
from collections import deque as _deque
# Note regarding PEP 8 compliant names
try:
from _thread import _local as local
-except ImportError:
+except ModuleNotFoundError:
from _threading_local import local
from warnings import warn as _warn
try:
from time import monotonic as _time
-except ImportError:
+except ModuleNotFoundError:
from time import time as _time
try:
import threading
-except ImportError:
+except ModuleNotFoundError:
_settrace = sys.settrace
def _unsettrace():
# check for SSL
try:
import ssl
-except ImportError:
+except ModuleNotFoundError:
_have_ssl = False
else:
_have_ssl = True
proxies = {}
try:
import winreg
- except ImportError:
+ except ModuleNotFoundError:
# Std module, so should be around - but you never know!
return proxies
try:
def proxy_bypass_registry(host):
try:
import winreg
- except ImportError:
+ except ModuleNotFoundError:
# Std modules, so should be around - but you never know!
return 0
try:
import sysconfig
try:
import threading
-except ImportError:
+except ModuleNotFoundError:
threading = None
logger = logging.getLogger(__name__)
module = category[:i]
klass = category[i+1:]
try:
- m = __import__(module, None, None, [klass])
- except ImportError:
+ m = __import__(module, fromlist[klass])
+ except ModuleNotFoundError:
raise _OptionError("invalid module name: %r" % (module,))
try:
cat = getattr(m, klass)
defaultaction = _defaultaction
onceregistry = _onceregistry
_warnings_defaults = True
-except ImportError:
+except ModuleNotFoundError:
filters = []
defaultaction = "default"
onceregistry = {}
def __init__(self, html=0, target=None, encoding=None):
try:
from xml.parsers import expat
- except ImportError:
+ except ModuleNotFoundError:
try:
import pyexpat as expat
- except ImportError:
- raise ImportError(
- "No module named expat; use SimpleXMLTreeBuilder instead"
- )
+ except ModuleNotFoundError:
+ raise ModuleNotFoundError(
+ "No module named expat; use SimpleXMLTreeBuilder instead",
+ name='expat')
parser = expat.ParserCreate(encoding, "}")
if target is None:
target = TreeBuilder()
try:
from xml.parsers import expat
-except ImportError:
+except ModuleNotFoundError:
raise SAXReaderNotAvailable("expat not supported", None)
else:
if not hasattr(expat, "ParserCreate"):
AttributesImpl = xmlreader.AttributesImpl
AttributesNSImpl = xmlreader.AttributesNSImpl
-# If we're using a sufficiently recent version of Python, we can use
-# weak references to avoid cycles between the parser and content
-# handler, otherwise we'll just have to pretend.
-try:
- import _weakref
-except ImportError:
- def _mkproxy(o):
- return o
-else:
- import weakref
- _mkproxy = weakref.proxy
- del weakref, _weakref
+import weakref
# --- ExpatLocator
a circular reference between the parser and the content handler.
"""
def __init__(self, parser):
- self._ref = _mkproxy(parser)
+ self._ref = weakref.proxy(parser)
def getColumnNumber(self):
parser = self._ref
from io import BytesIO
try:
import gzip
-except ImportError:
+except ModuleNotFoundError:
gzip = None #python can be built without zlib/gzip support
# --------------------------------------------------------------------
projects / python / commitdiff