Пример #1
0
    def connect_parse_data(self) -> pd.Series:
        op = Options()
        op.add_argument("--headless")

        with webdriver.Chrome(options=op) as driver:
            driver.get(self.source_url)
            time.sleep(5)

            total_vaccinations = clean_count(
                driver.find_element_by_id("counter1").text)
            total_boosters = clean_count(
                driver.find_element_by_id("counter4").text)
            # people_vaccinated_share = driver.find_element_by_id("counter4").text
            # assert "One dose" in people_vaccinated_share
            # people_fully_vaccinated_share = driver.find_element_by_id("counter4a").text
            # assert "Two doses" in people_fully_vaccinated_share

        # This logic is only valid as long as Qatar *exclusively* uses 2-dose vaccines
        # people_vaccinated_share = float(re.search(r"[\d.]+", people_vaccinated_share).group(0))
        # people_fully_vaccinated_share = float(re.search(r"[\d.]+", people_fully_vaccinated_share).group(0))
        # vaccinated_proportion = people_vaccinated_share / (people_vaccinated_share + people_fully_vaccinated_share)
        # people_vaccinated = round(total_vaccinations * vaccinated_proportion)
        # people_fully_vaccinated = total_vaccinations - people_vaccinated

        date = localdate("Asia/Qatar")

        data = {
            "total_vaccinations": total_vaccinations,
            "total_boosters": total_boosters,
            # "people_vaccinated": people_vaccinated,
            # "people_fully_vaccinated": people_fully_vaccinated,
            "date": date,
        }
        return pd.Series(data=data)
Пример #2
0
def read(source: str) -> pd.Series:
    op = Options()
    op.add_argument("--headless")

    with webdriver.Chrome(options=op) as driver:
        driver.get(source)
        time.sleep(3)

        for h5 in driver.find_elements_by_tag_name("h5"):

            if "Primera dosis" in h5.text:
                people_vaccinated = clean_count(
                    h5.find_element_by_xpath("./preceding-sibling::div").text)

            elif "Total dosis aplicadas" in h5.text:
                total_vaccinations = clean_count(
                    h5.find_element_by_xpath("./preceding-sibling::div").text)

            elif "Población completamente vacunada" in h5.text:
                people_fully_vaccinated = clean_count(
                    h5.find_element_by_xpath("./preceding-sibling::div").text)

            elif "Dosis refuerzo" in h5.text:
                total_boosters = clean_count(
                    h5.find_element_by_xpath("./preceding-sibling::div").text)

    data = {
        "date": localdate("America/Santo_Domingo"),
        "people_vaccinated": people_vaccinated,
        "people_fully_vaccinated": people_fully_vaccinated,
        "total_vaccinations": total_vaccinations,
        "total_boosters": total_boosters,
    }
    return pd.Series(data=data)
Пример #3
0
def _export_log_info(df_exec, t_sec_1, t_sec_2):
    # print(len(df_new), len(MODULES_NAME), len(df_new) == len(MODULES_NAME))
    if len(df_exec) == len(MODULES_NAME):
        print("EXPORTING LOG DETAILS")
        details = system_details()
        date_now = localdate(force_today=True)
        machine = details["id"]
        # Export timings per country
        df_exec = df_exec.reset_index().assign(date=date_now, machine=machine)
        df = obj_from_s3(LOG_GET_COUNTRIES)
        df = df[df.date + df.machine != date_now + machine]
        df = pd.concat([df, df_exec])
        obj_to_s3(df, LOG_GET_COUNTRIES)
        # Export machine info
        data = obj_from_s3(LOG_MACHINES)
        if machine not in data:
            data = {**details, machine: details["info"]}
            obj_to_s3(data, LOG_MACHINES)
        # Export overall timing
        report = {
            "machine": machine,
            "date": date_now,
            "t_sec": t_sec_1,
            "t_sec_retry": t_sec_2
        }
        df_new = pd.DataFrame([report])
        df = obj_from_s3(LOG_GET_GLOBAL)
        df = df[df.date + df.machine != date_now + machine]
        df = pd.concat([df, df_new])
        obj_to_s3(df, LOG_GET_GLOBAL)
Пример #4
0
 def _parse_date(self, soup):
     match = re.search(self.regex["title"], soup.text)
     date_str = match.group(1)
     date = clean_date(f"{date_str} {datetime.now().year}", "%d de %B %Y", lang="es")
     if date > localdate("America/Havana", force_today=True):
         date = clean_date(f"{date_str} {datetime.now().year-1}", "%d de %b %Y", lang="es")
     return date
Пример #5
0
 def _parse_data(self) -> pd.Series:
     data = request_json(self.source_url)["stats"]
     data = pd.DataFrame.from_records(data, columns=["tested"]).iloc[0]
     return {
         "count": clean_count(data[0]),
         "date": localdate("Atlantic/Faeroe"),
     }
Пример #6
0
def main():
    path = os.path.join(get_project_dir(), "scripts", "scripts", "testing",
                        "automated_sheets", "Azerbaijan.csv")
    data = pd.read_csv(path).sort_values(by="Date", ascending=False)

    source_url = "https://koronavirusinfo.az/az/page/statistika/azerbaycanda-cari-veziyyet"

    soup = get_soup(source_url)

    element = soup.find_all("div",
                            class_="gray_little_statistic")[5].find("strong")
    cumulative_total = clean_count(element.text)

    if cumulative_total > data["Cumulative total"].max():
        new = pd.DataFrame({
            "Cumulative total":
            cumulative_total,
            "Date": [localdate("Asia/Baku")],
            "Country":
            "Azerbaijan",
            "Units":
            "tests performed",
            "Source URL":
            source_url,
            "Source label":
            "Cabinet of Ministers of Azerbaijan",
        })

        df = pd.concat([new, data], sort=False)
        df.to_csv(path, index=False)
Пример #7
0
def main():
    path = os.path.join(get_project_dir(), "scripts", "scripts", "testing",
                        "automated_sheets", "Nigeria.csv")
    data = pd.read_csv(path).sort_values(by="Date", ascending=False)

    source_url = "http://covid19.ncdc.gov.ng/"

    soup = get_soup(source_url)

    element = soup.find("div", class_="col-xl-3").find("span")
    cumulative_total = clean_count(element.text)

    if cumulative_total > data["Cumulative total"].max():

        new = pd.DataFrame({
            "Date": [localdate("Africa/Lagos")],
            "Cumulative total":
            cumulative_total,
            "Country":
            "Nigeria",
            "Units":
            "samples tested",
            "Source URL":
            source_url,
            "Source label":
            "Nigeria Centre for Disease Control",
        })

        df = pd.concat([new, data], sort=False)
        df.to_csv(path, index=False)
Пример #8
0
def connect_parse_data(source: str) -> pd.Series:

    soup = get_soup(source)

    counters = soup.find_all(class_="elementor-counter-number")
    assert len(counters) == 6, "New counter in dashboard?"

    total_vaccinations = clean_count(counters[0]["data-to-value"])
    first_doses = clean_count(counters[1]["data-to-value"])
    second_doses = clean_count(counters[2]["data-to-value"])
    unique_doses = clean_count(counters[3]["data-to-value"])
    booster_shots = clean_count(counters[4]["data-to-value"])
    immunocompromised_doses = clean_count(counters[5]["data-to-value"])

    people_vaccinated = first_doses + unique_doses
    people_fully_vaccinated = second_doses + unique_doses
    total_boosters = booster_shots + immunocompromised_doses

    date = localdate("America/Jamaica")

    return pd.Series(
        data={
            "total_vaccinations": total_vaccinations,
            "people_vaccinated": people_vaccinated,
            "people_fully_vaccinated": people_fully_vaccinated,
            "total_boosters": total_boosters,
            "date": date,
        }
    )
Пример #9
0
def read(source: str) -> pd.Series:

    with get_driver() as driver:
        driver.get(source)
        time.sleep(10)

        for block in driver.find_elements_by_class_name("kpimetric"):
            if "1ste dosis" in block.text and "%" not in block.text:
                people_partly_vaccinated = clean_count(
                    block.find_element_by_class_name("valueLabel").text)
            elif "2de dosis" in block.text and "%" not in block.text:
                people_fully_vaccinated = clean_count(
                    block.find_element_by_class_name("valueLabel").text)
            elif "3de dosis" in block.text and "%" not in block.text:
                total_boosters = clean_count(
                    block.find_element_by_class_name("valueLabel").text)

    people_vaccinated = people_partly_vaccinated + people_fully_vaccinated

    return pd.Series(
        data={
            "total_vaccinations": people_vaccinated + people_fully_vaccinated,
            "people_vaccinated": people_vaccinated,
            "people_fully_vaccinated": people_fully_vaccinated,
            "total_boosters": total_boosters,
            "date": localdate("America/Paramaribo"),
        })
Пример #10
0
def _check_last_update(path, country):
    metadata = S3().get_metadata(path)
    last_update = metadata["LastModified"]
    now = localdate(force_today=True, as_datetime=True)
    num_days = (now - last_update).days
    if num_days > 4:  # Allow maximum 4 days delay
        raise FileExistsError(
            f"ICE File for {country} is too old ({num_days} days old)! Please check cowidev.vax.icer"
        )
Пример #11
0
 def parse_data(self, soup):
     widgets = soup.find_all(class_="textwidget")
     total_vaccinations = clean_count(widgets[0].text)
     people_fully_vaccinated = clean_count(widgets[1].text)
     people_vaccinated = total_vaccinations - people_fully_vaccinated
     return pd.Series({
         "total_vaccinations": total_vaccinations,
         "people_vaccinated": people_vaccinated,
         "people_fully_vaccinated": people_fully_vaccinated,
         "date": localdate("Asia/Tbilisi"),
     })
Пример #12
0
 def read(self) -> pd.Series:
     soup = get_soup(self.source_url, timeout=30)
     metrics = self._parse_metrics(soup)
     vaccines = self._parse_vaccines(soup)
     date = localdate("Asia/Dhaka")
     return pd.Series(
         data={
             **metrics,
             "date": date,
             "vaccine": vaccines,
         }
     )
Пример #13
0
 def _parse_data(self, soup: BeautifulSoup) -> pd.DataFrame:
     """Parse data from soup"""
     # Get the element
     elem = soup.find(text="Müayinə aparılıb").parent
     if not elem:
         raise ValueError("Element not found, please update the script")
     # Get the metrics
     count = self._parse_metrics(elem)
     df = pd.DataFrame({
         "Date": [localdate("Asia/Baku")],
         "Cumulative total": [count],
     })
     return df
Пример #14
0
    def _parse_data_date(self, soup) -> dict:
        date_raw = soup.find(class_="text-gray-500").text
        date = extract_clean_date(date_raw.strip() + str(datetime.now().year),
                                  self.regex["date"],
                                  "%d. %B%Y",
                                  lang="en")
        if date > localdate("America/Havana", force_today=True):
            date = extract_clean_date(date_raw.strip() +
                                      str(datetime.now().year - 1),
                                      self.regex["date"],
                                      "%d. %B%Y",
                                      lang="en")

        return {"date": date}
Пример #15
0
    def read(self) -> pd.DataFrame:
        """Read data from source"""
        body = str(get_soup(self.source_url))

        # Get count
        count = 0
        if "Totaal Testen" in body:
            count = int(body.split("Totaal Testen")[0].split('data-counter-value="')[-1].split('"')[0])
        # Get negative results
        negative = 0
        if "Totaal negatieve" in body:
            negative = int(body.split("Totaal negatieve")[0].split('data-counter-value="')[-1].split('"')[0])

        df = pd.DataFrame(
            {
                "Date": [localdate("America/Paramaribo")],
                "Daily change in cumulative total": [count],
                "positive": [count - negative],
            }
        )
        return df
Пример #16
0
def read(source: str) -> pd.Series:

    soup = get_soup(source)

    people_vaccinated = clean_count(
        re.search(r"^[\d,]+",
                  soup.find_all(class_="info-box-number")[2].text).group(0))
    people_fully_vaccinated = clean_count(
        re.search(r"^[\d,]+",
                  soup.find_all(class_="info-box-number")[3].text).group(0))
    total_vaccinations = people_vaccinated + people_fully_vaccinated

    date = localdate("Asia/Dhaka")

    return pd.Series(
        data={
            "total_vaccinations": total_vaccinations,
            "people_vaccinated": people_vaccinated,
            "people_fully_vaccinated": people_fully_vaccinated,
            "date": date,
        })
Пример #17
0
def connect_parse_data(source: str) -> pd.Series:

    soup = get_soup(source)

    df = pd.read_html(str(soup.find(class_="vaccination-count")))[0]
    assert df.shape == (3, 7)

    values = df.iloc[:, 2].values

    total_vaccinations = values[0]
    people_vaccinated = values[1]
    people_fully_vaccinated = values[2]
    assert total_vaccinations == people_vaccinated + people_fully_vaccinated

    date = soup.find(class_="aly_tx_center").text
    date = localdate("Asia/Tokyo")

    data = {
        "total_vaccinations": total_vaccinations,
        "people_vaccinated": people_vaccinated,
        "people_fully_vaccinated": people_fully_vaccinated,
        "date": date,
    }
    return pd.Series(data=data)
Пример #18
0
def connect_parse_data(source: str) -> pd.Series:

    soup = get_soup(source)

    az_dose1 = clean_count(soup.find_all(class_="yellow")[0].text)
    az_dose2 = clean_count(soup.find_all(class_="yellow")[1].text)
    assert az_dose1 >= az_dose2
    pfizer_dose1 = clean_count(soup.find_all(class_="yellow")[2].text)
    pfizer_dose2 = clean_count(soup.find_all(class_="yellow")[3].text)
    assert pfizer_dose1 >= pfizer_dose2

    people_vaccinated = az_dose1 + pfizer_dose1
    people_fully_vaccinated = az_dose2 + pfizer_dose2
    total_vaccinations = people_vaccinated + people_fully_vaccinated

    date = localdate("America/St_Lucia")

    data = {
        "total_vaccinations": total_vaccinations,
        "people_vaccinated": people_vaccinated,
        "people_fully_vaccinated": people_fully_vaccinated,
        "date": date,
    }
    return pd.Series(data=data)
Пример #19
0
 def pipe_date(self, ds: pd.Series) -> pd.Series:
     date = localdate("Europe/Isle_of_Man")
     return enrich_data(ds, "date", date)
Пример #20
0
 def _weekday_to_date(self, d):
     new_date = clean_date(d + "+5", "%Y-W%W+%w")
     if new_date > localdate("Europe/London"):
         new_date = clean_date(d + "+2", "%Y-W%W+%w")
     return new_date
Пример #21
0
def format_date(ds: pd.Series) -> pd.Series:
    date = localdate("Europe/Chisinau")
    return enrich_data(ds, "date", date)
Пример #22
0
def format_date(ds: pd.Series) -> pd.Series:
    date = localdate("Asia/Beirut")
    return enrich_data(ds, "date", date)
Пример #23
0
 def pipe_date(self, ds: pd.Series) -> pd.Series:
     return enrich_data(ds, "date", localdate("Asia/Bishkek"))
Пример #24
0
 def pipe_date(self, ds: pd.Series) -> pd.Series:
     date = localdate("Europe/Sofia")
     return enrich_data(ds, "date", date)
Пример #25
0
 def pipe_age_date(self, df: pd.DataFrame) -> pd.DataFrame:
     df = df.rename(columns={"last_day_of_epi_week": "date"})
     df.loc[df.complete_epi_week == 0, "date"] = localdate("America/Lima")
     return df
Пример #26
0
 def pipe_date(self, ds: pd.Series) -> pd.Series:
     date = localdate("Asia/Amman")
     return enrich_data(ds, "date", date)
Пример #27
0
def enrich_date(ds: pd.Series) -> pd.Series:
    date_str = localdate("America/Curacao")
    return enrich_data(ds, "date", date_str)
Пример #28
0
class Thailand:
    location: str = "Thailand"
    source_url: str = "https://ddc.moph.go.th/dcd/pagecontent.php?page=643&dept=dcd"
    base_url_template: str = "https://ddc.moph.go.th/vaccine-covid19/diaryReportMonth/{}/9/2021"
    regex_date: str = r"\s?ข้อมูล ณ วันที่ (\d{1,2}) (.*) (\d{4})"
    _year_difference_conversion = 543
    _current_month = localdate("Asia/Bangkok", date_format="%m")

    @property
    def regex_vax(self):
        regex_aux = r"\((?:รา|รำ)ย\)"
        regex_vax = (
            r" ".join([f"เข็มที่ {i} {regex_aux}" for i in range(1, 4)])
            + r" รวม \(โดส\)\s+([\d,]+)\s+([\d,]+)\s+([\d,]+)\s+([\d,]+)"
        )
        return regex_vax

    def read(self, last_update: str) -> pd.DataFrame:
        # Get Newest Month Report Page
        url_month = self.base_url_template.format(self._current_month)
        soup_month = get_soup(url_month)
        # Get links
        df = self._parse_data(soup_month, last_update)
        return df

    def _parse_data(self, soup: BeautifulSoup, last_update: str):
        links = self._get_month_links(soup)
        records = []
        for link in links:
            # print(link["date"])
            if link["date"] <= last_update:
                break
            records.append(self._parse_metrics(link))
        return pd.DataFrame(records)

    def _get_month_links(self, soup):
        links = soup.find_all("a", class_="selectModelMedia")
        links = [
            {
                "link": link.get("href"),
                "date": self._parse_date_from_link_title(link.parent.parent.text.strip()),
            }
            for link in links
        ]
        return sorted(links, key=lambda x: x["date"], reverse=True)

    def _parse_date_from_link_title(self, title):
        match = re.search(r".*สรุปวัคซีน ประจำวันที่\s+(\d+) .* (25\d\d)", title).group(1, 2)
        year = int(match[1]) - self._year_difference_conversion
        return clean_date(f"{year}-{self._current_month}-{match[0]}", "%Y-%m-%d")

    def _parse_metrics(self, link: str):
        raw_text = self._text_from_pdf(link["link"])
        text = self._substitute_special_chars(raw_text)
        record = self._parse_variables(text)
        record["date"] = link["date"]
        record["source_url"] = link["link"].replace(" ", "%20")
        return record

    def _text_from_pdf(self, pdf_link: str):
        with tempfile.NamedTemporaryFile() as tf:
            with open(tf.name, mode="wb") as f:
                f.write(requests.get(pdf_link).content)
            with open(tf.name, mode="rb") as f:
                viewer = SimplePDFViewer(f)
                viewer.render()
                raw_text = "".join(viewer.canvas.strings)
        return raw_text

    def _substitute_special_chars(self, raw_text: str):
        """Correct Thai Special Character Error."""
        special_char_replace = {
            "\uf701": "\u0e34",
            "\uf702": "\u0e35",
            "\uf703": "\u0e36",
            "\uf704": "\u0e37",
            "\uf705": "\u0e48",
            "\uf706": "\u0e49",
            "\uf70a": "\u0e48",
            "\uf70b": "\u0e49",
            "\uf70e": "\u0e4c",
            "\uf710": "\u0e31",
            "\uf712": "\u0e47",
            "\uf713": "\u0e48",
            "\uf714": "\u0e49",
        }
        special_char_replace = dict((re.escape(k), v) for k, v in special_char_replace.items())
        pattern = re.compile("|".join(special_char_replace.keys()))
        text = pattern.sub(lambda m: special_char_replace[re.escape(m.group(0))], raw_text)
        return text

    def _parse_variables(self, text: str):
        metrics = re.search(self.regex_vax, text).groups()
        people_vaccinated = clean_count(metrics[0])
        people_fully_vaccinated = clean_count(metrics[1])
        total_boosters = clean_count(metrics[2])
        total_vaccinations = clean_count(metrics[3])
        return {
            "total_vaccinations": total_vaccinations,
            "people_vaccinated": people_vaccinated,
            "people_fully_vaccinated": people_fully_vaccinated,
            "total_boosters": total_boosters,
        }

    def _parse_date(self, text: str):
        thai_date_replace = {
            # Months
            "มกราคม": 1,
            "กุมภาพันธ์": 2,
            "มีนาคม": 3,
            "เมษายน": 4,
            "พฤษภาคม": 5,
            "พฤษภำคม": 5,
            "มิถุนายน": 6,
            "มิถุนำยน": 6,
            "กรกฎาคม": 7,
            "กรกฎำคม": 7,
            "สิงหาคม": 8,
            "สิงหำคม": 8,
            "กันยายน": 9,
            "ตุลาคม": 10,
            "พฤศจิกายน": 11,
            "ธันวาคม": 12,
        }
        date_raw = re.search(self.regex_date, text)
        day = clean_count(date_raw.group(1))
        month = thai_date_replace[date_raw.group(2)]
        year = clean_count(date_raw.group(3)) - self._year_difference_conversion
        return clean_date(datetime(year, month, day))

    def pipe_location(self, df: pd.DataFrame) -> pd.DataFrame:
        return df.assign(location=self.location)

    def pipe_vaccine(self, df: pd.DataFrame) -> pd.DataFrame:
        return df.assign(vaccine="Oxford/AstraZeneca, Pfizer/BioNTech, Sinopharm/Beijing, Sinovac")

    def pipeline(self, df: pd.DataFrame) -> pd.DataFrame:
        return df.pipe(self.pipe_location).pipe(self.pipe_vaccine)

    def to_csv(self, paths):
        output_file = paths.tmp_vax_out(self.location)
        last_update = pd.read_csv(output_file).date.max()
        df = self.read(last_update)
        if not df.empty:
            df = df.pipe(self.pipeline)
            df = merge_with_current_data(df, output_file)
            df.to_csv(output_file, index=False)
Пример #29
0
 def _week_to_date(self, week: int) -> str:
     """Converts week to date."""
     year = localdate("Asia/Amman", as_datetime=True).isocalendar().year
     date = clean_date(f"{year} {week} +5", "%Y %W +%w")
     return date
Пример #30
0
class Jordan(CountryTestBase):
    location: str = "Jordan"
    units: str = "tests performed"
    source_label: str = "Ministry of Health"
    week: str = localdate("Asia/Amman", as_datetime=True).isocalendar().week
    notes: str = ""
    source_url: str = (
        "https://wabi-west-europe-d-primary-api.analysis.windows.net/public/reports/querydata?synchronous=true"
    )
    source_url_ref: str = "https://corona.moh.gov.jo/ar"

    def read(self) -> pd.DataFrame:
        """Reads the data from the source"""
        try:
            count = self._request()
            return self._df_builder(count)
        except KeyError:
            raise KeyError(
                "No value found. Please modify the payload and headers.")

    @property
    def headers(Self):
        """Headers for the request"""
        return {
            "User-Agent":
            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:85.0) Gecko/20100101 Firefox/85.0",
            "Accept": "application/json, text/plain, */*",
            "Accept-Language": "en-US",
            "X-PowerBI-ResourceKey": "f29483dd-2cd3-4be1-9fbd-6c67f0ca1037",
            "Content-Type": "application/json;charset=UTF-8",
            "Origin": "https://app.powerbi.com",
            "Referer": "https://app.powerbi.com/",
            "Pragma": "no-cache",
            "Cache-Control": "no-cache",
        }

    def payload(self, week: str = None) -> dict:
        """Request payload"""
        data = {
            "version":
            "1.0.0",
            "queries": [{
                "Query": {
                    "Commands": [{
                        "SemanticQueryDataShapeCommand": {
                            "Query": {
                                "Version":
                                2,
                                "From": [
                                    {
                                        "Name": "w",
                                        "Entity": "weekly data",
                                        "Type": 0
                                    },
                                ],
                                "Select": [{
                                    "Aggregation": {
                                        "Expression": {
                                            "Column": {
                                                "Expression": {
                                                    "SourceRef": {
                                                        "Source": "w"
                                                    }
                                                },
                                                "Property":
                                                "مجموع الفحوصات المخبرية التراكمي",
                                            }
                                        },
                                        "Function": 0,
                                    },
                                    "Name":
                                    "Sum(weekly data.مجموع الفحوصات المخبرية التراكمي)",
                                }],
                                "Where": [
                                    {
                                        "Condition": {
                                            "In": {
                                                "Expressions": [{
                                                    "Column": {
                                                        "Expression": {
                                                            "SourceRef": {
                                                                "Source": "w"
                                                            }
                                                        },
                                                        "Property": "week",
                                                    }
                                                }],
                                                "Values": [[{
                                                    "Literal": {
                                                        "Value": f"{week}L"
                                                    }
                                                }]],
                                            }
                                        }
                                    },
                                ],
                            },
                            "ExecutionMetricsKind": 1,
                        }
                    }]
                },
                "QueryId": "",
                "ApplicationContext": {
                    "DatasetId": "805d8b47-2e08-46cc-b1cd-7937fe585c59",
                },
            }],
            "cancelQueries": [],
            "modelId":
            1187812,
        }
        return data

    def _request(self) -> dict:
        """Requests data from source."""
        response = json.loads(
            requests.post(self.source_url,
                          headers=self.headers,
                          data=json.dumps(self.payload(str(
                              self.week)))).content
        )["results"][0]["result"]["data"]["dsr"]["DS"][0]["PH"][0]["DM0"][0]
        if "M0" in response.keys():
            response = response["M0"]
        else:
            self.week -= 1
            response = self._request()
        return response

    def _week_to_date(self, week: int) -> str:
        """Converts week to date."""
        year = localdate("Asia/Amman", as_datetime=True).isocalendar().year
        date = clean_date(f"{year} {week} +5", "%Y %W +%w")
        return date

    def _df_builder(self, count: str) -> pd.DataFrame:
        """Builds dataframe from the text data"""
        df = pd.DataFrame({"Cumulative total": [clean_count(count)]})
        return df

    def pipe_date(self, df: pd.DataFrame) -> pd.DataFrame:
        """Pipes date."""
        return df.assign(Date=self._week_to_date(self.week))

    def pipeline(self, df: pd.DataFrame) -> pd.DataFrame:
        """Pipeline for data."""
        return df.pipe(self.pipe_date).pipe(self.pipe_metadata)

    def export(self):
        """Exports data to CSV."""
        df = self.read().pipe(self.pipeline)
        # Export to CSV
        self.export_datafile(df, attach=True)