def register(cls, subclass): """ Registers a new subclass Parameters ---------- subclass : class Subclass to register """ # noinspection PyCallByClass ABCMeta.register(cls, subclass)
def _(): MyType = ABCMeta( # pylint: disable=invalid-name native_string('MyType'), (object, ), {}, ) MyType.register(int) class MyRecord(Record): value = MyType assert_eq( MyRecord(value=42).value, 42, )
def _new_in_ver(name, ver, bases_if_missing=(ABCMeta,), register_if_missing=()): if ver: return getattr(abc, name) # TODO: It's a shame to have to repeat the bases when # the ABC is missing. Can we DRY that? missing = ABCMeta(name, bases_if_missing, { '__doc__': "The ABC %s is not defined in this version of Python." % ( name ), }) for c in register_if_missing: missing.register(c) return missing
@staticmethod def __clone(node, args, kargs): try: args = list(args) args.insert(0, node.alphabet) except AttributeError: pass return clone(node, args, kargs) def clone(self): return ConstructorWalker(self, RegexpGraphNode)(Clone(self.__clone)) #class RegexpGraphNode(metaclass=ABCMeta): RegexpGraphNode = ABCMeta('RegexpGraphNode', (object, ), {}) RegexpGraphNode.register(_Character) RegexpGraphNode.register(Sequence) class Option(Sequence): ''' An optional sequence of Characters (or sequences). ''' def _build_str(self): ''' Construct a string representation of self. ''' return self.alphabet.fmt_option(self) def build(self, graph, before, after):
# Python 2.6 #class ApplyRaw(metaclass=ABCMeta): ApplyRaw = ABCMeta('ApplyRaw', (object, ), {}) ''' ABC used to control `Apply`, so that the result is not wrapped in a list. ''' # Python 2.6 #class ApplyArgs(metaclass=ABCMeta): ApplyArgs = ABCMeta('ApplyArgs', (object, ), {}) ''' ABC used to control `Apply`, so that the results list is supplied as "*args". ''' ApplyArgs.register(Node) class NullTransformation(object): def __call__(self, _stream, matcher): return matcher() def __bool__(self): return False # Python 2.6 def __nonzero__(self): return self.__bool__()
def register(self, subclass): ABCMeta.register(self, subclass) self.warnings.add(subclass) return subclass
def register_subclasses(klass: ABCMeta, subclassregs: Iterable): for subclass in subclassregs: klass.register(subclass) return klass
def register(cls, subclass): ABCMeta.register(cls, subclass) if subclass not in cls._abc_registry: cls._abc_registry.add(subclass)
import inspect import uuid from abc import ABCMeta from copy import copy from pyvfs.vfs import Storage, Inode, Eexist, Eperm, restrict if sys.version_info[0] > 2: from configparser import ConfigParser unicode = str long = int basestring = (str, bytes) else: from ConfigParser import SafeConfigParser as ConfigParser Skip = ABCMeta("Skip", (object,), {}) Skip.register(types.BuiltinFunctionType) Skip.register(types.BuiltinMethodType) Skip.register(type) Skip.register(types.GeneratorType) Skip.register(types.ModuleType) Cls = ABCMeta("Cls", (object,), {}) Cls.register(type) if sys.version_info[0] == 2: Cls.register(types.ClassType) Func = ABCMeta("Func", (object,), {}) Func.register(types.FunctionType) if sys.version_info[0] == 2:
class Punctuation(Enum): COMMA = ',' PERIOD = '.' EXCLAMATION = '!' QUESTION = '?' BOLD_COMMA = bold(',') BOLD_PERIOD = bold('.') BOLD_EXCLAMATION = bold('!') BOLD_QUESTION = bold('?') def bold(self): try: return getattr(Punctuation, 'BOLD_{}'.format(self.name)) except AttributeError: return self @staticmethod def has_tags(*tags): return False def capitalize(self): return self def de_capitalize(self): return self ABCMeta.register(AbstractWord, Punctuation)
return Tags(tag_list) def has_tags(self, *tags: WordTag) -> bool: return all(self.tags.has(tag) for tag in tags) def capitalize(self) -> AbstractWord: return BasicWord(self.value.capitalize()) def de_capitalize(self) -> 'BeVerb': return self def bold(self) -> AbstractWord: return BasicWord(bold(self.value)) def negative(self): if self.has_tags(WordTag.NEGATIVE) or self == BeVerb.BE: return self return getattr(self, '{}_NOT'.format(self.name)) def past_tense(self): if self.has_tags(WordTag.PAST): return self new_name = self.name pairs = {'AM': 'WAS', 'IS': 'WAS', 'ARE': 'WERE'} for present, past in pairs.items(): new_name = new_name.replace(present, past) return getattr(self, new_name) ABCMeta.register(AbstractWord, BeVerb)
def __gt__(self, other): return not(self <= other) def __ge__(self, other): return not(self < other) class Arrow(Category): pass class Monad(Category): @abstractmethod def mreturn(cls, val): pass @abstractmethod def __rshift__(self, f): pass for (cat, sub) in [ (Category, Number), (Category, TypeVariable), (Eq, Complex), (Ord, Real), (Arrow, Monad), ]: ABCMeta.register(cat, sub)
if self in changes: return changes[self] return self def is_pair(self, other): if not isinstance(other, AbstractPronoun): return False return self.subject() == other.subject() def has_tags(self, *tags): if tags == (WordTag.PLURAL,) and self in (self.YOU, self.WE, self.US, self.THEY, self.THEM): return True return False ABCMeta.register(AbstractWord, AbstractPronoun) class Pronoun(AbstractPronoun): I = 'I' ME = 'me' YOU = 'you' HE = 'he' HIM = 'him' SHE = 'she' HER = 'her' IT = 'it'