warn-scraper 1.2.154.dev0__py3-none-any.whl → 1.2.155.dev0__py3-none-any.whl

warn/pdfrodent/pdfrodent.py

@@ -1,6 +1,6 @@
-import json
 import logging
 import re
+from pathlib import Path
 
 import camelot  # pip install camelot-py==1.0.9 for now
 
@@ -178,7 +178,7 @@ We probably want code that tells us what PDF this is pulled from, on which row.
 """
 
 
-def parse_pdf(pdffile: str, field_fixes: dict | None = None):
+def parse_pdf(pdffile: str | Path, field_fixes: dict | None = None):
     """Parse a PDF file to extract data from tables.
 
     Args:
@@ -227,7 +227,7 @@ def parse_pdf(pdffile: str, field_fixes: dict | None = None):
                     patchedheaders.append(field_fixes[item])
                 else:
                     logger.debug(
-                        f"New header type found: {item}, not in {' '.join(sorted(list(field_fixes.keys())))}"
+                        f"New header type found: {item}, not in field_fixes: '{' '.join(sorted(list(field_fixes.keys())))}'"
                     )
                     patchedheaders.append(item)
             orphanholder = {
@@ -257,7 +257,7 @@ def parse_pdf(pdffile: str, field_fixes: dict | None = None):
                             patchedheaders.append(field_fixes[item])
                         else:
                             logger.debug(
-                                f"New header type found: {item}, not in {' '.join(sorted(list(field_fixes.keys())))}"
+                                f"New header type found: {item}, not in field_fixes: '{' '.join(sorted(list(field_fixes.keys())))}'"
                             )
                             patchedheaders.append(item)
                     headerfirst = patchedheaders
@@ -286,7 +286,7 @@ def parse_pdf(pdffile: str, field_fixes: dict | None = None):
                             isheader = False
                             orphanedheader = False
 
-                    else:  # seenheader
+                    else:  # seendata
                         if isheader:  # Supplement to a header on a latter page
                             filerowholder.append(
                                 "\tMostly empty row, seems to be appending to a header"
@@ -325,6 +325,7 @@ def parse_pdf(pdffile: str, field_fixes: dict | None = None):
                                     locallist[-1][
                                         fieldname
                                     ] = cleancell  # Add it to the previous line
+                                    locallist[-1]["_int_raw_fields"].extend(row)
                         isheader = False
 
                 else:
@@ -341,16 +342,18 @@ def parse_pdf(pdffile: str, field_fixes: dict | None = None):
                     for cellindex, cell in enumerate(row):
                         line[headerfirst[cellindex]] = clean_cell(cell)
                     filerowholder.append(f"\t\t{line}")
+                    line["_int_raw_fields"] = row
                     locallist.append(line)
 
             report = table.parsing_report
 
             for lineindex, line in enumerate(locallist):
                 line["_int_accuracy"] = report["accuracy"]
-                line["_int_pdf_filename"] = pdffile.split("/")[-1].split("\\")[-1]
+                line["_int_pdf_filename"] = str(pdffile).split("/")[-1].split("\\")[-1]
                 line["_int_page"] = report["page"]
                 line["_int_table_number"] = report["order"]
-                line["_int_raw_fields"] = json.dumps(list(line.values()))
+                # line["_int_raw_fields"] = row    # HEY! Need to handle for supplemented lines
+                # line["_int_raw_fields"] = json.dumps(list(line.values()))
                 line["_int_data_items"] = count_data_items(line)  # type: ignore
                 if "Event Number" in line:
                     line["Event Number"] = line["Event Number"].replace("\n", "")

warn/scrapers/la.py

@@ -1,12 +1,13 @@
+import json
 import logging
 import os
 import re
-from datetime import datetime
 from pathlib import Path
 
-import pdfplumber
 from bs4 import BeautifulSoup
 
+from warn.pdfrodent import pdfrodent as pdfrodent
+
 from .. import utils
 from ..cache import Cache
 
@@ -19,6 +20,8 @@ __source__ = {
 
 logger = logging.getLogger(__name__)
 
+want_debugging_file = True
+
 
 def scrape(
     data_dir: Path = utils.WARN_DATA_DIR,
@@ -41,6 +44,55 @@ def scrape(
     base_url = "https://www.laworks.net/"
     file_base = "Downloads_WFD"
 
+    headerfixes = {
+        "Company Name": "company_original",
+        "Notice Date": "date_notice",
+        "Layoff Date": "date_action",
+        "Employees Affected": "affected",
+        "supplement_0": "notes",
+        "Address": "address_original",
+    }
+
+    ignore = """
+    # First handle the older files, if needed
+    pdffiles = sorted(cache.files(subdir="la/", glob_pattern="*.pdf"))
+    historicalneeded = False
+    historicalfiles = []
+    for myyear in range(2007, 2023 + 1):
+        targeturl = f"https://www.laworks.net/Downloads/WFD/WarnNotices{myyear}.pdf"
+        targetfilename = str(cache_dir / "la"/targeturl.split("/")[-1])
+        historicalfiles.append(targetfilename)
+        if targetfilename not in pdffiles:
+            logger.debug(f"Missing {targetfilename} from collection of {' ... '.join(pdffiles)}")
+            filebin, filehtml = utils.get_with_zyte(targeturl)
+            cache.write_binary(targetfilename, filebin)
+            historicalneeded = True
+
+    if historicalneeded:
+        logger.debug(f"Need to process historical records")
+        historicallist = []
+        historicaldebug = []
+        for historicalfile in historicalfiles:
+            locallist, localdebug = pdfrodent.parse_pdf(historicalfile, headerfixes)
+            historicallist.extend(locallist)
+            historicaldebug.extend(localdebug)
+
+        with open(Path(cache_dir) / "la/historical.json", "w") as outfile:
+            outfile.write(json.dumps(historicallist), indent=4*" ")
+
+        if want_debugging_file:
+            with open(Path(cache_dir) / "la/debugging-historical.txt", "w") as outfile:
+                for row in historicaldebug:
+                    outfile.write(json.dumps(row) + "\r\n")
+    else:
+        logger.debug(f"No historical data missing.")
+
+    logger.debug(f"Fetching historical data")
+    with open(Path(cache_dir) / "la/historical.json", "r") as infile:
+        historicallist = json.loads(infile)
+    logger.debug(f"{len(historicallist):,} historical items imported.")
+    """
+
     # Download the root page
     url = f"{base_url}Downloads/{file_base}.asp"
     htmlbin, html = utils.get_with_zyte(url)
@@ -54,7 +106,8 @@ def scrape(
     document = BeautifulSoup(html, "html.parser")
     links = document.find_all("a")
 
-    all_rows = []
+    masterlist = []
+    fulldebug = []
 
     for link in links:
         if "WARN Notices" in link.text:
@@ -68,405 +121,76 @@ def scrape(
 
             # Process the PDF
             logger.debug(f"Attempting to parse {pdf_path}")
-            rows = _process_pdf(pdf_path)
-            all_rows.extend(rows)
-
-    # Insert a header row with clean column names.
-    # We are here assuming that the columns don't change between years
-    # and that one that contains "Employees Affected" will be clean.
-    output_rows = [list(filter(_is_clean_header, all_rows))[0]] + list(
-        filter(lambda row: not _is_header(row), all_rows)
-    )
-
-    # Write out to CSV
-    data_path = data_dir / f"{state_code}.csv"
-    utils.write_rows_to_csv(data_path, output_rows)
-
-    # Return the path
-    return data_path
-
-
-def _append_contents_to_cells_in_row_above(rows: list, index: int, row: list) -> list:
-    """
-    Append the contents of a row to the contents of the cell above it.
-
-    Keyword arguments:
-    index -- the index of the row
-    row -- the row to check
-    rows -- the rows to append to
-    """
-    for column_index, cell in enumerate(row):
-        if _cell_above_exists(column_index, rows):
-            rows[len(rows) - 1][column_index].extend(cell)
-    return rows
-
-
-def _append_contents_to_row_from_row_above(rows: list, index: int, row: list) -> list:
-    """
-    Append the contents of preceding row to a largely empty row.
-
-    Keyword arguments:
-    index -- the index of the row
-    row -- the row to amend
-    rows -- list of rows that includes the final row to pull from
-    """
-    for column_index, cell in enumerate(row):
-        if _cell_above_exists(column_index, rows):
-            if len(cell) == 0:
-                row[column_index] = rows[len(rows) - 1][column_index]
-    return row
-
-
-def _cell_above_exists(column_index: int, rows: list) -> bool:
-    """
-    Return True if the cell above the current cell exists.
-
-    Keyword arguments:
-    column_index -- the index of the column
-    rows -- the rows to check
-    """
-    return column_index < len(rows[len(rows) - 1])
-
-
-def _has_rows(rows: list) -> bool:
-    """
-    Determine if the table has rows.
-
-    Keyword arguments:
-    rows -- the rows to check
-
-    Returns: True if the table has rows, False otherwise
-    """
-    return len(rows) > 0
-
-
-def _is_first(index: int) -> bool:
-    """
-    Determine if a row is the first row in a table.
-
-    Keyword arguments:
-    index -- the index of the row
-
-    Returns: True if the row is the first row in a table, False otherwise
-    """
-    return index == 0
-
-
-def _is_mostly_empty(row: list) -> bool:
-    """
-    Check if a row has few populated cells. Used to determine if carried over from a previous page.
-
-    Keyword arguments:
-    row -- the row to check
-
-    Returns: True if the row is mostly empty, False otherwise
-    """
-    return len(list(filter(pdfplumber.utils.extract_text, row))) <= 2
-
-
-def _process_pdf(pdf_path) -> list:
-    """
-    Process a PDF file.
-
-    Keyword arguments:
-    pdf_path -- the path to the PDF file
-
-    Returns: a list of rows
-    """
-    output_rows: list = []
-
-    with pdfplumber.open(pdf_path) as pdf:
-        for page in pdf.pages:
-            for table in page.debug_tablefinder().tables:
-                for index, row in enumerate(table.rows):
-                    cells = row.cells
-                    cells = [_extract_cell_chars(page, cell) for cell in cells]
-
-                    # If the first row in a table is mostly empty,
-                    # append its contents to the previous row
-                    if (
-                        _is_first(index)
-                        and _is_mostly_empty(cells)
-                        and _has_rows(output_rows)
-                    ):
-                        output_rows = _append_contents_to_cells_in_row_above(
-                            output_rows, index, cells
-                        )
-                    # Otherwise, if a row is mostly empty, pull data into blank cells and add current row
-                    elif _is_mostly_empty(cells):
-                        cells = _append_contents_to_row_from_row_above(
-                            output_rows, index, cells
-                        )
-                        output_rows.append(cells)
-                    # Otherwise, append the row
-                    else:
-                        output_rows.append(cells)
-
-    return _clean_rows(output_rows)
-
-
-def _clean_rows(rows):
-    """
-    Clean up rows.
-
-    Keyword arguments:
-    rows -- the rows to clean
-
-    Returns: the cleaned rows
-    """
-    output_rows = []
-
-    for row in rows:
-        output_row = []
-        for column_index, chars in enumerate(row):
-            text = _clean_text(pdfplumber.utils.extract_text(chars))
-
-            # If we're on the first column, try to extract location and notes
-            if _is_first(column_index):
-                # Tries to extract a company name, appends it to the row
-                company_name = _extract_company_name(chars)
-                output_row.append(company_name)
-                remaining_text = text.replace(company_name, "")
-
-                # Tries to extract a note, typically UPDATE or WARN RESCINDED
-                note = _extract_note(chars).strip()
-
-                # Whatever is left is assumbed to be the location
-                location = remaining_text.strip().replace(note, "")
-
-                # Append the location and note to the row or headers for those
-                if _is_header(output_row):
-                    output_row.append("Location")
-                    output_row.append("Note")
-                else:
-                    output_row.append(location)
-                    output_row.append(note)
-            else:
-                # Appends the remaining text to the row
-                output_row.append(text)
-
-        output_rows.append(output_row)
-
-    return output_rows
-
-
-def _extract_cell_chars(page, bbox):
-    """
-    Extract the characters from a cell.
-
-    Keyword arguments:
-    page -- the page from which to extract the characters
-    bbox -- the bounding box of the cell
-
-    Returns: a list of characters
-    """
-    # If the bounding box is empty, append an empty list
-    if bbox is None:
-        return []
-
-    # Expand the bounding box to ensure it encompasses the bottom line of text
-    vertical_threshold = 5
-    expanded_bbox = _vertically_expand_bounding_box(bbox, vertical_threshold)
-
-    # Get the characters from the cell
-    return page.within_bbox(expanded_bbox).chars
-
-
-def _vertically_expand_bounding_box(bbox, increase):
-    """
-    Expand the bounding box by a given amount in the vertical direction.
-
-    Keyword arguments:
-    bbox -- the bounding box to expand
-    increase -- the amount to expand the bounding box
-
-    Returns: the expanded bounding box
-    """
-    return (
-        bbox[0],
-        bbox[1],
-        bbox[2],
-        bbox[3] + increase,
-    )
-
-
-def _read_or_download(cache: Cache, prefix: str, url: str) -> Path:
-    """
-    Read a file from the cache or downloads it.
-
-    Keyword arguments:
-    cache -- the cache to use
-    prefix -- the prefix to use for the cache key
-    url -- the URL to download
-
-    Returns: the path to the file
-    """
-    file_name = os.path.basename(url)
-    cache_key = f"{prefix}/{file_name}"
-
-    exists = cache.exists(cache_key)
-    year = _extract_year(file_name)
-    current_year = datetime.now().year
-
-    # Form a file path so we can read from the cache
-    if exists and year < current_year - 1:
-        return cache.path / cache_key
-
-    return cache.download(cache_key, url)
-
-
-def _extract_year(text: str) -> int:
-    """
-    Extract the year from a PDF file name.
-
-    Keyword arguments:
-    text -- the text to extract the year from
-
-    Returns: the year
-    """
-    year_pattern = re.compile(r"\d{4}", re.IGNORECASE)
-    year = re.search(year_pattern, text)
-
-    if year is not None:
-        return int(year.group(0))
-    else:
-        raise Exception(f"Could not extract year from {text}")
-
-
-def _is_header(row: list) -> bool:
-    """
-    Determine if a row is a header row.
-
-    Keyword arguments:
-    row -- the row to check
-
-    Returns: True if the row is a header row, False otherwise
-    """
-    return row[0].strip().lower() == "company name"
-
-
-def _is_clean_header(row: list) -> bool:
-    """
-    Return true for a header with a clean column name.
-
-    Keyword arguments:
-    row -- the rows to check
-
-    Returns: true if the row is a clean header
-    """
-    return _is_header(row) and "Employees Affected" in row
-
-
-def _extract_note(chars) -> str:
-    """
-    Extract a note from a PDF cell.
-
-    Keyword arguments:
-    chars -- the characters to extract the note from
+            locallist, localdebug = pdfrodent.parse_pdf(pdf_path, headerfixes)
+            masterlist.extend(locallist)
+            fulldebug.extend(localdebug)
 
-    Returns: the note
-    """
-    text = pdfplumber.utils.extract_text(chars)
-
-    # Split text into lines
-    lines = text.split("\n")
-
-    notes = []
-
-    for line in lines:
-        note_pattern = r"((UPDATE.*|WARN RESCINDED))+"
-        note = re.search(note_pattern, line, re.IGNORECASE)
-        if note:
-            notes.append(_clean_text(note[0]))
-
-    return " ".join(notes)
-
-
-def _extract_company_name(chars) -> str:
-    """
-    Extract the company name from a PDF cell.
-
-    Keyword arguments:
-    chars -- the characters to extract the company name from
+    # Earlier versions assumed headers were the same. Let's not do that.
+    # Identify all header elements, even in the ones we're about to remove.
+    allheaders = set()
 
-    Returns: the company name
+    ignore += """
+    logger.debug(f"Folding in historical data")
+    masterlist.extend(historicallist)
     """
-    text = pdfplumber.utils.extract_text(chars)
+    if ignore:
+        logger.debug("Historical PDFs are not available to be incorporated.")
 
-    # Split text into lines
-    lines = text.split("\n")
+    # Add a couple columns we're sort of missing
+    for rowindex, row in enumerate(masterlist):
+        if "address_original" in row:
+            masterlist[rowindex]["address"] = row["address_original"]
+            masterlist[rowindex]["company"] = row["company_original"]
+            # " ".join(row["_int_raw_fields"][0].split("\n")[0])
 
-    # We're assuming first line is always part of a company name
-    company_name = _clean_text(lines[0])
-
-    # Try to extract bold text in the cell
-    bold_text = _clean_text(_extract_bold_text(chars))
-    remaining_bold_text = bold_text.replace(company_name, "").strip()
-
-    # Loop through all but first and last lines
-    for index, line in enumerate(lines[1:-1]):
-        line_text = _clean_text(line)
-
-        # If line is bolded or doesn't match a pattern
-        # it's probably part of the company name
-        if remaining_bold_text.startswith(line_text) or (
-            bold_text == "" and index < 1 and not _is_location(line_text)
-        ):
-            company_name += f" {line_text}"
-
-            remaining_bold_text = remaining_bold_text.replace(line_text, "").strip()
-        # The first time we hit a line that doesn't match our expectations,
-        # we assume we've reached the end of the company name
         else:
-            break
-
-    return company_name
-
-
-def _is_location(text) -> bool:
-    """
-    Determine if text is likely to be a location.
-
-    Keyword arguments:
-    text -- the text to check
-
-    Returns: True if the text is likely to be a location, False otherwise
-    """
-    location_pattern = r"(^\d+|Highway|Hwy|Offshore|Statewide)"
-    return re.match(location_pattern, text, re.IGNORECASE) is not None
-
-
-def _extract_bold_text(chars) -> str:
-    """
-    Extract the bold text from a PDF cell.
-
-    Keyword arguments:
-    chars -- the list of characters in the cell
-
-    Returns: the bold text
-    """
-    bold_chars = [char["text"] for char in chars if "Bold" in char["fontname"]]
-    bold_text = "".join(bold_chars)
-    return bold_text
-
-
-def _clean_text(text) -> str:
-    """
-    Clean up text from a PDF cell.
-
-    Keyword arguments:
-    text -- the text to clean
-
-    Returns: the cleaned text
-    """
-    # Replace None with an empty string
-    if text is None:
-        return ""
-
-    # Standardize whitespace
-    clean_text = re.sub(r"\s+", " ", text).strip()
-
-    return clean_text
+            firstcell = row["_int_raw_fields"][0]
+            # Let's assume that in most cases the address begins on a new line with a number.
+            # In those cases, stuff from before that will be the company name.
+            # Stuff beginning with the number but not the new line will be the address.
+
+            # In other cases, we'll have to assume the first line is the company name
+            # and stuff on subsequent lines is the address.
+
+            if re.findall(r"(\n\d+)", firstcell, re.MULTILINE):
+                mysplit = re.findall(r"(\n\d+)", firstcell, re.MULTILINE)[0].replace(
+                    "\n", ""
+                )
+                masterlist[rowindex]["company"] = (
+                    firstcell.split(mysplit)[0].strip().replace("\n", ", ")
+                )
+                masterlist[rowindex]["address"] = (
+                    mysplit
+                    + " "
+                    + mysplit.join(firstcell.split(mysplit)[1:]).replace("\n", ", ")
+                )
+            else:
+                masterlist[rowindex]["company"] = row["_int_raw_fields"][0].split("\n")[
+                    0
+                ]
+                masterlist[rowindex]["address"] = ", ".join(
+                    row["_int_raw_fields"][0].split("\n")[1:]
+                )
+
+    for row in masterlist:
+        for item in row:
+            allheaders.add(item)
+    text = ""
+    for item in sorted(allheaders):
+        text += f"\t\t'{item}': ,\n"
+    with open(Path(cache_dir) / "la/allheaders.txt", "w") as outfile:
+        outfile.write(text)
+
+    if want_debugging_file:
+        with open(Path(cache_dir) / "la/debugging.txt", "w") as outfile:
+            for row in fulldebug:
+                outfile.write(json.dumps(row) + "\r\n")
+
+    targetfilename = data_dir / f"{state_code}.csv"
+    logger.debug(f"Writing {len(masterlist):,} rows of data to {targetfilename}")
+    utils.write_disparate_dict_rows_to_csv(targetfilename, masterlist)
+
+    return targetfilename
 
 
 if __name__ == "__main__":

warn/utils.py

@@ -144,7 +144,7 @@ def get_with_zyte(url, json_extras=None):
         returnbin = returntext.encode("utf-8")
         # returnbin = bin(returntext)
     else:
-        returnbin: bytes = b64decode(api_response.json()["httpResponseBody"])
+        returnbin: bytes = bytes(b64decode(api_response.json()["httpResponseBody"]))
         returntext: str = returnbin.decode("utf-8", errors="backslashreplace")
     logger.debug(f"Fetched {url}")
     return (returnbin, returntext)

{warn_scraper-1.2.154.dev0.dist-info → warn_scraper-1.2.155.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: warn-scraper
-Version: 1.2.154.dev0
+Version: 1.2.155.dev0
 Summary: Command-line interface for downloading WARN Act notices of qualified plant closings and mass layoffs from state government websites
 Author-email: Big Local News <biglocalnews@stanford.edu>
 License-Expression: Apache-2.0

{warn_scraper-1.2.154.dev0.dist-info → warn_scraper-1.2.155.dev0.dist-info}/RECORD

@@ -2,9 +2,9 @@ warn/__init__.py,sha256=A07JFY1TyaPtVIndBa7IvTk13DETqIkLgRdk0A-MCoE,85
 warn/cache.py,sha256=QBSHycchvRTkOQfHptOtZeTYiPgLP383jS8MTiGln_c,5969
 warn/cli.py,sha256=ZqyJwICdHFkn2hEgbArj_upbElR9-TSDlYDqyEGeexE,2019
 warn/runner.py,sha256=oeGRybGwpnkQKlPzRMlKxhsDt1GN4PZoX-vUwrsPgos,1894
-warn/utils.py,sha256=-JF8DnSg-80CbCIswM-rtB0CWf9zSVU56iJNpRw3V-o,13086
+warn/utils.py,sha256=h1V5IISj9c2REtNnGctp0JqVjCi_Mi0r_FlvzNlrKb0,13093
 warn/pdfrodent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-warn/pdfrodent/pdfrodent.py,sha256=IajvUyzVuUlph7F3LqaPU0HxDCkHb8YfnP1js4vOoTs,14632
+warn/pdfrodent/pdfrodent.py,sha256=S2LXkKOdP0Jqzcg10hzGijTu83TMS72DzZqQceslJ70,14914
 warn/platforms/__init__.py,sha256=wIZRDf4tbTuC8oKM4ZrTAtwNgbtMQGzPXMwDYCFyrog,81
 warn/platforms/job_center/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 warn/platforms/job_center/cache.py,sha256=yhA3sE46lNFg8vEewSoRYVByi0YSlkBiKm7qoSUiTdM,1868
@@ -29,7 +29,7 @@ warn/scrapers/il.py,sha256=sygdvsNuB_Gvu3o_HidtpSP4FLz0szKb1zEHqGxVtlI,1563
 warn/scrapers/in.py,sha256=0hOCdbUyls3xX7Q1z5OB6yCrXJFpsu2CmvfwRh9NTfY,2202
 warn/scrapers/ks.py,sha256=F_3biEMF7zgCX2XVuUACR74Vyzapta4SaM9SY3EuZCU,1266
 warn/scrapers/ky.py,sha256=7kJTNOzxChyXlcyBImmdwwmrczYksU8XNxbhQ2owmJs,9688
-warn/scrapers/la.py,sha256=ORkMOQErl33SEiagOli4agDLdTt0R1MxxBmqOg3hNv8,13175
+warn/scrapers/la.py,sha256=52i7ICYH0R7omFyu-kmKi_s-8Rhy0vaPjNIKlW_OMC8,6938
 warn/scrapers/md.py,sha256=hwgxXQnhyBWm8qF1dvxIThAX1MkrZbXLwRI9inO5t8g,4060
 warn/scrapers/me.py,sha256=q36F4yJ7hvZsLayA3uBS1romo4X3Qf-sEi2Y7LAQCi8,1172
 warn/scrapers/mi.py,sha256=Ppyawp4nbzSBODuzDKeqnO9_9do5MFwK4Y_f3uc6blE,5846
@@ -54,9 +54,9 @@ warn/scrapers/va.py,sha256=7Nle7qL0VNPiE653XyaP9HQqSfuJFDRr2kEkjOqLvFM,11269
 warn/scrapers/vt.py,sha256=d-bo4WK2hkrk4BhCCmLpEovcoZltlvdIUB6O0uaMx5A,1186
 warn/scrapers/wa.py,sha256=UXdVtHZo_a-XfoiyOooTRfTb9W3PErSZdKca6SRORgs,4282
 warn/scrapers/wi.py,sha256=ClEzXkwZbop0W4fkQgsb5oHAPUrb4luUPGV-jOKwkcg,4855
-warn_scraper-1.2.154.dev0.dist-info/licenses/LICENSE,sha256=ZV-QHyqPwyMuwuj0lI05JeSjV1NyzVEk8Yeu7FPtYS0,585
-warn_scraper-1.2.154.dev0.dist-info/METADATA,sha256=OtXPhDRnhpTYB_lgZY3y35ZY6IKTYZkZcTFtQeCmaf0,1780
-warn_scraper-1.2.154.dev0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-warn_scraper-1.2.154.dev0.dist-info/entry_points.txt,sha256=poh_oSweObGlBSs1_2qZmnTodlOYD0KfO7-h7W2UQIw,47
-warn_scraper-1.2.154.dev0.dist-info/top_level.txt,sha256=dZfms6N3kqVXufiPOo7YqOrAcUtYfNH_oyGvYUk9FB4,5
-warn_scraper-1.2.154.dev0.dist-info/RECORD,,
+warn_scraper-1.2.155.dev0.dist-info/licenses/LICENSE,sha256=ZV-QHyqPwyMuwuj0lI05JeSjV1NyzVEk8Yeu7FPtYS0,585
+warn_scraper-1.2.155.dev0.dist-info/METADATA,sha256=Vz4NRjIMPAx1mNm6337Va3PAEhD4Zd4VTNeiGBumCG0,1780
+warn_scraper-1.2.155.dev0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+warn_scraper-1.2.155.dev0.dist-info/entry_points.txt,sha256=poh_oSweObGlBSs1_2qZmnTodlOYD0KfO7-h7W2UQIw,47
+warn_scraper-1.2.155.dev0.dist-info/top_level.txt,sha256=dZfms6N3kqVXufiPOo7YqOrAcUtYfNH_oyGvYUk9FB4,5
+warn_scraper-1.2.155.dev0.dist-info/RECORD,,