-

cool-RR · cool-RR · commit d71453eed37a · 2013-10-05T01:29:09.000+03:00
diff --git a/source_py3/python_toolbox/abc_tools.py b/source_py3/python_toolbox/abc_tools.py
@@ -18,5 +18,5 @@ class AbstractStaticMethod(staticmethod):
     __isabstractmethod__ = True
     
     def __init__(self, function):
-        super(AbstractStaticMethod, self).__init__(function)
+        super().__init__(function)
         function.__isabstractmethod__ = True
diff --git a/source_py3/python_toolbox/caching/cached_type.py b/source_py3/python_toolbox/caching/cached_type.py
@@ -42,7 +42,7 @@ def __init__(self, a, b=2):
     '''
     
     def __new__(mcls, *args, **kwargs):
-        result = super(CachedType, mcls).__new__(mcls, *args, **kwargs)
+        result = super().__new__(mcls, *args, **kwargs)
         result.__cache = {}
         return result
 
@@ -58,5 +58,5 @@ def __call__(cls, *args, **kwargs):
             return cls.__cache[sleek_call_args]
         except KeyError:
             cls.__cache[sleek_call_args] = value = \
-                super(CachedType, cls).__call__(*args, **kwargs)
+                super().__call__(*args, **kwargs)
             return value
diff --git a/source_py3/python_toolbox/context_management/context_manager_type.py b/source_py3/python_toolbox/context_management/context_manager_type.py
@@ -66,7 +66,7 @@ def __new__(mcls, name, bases, namespace):
             namespace['__exit__'] = \
                 ContextManager._ContextManager__exit_using_manage_context
             
-        result_class = super(ContextManagerType, mcls).__new__(
+        result_class = super().__new__(
             mcls,
             name,
             bases,
diff --git a/source_py3/python_toolbox/context_management/context_manager_type_type.py b/source_py3/python_toolbox/context_management/context_manager_type_type.py
@@ -53,12 +53,12 @@ def MyContextManager():
                 '__init__': ContextManager.\
                             _ContextManager__init_lone_manage_context
             }
-            return super(ContextManagerTypeType, cls).__call__(
+            return super().__call__(
                 name,
                 bases,
                 namespace_dict
             )
             
         else:
-            return super(ContextManagerTypeType, cls).__call__(*args)
+            return super().__call__(*args)
         
diff --git a/source_py3/python_toolbox/function_anchoring_type.py b/source_py3/python_toolbox/function_anchoring_type.py
@@ -31,10 +31,7 @@ class FunctionAnchoringType(type):
     Python learns how to pickle non-module-level functions.
     '''
     def __new__(mcls, name, bases, namespace_dict):
-        my_type = super(FunctionAnchoringType, mcls).__new__(mcls,
-                                                             name,
-                                                             bases,
-                                                             namespace_dict)
+        my_type = super().__new__(mcls, name, bases, namespace_dict)
         
         # We want the type's `vars`, but we want them "getted," and not in a
         # `dict`, so we'll get method objects instead of plain functions.
diff --git a/source_py3/python_toolbox/nifty_collections/emitting_weak_key_default_dict.py b/source_py3/python_toolbox/nifty_collections/emitting_weak_key_default_dict.py
@@ -28,7 +28,7 @@ class EmittingWeakKeyDefaultDict(WeakKeyDefaultDict):
     '''
     
     def __init__(self, emitter, *args, **kwargs):
-        super(EmittingWeakKeyDefaultDict, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.emitter = emitter
 
         
@@ -38,15 +38,14 @@ def set_emitter(self, emitter):
 
         
     def __setitem__(self, key, value):
-        result = \
-            super(EmittingWeakKeyDefaultDict, self).__setitem__(key, value)
+        result = super().__setitem__(key, value)
         if self.emitter:
             self.emitter.emit()
         return result
 
     
     def __delitem__(self, key):
-        result = super(EmittingWeakKeyDefaultDict, self).__delitem__(key)
+        result = super().__delitem__(key)
         if self.emitter:
             self.emitter.emit()
         return result
@@ -56,7 +55,7 @@ def pop(self, key, *args):
         """ D.pop(k[,d]) -> v, remove specified key and return the 
         corresponding value. If key is not found, d is returned if given,
         otherwise KeyError is raised """
-        result = super(EmittingWeakKeyDefaultDict, self).pop(key, *args)
+        result = super().pop(key, *args)
         if self.emitter:
             self.emitter.emit()
         return result
@@ -65,15 +64,15 @@ def pop(self, key, *args):
     def popitem(self):
         """ D.popitem() -> (k, v), remove and return some (key, value) 
         pair as a 2-tuple; but raise KeyError if D is empty """
-        result = super(EmittingWeakKeyDefaultDict, self).popitem()
+        result = super().popitem()
         if self.emitter:
             self.emitter.emit()
         return result
 
     
     def clear(self):
         """ D.clear() -> None.  Remove all items from D. """
-        result = super(EmittingWeakKeyDefaultDict, self).clear()
+        result = super().clear()
         if self.emitter:
             self.emitter.emit()
         return result
diff --git a/source_py3/python_toolbox/nifty_collections/weak_key_default_dict.py b/source_py3/python_toolbox/nifty_collections/weak_key_default_dict.py
@@ -68,7 +68,7 @@ def __repr__(self, recurse=set()):
             return "%s(%s, %s)" % (
                 type_name,
                 repr(self.default_factory),
-                super(WeakKeyDefaultDict, self).__repr__()
+                super().__repr__()
             )
         finally:
             recurse.remove(id(self))
diff --git a/source_py3/python_toolbox/persistent/cross_process_persistent.py b/source_py3/python_toolbox/persistent/cross_process_persistent.py
@@ -83,13 +83,13 @@ def __new__(cls, *args, **kwargs):
                 thing._CrossProcessPersistent__skip_setstate = True
                 return thing
             else: # This object does not exist in our library yet; let's add it
-                thing = super(CrossProcessPersistent, cls).__new__(cls)
+                thing = super().__new__(cls)
                 thing._CrossProcessPersistent__uuid = received_uuid
                 library[received_uuid] = thing
                 return thing
                 
         else: # The object is being created
-            thing = super(CrossProcessPersistent, cls).__new__(cls)
+            thing = super().__new__(cls)
             new_uuid = uuid.uuid4()
             thing._CrossProcessPersistent__uuid = new_uuid
             library[new_uuid] = thing
diff --git a/source_py3/python_toolbox/sleek_reffing/cute_sleek_value_dict.py b/source_py3/python_toolbox/sleek_reffing/cute_sleek_value_dict.py
@@ -254,7 +254,7 @@ def __new__(cls, thing, callback, key):
 
     
     def __init__(self, thing, callback, key):
-        super(KeyedSleekRef, self).__init__(thing, callback)
+        super().__init__(thing, callback)
         if self.ref:
             self.ref.key = key
 

Original file line number	Diff line number	Diff line change
`@@ -53,12 +53,12 @@ def MyContextManager():`
`53`	`53`	`'__init__': ContextManager.\`
`54`	`54`	`_ContextManager__init_lone_manage_context`
`55`	`55`	`}`
`56`		`- return super(ContextManagerTypeType, cls).__call__(`
	`56`	`+ return super().__call__(`
`57`	`57`	`name,`
`58`	`58`	`bases,`
`59`	`59`	`namespace_dict`
`60`	`60`	`)`
`61`	`61`
`62`	`62`	`else:`
`63`		`- return super(ContextManagerTypeType, cls).__call__(*args)`
	`63`	`+ return super().__call__(*args)`
`64`	`64`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ def __repr__(self, recurse=set()):`
`68`	`68`	`return "%s(%s, %s)" % (`
`69`	`69`	`type_name,`
`70`	`70`	`repr(self.default_factory),`
`71`		`- super(WeakKeyDefaultDict, self).__repr__()`
	`71`	`+ super().__repr__()`
`72`	`72`	`)`
`73`	`73`	`finally:`
`74`	`74`	`recurse.remove(id(self))`