def cat_handler(self, args):
    '''Handler for cat command'''

    self.validate('cmd|s3', args)
    source = args[1]

    self.s3handler().print_files(source)

def cat_handler ( self , args ) : self . validate ( 'cmd|s3' , args ) source = args [ 1 ] self . s3handler ( ) . print_files ( source )


def dsync_handler(self, args):
    '''Handler for dsync command.'''
    self.opt.recursive = True
    self.opt.sync_check = True
    self.opt.force = True

    self.validate('cmd|s3,local|s3,local', args)
    source = args[1]
    target = args[2]

    self.s3handler().dsync_files(source, target)

def dsync_handler ( self , args ) : self . opt . recursive = True self . opt . sync_check = True self . opt . force = True self . validate ( 'cmd|s3,local|s3,local' , args ) source = args [ 1 ] target = args [ 2 ] self . s3handler ( ) . dsync_files ( source , target )


def cp_handler(self, args):
    '''Handler for cp command'''

    self.validate('cmd|s3|s3', args)
    source = args[1]
    target = args[2]
    self.s3handler().cp_files(source, target)

def cp_handler ( self , args ) : self . validate ( 'cmd|s3|s3' , args ) source = args [ 1 ] target = args [ 2 ] self . s3handler ( ) . cp_files ( source , target )


def mv_handler(self, args):
    '''Handler for mv command'''

    self.validate('cmd|s3|s3', args)
    source = args[1]
    target = args[2]
    self.s3handler().cp_files(source, target, delete_source=True)

def mv_handler ( self , args ) : self . validate ( 'cmd|s3|s3' , args ) source = args [ 1 ] target = args [ 2 ] self . s3handler ( ) . cp_files ( source , target , delete_source = True )


def del_handler(self, args):
    '''Handler for del command'''
    self.validate('cmd|s3', args)
    source = args[1]
    self.s3handler().del_files(source)

def del_handler ( self , args ) : self . validate ( 'cmd|s3' , args ) source = args [ 1 ] self . s3handler ( ) . del_files ( source )


def du_handler(self, args):
    '''Handler for size command'''
    for src, size in self.s3handler().size(args[1:]):
      message('%s\t%s' % (size, src))

def du_handler ( self , args ) : for src , size in self . s3handler ( ) . size ( args [ 1 : ] ) : message ( '%s\t%s' % ( size , src ) )


def _totalsize_handler(self, args):
    '''Handler of total_size command'''
    total_size = 0
    for src, size in self.s3handler().size(args[1:]):
      total_size += size
    message(str(total_size))

def _totalsize_handler ( self , args ) : total_size = 0 for src , size in self . s3handler ( ) . size ( args [ 1 : ] ) : total_size += size message ( str ( total_size ) )


def match_date(self, value):
    '''Search for date information in the string'''
    m = self.REGEX_DATE.search(value)
    date = datetime.datetime.utcnow().date()
    if m:
      date = datetime.date(int(m.group(1)), int(m.group(2)), int(m.group(3)))
      value = self.REGEX_DATE.sub('', value)
    return (date, value)

def match_date ( self , value ) : m = self . REGEX_DATE . search ( value ) date = datetime . datetime . utcnow ( ) . date ( ) if m : date = datetime . date ( int ( m . group ( 1 ) ) , int ( m . group ( 2 ) ) , int ( m . group ( 3 ) ) ) value = self . REGEX_DATE . sub ( '' , value ) return ( date , value )


def match_time(self, value):
    '''Search for time information in the string'''
    m = self.REGEX_TIME.search(value)
    time = datetime.datetime.utcnow().time()
    if m:
      time = datetime.time(int(m.group(1)), int(m.group(2)))
      value = self.REGEX_TIME.sub('', value)
    return (time, value)

def match_time ( self , value ) : m = self . REGEX_TIME . search ( value ) time = datetime . datetime . utcnow ( ) . time ( ) if m : time = datetime . time ( int ( m . group ( 1 ) ) , int ( m . group ( 2 ) ) ) value = self . REGEX_TIME . sub ( '' , value ) return ( time , value )


def match_delta(self, value):
    '''Search for timedelta information in the string'''
    m = self.REGEX_DELTA.search(value)
    delta = datetime.timedelta(days=0)
    if m:
      d = int(m.group(1))
      if m.group(3) == 'ago' or m.group(3) == 'before':
        d = -d

      if m.group(2) == 'minute':
        delta = datetime.timedelta(minutes=d)
      elif m.group(2) == 'hour':
        delta = datetime.timedelta(hours=d)
      elif m.group(2) == 'day':
        delta = datetime.timedelta(days=d)
      elif m.group(2) == 'week':
        delta = datetime.timedelta(weeks=d)
      value = self.REGEX_DELTA.sub('', value)
    return (delta, value)

def match_delta ( self , value ) : m = self . REGEX_DELTA . search ( value ) delta = datetime . timedelta ( days = 0 ) if m : d = int ( m . group ( 1 ) ) if m . group ( 3 ) == 'ago' or m . group ( 3 ) == 'before' : d = - d if m . group ( 2 ) == 'minute' : delta = datetime . timedelta ( minutes = d ) elif m . group ( 2 ) == 'hour' : delta = datetime . timedelta ( hours = d ) elif m . group ( 2 ) == 'day' : delta = datetime . timedelta ( days = d ) elif m . group ( 2 ) == 'week' : delta = datetime . timedelta ( weeks = d ) value = self . REGEX_DELTA . sub ( '' , value ) return ( delta , value )


def check_dict(self, opt, value):
    '''Take json as dictionary parameter'''
    try:
      return json.loads(value)
    except:
      raise optparse.OptionValueError("Option %s: invalid dict value: %r" % (opt, value))

def
check_dict
(
self
,
opt
,
value
)
:
try
:
return
json
.
loads
(
value
)
except
:
raise
optparse
.
OptionValueError
(
"Option %s: invalid dict value: %r"
%
(
opt
,
value
)
)


def discover_gateways(self):
        """Discover gateways using multicast"""

        _socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        _socket.settimeout(5.0)
        if self._interface != 'any':
            _socket.bind((self._interface, 0))

        for gateway in self._gateways_config:
            host = gateway.get('host')
            port = gateway.get('port')
            sid = gateway.get('sid')

            if not (host and port and sid):
                continue
            try:
                ip_address = socket.gethostbyname(host)
                if gateway.get('disable'):
                    _LOGGER.info(
                        'Xiaomi Gateway %s is disabled by configuration', sid)
                    self.disabled_gateways.append(ip_address)
                    continue
                _LOGGER.info(
                    'Xiaomi Gateway %s configured at IP %s:%s',
                    sid, ip_address, port)

                self.gateways[ip_address] = XiaomiGateway(
                    ip_address, port, sid,
                    gateway.get('key'), self._device_discovery_retries,
                    self._interface, gateway.get('proto'))
            except OSError as error:
                _LOGGER.error(
                    "Could not resolve %s: %s", host, error)

        try:
            _socket.sendto('{"cmd":"whois"}'.encode(),
                           (self.MULTICAST_ADDRESS, self.GATEWAY_DISCOVERY_PORT))

            while True:
                data, (ip_add, _) = _socket.recvfrom(1024)
                if len(data) is None or ip_add in self.gateways:
                    continue

                if ip_add in self.gateways.keys() or ip_add in self.disabled_gateways:
                    continue

                resp = json.loads(data.decode())
                if resp["cmd"] != 'iam':
                    _LOGGER.error("Response does not match return cmd")
                    continue

                if resp["model"] not in GATEWAY_MODELS:
                    _LOGGER.error("Response must be gateway model")
                    continue

                disabled = False
                gateway_key = None
                for gateway in self._gateways_config:
                    sid = gateway.get('sid')
                    if sid is None or sid == resp["sid"]:
                        gateway_key = gateway.get('key')
                    if sid and sid == resp['sid'] and gateway.get('disable'):
                        disabled = True

                sid = resp["sid"]
                if disabled:
                    _LOGGER.info("Xiaomi Gateway %s is disabled by configuration",
                                 sid)
                    self.disabled_gateways.append(ip_add)
                else:
                    _LOGGER.info('Xiaomi Gateway %s found at IP %s', sid, ip_add)
                    self.gateways[ip_add] = XiaomiGateway(
                        ip_add, resp["port"], sid, gateway_key,
                        self._device_discovery_retries, self._interface,
                        resp["proto_version"] if "proto_version" in resp else None)

        except socket.timeout:
            _LOGGER.info("Gateway discovery finished in 5 seconds")
            _socket.close()


def listen(self):
        """Start listening."""

        _LOGGER.info('Creating Multicast Socket')
        self._mcastsocket = self._create_mcast_socket()
        self._listening = True
        thread = Thread(target=self._listen_to_msg, args=())
        self._threads.append(thread)
        thread.daemon = True
        thread.start()

def
listen
(
self
)
:
_LOGGER
.
info
(
'Creating Multicast Socket'
)
self
.
_mcastsocket
=
self
.
_create_mcast_socket
(
)
self
.
_listening
=
True
thread
=
Thread
(
target
=
self
.
_listen_to_msg
,
args
=
(
)
)
self
.
_threads
.
append
(
thread
)
thread
.
daemon
=
True
thread
.
start
(
)


def get_from_hub(self, sid):
        """Get data from gateway"""
        cmd = '{ "cmd":"read","sid":"' + sid + '"}'
        resp = self._send_cmd(cmd, "read_ack") if int(self.proto[0:1]) == 1 else self._send_cmd(cmd, "read_rsp")
        _LOGGER.debug("read_ack << %s", resp)
        return self.push_data(resp)

def
get_from_hub
(
self
,
sid
)
:
cmd
=
'{ "cmd":"read","sid":"'
+
sid
+
'"}'
resp
=
self
.
_send_cmd
(
cmd
,
"read_ack"
)
if
int
(
self
.
proto
[
0
:
1
]
)
==
1
else
self
.
_send_cmd
(
cmd
,
"read_rsp"
)
_LOGGER
.
debug
(
"read_ack << %s"
,
resp
)
return
self
.
push_data
(
resp
)


def push_data(self, data):
        """Push data broadcasted from gateway to device"""
        if not _validate_data(data):
            return False
        jdata = json.loads(data['data']) if int(self.proto[0:1]) == 1 else _list2map(data['params'])
        if jdata is None:
            return False
        sid = data['sid']
        for func in self.callbacks[sid]:
            func(jdata, data)
        return True

def push_data ( self , data ) : if not _validate_data ( data ) : return False jdata = json . loads ( data [ 'data' ] ) if int ( self . proto [ 0 : 1 ] ) == 1 else _list2map ( data [ 'params' ] ) if jdata is None : return False sid = data [ 'sid' ] for func in self . callbacks [ sid ] : func ( jdata , data ) return True


def _get_key(self):
        """Get key using token from gateway"""
        init_vector = bytes(bytearray.fromhex('17996d093d28ddb3ba695a2e6f58562e'))
        encryptor = Cipher(algorithms.AES(self.key.encode()), modes.CBC(init_vector),
                           backend=default_backend()).encryptor()
        ciphertext = encryptor.update(self.token.encode()) + encryptor.finalize()
        if isinstance(ciphertext, str):  # For Python 2 compatibility
            return ''.join('{:02x}'.format(ord(x)) for x in ciphertext)
        return ''.join('{:02x}'.format(x) for x in ciphertext)

def
_get_key
(
self
)
:
init_vector
=
bytes
(
bytearray
.
fromhex
(
'17996d093d28ddb3ba695a2e6f58562e'
)
)
encryptor
=
Cipher
(
algorithms
.
AES
(
self
.
key
.
encode
(
)
)
,
modes
.
CBC
(
init_vector
)
,
backend
=
default_backend
(
)
)
.
encryptor
(
)
ciphertext
=
encryptor
.
update
(
self
.
token
.
encode
(
)
)
+
encryptor
.
finalize
(
)
if
isinstance
(
ciphertext
,
str
)
:
# For Python 2 compatibility
return
''
.
join
(
'{:02x}'
.
format
(
ord
(
x
)
)
for
x
in
ciphertext
)
return
''
.
join
(
'{:02x}'
.
format
(
x
)
for
x
in
ciphertext
)


def exception_handler(job, *exc_info):
    """
    Called by RQ when there is a failure in a worker.

    NOTE: Make sure that in your RQ worker process, rollbar.init() has been called with
    handler='blocking'. The default handler, 'thread', does not work from inside an RQ worker.
    """
    # Report data about the job with the exception.
    job_info = job.to_dict()
    # job_info['data'] is the pickled representation of the job, and doesn't json-serialize well.
    # repr() works nicely.
    job_info['data'] = repr(job_info['data'])

    extra_data = {'job': job_info}
    payload_data = {'framework': 'rq'}

    rollbar.report_exc_info(exc_info, extra_data=extra_data, payload_data=payload_data)

    # continue to the next handler
    return True

Called by RQ when there is a failure in a worker .


def includeme(config):
    """
    Pyramid entry point
    """
    settings = config.registry.settings

    config.add_tween('rollbar.contrib.pyramid.rollbar_tween_factory', over=EXCVIEW)

    # run patch_debugtoolbar, unless they disabled it
    if asbool(settings.get('rollbar.patch_debugtoolbar', True)):
        patch_debugtoolbar(settings)

    def hook(request, data):
        data['framework'] = 'pyramid'

        if request:
            request.environ['rollbar.uuid'] = data['uuid']

            if request.matched_route:
                data['context'] = request.matched_route.name

    rollbar.BASE_DATA_HOOK = hook

    kw = parse_settings(settings)

    access_token = kw.pop('access_token')
    environment = kw.pop('environment', 'production')

    if kw.get('scrub_fields'):
        kw['scrub_fields'] = set([str.strip(x) for x in kw.get('scrub_fields').split('\n') if x])

    if kw.get('exception_level_filters'):
        r = DottedNameResolver()
        exception_level_filters = []
        for line in kw.get('exception_level_filters').split('\n'):
            if line:
                dotted_path, level = line.split()

                try:
                    cls = r.resolve(dotted_path)
                    exception_level_filters.append((cls, level))
                except ImportError:
                    log.error('Could not import %r' % dotted_path)

        kw['exception_level_filters'] = exception_level_filters

    kw['enabled'] = asbool(kw.get('enabled', True))

    rollbar.init(access_token, environment, **kw)


def _ensure_log_handler(self):
        """
        If there's no log configuration, set up a default handler.
        """
        if log.handlers:
            return
        handler = logging.StreamHandler()
        formatter = logging.Formatter(
            '%(asctime)s %(levelname)-5.5s [%(name)s][%(threadName)s] %(message)s')
        handler.setFormatter(formatter)
        log.addHandler(handler)

If there s no log configuration set up a default handler .


def get_request():
    """
    Get the current request object. Implementation varies on
    library support. Modified below when we know which framework
    is being used.
    """

    # TODO(cory): add in a generic _get_locals_request() which
    # will iterate up through the call stack and look for a variable
    # that appears to be valid request object.
    for fn in (_get_bottle_request,
               _get_flask_request,
               _get_pyramid_request,
               _get_pylons_request):
        try:
            req = fn()
            if req is not None:
                return req
        except:
            pass

    return None

Get the current request object . Implementation varies on library support . Modified below when we know which framework is being used .


def init(access_token, environment='production', scrub_fields=None, url_fields=None, **kw):
    """
    Saves configuration variables in this module's SETTINGS.

    access_token: project access token. Get this from the Rollbar UI:
                  - click "Settings" in the top nav
                  - click "Projects" in the left nav
                  - copy-paste the appropriate token.
    environment: environment name. Can be any string; suggestions: 'production', 'development',
                 'staging', 'yourname'
    **kw: provided keyword arguments will override keys in SETTINGS.
    """
    global SETTINGS, agent_log, _initialized, _transforms, _serialize_transform, _threads

    if scrub_fields is not None:
       SETTINGS['scrub_fields'] = list(scrub_fields)
    if url_fields is not None:
       SETTINGS['url_fields'] = list(url_fields)

    # Merge the extra config settings into SETTINGS
    SETTINGS = dict_merge(SETTINGS, kw)
    if _initialized:
        # NOTE: Temp solution to not being able to re-init.
        # New versions of pyrollbar will support re-initialization
        # via the (not-yet-implemented) configure() method.
        if not SETTINGS.get('suppress_reinit_warning'):
            log.warning('Rollbar already initialized. Ignoring re-init.')
        return

    SETTINGS['access_token'] = access_token
    SETTINGS['environment'] = environment

    if SETTINGS.get('allow_logging_basic_config'):
        logging.basicConfig()

    if SETTINGS.get('handler') == 'agent':
        agent_log = _create_agent_log()

    # We will perform these transforms in order:
    # 1. Serialize the payload to be all python built-in objects
    # 2. Scrub the payloads based on the key suffixes in SETTINGS['scrub_fields']
    # 3. Scrub URLs in the payload for keys that end with 'url'
    # 4. Optional - If local variable gathering is enabled, transform the
    #       trace frame values using the ShortReprTransform.
    _serialize_transform = SerializableTransform(safe_repr=SETTINGS['locals']['safe_repr'],
                                                 whitelist_types=SETTINGS['locals']['whitelisted_types'])
    _transforms = [
        ScrubRedactTransform(),
        _serialize_transform,
        ScrubTransform(suffixes=[(field,) for field in SETTINGS['scrub_fields']], redact_char='*'),
        ScrubUrlTransform(suffixes=[(field,) for field in SETTINGS['url_fields']], params_to_scrub=SETTINGS['scrub_fields'])
    ]

    # A list of key prefixes to apply our shortener transform to. The request
    # being included in the body key is old behavior and is being retained for
    # backwards compatibility.
    shortener_keys = [
        ('request', 'POST'),
        ('request', 'json'),
        ('body', 'request', 'POST'),
        ('body', 'request', 'json'),
    ]

    if SETTINGS['locals']['enabled']:
        shortener_keys.append(('body', 'trace', 'frames', '*', 'code'))
        shortener_keys.append(('body', 'trace', 'frames', '*', 'args', '*'))
        shortener_keys.append(('body', 'trace', 'frames', '*', 'kwargs', '*'))
        shortener_keys.append(('body', 'trace', 'frames', '*', 'locals', '*'))

    shortener_keys.extend(SETTINGS['shortener_keys'])

    shortener = ShortenerTransform(safe_repr=SETTINGS['locals']['safe_repr'],
                                   keys=shortener_keys,
                                   **SETTINGS['locals']['sizes'])
    _transforms.append(shortener)
    _threads = queue.Queue()
    events.reset()
    filters.add_builtin_filters(SETTINGS)

    _initialized = True

Saves configuration variables in this module s SETTINGS .


def lambda_function(f):
    """
    Decorator for making error handling on AWS Lambda easier
    """
    @functools.wraps(f)
    def wrapper(event, context):
        global _CURRENT_LAMBDA_CONTEXT
        _CURRENT_LAMBDA_CONTEXT = context
        try:
            result = f(event, context)
            return wait(lambda: result)
        except:
            cls, exc, trace = sys.exc_info()
            report_exc_info((cls, exc, trace.tb_next))
            wait()
            raise
    return wrapper

def lambda_function ( f ) : @ functools . wraps ( f ) def wrapper ( event , context ) : global _CURRENT_LAMBDA_CONTEXT _CURRENT_LAMBDA_CONTEXT = context try : result = f ( event , context ) return wait ( lambda : result ) except : cls , exc , trace = sys . exc_info ( ) report_exc_info ( ( cls , exc , trace . tb_next ) ) wait ( ) raise return wrapper


def report_message(message, level='error', request=None, extra_data=None, payload_data=None):
    """
    Reports an arbitrary string message to Rollbar.

    message: the string body of the message
    level: level to report at. One of: 'critical', 'error', 'warning', 'info', 'debug'
    request: the request object for the context of the message
    extra_data: dictionary of params to include with the message. 'body' is reserved.
    payload_data: param names to pass in the 'data' level of the payload; overrides defaults.
    """
    try:
        return _report_message(message, level, request, extra_data, payload_data)
    except Exception as e:
        log.exception("Exception while reporting message to Rollbar. %r", e)

Reports an arbitrary string message to Rollbar .


def search_items(title, return_fields=None, access_token=None, endpoint=None, **search_fields):
    """
    Searches a project for items that match the input criteria.

    title: all or part of the item's title to search for.
    return_fields: the fields that should be returned for each item.
            e.g. ['id', 'project_id', 'status'] will return a dict containing
                 only those fields for each item.
    access_token: a project access token. If this is not provided,
                  the one provided to init() will be used instead.
    search_fields: additional fields to include in the search.
            currently supported: status, level, environment
    """
    if not title:
        return []

    if return_fields is not None:
        return_fields = ','.join(return_fields)

    return _get_api('search/',
                    title=title,
                    fields=return_fields,
                    access_token=access_token,
                    endpoint=endpoint,
                    **search_fields)

def search_items ( title , return_fields = None , access_token = None , endpoint = None , * * search_fields ) : if not title : return [ ] if return_fields is not None : return_fields = ',' . join ( return_fields ) return _get_api ( 'search/' , title = title , fields = return_fields , access_token = access_token , endpoint = endpoint , * * search_fields )

Searches a project for items that match the input criteria .


def _create_agent_log():
    """
    Creates .rollbar log file for use with rollbar-agent
    """
    log_file = SETTINGS['agent.log_file']
    if not log_file.endswith('.rollbar'):
        log.error("Provided agent log file does not end with .rollbar, which it must. "
                  "Using default instead.")
        log_file = DEFAULTS['agent.log_file']

    retval = logging.getLogger('rollbar_agent')
    handler = logging.FileHandler(log_file, 'a', 'utf-8')
    formatter = logging.Formatter('%(message)s')
    handler.setFormatter(formatter)
    retval.addHandler(handler)
    retval.setLevel(logging.WARNING)
    return retval

Creates . rollbar log file for use with rollbar - agent


def _build_person_data(request):
    """
    Returns a dictionary describing the logged-in user using data from `request.

    Try request.rollbar_person first, then 'user', then 'user_id'
    """
    if hasattr(request, 'rollbar_person'):
        rollbar_person_prop = request.rollbar_person
        try:
            person = rollbar_person_prop()
        except TypeError:
            person = rollbar_person_prop

        if person and isinstance(person, dict):
            return person
        else:
            return None

    if hasattr(request, 'user'):
        user_prop = request.user
        try:
            user = user_prop()
        except TypeError:
            user = user_prop

        if not user:
            return None
        elif isinstance(user, dict):
            return user
        else:
            retval = {}
            if getattr(user, 'id', None):
                retval['id'] = text(user.id)
            elif getattr(user, 'user_id', None):
                retval['id'] = text(user.user_id)

            # id is required, so only include username/email if we have an id
            if retval.get('id'):
                username = getattr(user, 'username', None)
                email = getattr(user, 'email', None)
                retval.update({
                    'username': username,
                    'email': email
                })
            return retval

    if hasattr(request, 'user_id'):
        user_id_prop = request.user_id
        try:
            user_id = user_id_prop()
        except TypeError:
            user_id = user_id_prop

        if not user_id:
            return None
        return {'id': text(user_id)}

Returns a dictionary describing the logged - in user using data from request .


def _add_lambda_context_data(data):
    """
    Attempts to add information from the lambda context if it exists
    """
    global _CURRENT_LAMBDA_CONTEXT
    context = _CURRENT_LAMBDA_CONTEXT
    if context is None:
        return
    try:
        lambda_data = {
            'lambda': {
                'remaining_time_in_millis': context.get_remaining_time_in_millis(),
                'function_name': context.function_name,
                'function_version': context.function_version,
                'arn': context.invoked_function_arn,
                'request_id': context.aws_request_id,
            }
        }
        if 'custom' in data:
            data['custom'] = dict_merge(data['custom'], lambda_data)
        else:
            data['custom'] = lambda_data
    except Exception as e:
        log.exception("Exception while adding lambda context data: %r", e)
    finally:
        _CURRENT_LAMBDA_CONTEXT = None


def _add_request_data(data, request):
    """
    Attempts to build request data; if successful, sets the 'request' key on `data`.
    """
    try:
        request_data = _build_request_data(request)
    except Exception as e:
        log.exception("Exception while building request_data for Rollbar payload: %r", e)
    else:
        if request_data:
            _filter_ip(request_data, SETTINGS['capture_ip'])
            data['request'] = request_data

Attempts to build request data ; if successful sets the request key on data .


def _check_add_locals(frame, frame_num, total_frames):
    """
    Returns True if we should record local variables for the given frame.
    """
    # Include the last frames locals
    # Include any frame locals that came from a file in the project's root
    return any(((frame_num == total_frames - 1),
                ('root' in SETTINGS and (frame.get('filename') or '').lower().startswith((SETTINGS['root'] or '').lower()))))

Returns True if we should record local variables for the given frame .


def _build_request_data(request):
    """
    Returns a dictionary containing data from the request.
    Can handle webob or werkzeug-based request objects.
    """

    # webob (pyramid)
    if WebobBaseRequest and isinstance(request, WebobBaseRequest):
        return _build_webob_request_data(request)

    # django
    if DjangoHttpRequest and isinstance(request, DjangoHttpRequest):
        return _build_django_request_data(request)

    # django rest framework
    if RestFrameworkRequest and isinstance(request, RestFrameworkRequest):
        return _build_django_request_data(request)

    # werkzeug (flask)
    if WerkzeugRequest and isinstance(request, WerkzeugRequest):
        return _build_werkzeug_request_data(request)

    # tornado
    if TornadoRequest and isinstance(request, TornadoRequest):
        return _build_tornado_request_data(request)

    # bottle
    if BottleRequest and isinstance(request, BottleRequest):
        return _build_bottle_request_data(request)

    # Sanic
    if SanicRequest and isinstance(request, SanicRequest):
        return _build_sanic_request_data(request)

    # falcon
    if FalconRequest and isinstance(request, FalconRequest):
        return _build_falcon_request_data(request)

    # Plain wsgi (should be last)
    if isinstance(request, dict) and 'wsgi.version' in request:
        return _build_wsgi_request_data(request)

    return None

def
_build_request_data
(
request
)
:
# webob (pyramid)
if
WebobBaseRequest
and
isinstance
(
request
,
WebobBaseRequest
)
:
return
_build_webob_request_data
(
request
)
# django
if
DjangoHttpRequest
and
isinstance
(
request
,
DjangoHttpRequest
)
:
return
_build_django_request_data
(
request
)
# django rest framework
if
RestFrameworkRequest
and
isinstance
(
request
,
RestFrameworkRequest
)
:
return
_build_django_request_data
(
request
)
# werkzeug (flask)
if
WerkzeugRequest
and
isinstance
(
request
,
WerkzeugRequest
)
:
return
_build_werkzeug_request_data
(
request
)
# tornado
if
TornadoRequest
and
isinstance
(
request
,
TornadoRequest
)
:
return
_build_tornado_request_data
(
request
)
# bottle
if
BottleRequest
and
isinstance
(
request
,
BottleRequest
)
:
return
_build_bottle_request_data
(
request
)
# Sanic
if
SanicRequest
and
isinstance
(
request
,
SanicRequest
)
:
return
_build_sanic_request_data
(
request
)
# falcon
if
FalconRequest
and
isinstance
(
request
,
FalconRequest
)
:
return
_build_falcon_request_data
(
request
)
# Plain wsgi (should be last)
if
isinstance
(
request
,
dict
)
and
'wsgi.version'
in
request
:
return
_build_wsgi_request_data
(
request
)
return

Returns a dictionary containing data from the request . Can handle webob or werkzeug - based request objects .


def _build_server_data():
    """
    Returns a dictionary containing information about the server environment.
    """
    # server environment
    server_data = {
        'host': socket.gethostname(),
        'pid': os.getpid()
    }

    # argv does not always exist in embedded python environments
    argv = getattr(sys, 'argv', None)
    if argv:
         server_data['argv'] = argv

    for key in ['branch', 'root']:
        if SETTINGS.get(key):
            server_data[key] = SETTINGS[key]

    return server_data

Returns a dictionary containing information about the server environment .


def _build_payload(data):
    """
    Returns the full payload as a string.
    """

    for k, v in iteritems(data):
        data[k] = _transform(v, key=(k,))

    payload = {
        'access_token': SETTINGS['access_token'],
        'data': data
    }

    return payload

def _build_payload ( data ) : for k , v in iteritems ( data ) : data [ k ] = _transform ( v , key = ( k , ) ) payload = { 'access_token' : SETTINGS [ 'access_token' ] , 'data' : data } return payload


def main():
    rollbar.init('ACCESS_TOKEN', environment='test', handler='twisted')

    """This runs the protocol on port 8000"""
    factory = protocol.ServerFactory()
    factory.protocol = Echo
    reactor.listenTCP(8000, factory)
    reactor.run()

def main ( ) : rollbar . init ( 'ACCESS_TOKEN' , environment = 'test' , handler = 'twisted' ) factory = protocol . ServerFactory ( ) factory . protocol = Echo reactor . listenTCP ( 8000 , factory ) reactor . run ( )


def compose(chosung, joongsung, jongsung=u''):
    """This function returns a Hangul letter by composing the specified chosung, joongsung, and jongsung.
    @param chosung
    @param joongsung
    @param jongsung the terminal Hangul letter. This is optional if you do not need a jongsung."""

    if jongsung is None: jongsung = u''

    try:
        chosung_index = CHO.index(chosung)
        joongsung_index = JOONG.index(joongsung)
        jongsung_index = JONG.index(jongsung)
    except Exception:
        raise NotHangulException('No valid Hangul character index')

    return unichr(0xAC00 + chosung_index * NUM_JOONG * NUM_JONG + joongsung_index * NUM_JONG + jongsung_index)

def
compose
(
chosung
,
joongsung
,
jongsung
=
u''
)
:
if
jongsung
is
:
jongsung
=
u''
try
:
chosung_index
=
CHO
.
index
(
chosung
)
joongsung_index
=
JOONG
.
index
(
joongsung
)
jongsung_index
=
JONG
.
index
(
jongsung
)
except
Exception
:
raise
NotHangulException
(
'No valid Hangul character index'
)
return
unichr
(
0xAC00
+
chosung_index
*
NUM_JOONG
*
NUM_JONG
+
joongsung_index
*
NUM_JONG
+
jongsung_index
)

This function returns a Hangul letter by composing the specified chosung joongsung and jongsung .


def decompose(hangul_letter):
    """This function returns letters by decomposing the specified Hangul letter."""

    from . import checker

    if len(hangul_letter) < 1:
        raise NotLetterException('')
    elif not checker.is_hangul(hangul_letter):
        raise NotHangulException('')

    if hangul_letter in CHO:
        return hangul_letter, '', ''

    if hangul_letter in JOONG:
        return '', hangul_letter, ''

    if hangul_letter in JONG:
        return '', '', hangul_letter

    code = hangul_index(hangul_letter)
    cho, joong, jong = decompose_index(code)

    if cho < 0:
        cho = 0

    try:
        return CHO[cho], JOONG[joong], JONG[jong]
    except:
        print("%d / %d  / %d"%(cho, joong, jong))
        print("%s / %s " %( JOONG[joong].encode("utf8"), JONG[jong].encode('utf8')))
        raise Exception()

def
decompose
(
hangul_letter
)
:
from
.
import
checker
if
len
(
hangul_letter
)
<
1
:
raise
NotLetterException
(
''
)
elif
not
checker
.
is_hangul
(
hangul_letter
)
:
raise
NotHangulException
(
''
)
if
hangul_letter
in
CHO
:
return
hangul_letter
,
''
,
''
if
hangul_letter
in
JOONG
:
return
''
,
hangul_letter
,
''
if
hangul_letter
in
JONG
:
return
''
,
''
,
hangul_letter
code
=
hangul_index
(
hangul_letter
)
cho
,
joong
,
jong
=
decompose_index
(
code
)
if
cho
<
0
:
cho
=
0
try
:
return
CHO
[
cho
]
,
JOONG
[
joong
]
,
JONG
[
jong
]
except
:
print
(
"%d / %d  / %d"
%
(
cho
,
joong
,
jong
)
)
print
(
"%s / %s "
%
(
JOONG
[
joong
]
.
encode
(
"utf8"
)
,
JONG
[
jong
]
.
encode
(
'utf8'
)
)
)
raise
Exception
(
)

This function returns letters by decomposing the specified Hangul letter .


def has_jongsung(letter):
    """Check whether this letter contains Jongsung"""
    if len(letter) != 1:
        raise Exception('The target string must be one letter.')
    if not is_hangul(letter):
        raise NotHangulException('The target string must be Hangul')

    code = lt.hangul_index(letter)
    return code % NUM_JONG > 0

def
has_jongsung
(
letter
)
:
if
len
(
letter
)
!=
1
:
raise
Exception
(
'The target string must be one letter.'
)
if
not
is_hangul
(
letter
)
:
raise
NotHangulException
(
'The target string must be Hangul'
)
code
=
lt
.
hangul_index
(
letter
)
return
code
%
NUM_JONG
>
0


def attach(word, josa=EUN_NEUN):
    """add josa at the end of this word"""
    last_letter = word.strip()[-1]
    try:
        _, _, letter_jong = letter.decompose(last_letter)
    except NotHangulException:
        letter_jong = letter.get_substituent_of(last_letter)

    if letter_jong in ('', josa['except']):
        return word + josa['has']

    return word + josa['not']

def attach ( word , josa = EUN_NEUN ) : last_letter = word . strip ( ) [ - 1 ] try : _ , _ , letter_jong = letter . decompose ( last_letter ) except NotHangulException : letter_jong = letter . get_substituent_of ( last_letter ) if letter_jong in ( '' , josa [ 'except' ] ) : return word + josa [ 'has' ] return word + josa [ 'not' ]


def is_inside_except(node):
    """Returns true if node is inside the name of an except handler."""
    current = node
    while current and not isinstance(current.parent, astroid.ExceptHandler):
        current = current.parent

    return current and current is current.parent.name

def is_inside_except ( node ) : current = node while current and not isinstance ( current . parent , astroid . ExceptHandler ) : current = current . parent return current and current is current . parent . name

Returns true if node is inside the name of an except handler .


def is_inside_lambda(node: astroid.node_classes.NodeNG) -> bool:
    """Return true if given node is inside lambda"""
    parent = node.parent
    while parent is not None:
        if isinstance(parent, astroid.Lambda):
            return True
        parent = parent.parent
    return False

def is_inside_lambda ( node : astroid . node_classes . NodeNG ) -> bool : parent = node . parent while parent is not None : if isinstance ( parent , astroid . Lambda ) : return True parent = parent . parent return False


def get_all_elements(
    node: astroid.node_classes.NodeNG
) -> Iterable[astroid.node_classes.NodeNG]:
    """Recursively returns all atoms in nested lists and tuples."""
    if isinstance(node, (astroid.Tuple, astroid.List)):
        for child in node.elts:
            for e in get_all_elements(child):
                yield e
    else:
        yield node

def get_all_elements ( node : astroid . node_classes . NodeNG ) -> Iterable [ astroid . node_classes . NodeNG ] : if isinstance ( node , ( astroid . Tuple , astroid . List ) ) : for child in node . elts : for e in get_all_elements ( child ) : yield e else : yield node

Recursively returns all atoms in nested lists and tuples .


def clobber_in_except(
    node: astroid.node_classes.NodeNG
) -> Tuple[bool, Tuple[str, str]]:
    """Checks if an assignment node in an except handler clobbers an existing
    variable.

    Returns (True, args for W0623) if assignment clobbers an existing variable,
    (False, None) otherwise.
    """
    if isinstance(node, astroid.AssignAttr):
        return True, (node.attrname, "object %r" % (node.expr.as_string(),))
    if isinstance(node, astroid.AssignName):
        name = node.name
        if is_builtin(name):
            return (True, (name, "builtins"))

        stmts = node.lookup(name)[1]
        if stmts and not isinstance(
            stmts[0].assign_type(),
            (astroid.Assign, astroid.AugAssign, astroid.ExceptHandler),
        ):
            return True, (name, "outer scope (line %s)" % stmts[0].fromlineno)
    return False, None

def
clobber_in_except
(
node
:
astroid
.
node_classes
.
NodeNG
)
->
Tuple
[
bool
,
Tuple
[
str
,
str
]
]
:
if
isinstance
(
node
,
astroid
.
AssignAttr
)
:
return
True
,
(
node
.
attrname
,
"object %r"
%
(
node
.
expr
.
as_string
(
)
,
)
)
if
isinstance
(
node
,
astroid
.
AssignName
)
:
name
=
node
.
name
if
is_builtin
(
name
)
:
return
(
True
,
(
name
,
"builtins"
)
)
stmts
=
node
.
lookup
(
name
)
[
1
]
if
stmts
and
not
isinstance
(
stmts
[
0
]
.
assign_type
(
)
,
(
astroid
.
Assign
,
astroid
.
AugAssign
,
astroid
.
ExceptHandler
)
,
)
:
return
True
,
(
name
,
"outer scope (line %s)"
%
stmts
[
0
]
.
fromlineno
)
return
False
,

Checks if an assignment node in an except handler clobbers an existing variable .


def is_super(node: astroid.node_classes.NodeNG) -> bool:
    """return True if the node is referencing the "super" builtin function
    """
    if getattr(node, "name", None) == "super" and node.root().name == BUILTINS_NAME:
        return True
    return False

def is_super ( node : astroid . node_classes . NodeNG ) -> bool : if getattr ( node , "name" , None ) == "super" and node . root ( ) . name == BUILTINS_NAME : return True return False

return True if the node is referencing the super builtin function


def is_error(node: astroid.node_classes.NodeNG) -> bool:
    """return true if the function does nothing but raising an exception"""
    for child_node in node.get_children():
        if isinstance(child_node, astroid.Raise):
            return True
    return False

def is_error ( node : astroid . node_classes . NodeNG ) -> bool : for child_node in node . get_children ( ) : if isinstance ( child_node , astroid . Raise ) : return True return False


def is_default_argument(node: astroid.node_classes.NodeNG) -> bool:
    """return true if the given Name node is used in function or lambda
    default argument's value
    """
    parent = node.scope()
    if isinstance(parent, (astroid.FunctionDef, astroid.Lambda)):
        for default_node in parent.args.defaults:
            for default_name_node in default_node.nodes_of_class(astroid.Name):
                if default_name_node is node:
                    return True
    return False

def is_default_argument ( node : astroid . node_classes . NodeNG ) -> bool : parent = node . scope ( ) if isinstance ( parent , ( astroid . FunctionDef , astroid . Lambda ) ) : for default_node in parent . args . defaults : for default_name_node in default_node . nodes_of_class ( astroid . Name ) : if default_name_node is node : return True return False

return true if the given Name node is used in function or lambda default argument s value


def is_func_decorator(node: astroid.node_classes.NodeNG) -> bool:
    """return true if the name is used in function decorator"""
    parent = node.parent
    while parent is not None:
        if isinstance(parent, astroid.Decorators):
            return True
        if parent.is_statement or isinstance(
            parent,
            (astroid.Lambda, scoped_nodes.ComprehensionScope, scoped_nodes.ListComp),
        ):
            break
        parent = parent.parent
    return False

def is_func_decorator ( node : astroid . node_classes . NodeNG ) -> bool : parent = node . parent while parent is not None : if isinstance ( parent , astroid . Decorators ) : return True if parent . is_statement or isinstance ( parent , ( astroid . Lambda , scoped_nodes . ComprehensionScope , scoped_nodes . ListComp ) , ) : break parent = parent . parent return False


def is_ancestor_name(
    frame: astroid.node_classes.NodeNG, node: astroid.node_classes.NodeNG
) -> bool:
    """return True if `frame` is an astroid.Class node with `node` in the
    subtree of its bases attribute
    """
    try:
        bases = frame.bases
    except AttributeError:
        return False
    for base in bases:
        if node in base.nodes_of_class(astroid.Name):
            return True
    return False

def is_ancestor_name ( frame : astroid . node_classes . NodeNG , node : astroid . node_classes . NodeNG ) -> bool : try : bases = frame . bases except AttributeError : return False for base in bases : if node in base . nodes_of_class ( astroid . Name ) : return True return False

return True if frame is an astroid . Class node with node in the subtree of its bases attribute


def assign_parent(node: astroid.node_classes.NodeNG) -> astroid.node_classes.NodeNG:
    """return the higher parent which is not an AssignName, Tuple or List node
    """
    while node and isinstance(node, (astroid.AssignName, astroid.Tuple, astroid.List)):
        node = node.parent
    return node

def assign_parent ( node : astroid . node_classes . NodeNG ) -> astroid . node_classes . NodeNG : while node and isinstance ( node , ( astroid . AssignName , astroid . Tuple , astroid . List ) ) : node = node . parent return node

return the higher parent which is not an AssignName Tuple or List node


def check_messages(*messages: str) -> Callable:
    """decorator to store messages that are handled by a checker method"""

    def store_messages(func):
        func.checks_msgs = messages
        return func

    return store_messages

def check_messages ( * messages : str ) -> Callable : def store_messages ( func ) : func . checks_msgs = messages return func return store_messages


def collect_string_fields(format_string) -> Iterable[Optional[str]]:
    """ Given a format string, return an iterator
    of all the valid format fields. It handles nested fields
    as well.
    """
    formatter = string.Formatter()
    try:
        parseiterator = formatter.parse(format_string)
        for result in parseiterator:
            if all(item is None for item in result[1:]):
                # not a replacement format
                continue
            name = result[1]
            nested = result[2]
            yield name
            if nested:
                for field in collect_string_fields(nested):
                    yield field
    except ValueError as exc:
        # Probably the format string is invalid.
        if exc.args[0].startswith("cannot switch from manual"):
            # On Jython, parsing a string with both manual
            # and automatic positions will fail with a ValueError,
            # while on CPython it will simply return the fields,
            # the validation being done in the interpreter (?).
            # We're just returning two mixed fields in order
            # to trigger the format-combined-specification check.
            yield ""
            yield "1"
            return
        raise IncompleteFormatString(format_string)

Given a format string return an iterator of all the valid format fields . It handles nested fields as well .


def get_argument_from_call(
    call_node: astroid.Call, position: int = None, keyword: str = None
) -> astroid.Name:
    """Returns the specified argument from a function call.

    :param astroid.Call call_node: Node representing a function call to check.
    :param int position: position of the argument.
    :param str keyword: the keyword of the argument.

    :returns: The node representing the argument, None if the argument is not found.
    :rtype: astroid.Name
    :raises ValueError: if both position and keyword are None.
    :raises NoSuchArgumentError: if no argument at the provided position or with
    the provided keyword.
    """
    if position is None and keyword is None:
        raise ValueError("Must specify at least one of: position or keyword.")
    if position is not None:
        try:
            return call_node.args[position]
        except IndexError:
            pass
    if keyword and call_node.keywords:
        for arg in call_node.keywords:
            if arg.arg == keyword:
                return arg.value

    raise NoSuchArgumentError

Returns the specified argument from a function call .


def inherit_from_std_ex(node: astroid.node_classes.NodeNG) -> bool:
    """
    Return true if the given class node is subclass of
    exceptions.Exception.
    """
    ancestors = node.ancestors() if hasattr(node, "ancestors") else []
    for ancestor in itertools.chain([node], ancestors):
        if (
            ancestor.name in ("Exception", "BaseException")
            and ancestor.root().name == EXCEPTIONS_MODULE
        ):
            return True
    return False

def inherit_from_std_ex ( node : astroid . node_classes . NodeNG ) -> bool : ancestors = node . ancestors ( ) if hasattr ( node , "ancestors" ) else [ ] for ancestor in itertools . chain ( [ node ] , ancestors ) : if ( ancestor . name in ( "Exception" , "BaseException" ) and ancestor . root ( ) . name == EXCEPTIONS_MODULE ) : return True return False

Return true if the given class node is subclass of exceptions . Exception .


def error_of_type(handler: astroid.ExceptHandler, error_type) -> bool:
    """
    Check if the given exception handler catches
    the given error_type.

    The *handler* parameter is a node, representing an ExceptHandler node.
    The *error_type* can be an exception, such as AttributeError,
    the name of an exception, or it can be a tuple of errors.
    The function will return True if the handler catches any of the
    given errors.
    """

    def stringify_error(error):
        if not isinstance(error, str):
            return error.__name__
        return error

    if not isinstance(error_type, tuple):
        error_type = (error_type,)  # type: ignore
    expected_errors = {stringify_error(error) for error in error_type}  # type: ignore
    if not handler.type:
        return True
    return handler.catch(expected_errors)

def
error_of_type
(
handler
:
astroid
.
ExceptHandler
,
error_type
)
->
bool
:
def
stringify_error
(
error
)
:
if
not
isinstance
(
error
,
str
)
:
return
error
.
__name__
return
error
if
not
isinstance
(
error_type
,
tuple
)
:
error_type
=
(
error_type
,
)
# type: ignore
expected_errors
=
{
stringify_error
(
error
)
for
error
in
error_type
}
# type: ignore
if
not
handler
.
type
:
return
True
return
handler
.
catch
(
expected_errors
)

Check if the given exception handler catches the given error_type .


def decorated_with_property(node: astroid.FunctionDef) -> bool:
    """ Detect if the given function node is decorated with a property. """
    if not node.decorators:
        return False
    for decorator in node.decorators.nodes:
        if not isinstance(decorator, astroid.Name):
            continue
        try:
            if _is_property_decorator(decorator):
                return True
        except astroid.InferenceError:
            pass
    return False

def decorated_with_property ( node : astroid . FunctionDef ) -> bool : if not node . decorators : return False for decorator in node . decorators . nodes : if not isinstance ( decorator , astroid . Name ) : continue try : if _is_property_decorator ( decorator ) : return True except astroid . InferenceError : pass return False

Detect if the given function node is decorated with a property .


def decorated_with(func: astroid.FunctionDef, qnames: Iterable[str]) -> bool:
    """Determine if the `func` node has a decorator with the qualified name `qname`."""
    decorators = func.decorators.nodes if func.decorators else []
    for decorator_node in decorators:
        try:
            if any(
                i is not None and i.qname() in qnames for i in decorator_node.infer()
            ):
                return True
        except astroid.InferenceError:
            continue
    return False

def decorated_with ( func : astroid . FunctionDef , qnames : Iterable [ str ] ) -> bool : decorators = func . decorators . nodes if func . decorators else [ ] for decorator_node in decorators : try : if any ( i is not None and i . qname ( ) in qnames for i in decorator_node . infer ( ) ) : return True except astroid . InferenceError : continue return False

Determine if the func node has a decorator with the qualified name qname .


def find_try_except_wrapper_node(
    node: astroid.node_classes.NodeNG
) -> Union[astroid.ExceptHandler, astroid.TryExcept]:
    """Return the ExceptHandler or the TryExcept node in which the node is."""
    current = node
    ignores = (astroid.ExceptHandler, astroid.TryExcept)
    while current and not isinstance(current.parent, ignores):
        current = current.parent

    if current and isinstance(current.parent, ignores):
        return current.parent
    return None

def find_try_except_wrapper_node ( node : astroid . node_classes . NodeNG ) -> Union [ astroid . ExceptHandler , astroid . TryExcept ] : current = node ignores = ( astroid . ExceptHandler , astroid . TryExcept ) while current and not isinstance ( current . parent , ignores ) : current = current . parent if current and isinstance ( current . parent , ignores ) : return current . parent return None

Return the ExceptHandler or the TryExcept node in which the node is .


def is_from_fallback_block(node: astroid.node_classes.NodeNG) -> bool:
    """Check if the given node is from a fallback import block."""
    context = find_try_except_wrapper_node(node)
    if not context:
        return False

    if isinstance(context, astroid.ExceptHandler):
        other_body = context.parent.body
        handlers = context.parent.handlers
    else:
        other_body = itertools.chain.from_iterable(
            handler.body for handler in context.handlers
        )
        handlers = context.handlers

    has_fallback_imports = any(
        isinstance(import_node, (astroid.ImportFrom, astroid.Import))
        for import_node in other_body
    )
    ignores_import_error = _except_handlers_ignores_exception(handlers, ImportError)
    return ignores_import_error or has_fallback_imports

def is_from_fallback_block ( node : astroid . node_classes . NodeNG ) -> bool : context = find_try_except_wrapper_node ( node ) if not context : return False if isinstance ( context , astroid . ExceptHandler ) : other_body = context . parent . body handlers = context . parent . handlers else : other_body = itertools . chain . from_iterable ( handler . body for handler in context . handlers ) handlers = context . handlers has_fallback_imports = any ( isinstance ( import_node , ( astroid . ImportFrom , astroid . Import ) ) for import_node in other_body ) ignores_import_error = _except_handlers_ignores_exception ( handlers , ImportError ) return ignores_import_error or has_fallback_imports

Check if the given node is from a fallback import block .


def get_exception_handlers(
    node: astroid.node_classes.NodeNG, exception=Exception
) -> List[astroid.ExceptHandler]:
    """Return the collections of handlers handling the exception in arguments.

    Args:
        node (astroid.NodeNG): A node that is potentially wrapped in a try except.
        exception (builtin.Exception or str): exception or name of the exception.

    Returns:
        list: the collection of handlers that are handling the exception or None.

    """
    context = find_try_except_wrapper_node(node)
    if isinstance(context, astroid.TryExcept):
        return [
            handler for handler in context.handlers if error_of_type(handler, exception)
        ]
    return None

def get_exception_handlers ( node : astroid . node_classes . NodeNG , exception = Exception ) -> List [ astroid . ExceptHandler ] : context = find_try_except_wrapper_node ( node ) if isinstance ( context , astroid . TryExcept ) : return [ handler for handler in context . handlers if error_of_type ( handler , exception ) ] return None

Return the collections of handlers handling the exception in arguments .


def node_ignores_exception(
    node: astroid.node_classes.NodeNG, exception=Exception
) -> bool:
    """Check if the node is in a TryExcept which handles the given exception.

    If the exception is not given, the function is going to look for bare
    excepts.
    """
    managing_handlers = get_exception_handlers(node, exception)
    if not managing_handlers:
        return False
    return any(managing_handlers)

def node_ignores_exception ( node : astroid . node_classes . NodeNG , exception = Exception ) -> bool : managing_handlers = get_exception_handlers ( node , exception ) if not managing_handlers : return False return any ( managing_handlers )

Check if the node is in a TryExcept which handles the given exception .


def class_is_abstract(node: astroid.ClassDef) -> bool:
    """return true if the given class node should be considered as an abstract
    class
    """
    for method in node.methods():
        if method.parent.frame() is node:
            if method.is_abstract(pass_is_abstract=False):
                return True
    return False

def class_is_abstract ( node : astroid . ClassDef ) -> bool : for method in node . methods ( ) : if method . parent . frame ( ) is node : if method . is_abstract ( pass_is_abstract = False ) : return True return False


def safe_infer(
    node: astroid.node_classes.NodeNG, context=None
) -> Optional[astroid.node_classes.NodeNG]:
    """Return the inferred value for the given node.

    Return None if inference failed or if there is some ambiguity (more than
    one node has been inferred).
    """
    try:
        inferit = node.infer(context=context)
        value = next(inferit)
    except astroid.InferenceError:
        return None
    try:
        next(inferit)
        return None  # None if there is ambiguity on the inferred node
    except astroid.InferenceError:
        return None  # there is some kind of ambiguity
    except StopIteration:
        return value

Return the inferred value for the given node .


def node_type(node: astroid.node_classes.NodeNG) -> Optional[type]:
    """Return the inferred type for `node`

    If there is more than one possible type, or if inferred type is Uninferable or None,
    return None
    """
    # check there is only one possible type for the assign node. Else we
    # don't handle it for now
    types = set()
    try:
        for var_type in node.infer():
            if var_type == astroid.Uninferable or is_none(var_type):
                continue
            types.add(var_type)
            if len(types) > 1:
                return None
    except astroid.InferenceError:
        return None
    return types.pop() if types else None


def is_registered_in_singledispatch_function(node: astroid.FunctionDef) -> bool:
    """Check if the given function node is a singledispatch function."""

    singledispatch_qnames = (
        "functools.singledispatch",
        "singledispatch.singledispatch",
    )

    if not isinstance(node, astroid.FunctionDef):
        return False

    decorators = node.decorators.nodes if node.decorators else []
    for decorator in decorators:
        # func.register are function calls
        if not isinstance(decorator, astroid.Call):
            continue

        func = decorator.func
        if not isinstance(func, astroid.Attribute) or func.attrname != "register":
            continue

        try:
            func_def = next(func.expr.infer())
        except astroid.InferenceError:
            continue

        if isinstance(func_def, astroid.FunctionDef):
            # pylint: disable=redundant-keyword-arg; some flow inference goes wrong here
            return decorated_with(func_def, singledispatch_qnames)

    return False

Check if the given function node is a singledispatch function .


def is_postponed_evaluation_enabled(node: astroid.node_classes.NodeNG) -> bool:
    """Check if the postponed evaluation of annotations is enabled"""
    name = "annotations"
    module = node.root()
    stmt = module.locals.get(name)
    return (
        stmt
        and isinstance(stmt[0], astroid.ImportFrom)
        and stmt[0].modname == "__future__"
    )

def is_postponed_evaluation_enabled ( node : astroid . node_classes . NodeNG ) -> bool : name = "annotations" module = node . root ( ) stmt = module . locals . get ( name ) return ( stmt and isinstance ( stmt [ 0 ] , astroid . ImportFrom ) and stmt [ 0 ] . modname == "__future__" )


def _qualified_names(modname):
    """Split the names of the given module into subparts

    For example,
        _qualified_names('pylint.checkers.ImportsChecker')
    returns
        ['pylint', 'pylint.checkers', 'pylint.checkers.ImportsChecker']
    """
    names = modname.split(".")
    return [".".join(names[0 : i + 1]) for i in range(len(names))]

def _qualified_names ( modname ) : names = modname . split ( "." ) return [ "." . join ( names [ 0 : i + 1 ] ) for i in range ( len ( names ) ) ]


def _get_import_name(importnode, modname):
    """Get a prepared module name from the given import node

    In the case of relative imports, this will return the
    absolute qualified module name, which might be useful
    for debugging. Otherwise, the initial module name
    is returned unchanged.
    """
    if isinstance(importnode, astroid.ImportFrom):
        if importnode.level:
            root = importnode.root()
            if isinstance(root, astroid.Module):
                modname = root.relative_to_absolute_name(
                    modname, level=importnode.level
                )
    return modname

def _get_import_name ( importnode , modname ) : if isinstance ( importnode , astroid . ImportFrom ) : if importnode . level : root = importnode . root ( ) if isinstance ( root , astroid . Module ) : modname = root . relative_to_absolute_name ( modname , level = importnode . level ) return modname


def _repr_tree_defs(data, indent_str=None):
    """return a string which represents imports as a tree"""
    lines = []
    nodes = data.items()
    for i, (mod, (sub, files)) in enumerate(sorted(nodes, key=lambda x: x[0])):
        if not files:
            files = ""
        else:
            files = "(%s)" % ",".join(sorted(files))
        if indent_str is None:
            lines.append("%s %s" % (mod, files))
            sub_indent_str = "  "
        else:
            lines.append(r"%s\-%s %s" % (indent_str, mod, files))
            if i == len(nodes) - 1:
                sub_indent_str = "%s  " % indent_str
            else:
                sub_indent_str = "%s| " % indent_str
        if sub:
            lines.append(_repr_tree_defs(sub, sub_indent_str))
    return "\n".join(lines)

def
_repr_tree_defs
(
data
,
indent_str
=
)
:
lines
=
[
]
nodes
=
data
.
items
(
)
for
i
,
(
mod
,
(
sub
,
files
)
)
in
enumerate
(
sorted
(
nodes
,
key
=
lambda
x
:
x
[
0
]
)
)
:
if
not
files
:
files
=
""
else
:
files
=
"(%s)"
%
","
.
join
(
sorted
(
files
)
)
if
indent_str
is
:
lines
.
append
(
"%s %s"
%
(
mod
,
files
)
)
sub_indent_str
=
"  "
else
:
lines
.
append
(
r"%s\-%s %s"
%
(
indent_str
,
mod
,
files
)
)
if
i
==
len
(
nodes
)
1
:
sub_indent_str
=
"%s  "
%
indent_str
else
:
sub_indent_str
=
"%s| "
%
indent_str
if
sub
:
lines
.
append
(
_repr_tree_defs
(
sub
,
sub_indent_str
)
)
return
"\n"
.
join
(
lines
)


def _make_graph(filename, dep_info, sect, gtype):
    """generate a dependencies graph and add some information about it in the
    report's section
    """
    _dependencies_graph(filename, dep_info)
    sect.append(Paragraph("%simports graph has been written to %s" % (gtype, filename)))

generate a dependencies graph and add some information about it in the report s section


def visit_import(self, node):
        """triggered when an import statement is seen"""
        self._check_reimport(node)
        self._check_import_as_rename(node)

        modnode = node.root()
        names = [name for name, _ in node.names]
        if len(names) >= 2:
            self.add_message("multiple-imports", args=", ".join(names), node=node)

        for name in names:
            self._check_deprecated_module(node, name)
            self._check_preferred_module(node, name)
            imported_module = self._get_imported_module(node, name)
            if isinstance(node.parent, astroid.Module):
                # Allow imports nested
                self._check_position(node)
            if isinstance(node.scope(), astroid.Module):
                self._record_import(node, imported_module)

            if imported_module is None:
                continue

            self._check_relative_import(modnode, node, imported_module, name)
            self._add_imported_module(node, imported_module.name)

def
visit_import
(
self
,
node
)
:
self
.
_check_reimport
(
node
)
self
.
_check_import_as_rename
(
node
)
modnode
=
node
.
root
(
)
names
=
[
name
for
name
,
_
in
node
.
names
]
if
len
(
names
)
>=
2
:
self
.
add_message
(
"multiple-imports"
,
args
=
", "
.
join
(
names
)
,
node
=
node
)
for
name
in
names
:
self
.
_check_deprecated_module
(
node
,
name
)
self
.
_check_preferred_module
(
node
,
name
)
imported_module
=
self
.
_get_imported_module
(
node
,
name
)
if
isinstance
(
node
.
parent
,
astroid
.
Module
)
:
# Allow imports nested
self
.
_check_position
(
node
)
if
isinstance
(
node
.
scope
(
)
,
astroid
.
Module
)
:
self
.
_record_import
(
node
,
imported_module
)
if
imported_module
is
:
continue
self
.
_check_relative_import
(
modnode
,
node
,
imported_module
,
name
)
self
.
_add_imported_module
(
node
,
imported_module
.
name
)


def visit_importfrom(self, node):
        """triggered when a from statement is seen"""
        basename = node.modname
        imported_module = self._get_imported_module(node, basename)

        self._check_import_as_rename(node)
        self._check_misplaced_future(node)
        self._check_deprecated_module(node, basename)
        self._check_preferred_module(node, basename)
        self._check_wildcard_imports(node, imported_module)
        self._check_same_line_imports(node)
        self._check_reimport(node, basename=basename, level=node.level)

        if isinstance(node.parent, astroid.Module):
            # Allow imports nested
            self._check_position(node)
        if isinstance(node.scope(), astroid.Module):
            self._record_import(node, imported_module)
        if imported_module is None:
            return
        modnode = node.root()
        self._check_relative_import(modnode, node, imported_module, basename)

        for name, _ in node.names:
            if name != "*":
                self._add_imported_module(node, "%s.%s" % (imported_module.name, name))
            else:
                self._add_imported_module(node, imported_module.name)

def
visit_importfrom
(
self
,
node
)
:
basename
=
node
.
modname
imported_module
=
self
.
_get_imported_module
(
node
,
basename
)
self
.
_check_import_as_rename
(
node
)
self
.
_check_misplaced_future
(
node
)
self
.
_check_deprecated_module
(
node
,
basename
)
self
.
_check_preferred_module
(
node
,
basename
)
self
.
_check_wildcard_imports
(
node
,
imported_module
)
self
.
_check_same_line_imports
(
node
)
self
.
_check_reimport
(
node
,
basename
=
basename
,
level
=
node
.
level
)
if
isinstance
(
node
.
parent
,
astroid
.
Module
)
:
# Allow imports nested
self
.
_check_position
(
node
)
if
isinstance
(
node
.
scope
(
)
,
astroid
.
Module
)
:
self
.
_record_import
(
node
,
imported_module
)
if
imported_module
is
:
return
modnode
=
node
.
root
(
)
self
.
_check_relative_import
(
modnode
,
node
,
imported_module
,
basename
)
for
name
,
_
in
node
.
names
:
if
name
!=
"*"
:
self
.
_add_imported_module
(
node
,
"%s.%s"
%
(
imported_module
.
name
,
name
)
)
else
:
self
.
_add_imported_module
(
node
,
imported_module
.
name
)


def _check_position(self, node):
        """Check `node` import or importfrom node position is correct

        Send a message  if `node` comes before another instruction
        """
        # if a first non-import instruction has already been encountered,
        # it means the import comes after it and therefore is not well placed
        if self._first_non_import_node:
            self.add_message("wrong-import-position", node=node, args=node.as_string())

Check node import or importfrom node position is correct


def _record_import(self, node, importedmodnode):
        """Record the package `node` imports from"""
        if isinstance(node, astroid.ImportFrom):
            importedname = node.modname
        else:
            importedname = importedmodnode.name if importedmodnode else None
        if not importedname:
            importedname = node.names[0][0].split(".")[0]

        if isinstance(node, astroid.ImportFrom) and (node.level or 0) >= 1:
            # We need the importedname with first point to detect local package
            # Example of node:
            #  'from .my_package1 import MyClass1'
            #  the output should be '.my_package1' instead of 'my_package1'
            # Example of node:
            #  'from . import my_package2'
            #  the output should be '.my_package2' instead of '{pyfile}'
            importedname = "." + importedname

        self._imports_stack.append((node, importedname))


def _check_imports_order(self, _module_node):
        """Checks imports of module `node` are grouped by category

        Imports must follow this order: standard, 3rd party, local
        """
        std_imports = []
        third_party_imports = []
        first_party_imports = []
        # need of a list that holds third or first party ordered import
        external_imports = []
        local_imports = []
        third_party_not_ignored = []
        first_party_not_ignored = []
        local_not_ignored = []
        isort_obj = isort.SortImports(
            file_contents="",
            known_third_party=self.config.known_third_party,
            known_standard_library=self.config.known_standard_library,
        )
        for node, modname in self._imports_stack:
            if modname.startswith("."):
                package = "." + modname.split(".")[1]
            else:
                package = modname.split(".")[0]
            nested = not isinstance(node.parent, astroid.Module)
            ignore_for_import_order = not self.linter.is_message_enabled(
                "wrong-import-order", node.fromlineno
            )
            import_category = isort_obj.place_module(package)
            node_and_package_import = (node, package)
            if import_category in ("FUTURE", "STDLIB"):
                std_imports.append(node_and_package_import)
                wrong_import = (
                    third_party_not_ignored
                    or first_party_not_ignored
                    or local_not_ignored
                )
                if self._is_fallback_import(node, wrong_import):
                    continue
                if wrong_import and not nested:
                    self.add_message(
                        "wrong-import-order",
                        node=node,
                        args=(
                            'standard import "%s"' % node.as_string(),
                            '"%s"' % wrong_import[0][0].as_string(),
                        ),
                    )
            elif import_category == "THIRDPARTY":
                third_party_imports.append(node_and_package_import)
                external_imports.append(node_and_package_import)
                if not nested and not ignore_for_import_order:
                    third_party_not_ignored.append(node_and_package_import)
                wrong_import = first_party_not_ignored or local_not_ignored
                if wrong_import and not nested:
                    self.add_message(
                        "wrong-import-order",
                        node=node,
                        args=(
                            'third party import "%s"' % node.as_string(),
                            '"%s"' % wrong_import[0][0].as_string(),
                        ),
                    )
            elif import_category == "FIRSTPARTY":
                first_party_imports.append(node_and_package_import)
                external_imports.append(node_and_package_import)
                if not nested and not ignore_for_import_order:
                    first_party_not_ignored.append(node_and_package_import)
                wrong_import = local_not_ignored
                if wrong_import and not nested:
                    self.add_message(
                        "wrong-import-order",
                        node=node,
                        args=(
                            'first party import "%s"' % node.as_string(),
                            '"%s"' % wrong_import[0][0].as_string(),
                        ),
                    )
            elif import_category == "LOCALFOLDER":
                local_imports.append((node, package))
                if not nested and not ignore_for_import_order:
                    local_not_ignored.append((node, package))
        return std_imports, external_imports, local_imports

Checks imports of module node are grouped by category


def _check_relative_import(
        self, modnode, importnode, importedmodnode, importedasname
    ):
        """check relative import. node is either an Import or From node, modname
        the imported module name.
        """
        if not self.linter.is_message_enabled("relative-import"):
            return None
        if importedmodnode.file is None:
            return False  # built-in module
        if modnode is importedmodnode:
            return False  # module importing itself
        if modnode.absolute_import_activated() or getattr(importnode, "level", None):
            return False
        if importedmodnode.name != importedasname:
            # this must be a relative import...
            self.add_message(
                "relative-import",
                args=(importedasname, importedmodnode.name),
                node=importnode,
            )
            return None
        return None

def
_check_relative_import
(
self
,
modnode
,
importnode
,
importedmodnode
,
importedasname
)
:
if
not
self
.
linter
.
is_message_enabled
(
"relative-import"
)
:
return
if
importedmodnode
.
file
is
:
return
False
# built-in module
if
modnode
is
importedmodnode
:
return
False
# module importing itself
if
modnode
.
absolute_import_activated
(
)
or
getattr
(
importnode
,
"level"
,
)
:
return
False
if
importedmodnode
.
name
!=
importedasname
:
# this must be a relative import...
self
.
add_message
(
"relative-import"
,
args
=
(
importedasname
,
importedmodnode
.
name
)
,
node
=
importnode
,
)
return
return

check relative import . node is either an Import or From node modname the imported module name .


def _add_imported_module(self, node, importedmodname):
        """notify an imported module, used to analyze dependencies"""
        module_file = node.root().file
        context_name = node.root().name
        base = os.path.splitext(os.path.basename(module_file))[0]

        try:
            importedmodname = astroid.modutils.get_module_part(
                importedmodname, module_file
            )
        except ImportError:
            pass

        if context_name == importedmodname:
            self.add_message("import-self", node=node)

        elif not astroid.modutils.is_standard_module(importedmodname):
            # if this is not a package __init__ module
            if base != "__init__" and context_name not in self._module_pkg:
                # record the module's parent, or the module itself if this is
                # a top level module, as the package it belongs to
                self._module_pkg[context_name] = context_name.rsplit(".", 1)[0]

            # handle dependencies
            importedmodnames = self.stats["dependencies"].setdefault(
                importedmodname, set()
            )
            if context_name not in importedmodnames:
                importedmodnames.add(context_name)

            # update import graph
            self.import_graph[context_name].add(importedmodname)
            if not self.linter.is_message_enabled("cyclic-import", line=node.lineno):
                self._excluded_edges[context_name].add(importedmodname)

notify an imported module used to analyze dependencies


def _check_deprecated_module(self, node, mod_path):
        """check if the module is deprecated"""
        for mod_name in self.config.deprecated_modules:
            if mod_path == mod_name or mod_path.startswith(mod_name + "."):
                self.add_message("deprecated-module", node=node, args=mod_path)

def _check_deprecated_module ( self , node , mod_path ) : for mod_name in self . config . deprecated_modules : if mod_path == mod_name or mod_path . startswith ( mod_name + "." ) : self . add_message ( "deprecated-module" , node = node , args = mod_path )


def _check_preferred_module(self, node, mod_path):
        """check if the module has a preferred replacement"""
        if mod_path in self.preferred_modules:
            self.add_message(
                "preferred-module",
                node=node,
                args=(self.preferred_modules[mod_path], mod_path),
            )

def _check_preferred_module ( self , node , mod_path ) : if mod_path in self . preferred_modules : self . add_message ( "preferred-module" , node = node , args = ( self . preferred_modules [ mod_path ] , mod_path ) , )


def _report_external_dependencies(self, sect, _, _dummy):
        """return a verbatim layout for displaying dependencies"""
        dep_info = _make_tree_defs(self._external_dependencies_info().items())
        if not dep_info:
            raise EmptyReportError()
        tree_str = _repr_tree_defs(dep_info)
        sect.append(VerbatimText(tree_str))

def _report_external_dependencies ( self , sect , _ , _dummy ) : dep_info = _make_tree_defs ( self . _external_dependencies_info ( ) . items ( ) ) if not dep_info : raise EmptyReportError ( ) tree_str = _repr_tree_defs ( dep_info ) sect . append ( VerbatimText ( tree_str ) )


def _filter_dependencies_graph(self, internal):
        """build the internal or the external depedency graph"""
        graph = collections.defaultdict(set)
        for importee, importers in self.stats["dependencies"].items():
            for importer in importers:
                package = self._module_pkg.get(importer, importer)
                is_inside = importee.startswith(package)
                if is_inside and internal or not is_inside and not internal:
                    graph[importee].add(importer)
        return graph

def _filter_dependencies_graph ( self , internal ) : graph = collections . defaultdict ( set ) for importee , importers in self . stats [ "dependencies" ] . items ( ) : for importer in importers : package = self . _module_pkg . get ( importer , importer ) is_inside = importee . startswith ( package ) if is_inside and internal or not is_inside and not internal : graph [ importee ] . add ( importer ) return graph


def get_default_options():
    """
    Read config file and return list of options
    """
    options = []
    home = os.environ.get("HOME", "")
    if home:
        rcfile = os.path.join(home, RCFILE)
        try:
            options = open(rcfile).read().split()
        except IOError:
            pass  # ignore if no config file found
    return options

def
get_default_options
(
)
:
options
=
[
]
home
=
os
.
environ
.
get
(
"HOME"
,
""
)
if
home
:
rcfile
=
os
.
path
.
join
(
home
,
RCFILE
)
try
:
options
=
open
(
rcfile
)
.
read
(
)
.
split
(
)
except
IOError
:
pass
# ignore if no config file found
return
options


def insert_default_options():
    """insert default options to sys.argv
    """
    options = get_default_options()
    options.reverse()
    for arg in options:
        sys.argv.insert(1, arg)

def insert_default_options ( ) : options = get_default_options ( ) options . reverse ( ) for arg in options : sys . argv . insert ( 1 , arg )


def show_attr(self, node):
        """return true if the node should be treated
        """
        visibility = get_visibility(getattr(node, "name", node))
        return not self.__mode & VIS_MOD[visibility]

def show_attr ( self , node ) : visibility = get_visibility ( getattr ( node , "name" , node ) ) return not self . __mode & VIS_MOD [ visibility ]


def get_callbacks(self, node):
        """get callbacks from handler for the visited node"""
        klass = node.__class__
        methods = self._cache.get(klass)
        if methods is None:
            handler = self.handler
            kid = klass.__name__.lower()
            e_method = getattr(
                handler, "visit_%s" % kid, getattr(handler, "visit_default", None)
            )
            l_method = getattr(
                handler, "leave_%s" % kid, getattr(handler, "leave_default", None)
            )
            self._cache[klass] = (e_method, l_method)
        else:
            e_method, l_method = methods
        return e_method, l_method

def get_callbacks ( self , node ) : klass = node . __class__ methods = self . _cache . get ( klass ) if methods is None : handler = self . handler kid = klass . __name__ . lower ( ) e_method = getattr ( handler , "visit_%s" % kid , getattr ( handler , "visit_default" , None ) ) l_method = getattr ( handler , "leave_%s" % kid , getattr ( handler , "leave_default" , None ) ) self . _cache [ klass ] = ( e_method , l_method ) else : e_method , l_method = methods return e_method , l_method


def visit(self, node):
        """launch the visit starting from the given node"""
        if node in self._visited:
            return None
        self._visited[node] = 1  # FIXME: use set ?
        methods = self.get_callbacks(node)
        if methods[0] is not None:
            methods[0](node)
        if hasattr(node, "locals"):  # skip Instance and other proxy
            for local_node in node.values():
                self.visit(local_node)
        if methods[1] is not None:
            return methods[1](node)
        return None

def
visit
(
self
,
node
)
:
if
node
in
self
.
_visited
:
return
self
.
_visited
[
node
]
=
1
# FIXME: use set ?
methods
=
self
.
get_callbacks
(
node
)
if
methods
[
0
]
is
not
:
methods
[
0
]
(
node
)
if
hasattr
(
node
,
"locals"
)
:
# skip Instance and other proxy
for
local_node
in
node
.
values
(
)
:
self
.
visit
(
local_node
)
if
methods
[
1
]
is
not
:
return
methods
[
1
]
(
node
)
return


def check_consistency(self) -> None:
        """Check the consistency of msgid.

        msg ids for a checker should be a string of len 4, where the two first
        characters are the checker id and the two last the msg id in this
        checker.

        :raises InvalidMessageError: If the checker id in the messages are not
        always the same. """
        checker_id = None
        existing_ids = []
        for message in self.messages:
            if checker_id is not None and checker_id != message.msgid[1:3]:
                error_msg = "Inconsistent checker part in message id "
                error_msg += "'{}' (expected 'x{checker_id}xx' ".format(
                    message.msgid, checker_id=checker_id
                )
                error_msg += "because we already had {existing_ids}).".format(
                    existing_ids=existing_ids
                )
                raise InvalidMessageError(error_msg)
            checker_id = message.msgid[1:3]
            existing_ids.append(message.msgid)


def visit_call(self, node):
        """Visit a Call node."""
        try:
            for inferred in node.func.infer():
                if inferred is astroid.Uninferable:
                    continue
                elif inferred.root().name == OPEN_MODULE:
                    if getattr(node.func, "name", None) in OPEN_FILES:
                        self._check_open_mode(node)
                elif inferred.root().name == UNITTEST_CASE:
                    self._check_redundant_assert(node, inferred)
                elif isinstance(inferred, astroid.ClassDef):
                    if inferred.qname() == THREADING_THREAD:
                        self._check_bad_thread_instantiation(node)
                    elif inferred.qname() == SUBPROCESS_POPEN:
                        self._check_for_preexec_fn_in_popen(node)
                elif isinstance(inferred, astroid.FunctionDef):
                    name = inferred.qname()
                    if name == COPY_COPY:
                        self._check_shallow_copy_environ(node)
                    elif name in ENV_GETTERS:
                        self._check_env_function(node, inferred)
                    elif name == SUBPROCESS_RUN and PY35:
                        self._check_for_check_kw_in_run(node)
                self._check_deprecated_method(node, inferred)
        except astroid.InferenceError:
            return

def visit_call ( self , node ) : try : for inferred in node . func . infer ( ) : if inferred is astroid . Uninferable : continue elif inferred . root ( ) . name == OPEN_MODULE : if getattr ( node . func , "name" , None ) in OPEN_FILES : self . _check_open_mode ( node ) elif inferred . root ( ) . name == UNITTEST_CASE : self . _check_redundant_assert ( node , inferred ) elif isinstance ( inferred , astroid . ClassDef ) : if inferred . qname ( ) == THREADING_THREAD : self . _check_bad_thread_instantiation ( node ) elif inferred . qname ( ) == SUBPROCESS_POPEN : self . _check_for_preexec_fn_in_popen ( node ) elif isinstance ( inferred , astroid . FunctionDef ) : name = inferred . qname ( ) if name == COPY_COPY : self . _check_shallow_copy_environ ( node ) elif name in ENV_GETTERS : self . _check_env_function ( node , inferred ) elif name == SUBPROCESS_RUN and PY35 : self . _check_for_check_kw_in_run ( node ) self . _check_deprecated_method ( node , inferred ) except astroid . InferenceError : return


def _check_datetime(self, node):
        """ Check that a datetime was infered.
        If so, emit boolean-datetime warning.
        """
        try:
            infered = next(node.infer())
        except astroid.InferenceError:
            return
        if isinstance(infered, Instance) and infered.qname() == "datetime.time":
            self.add_message("boolean-datetime", node=node)

def _check_datetime ( self , node ) : try : infered = next ( node . infer ( ) ) except astroid . InferenceError : return if isinstance ( infered , Instance ) and infered . qname ( ) == "datetime.time" : self . add_message ( "boolean-datetime" , node = node )

Check that a datetime was infered . If so emit boolean - datetime warning .


def _check_open_mode(self, node):
        """Check that the mode argument of an open or file call is valid."""
        try:
            mode_arg = utils.get_argument_from_call(node, position=1, keyword="mode")
        except utils.NoSuchArgumentError:
            return
        if mode_arg:
            mode_arg = utils.safe_infer(mode_arg)
            if isinstance(mode_arg, astroid.Const) and not _check_mode_str(
                mode_arg.value
            ):
                self.add_message("bad-open-mode", node=node, args=mode_arg.value)

def _check_open_mode ( self , node ) : try : mode_arg = utils . get_argument_from_call ( node , position = 1 , keyword = "mode" ) except utils . NoSuchArgumentError : return if mode_arg : mode_arg = utils . safe_infer ( mode_arg ) if isinstance ( mode_arg , astroid . Const ) and not _check_mode_str ( mode_arg . value ) : self . add_message ( "bad-open-mode" , node = node , args = mode_arg . value )

Check that the mode argument of an open or file call is valid .


def handle_message(self, msg):
        """Manage message of different type and in the context of path."""
        self.messages.append(
            {
                "type": msg.category,
                "module": msg.module,
                "obj": msg.obj,
                "line": msg.line,
                "column": msg.column,
                "path": msg.path,
                "symbol": msg.symbol,
                "message": html.escape(msg.msg or "", quote=False),
                "message-id": msg.msg_id,
            }
        )

def handle_message ( self , msg ) : self . messages . append ( { "type" : msg . category , "module" : msg . module , "obj" : msg . obj , "line" : msg . line , "column" : msg . column , "path" : msg . path , "symbol" : msg . symbol , "message" : html . escape ( msg . msg or "" , quote = False ) , "message-id" : msg . msg_id , } )

Manage message of different type and in the context of path .


def display_messages(self, layout):
        """Launch layouts display"""
        print(json.dumps(self.messages, indent=4), file=self.out)

def display_messages ( self , layout ) : print ( json . dumps ( self . messages , indent = 4 ) , file = self . out )


def get_title(self, node):
        """get title for objects"""
        title = node.name
        if self.module_names:
            title = "%s.%s" % (node.root().name, title)
        return title

def get_title ( self , node ) : title = node . name if self . module_names : title = "%s.%s" % ( node . root ( ) . name , title ) return title


def _set_default_options(self):
        """set different default options with _default dictionary"""
        self.module_names = self._set_option(self.config.module_names)
        all_ancestors = self._set_option(self.config.all_ancestors)
        all_associated = self._set_option(self.config.all_associated)
        anc_level, association_level = (0, 0)
        if all_ancestors:
            anc_level = -1
        if all_associated:
            association_level = -1
        if self.config.show_ancestors is not None:
            anc_level = self.config.show_ancestors
        if self.config.show_associated is not None:
            association_level = self.config.show_associated
        self.anc_level, self.association_level = anc_level, association_level

def _set_default_options ( self ) : self . module_names = self . _set_option ( self . config . module_names ) all_ancestors = self . _set_option ( self . config . all_ancestors ) all_associated = self . _set_option ( self . config . all_associated ) anc_level , association_level = ( 0 , 0 ) if all_ancestors : anc_level = - 1 if all_associated : association_level = - 1 if self . config . show_ancestors is not None : anc_level = self . config . show_ancestors if self . config . show_associated is not None : association_level = self . config . show_associated self . anc_level , self . association_level = anc_level , association_level


def show_node(self, node):
        """true if builtins and not show_builtins"""
        if self.config.show_builtin:
            return True
        return node.root().name != BUILTINS_NAME

def show_node ( self , node ) : if self . config . show_builtin : return True return node . root ( ) . name != BUILTINS_NAME


def add_class(self, node):
        """visit one class and add it to diagram"""
        self.linker.visit(node)
        self.classdiagram.add_object(self.get_title(node), node)

def add_class ( self , node ) : self . linker . visit ( node ) self . classdiagram . add_object ( self . get_title ( node ) , node )


def get_ancestors(self, node, level):
        """return ancestor nodes of a class node"""
        if level == 0:
            return
        for ancestor in node.ancestors(recurs=False):
            if not self.show_node(ancestor):
                continue
            yield ancestor

def get_ancestors ( self , node , level ) : if level == 0 : return for ancestor in node . ancestors ( recurs = False ) : if not self . show_node ( ancestor ) : continue yield ancestor


def get_associated(self, klass_node, level):
        """return associated nodes of a class node"""
        if level == 0:
            return
        for association_nodes in list(klass_node.instance_attrs_type.values()) + list(
            klass_node.locals_type.values()
        ):
            for node in association_nodes:
                if isinstance(node, astroid.Instance):
                    node = node._proxied
                if not (isinstance(node, astroid.ClassDef) and self.show_node(node)):
                    continue
                yield node

def get_associated ( self , klass_node , level ) : if level == 0 : return for association_nodes in list ( klass_node . instance_attrs_type . values ( ) ) + list ( klass_node . locals_type . values ( ) ) : for node in association_nodes : if isinstance ( node , astroid . Instance ) : node = node . _proxied if not ( isinstance ( node , astroid . ClassDef ) and self . show_node ( node ) ) : continue yield node


def extract_classes(self, klass_node, anc_level, association_level):
        """extract recursively classes related to klass_node"""
        if self.classdiagram.has_node(klass_node) or not self.show_node(klass_node):
            return
        self.add_class(klass_node)

        for ancestor in self.get_ancestors(klass_node, anc_level):
            self.extract_classes(ancestor, anc_level - 1, association_level)

        for node in self.get_associated(klass_node, association_level):
            self.extract_classes(node, anc_level, association_level - 1)

def extract_classes ( self , klass_node , anc_level , association_level ) : if self . classdiagram . has_node ( klass_node ) or not self . show_node ( klass_node ) : return self . add_class ( klass_node ) for ancestor in self . get_ancestors ( klass_node , anc_level ) : self . extract_classes ( ancestor , anc_level - 1 , association_level ) for node in self . get_associated ( klass_node , association_level ) : self . extract_classes ( node , anc_level , association_level - 1 )


def leave_project(self, node):  # pylint: disable=unused-argument
        """leave the pyreverse.utils.Project node

        return the generated diagram definition
        """
        if self.pkgdiagram:
            return self.pkgdiagram, self.classdiagram
        return (self.classdiagram,)

def
leave_project
(
self
,
node
)
:
# pylint: disable=unused-argument
if
self
.
pkgdiagram
:
return
self
.
pkgdiagram
,
self
.
classdiagram
return
(
self
.
classdiagram
,
)

leave the pyreverse . utils . Project node


def visit_importfrom(self, node):
        """visit astroid.ImportFrom  and catch modules for package diagram
        """
        if self.pkgdiagram:
            self.pkgdiagram.add_from_depend(node, node.modname)

def visit_importfrom ( self , node ) : if self . pkgdiagram : self . pkgdiagram . add_from_depend ( node , node . modname )

visit astroid . ImportFrom and catch modules for package diagram


def class_diagram(self, project, klass):
        """return a class diagram definition for the given klass and its
        related klasses
        """

        self.classdiagram = ClassDiagram(klass, self.config.mode)
        if len(project.modules) > 1:
            module, klass = klass.rsplit(".", 1)
            module = project.get_module(module)
        else:
            module = project.modules[0]
            klass = klass.split(".")[-1]
        klass = next(module.ilookup(klass))

        anc_level, association_level = self._get_levels()
        self.extract_classes(klass, anc_level, association_level)
        return self.classdiagram

def class_diagram ( self , project , klass ) : self . classdiagram = ClassDiagram ( klass , self . config . mode ) if len ( project . modules ) > 1 : module , klass = klass . rsplit ( "." , 1 ) module = project . get_module ( module ) else : module = project . modules [ 0 ] klass = klass . split ( "." ) [ - 1 ] klass = next ( module . ilookup ( klass ) ) anc_level , association_level = self . _get_levels ( ) self . extract_classes ( klass , anc_level , association_level ) return self . classdiagram


def get_diadefs(self, project, linker):
        """Get the diagrams configuration data

        :param project:The pyreverse project
        :type project: pyreverse.utils.Project
        :param linker: The linker
        :type linker: pyreverse.inspector.Linker(IdGeneratorMixIn, LocalsVisitor)

        :returns: The list of diagram definitions
        :rtype: list(:class:`pylint.pyreverse.diagrams.ClassDiagram`)
        """

        #  read and interpret diagram definitions (Diadefs)
        diagrams = []
        generator = ClassDiadefGenerator(linker, self)
        for klass in self.config.classes:
            diagrams.append(generator.class_diagram(project, klass))
        if not diagrams:
            diagrams = DefaultDiadefGenerator(linker, self).visit(project)
        for diagram in diagrams:
            diagram.extract_relationships()
        return diagrams


def _is_owner_ignored(owner, name, ignored_classes, ignored_modules):
    """Check if the given owner should be ignored

    This will verify if the owner's module is in *ignored_modules*
    or the owner's module fully qualified name is in *ignored_modules*
    or if the *ignored_modules* contains a pattern which catches
    the fully qualified name of the module.

    Also, similar checks are done for the owner itself, if its name
    matches any name from the *ignored_classes* or if its qualified
    name can be found in *ignored_classes*.
    """
    ignored_modules = set(ignored_modules)
    module_name = owner.root().name
    module_qname = owner.root().qname()
    if any(
        module_name in ignored_modules
        or module_qname in ignored_modules
        or fnmatch.fnmatch(module_qname, ignore)
        for ignore in ignored_modules
    ):
        return True

    ignored_classes = set(ignored_classes)
    if hasattr(owner, "qname"):
        qname = owner.qname()
    else:
        qname = ""
    return any(ignore in (name, qname) for ignore in ignored_classes)

def _is_owner_ignored ( owner , name , ignored_classes , ignored_modules ) : ignored_modules = set ( ignored_modules ) module_name = owner . root ( ) . name module_qname = owner . root ( ) . qname ( ) if any ( module_name in ignored_modules or module_qname in ignored_modules or fnmatch . fnmatch ( module_qname , ignore ) for ignore in ignored_modules ) : return True ignored_classes = set ( ignored_classes ) if hasattr ( owner , "qname" ) : qname = owner . qname ( ) else : qname = "" return any ( ignore in ( name , qname ) for ignore in ignored_classes )


def _similar_names(owner, attrname, distance_threshold, max_choices):
    """Given an owner and a name, try to find similar names

    The similar names are searched given a distance metric and only
    a given number of choices will be returned.
    """
    possible_names = []
    names = _node_names(owner)

    for name in names:
        if name == attrname:
            continue

        distance = _string_distance(attrname, name)
        if distance <= distance_threshold:
            possible_names.append((name, distance))

    # Now get back the values with a minimum, up to the given
    # limit or choices.
    picked = [
        name
        for (name, _) in heapq.nsmallest(
            max_choices, possible_names, key=operator.itemgetter(1)
        )
    ]
    return sorted(picked)

Given an owner and a name try to find similar names


def _emit_no_member(node, owner, owner_name, ignored_mixins=True, ignored_none=True):
    """Try to see if no-member should be emitted for the given owner.

    The following cases are ignored:

        * the owner is a function and it has decorators.
        * the owner is an instance and it has __getattr__, __getattribute__ implemented
        * the module is explicitly ignored from no-member checks
        * the owner is a class and the name can be found in its metaclass.
        * The access node is protected by an except handler, which handles
          AttributeError, Exception or bare except.
    """
    # pylint: disable=too-many-return-statements
    if node_ignores_exception(node, AttributeError):
        return False
    if ignored_none and isinstance(owner, astroid.Const) and owner.value is None:
        return False
    if is_super(owner) or getattr(owner, "type", None) == "metaclass":
        return False
    if ignored_mixins and owner_name[-5:].lower() == "mixin":
        return False
    if isinstance(owner, astroid.FunctionDef) and owner.decorators:
        return False
    if isinstance(owner, (astroid.Instance, astroid.ClassDef)):
        if owner.has_dynamic_getattr():
            # Issue #2565: Don't ignore enums, as they have a `__getattr__` but it's not
            # invoked at this point.
            try:
                metaclass = owner.metaclass()
            except exceptions.MroError:
                return False
            if metaclass:
                return metaclass.qname() == "enum.EnumMeta"
            return False
        if not has_known_bases(owner):
            return False
    if isinstance(owner, objects.Super):
        # Verify if we are dealing with an invalid Super object.
        # If it is invalid, then there's no point in checking that
        # it has the required attribute. Also, don't fail if the
        # MRO is invalid.
        try:
            owner.super_mro()
        except (exceptions.MroError, exceptions.SuperError):
            return False
        if not all(map(has_known_bases, owner.type.mro())):
            return False
    if isinstance(owner, astroid.Module):
        try:
            owner.getattr("__getattr__")
            return False
        except astroid.NotFoundError:
            pass
    if node.attrname.startswith("_" + owner_name):
        # Test if an attribute has been mangled ('private' attribute)
        unmangled_name = node.attrname.split("_" + owner_name)[-1]
        try:
            if owner.getattr(unmangled_name, context=None) is not None:
                return False
        except astroid.NotFoundError:
            return True
    return True

Try to see if no - member should be emitted for the given owner .


def _has_parent_of_type(node, node_type, statement):
    """Check if the given node has a parent of the given type."""
    parent = node.parent
    while not isinstance(parent, node_type) and statement.parent_of(parent):
        parent = parent.parent
    return isinstance(parent, node_type)

def _has_parent_of_type ( node , node_type , statement ) : parent = node . parent while not isinstance ( parent , node_type ) and statement . parent_of ( parent ) : parent = parent . parent return isinstance ( parent , node_type )

Check if the given node has a parent of the given type .