nrc = netrc.netrc()
                self.assertEqual(nrc.hosts['foo.domain.com'],
                                 ('bar', None, 'pass'))
                os.chmod(fn, 0o622)
                self.assertRaises(netrc.NetrcParseError, netrc.netrc)

    def test_file_not_found_in_home(self):
        with os_helper.temp_cwd(None) as d:
            with os_helper.EnvironmentVarGuard() as environ:

            

Reported by Bandit.

              
            with support.swap_attr(os.path, 'expanduser', fake_expanduser):
                nrc = netrc.netrc()
                login, account, password = nrc.authenticators('foo.domain.com')
                self.assertEqual(login, 'bar')

            self.assertTrue(called)



            

Reported by Pylint.

              
            with support.swap_attr(os.path, 'expanduser', fake_expanduser):
                nrc = netrc.netrc()
                login, account, password = nrc.authenticators('foo.domain.com')
                self.assertEqual(login, 'bar')

            self.assertTrue(called)



            

Reported by Pylint.

              import netrc, os, unittest, sys, tempfile, textwrap
from test import support
from test.support import os_helper


class NetrcTestCase(unittest.TestCase):

    def make_nrc(self, test_data):
        test_data = textwrap.dedent(test_data)

            

Reported by Pylint.

              import netrc, os, unittest, sys, tempfile, textwrap
from test import support
from test.support import os_helper


class NetrcTestCase(unittest.TestCase):

    def make_nrc(self, test_data):
        test_data = textwrap.dedent(test_data)

            

Reported by Pylint.

              from test.support import os_helper


class NetrcTestCase(unittest.TestCase):

    def make_nrc(self, test_data):
        test_data = textwrap.dedent(test_data)
        mode = 'w'
        if sys.platform != 'cygwin':

            

Reported by Pylint.

              
class NetrcTestCase(unittest.TestCase):

    def make_nrc(self, test_data):
        test_data = textwrap.dedent(test_data)
        mode = 'w'
        if sys.platform != 'cygwin':
            mode += 't'
        temp_fd, temp_filename = tempfile.mkstemp()

            

Reported by Pylint.

                      if sys.platform != 'cygwin':
            mode += 't'
        temp_fd, temp_filename = tempfile.mkstemp()
        with os.fdopen(temp_fd, mode=mode) as fp:
            fp.write(test_data)
        self.addCleanup(os.unlink, temp_filename)
        return netrc.netrc(temp_filename)

    def test_default(self):

            

Reported by Pylint.

                      self.addCleanup(os.unlink, temp_filename)
        return netrc.netrc(temp_filename)

    def test_default(self):
        nrc = self.make_nrc("""\
            machine host1.domain.com login log1 password pass1 account acct1
            default login log2 password pass2
            """)
        self.assertEqual(nrc.hosts['host1.domain.com'],

            

Reported by Pylint.

                      nrc2 = self.make_nrc(nrc.__repr__())
        self.assertEqual(nrc.hosts, nrc2.hosts)

    def test_macros(self):
        nrc = self.make_nrc("""\
            macdef macro1
            line1
            line2


            

Reported by Pylint.

                  return Function(ob.module, func_name, ob.file, lineno,
                    parent=ob, is_async=is_async, end_lineno=end_lineno)

def _nest_class(ob, class_name, lineno, end_lineno, super=None):
    "Return a Class after nesting within ob."
    return Class(ob.module, class_name, super, ob.file, lineno,
                 parent=ob, end_lineno=end_lineno)



            

Reported by Pylint.

                      return _readmodule(submodule, parent['__path__'], package)

    # Search the path for the module.
    f = None
    if inpackage is not None:
        search_path = path
    else:
        search_path = path + sys.path
    spec = importlib.util._find_spec_from_path(fullmodule, search_path)

            

Reported by Pylint.

                      search_path = path
    else:
        search_path = path + sys.path
    spec = importlib.util._find_spec_from_path(fullmodule, search_path)
    if spec is None:
        raise ModuleNotFoundError(f"no module named {fullmodule!r}", name=fullmodule)
    _modules[fullmodule] = tree
    # Is module a package?
    if spec.submodule_search_locations is not None:

            

Reported by Pylint.

                  import os
    try:
        mod = sys.argv[1]
    except:
        mod = __file__
    if os.path.exists(mod):
        path = [os.path.dirname(mod)]
        mod = os.path.basename(mod)
        if mod.lower().endswith(".py"):

            

Reported by Pylint.

              _modules = {}  # Initialize cache of modules we've seen.


class _Object:
    "Information about Python class or function."
    def __init__(self, module, name, file, lineno, end_lineno, parent):
        self.module = module
        self.name = name
        self.file = file

            

Reported by Pylint.

              
class _Object:
    "Information about Python class or function."
    def __init__(self, module, name, file, lineno, end_lineno, parent):
        self.module = module
        self.name = name
        self.file = file
        self.lineno = lineno
        self.end_lineno = end_lineno

            

Reported by Pylint.

              

# Odd Function and Class signatures are for back-compatibility.
class Function(_Object):
    "Information about a Python function, including methods."
    def __init__(self, module, name, file, lineno,
                 parent=None, is_async=False, *, end_lineno=None):
        super().__init__(module, name, file, lineno, end_lineno, parent)
        self.is_async = is_async

            

Reported by Pylint.

              # Odd Function and Class signatures are for back-compatibility.
class Function(_Object):
    "Information about a Python function, including methods."
    def __init__(self, module, name, file, lineno,
                 parent=None, is_async=False, *, end_lineno=None):
        super().__init__(module, name, file, lineno, end_lineno, parent)
        self.is_async = is_async
        if isinstance(parent, Class):
            parent.methods[name] = lineno

            

Reported by Pylint.

                          parent.methods[name] = lineno


class Class(_Object):
    "Information about a Python class."
    def __init__(self, module, name, super_, file, lineno,
                 parent=None, *, end_lineno=None):
        super().__init__(module, name, file, lineno, end_lineno, parent)
        self.super = super_ or []

            

Reported by Pylint.

              
class Class(_Object):
    "Information about a Python class."
    def __init__(self, module, name, super_, file, lineno,
                 parent=None, *, end_lineno=None):
        super().__init__(module, name, file, lineno, end_lineno, parent)
        self.super = super_ or []
        self.methods = {}


            

Reported by Pylint.

                      self.assertIsNone(self.d.get(b'xxx'))
        self.assertEqual(self.d.get(b'xxx', b'foo'), b'foo')
        with self.assertRaises(KeyError):
            self.d['xxx']
        self.assertEqual(self.d.setdefault(b'xxx', b'foo'), b'foo')
        self.assertEqual(self.d[b'xxx'], b'foo')
        self.d.close()

    def test_empty_value(self):

            

Reported by Pylint.

              from test.support import import_helper
from test.support import os_helper
import_helper.import_module("dbm.ndbm") #skip if not supported
import os
import unittest
import dbm.ndbm
from dbm.ndbm import error

class DbmTestCase(unittest.TestCase):

            

Reported by Pylint.

              from test.support import import_helper
from test.support import os_helper
import_helper.import_module("dbm.ndbm") #skip if not supported
import os
import unittest
import dbm.ndbm
from dbm.ndbm import error

class DbmTestCase(unittest.TestCase):

            

Reported by Pylint.

              from test.support import os_helper
import_helper.import_module("dbm.ndbm") #skip if not supported
import os
import unittest
import dbm.ndbm
from dbm.ndbm import error

class DbmTestCase(unittest.TestCase):


            

Reported by Pylint.

              import_helper.import_module("dbm.ndbm") #skip if not supported
import os
import unittest
import dbm.ndbm
from dbm.ndbm import error

class DbmTestCase(unittest.TestCase):

    def setUp(self):

            

Reported by Pylint.

              import os
import unittest
import dbm.ndbm
from dbm.ndbm import error

class DbmTestCase(unittest.TestCase):

    def setUp(self):
        self.filename = os_helper.TESTFN

            

Reported by Pylint.

              import dbm.ndbm
from dbm.ndbm import error

class DbmTestCase(unittest.TestCase):

    def setUp(self):
        self.filename = os_helper.TESTFN
        self.d = dbm.ndbm.open(self.filename, 'c')
        self.d.close()

            

Reported by Pylint.

              
    def setUp(self):
        self.filename = os_helper.TESTFN
        self.d = dbm.ndbm.open(self.filename, 'c')
        self.d.close()

    def tearDown(self):
        for suffix in ['', '.pag', '.dir', '.db']:
            os_helper.unlink(self.filename + suffix)

            

Reported by Pylint.

                      for suffix in ['', '.pag', '.dir', '.db']:
            os_helper.unlink(self.filename + suffix)

    def test_keys(self):
        self.d = dbm.ndbm.open(self.filename, 'c')
        self.assertEqual(self.d.keys(), [])
        self.d['a'] = 'b'
        self.d[b'bytes'] = b'data'
        self.d['12345678910'] = '019237410982340912840198242'

            

Reported by Pylint.

                      self.assertEqual(self.d[b'xxx'], b'foo')
        self.d.close()

    def test_empty_value(self):
        if dbm.ndbm.library == 'Berkeley DB':
            self.skipTest("Berkeley DB doesn't distinguish the empty value "
                          "from the absent one")
        self.d = dbm.ndbm.open(self.filename, 'c')
        self.assertEqual(self.d.keys(), [])

            

Reported by Pylint.

              
class GeneralTest(unittest.TestCase):
    def setUp(self):
        atexit._clear()

    def tearDown(self):
        atexit._clear()

    def assert_raises_unraisable(self, exc_type, func, *args):

            

Reported by Pylint.

                      atexit._clear()

    def tearDown(self):
        atexit._clear()

    def assert_raises_unraisable(self, exc_type, func, *args):
        with support.catch_unraisable_exception() as cm:
            atexit.register(func, *args)
            atexit._run_exitfuncs()

            

Reported by Pylint.

                  def assert_raises_unraisable(self, exc_type, func, *args):
        with support.catch_unraisable_exception() as cm:
            atexit.register(func, *args)
            atexit._run_exitfuncs()

            self.assertEqual(cm.unraisable.object, func)
            self.assertEqual(cm.unraisable.exc_type, exc_type)
            self.assertEqual(type(cm.unraisable.exc_value), exc_type)


            

Reported by Pylint.

                      atexit.register(func1, 1, 2)
        atexit.register(func2)
        atexit.register(func2, 3, key="value")
        atexit._run_exitfuncs()

        self.assertEqual(calls,
                         [('func2', (3,), {'key': 'value'}),
                          ('func2', (), {}),
                          ('func1', (1, 2), {})])

            

Reported by Pylint.

                      # bpo-10756: Make sure that an unnormalized exception is handled
        # properly.
        def div_zero():
            1 / 0

        self.assert_raises_unraisable(ZeroDivisionError, div_zero)

    def test_exit(self):
        self.assert_raises_unraisable(SystemExit, sys.exit)

            

Reported by Pylint.

                      def inc():
            a[0] += 1

        for i in range(128):
            atexit.register(inc)
        atexit._run_exitfuncs()

        self.assertEqual(a[0], 128)


            

Reported by Pylint.

              
        for i in range(128):
            atexit.register(inc)
        atexit._run_exitfuncs()

        self.assertEqual(a[0], 128)

    def test_clear(self):
        a = [0]

            

Reported by Pylint.

                          a[0] += 1

        atexit.register(inc)
        atexit._clear()
        atexit._run_exitfuncs()

        self.assertEqual(a[0], 0)

    def test_unregister(self):

            

Reported by Pylint.

              
        atexit.register(inc)
        atexit._clear()
        atexit._run_exitfuncs()

        self.assertEqual(a[0], 0)

    def test_unregister(self):
        a = [0]

            

Reported by Pylint.

                      def dec():
            a[0] -= 1

        for i in range(4):
            atexit.register(inc)
        atexit.register(dec)
        atexit.unregister(inc)
        atexit._run_exitfuncs()


            

Reported by Pylint.

                      return NULL;
    }
    if (prefix)
        strcpy(result, prefix);
    else
        result[0] = '\0';
    strcat(result, suffix);
    return result;
}

            

Reported by FlawFinder.

                      strcpy(result, prefix);
    else
        result[0] = '\0';
    strcat(result, suffix);
    return result;
}

/*
  Allocate a memory block for a pep3118 format string, adding

            

Reported by FlawFinder.

                  }
    new_prefix[0] = '\0';
    if (prefix)
        strcpy(new_prefix, prefix);
    if (ndim > 0) {
        /* Add the prefix "(shape[0],shape[1],...,shape[ndim-1])" */
        strcat(new_prefix, "(");
        for (k = 0; k < ndim; ++k) {
            if (k < ndim-1) {

            

Reported by FlawFinder.

                          } else {
                sprintf(buf, "%"PY_FORMAT_SIZE_T"d)", shape[k]);
            }
            strcat(new_prefix, buf);
        }
    }
    result = _ctypes_alloc_format_string(new_prefix, suffix);
    PyMem_Free(new_prefix);
    return result;

            

Reported by FlawFinder.

                  if (!mangled_name)
        return NULL;
    for (i = 0; i < 32; ++i) {
        sprintf(mangled_name, "_%s@%d", name, i*4);
        Py_BEGIN_ALLOW_THREADS
        address = (PPROC)GetProcAddress(handle, mangled_name);
        Py_END_ALLOW_THREADS
        if (address)
            return address;

            

Reported by FlawFinder.

              {
    char *new_prefix;
    char *result;
    char buf[32];
    Py_ssize_t prefix_len;
    int k;

    prefix_len = 32 * ndim + 3;
    if (prefix)

            

Reported by FlawFinder.

                      strcat(new_prefix, "(");
        for (k = 0; k < ndim; ++k) {
            if (k < ndim-1) {
                sprintf(buf, "%"PY_FORMAT_SIZE_T"d,", shape[k]);
            } else {
                sprintf(buf, "%"PY_FORMAT_SIZE_T"d)", shape[k]);
            }
            strcat(new_prefix, buf);
        }

            

Reported by FlawFinder.

                          if (k < ndim-1) {
                sprintf(buf, "%"PY_FORMAT_SIZE_T"d,", shape[k]);
            } else {
                sprintf(buf, "%"PY_FORMAT_SIZE_T"d)", shape[k]);
            }
            strcat(new_prefix, buf);
        }
    }
    result = _ctypes_alloc_format_string(new_prefix, suffix);

            

Reported by FlawFinder.

                      if (ptr == NULL) {
            return NULL;
        }
        memcpy(ptr, self->b_ptr, self->b_size);

        /* Create a Python object which calls PyMem_Free(ptr) in
           its deallocator. The object will be destroyed
           at _ctypes_callproc() cleanup. */
        obj = (&StructParam_Type)->tp_alloc(&StructParam_Type, 0);

            

Reported by FlawFinder.

              
    result = GenericPyCData_new((PyTypeObject *)type, NULL, NULL);
    if (result != NULL) {
        memcpy(((CDataObject *)result)->b_ptr,
               (char *)buffer.buf + offset, dict->size);
    }
    PyBuffer_Release(&buffer);
    return result;
}

            

Reported by FlawFinder.

              from tempfile import TemporaryFile

from test.support import os_helper
from test.support import TESTFN, requires_zlib

TESTFN2 = TESTFN + "2"

# How much time in seconds can pass before we print a 'Still working' message.
_PRINT_WORKING_MSG_INTERVAL = 60

            

Reported by Pylint.

              # from test_zipfile
from test import support

# XXX(nnorwitz): disable this test by looking for extralargefile resource,
# which doesn't exist.  This test takes over 30 minutes to run in general
# and requires more disk space than most of the buildbots.
support.requires(
        'extralargefile',
        'test requires loads of disk-space bytes and a long time to run'

            

Reported by Pylint.

              # Tests of the full ZIP64 functionality of zipfile
# The support.requires call is the only reason for keeping this separate
# from test_zipfile
from test import support

# XXX(nnorwitz): disable this test by looking for extralargefile resource,
# which doesn't exist.  This test takes over 30 minutes to run in general
# and requires more disk space than most of the buildbots.
support.requires(

            

Reported by Pylint.

                      'test requires loads of disk-space bytes and a long time to run'
    )

import zipfile, os, unittest
import time
import sys

from tempfile import TemporaryFile


            

Reported by Pylint.

                      'test requires loads of disk-space bytes and a long time to run'
    )

import zipfile, os, unittest
import time
import sys

from tempfile import TemporaryFile


            

Reported by Pylint.

                      'test requires loads of disk-space bytes and a long time to run'
    )

import zipfile, os, unittest
import time
import sys

from tempfile import TemporaryFile


            

Reported by Pylint.

                      'test requires loads of disk-space bytes and a long time to run'
    )

import zipfile, os, unittest
import time
import sys

from tempfile import TemporaryFile


            

Reported by Pylint.

                  )

import zipfile, os, unittest
import time
import sys

from tempfile import TemporaryFile

from test.support import os_helper

            

Reported by Pylint.

              
import zipfile, os, unittest
import time
import sys

from tempfile import TemporaryFile

from test.support import os_helper
from test.support import TESTFN, requires_zlib

            

Reported by Pylint.

              import time
import sys

from tempfile import TemporaryFile

from test.support import os_helper
from test.support import TESTFN, requires_zlib

TESTFN2 = TESTFN + "2"

            

Reported by Pylint.

              import re

from . import info as _info
from .parser._regexes import SIMPLE_TYPE


_KIND = _info.KIND



            

Reported by Pylint.

              import re

from . import info as _info
from .parser._regexes import SIMPLE_TYPE


_KIND = _info.KIND



            

Reported by Pylint.

              def _is_funcptr(declstr):
    if not declstr:
        return None
    # XXX Support "(<name>*)(".
    return '(*)(' in declstr.replace(' ', '')


def is_forward_decl(decl):
    if decl.kind is _KIND.TYPEDEF:

            

Reported by Pylint.

                  elif is_type_decl(decl):
        return not decl.data
    elif decl.kind is _KIND.FUNCTION:
        # XXX This doesn't work with ParsedItem.
        return decl.signature.isforward
    elif decl.kind is _KIND.VARIABLE:
        # No var decls are considered forward (or all are...).
        return False
    else:

            

Reported by Pylint.

              
def filter_by_kind(items, kind):
    if kind == 'type':
        kinds = _KIND._TYPE_DECLS
    elif kind == 'decl':
        kinds = _KIND._TYPE_DECLS
    try:
        okay = kind in _KIND
    except TypeError:

            

Reported by Pylint.

                  if kind == 'type':
        kinds = _KIND._TYPE_DECLS
    elif kind == 'decl':
        kinds = _KIND._TYPE_DECLS
    try:
        okay = kind in _KIND
    except TypeError:
        kinds = set(kind)
    else:

            

Reported by Pylint.

                      try:
            collated[item.kind].append(item)
        except KeyError:
            raise ValueError(f'unsupported kind in {item!r}')
    return collated


def group_by_kinds(items):
    # Collate into kind groups (decl, type, etc.).

            

Reported by Pylint.

              import re

from . import info as _info
from .parser._regexes import SIMPLE_TYPE


_KIND = _info.KIND



            

Reported by Pylint.

              _KIND = _info.KIND


def match_storage(decl, expected):
    default = _info.get_default_storage(decl)
    #assert default
    if expected is None:
        expected = {default}
    elif isinstance(expected, str):

            

Reported by Pylint.

              ##################################
# decl matchers

def is_type_decl(item):
    return _KIND.is_type_decl(item.kind)


def is_decl(item):
    return _KIND.is_decl(item.kind)

            

Reported by Pylint.

                                      yield NeedMoreData
                        continue
                    break
                msg = self._pop_message()
                # We need to pop the EOF matcher in order to tell if we're at
                # the end of the current file, not the end of the last block
                # of message headers.
                self._input.pop_eof_matcher()
                # The input stream must be sitting at the newline or at the

            

Reported by Pylint.

                                              end = len(mo.group(0))
                                self._last.epilogue = epilogue[:-end]
                    else:
                        payload = self._last._payload
                        if isinstance(payload, str):
                            mo = NLCRE_eol.search(payload)
                            if mo:
                                payload = payload[:-len(mo.group(0))]
                                self._last._payload = payload

            

Reported by Pylint.

                                          mo = NLCRE_eol.search(payload)
                            if mo:
                                payload = payload[:-len(mo.group(0))]
                                self._last._payload = payload
                    self._input.pop_eof_matcher()
                    self._pop_message()
                    # Set the multipart up for newline cleansing, which will
                    # happen if we're in a nested multipart.
                    self._last = self._cur

            

Reported by Pylint.

              


class BufferedSubFile(object):
    """A file-ish object that can have new data loaded into it.

    You can also push and pop line-matching predicates onto a stack.  When the
    current predicate matches the current line, a false EOF response
    (i.e. empty string) is returned instead.  This lets the parser adhere to a

            

Reported by Pylint.

                      # A flag indicating whether the file has been closed or not.
        self._closed = False

    def push_eof_matcher(self, pred):
        self._eofstack.append(pred)

    def pop_eof_matcher(self):
        return self._eofstack.pop()


            

Reported by Pylint.

                  def push_eof_matcher(self, pred):
        self._eofstack.append(pred)

    def pop_eof_matcher(self):
        return self._eofstack.pop()

    def close(self):
        # Don't forget any trailing partial line.
        self._partial.seek(0)

            

Reported by Pylint.

                  def pop_eof_matcher(self):
        return self._eofstack.pop()

    def close(self):
        # Don't forget any trailing partial line.
        self._partial.seek(0)
        self.pushlines(self._partial.readlines())
        self._partial.seek(0)
        self._partial.truncate()

            

Reported by Pylint.

                      self._partial.truncate()
        self._closed = True

    def readline(self):
        if not self._lines:
            if self._closed:
                return ''
            return NeedMoreData
        # Pop the line off the stack and see if it matches the current

            

Reported by Pylint.

                              return ''
        return line

    def unreadline(self, line):
        # Let the consumer push a line back into the buffer.
        assert line is not NeedMoreData
        self._lines.appendleft(line)

    def push(self, data):

            

Reported by Pylint.

              
    def unreadline(self, line):
        # Let the consumer push a line back into the buffer.
        assert line is not NeedMoreData
        self._lines.appendleft(line)

    def push(self, data):
        """Push some new data into this object."""
        self._partial.write(data)

            

Reported by Bandit.

              from _collections_abc import *
from _collections_abc import __all__
from _collections_abc import _CallableGenericAlias

            

Reported by Pylint.

              from _collections_abc import *
from _collections_abc import __all__
from _collections_abc import _CallableGenericAlias

            

Reported by Pylint.

              from _collections_abc import *
from _collections_abc import __all__
from _collections_abc import _CallableGenericAlias

            

Reported by Pylint.

              from _collections_abc import *
from _collections_abc import __all__
from _collections_abc import _CallableGenericAlias

            

Reported by Pylint.

              from _collections_abc import *
from _collections_abc import __all__
from _collections_abc import _CallableGenericAlias

            

Reported by Pylint.

              from _collections_abc import *
from _collections_abc import __all__
from _collections_abc import _CallableGenericAlias

            

Reported by Pylint.

              from _collections_abc import *
from _collections_abc import __all__
from _collections_abc import _CallableGenericAlias

            

Reported by Pylint.

              from _collections_abc import *
from _collections_abc import __all__
from _collections_abc import _CallableGenericAlias

            

Reported by Pylint.

              from _collections_abc import *
from _collections_abc import __all__
from _collections_abc import _CallableGenericAlias

            

Reported by Pylint.

              from _collections_abc import *
from _collections_abc import __all__
from _collections_abc import _CallableGenericAlias

            

Reported by Pylint.

              """

from os import path
from docutils import nodes
from docutils.parsers.rst import directives
from docutils.parsers.rst import Directive
from docutils.statemachine import StringList
import csv


            

Reported by Pylint.

              
from os import path
from docutils import nodes
from docutils.parsers.rst import directives
from docutils.parsers.rst import Directive
from docutils.statemachine import StringList
import csv

from sphinx import addnodes

            

Reported by Pylint.

              from os import path
from docutils import nodes
from docutils.parsers.rst import directives
from docutils.parsers.rst import Directive
from docutils.statemachine import StringList
import csv

from sphinx import addnodes
from sphinx.domains.c import CObject

            

Reported by Pylint.

              from docutils import nodes
from docutils.parsers.rst import directives
from docutils.parsers.rst import Directive
from docutils.statemachine import StringList
import csv

from sphinx import addnodes
from sphinx.domains.c import CObject


            

Reported by Pylint.

              from docutils.statemachine import StringList
import csv

from sphinx import addnodes
from sphinx.domains.c import CObject


REST_ROLE_MAP = {
    'function': 'func',

            

Reported by Pylint.

              import csv

from sphinx import addnodes
from sphinx.domains.c import CObject


REST_ROLE_MAP = {
    'function': 'func',
    'var': 'data',

            

Reported by Pylint.

              from sphinx.domains.c import CObject


REST_ROLE_MAP = {
    'function': 'func',
    'var': 'data',
    'type': 'type',
    'macro': 'macro',
    'type': 'type',

            

Reported by Pylint.

                              parts = line.split(":", 4)
                if len(parts) != 5:
                    raise ValueError("Wrong field count in %r" % line)
                function, type, arg, refcount, comment = parts
                # Get the entry, creating it if needed:
                try:
                    entry = self.refcount_data[function]
                except KeyError:
                    entry = self.refcount_data[function] = RCEntry(function)

            

Reported by Pylint.

                              parts = line.split(":", 4)
                if len(parts) != 5:
                    raise ValueError("Wrong field count in %r" % line)
                function, type, arg, refcount, comment = parts
                # Get the entry, creating it if needed:
                try:
                    entry = self.refcount_data[function]
                except KeyError:
                    entry = self.refcount_data[function] = RCEntry(function)

            

Reported by Pylint.

                      self.stable_abi_data = {}
        with open(stable_abi_file, 'r') as fp:
            for record in csv.DictReader(fp):
                role = record['role']
                name = record['name']
                self.stable_abi_data[name] = record

    def add_annotations(self, app, doctree):
        for node in doctree.traverse(addnodes.desc_content):

            

Reported by Pylint.