PyPaf 1.0.0__tar.gz → 1.0.2__tar.gz

{PyPaf-1.0.0/src/PyPaf.egg-info → pypaf-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: PyPaf
-Version: 1.0.0
+Version: 1.0.2
 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.0 → pypaf-1.0.2/src/PyPaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: PyPaf
-Version: 1.0.0
+Version: 1.0.2
 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.0 → pypaf-1.0.2}/src/paf/premises/__init__.py

@@ -79,6 +79,11 @@ class Premises(
         """Returns sub-building number and first thoroughfare or locality"""
         return self._concatenate(('sub_building_name', 'first_thoroughfare_or_locality'))
 
+    @property
+    def sub_and_building_name_but_last_word(self):
+        """Returns sub-building name and but last word of the building name"""
+        return self._concatenate(('sub_building_name', 'building_name_but_last_word'))
+
     @property
     def building_name_but_last_word(self):
         """Returns all but last word of the building name"""
@@ -89,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.0 → pypaf-1.0.2}/src/paf/premises/exception.py

@@ -46,7 +46,12 @@ class ExceptionMixin(BuildingTypeMixin, SplitMixin):
     def is_split_exception(self, attr):
         """Returns if attribute should be split"""
         return (
-            self.__is_exception(self.last_word(attr))
+            (self.__is_exception_i(self.last_word(attr))
+                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_building_type('building_name_last_two_words')
+                )
             )

pypaf-1.0.2/src/paf/premises/extender.py

@@ -0,0 +1,23 @@
+"""Premises Extender Mixin"""
+
+import sys
+import importlib
+
+
+class ExtenderMixin():
+    """Dynamic Premises processing"""
+
+    @property
+    def rule(self):
+        """Returns premises rule class"""
+        rule_num = ''.join(['0' if self.is_empty(k) else '1' for k in self.building_attrs])
+        package_name = getattr(sys.modules[__name__], '__package__', None)
+        module_name = f'rule{rule_num}'
+        module = importlib.import_module(f'{package_name}.{module_name}')
+        class_name = f'Rule{rule_num}'
+        return getattr(module, class_name)
+
+    def extend(self):
+        """Dynamically extends instance with appropriate rule"""
+        base_cls = self.__class__
+        object.__setattr__(self, '__class__', type(base_cls.__name__, (base_cls, self.rule), {}))

{PyPaf-1.0.0 → pypaf-1.0.2}/src/paf/premises/rule110.py

@@ -10,6 +10,11 @@ class Rule110(PremisableMixin):
     def rule_attrs(self):
         """Returns premises list"""
         if self.is_exception('sub_building_name'):
+            if self.is_split_exception('building_name'):
+                return (
+                    'sub_and_building_name_but_last_word',
+                    'name_last_word_and_thoroughfare_or_locality'
+                    )
             return ('sub_name_and_name',)
         if self.is_exception('building_name'):
             return ('sub_building_name', 'name_and_thoroughfare_or_locality')
@@ -24,6 +29,6 @@ class Rule110(PremisableMixin):
     def includes_first_thoroughfare_or_locality(self):
         """Returns if premises includes first thoroughfare or locality"""
         return (
-            not self.is_exception('sub_building_name')
-            and (self.is_exception('building_name') or self.is_split_exception('building_name'))
+            self.is_split_exception('building_name')
+            or (not self.is_exception('sub_building_name') and self.is_exception('building_name'))
             )

{PyPaf-1.0.0 → pypaf-1.0.2}/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.2/src/paf/version.py

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

{PyPaf-1.0.0 → pypaf-1.0.2}/tests/test_rule_3.py

@@ -274,5 +274,160 @@ class TestRule3WithoutSplit(unittest.TestCase):
             )
 
 
+class TestRule3WithoutCharSplit(unittest.TestCase):
+    """Test Address Rule 3 without Character Split Exception"""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up Address instance"""
+        cls.address = paf.Address({
+            'organisation_name': "JOBCENTRE PLUS",
+            'building_name': "ABERDEEN B D C",
+            'thoroughfare_name': "WELLINGTON",
+            'thoroughfare_descriptor': "CIRCLE",
+            'post_town': "ABERDEEN",
+            'postcode': "AB99 8AB"
+            })
+
+    def test_list(self):
+        """Test conversion to an list"""
+        address = [
+            "JOBCENTRE PLUS",
+            "ABERDEEN B D C",
+            "WELLINGTON CIRCLE",
+            "ABERDEEN",
+            "AB99 8AB"
+            ]
+        self.assertEqual(
+            self.address.as_list(), address, "Incorrect Rule 3 w/o char split list format"
+            )
+
+    def test_string(self):
+        """Test conversion to a string"""
+        address = (
+            "JOBCENTRE PLUS, "
+            "ABERDEEN B D C, "
+            "WELLINGTON CIRCLE, "
+            "ABERDEEN. "
+            "AB99 8AB"
+            )
+        self.assertEqual(
+            self.address.as_str(), address, "Incorrect Rule 3 w/o char split string format"
+            )
+
+    def test_tuple(self):
+        """Test conversion to a tuple"""
+        address = (
+            "JOBCENTRE PLUS",
+            "ABERDEEN B D C",
+            "WELLINGTON CIRCLE",
+            "ABERDEEN",
+            "AB99 8AB"
+            )
+        self.assertEqual(
+            self.address.as_tuple(), address, "Incorrect Rule 3 w/o char split tuple format"
+            )
+
+    def test_dict(self):
+        """Test conversion to a dict"""
+        address = {
+            'line_1': "JOBCENTRE PLUS",
+            'line_2': "ABERDEEN B D C",
+            'line_3': "WELLINGTON CIRCLE",
+            'post_town': "ABERDEEN",
+            'postcode': "AB99 8AB"
+            }
+        self.assertEqual(
+            self.address.as_dict(), address, "Incorrect Rule 3 w/o char split dict format"
+            )
+
+    def test_premises(self):
+        """Test premises"""
+        premises = {'premises_name': 'ABERDEEN B D C'}
+        self.assertEqual(
+            self.address.premises(), premises, "Incorrect Rule 3 w/o char split premises"
+            )
+
+
+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.0 → pypaf-1.0.2}/tests/test_rule_6.py

@@ -216,6 +216,76 @@ class TestRule6WithSplitException(unittest.TestCase):
             self.address.premises(), premises, "Incorrect Rule 6 w/ split building premises")
 
 
+class TestRule6WithDoubleException(unittest.TestCase):
+    """Test Address Rule 6 with Double Building Name Exception"""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up Address instance"""
+        cls.address = paf.Address({
+            'sub_building_name': "91",
+            'building_name': "OCEAN APARTMENTS 52-54",
+            'thoroughfare_name': "PARK",
+            'thoroughfare_descriptor': "ROAD",
+            'post_town': "ABERDEEN",
+            'postcode': "AB24 5RZ"
+            })
+
+    def test_list(self):
+        """Test conversion to an list"""
+        address = [
+            "91 OCEAN APARTMENTS",
+            "52-54 PARK ROAD",
+            "ABERDEEN",
+            "AB24 5RZ"
+            ]
+        self.assertEqual(
+            self.address.as_list(), address, "Incorrect Rule 6 w/ double building list format"
+            )
+
+    def test_string(self):
+        """Test conversion to a string"""
+        address = "91 OCEAN APARTMENTS, 52-54 PARK ROAD, ABERDEEN. AB24 5RZ"
+        self.assertEqual(
+            self.address.as_str(), address, "Incorrect Rule 6 w/ double building string format"
+            )
+
+    def test_tuple(self):
+        """Test conversion to a tuple"""
+        address = (
+            "91 OCEAN APARTMENTS",
+            "52-54 PARK ROAD",
+            "ABERDEEN",
+            "AB24 5RZ"
+            )
+        self.assertEqual(
+            self.address.as_tuple(), address, "Incorrect Rule 6 w/ double building tuple format"
+            )
+
+    def test_dict(self):
+        """Test conversion to a dict"""
+        address = {
+            'line_1': "91 OCEAN APARTMENTS",
+            'line_2': "52-54 PARK ROAD",
+            'post_town': "ABERDEEN",
+            'postcode': "AB24 5RZ"
+            }
+        self.assertEqual(
+            self.address.as_dict(), address, "Incorrect Rule 6 w/ double building dict format"
+            )
+
+    def test_premises(self):
+        """Test premises"""
+        premises = {
+            'premises_number': 52,
+            'premises_suffix': '-54',
+            'premises_name': 'OCEAN APARTMENTS',
+            'sub_premises_number': 91
+            }
+        self.assertEqual(
+            self.address.premises(), premises, "Incorrect Rule 6 w/ split building premises")
+
+
 class TestRule6(unittest.TestCase):
     """Test Address Rule 6 without Exception"""
 

PyPaf-1.0.0/src/paf/premises/extender.py

@@ -1,26 +0,0 @@
-"""Premises Extender Mixin"""
-
-import sys
-from .rule000 import Rule000  # pylint: disable=unused-import # noqa: F401
-from .rule001 import Rule001  # pylint: disable=unused-import # noqa: F401
-from .rule010 import Rule010  # pylint: disable=unused-import # noqa: F401
-from .rule100 import Rule100  # pylint: disable=unused-import # noqa: F401
-from .rule011 import Rule011  # pylint: disable=unused-import # noqa: F401
-from .rule101 import Rule101  # pylint: disable=unused-import # noqa: F401
-from .rule110 import Rule110  # pylint: disable=unused-import # noqa: F401
-from .rule111 import Rule111  # pylint: disable=unused-import # noqa: F401
-
-
-class ExtenderMixin():
-    """Dynamic Premises processing"""
-
-    @property
-    def rule(self):
-        """Returns premises rule class"""
-        rule = ''.join(['0' if self.is_empty(k) else '1' for k in self.building_attrs])
-        return getattr(sys.modules[__name__], 'Rule' + rule)
-
-    def extend(self):
-        """Dynamically extends instance with appropriate rule"""
-        base_cls = self.__class__
-        object.__setattr__(self, '__class__', type(base_cls.__name__, (base_cls, self.rule), {}))

PyPaf-1.0.0/src/paf/version.py

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