PyPaf 0.3.0__tar.gz → 0.5.0__tar.gz

{pypaf-0.3.0/src/PyPaf.egg-info → pypaf-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyPaf
-Version: 0.3.0
+Version: 0.5.0
 Summary: Formats the elements of a Royal Mail Postcode Address File entry
 Author-email: John Bard <johnbard@globalnet.co.uk>
 License: MIT
@@ -25,11 +25,11 @@ Install it from PyPI:
 
 ## Usage
 
-May be used to format the PAF elements as an array of strings:
+May be used to format the PAF Address elements as an array of strings:
 
 ```python
-from paf import Paf
-paf = Paf({
+import paf
+address = paf.Address({
     'building_name': "1-2",
     'thoroughfare_name': "NURSERY",
     'thoroughfare_descriptor': "LANE",
@@ -37,7 +37,7 @@ paf = Paf({
     'post_town': "HIGH WYCOMBE",
     'postcode': "HP10 8LS"
 })
-paf.list() # or list(paf)
+address.list() # or list(address)
 
 ['1-2 NURSERY LANE', 'PENN', 'HIGH WYCOMBE', 'HP10 8LS']
 ```
@@ -45,8 +45,8 @@ paf.list() # or list(paf)
 Or as a single string:
 
 ```python
-from paf import Paf
-paf = Paf({
+import paf
+address = paf.Address({
     'building_name': "1-2",
     'thoroughfare_name': "NURSERY",
     'thoroughfare_descriptor': "LANE",
@@ -54,7 +54,7 @@ paf = Paf({
     'post_town': "HIGH WYCOMBE",
     'postcode': "HP10 8LS"
 })
-paf.str() # or str(paf)
+address.str() # or str(address)
 
 '1-2 NURSERY LANE, PENN, HIGH WYCOMBE. HP10 8LS'
 ```

{pypaf-0.3.0 → pypaf-0.5.0}/README.md

@@ -10,11 +10,11 @@ Install it from PyPI:
 
 ## Usage
 
-May be used to format the PAF elements as an array of strings:
+May be used to format the PAF Address elements as an array of strings:
 
 ```python
-from paf import Paf
-paf = Paf({
+import paf
+address = paf.Address({
     'building_name': "1-2",
     'thoroughfare_name': "NURSERY",
     'thoroughfare_descriptor': "LANE",
@@ -22,7 +22,7 @@ paf = Paf({
     'post_town': "HIGH WYCOMBE",
     'postcode': "HP10 8LS"
 })
-paf.list() # or list(paf)
+address.list() # or list(address)
 
 ['1-2 NURSERY LANE', 'PENN', 'HIGH WYCOMBE', 'HP10 8LS']
 ```
@@ -30,8 +30,8 @@ paf.list() # or list(paf)
 Or as a single string:
 
 ```python
-from paf import Paf
-paf = Paf({
+import paf
+address = paf.Address({
     'building_name': "1-2",
     'thoroughfare_name': "NURSERY",
     'thoroughfare_descriptor': "LANE",
@@ -39,7 +39,7 @@ paf = Paf({
     'post_town': "HIGH WYCOMBE",
     'postcode': "HP10 8LS"
 })
-paf.str() # or str(paf)
+address.str() # or str(address)
 
 '1-2 NURSERY LANE, PENN, HIGH WYCOMBE. HP10 8LS'
 ```

{pypaf-0.3.0 → pypaf-0.5.0/src/PyPaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyPaf
-Version: 0.3.0
+Version: 0.5.0
 Summary: Formats the elements of a Royal Mail Postcode Address File entry
 Author-email: John Bard <johnbard@globalnet.co.uk>
 License: MIT
@@ -25,11 +25,11 @@ Install it from PyPI:
 
 ## Usage
 
-May be used to format the PAF elements as an array of strings:
+May be used to format the PAF Address elements as an array of strings:
 
 ```python
-from paf import Paf
-paf = Paf({
+import paf
+address = paf.Address({
     'building_name': "1-2",
     'thoroughfare_name': "NURSERY",
     'thoroughfare_descriptor': "LANE",
@@ -37,7 +37,7 @@ paf = Paf({
     'post_town': "HIGH WYCOMBE",
     'postcode': "HP10 8LS"
 })
-paf.list() # or list(paf)
+address.list() # or list(address)
 
 ['1-2 NURSERY LANE', 'PENN', 'HIGH WYCOMBE', 'HP10 8LS']
 ```
@@ -45,8 +45,8 @@ paf.list() # or list(paf)
 Or as a single string:
 
 ```python
-from paf import Paf
-paf = Paf({
+import paf
+address = paf.Address({
     'building_name': "1-2",
     'thoroughfare_name': "NURSERY",
     'thoroughfare_descriptor': "LANE",
@@ -54,7 +54,7 @@ paf = Paf({
     'post_town': "HIGH WYCOMBE",
     'postcode': "HP10 8LS"
 })
-paf.str() # or str(paf)
+address.str() # or str(address)
 
 '1-2 NURSERY LANE, PENN, HIGH WYCOMBE. HP10 8LS'
 ```

{pypaf-0.3.0 → pypaf-0.5.0}/src/PyPaf.egg-info/SOURCES.txt

@@ -6,9 +6,10 @@ src/PyPaf.egg-info/SOURCES.txt
 src/PyPaf.egg-info/dependency_links.txt
 src/PyPaf.egg-info/top_level.txt
 src/paf/__init__.py
+src/paf/address.py
 src/paf/attribute.py
+src/paf/immutable.py
 src/paf/lineable.py
-src/paf/paf.py
 src/paf/premises_extender.py
 src/paf/thoroughfare_locality.py
 src/paf/version.py
@@ -25,6 +26,7 @@ tests/test_exception_i.py
 tests/test_exception_ii.py
 tests/test_exception_iii.py
 tests/test_exception_iv.py
+tests/test_immutability.py
 tests/test_mainfile.py
 tests/test_po_box.py
 tests/test_rule_1.py

pypaf-0.5.0/src/paf/__init__.py

@@ -0,0 +1,6 @@
+"""__init__ file"""
+
+from .address import Address
+from .version import __version__
+
+__all__ = ["Address", "__version__"]

pypaf-0.3.0/src/paf/paf.py → pypaf-0.5.0/src/paf/address.py

@@ -1,41 +1,43 @@
-"""Paf"""
+"""PAF Address"""
 
+# Tried using dataclasses.dataclass(frozen=True) decorator for immutablity but did not work"""
+from .immutable import ImmutableMixin
 from .lineable import LineableMixin
 
-class Paf(LineableMixin):
-    """Main Paf class"""
+class Address(ImmutableMixin, LineableMixin):
+    """Main PAF Address class"""
 
     def __init__(self, args):
-        """Initialise Paf address elements"""
-        for key in self.__class__.attrs:
-            setattr(self, key, '')
+        """Initialise Address elements"""
+        for key in self.__class__.attrs: # pylint: disable=not-an-iterable
+            object.__setattr__(self, key, '')
         for key, val in args.items():
             if hasattr(self, key):
-                setattr(self, key, val)
+                object.__setattr__(self, key, val)
         self.extend_premises()
 
     def __repr__(self):
-        """Return full representation of Paf"""
-        args = {k: getattr(self, k) for k in self.__class__.attrs if getattr(self, k, None)}
+        """Return full representation of an Address"""
+        args = {k: getattr(self, k) for k in self.__class__.attrs if getattr(self, k, None)} # pylint: disable=not-an-iterable
         return self.__class__.__name__ + '(' + str(args) + ')'
 
     def __str__(self):
-        """Return Paf as string representation"""
+        """Return Address as string representation"""
         line = ', '.join(self.lines)
         if self.is_empty('postcode'):
             return line
         return '. '.join([line] + [getattr(self, 'postcode')])
 
     def __iter__(self):
-        """Return Paf as iterable"""
+        """Return Address as iterable"""
         yield from self.lines.__iter__()
         if not self.is_empty('postcode'):
             yield from [getattr(self, 'postcode')].__iter__()
 
     def str(self):
-        """Return Paf as string"""
+        """Return Address as string"""
         return str(self)
 
     def list(self):
-        """Return Paf as list of strings"""
+        """Return Address as list of strings"""
         return list(self)

pypaf-0.5.0/src/paf/immutable.py

@@ -0,0 +1,12 @@
+"""Immutable Mixin"""
+
+from dataclasses import FrozenInstanceError
+
+class ImmutableMixin():
+    """Prevent manipulation of object attributes"""
+
+    def __setattr__(self, *_):
+        raise FrozenInstanceError
+
+    def __delattr__(self, *_):
+        raise FrozenInstanceError

{pypaf-0.3.0 → pypaf-0.5.0}/src/paf/premises/rule010.py

@@ -26,12 +26,12 @@ class Rule010(Common):
         return(
             self.is_exception('building_name_last_word') and
                 not re.match(r'^\d+$', self.building_name_last_word) and
-                not self.is_non_split_building_name
+                not self.is_known_building_type
             )
 
     @property
-    def is_non_split_building_name(self):
-        """Returns if building name should not be split based on all but last word"""
+    def is_known_building_type(self):
+        """Returns if building name starts with a known building type"""
         return self.building_name_but_last_word in [
             "BACK OF", "BLOCK", "BLOCKS", "BUILDING", "MAISONETTE", "MAISONETTES", "REAR OF",
             "SHOP", "SHOPS", "STALL", "STALLS", "SUITE", "SUITES", "UNIT", "UNITS"

{pypaf-0.3.0 → pypaf-0.5.0}/src/paf/premises_extender.py

@@ -22,4 +22,6 @@ class PremisesExtenderMixin(AttributeMixin):
     def extend_premises(self):
         """Dynamically extends instance with appropriate premises rule"""
         base_cls = self.__class__
-        self.__class__ = type(base_cls.__name__, (base_cls, self.premises_rule), {})
+        object.__setattr__(
+            self, '__class__', type(base_cls.__name__, (base_cls, self.premises_rule), {})
+            )

pypaf-0.5.0/src/paf/version.py

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

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_exception_i.py

@@ -1,14 +1,14 @@
-"""Test Paf Exception I formatting"""
+"""Test Address Exception I formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestExceptionI(unittest.TestCase):
-    """Test Paf Exception I"""
+    """Test Address Exception I"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'building_name': "1-2",
             'thoroughfare_name': "NURSERY",
             'thoroughfare_descriptor': "LANE",
@@ -20,12 +20,12 @@ class TestExceptionI(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["1-2 NURSERY LANE", "PENN", "HIGH WYCOMBE", "HP10 8LS"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Exception I list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Exception I list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "1-2 NURSERY LANE, PENN, HIGH WYCOMBE. HP10 8LS"
-        self.assertEqual(self.paf.str(), address, "Incorrect Exception I string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Exception I string format")
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_exception_ii.py

@@ -1,14 +1,14 @@
-"""Test Paf Exception II formatting"""
+"""Test Address Exception II formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestExceptionII(unittest.TestCase):
-    """Test Paf Exception II"""
+    """Test Address Exception II"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'building_name': "12A",
             'thoroughfare_name': "UPPERKIRKGATE",
             'post_town': "ABERDEEN",
@@ -18,12 +18,12 @@ class TestExceptionII(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["12A UPPERKIRKGATE", "ABERDEEN", "AB10 1BA"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Exception II list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Exception II list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "12A UPPERKIRKGATE, ABERDEEN. AB10 1BA"
-        self.assertEqual(self.paf.str(), address, "Incorrect Exception II string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Exception II string format")
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_exception_iii.py

@@ -1,14 +1,14 @@
-"""Test Paf Exception III formatting"""
+"""Test Address Exception III formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestExceptionIII(unittest.TestCase):
-    """Test Paf Exception III"""
+    """Test Address Exception III"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'building_name': "K",
             'thoroughfare_name': "PORTLAND",
             'thoroughfare_descriptor': "ROAD",
@@ -19,12 +19,12 @@ class TestExceptionIII(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["K PORTLAND ROAD", "DORKING", "RH4 1EW"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Exception III list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Exception III list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "K PORTLAND ROAD, DORKING. RH4 1EW"
-        self.assertEqual(self.paf.str(), address, "Incorrect Exception III string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Exception III string format")
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_exception_iv.py

@@ -1,14 +1,14 @@
-"""Test Paf Exception IV formatting"""
+"""Test Address Exception IV formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestExceptionIVUnit(unittest.TestCase):
-    """Test Paf Exception IV Unit"""
+    """Test Address Exception IV Unit"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'organisation_name': "THE TAMBOURINE WAREHOUSE",
             'building_name': "UNIT 1-3",
             'dependent_thoroughfare_name': "INDUSTRIAL",
@@ -29,19 +29,19 @@ class TestExceptionIVUnit(unittest.TestCase):
             "LONDON",
             "E6 7HS"
             ]
-        self.assertEqual(self.paf.list(), address, "Incorrect Exception IV Unit list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Exception IV Unit list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "THE TAMBOURINE WAREHOUSE, UNIT 1-3, INDUSTRIAL ESTATE, TAME ROAD, LONDON. E6 7HS"
-        self.assertEqual(self.paf.str(), address, "Incorrect Exception IV Unit string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Exception IV Unit string format")
 
 class TestExceptionIVStall(unittest.TestCase):
-    """Test Paf Exception IV Stall"""
+    """Test Address Exception IV Stall"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'organisation_name': "QUIRKY CANDLES LTD",
             'building_name': "STALL 4",
             'thoroughfare_name': "MARKET",
@@ -59,19 +59,19 @@ class TestExceptionIVStall(unittest.TestCase):
             "LIVERPOOL",
             "L8 1LH"
             ]
-        self.assertEqual(self.paf.list(), address, "Incorrect Exception IV Stall list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Exception IV Stall list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "QUIRKY CANDLES LTD, STALL 4, MARKET SQUARE, LIVERPOOL. L8 1LH"
-        self.assertEqual(self.paf.str(), address, "Incorrect Exception IV Stall string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Exception IV Stall string format")
 
 class TestExceptionIVRearOf(unittest.TestCase):
-    """Test Paf Exception IV Rear Of"""
+    """Test Address Exception IV Rear Of"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'organisation_name': "FIONA'S FLOWERS",
             'building_name': "REAR OF 5A",
             'thoroughfare_name': "HIGH",
@@ -89,12 +89,12 @@ class TestExceptionIVRearOf(unittest.TestCase):
             "GATESHEAD",
             "NE8 1BH"
             ]
-        self.assertEqual(self.paf.list(), address, "Incorrect Exception IV Rear Of list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Exception IV RearOf list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "FIONA'S FLOWERS, REAR OF 5A, HIGH STREET, GATESHEAD. NE8 1BH"
-        self.assertEqual(self.paf.str(), address, "Incorrect Exception IV Rear Of string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Exception IV RearOf string format")
 
 if __name__ == '__main__':
     unittest.main()

pypaf-0.5.0/tests/test_immutability.py

@@ -0,0 +1,38 @@
+"""Test Immutability"""
+
+import unittest
+from dataclasses import FrozenInstanceError
+import paf
+
+class TestImmutability(unittest.TestCase):
+    """Test Immutable"""
+
+    def setUp(self):
+        """Set up Address instance"""
+        self.address = paf.Address({
+            'building_number': "16",
+            'thoroughfare_name': "VIXEN",
+            'thoroughfare_descriptor': "ROAD",
+            'post_town': "BRADOCK",
+            'postcode': "KT6 5BT"
+            })
+
+    def test_assignment(self):
+        """Test setting attribute by direct assignment"""
+        with self.assertRaises(FrozenInstanceError):
+            self.address.building_name = "THE HOUSE"
+
+    def test_setattr(self):
+        """Test setting new attribute"""
+        self.assertRaises(FrozenInstanceError, setattr, self.address, 'building_name', "THE HOUSE")
+
+    def test_resetattr(self):
+        """Test re-setting existing attribute"""
+        self.assertRaises(FrozenInstanceError, setattr, self.address, 'building_number', "20")
+
+    def test_delattr(self):
+        """Test deleting attribute"""
+        self.assertRaises(FrozenInstanceError, delattr, self.address, 'post_town')
+
+if __name__ == '__main__':
+    unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_mainfile.py

@@ -1,14 +1,14 @@
-"""Test Paf Mainfile formatting"""
+"""Test Address Mainfile formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestMainfile(unittest.TestCase):
-    """Test Paf Mainfile"""
+    """Test Address Mainfile"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'organisation_name': "SOUTH LANARKSHIRE COUNCIL",
             'department_name': "HEAD START",
             'sub_building_name': "UNIT 1",
@@ -34,7 +34,7 @@ class TestMainfile(unittest.TestCase):
             "GLASGOW",
             "G72 0UP"
             ]
-        self.assertEqual(self.paf.list(), address, "Incorrect Mainfile list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Mainfile list format")
 
     def test_string(self):
         """Test conversion to a string"""
@@ -49,7 +49,7 @@ class TestMainfile(unittest.TestCase):
             "GLASGOW. "
             "G72 0UP"
             )
-        self.assertEqual(self.paf.str(), address, "Incorrect Mainfile string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Mainfile string format")
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_po_box.py

@@ -1,14 +1,14 @@
-"""Test Paf PO Box formatting"""
+"""Test Address PO Box formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestPoBox(unittest.TestCase):
-    """Test Paf PO Box"""
+    """Test Address PO Box"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'po_box_number': "61",
             'post_town': "FAREHAM",
             'postcode': "PO14 1UX"
@@ -17,12 +17,12 @@ class TestPoBox(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["PO BOX 61", "FAREHAM", "PO14 1UX"]
-        self.assertEqual(self.paf.list(), address, "Incorrect PO Box list format")
+        self.assertEqual(self.address.list(), address, "Incorrect PO Box list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "PO BOX 61, FAREHAM. PO14 1UX"
-        self.assertEqual(self.paf.str(), address, "Incorrect PO Box string format")
+        self.assertEqual(self.address.str(), address, "Incorrect PO Box string format")
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_rule_1.py

@@ -1,14 +1,14 @@
-"""Test Paf Rule 1 formatting"""
+"""Test Address Rule 1 formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestRule1(unittest.TestCase):
-    """Test Paf Rule 1"""
+    """Test Address Rule 1"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'organisation_name': "LEDA ENGINEERING LTD",
             'dependent_locality': "APPLEFORD",
             'post_town': "ABINGDON",
@@ -18,12 +18,12 @@ class TestRule1(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["LEDA ENGINEERING LTD", "APPLEFORD", "ABINGDON", "OX14 4PG"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 1 list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 1 list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "LEDA ENGINEERING LTD, APPLEFORD, ABINGDON. OX14 4PG"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 1 string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 1 string format")
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_rule_2.py

@@ -1,14 +1,14 @@
-"""Test Paf Rule 2 formatting"""
+"""Test Address Rule 2 formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestRule2(unittest.TestCase):
-    """Test Paf Rule 2"""
+    """Test Address Rule 2"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'building_number': "1",
             'thoroughfare_name': "ACACIA",
             'thoroughfare_descriptor': "AVENUE",
@@ -19,12 +19,12 @@ class TestRule2(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["1 ACACIA AVENUE", "ABINGDON", "OX14 4PG"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 2 list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 2 list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "1 ACACIA AVENUE, ABINGDON. OX14 4PG"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 2 string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 2 string format")
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_rule_3.py

@@ -1,14 +1,14 @@
-"""Test Paf Rule 3 formatting"""
+"""Test Address Rule 3 formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestRule3WithBuildingName(unittest.TestCase):
-    """Test Paf Rule 3 with Building Name Exception"""
+    """Test Address Rule 3 with Building Name Exception"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'building_name': "1A",
             'dependent_thoroughfare_name': "SEASTONE",
             'dependent_thoroughfare_descriptor': "COURT",
@@ -21,19 +21,19 @@ class TestRule3WithBuildingName(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["1A SEASTONE COURT", "STATION ROAD", "HOLT", "NR25 7HG"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 3 with building list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 3 w/ building list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "1A SEASTONE COURT, STATION ROAD, HOLT. NR25 7HG"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 3 with building string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 3 w/ building string format")
 
 class TestRule3WithoutBuildingName(unittest.TestCase):
-    """Test Paf Rule 3 without Building Name Exception"""
+    """Test Address Rule 3 without Building Name Exception"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'building_name': "THE MANOR",
             'thoroughfare_name': "UPPER",
             'thoroughfare_descriptor': "ROAD",
@@ -44,19 +44,19 @@ class TestRule3WithoutBuildingName(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["THE MANOR", "UPPER ROAD", "HORLEY", "RH6 0HP"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 3 without building list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 3 w/o building list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "THE MANOR, UPPER ROAD, HORLEY. RH6 0HP"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 3 without building string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 3 w/ building string format")
 
 class TestRule3WithSplit(unittest.TestCase):
-    """Test Paf Rule 3 with Split Exception"""
+    """Test Address Rule 3 with Split Exception"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'organisation_name': "S D ALCOTT FLORISTS",
             'building_name': "FLOWER HOUSE 189A",
             'thoroughfare_name': "PYE GREEN",
@@ -74,19 +74,19 @@ class TestRule3WithSplit(unittest.TestCase):
             "CANNOCK",
             "WS11 5SB"
             ]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 3 with split list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 3 with split list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "S D ALCOTT FLORISTS, FLOWER HOUSE, 189A PYE GREEN ROAD, CANNOCK. WS11 5SB"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 3 with split string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 3 with split string format")
 
 class TestRule3WithoutSplit(unittest.TestCase):
-    """Test Paf Rule 3 without Split Exception"""
+    """Test Address Rule 3 without Split Exception"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'organisation_name': "JAMES VILLA HOLIDAYS",
             'building_name': "CENTRE 30",
             'thoroughfare_name': "ST LAURENCE",
@@ -98,12 +98,12 @@ class TestRule3WithoutSplit(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["JAMES VILLA HOLIDAYS", "CENTRE 30", "ST LAURENCE AVENUE", "GRAFTON", "ME16 0LP"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 3 without split list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 3 w/o split list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "JAMES VILLA HOLIDAYS, CENTRE 30, ST LAURENCE AVENUE, GRAFTON. ME16 0LP"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 3 without split string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 3 w/o split string format")
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_rule_4.py

@@ -1,14 +1,14 @@
-"""Test Paf Rule 4 formatting"""
+"""Test Address Rule 4 formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestRule4(unittest.TestCase):
-    """Test Paf Rule 4"""
+    """Test Address Rule 4"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'building_name': "VICTORIA HOUSE",
             'building_number': "15",
             'thoroughfare_name': "THE",
@@ -20,12 +20,12 @@ class TestRule4(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["VICTORIA HOUSE", "15 THE STREET", "CHRISTCHURCH", "BH23 6AA"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 4 list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 4 list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "VICTORIA HOUSE, 15 THE STREET, CHRISTCHURCH. BH23 6AA"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 4 string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 4 string format")
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_rule_5.py

@@ -1,14 +1,14 @@
-"""Test Paf Rule 5 formatting"""
+"""Test Address Rule 5 formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestRule5(unittest.TestCase):
-    """Test Paf Rule 5"""
+    """Test Address Rule 5"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'sub_building_name': "FLAT 1",
             'building_number': "12",
             'thoroughfare_name': "LIME TREE",
@@ -20,19 +20,19 @@ class TestRule5(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["FLAT 1", "12 LIME TREE AVENUE", "BRISTOL", "BS8 4AB"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 5 list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 5 list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "FLAT 1, 12 LIME TREE AVENUE, BRISTOL. BS8 4AB"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 5 string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 5 string format")
 
 class TestRule5WithConcatenation(unittest.TestCase):
-    """Test Paf Rule 5 with Concatenation"""
+    """Test Address Rule 5 with Concatenation"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'sub_building_name': "A",
             'building_number': "12",
             'thoroughfare_name': "HIGH",
@@ -46,12 +46,16 @@ class TestRule5WithConcatenation(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["12A HIGH STREET NORTH", "COOMBE BISSETT", "SALISBURY", "SP5 4NA"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 5 with concatenate list format")
+        self.assertEqual(
+            self.address.list(), address, "Incorrect Rule 5 with concatenate list format"
+            )
 
     def test_string(self):
         """Test conversion to a string"""
         address = "12A HIGH STREET NORTH, COOMBE BISSETT, SALISBURY. SP5 4NA"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 5 with concatenate string format")
+        self.assertEqual(
+            self.address.str(), address, "Incorrect Rule 5 with concatenate string format"
+            )
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_rule_6.py

@@ -1,14 +1,14 @@
-"""Test Paf Rule 6 formatting"""
+"""Test Address Rule 6 formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestRule6WithSubBuildingName(unittest.TestCase):
-    """Test Paf Rule 6 with Sub-Building Name Exception"""
+    """Test Address Rule 6 with Sub-Building Name Exception"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'sub_building_name': "10B",
             'building_name': "BARRY JACKSON TOWER",
             'thoroughfare_name': "ESTONE",
@@ -20,19 +20,23 @@ class TestRule6WithSubBuildingName(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["10B BARRY JACKSON TOWER", "ESTONE WALK", "BIRMINGHAM", "B6 5BA"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 6 with sub-building list format")
+        self.assertEqual(
+            self.address.list(), address, "Incorrect Rule 6 with sub-building list format"
+            )
 
     def test_string(self):
         """Test conversion to a string"""
         address = "10B BARRY JACKSON TOWER, ESTONE WALK, BIRMINGHAM. B6 5BA"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 6 w/ sub-building string format")
+        self.assertEqual(
+            self.address.str(), address, "Incorrect Rule 6 with sub-building string format"
+            )
 
 class TestRule6WithBuildingName(unittest.TestCase):
-    """Test Paf Rule 6 with Building Name Exception"""
+    """Test Address Rule 6 with Building Name Exception"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'sub_building_name': "CARETAKERS FLAT",
             'building_name': "110-114",
             'thoroughfare_name': "HIGH",
@@ -44,19 +48,19 @@ class TestRule6WithBuildingName(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["CARETAKERS FLAT", "110-114 HIGH STREET WEST", "BRISTOL", "BS1 2AW"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 6 with building list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 6 w/ building list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "CARETAKERS FLAT, 110-114 HIGH STREET WEST, BRISTOL. BS1 2AW"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 6 with building string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 6 w/ building string format")
 
 class TestRule6(unittest.TestCase):
-    """Test Paf Rule 6 without Exception"""
+    """Test Address Rule 6 without Exception"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'sub_building_name': "STABLES FLAT",
             'building_name': "THE MANOR",
             'thoroughfare_name': "UPPER",
@@ -68,12 +72,12 @@ class TestRule6(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["STABLES FLAT", "THE MANOR", "UPPER HILL", "HORLEY", "RH6 0HP"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 6 list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 6 list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "STABLES FLAT, THE MANOR, UPPER HILL, HORLEY. RH6 0HP"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 6 string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 6 string format")
 
 if __name__ == '__main__':
     unittest.main()

{pypaf-0.3.0 → pypaf-0.5.0}/tests/test_rule_7.py

@@ -1,14 +1,14 @@
-"""Test Paf Rule 7 formatting"""
+"""Test Address Rule 7 formatting"""
 
 import unittest
-from paf import Paf
+import paf
 
 class TestRule7WithZeroBuildingNumber(unittest.TestCase):
-    """Test Paf Rule 7 with a 0 Building Number"""
+    """Test Address Rule 7 with a 0 Building Number"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'sub_building_name': "FLAT 1",
             'building_name': "HOLLY HOUSE",
             'building_number': "0",
@@ -22,19 +22,23 @@ class TestRule7WithZeroBuildingNumber(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["FLAT 1, HOLLY HOUSE", "OAK AVENUE", "BIDDENDEN", "ASHFORD", "TN27 8BT"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 7 with 0 building number format")
+        self.assertEqual(
+            self.address.list(), address, "Incorrect Rule 7 with 0 building number format"
+            )
 
     def test_string(self):
         """Test conversion to a string"""
         address = "FLAT 1, HOLLY HOUSE, OAK AVENUE, BIDDENDEN, ASHFORD. TN27 8BT"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 7 w/ 0 building number format")
+        self.assertEqual(
+            self.address.str(), address, "Incorrect Rule 7 with 0 building number format"
+            )
 
 class TestRule7WithSubBuildingName(unittest.TestCase):
-    """Test Paf Rule 7 with Sub-Building Name Exception"""
+    """Test Address Rule 7 with Sub-Building Name Exception"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'sub_building_name': "2B",
             'building_name': "THE TOWER",
             'building_number': "27",
@@ -47,19 +51,23 @@ class TestRule7WithSubBuildingName(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["2B THE TOWER", "27 JOHN STREET", "WINCHESTER", "SO23 9AP"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 7 with sub-building list format")
+        self.assertEqual(
+            self.address.list(), address, "Incorrect Rule 7 with sub-building list format"
+            )
 
     def test_string(self):
         """Test conversion to a string"""
         address = "2B THE TOWER, 27 JOHN STREET, WINCHESTER. SO23 9AP"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 7 w/ sub-building string format")
+        self.assertEqual(
+            self.address.str(), address, "Incorrect Rule 7 with sub-building string format"
+            )
 
 class TestRule7(unittest.TestCase):
-    """Test Paf Rule 7 without Exception"""
+    """Test Address Rule 7 without Exception"""
 
     def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
+        """Set up Address instance"""
+        self.address = paf.Address({
             'sub_building_name': "BASEMENT FLAT",
             'building_name': "VICTORIA HOUSE",
             'building_number': "15",
@@ -72,12 +80,12 @@ class TestRule7(unittest.TestCase):
     def test_list(self):
         """Test conversion to an list"""
         address = ["BASEMENT FLAT", "VICTORIA HOUSE", "15 THE STREET", "CORYTON", "BP23 6AA"]
-        self.assertEqual(self.paf.list(), address, "Incorrect Rule 7 list format")
+        self.assertEqual(self.address.list(), address, "Incorrect Rule 7 list format")
 
     def test_string(self):
         """Test conversion to a string"""
         address = "BASEMENT FLAT, VICTORIA HOUSE, 15 THE STREET, CORYTON. BP23 6AA"
-        self.assertEqual(self.paf.str(), address, "Incorrect Rule 7 string format")
+        self.assertEqual(self.address.str(), address, "Incorrect Rule 7 string format")
 
 if __name__ == '__main__':
     unittest.main()

pypaf-0.3.0/src/paf/__init__.py

@@ -1,6 +0,0 @@
-"""__init__ file"""
-
-from .paf import Paf
-from .version import __version__
-
-__all__ = ["Paf", "__version__"]

pypaf-0.3.0/src/paf/version.py

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