This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7272

pytype: don't warn us about ignored-on-py3 metaclasses
ClosedPublic

Authored by durin42 on Nov 6 2019, 5:57 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG70d42e2ad9b4: pytype: don't warn us about ignored-on-py3 metaclasses
Summary

We can remove this when we're Python 3-only, but for now it's just too
awkward to deal with and it's harmless.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durin42 created this revision.Nov 6 2019, 5:57 PM
indygreg accepted this revision.Nov 7 2019, 3:11 AM
indygreg added a subscriber: indygreg.

I wonder if we should adopt a convention like # TODO nopy2 XXX to denote things to fix when Python 2 support is ripped out. Otherwise I feel like we're going to forget to undo many of these hacks. (I should have suggested this months ago because there will be lingering signs of Python 2 for years to come, I fear.)

This revision is now accepted and ready to land.Nov 7 2019, 3:11 AM
durin42 added a commit: rHG70d42e2ad9b4: pytype: don't warn us about ignored-on-py3 metaclasses.Nov 7 2019, 3:32 AM
Closed by commit rHG70d42e2ad9b4: pytype: don't warn us about ignored-on-py3 metaclasses (authored by durin42). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 17642

contrib/testparseutil.py

def writeerr(data): def writeerr(data):
# write "data" in BYTES into stderr # write "data" in BYTES into stderr
sys.stderr.write(data) sys.stderr.write(data)
#################### ####################
class embeddedmatcher(object): class embeddedmatcher(object): # pytype: disable=ignored-metaclass
"""Base class to detect embedded code fragments in *.t test script """Base class to detect embedded code fragments in *.t test script
""" """
__metaclass__ = abc.ABCMeta __metaclass__ = abc.ABCMeta
def __init__(self, desc): def __init__(self, desc):
self.desc = desc self.desc = desc

hgext/infinitepush/store.py

class BundleWriteException(Exception): class BundleWriteException(Exception):
pass pass
class BundleReadException(Exception): class BundleReadException(Exception):
pass pass
class abstractbundlestore(object): class abstractbundlestore(object): # pytype: disable=ignored-metaclass
"""Defines the interface for bundle stores. """Defines the interface for bundle stores.
A bundle store is an entity that stores raw bundle data. It is a simple A bundle store is an entity that stores raw bundle data. It is a simple
key-value store. However, the keys are chosen by the store. The keys can key-value store. However, the keys are chosen by the store. The keys can
be any Python object understood by the corresponding bundle index (see be any Python object understood by the corresponding bundle index (see
``abstractbundleindex`` below). ``abstractbundleindex`` below).
""" """

mercurial/fancyopts.py

# -s/--str VALUE # -s/--str VALUE
parsedopts.append((flag, args[pos + 1])) parsedopts.append((flag, args[pos + 1]))
pos += 2 pos += 2
parsedargs.extend(args[pos:]) parsedargs.extend(args[pos:])
return parsedopts, parsedargs return parsedopts, parsedargs
class customopt(object): class customopt(object): # pytype: disable=ignored-metaclass
"""Manage defaults and mutations for any type of opt.""" """Manage defaults and mutations for any type of opt."""
__metaclass__ = abc.ABCMeta __metaclass__ = abc.ABCMeta
def __init__(self, defaultvalue): def __init__(self, defaultvalue):
self._defaultvalue = defaultvalue self._defaultvalue = defaultvalue
def _isboolopt(self): def _isboolopt(self):

mercurial/templater.py

def unquotestring(s): def unquotestring(s):
'''unwrap quotes if any; otherwise returns unmodified string''' '''unwrap quotes if any; otherwise returns unmodified string'''
if len(s) < 2 or s[0] not in b"'\"" or s[0] != s[-1]: if len(s) < 2 or s[0] not in b"'\"" or s[0] != s[-1]:
return s return s
return s[1:-1] return s[1:-1]
class resourcemapper(object): class resourcemapper(object): # pytype: disable=ignored-metaclass
"""Mapper of internal template resources""" """Mapper of internal template resources"""
__metaclass__ = abc.ABCMeta __metaclass__ = abc.ABCMeta
@abc.abstractmethod @abc.abstractmethod
def availablekeys(self, mapping): def availablekeys(self, mapping):
"""Return a set of available resource keys based on the given mapping""" """Return a set of available resource keys based on the given mapping"""

mercurial/templateutil.py

class ResourceUnavailable(error.Abort): class ResourceUnavailable(error.Abort):
pass pass
class TemplateNotFound(error.Abort): class TemplateNotFound(error.Abort):
pass pass
class wrapped(object): class wrapped(object): # pytype: disable=ignored-metaclass
"""Object requiring extra conversion prior to displaying or processing """Object requiring extra conversion prior to displaying or processing
as value as value
Use unwrapvalue() or unwrapastype() to obtain the inner object. Use unwrapvalue() or unwrapastype() to obtain the inner object.
""" """
__metaclass__ = abc.ABCMeta __metaclass__ = abc.ABCMeta
@abc.abstractmethod @abc.abstractmethod
def tovalue(self, context, mapping): def tovalue(self, context, mapping):
"""Move the inner value object out or create a value representation """Move the inner value object out or create a value representation
A returned value must be serializable by templaterfilters.json(). A returned value must be serializable by templaterfilters.json().
""" """
class mappable(object): class mappable(object): # pytype: disable=ignored-metaclass
"""Object which can be converted to a single template mapping""" """Object which can be converted to a single template mapping"""
__metaclass__ = abc.ABCMeta __metaclass__ = abc.ABCMeta
def itermaps(self, context): def itermaps(self, context):
yield self.tomap(context) yield self.tomap(context)
@abc.abstractmethod @abc.abstractmethod

mercurial/util.py

class cowsortdict(cow, sortdict): class cowsortdict(cow, sortdict):
"""copy-on-write sortdict """copy-on-write sortdict
Be sure to call d = d.preparewrite() before writing to d. Be sure to call d = d.preparewrite() before writing to d.
""" """
class transactional(object): class transactional(object): # pytype: disable=ignored-metaclass
"""Base class for making a transactional type into a context manager.""" """Base class for making a transactional type into a context manager."""
__metaclass__ = abc.ABCMeta __metaclass__ = abc.ABCMeta
@abc.abstractmethod @abc.abstractmethod
def close(self): def close(self):
"""Successfully closes the transaction.""" """Successfully closes the transaction."""