PyPaf 0.8.0__tar.gz → 1.0.1__tar.gz

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

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

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

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

{pypaf-0.8.0 → pypaf-1.0.1}/src/PyPaf.egg-info/SOURCES.txt

@@ -21,7 +21,6 @@ src/paf/premises/exception.py
 src/paf/premises/extender.py
 src/paf/premises/lineable.py
 src/paf/premises/premisable.py
-src/paf/premises/premises.py
 src/paf/premises/rule000.py
 src/paf/premises/rule001.py
 src/paf/premises/rule010.py

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/address.py

@@ -1,12 +1,13 @@
 """PAF Address"""
 
-# Tried using dataclasses.dataclass(frozen=True) decorator for immutablity but did not work"""
+# Tried dataclasses.dataclass(frozen=True) for immutablity but did not work"""
 from .initiator import attribute_init
 from .attribute import AttributeMixin
 from .immutable import ImmutableMixin
 from .lineable import LineableMixin
 from .thoroughfare_locality import ThoroughfareLocalityMixin
-from .premises.premises import Premises
+from .premises import Premises
+
 
 class Address(ImmutableMixin, AttributeMixin, ThoroughfareLocalityMixin, LineableMixin):
     """Main PAF Address class"""

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/attribute.py

@@ -1,5 +1,6 @@
 """Attribute Mixin"""
 
+
 class AttributeMixin():
     """Address elements and derived properties"""
 
@@ -9,8 +10,8 @@ class AttributeMixin():
         """Returns Paf premises elements"""
         return (
             'organisation_name', 'department_name',
-                'sub_building_name', 'building_name', 'building_number',
-                'po_box_number'
+            'sub_building_name', 'building_name', 'building_number',
+            'po_box_number'
             )
 
     @classmethod
@@ -29,13 +30,13 @@ class AttributeMixin():
     @property
     def attrs(cls):
         """Returns all Paf address elements"""
-        return(
+        return (
             cls.premises_attrs
-                + cls.dependent_thoroughfare_attrs
-                + cls.thoroughfare_attrs
-                + cls.locality_attrs
-                + cls.post_attrs
-                + cls.other_attrs
+            + cls.dependent_thoroughfare_attrs
+            + cls.thoroughfare_attrs
+            + cls.locality_attrs
+            + cls.post_attrs
+            + cls.other_attrs
             )
 
     def is_empty(self, attr):

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/immutable.py

@@ -2,6 +2,7 @@
 
 from dataclasses import FrozenInstanceError
 
+
 class ImmutableMixin():
     """Prevent manipulation of object attributes"""
 

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/initiator.py

@@ -2,6 +2,7 @@
 
 import functools
 
+
 def attribute_init(func):
     """Decorator to initiate an object based on a list of attributes"""
 

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/lineable.py

@@ -2,6 +2,7 @@
 
 from itertools import chain
 
+
 class LineableMixin():
     """Converts Paf address elements into list of address lines"""
 

pypaf-0.8.0/src/paf/premises/premises.py → pypaf-1.0.1/src/paf/premises/__init__.py

@@ -8,14 +8,15 @@ from .extender import ExtenderMixin
 from .lineable import LineableMixin
 from .split import SplitMixin
 
+
 class Premises(
-    ImmutableMixin, ExtenderMixin, AttributeMixin,
+        ImmutableMixin, ExtenderMixin, AttributeMixin,
         ThoroughfareLocalityMixin, LineableMixin, SplitMixin
-    ):
+        ):
     """PAF Address Premises class"""
 
     @attribute_init
-    def __init__(self, *args, **kwargs): # pylint: disable=unused-argument
+    def __init__(self, *args, **kwargs):  # pylint: disable=unused-argument
         """Initialise Premises elements"""
         self.extend()
 
@@ -34,7 +35,7 @@ class Premises(
 
     def __call__(self):
         """Return Premises as dictionary"""
-        return self.as_premisable() # pylint: disable=no-member
+        return self.as_premisable()  # pylint: disable=no-member
 
     @property
     def building_number_and_sub_building_name(self):
@@ -48,16 +49,17 @@ class Premises(
 
     @property
     def name_last_word_and_thoroughfare_or_locality(self):
-        """Returns last word of building name and first thoroughfare or locality"""
+        """Returns last word of building name and first thoroughfare"""
         return self._concatenate(('building_name_last_word', 'first_thoroughfare_or_locality'))
 
     @property
     def number_and_thoroughfare_or_locality(self):
         """Returns building number and first thoroughfare or locality"""
         return self._concatenate(('building_number', 'first_thoroughfare_or_locality'))
+
     @property
     def number_sub_name_and_thoroughfare_or_locality(self):
-        """Returns building number, sub-building name and first thoroughfare or locality"""
+        """Returns building number, sub-building name and first thoroughfare"""
         return self._concatenate(
             ('building_number_and_sub_building_name', 'first_thoroughfare_or_locality')
             )
@@ -69,7 +71,7 @@ class Premises(
 
     @property
     def sub_name_comma_name(self):
-        """Returns sub-building name and building name concatenated with a comma"""
+        """Returns sub-building name and building name joined with a comma"""
         return self._concatenate(('sub_building_name', 'building_name'), ', ')
 
     @property
@@ -77,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"""
@@ -98,5 +105,7 @@ class Premises(
         return self.last_word('sub_building_name')
 
     def _concatenate(self, keys, concatenator=' '):
-        """Returns specified attributes concatenated with a specified separator"""
-        return concatenator.join(filter(None, [getattr(self, k, None) for k in keys]))
+        """Returns specified attributes concatenated with a separator"""
+        return concatenator.join(
+            filter(None, [getattr(self, k, None) for k in keys])
+            )

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/premises/attribute.py

@@ -1,5 +1,6 @@
 """Attribute Mixin"""
 
+
 class AttributeMixin():
     """Premises elements and derived properties"""
 
@@ -25,13 +26,13 @@ class AttributeMixin():
     @property
     def attrs(cls):
         """Returns all Paf premises elements"""
-        return(
+        return (
             cls.organisation_attrs
-                + cls.building_attrs
-                + cls.dependent_thoroughfare_attrs
-                + cls.thoroughfare_attrs
-                + cls.locality_attrs
-                + cls.other_attrs
+            + cls.building_attrs
+            + cls.dependent_thoroughfare_attrs
+            + cls.thoroughfare_attrs
+            + cls.locality_attrs
+            + cls.other_attrs
             )
 
     def is_empty(self, attr):

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

@@ -2,6 +2,7 @@
 
 from .split import SplitMixin
 
+
 class BuildingTypeMixin(SplitMixin):
     """Determines if a string represents a known building type"""
 
@@ -10,8 +11,11 @@ class BuildingTypeMixin(SplitMixin):
     def known_building_types(cls):
         """Returns known building types"""
         return (
-            "BACK OF", "BLOCK", "BLOCKS", "BUILDING", "MAISONETTE", "MAISONETTES", "REAR OF",
-            "SHOP", "SHOPS", "STALL", "STALLS", "SUITE", "SUITES", "UNIT", "UNITS", "PO BOX"
+            "BACK OF", "BLOCK", "BLOCKS", "BUILDING",
+            "MAISONETTE", "MAISONETTES", "REAR OF",
+            "SHOP", "SHOPS", "STALL", "STALLS",
+            "SUITE", "SUITES", "UNIT", "UNITS",
+            "PO BOX"
             )
 
     @classmethod

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/premises/dependent_premisable.py

@@ -2,6 +2,7 @@
 
 from .premisable import PremisableMixin
 
+
 class DependentPremisableMixin(PremisableMixin):
     """Returns the values for the premises properties"""
 

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

@@ -4,6 +4,7 @@ import re
 from .building_type import BuildingTypeMixin
 from .split import SplitMixin
 
+
 class ExceptionMixin(BuildingTypeMixin, SplitMixin):
     """Exceptions"""
 
@@ -27,8 +28,8 @@ class ExceptionMixin(BuildingTypeMixin, SplitMixin):
         """Returns if value is an exception"""
         return (
             cls.__is_exception_i(val)
-                or cls.__is_exception_ii(val)
-                or cls.__is_exception_iii(val)
+            or cls.__is_exception_ii(val)
+            or cls.__is_exception_iii(val)
             )
 
     def __is_exception_iv(self, attr):  # pylint: disable=unused-argument
@@ -36,7 +37,7 @@ class ExceptionMixin(BuildingTypeMixin, SplitMixin):
            and ends with numeric range or numeric alpha suffix"""
         # Do not include suffix check as does not account for values such as BLOCK B
         return self.is_known_building_type(attr)
-        # and re.match(r'^\d', splitstring.last_word(getattr(self, attr, None)))
+        # and re.match(r'^\d', self.last_word(attr))
 
     def is_exception(self, attr):
         """Returns if attribute is an exception"""
@@ -45,7 +46,8 @@ class ExceptionMixin(BuildingTypeMixin, SplitMixin):
     def is_split_exception(self, attr):
         """Returns if attribute should be split"""
         return (
-            self.__is_exception(self.last_word(attr))
-                and not self.last_word(attr).isdigit()
-                and not self.__is_exception_iv(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)
             )

pypaf-1.0.1/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-0.8.0 → pypaf-1.0.1}/src/paf/premises/lineable.py

@@ -2,6 +2,7 @@
 
 from itertools import chain
 
+
 class LineableMixin():
     """Converts Paf address premises elements into list of lines"""
 
@@ -18,7 +19,10 @@ class LineableMixin():
     @property
     def po_box(self):
         """Returns PO Box"""
-        return '' if self.is_empty('po_box_number') else f"PO BOX {getattr(self, 'po_box_number')}"
+        return (
+            '' if self.is_empty('po_box_number')
+            else f"PO BOX {getattr(self, 'po_box_number')}"
+            )
 
     def _lines(self, attrs):
         """Returns list of premises lines from specified attributes"""

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/premises/premisable.py

@@ -2,6 +2,7 @@
 
 from .exception import ExceptionMixin
 
+
 class PremisableMixin(ExceptionMixin):
     """Returns the values for the premises properties"""
 

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/premises/rule000.py

@@ -2,6 +2,7 @@
 
 from .premisable import PremisableMixin
 
+
 class Rule000(PremisableMixin):
     """Rule 1 processing"""
 

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/premises/rule001.py

@@ -2,6 +2,7 @@
 
 from .dependent_premisable import DependentPremisableMixin
 
+
 class Rule001(DependentPremisableMixin):
     """Rule 2 processing"""
 

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/premises/rule010.py

@@ -2,6 +2,7 @@
 
 from .dependent_premisable import DependentPremisableMixin
 
+
 class Rule010(DependentPremisableMixin):
     """Rule 3 processing"""
 
@@ -17,4 +18,7 @@ class Rule010(DependentPremisableMixin):
     @property
     def includes_first_thoroughfare_or_locality(self):
         """Returns if premises includes first thoroughfare or locality"""
-        return self.is_exception('building_name') or self.is_split_exception('building_name')
+        return (
+            self.is_exception('building_name')
+            or self.is_split_exception('building_name')
+            )

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/premises/rule011.py

@@ -2,6 +2,7 @@
 
 from .dependent_premisable import DependentPremisableMixin
 
+
 class Rule011(DependentPremisableMixin):
     """Rule 4 processing"""
 

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/premises/rule100.py

@@ -2,6 +2,7 @@
 
 from .premisable import PremisableMixin
 
+
 class Rule100(PremisableMixin):
     """Rule X processing"""
 
@@ -9,7 +10,7 @@ class Rule100(PremisableMixin):
     def rule_attrs(self):
         """Returns premises list"""
         if self.is_exception('sub_building_name'):
-            return('sub_name_and_thoroughfare_or_locality',)
+            return ('sub_name_and_thoroughfare_or_locality',)
         return ('sub_building_name',)
 
     @property

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/premises/rule101.py

@@ -2,6 +2,7 @@
 
 from .premisable import PremisableMixin
 
+
 class Rule101(PremisableMixin):
     """Rule 5 processing"""
 

pypaf-1.0.1/src/paf/premises/rule110.py

@@ -0,0 +1,34 @@
+"""Rule 6"""
+
+from .premisable import PremisableMixin
+
+
+class Rule110(PremisableMixin):
+    """Rule 6 processing"""
+
+    @property
+    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')
+        if self.is_split_exception('building_name'):
+            return (
+                'sub_building_name', 'building_name_but_last_word',
+                'name_last_word_and_thoroughfare_or_locality'
+                )
+        return ('sub_building_name', 'building_name')
+
+    @property
+    def includes_first_thoroughfare_or_locality(self):
+        """Returns if premises includes first thoroughfare or locality"""
+        return (
+            self.is_split_exception('building_name')
+            or (not self.is_exception('sub_building_name') and self.is_exception('building_name'))
+            )

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/premises/rule111.py

@@ -2,6 +2,7 @@
 
 from .premisable import PremisableMixin
 
+
 class Rule111(PremisableMixin):
     """Rule 7 processing"""
 
@@ -9,9 +10,9 @@ class Rule111(PremisableMixin):
     def rule_attrs(self):
         """Returns premises list"""
         if self.is_zero('building_number'):
-            return('sub_name_comma_name',)
+            return ('sub_name_comma_name',)
         if self.is_exception('sub_building_name'):
-            return('sub_name_and_name', 'number_and_thoroughfare_or_locality')
+            return ('sub_name_and_name', 'number_and_thoroughfare_or_locality')
         return ('sub_building_name', 'building_name', 'number_and_thoroughfare_or_locality')
 
     @property

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

@@ -2,6 +2,7 @@
 
 import re
 
+
 class SplitMixin():
     """Methods to extract various parts of a attribute value"""
 
@@ -53,5 +54,5 @@ class SplitMixin():
         return self.__leading_digits(str(getattr(self, attr, '')))
 
     def after_leading_digits(self, attr):
-        """Returns the characters after the leading digits from the attribute"""
+        """Returns characters after the leading digits from the attribute"""
         return self.__after_leading_digits(str(getattr(self, attr, '')))

{pypaf-0.8.0 → pypaf-1.0.1}/src/paf/thoroughfare_locality.py

@@ -1,5 +1,6 @@
 """Thoroughfare and Locality Mixin"""
 
+
 class ThoroughfareLocalityMixin():
     """Thoroughfare and locality processing"""
 
@@ -37,8 +38,7 @@ class ThoroughfareLocalityMixin():
     def dependent_thoroughfare(self):
         """Returns dependent thoroughfare"""
         return ' '.join(
-            filter(None, [getattr(self, k, None) for k in self.dependent_thoroughfare_attrs])
-            )
+            filter(None, [getattr(self, k, None) for k in self.dependent_thoroughfare_attrs]))
 
     @property
     def thoroughfare(self):
@@ -47,7 +47,7 @@ class ThoroughfareLocalityMixin():
 
     @property
     def first_thoroughfare_or_locality_attr(self):
-        """Returns name of first populated thoroughfare or locality attribute"""
+        """Returns name of first populated thoroughfare / locality attribute"""
         for k in self.thoroughfare_and_locality_attrs:
             if not self.is_empty(k):
                 return k
@@ -63,7 +63,7 @@ class ThoroughfareLocalityMixin():
         """Returns if attribute value is empty or has already been used"""
         if self.is_empty(attr):
             return True
-        return(
+        return (
             attr == self.first_thoroughfare_or_locality_attr
-                and self.premises.includes_first_thoroughfare_or_locality
+            and self.premises.includes_first_thoroughfare_or_locality
             )

pypaf-1.0.1/src/paf/version.py

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

{pypaf-0.8.0 → pypaf-1.0.1}/tests/test_empty.py

@@ -3,12 +3,14 @@
 import unittest
 import paf
 
+
 class TestEmpty(unittest.TestCase):
     """Test Address Exception I"""
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """Set up Address instance"""
-        self.address = paf.Address({})
+        cls.address = paf.Address({})
 
     def test_list(self):
         """Test conversion to an list"""
@@ -35,5 +37,6 @@ class TestEmpty(unittest.TestCase):
         premises = {}
         self.assertEqual(self.address.premises(), premises, "Incorrect empty premises")
 
+
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.8.0 → pypaf-1.0.1}/tests/test_exception_i.py

@@ -3,12 +3,14 @@
 import unittest
 import paf
 
+
 class TestExceptionI(unittest.TestCase):
     """Test Address Exception I"""
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """Set up Address instance"""
-        self.address = paf.Address({
+        cls.address = paf.Address({
             'building_name': "1-2",
             'thoroughfare_name': "NURSERY",
             'thoroughfare_descriptor': "LANE",
@@ -25,7 +27,10 @@ class TestExceptionI(unittest.TestCase):
     def test_string(self):
         """Test conversion to a string"""
         address = "1-2 NURSERY LANE, PENN, HIGH WYCOMBE. HP10 8LS"
-        self.assertEqual(self.address.as_str(), address, "Incorrect Exception I string format")
+        self.assertEqual(
+            self.address.as_str(), address,
+            "Incorrect Exception I string format"
+            )
 
     def test_tuple(self):
         """Test conversion to a tuple"""
@@ -47,5 +52,6 @@ class TestExceptionI(unittest.TestCase):
         premises = {'premises_number': 1, 'premises_suffix': '-2'}
         self.assertEqual(self.address.premises(), premises, "Incorrect Exception I premises")
 
+
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.8.0 → pypaf-1.0.1}/tests/test_exception_ii.py

@@ -3,12 +3,14 @@
 import unittest
 import paf
 
+
 class TestExceptionII(unittest.TestCase):
     """Test Address Exception II"""
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """Set up Address instance"""
-        self.address = paf.Address({
+        cls.address = paf.Address({
             'building_name': "12A",
             'thoroughfare_name': "UPPERKIRKGATE",
             'post_town': "ABERDEEN",
@@ -32,7 +34,11 @@ class TestExceptionII(unittest.TestCase):
 
     def test_dict(self):
         """Test conversion to a dict"""
-        address = {'line_1': "12A UPPERKIRKGATE", 'post_town': "ABERDEEN", 'postcode': "AB10 1BA"}
+        address = {
+            'line_1': "12A UPPERKIRKGATE",
+            'post_town': "ABERDEEN",
+            'postcode': "AB10 1BA"
+            }
         self.assertEqual(self.address.as_dict(), address, "Incorrect Exception II dict format")
 
     def test_premises(self):
@@ -40,5 +46,6 @@ class TestExceptionII(unittest.TestCase):
         premises = {'premises_number': 12, 'premises_suffix': 'A'}
         self.assertEqual(self.address.premises(), premises, "Incorrect Exception II premises")
 
+
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.8.0 → pypaf-1.0.1}/tests/test_exception_iii.py

@@ -3,12 +3,14 @@
 import unittest
 import paf
 
+
 class TestExceptionIII(unittest.TestCase):
     """Test Address Exception III"""
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """Set up Address instance"""
-        self.address = paf.Address({
+        cls.address = paf.Address({
             'building_name': "K",
             'thoroughfare_name': "PORTLAND",
             'thoroughfare_descriptor': "ROAD",
@@ -33,7 +35,11 @@ class TestExceptionIII(unittest.TestCase):
 
     def test_dict(self):
         """Test conversion to a dict"""
-        address = {'line_1': "K PORTLAND ROAD", 'post_town': "DORKING", 'postcode': "RH4 1EW"}
+        address = {
+            'line_1': "K PORTLAND ROAD",
+            'post_town': "DORKING",
+            'postcode': "RH4 1EW"
+            }
         self.assertEqual(self.address.as_dict(), address, "Incorrect Exception III dict format")
 
     def test_premises(self):
@@ -41,5 +47,6 @@ class TestExceptionIII(unittest.TestCase):
         premises = {'premises_name': 'K'}
         self.assertEqual(self.address.premises(), premises, "Incorrect Exception III premises")
 
+
 if __name__ == '__main__':
     unittest.main()