def __getattribute__(self, name): Q = type(self).Q if name == 'Q': return Q try: _qclass.__getattribute__(self, 'set' + camelize(name)) except AttributeError: attr = _qclass.__getattribute__(self, name) if name.endswith('Event'): try: event = self.__dict__[name] except KeyError: event = self.__dict__[name] = Event(name, attr) return event if isinstance(attr, Q.qboundsignalclass): try: signal = self.__dict__[name] except KeyError: signal = self.__dict__[name] = Signal(name, attr) attr.connect(signal.run) return signal return attr try: getter = _qclass.__getattribute__(self, name) except AttributeError: getter = _qclass.__getattribute__(self, 'is' + camelize(name)) value = getter() if isinstance(value, (Q.QtCore.QObject, Q.qbaseclass)): return Q(value) return value
def __getattribute__(self, name): Q = type(self).Q if name == 'Q': return Q try: _qclass.__getattribute__(self, 'set' + camelize(name)) except AttributeError: attr = _qclass.__getattribute__(self, name) if name.endswith('Event'): try: event = self.__dict__[name] except KeyError: event = self.__dict__[name] = Event(name, attr) return event if isinstance(attr, Q.qboundsignalclass): try: signal = self.__dict__[name] except KeyError: signal = self.__dict__[name] = Signal( name, attr) attr.connect(signal.run) return signal return attr try: getter = _qclass.__getattribute__(self, name) except AttributeError: getter = _qclass.__getattribute__( self, 'is' + camelize(name)) value = getter() if isinstance(value, (Q.QtCore.QObject, Q.qbaseclass)): return Q(value) return value
def test__iter__(self, inspector, stdlib, stdlib_kwfuncnames): kwnames = [camelize(n, joiner=' ') for n in stdlib_kwfuncnames] for keyword in iter(inspector): assert isinstance(keyword, robottools.library.inspector.KeywordInspector) kwnames.remove(keyword.name) assert not kwnames
def __setattr__(self, name, value): Q = type(self).Q try: setter = getattr(self, 'set' + camelize(name)) except AttributeError: pass else: setter(value) return try: attr = _qclass.__getattribute__(self, name) except AttributeError: pass else: if isinstance(attr, Q.qboundsignalclass): try: signal = self.__dict__[name] except KeyError: signal = self.__dict__[name] = Signal( name, attr) attr.connect(signal.run) if value is not signal: if callable(value): signal.slots = [value] else: signal.slots = value return _qclass.__setattr__(self, name, value)
def __setattr__(self, name, value): Q = type(self).Q try: setter = getattr(self, 'set' + camelize(name)) except AttributeError: pass else: setter(value) return try: attr = _qclass.__getattribute__(self, name) except AttributeError: pass else: if isinstance(attr, Q.qboundsignalclass): try: signal = self.__dict__[name] except KeyError: signal = self.__dict__[name] = Signal(name, attr) attr.connect(signal.run) if value is not signal: if callable(value): signal.slots = [value] else: signal.slots = value return _qclass.__setattr__(self, name, value)
def __setattr__(self, name, value): if name == 'qlist': object.__setattr__(self, name, value) for q in self.qlist: try: setter = getattr(q, 'set' + camelize(name)) except AttributeError: object.__setattr__(self, name, value) break else: setter(value)
def test__getattr__(self, inspector, stdlib): # filter keyword methods from directly instantiated stdlib kwfuncnames = [name for name, obj in getmembers(stdlib) if name[0] != "_" and ismethod(obj)] # and check that __getattr__ works with with keyword method names # as well as with normalized and camelized keyword names for name, normalized, camelized in zip(kwfuncnames, map(normalize, kwfuncnames), map(camelize, kwfuncnames)): keyword, from_normalized, from_camelized = (getattr(inspector, n) for n in [name, normalized, camelized]) assert keyword == from_normalized == from_camelized for keyword in [keyword, from_normalized, from_camelized]: assert isinstance(keyword, robottools.library.inspector.KeywordInspector) assert keyword.name == camelize(name, joiner=" ")
def __getattr__(self, name): Q = self.Q values = [] for q in self.qlist: obj = object.__getattribute__(q, name) if hasattr(q, 'set' + camelize(name)): values.append(obj()) else: values.append(obj) try: return Q(values) except TypeError: return tuple(values)
def check__getattr__Keyword(self, robot, libname, kwfuncnames): """Helper method to check that access to all Keywords given by their original function names works in different name formats. """ for funcname, camelized, normalized in zip(kwfuncnames, map(camelize, kwfuncnames), map(normalize, kwfuncnames)): for name in funcname, camelized, normalized: keyword = getattr(robot, name) assert isinstance(keyword, robottools.testrobot.Keyword) assert keyword.name == camelize(funcname, joiner=' ') assert keyword.libname == libname
def __call__(self, func=None, id=None, text=None, **props): if not func: if id: self.id = id if text: self.text = text return self props['text'] = text or self.text or camelize( func.__name__, joiner=' ') props['clicked'] = lambda arg: func() id = id or self.id if id: if id is True: id = func.__name__ + 'Button' props['id'] = id return self.Q.PushButton(**props)
def __init__(self, *args, **kwargs): Q = self.Q if args and args[0] is self: return self.qclass.__init__(self, *args) self.q = self self.qxclass.__init__(self, kwargs) for name, value in kwargs.items(): if name == "id": self.id = value continue try: setter = _qclass.__getattribute__( self, 'set' + camelize(name)) except AttributeError: attr = _qclass.__getattribute__(self, name) if name.endswith('Event'): try: event = self.__dict__[name] except KeyError: event = self.__dict__[name] = Event(name, attr) if callable(value): event.slots = [value] else: event.slots = value elif isinstance(attr, Q.qboundsignalclass): try: signal = self.__dict__[name] except KeyError: signal = self.__dict__[name] = Signal( name, attr) attr.connect(signal.run) if value is not signal: if callable(value): signal.slots = [value] else: signal.slots = value else: setter(value) @self.signal def slot(partial): partial() self.emit = Emitter(q=self)
def __call__(self, func=None, id=None, text=None, **props): if not func: if id: self.id = id if text: self.text = text return self props['text'] = text or self.text or camelize(func.__name__, joiner=' ') props['clicked'] = lambda arg: func() id = id or self.id if id: if id is True: id = func.__name__ + 'Button' props['id'] = id return self.Q.PushButton(**props)
def test__getattr__(self, inspector, stdlib): # filter keyword methods from directly instantiated stdlib kwfuncnames = [ name for name, obj in getmembers(stdlib) if name[0] != '_' and ismethod(obj) ] # and check that __getattr__ works with with keyword method names # as well as with normalized and camelized keyword names for name, normalized, camelized in zip(kwfuncnames, map(normalize, kwfuncnames), map(camelize, kwfuncnames)): keyword, from_normalized, from_camelized = (getattr( inspector, n) for n in [name, normalized, camelized]) assert keyword == from_normalized == from_camelized for keyword in [keyword, from_normalized, from_camelized]: assert isinstance( keyword, robottools.library.inspector.KeywordInspector) assert keyword.name == camelize(name, joiner=' ')
def test_camelize(): """Test the string camelize() function. """ for lower_case, CamelCase in CAMELIZED: assert camelize(lower_case) == CamelCase
def __getattr__(self, name): value = getattr(self.com, camelize(name)) if isinstance(value, DispatchBaseClass): return type(self)(value) return value
def test__iter__(self, inspector, stdlib, stdlib_kwfuncnames): kwnames = [camelize(n, joiner=" ") for n in stdlib_kwfuncnames] for keyword in iter(inspector): assert isinstance(keyword, robottools.library.inspector.KeywordInspector) kwnames.remove(keyword.name) assert not kwnames
def __new__(cls, name='', convert=True): if convert and type(name) is not KeywordName: name = camelize(name, joiner=' ') return str.__new__(cls, name)
def __init__(self, handlerclsname=None, options=None): """Generate several variants of a session handler name for use in identifiers and message strings. - Based on the `handlerclsname` and/or the attributes of the optional `Handler.Meta` class in `options`, which can define name (variant) prefixes/suffixes and/or explicit name variants. """ # Check all prefix definitions and generate actual prefix strings prefixes = {} def gen_prefix(key, default, append=''): """Check the prefix definition for name variant identified by `key`. - Set to `default` if not defined. - Always `append` the given extra string. """ try: prefix = getattr( options, (key and key + '_') + 'name_prefix') except AttributeError: prefix = default else: prefix = prefix and str(prefix) or '' if prefix and not prefix.endswith(append): prefix += append # Finally add to the prefixes dictionary prefixes[key] = prefix def gen_plural_prefix(key, append=''): """Check the prefix definition for plural name variant identified by plural_`key`. - Set to singular `key` prefix if not defined. - Always `append` the given extra string. """ plural_key = 'plural' + (key and '_' + key) default = prefixes[key] gen_prefix(plural_key, default, append) # Base name prefixes gen_prefix('', '', '_') gen_plural_prefix('', '_') gen_prefix('upper', camelize(prefixes[''])) gen_plural_prefix('upper') # Identifier name prefixes gen_prefix('identifier', '', '_') gen_plural_prefix('identifier', '_') gen_prefix('upper_identifier', camelize(prefixes['identifier'])) # Verbose name prefixes gen_prefix('verbose', '', ' ') gen_plural_prefix('verbose', ' ') # Check all suffix definitions and generate actual suffix strings suffixes = {} def gen_suffix(key, default, prepend=''): """Check the suffix definition for name variant identified by `key`. - Set to `default` if not defined. - Always `prepend` the given extra string. """ try: suffix = getattr(options, key + '_name_suffix') except AttributeError: suffix = default else: suffix = suffix and str(suffix) or '' if suffix and not suffix.startswith(prepend): suffix = prepend + suffix # Finally add to the suffixes dictionary suffixes[key] = suffix def gen_plural_suffix(key, prepend=''): """Check the suffix definition for plural name variant identified by plural_`key`. - Set to singular `key` suffix + 's' if not defined. - Always `prepend` the given extra string. """ plural_key = 'plural' + (key and '_' + key) default = suffixes[key] and suffixes[key] + 's' gen_suffix(plural_key, default, prepend) # Identifier name suffixes gen_suffix('', '', '_') gen_plural_suffix('', '_') gen_suffix('upper', camelize(suffixes[''])) gen_plural_suffix('upper') # Identifier name suffixes ## gen_suffix('identifier', 'session', '_') gen_suffix('identifier', '', '_') gen_plural_suffix('identifier', '_') gen_suffix('upper_identifier', camelize(suffixes['identifier'])) # Verbose name suffixes ## gen_suffix('verbose', 'Session', ' ') gen_suffix('verbose', '', ' ') gen_plural_suffix('verbose', ' ') # Check explicit name variant definitions variants = {} for variantkey in ( '', 'plural', 'upper', 'plural_upper', 'identifier', 'plural_identifier', 'upper_identifier', 'verbose', 'plural_verbose' ): defname = (variantkey and variantkey + '_') + 'name' variant = getattr(options, defname, None) # Non-empty string or None variant = variant and (str(variant) or None) or None variants[variantkey] = variant # Create final base name (helper) variants # (NOT stored in final meta object (self)) key = '' name = ( variants[key] or prefixes[key] + decamelize(handlerclsname) + suffixes[key]) key = 'plural' plural_name = ( variants[key] and prefixes[key] + variants[key] + suffixes[key] or None) key = 'upper' upper_name = ( variants[key] or variants[''] and camelize(variants['']) or prefixes[key] + handlerclsname + suffixes[key]) key = 'plural_upper' plural_upper_name = ( variants[key] or variants['plural'] and prefixes[key] + camelize(variants['plural']) + ( suffixes[key] or (not variants['plural'] and 's' or '')) or None) # Create final identifier/verbose name variants # (stored in final meta object (self)) key = 'identifier' self.identifier_name = ( variants[key] or prefixes[key] + name + suffixes[key]) key = 'plural_identifier' self.plural_identifier_name = ( variants[key] or prefixes[key] + (plural_name or name) + ( suffixes[key] or (not plural_name and 's' or ''))) key = 'upper_identifier' self.upper_identifier_name = ( variants[key] or prefixes[key] + upper_name + suffixes[key]) key = 'verbose' self.verbose_name = ( variants[key] or prefixes[key] + upper_name + suffixes[key]) key = 'plural_verbose' self.plural_verbose_name = ( variants[key] or prefixes[key] + (plural_upper_name or upper_name) + ( suffixes[key] or (not plural_upper_name and 's' or '')))
def __new__(cls, name, convert=True): if convert and type(name) is not KeywordName: name = camelize(name, joiner=' ') return str.__new__(cls, name)
def __init__(self, handlerclsname=None, options=None): """Generate several variants of the session handler name for use in identifiers and message strings and store additional general `options` given as ``Handler.Meta`` class object. - Name generation is based on the `handlerclsname` and/or related `options` attributes, which can define name (variant) prefixes/suffixes and/or explicit name variants. """ self.auto_explicit = bool(getattr(options, 'auto_explicit', False)) # Check all prefix definitions and generate actual prefix strings prefixes = {} def gen_prefix(key, default, append=''): """Check the prefix definition for name variant identified by `key`. - Set to `default` if not defined. - Always `append` the given extra string. """ try: prefix = getattr(options, (key and key + '_') + 'name_prefix') except AttributeError: prefix = default else: prefix = prefix and str(prefix) or '' if prefix and not prefix.endswith(append): prefix += append # Finally add to the prefixes dictionary prefixes[key] = prefix def gen_plural_prefix(key, append=''): """Check the prefix definition for plural name variant identified by plural_`key`. - Set to singular `key` prefix if not defined. - Always `append` the given extra string. """ plural_key = 'plural' + (key and '_' + key) default = prefixes[key] gen_prefix(plural_key, default, append) # Base name prefixes gen_prefix('', '', '_') gen_plural_prefix('', '_') gen_prefix('upper', camelize(prefixes[''])) gen_plural_prefix('upper') # Identifier name prefixes gen_prefix('identifier', '', '_') gen_plural_prefix('identifier', '_') gen_prefix('upper_identifier', camelize(prefixes['identifier'])) # Verbose name prefixes gen_prefix('verbose', '', ' ') gen_plural_prefix('verbose', ' ') # Check all suffix definitions and generate actual suffix strings suffixes = {} def gen_suffix(key, default, prepend=''): """Check the suffix definition for name variant identified by `key`. - Set to `default` if not defined. - Always `prepend` the given extra string. """ try: suffix = getattr(options, key + '_name_suffix') except AttributeError: suffix = default else: suffix = suffix and str(suffix) or '' if suffix and not suffix.startswith(prepend): suffix = prepend + suffix # Finally add to the suffixes dictionary suffixes[key] = suffix def gen_plural_suffix(key, prepend=''): """Check the suffix definition for plural name variant identified by plural_`key`. - Set to singular `key` suffix + 's' if not defined. - Always `prepend` the given extra string. """ plural_key = 'plural' + (key and '_' + key) default = suffixes[key] and suffixes[key] + 's' gen_suffix(plural_key, default, prepend) # Identifier name suffixes gen_suffix('', '', '_') gen_plural_suffix('', '_') gen_suffix('upper', camelize(suffixes[''])) gen_plural_suffix('upper') # Identifier name suffixes ## gen_suffix('identifier', 'session', '_') gen_suffix('identifier', '', '_') gen_plural_suffix('identifier', '_') gen_suffix('upper_identifier', camelize(suffixes['identifier'])) # Verbose name suffixes ## gen_suffix('verbose', 'Session', ' ') gen_suffix('verbose', '', ' ') gen_plural_suffix('verbose', ' ') # Check explicit name variant definitions variants = {} for variantkey in ('', 'plural', 'upper', 'plural_upper', 'identifier', 'plural_identifier', 'upper_identifier', 'verbose', 'plural_verbose'): defname = (variantkey and variantkey + '_') + 'name' variant = getattr(options, defname, None) # Non-empty string or None variant = variant and (str(variant) or None) or None variants[variantkey] = variant # Create final base name (helper) variants # (NOT stored in final meta object (self)) key = '' name = (variants[key] or prefixes[key] + decamelize(handlerclsname) + suffixes[key]) key = 'plural' plural_name = (variants[key] and prefixes[key] + variants[key] + suffixes[key] or None) key = 'upper' upper_name = (variants[key] or variants[''] and camelize(variants['']) or prefixes[key] + handlerclsname + suffixes[key]) key = 'plural_upper' plural_upper_name = (variants[key] or variants['plural'] and prefixes[key] + camelize(variants['plural']) + (suffixes[key] or (not variants['plural'] and 's' or '')) or None) # Create final identifier/verbose name variants # (stored in final meta object (self)) key = 'identifier' self.identifier_name = (variants[key] or prefixes[key] + name + suffixes[key]) key = 'plural_identifier' self.plural_identifier_name = (variants[key] or prefixes[key] + (plural_name or name) + (suffixes[key] or (not plural_name and 's' or ''))) key = 'upper_identifier' self.upper_identifier_name = (variants[key] or prefixes[key] + upper_name + suffixes[key]) key = 'verbose' self.verbose_name = (variants[key] or prefixes[key] + upper_name + suffixes[key]) key = 'plural_verbose' self.plural_verbose_name = (variants[key] or prefixes[key] + (plural_upper_name or upper_name) + (suffixes[key] or (not plural_upper_name and 's' or '')))