uk_bin_collection 0.110.0__py3-none-any.whl → 0.112.0__py3-none-any.whl

uk_bin_collection/tests/test_collect_data.py

@@ -4,7 +4,6 @@ import pytest
 from uk_bin_collection.collect_data import UKBinCollectionApp, import_council_module
 
 
-
 # Test UKBinCollectionApp setup_arg_parser
 def test_setup_arg_parser():
     app = UKBinCollectionApp()

uk_bin_collection/tests/test_common_functions.py

@@ -430,8 +430,10 @@ def test_string_with_whitespace_and_numbers():
 )
 def test_get_next_day_of_week(today_str, day_name, expected):
     mock_today = datetime.strptime(today_str, "%Y-%m-%d")
-    with patch('uk_bin_collection.common.datetime') as mock_datetime:  # replace 'your_module' with the actual module name
+    with patch(
+        "uk_bin_collection.common.datetime"
+    ) as mock_datetime:  # replace 'your_module' with the actual module name
         mock_datetime.now.return_value = mock_today
         mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
         result = get_next_day_of_week(day_name, date_format="%m/%d/%Y")
-        assert result == expected
+        assert result == expected

uk_bin_collection/tests/test_conftest.py

@@ -2,26 +2,37 @@ import pytest
 
 # Test the command-line options
 
+
 def test_headless_mode(pytestconfig):
     # Simulate pytest command-line option
     headless_mode_value = pytestconfig.getoption("--headless")
     assert headless_mode_value == "True"  # This should match the default value
 
+
 def test_local_browser(pytestconfig):
     local_browser_value = pytestconfig.getoption("--local_browser")
     assert local_browser_value == "False"  # This should match the default value
 
+
 def test_selenium_url(pytestconfig):
     selenium_url_value = pytestconfig.getoption("--selenium_url")
-    assert selenium_url_value == "http://localhost:4444"  # This should match the default value
+    assert (
+        selenium_url_value == "http://localhost:4444"
+    )  # This should match the default value
+
 
 # Test the fixtures
 
+
 def test_headless_mode_fixture(headless_mode):
     assert headless_mode == "True"  # This should match the default value
 
+
 def test_local_browser_fixture(local_browser):
     assert local_browser == "False"  # This should match the default value
 
+
 def test_selenium_url_fixture(selenium_url):
-    assert selenium_url == "http://localhost:4444"  # This should match the default value
+    assert (
+        selenium_url == "http://localhost:4444"
+    )  # This should match the default value

uk_bin_collection/tests/test_get_data.py

@@ -105,8 +105,10 @@ def test_output_json():
     assert type(output) == str
     assert output == '{\n    "bin": ""\n}'
 
+
 class ConcreteGetBinDataClass(agbdc):
     """Concrete implementation of the abstract class to test abstract methods."""
+
     def parse_data(self, page: str, **kwargs) -> dict:
         return {"mock_key": "mock_value"}
 
@@ -114,33 +116,46 @@ class ConcreteGetBinDataClass(agbdc):
         # You can implement the method or delegate it to the abstract class's method
         super().update_dev_mode_data(council_module_str, this_url, **kwargs)
 
+
 @pytest.fixture
 def concrete_class_instance():
     return ConcreteGetBinDataClass()
 
+
 def test_get_and_parse_data_no_skip_get_url(concrete_class_instance):
     mock_page = "mocked page content"
     mock_parsed_data = {"mock_key": "mock_value"}
 
-    with mock.patch.object(concrete_class_instance, 'get_data', return_value=mock_page) as mock_get_data, \
-         mock.patch.object(concrete_class_instance, 'parse_data', return_value=mock_parsed_data) as mock_parse_data:
-        
+    with mock.patch.object(
+        concrete_class_instance, "get_data", return_value=mock_page
+    ) as mock_get_data, mock.patch.object(
+        concrete_class_instance, "parse_data", return_value=mock_parsed_data
+    ) as mock_parse_data:
+
         result = concrete_class_instance.get_and_parse_data("http://example.com")
 
         mock_get_data.assert_called_once_with("http://example.com")
         mock_parse_data.assert_called_once_with(mock_page, url="http://example.com")
         assert result == mock_parsed_data
 
+
 def test_get_and_parse_data_skip_get_url(concrete_class_instance):
     mock_parsed_data = {"mock_key": "mock_value"}
 
-    with mock.patch.object(concrete_class_instance, 'parse_data', return_value=mock_parsed_data) as mock_parse_data:
-        
-        result = concrete_class_instance.get_and_parse_data("http://example.com", skip_get_url=True)
+    with mock.patch.object(
+        concrete_class_instance, "parse_data", return_value=mock_parsed_data
+    ) as mock_parse_data:
+
+        result = concrete_class_instance.get_and_parse_data(
+            "http://example.com", skip_get_url=True
+        )
 
-        mock_parse_data.assert_called_once_with("", url="http://example.com", skip_get_url=True)
+        mock_parse_data.assert_called_once_with(
+            "", url="http://example.com", skip_get_url=True
+        )
         assert result == mock_parsed_data
-        
+
+
 @pytest.fixture
 def setup_test_update_dev_mode_data():
     """Fixture to set up and tear down the environment for test_update_dev_mode_data"""
@@ -148,7 +163,7 @@ def setup_test_update_dev_mode_data():
     test_dir = tempfile.TemporaryDirectory()
 
     # Patch os.getcwd() to return the temporary directory
-    cwd_patch = patch('os.getcwd', return_value=test_dir.name)
+    cwd_patch = patch("os.getcwd", return_value=test_dir.name)
     mock_getcwd = cwd_patch.start()
 
     # Ensure the nested directory structure exists
@@ -171,15 +186,15 @@ def test_update_dev_mode_data(setup_test_update_dev_mode_data):
     obj = ConcreteGetBinDataClass()
 
     # Define input arguments for the method
-    council_module_str = 'test_council_module'
-    this_url = 'https://example.com'
+    council_module_str = "test_council_module"
+    this_url = "https://example.com"
     kwargs = {
-        'postcode': '12345',
-        'paon': '1A',
-        'uprn': '100012345',
-        'usrn': '200012345',
-        'web_driver': 'mocked_web_driver',
-        'skip_get_url': True,
+        "postcode": "12345",
+        "paon": "1A",
+        "uprn": "100012345",
+        "usrn": "200012345",
+        "web_driver": "mocked_web_driver",
+        "skip_get_url": True,
     }
 
     # Call the method being tested on the instance
@@ -190,8 +205,8 @@ def test_update_dev_mode_data(setup_test_update_dev_mode_data):
     assert os.path.exists(input_file_path)
 
     # Read the contents of the file and make necessary assertions
-    with open(input_file_path, 'r') as f:
+    with open(input_file_path, "r") as f:
         file_content = f.read()
 
     # Example assertion - check if certain values exist in the file content (based on your actual file format)
-    assert '100012345' in file_content  # Checking UPRN as an example
+    assert "100012345" in file_content  # Checking UPRN as an example

uk_bin_collection/uk_bin_collection/common.py

@@ -106,6 +106,7 @@ def get_date_with_ordinal(date_number: int) -> str:
         else {1: "st", 2: "nd", 3: "rd"}.get(date_number % 10, "th")
     )
 
+
 def has_numbers(inputString: str) -> bool:
     """
 

uk_bin_collection/uk_bin_collection/councils/BarnsleyMBCouncil.py

@@ -27,13 +27,14 @@ def parse_bin_text(bin_type_str: str, bin_date_str: str) -> List[Dict[str, str]]
         bin_date = datetime.strptime(bin_date_str, "%A, %B %d, %Y")
 
     for bin_type in bin_type_str.split(", "):
-        bins.append({
-            "type": bin_type.strip() + " bin",
-            "collectionDate": bin_date.strftime(date_format)
-        })
+        bins.append(
+            {
+                "type": bin_type.strip() + " bin",
+                "collectionDate": bin_date.strftime(date_format),
+            }
+        )
 
     return bins
-    
 
 class CouncilClass(AbstractGetBinDataClass):
     """

uk_bin_collection/uk_bin_collection/councils/BasildonCouncil.py

@@ -1,7 +1,10 @@
 import requests
 import json
 from datetime import datetime
-from uk_bin_collection.uk_bin_collection.common import check_uprn, date_format as DATE_FORMAT
+from uk_bin_collection.uk_bin_collection.common import (
+    check_uprn,
+    date_format as DATE_FORMAT,
+)
 from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
 
 
@@ -11,15 +14,15 @@ class CouncilClass(AbstractGetBinDataClass):
     """
 
     def parse_data(self, page: str, **kwargs) -> dict:
-        url_base = "https://basildonportal.azurewebsites.net/api/getPropertyRefuseInformation"
+        url_base = (
+            "https://basildonportal.azurewebsites.net/api/getPropertyRefuseInformation"
+        )
 
         uprn = kwargs.get("uprn")
         # Check the UPRN is valid
         check_uprn(uprn)
 
-        payload = {
-            "uprn": uprn
-        }
+        payload = {"uprn": uprn}
 
         headers = {"Content-Type": "application/json"}
 
@@ -36,7 +39,9 @@ class CouncilClass(AbstractGetBinDataClass):
                 bins.append(
                     {
                         "type": service_name,
-                        "collectionDate": collection_data.get("current_collection_date"),
+                        "collectionDate": collection_data.get(
+                            "current_collection_date"
+                        ),
                     }
                 )
 

uk_bin_collection/uk_bin_collection/councils/ChesterfieldBoroughCouncil.py

@@ -15,6 +15,7 @@ urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
 _LOGGER = logging.getLogger(__name__)
 
+
 class CouncilClass(AbstractGetBinDataClass):
     """
     Implementation for Chesterfield Borough Council waste collection data retrieval.
@@ -56,7 +57,9 @@ class CouncilClass(AbstractGetBinDataClass):
             session.get(API_URLS["session"], headers=HEADERS, verify=False)
 
             # Step 2: Get fwuid
-            fwuid_response = session.get(API_URLS["fwuid"], headers=HEADERS, verify=False)
+            fwuid_response = session.get(
+                API_URLS["fwuid"], headers=HEADERS, verify=False
+            )
             fwuid_data = fwuid_response.json()
             fwuid = fwuid_data.get("auraConfig", {}).get("context", {}).get("fwuid")
 
@@ -66,50 +69,58 @@ class CouncilClass(AbstractGetBinDataClass):
 
             # Step 3: Prepare payload for UPRN search
             payload = {
-                "message": json.dumps({
-                    "actions": [{
-                        "id": "4;a",
-                        "descriptor": "aura://ApexActionController/ACTION$execute",
-                        "callingDescriptor": "UNKNOWN",
-                        "params": {
-                            "namespace": "",
-                            "classname": "CBC_VE_CollectionDays",
-                            "method": "getServicesByUPRN",
-                            "params": {
-                                "propertyUprn": user_uprn,
-                                "executedFrom": "Main Website"
-                            },
-                            "cacheable": False,
-                            "isContinuation": False
-                        }
-                    }]
-                }),
-                "aura.context": json.dumps({
-                    "mode": "PROD",
-                    "fwuid": fwuid,
-                    "app": "c:cbc_VE_CollectionDaysLO",
-                    "loaded": {
-                        "APPLICATION@markup://c:cbc_VE_CollectionDaysLO": "pqeNg7kPWCbx1pO8sIjdLA"
-                    },
-                    "dn": [],
-                    "globals": {},
-                    "uad": True
-                }),
+                "message": json.dumps(
+                    {
+                        "actions": [
+                            {
+                                "id": "4;a",
+                                "descriptor": "aura://ApexActionController/ACTION$execute",
+                                "callingDescriptor": "UNKNOWN",
+                                "params": {
+                                    "namespace": "",
+                                    "classname": "CBC_VE_CollectionDays",
+                                    "method": "getServicesByUPRN",
+                                    "params": {
+                                        "propertyUprn": user_uprn,
+                                        "executedFrom": "Main Website",
+                                    },
+                                    "cacheable": False,
+                                    "isContinuation": False,
+                                },
+                            }
+                        ]
+                    }
+                ),
+                "aura.context": json.dumps(
+                    {
+                        "mode": "PROD",
+                        "fwuid": fwuid,
+                        "app": "c:cbc_VE_CollectionDaysLO",
+                        "loaded": {
+                            "APPLICATION@markup://c:cbc_VE_CollectionDaysLO": "pqeNg7kPWCbx1pO8sIjdLA"
+                        },
+                        "dn": [],
+                        "globals": {},
+                        "uad": True,
+                    }
+                ),
                 "aura.pageURI": "/bins-and-recycling/bin-collections/check-bin-collections.aspx",
                 "aura.token": "null",
             }
 
             # Step 4: Make POST request to fetch collection data
             search_response = session.post(
-                API_URLS["search"],
-                data=payload,
-                headers=HEADERS,
-                verify=False
+                API_URLS["search"], data=payload, headers=HEADERS, verify=False
             )
             search_data = search_response.json()
 
             # Step 5: Extract service units
-            service_units = search_data.get("actions", [])[0].get("returnValue", {}).get("returnValue", {}).get("serviceUnits", [])
+            service_units = (
+                search_data.get("actions", [])[0]
+                .get("returnValue", {})
+                .get("returnValue", {})
+                .get("serviceUnits", [])
+            )
 
             if not service_units:
                 _LOGGER.warning("No service units found for the given UPRN.")
@@ -141,7 +152,9 @@ class CouncilClass(AbstractGetBinDataClass):
 
                 # Extract the next scheduled date
                 try:
-                    dt_zulu = item["serviceTasks"][0]["serviceTaskSchedules"][0]["nextInstance"]["currentScheduledDate"]
+                    dt_zulu = item["serviceTasks"][0]["serviceTaskSchedules"][0][
+                        "nextInstance"
+                    ]["currentScheduledDate"]
                     dt_utc = datetime.strptime(dt_zulu, "%Y-%m-%dT%H:%M:%S.%f%z")
                     dt_local = dt_utc.astimezone(None)
                     collection_date = dt_local.date()

uk_bin_collection/uk_bin_collection/councils/GlasgowCityCouncil.py

@@ -38,7 +38,7 @@ class CouncilClass(AbstractGetBinDataClass):
             for icon in icons:
                 cal_item = icon.find_parent().find_parent()
                 bin_date = datetime.strptime(
-                    cal_item["title"],
+                    cal_item["title"].replace("today is ", ""),
                     "%A, %d %B %Y",
                 )
 

uk_bin_collection/uk_bin_collection/councils/LondonBoroughSutton.py

@@ -0,0 +1,75 @@
+from time import sleep
+
+import requests
+from bs4 import BeautifulSoup
+
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+# import the wonderful Beautiful Soup and the URL grabber
+class CouncilClass(AbstractGetBinDataClass):
+    """
+    Concrete classes have to implement all abstract operations of the
+    base class. They can also override some operations with a default
+    implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+
+        user_uprn = kwargs.get("uprn")
+        # check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        URI = f"https://waste-services.sutton.gov.uk/waste/{user_uprn}"
+
+        s = requests.Session()
+
+        r = s.get(URI)
+        while "Loading your bin days..." in r.text:
+            sleep(2)
+            r = s.get(URI)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.content, "html.parser")
+
+        current_year = datetime.now().year
+        next_year = current_year + 1
+
+        services = soup.find_all("h3", class_="govuk-heading-m waste-service-name")
+
+        for service in services:
+            bin_type = service.get_text(
+                strip=True
+            )  # Bin type name (e.g., 'Food waste', 'Mixed recycling')
+            if bin_type == "Bulky waste":
+                continue
+            service_details = service.find_next("div", class_="govuk-grid-row")
+
+            next_collection = (
+                service_details.find("dt", string="Next collection")
+                .find_next_sibling("dd")
+                .get_text(strip=True)
+            )
+
+            next_collection = datetime.strptime(
+                remove_ordinal_indicator_from_date_string(next_collection),
+                "%A, %d %B",
+            )
+
+            if next_collection.month == 1:
+                next_collection = next_collection.replace(year=next_year)
+            else:
+                next_collection = next_collection.replace(year=current_year)
+
+            dict_data = {
+                "type": bin_type,
+                "collectionDate": next_collection.strftime("%d/%m/%Y"),
+            }
+            bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/MidDevonCouncil.py

@@ -0,0 +1,93 @@
+import time
+
+import requests
+
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+# import the wonderful Beautiful Soup and the URL grabber
+class CouncilClass(AbstractGetBinDataClass):
+    """
+    Concrete classes have to implement all abstract operations of the
+    base class. They can also override some operations with a default
+    implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+
+        user_uprn = kwargs.get("uprn")
+        check_uprn(user_uprn)
+        bindata = {"bins": []}
+
+        SESSION_URL = "https://my.middevon.gov.uk/authapi/isauthenticated?uri=https%253A%252F%252Fmy.middevon.gov.uk%252Fen%252FAchieveForms%252F%253Fform_uri%253Dsandbox-publish%253A%252F%252FAF-Process-2289dd06-9a12-4202-ba09-857fe756f6bd%252FAF-Stage-eb382015-001c-415d-beda-84f796dbb167%252Fdefinition.json%2526redirectlink%253D%25252Fen%2526cancelRedirectLink%253D%25252Fen%2526consentMessage%253Dyes&hostname=my.middevon.gov.uk&withCredentials=true"
+
+        API_URL = "https://my.middevon.gov.uk/apibroker/runLookup"
+
+        payload = {
+            "formValues": {
+                "Your Address": {
+                    "listAddress": {"value": user_uprn},
+                },
+            },
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "Mozilla/5.0",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": "https://my.middevon.gov.uk/fillform/?iframe_id=fillform-frame-1&db_id=",
+        }
+
+        ids = [
+            "6423144f50ec0",
+            "641c7ae9b4c96",
+            "645e13a01dba1",
+            "642315aacb919",
+            "64231699483cf",
+            "642421bab7478",
+            "6424229605d13",
+            "645e14020c9cc",
+        ]
+
+        rows_data = []
+
+        for id in ids:
+            s = requests.session()
+            r = s.get(SESSION_URL)
+            r.raise_for_status()
+            session_data = r.json()
+            sid = session_data["auth-session"]
+
+            params = {
+                "id": id,
+                "repeat_against": "",
+                "noRetry": "false",
+                "getOnlyTokens": "undefined",
+                "log_id": "",
+                "app_name": "AF-Renderer::Self",
+                # unix_timestamp
+                "_": str(int(time.time() * 1000)),
+                "sid": sid,
+            }
+            r = s.post(API_URL, json=payload, headers=headers, params=params)
+            r.raise_for_status()
+            data = r.json()
+            rows_data = data["integration"]["transformed"]["rows_data"]
+            if isinstance(rows_data, dict):
+                date = datetime.strptime(rows_data["0"]["display"], "%d-%b-%y")
+                bin_types = (rows_data["0"]["CollectionItems"]).split(" and ")
+
+                for bin_type in bin_types:
+                    dict_data = {
+                        "type": bin_type,
+                        "collectionDate": date.strftime(date_format),
+                    }
+                    bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

uk_bin_collection/uk_bin_collection/councils/OxfordCityCouncil.py

@@ -0,0 +1,63 @@
+import requests
+from bs4 import BeautifulSoup
+
+from uk_bin_collection.uk_bin_collection.common import *
+from uk_bin_collection.uk_bin_collection.get_bin_data import AbstractGetBinDataClass
+
+
+# import the wonderful Beautiful Soup and the URL grabber
+class CouncilClass(AbstractGetBinDataClass):
+    """
+    Concrete classes have to implement all abstract operations of the
+    base class. They can also override some operations with a default
+    implementation.
+    """
+
+    def parse_data(self, page: str, **kwargs) -> dict:
+
+        user_uprn = kwargs.get("uprn")
+        user_postcode = kwargs.get("postcode")
+        check_uprn(user_uprn)
+        check_postcode(user_postcode)
+        bindata = {"bins": []}
+
+        session_uri = "https://www.oxford.gov.uk/mybinday"
+        URI = "https://www.oxford.gov.uk/xfp/form/142"
+
+        session = requests.Session()
+        token_response = session.get(session_uri)
+        soup = BeautifulSoup(token_response.text, "html.parser")
+        token = soup.find("input", {"name": "__token"}).attrs["value"]
+
+        form_data = {
+            "__token": token,
+            "page": "12",
+            "locale": "en_GB",
+            "q6ad4e3bf432c83230a0347a6eea6c805c672efeb_0_0": user_postcode,
+            "q6ad4e3bf432c83230a0347a6eea6c805c672efeb_1_0": user_uprn,
+            "next": "Next",
+        }
+
+        collection_response = session.post(URI, data=form_data)
+
+        collection_soup = BeautifulSoup(collection_response.text, "html.parser")
+        for paragraph in collection_soup.find("div", class_="editor").find_all("p"):
+            matches = re.match(r"^(\w+) Next Collection: (.*)", paragraph.text)
+            if matches:
+                collection_type, date_string = matches.groups()
+                try:
+                    date = datetime.strptime(date_string, "%A %d %B %Y").date()
+                except ValueError:
+                    date = datetime.strptime(date_string, "%A %d %b %Y").date()
+
+                dict_data = {
+                    "type": collection_type,
+                    "collectionDate": date.strftime("%d/%m/%Y"),
+                }
+                bindata["bins"].append(dict_data)
+
+        bindata["bins"].sort(
+            key=lambda x: datetime.strptime(x.get("collectionDate"), "%d/%m/%Y")
+        )
+
+        return bindata

{uk_bin_collection-0.110.0.dist-info → uk_bin_collection-0.112.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: uk_bin_collection
-Version: 0.110.0
+Version: 0.112.0
 Summary: Python Lib to collect UK Bin Data
 Author: Robert Bradley
 Author-email: robbrad182@gmail.com