def set_size(self, size): """See `storm.store.Cache.set_size`. After calling this, the cache may still contain more than `size` objects, but no more than twice that number. """ self._size = size cache = itertools.islice( itertools.chain(iter_items(self._new_cache), iter_items(self._old_cache)), 0, size) self._new_cache = dict(cache) self._old_cache.clear()
def _detect_attr_name(self, used_cls): self_id = id(self) for cls in used_cls.__mro__: for attr, prop in iter_items(cls.__dict__): if id(prop) == self_id: return attr raise RuntimeError("Property used in an unknown class")
def assert_methods_match(first, second): """Assert that public methods in C{first} are present in C{second}. This helper function asserts that all public methods found in C{first} are also present in C{second} and accept the same arguments. C{first} may have its own private methods, though, and may not have all methods found in C{second}. Note that if a private method in C{first} matches the name of one in C{second}, their specification is still compared. This is useful to verify if a fake or stub class have the same API as the real class being simulated. """ first_methods = dict(inspect.getmembers(first, inspect.ismethod)) second_methods = dict(inspect.getmembers(second, inspect.ismethod)) for name, first_method in iter_items(first_methods): # First may have its own private methods. if name.startswith("_"): continue first_argspec = inspect.getargspec(first_method) first_formatted = inspect.formatargspec(*first_argspec) assert name in second_methods second_method = second_methods.get(name) second_argspec = inspect.getargspec(second_method) assert first_argspec == second_argspec
def __str__(self): tokens = [self.scheme, ":"] append = tokens.append if (self.username is not None or self.password is not None or self.host is not None or self.port is not None): append("//") if self.username is not None or self.password is not None: if self.username is not None: append(escape(self.username)) if self.password is not None: append(":") append(escape(self.password)) append("@") if self.host is not None: append(escape(self.host)) if self.port is not None: append(":") append(str(self.port)) append("/") if self.database is not None: append(escape(self.database, "/")) if self.options: options = [ "%s=%s" % (escape(key), escape(value)) for key, value in sorted(iter_items(self.options)) ] append("?") append("&".join(options)) return "".join(tokens)
def __init__(self, name=None, primary=False, **kwargs): set_map = dict(kwargs.pop("map")) get_map = {value: key for key, value in iter_items(set_map)} if "set_map" in kwargs: set_map = dict(kwargs.pop("set_map")) kwargs["get_map"] = get_map kwargs["set_map"] = set_map SimpleProperty.__init__(self, name, primary, **kwargs)
def _find_descriptor_obj(used_cls, descr): for cls in used_cls.__mro__: for attr, _descr in iter_items(cls.__dict__): if _descr is descr: return getattr(cls, attr) raise RuntimeError("Reference used in an unknown class")