pythonthings
diff --git a/‎source_py2/python_toolbox/dict_tools.py‎
Lines changed: 17 additions & 4 deletions b/‎source_py2/python_toolbox/dict_tools.py‎
Lines changed: 17 additions & 4 deletions
diff --git a/‎source_py2/python_toolbox/monkeypatching_tools.py‎
Lines changed: 59 additions & 5 deletions b/‎source_py2/python_toolbox/monkeypatching_tools.py‎
Lines changed: 59 additions & 5 deletions
@@ -9,7 +9,7 @@
 from python_toolbox import comparison_tools
 
 
-def filter_items(d, condition, force_dict_type=None):
+def filter_items(d, condition, double=False, force_dict_type=None):
     '''
     Get new dict with items from `d` that satisfy the `condition` functions.
     
@@ -18,16 +18,29 @@ def filter_items(d, condition, force_dict_type=None):
     The newly created dict will be of the same class as `d`, e.g. if you passed
     an ordered dict as `d`, the result will be an ordered dict, using the
     correct order.
+    
+    Specify `double=True` to get a tuple of two dicts instead of one. The
+    second dict will have all the rejected items.
     '''
     # todo future: possibly shallow-copy `d` to allow for dict classes that
     # have more state, (like default factory.)
     if force_dict_type is not None:
         dict_type = force_dict_type
     else:
         dict_type = type(d) if (type(d).__name__ != 'dictproxy') else dict
-    return dict_type(
-        (key, value) for (key, value) in d.iteritems() if condition(key, value)
-    )
+        
+    if double:
+        return map(
+            dict_type,
+            cute_iter_tools.double_filter(
+                lambda (key, value): condition(key, value),
+                d.iteritems()
+            )
+        )
+    else:
+        return dict_type(
+                (key, value) for (key, value) in d.iteritems() if condition(key, value)
+        )
 
 
 def get_list(d, iterable):
 
@@ -4,15 +4,20 @@
 '''Tools for monkeypatching.'''
 
 import sys
+import collections
+import inspect
 import types
 
+from python_toolbox.third_party import funcsigs
+
 from python_toolbox import misc_tools
+from python_toolbox import dict_tools
 from python_toolbox import decorator_tools
 from python_toolbox import caching
 
 
 @decorator_tools.helpful_decorator_builder
-def monkeypatch_method(monkeypatchee, name=None):
+def monkeypatch_method(monkeypatchee, name=None, override_if_exists=True):
     '''
     Monkeypatch a method into a class (or an object).
     
@@ -49,8 +54,8 @@ def decorator(function):
             new_method = types.MethodType(function, None, monkeypatchee) if \
                 monkeypatchee_is_a_class else types.MethodType(function,
                                          monkeypatchee, class_of_monkeypatchee)
-            setattr(monkeypatchee, name_, new_method)
-            return function
+            setattr_value = new_method
+            return_value = function
         else:
             # `function` is probably some kind of descriptor.
             if not monkeypatchee_is_a_class:
@@ -77,8 +82,57 @@ def decorator(function):
                     )
                 #                                                             #
                 ### Finished getting name of descriptor. ######################
-            setattr(monkeypatchee, name_, function)
-            return function
+            setattr_value = return_value = function
+
+        if override_if_exists or not hasattr(monkeypatchee, name_):
+            setattr(monkeypatchee, name_, setattr_value)
+        return return_value
 
     return decorator
 
+
+def change_defaults(function=None, new_defaults={}):
+    '''
+    Change default values of a function.
+    
+    Include the new defaults in a dict `new_defaults`, with each key being a
+    keyword name and each value being the new default value.
+    
+    Note: This changes the actual function!
+    
+    Can be used both as a straight function and as a decorater to a function to
+    be changed.
+    '''
+    def change_defaults_(function_, new_defaults_):
+        signature = funcsigs.Signature.from_function(function_)
+        defaults = list(function_.__defaults__ or ())
+        non_keyword_only_defaultful_parameters = defaultful_parameters = \
+            dict_tools.filter_items(
+            signature.parameters,
+            lambda name, parameter: parameter.default != funcsigs._empty,
+            force_dict_type=collections.OrderedDict
+        )
+        
+        for i, parameter_name in \
+                             enumerate(non_keyword_only_defaultful_parameters):
+            if parameter_name in new_defaults_:
+                defaults[i] = new_defaults_[parameter_name]
+                
+        function_.__defaults__ = tuple(defaults)
+        
+        return function_
+
+    if not callable(function):
+        # Decorator mode:
+        if function is None:
+            actual_new_defaults = new_defaults
+        else:
+            actual_new_defaults = function
+        return lambda function_: change_defaults_(function_,
+                                                  actual_new_defaults)
+    else:
+        # Normal usage mode:
+        return change_defaults_(function, new_defaults)
+        
+        
+