Move Windows libs to libs/windows

libs/win/jaraco/classes/ancestry.py

@@ -0,0 +1,75 @@
+"""
+Routines for obtaining the class names
+of an object and its parent classes.
+"""
+
+from __future__ import unicode_literals
+
+
+def all_bases(c):
+	"""
+	return a tuple of all base classes the class c has as a parent.
+	>>> object in all_bases(list)
+	True
+	"""
+	return c.mro()[1:]
+
+
+def all_classes(c):
+	"""
+	return a tuple of all classes to which c belongs
+	>>> list in all_classes(list)
+	True
+	"""
+	return c.mro()
+
+# borrowed from
+# http://code.activestate.com/recipes/576949-find-all-subclasses-of-a-given-class/
+
+
+def iter_subclasses(cls, _seen=None):
+	"""
+	Generator over all subclasses of a given class, in depth-first order.
+
+	>>> bool in list(iter_subclasses(int))
+	True
+	>>> class A(object): pass
+	>>> class B(A): pass
+	>>> class C(A): pass
+	>>> class D(B,C): pass
+	>>> class E(D): pass
+	>>>
+	>>> for cls in iter_subclasses(A):
+	...		print(cls.__name__)
+	B
+	D
+	E
+	C
+	>>> # get ALL (new-style) classes currently defined
+	>>> res = [cls.__name__ for cls in iter_subclasses(object)]
+	>>> 'type' in res
+	True
+	>>> 'tuple' in res
+	True
+	>>> len(res) > 100
+	True
+	"""
+
+	if not isinstance(cls, type):
+		raise TypeError(
+			'iter_subclasses must be called with '
+			'new-style classes, not %.100r' % cls
+		)
+	if _seen is None:
+		_seen = set()
+	try:
+		subs = cls.__subclasses__()
+	except TypeError:  # fails only when cls is type
+		subs = cls.__subclasses__(cls)
+	for sub in subs:
+		if sub in _seen:
+			continue
+		_seen.add(sub)
+		yield sub
+		for sub in iter_subclasses(sub, _seen):
+			yield sub

libs/win/jaraco/classes/meta.py

@@ -0,0 +1,41 @@
+"""
+meta.py
+
+Some useful metaclasses.
+"""
+
+from __future__ import unicode_literals
+
+
+class LeafClassesMeta(type):
+	"""
+	A metaclass for classes that keeps track of all of them that
+	aren't base classes.
+	"""
+
+	_leaf_classes = set()
+
+	def __init__(cls, name, bases, attrs):
+		if not hasattr(cls, '_leaf_classes'):
+			cls._leaf_classes = set()
+		leaf_classes = getattr(cls, '_leaf_classes')
+		leaf_classes.add(cls)
+		# remove any base classes
+		leaf_classes -= set(bases)
+
+
+class TagRegistered(type):
+	"""
+	As classes of this metaclass are created, they keep a registry in the
+	base class of all classes by a class attribute, indicated by attr_name.
+	"""
+	attr_name = 'tag'
+
+	def __init__(cls, name, bases, namespace):
+		super(TagRegistered, cls).__init__(name, bases, namespace)
+		if not hasattr(cls, '_registry'):
+			cls._registry = {}
+		meta = cls.__class__
+		attr = getattr(cls, meta.attr_name, None)
+		if attr:
+			cls._registry[attr] = cls

libs/win/jaraco/classes/properties.py

@@ -0,0 +1,67 @@
+from __future__ import unicode_literals
+
+import six
+
+__metaclass__ = type
+
+
+class NonDataProperty:
+	"""Much like the property builtin, but only implements __get__,
+	making it a non-data property, and can be subsequently reset.
+
+	See http://users.rcn.com/python/download/Descriptor.htm for more
+	information.
+
+	>>> class X(object):
+	...   @NonDataProperty
+	...   def foo(self):
+	...     return 3
+	>>> x = X()
+	>>> x.foo
+	3
+	>>> x.foo = 4
+	>>> x.foo
+	4
+	"""
+
+	def __init__(self, fget):
+		assert fget is not None, "fget cannot be none"
+		assert six.callable(fget), "fget must be callable"
+		self.fget = fget
+
+	def __get__(self, obj, objtype=None):
+		if obj is None:
+			return self
+		return self.fget(obj)
+
+
+# from http://stackoverflow.com/a/5191224
+class ClassPropertyDescriptor:
+
+	def __init__(self, fget, fset=None):
+		self.fget = fget
+		self.fset = fset
+
+	def __get__(self, obj, klass=None):
+		if klass is None:
+			klass = type(obj)
+		return self.fget.__get__(obj, klass)()
+
+	def __set__(self, obj, value):
+		if not self.fset:
+			raise AttributeError("can't set attribute")
+		type_ = type(obj)
+		return self.fset.__get__(obj, type_)(value)
+
+	def setter(self, func):
+		if not isinstance(func, (classmethod, staticmethod)):
+			func = classmethod(func)
+		self.fset = func
+		return self
+
+
+def classproperty(func):
+	if not isinstance(func, (classmethod, staticmethod)):
+		func = classmethod(func)
+
+	return ClassPropertyDescriptor(func)