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'
