PyPaf 1.0.1__tar.gz → 1.0.3__tar.gz

{pypaf-1.0.1/src/PyPaf.egg-info → pypaf-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyPaf
-Version: 1.0.1
+Version: 1.0.3
 Summary: Formats the elements of a Royal Mail Postcode Address File entry
 Author-email: John Bard <johnbard@globalnet.co.uk>
 License: MIT

{pypaf-1.0.1 → pypaf-1.0.3/src/PyPaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyPaf
-Version: 1.0.1
+Version: 1.0.3
 Summary: Formats the elements of a Royal Mail Postcode Address File entry
 Author-email: John Bard <johnbard@globalnet.co.uk>
 License: MIT

{pypaf-1.0.1 → pypaf-1.0.3}/src/paf/premises/__init__.py

@@ -94,6 +94,11 @@ class Premises(
         """Returns last word of the building name"""
         return self.last_word('building_name')
 
+    @property
+    def building_name_last_two_words(self):
+        """Returns last two words of the building name"""
+        return self.last_two_words('building_name')
+
     @property
     def sub_building_name_but_last_word(self):
         """Returns all but last word of the sub-building name"""

{pypaf-1.0.1 → pypaf-1.0.3}/src/paf/premises/building_type.py

@@ -15,14 +15,20 @@ class BuildingTypeMixin(SplitMixin):
             "MAISONETTE", "MAISONETTES", "REAR OF",
             "SHOP", "SHOPS", "STALL", "STALLS",
             "SUITE", "SUITES", "UNIT", "UNITS",
-            "PO BOX"
+            "FLAT", "FLATS", "PO BOX"
             )
 
     @classmethod
     @property
     def known_sub_building_types(cls):
         """Returns known sub-building types"""
-        return cls.known_building_types + ("FLAT", "FLATS")
+        return cls.known_building_types
+
+    @classmethod
+    @property
+    def known_split_building_types(cls):
+        """Returns known split building types"""
+        return ("UNIT",)
 
     def is_known_building_type(self, attr='building_name'):
         """Returns if attribute starts with a known type"""
@@ -31,3 +37,7 @@ class BuildingTypeMixin(SplitMixin):
     def is_known_sub_building_type(self, attr='sub_building_name'):
         """Returns if attribute starts with a known type"""
         return self.but_last_word(attr) in self.known_sub_building_types
+
+    def is_known_split_building_type(self, attr='building_name'):
+        """Returns if attribute starts with a known type"""
+        return self.but_last_word(attr) in self.known_split_building_types

{pypaf-1.0.1 → pypaf-1.0.3}/src/paf/premises/exception.py

@@ -50,4 +50,8 @@ class ExceptionMixin(BuildingTypeMixin, SplitMixin):
                 or self.__is_exception_ii(self.last_word(attr)))
             and not self.last_word(attr).isdigit()
             and not self.__is_exception_iv(attr)
+            and (
+                attr != 'building_name'
+                or not self.is_known_split_building_type('building_name_last_two_words')
+                )
             )

{pypaf-1.0.1 → pypaf-1.0.3}/src/paf/premises/split.py

@@ -24,6 +24,15 @@ class SplitMixin():
         except ValueError:
             return string
 
+    @classmethod
+    def __last_two_words(cls, string):
+        """Returns last two words of the string"""
+        try:
+            *_, penultimate, last = string.split()
+            return ' '.join([penultimate, last])
+        except ValueError:
+            return cls.__last_word(string)
+
     @classmethod
     def __leading_digits(cls, string):
         """Returns the leading digits from the string"""
@@ -49,6 +58,10 @@ class SplitMixin():
         """Returns last word of the attribute"""
         return self.__last_word(str(getattr(self, attr, '')))
 
+    def last_two_words(self, attr):
+        """Returns last two word of the attribute"""
+        return self.__last_two_words(str(getattr(self, attr, '')))
+
     def leading_digits(self, attr):
         """Returns the leading digits from the attribute"""
         return self.__leading_digits(str(getattr(self, attr, '')))

pypaf-1.0.3/src/paf/version.py

@@ -0,0 +1,3 @@
+"""Version"""
+
+__version__ = '1.0.3'

{pypaf-1.0.1 → pypaf-1.0.3}/tests/test_rule_3.py

@@ -349,5 +349,85 @@ class TestRule3WithoutCharSplit(unittest.TestCase):
             )
 
 
+class TestRule3WithoutTypeSplit(unittest.TestCase):
+    """Test Address Rule 3 without Building Type Split Exception"""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up Address instance"""
+        cls.address = paf.Address({
+            'organisation_name': "P S G MARINE & LOGISTICS LTD",
+            'building_name': "PORT SERVICES HOUSE UNIT 14A",
+            'thoroughfare_name': "PETERSEAT",
+            'thoroughfare_descriptor': "DRIVE",
+            'dependent_locality': "ALTENS INDUSTRIAL ESTATE",
+            'post_town': "ABERDEEN",
+            'postcode': "AB12 3HT"
+            })
+
+    def test_list(self):
+        """Test conversion to an list"""
+        address = [
+            "P S G MARINE & LOGISTICS LTD",
+            "PORT SERVICES HOUSE UNIT 14A",
+            "PETERSEAT DRIVE",
+            "ALTENS INDUSTRIAL ESTATE",
+            "ABERDEEN",
+            "AB12 3HT"
+            ]
+        self.assertEqual(
+            self.address.as_list(), address, "Incorrect Rule 3 w/o type split list format"
+            )
+
+    def test_string(self):
+        """Test conversion to a string"""
+        address = (
+            "P S G MARINE & LOGISTICS LTD, "
+            "PORT SERVICES HOUSE UNIT 14A, "
+            "PETERSEAT DRIVE, "
+            "ALTENS INDUSTRIAL ESTATE, "
+            "ABERDEEN. "
+            "AB12 3HT"
+            )
+        self.assertEqual(
+            self.address.as_str(), address, "Incorrect Rule 3 w/o type split string format"
+            )
+
+    def test_tuple(self):
+        """Test conversion to a tuple"""
+        address = (
+            "P S G MARINE & LOGISTICS LTD",
+            "PORT SERVICES HOUSE UNIT 14A",
+            "PETERSEAT DRIVE",
+            "ALTENS INDUSTRIAL ESTATE",
+            "ABERDEEN",
+            "AB12 3HT"
+            )
+        self.assertEqual(
+            self.address.as_tuple(), address, "Incorrect Rule 3 w/o type split tuple format"
+            )
+
+    def test_dict(self):
+        """Test conversion to a dict"""
+        address = {
+            'line_1': "P S G MARINE & LOGISTICS LTD",
+            'line_2': "PORT SERVICES HOUSE UNIT 14A",
+            'line_3': "PETERSEAT DRIVE",
+            'line_4': "ALTENS INDUSTRIAL ESTATE",
+            'post_town': "ABERDEEN",
+            'postcode': "AB12 3HT"
+            }
+        self.assertEqual(
+            self.address.as_dict(), address, "Incorrect Rule 3 w/o type split dict format"
+            )
+
+    def test_premises(self):
+        """Test premises"""
+        premises = {'premises_name': 'PORT SERVICES HOUSE UNIT 14A'}
+        self.assertEqual(
+            self.address.premises(), premises, "Incorrect Rule 3 w/o type split premises"
+            )
+
+
 if __name__ == '__main__':
     unittest.main()

{pypaf-1.0.1 → pypaf-1.0.3}/tests/test_rule_6.py

@@ -286,6 +286,91 @@ class TestRule6WithDoubleException(unittest.TestCase):
             self.address.premises(), premises, "Incorrect Rule 6 w/ split building premises")
 
 
+class TestRule6WithBuilding(unittest.TestCase):
+    """Test Address Rule 6 with Building Non-Exception"""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up Address instance"""
+        cls.address = paf.Address({
+            'sub_building_name': "FLAT 1",
+            'building_name': "SUNLIFE BUILDING 1A",
+            'thoroughfare_name': "SOUTH VIEW",
+            'thoroughfare_descriptor': "PLACE",
+            'dependent_locality': "MIDSOMER NORTON",
+            'post_town': "RADSTOCK",
+            'postcode': "BA3 2AX"
+            })
+
+    def test_list(self):
+        """Test conversion to an list"""
+        address = [
+            "FLAT 1",
+            "SUNLIFE BUILDING",
+            "1A SOUTH VIEW PLACE",
+            "MIDSOMER NORTON",
+            "RADSTOCK",
+            "BA3 2AX"
+            ]
+        self.assertEqual(
+            self.address.as_list(), address, "Incorrect Rule 6 w/ building non list format"
+            )
+
+    def test_string(self):
+        """Test conversion to a string"""
+        address = (
+            "FLAT 1, "
+            "SUNLIFE BUILDING, "
+            "1A SOUTH VIEW PLACE, "
+            "MIDSOMER NORTON, "
+            "RADSTOCK. "
+            "BA3 2AX"
+            )
+        self.assertEqual(
+            self.address.as_str(), address, "Incorrect Rule 6 w/ building non string format"
+            )
+
+    def test_tuple(self):
+        """Test conversion to a tuple"""
+        address = (
+            "FLAT 1",
+            "SUNLIFE BUILDING",
+            "1A SOUTH VIEW PLACE",
+            "MIDSOMER NORTON",
+            "RADSTOCK",
+            "BA3 2AX"
+            )
+        self.assertEqual(
+            self.address.as_tuple(), address, "Incorrect Rule 6 w/ building non tuple format"
+            )
+
+    def test_dict(self):
+        """Test conversion to a dict"""
+        address = {
+            'line_1': "FLAT 1",
+            'line_2': "SUNLIFE BUILDING",
+            'line_3': "1A SOUTH VIEW PLACE",
+            'line_4': "MIDSOMER NORTON",
+            'post_town': "RADSTOCK",
+            'postcode': "BA3 2AX"
+            }
+        self.assertEqual(
+            self.address.as_dict(), address, "Incorrect Rule 6 w/ building non dict format"
+            )
+
+    def test_premises(self):
+        """Test premises"""
+        premises = {
+            'premises_number': 1,
+            'premises_suffix': 'A',
+            'premises_name': 'SUNLIFE BUILDING',
+            'sub_premises_type': 'FLAT',
+            'sub_premises_number': 1
+            }
+        self.assertEqual(
+            self.address.premises(), premises, "Incorrect Rule 6 w/ building non premises")
+
+
 class TestRule6(unittest.TestCase):
     """Test Address Rule 6 without Exception"""
 

pypaf-1.0.1/src/paf/version.py

@@ -1,3 +0,0 @@
-"""Version"""
-
-__version__ = '1.0.1'