Add mutating_method decorator

Author: daviddrysdale

python/phonenumbers/phonemetadata.py

@@ -16,21 +16,21 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from .util import UnicodeMixin, ImmutableMixin
+from .util import UnicodeMixin, ImmutableMixin, mutating_method
 
 REGION_CODE_FOR_NON_GEO_ENTITY = u"001"
 
 
 class NumberFormat(UnicodeMixin, ImmutableMixin):
     """Representation of way that a phone number can be formatted for output"""
+    @mutating_method
     def __init__(self,
                  pattern=None,
                  format=None,
                  leading_digits_pattern=None,
                  national_prefix_formatting_rule=None,
                  national_prefix_optional_when_formatting=False,
                  domestic_carrier_code_formatting_rule=None):
-        self._mutable = True
         # pattern is a regex that is used to match the national (significant)
         # number. For example, the pattern "(20)(\d{4})(\d{4})" will match
         # number "2070313000", which is the national (significant) number for
@@ -99,7 +99,6 @@ def __init__(self,
         # formatted when format_with_carrier_code is called, if carrier codes
         # are used for a certain country.
         self.domestic_carrier_code_formatting_rule = domestic_carrier_code_formatting_rule  # None or Unicode string
-        self._mutable = False
 
     def merge_from(self, other):
         """Merge information from another NumberFormat object into this one."""
@@ -144,11 +143,11 @@ def __unicode__(self):
 
 class PhoneNumberDesc(UnicodeMixin, ImmutableMixin):
     """Class representing the description of a set of phone numbers."""
+    @mutating_method
     def __init__(self,
                  national_number_pattern=None,
                  possible_number_pattern=None,
                  example_number=None):
-        self._mutable = True
         # The national_number_pattern is the pattern that a valid national
         # significant number would match. This specifies information such as
         # its total length and leading digits.
@@ -166,7 +165,6 @@ def __init__(self,
         # An example national significant number for the specific type. It
         # should not contain any formatting information.
         self.example_number = example_number  # None or Unicode string
-        self._mutable = False
 
     def merge_from(self, other):
         """Merge information from another PhoneNumberDesc object into this one."""
@@ -225,6 +223,7 @@ def metadata_for_region_or_calling_code(kls, country_calling_code, region_code):
         else:
             return kls.region_metadata.get(region_code, None)
 
+    @mutating_method
     def __init__(self,
                  id,
                  general_desc=None,
@@ -253,8 +252,6 @@ def __init__(self,
                  leading_digits=None,
                  leading_zero_possible=False,
                  register=True):
-        self._mutable = True
-
         # The general_desc contains information which is a superset of
         # descriptions for all types of phone numbers. If any element is
         # missing in the description of a specific type of number, the element
@@ -424,7 +421,6 @@ def __init__(self,
                     raise Exception("Duplicate PhoneMetadata for %s (from %s:%s)" % (id, self.id, self.country_code))
             else:
                 kls_map[id] = self
-        self._mutable = False
 
     def __eq__(self, other):
         if not isinstance(other, PhoneMetadata):

python/phonenumbers/util.py

@@ -13,14 +13,27 @@ class ImmutableMixin(object):
     """Mixin class to make objects of subclasses immutable"""
     _mutable = False
 
-    def __setattr__(self, name, value):  # pragma no cover
+    def __setattr__(self, name, value):
         if self._mutable or name == "_mutable":
             object.__setattr__(self, name, value)
         else:
             raise TypeError("Can't modify immutable instance")
 
-    def __delattr__(self, name):  # pragma no cover
+    def __delattr__(self, name):
         if self._mutable:
             object.__delattr__(self, name)
         else:
             raise TypeError("Can't modify immutable instance")
+
+
+def mutating_method(func):
+    """Decorator for methods that are allowed to modify immutable objects"""
+    def wrapper(self, *__args, **__kwargs):
+        old_mutable = self._mutable
+        self._mutable = True
+        try:
+            # Call the wrapped function
+            return func(self, *__args, **__kwargs)
+        finally:
+            self._mutable = old_mutable
+    return wrapper