Metadata should not be mutable

Author: daviddrysdale

python/buildmetadatafromxml.py

@@ -156,6 +156,7 @@ def __init__(self, owning_xterr, xtag, national_prefix,
             self.io = None
         else:
             self.o = NumberFormat()
+            self.o._mutable = True
             # Find the REQUIRED attribute
             self.o.pattern = xtag.attrib['pattern']
             # Find the IMPLIED attribute(s)
@@ -207,6 +208,7 @@ def __init__(self, owning_xterr, xtag, national_prefix,
             # If the intlFormat is set to "NA" the intlFormat should be ignored.
             self.io = NumberFormat(pattern=self.o.pattern,
                                    leading_digits_pattern=self.o.leading_digits_pattern)
+            self.io._mutable = True
 
             intl_format = _get_unique_child_value(xtag, "intlFormat")
             if intl_format is None:
@@ -231,6 +233,7 @@ class XPhoneNumberDesc(UnicodeMixin):
     def __init__(self, xtag,
                  template=None, fill_na=True):
         self.o = PhoneNumberDesc()
+        self.o._mutable = True
         self.o.national_number_pattern = None
         self.o.possible_number_pattern = None
         self.o.example_number = None
@@ -266,6 +269,7 @@ def __init__(self, xterritory):
         # Retrieve the REQUIRED attributes
         id = xterritory.attrib['id']
         self.o = PhoneMetadata(id, register=False)
+        self.o._mutable = True
         self.o.country_code = int(xterritory.attrib['countryCode'])
         # Retrieve the IMPLIED attributes
         self.o.international_prefix = xterritory.get('internationalPrefix', None)

python/phonenumbers/phonemetadata.py

@@ -23,13 +23,16 @@
 
 class NumberFormat(UnicodeMixin):
     """Representation of way that a phone number can be formatted for output"""
+    _mutable = False
+
     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
@@ -98,6 +101,7 @@ 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."""
@@ -139,14 +143,28 @@ def __unicode__(self):
         result += u")"
         return result
 
+    def __setattr__(self, name, value):  # pragma no cover
+        if self._mutable or name == "_mutable":
+            super(NumberFormat, self).__setattr__(name, value)
+        else:
+            raise TypeError("Can't modify immutable instance")
+
+    def __delattr__(self, name):  # pragma no cover
+        if self._mutable:
+            super(NumberFormat, self).__delattr__(name)
+        else:
+            raise TypeError("Can't modify immutable instance")
+
 
 class PhoneNumberDesc(UnicodeMixin):
     """Class representing the description of a set of phone numbers."""
+    _mutable = False
 
     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.
@@ -164,6 +182,7 @@ 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."""
@@ -201,13 +220,26 @@ def __unicode__(self):
         result += u")"
         return result
 
+    def __setattr__(self, name, value):  # pragma no cover
+        if self._mutable or name == "_mutable":
+            super(PhoneNumberDesc, self).__setattr__(name, value)
+        else:
+            raise TypeError("Can't modify immutable instance")
+
+    def __delattr__(self, name):  # pragma no cover
+        if self._mutable:
+            super(PhoneNumberDesc, self).__delattr__(name)
+        else:
+            raise TypeError("Can't modify immutable instance")
+
 
 class PhoneMetadata(UnicodeMixin):
     """Class representing metadata for international telephone numbers for a region.
 
     This class is hand created based on phonemetadata.proto. Please refer to that file
     for detailed descriptions of the meaning of each field.
     """
+    _mutable = False
     region_metadata = {}  # ISO 3166-1 alpha 2 => PhoneMetadata
     # A mapping from a country calling code for a non-geographical entity to
     # the PhoneMetadata for that country calling code. Examples of the country
@@ -250,6 +282,8 @@ 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
@@ -419,6 +453,7 @@ 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):
@@ -475,3 +510,15 @@ def __unicode__(self):
             result += ",\n    leading_zero_possible=True"
         result += u")"
         return result
+
+    def __setattr__(self, name, value):  # pragma no cover
+        if self._mutable or name == "_mutable":
+            super(PhoneMetadata, self).__setattr__(name, value)
+        else:
+            raise TypeError("Can't modify immutable instance")
+
+    def __delattr__(self, name):  # pragma no cover
+        if self._mutable:
+            super(PhoneMetadata, self).__delattr__(name)
+        else:
+            raise TypeError("Can't modify immutable instance")

python/phonenumbers/phonenumberutil.py

@@ -750,6 +750,7 @@ def format_by_pattern(numobj, number_format, user_defined_formats):
         formatted_number = nsn
     else:
         num_format_copy = NumberFormat()
+        num_format_copy._mutable = True
         # Before we do a replacement of the national prefix pattern $NP with
         # the national prefix, we need to copy the rule so that subsequent
         # replacements for different numbers have the appropriate national
@@ -1088,6 +1089,7 @@ def _format_original_allow_mods(numobj, region_calling_from):
             return national_format
         # Otherwise, we need to remove the national prefix from our output.
         new_format_rule = NumberFormat()
+        new_format_rule._mutable = True
         new_format_rule.merge_from(format_rule)
         new_format_rule.national_prefix_formatting_rule = None
         return format_by_pattern(numobj, PhoneNumberFormat.NATIONAL, [new_format_rule])
@@ -1196,6 +1198,7 @@ def format_out_of_country_keeping_alpha_chars(numobj, region_calling_from):
             # If no pattern above is matched, we format the original input
             return raw_input
         new_format = NumberFormat()
+        new_format._mutable = True
         new_format.merge_from(formatting_pattern)
         # The first group is the first group of digits that the user
         # wrote together.

python/tests/phonenumberutiltest.py

@@ -693,6 +693,7 @@ def testFormatNumberForMobileDialing(self):
 
     def testFormatByPattern(self):
         newNumFormat = NumberFormat(pattern="(\\d{3})(\\d{3})(\\d{4})", format="(\\1) \\2-\\3")
+        newNumFormat._mutable = True
         newNumberFormats = [newNumFormat]
 
         self.assertEqual("(650) 253-0000", phonenumbers.format_by_pattern(US_NUMBER, PhoneNumberFormat.NATIONAL,
@@ -1284,7 +1285,9 @@ def testExtractPossibleNumber(self):
 
     def testMaybeStripNationalPrefix(self):
         metadata = PhoneMetadata(id="Test", national_prefix_for_parsing="34", register=False)
+        metadata._mutable = True
         metadata.general_desc = PhoneNumberDesc(national_number_pattern="\\d{4,8}")
+        metadata.general_desc._mutable = True
         numberToStrip = "34356778"
         strippedNumber = "356778"
         cc, numberToStrip, rc = phonenumberutil._maybe_strip_national_prefix_carrier_code(numberToStrip, metadata)
@@ -2166,10 +2169,13 @@ def testIsAlphaNumber(self):
     def testMetadataEquality(self):
         # Python version extra tests for equality against other types
         desc1 = PhoneNumberDesc(national_number_pattern="\\d{4,8}")
+        desc1._mutable = True
         desc2 = PhoneNumberDesc(national_number_pattern="\\d{4,8}")
+        desc2._mutable = True
         desc3 = PhoneNumberDesc(national_number_pattern="\\d{4,7}",
                                 possible_number_pattern="\\d{7}",
                                 example_number="1234567")
+        desc3._mutable = True
         self.assertNotEqual(desc1, None)
         self.assertNotEqual(desc1, "")
         self.assertEqual(desc1, desc2)
@@ -2181,10 +2187,13 @@ def testMetadataEquality(self):
                          r"possible_number_pattern='\\d{7}', example_number='1234567')",
                          str(desc3))
         nf1 = NumberFormat(pattern=r'\d{3}', format=r'\1', leading_digits_pattern=['1'])
+        nf1._mutable = True
         nf2 = NumberFormat(pattern=r'\d{3}', format=r'\1', leading_digits_pattern=['1'])
+        nf2._mutable = True
         nf3 = NumberFormat(pattern=r'\d{3}', format=r'\1', leading_digits_pattern=['2'],
                            national_prefix_formatting_rule='$NP',
                            domestic_carrier_code_formatting_rule='$NP')
+        nf3._mutable = True
         self.assertEqual(nf1, nf2)
         self.assertNotEqual(nf1, nf3)
         self.assertNotEqual(nf1, None)
@@ -2196,8 +2205,11 @@ def testMetadataEquality(self):
         self.assertNotEqual(nf1, nf3)
 
         metadata1 = PhoneMetadata("XY", preferred_international_prefix=u'9123', register=False)
+        metadata1._mutable = True
         metadata2 = PhoneMetadata("XY", preferred_international_prefix=u'9123', register=False)
+        metadata2._mutable = True
         metadata3 = PhoneMetadata("XY", preferred_international_prefix=u'9100', register=False)
+        metadata3._mutable = True
         self.assertEqual(metadata1, metadata2)
         self.assertNotEqual(metadata1, metadata3)
         self.assertTrue(metadata1 != metadata3)
@@ -2341,17 +2353,21 @@ def testCoverage(self):
         # Temporarily insert invalid example number
         metadata800 = PhoneMetadata.country_code_metadata[800]
         saved_example = metadata800.general_desc.example_number
+        metadata800.general_desc._mutable = True
         metadata800.general_desc.example_number = '01'
         self.assertTrue(phonenumbers.example_number_for_non_geo_entity(800) is None)
         metadata800.general_desc.example_number = saved_example
+        metadata800.general_desc._mutable = False
 
         self.assertFalse(phonenumbers.phonenumberutil._raw_input_contains_national_prefix("077", "0", "JP"))
 
         # Temporarily change formatting rule
         metadataGB = PhoneMetadata.region_metadata["GB"]
         saved_rule = metadataGB.number_format[0].national_prefix_formatting_rule
+        metadataGB.number_format[0]._mutable = True
         metadataGB.number_format[0].national_prefix_formatting_rule = u'(\\1)'
         numberWithoutNationalPrefixGB = phonenumbers.parse("2087654321", "GB", keep_raw_input=True)
         self.assertEqual("(20) 8765 4321",
                          phonenumbers.format_in_original_format(numberWithoutNationalPrefixGB, "GB"))
         metadataGB.number_format[0].national_prefix_formatting_rule = saved_rule
+        metadataGB.number_format[0]._mutable = False