PyPaf 0.2.0__tar.gz → 0.4.0__tar.gz

{pypaf-0.2.0/src/PyPaf.egg-info → pypaf-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyPaf
-Version: 0.2.0
+Version: 0.4.0
 Summary: Formats the elements of a Royal Mail Postcode Address File entry
 Author-email: John Bard <johnbard@globalnet.co.uk>
 License: MIT
@@ -15,7 +15,7 @@ License-File: LICENSE.txt
 
 # PyPaf
 
-Formats the elements of a Royal Mail Postcode Address File entry according to the rules described in the [Royal Mail Programmer's Guide Edition 7, Version 5.0](http://www.royalmail.com/sites/default/files/docs/pdf/programmers_guide_edition_7_v5.pdf)
+Formats the elements of a Royal Mail Postcode Address File entry according to the rules described in the [Royal Mail Programmer's Guide Edition 7, Version 6.2](https://www.poweredbypaf.com/wp-content/uploads/2024/11/Latest-Programmers_guide_Edition-7-Version-6-2.pdf)
 
 ## Installation
 
@@ -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.2.0 → pypaf-0.4.0}/README.md

@@ -1,6 +1,6 @@
 # PyPaf
 
-Formats the elements of a Royal Mail Postcode Address File entry according to the rules described in the [Royal Mail Programmer's Guide Edition 7, Version 5.0](http://www.royalmail.com/sites/default/files/docs/pdf/programmers_guide_edition_7_v5.pdf)
+Formats the elements of a Royal Mail Postcode Address File entry according to the rules described in the [Royal Mail Programmer's Guide Edition 7, Version 6.2](https://www.poweredbypaf.com/wp-content/uploads/2024/11/Latest-Programmers_guide_Edition-7-Version-6-2.pdf)
 
 ## Installation
 
@@ -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.2.0 → pypaf-0.4.0/src/PyPaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyPaf
-Version: 0.2.0
+Version: 0.4.0
 Summary: Formats the elements of a Royal Mail Postcode Address File entry
 Author-email: John Bard <johnbard@globalnet.co.uk>
 License: MIT
@@ -15,7 +15,7 @@ License-File: LICENSE.txt
 
 # PyPaf
 
-Formats the elements of a Royal Mail Postcode Address File entry according to the rules described in the [Royal Mail Programmer's Guide Edition 7, Version 5.0](http://www.royalmail.com/sites/default/files/docs/pdf/programmers_guide_edition_7_v5.pdf)
+Formats the elements of a Royal Mail Postcode Address File entry according to the rules described in the [Royal Mail Programmer's Guide Edition 7, Version 6.2](https://www.poweredbypaf.com/wp-content/uploads/2024/11/Latest-Programmers_guide_Edition-7-Version-6-2.pdf)
 
 ## Installation
 
@@ -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.2.0 → pypaf-0.4.0}/src/PyPaf.egg-info/SOURCES.txt

@@ -6,9 +6,9 @@ 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/lineable.py
-src/paf/paf.py
 src/paf/premises_extender.py
 src/paf/thoroughfare_locality.py
 src/paf/version.py
@@ -24,6 +24,7 @@ src/paf/premises/rule111.py
 tests/test_exception_i.py
 tests/test_exception_ii.py
 tests/test_exception_iii.py
+tests/test_exception_iv.py
 tests/test_mainfile.py
 tests/test_po_box.py
 tests/test_rule_1.py

pypaf-0.4.0/src/paf/__init__.py

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

pypaf-0.2.0/src/paf/paf.py → pypaf-0.4.0/src/paf/address.py

@@ -1,12 +1,12 @@
-"""Paf"""
+"""PAF Address"""
 
 from .lineable import LineableMixin
 
-class Paf(LineableMixin):
-    """Main Paf class"""
+class Address(LineableMixin):
+    """Main PAF Address class"""
 
     def __init__(self, args):
-        """Initialise Paf address elements"""
+        """Initialise Address elements"""
         for key in self.__class__.attrs:
             setattr(self, key, '')
         for key, val in args.items():
@@ -15,27 +15,27 @@ class Paf(LineableMixin):
         self.extend_premises()
 
     def __repr__(self):
-        """Return full representation of Paf"""
+        """Return full representation of an Address"""
         args = {k: getattr(self, k) for k in self.__class__.attrs if getattr(self, k, None)}
         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.2.0 → pypaf-0.4.0}/src/paf/premises/rule010.py

@@ -25,9 +25,18 @@ class Rule010(Common):
         """Returns if building name should be split"""
         return(
             self.is_exception('building_name_last_word') and
-                not re.match(r'^\d+$', self.building_name_last_word)
+                not re.match(r'^\d+$', self.building_name_last_word) and
+                not self.is_non_split_building_name
             )
 
+    @property
+    def is_non_split_building_name(self):
+        """Returns if building name should not be split based on all but last word"""
+        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"
+            ]
+
     @property
     def building_name_last_word(self):
         """Returns last word of the building name"""

{pypaf-0.2.0 → pypaf-0.4.0}/src/paf/premises/rule111.py

@@ -8,6 +8,8 @@ class Rule111(Common):
     @property
     def premises_rule_attrs(self):
         """Returns premises list"""
+        if self.is_zero_building_number:
+            return['sub_name_comma_name']
         if self.is_exception('sub_building_name'):
             return['sub_name_and_name', 'number_and_thoroughfare_or_locality']
         return ['sub_building_name', 'building_name', 'number_and_thoroughfare_or_locality']
@@ -15,4 +17,14 @@ class Rule111(Common):
     @property
     def does_premises_include_first_thoroughfare_or_locality(self):
         """Returns if premises includes first thoroughfare or locality"""
-        return True
+        return not self.is_zero_building_number
+
+    @property
+    def is_zero_building_number(self):
+        """Returns if building number is a 0"""
+        return getattr(self, 'building_number', '') == "0"
+
+    @property
+    def sub_name_comma_name(self):
+        """Returns sub-building name and building name concatenated with a comma"""
+        return self._concatenate(['sub_building_name', 'building_name'], ', ')

pypaf-0.4.0/src/paf/version.py

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

{pypaf-0.2.0 → pypaf-0.4.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.2.0 → pypaf-0.4.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.2.0 → pypaf-0.4.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.4.0/tests/test_exception_iv.py

@@ -0,0 +1,100 @@
+"""Test Address Exception IV formatting"""
+
+import unittest
+import paf
+
+class TestExceptionIVUnit(unittest.TestCase):
+    """Test Address Exception IV Unit"""
+
+    def setUp(self):
+        """Set up Address instance"""
+        self.address = paf.Address({
+            'organisation_name': "THE TAMBOURINE WAREHOUSE",
+            'building_name': "UNIT 1-3",
+            'dependent_thoroughfare_name': "INDUSTRIAL",
+            'dependent_thoroughfare_descriptor': "ESTATE",
+            'thoroughfare_name': "TAME",
+            'thoroughfare_descriptor': "ROAD",
+            'post_town': "LONDON",
+            'postcode': "E6 7HS"
+            })
+
+    def test_list(self):
+        """Test conversion to an list"""
+        address = [
+            "THE TAMBOURINE WAREHOUSE",
+            "UNIT 1-3",
+            "INDUSTRIAL ESTATE",
+            "TAME ROAD",
+            "LONDON",
+            "E6 7HS"
+            ]
+        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.address.str(), address, "Incorrect Exception IV Unit string format")
+
+class TestExceptionIVStall(unittest.TestCase):
+    """Test Address Exception IV Stall"""
+
+    def setUp(self):
+        """Set up Address instance"""
+        self.address = paf.Address({
+            'organisation_name': "QUIRKY CANDLES LTD",
+            'building_name': "STALL 4",
+            'thoroughfare_name': "MARKET",
+            'thoroughfare_descriptor': "SQUARE",
+            'post_town': "LIVERPOOL",
+            'postcode': "L8 1LH"
+            })
+
+    def test_list(self):
+        """Test conversion to an list"""
+        address = [
+            "QUIRKY CANDLES LTD",
+            "STALL 4",
+            "MARKET SQUARE",
+            "LIVERPOOL",
+            "L8 1LH"
+            ]
+        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.address.str(), address, "Incorrect Exception IV Stall string format")
+
+class TestExceptionIVRearOf(unittest.TestCase):
+    """Test Address Exception IV Rear Of"""
+
+    def setUp(self):
+        """Set up Address instance"""
+        self.address = paf.Address({
+            'organisation_name': "FIONA'S FLOWERS",
+            'building_name': "REAR OF 5A",
+            'thoroughfare_name': "HIGH",
+            'thoroughfare_descriptor': "STREET",
+            'post_town': "GATESHEAD",
+            'postcode': "NE8 1BH"
+            })
+
+    def test_list(self):
+        """Test conversion to an list"""
+        address = [
+            "FIONA'S FLOWERS",
+            "REAR OF 5A",
+            "HIGH STREET",
+            "GATESHEAD",
+            "NE8 1BH"
+            ]
+        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.address.str(), address, "Incorrect Exception IV RearOf string format")
+
+if __name__ == '__main__':
+    unittest.main()

{pypaf-0.2.0 → pypaf-0.4.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.2.0 → pypaf-0.4.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.2.0 → pypaf-0.4.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.2.0 → pypaf-0.4.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.2.0 → pypaf-0.4.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.2.0 → pypaf-0.4.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.2.0 → pypaf-0.4.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.2.0 → pypaf-0.4.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.4.0/tests/test_rule_7.py

@@ -0,0 +1,91 @@
+"""Test Address Rule 7 formatting"""
+
+import unittest
+import paf
+
+class TestRule7WithZeroBuildingNumber(unittest.TestCase):
+    """Test Address Rule 7 with a 0 Building Number"""
+
+    def setUp(self):
+        """Set up Address instance"""
+        self.address = paf.Address({
+            'sub_building_name': "FLAT 1",
+            'building_name': "HOLLY HOUSE",
+            'building_number': "0",
+            'thoroughfare_name': "OAK",
+            'thoroughfare_descriptor': "AVENUE",
+            'dependent_locality': "BIDDENDEN",
+            'post_town': "ASHFORD",
+            'postcode': "TN27 8BT"
+            })
+
+    def test_list(self):
+        """Test conversion to an list"""
+        address = ["FLAT 1, HOLLY HOUSE", "OAK AVENUE", "BIDDENDEN", "ASHFORD", "TN27 8BT"]
+        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.address.str(), address, "Incorrect Rule 7 with 0 building number format"
+            )
+
+class TestRule7WithSubBuildingName(unittest.TestCase):
+    """Test Address Rule 7 with Sub-Building Name Exception"""
+
+    def setUp(self):
+        """Set up Address instance"""
+        self.address = paf.Address({
+            'sub_building_name': "2B",
+            'building_name': "THE TOWER",
+            'building_number': "27",
+            'thoroughfare_name': "JOHN",
+            'thoroughfare_descriptor': "STREET",
+            'post_town': "WINCHESTER",
+            'postcode': "SO23 9AP"
+            })
+
+    def test_list(self):
+        """Test conversion to an list"""
+        address = ["2B THE TOWER", "27 JOHN STREET", "WINCHESTER", "SO23 9AP"]
+        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.address.str(), address, "Incorrect Rule 7 with sub-building string format"
+            )
+
+class TestRule7(unittest.TestCase):
+    """Test Address Rule 7 without Exception"""
+
+    def setUp(self):
+        """Set up Address instance"""
+        self.address = paf.Address({
+            'sub_building_name': "BASEMENT FLAT",
+            'building_name': "VICTORIA HOUSE",
+            'building_number': "15",
+            'thoroughfare_name': "THE",
+            'thoroughfare_descriptor': "STREET",
+            'post_town': "CORYTON",
+            'postcode': "BP23 6AA"
+            })
+
+    def test_list(self):
+        """Test conversion to an list"""
+        address = ["BASEMENT FLAT", "VICTORIA HOUSE", "15 THE STREET", "CORYTON", "BP23 6AA"]
+        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.address.str(), address, "Incorrect Rule 7 string format")
+
+if __name__ == '__main__':
+    unittest.main()

pypaf-0.2.0/src/paf/__init__.py

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

pypaf-0.2.0/src/paf/version.py

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

pypaf-0.2.0/tests/test_rule_7.py

@@ -1,57 +0,0 @@
-"""Test Paf Rule 7 formatting"""
-
-import unittest
-from paf import Paf
-
-class TestRule7WithSubBuildingName(unittest.TestCase):
-    """Test Paf Rule 7 with Sub-Building Name Exception"""
-
-    def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
-            'sub_building_name': "2B",
-            'building_name': "THE TOWER",
-            'building_number': "27",
-            'thoroughfare_name': "JOHN",
-            'thoroughfare_descriptor': "STREET",
-            'post_town': "WINCHESTER",
-            'postcode': "SO23 9AP"
-            })
-
-    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")
-
-    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")
-
-class TestRule7(unittest.TestCase):
-    """Test Paf Rule 7 without Exception"""
-
-    def setUp(self):
-        """Set up Paf instance"""
-        self.paf = Paf({
-            'sub_building_name': "BASEMENT FLAT",
-            'building_name': "VICTORIA HOUSE",
-            'building_number': "15",
-            'thoroughfare_name': "THE",
-            'thoroughfare_descriptor': "STREET",
-            'post_town': "CORYTON",
-            'postcode': "BP23 6AA"
-            })
-
-    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")
-
-    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")
-
-if __name__ == '__main__':
-    unittest.main()