PyFunceble-dev 4.3.0a25__py3-none-any.whl → 4.4.0__py3-none-any.whl

PyFunceble/checker/availability/base.py

@@ -54,7 +54,7 @@ License:
 
 import multiprocessing
 from datetime import datetime
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from sqlalchemy.orm import Session
 
@@ -110,8 +110,12 @@ class AvailabilityCheckerBase(CheckerBase):
         Optional, Activates/Disables the check of the status before the actual
         status gathering.
     :param bool use_whois_db:
-        Optional, Activates/Disable the usage of a local database to store the
+        Optional, Activates/Disables the usage of a local database to store the
         WHOIS datasets.
+    :param bool use_platform:
+        Optional, Activates/Disables the usage of the platform features.
+    :param multiprocessing.Lock shared_lock:
+        Optional, The shared lock to use to access shared resources.
     """
 
     # pylint: disable=too-many-public-methods, too-many-instance-attributes
@@ -160,6 +164,7 @@ class AvailabilityCheckerBase(CheckerBase):
         db_session: Optional[Session] = None,
         use_whois_db: Optional[bool] = None,
         use_platform: Optional[bool] = None,
+        shared_lock: Optional[Any] = None,
     ) -> None:
         self.dns_query_tool = DNSQueryTool()
         self.whois_query_tool = WhoisQueryTool()
@@ -226,6 +231,7 @@ class AvailabilityCheckerBase(CheckerBase):
             do_syntax_check_first=do_syntax_check_first,
             db_session=db_session,
             use_platform=use_platform,
+            shared_lock=shared_lock,
         )
 
     @property
@@ -761,7 +767,9 @@ class AvailabilityCheckerBase(CheckerBase):
         if (
             PyFunceble.facility.ConfigLoader.is_already_loaded() and self.use_whois_db
         ):  # pragma: no cover ## Not interesting enough to spend time on it.
-            whois_object = get_whois_dataset_object(db_session=self.db_session)
+            whois_object = get_whois_dataset_object(
+                db_session=self.db_session, shared_lock=self.shared_lock
+            )
             known_record = whois_object[self.subject]
 
             if known_record and not isinstance(known_record, dict):

PyFunceble/checker/availability/domain.py

@@ -115,7 +115,9 @@ class DomainAvailabilityChecker(AvailabilityCheckerBase):
             self.status.idna_subject,
         )
 
-        lookup_result = DomainReputationChecker(self.status.idna_subject).get_status()
+        lookup_result = DomainReputationChecker(
+            self.status.idna_subject, shared_lock=self.shared_lock
+        ).get_status()
 
         # pylint: disable=no-member
         if lookup_result and lookup_result.is_malicious():

PyFunceble/checker/availability/domain_and_ip.py

@@ -112,6 +112,7 @@ class DomainAndIPAvailabilityChecker(AvailabilityCheckerBase):
                 db_session=self.db_session,
                 use_whois_db=self.use_whois_db,
                 use_platform=self.use_platform,
+                shared_lock=self.shared_lock,
             )
         else:
             query_object = DomainAvailabilityChecker(
@@ -126,6 +127,7 @@ class DomainAndIPAvailabilityChecker(AvailabilityCheckerBase):
                 db_session=self.db_session,
                 use_whois_db=self.use_whois_db,
                 use_platform=self.use_platform,
+                shared_lock=self.shared_lock,
             )
 
         query_object.dns_query_tool = self.dns_query_tool

PyFunceble/checker/base.py

@@ -52,7 +52,7 @@ License:
 
 import datetime
 import functools
-from typing import Optional
+from typing import Any, Optional
 
 import domain2idna
 from sqlalchemy.orm import Session
@@ -77,6 +77,12 @@ class CheckerBase:
 
         .. warning::
             This does not apply to the syntax checker - itself.
+    :param Session db_session:
+        Optional, The database session to use.
+    :param bool use_platform:
+        Optional, Authorizes the usage of the platform.
+    :param Any shared_lock:
+        Optional, The shared lock to use to access shared resources.
     """
 
     STD_DO_SYNTAX_CHECK_FIRST: bool = False
@@ -97,6 +103,8 @@ class CheckerBase:
     status: Optional[CheckerStatusBase] = None
     params: Optional[CheckerParamsBase] = None
 
+    shared_lock: Optional[Any] = None
+
     def __init__(
         self,
         subject: Optional[str] = None,
@@ -104,6 +112,7 @@ class CheckerBase:
         do_syntax_check_first: Optional[bool] = None,
         db_session: Optional[Session] = None,
         use_platform: Optional[bool] = None,
+        shared_lock: Optional[Any] = None,
     ) -> None:
         self.platform_query_tool = PlatformQueryTool()
         self.url2netloc = Url2Netloc()
@@ -115,6 +124,9 @@ class CheckerBase:
         if self.status is None:
             self.status = CheckerStatusBase()
 
+        if shared_lock is not None:
+            self.shared_lock = shared_lock
+
         if subject is not None:
             self.subject = subject
 

PyFunceble/checker/reputation/base.py

@@ -50,7 +50,7 @@ License:
     limitations under the License.
 """
 
-from typing import List, Optional
+from typing import Any, List, Optional
 
 from sqlalchemy.orm import Session
 
@@ -75,6 +75,12 @@ class ReputationCheckerBase(CheckerBase):
     :param bool do_syntax_check_first:
         Optional, Activates/Disables the check of the status before the actual
         status gathering.
+    :param Session db_session:
+        Optional, The database session to use.
+    :param bool use_platform:
+        Optional, Authorizes the usage of the platform.
+    :param Any shared_lock:
+        Optional, The shared lock to use to access shared resources.
     """
 
     dns_query_tool: Optional[DNSQueryTool] = None
@@ -92,9 +98,10 @@ class ReputationCheckerBase(CheckerBase):
         do_syntax_check_first: Optional[bool] = None,
         db_session: Optional[Session] = None,
         use_platform: Optional[bool] = None,
+        shared_lock: Optional[Any] = None,
     ) -> None:
         self.dns_query_tool = DNSQueryTool()
-        self.ipv4_reputation_query_tool = IPV4ReputationDataset()
+        self.ipv4_reputation_query_tool = IPV4ReputationDataset(shared_lock=shared_lock)
         self.domain_syntax_checker = DomainSyntaxChecker()
         self.ip_syntax_checker = IPSyntaxChecker()
         self.url_syntax_checker = URLSyntaxChecker()
@@ -110,6 +117,7 @@ class ReputationCheckerBase(CheckerBase):
             do_syntax_check_first=do_syntax_check_first,
             db_session=db_session,
             use_platform=use_platform,
+            shared_lock=shared_lock,
         )
 
     @staticmethod

PyFunceble/checker/syntax/base.py

@@ -50,7 +50,7 @@ License:
     limitations under the License.
 """
 
-from typing import Optional
+from typing import Any, Optional
 
 from sqlalchemy.orm import Session
 
@@ -78,13 +78,16 @@ class SyntaxCheckerBase(CheckerBase):
         self,
         subject: Optional[str] = None,
         db_session: Optional[Session] = None,
+        shared_lock: Optional[Any] = None,
     ) -> None:
         self.params = SyntaxCheckerParams()
 
         self.status = SyntaxCheckerStatus()
         self.status.params = self.params
 
-        super().__init__(subject=subject, db_session=db_session)
+        super().__init__(
+            subject=subject, db_session=db_session, shared_lock=shared_lock
+        )
 
     def subject_propagator(self) -> "CheckerBase":
         """

PyFunceble/checker/utils/whois.py

@@ -50,7 +50,7 @@ License:
     limitations under the License.
 """
 
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 from sqlalchemy.orm import Session
 
@@ -64,13 +64,17 @@ from PyFunceble.dataset.whois.sql import SQLDBWhoisDataset
 
 
 def get_whois_dataset_object(
-    *, db_session: Optional[Session] = None
+    *,
+    db_session: Optional[Session] = None,
+    shared_lock: Optional[Any] = None,
 ) -> Union[DatasetBase, CSVDatasetBase, DBDatasetBase]:
     """
     Provides the whois dataset object to work with.
 
     :param db_session:
         A database session to use.
+    :param shared_lock:
+        Optional, The shared lock to use to access shared resources.
 
     :raise ValueError:
         When the given database type is unknown.
@@ -80,7 +84,7 @@ def get_whois_dataset_object(
 
     if PyFunceble.facility.ConfigLoader.is_already_loaded():
         if PyFunceble.storage.CONFIGURATION.cli_testing.db_type == "csv":
-            return CSVWhoisDataset().set_authorized(
+            return CSVWhoisDataset(shared_lock=shared_lock).set_authorized(
                 bool(PyFunceble.storage.CONFIGURATION.cli_testing.whois_db)
             )
 

PyFunceble/cli/facility.py

@@ -52,4 +52,6 @@ License:
 
 from PyFunceble.cli.credential_loader import CredentialLoader as credential_loader
 
+# pylint: disable=invalid-name
+
 CredentialLoader = credential_loader()

PyFunceble/cli/factory.py

@@ -52,4 +52,6 @@ License:
 
 from PyFunceble.database.session import DBSession as db_session
 
+# pylint: disable=invalid-name
+
 DBSession = db_session()

PyFunceble/cli/filesystem/status_file.py

@@ -77,7 +77,7 @@ class StatusFileGenerator(FilesystemDirBase):
 
     # pylint: disable=too-many-public-methods
 
-    STD_HOSTS_IP: str = "0.0.0.0"
+    STD_HOSTS_IP: str = "0.0.0.0"  # nosec: B104  # Default to non-routable IP
     STD_ALLOW_HOSTS_FILES: bool = True
     STD_ALLOW_PLAIN_FILES: bool = True
     STD_ALLOW_ANALYTIC_FILES: bool = True

PyFunceble/cli/migrators/mariadb/file_and_status.py

@@ -106,8 +106,8 @@ class FileAndStatusMigrator(MariaDBMigratorBase):
 
             destination = get_destination_from_origin(file_info["path"])
 
-            for status in self.get_rows(
-                f"SELECT * from pyfunceble_status WHERE file_id = {file_info['id']}"
+            for status in self.get_rows(  # nosec: B608 # Self-Controlled Input
+                "SELECT * from pyfunceble_status WHERE file_id = {file_info['id']}"
             ):
                 if (
                     self.continuous_integration
@@ -144,7 +144,9 @@ class FileAndStatusMigrator(MariaDBMigratorBase):
 
                 # pylint: disable=line-too-long
                 self.db_session.execute(
-                    text(f"DELETE from pyfunceble_status WHERE id = {status['id']}")
+                    text(
+                        f"DELETE from pyfunceble_status WHERE id = {status['id']}"  # nosec: B608 # Self-Controlled Input
+                    )
                 )
                 self.db_session.commit()
 
@@ -155,7 +157,9 @@ class FileAndStatusMigrator(MariaDBMigratorBase):
             if drop_table:
                 # pylint: disable=line-too-long
                 self.db_session.execute(
-                    text(f"DELETE from pyfunceble_file WHERE id = {file_info['id']}")
+                    text(
+                        f"DELETE from pyfunceble_file WHERE id = {file_info['id']}"  # nosec: B608 # Self-Controlled Input
+                    )
                 )
                 self.db_session.commit()
 

PyFunceble/cli/processes/base.py

@@ -60,3 +60,10 @@ class ProcessesManagerBase(PyFunceble.ext.process_manager.ProcessManagerCore):
     """
     Provides the base of all classes.
     """
+
+    def __init__(self, *args, **kwargs) -> None:
+        # Better handling of shared locks.
+        # This help be be retro-compatible. Allowing existing users to
+        # not get exceptions.
+        shared_lock = kwargs.pop("shared_lock", None)
+        super().__init__(*args, **kwargs, shared_lock=shared_lock)

PyFunceble/cli/processes/workers/producer.py

@@ -125,9 +125,15 @@ class ProducerWorker(WorkerBase):
         self.file_printer = FilePrinter(
             skip_column=skip_columns, extra_formatters=extra_formatters
         )
-        self.whois_dataset = get_whois_dataset_object(db_session=self.db_session)
-        self.inactive_dataset = get_inactive_dataset_object(db_session=self.db_session)
-        self.continue_dataset = get_continue_dataset_object(db_session=self.db_session)
+        self.whois_dataset = get_whois_dataset_object(
+            db_session=self.db_session, shared_lock=self.shared_lock
+        )
+        self.inactive_dataset = get_inactive_dataset_object(
+            db_session=self.db_session, shared_lock=self.shared_lock
+        )
+        self.continue_dataset = get_continue_dataset_object(
+            db_session=self.db_session, shared_lock=self.shared_lock
+        )
         self.status_file_generator = StatusFileGenerator().guess_all_settings()
         self.counter = FilesystemCounter()
         self.registrar_counter = RegistrarCounter()

PyFunceble/cli/processes/workers/tester.py

@@ -90,12 +90,12 @@ class TesterWorker(WorkerBase):
 
         self.continue_dataset = (
             PyFunceble.cli.utils.testing.get_continue_dataset_object(
-                db_session=self.db_session
+                db_session=self.db_session, shared_lock=self.shared_lock
             )
         )
         self.inactive_dataset = (
             PyFunceble.cli.utils.testing.get_inactive_dataset_object(
-                db_session=self.db_session
+                db_session=self.db_session, shared_lock=self.shared_lock
             )
         )
 
@@ -191,7 +191,7 @@ class TesterWorker(WorkerBase):
             self.initiated_testing_objects[checker_type][
                 subject_type
             ] = self.known_testing_objects[checker_type][subject_type](
-                db_session=self.db_session
+                db_session=self.db_session, shared_lock=self.shared_lock
             ).set_do_syntax_check_first(
                 # We want to always check the syntax first (ONLY UNDER THE CLI)
                 not bool(PyFunceble.storage.CONFIGURATION.cli_testing.local_network)
@@ -278,12 +278,12 @@ class TesterWorker(WorkerBase):
             test_dataset["idna_subject"],
         )
 
-        self._init_testing_object(
+        testing_object = self._init_testing_object(
             test_dataset["subject_type"], test_dataset["checker_type"]
         )
 
         result = (
-            self.testing_object.set_subject(test_dataset["idna_subject"])
+            testing_object.set_subject(test_dataset["idna_subject"])
             .query_status()
             .get_status()
         )

PyFunceble/cli/system/launcher.py

@@ -156,6 +156,7 @@ class SystemLauncher(SystemBase):
     file_preloader: Optional[FilePreloader] = None
 
     manager: Optional[multiprocessing.Manager]
+    shared_lock: Optional[multiprocessing.Lock] = None
     tester_process_manager: Optional[
         Union[TesterProcessesManager, ChancyTesterProcessesManager]
     ] = None
@@ -185,11 +186,20 @@ class SystemLauncher(SystemBase):
         except TypeError:
             self.db_session = None
 
+        self.manager = multiprocessing.Manager()
+        self.shared_lock = multiprocessing.Lock()
+
         self.execution_time_holder = ExecutionTime().set_start_time()
         self.checker_type = get_testing_mode()
-        self.continue_dataset = get_continue_dataset_object(db_session=self.db_session)
-        self.inactive_dataset = get_inactive_dataset_object(db_session=self.db_session)
-        self.whois_dataset = get_whois_dataset_object(db_session=self.db_session)
+        self.continue_dataset = get_continue_dataset_object(
+            db_session=self.db_session, shared_lock=self.shared_lock
+        )
+        self.inactive_dataset = get_inactive_dataset_object(
+            db_session=self.db_session, shared_lock=self.shared_lock
+        )
+        self.whois_dataset = get_whois_dataset_object(
+            db_session=self.db_session, shared_lock=self.shared_lock
+        )
         self.continuous_integration = ci_object()
 
         if self.continuous_integration.authorized:
@@ -197,8 +207,6 @@ class SystemLauncher(SystemBase):
 
         self.stdout_printer.guess_allow_coloration().guess_allow_background_coloration()
 
-        self.manager = multiprocessing.Manager()
-
         if not PyFunceble.storage.CONFIGURATION.cli_testing.chancy_tester:
             self.tester_process_manager = TesterProcessesManager(
                 max_workers=PyFunceble.storage.CONFIGURATION.cli_testing.max_workers,
@@ -215,6 +223,7 @@ class SystemLauncher(SystemBase):
                 delay_shutdown=PyFunceble.storage.CONFIGURATION.cli_testing.mining,
                 generate_configuration_queue=False,
                 continuous_integration=self.continuous_integration,
+                shared_lock=self.shared_lock,
             )
 
             self.producer_process_manager = ProducerProcessesManager(
@@ -227,6 +236,7 @@ class SystemLauncher(SystemBase):
                 delay_shutdown=PyFunceble.storage.CONFIGURATION.cli_testing.mining,
                 generate_configuration_queue=False,
                 continuous_integration=self.continuous_integration,
+                shared_lock=self.shared_lock,
             )
         else:
             self.tester_process_manager = ChancyTesterProcessesManager(
@@ -266,6 +276,7 @@ class SystemLauncher(SystemBase):
             daemon=True,
             generate_output_queue=False,
             generate_configuration_queue=False,
+            shared_lock=self.shared_lock,
         )
         self.migrator_process_manager = MigratorProcessesManager(
             manager=self.manager,
@@ -273,6 +284,7 @@ class SystemLauncher(SystemBase):
             daemon=True,
             generate_input_queue=False,
             generate_output_queue=False,
+            shared_lock=self.shared_lock,
         )
 
         if PyFunceble.storage.CONFIGURATION.cli_testing.mining:
@@ -287,6 +299,7 @@ class SystemLauncher(SystemBase):
                 spread_stop_signal=False,
                 spread_wait_signal=True,
                 delay_shutdown=PyFunceble.storage.CONFIGURATION.cli_testing.mining,
+                shared_lock=self.shared_lock,
             )
 
             self.tester_process_manager.add_dependent_manager(

PyFunceble/cli/utils/testing.py

@@ -51,7 +51,7 @@ License:
 """
 
 import os
-from typing import List, Optional, Union
+from typing import Any, List, Optional, Union
 
 from sqlalchemy.orm import Session
 
@@ -92,12 +92,15 @@ def get_testing_mode() -> str:
 
 def get_continue_dataset_object(
     db_session: Optional[Session] = None,
+    shared_lock: Optional[Any] = None,
 ) -> Union[DatasetBase, CSVDatasetBase, DBDatasetBase]:
     """
     Provides the continue object to work with.
 
     :param db_session:
         A database session to use.
+    :param shared_lock:
+        Optional, The shared lock to use to access shared resources.
 
     :raise ValueError:
         When the given database type is unkown.
@@ -106,7 +109,7 @@ def get_continue_dataset_object(
     result = None
 
     if PyFunceble.storage.CONFIGURATION.cli_testing.db_type in "csv":
-        result = CSVContinueDataset()
+        result = CSVContinueDataset(shared_lock=shared_lock)
     elif PyFunceble.storage.CONFIGURATION.cli_testing.db_type in (
         "mariadb",
         "mysql",
@@ -129,12 +132,15 @@ def get_continue_dataset_object(
 
 def get_inactive_dataset_object(
     db_session: Optional[Session] = None,
+    shared_lock: Optional[Any] = None,
 ) -> Union[DatasetBase, CSVDatasetBase, DBDatasetBase]:
     """
     Provides the inactive object to work with.
 
     :param db_session:
         A database session to use.
+    :param shared_lock:
+        An optional shared lock to use.
 
     :raise ValueError:
         When the given database type is unkown.
@@ -143,7 +149,7 @@ def get_inactive_dataset_object(
     result = None
 
     if PyFunceble.storage.CONFIGURATION.cli_testing.db_type == "csv":
-        result = CSVInactiveDataset()
+        result = CSVInactiveDataset(shared_lock=shared_lock)
     elif PyFunceble.storage.CONFIGURATION.cli_testing.db_type in (
         "mariadb",
         "mysql",

PyFunceble/database/sqlalchemy/base_schema.py

@@ -54,12 +54,13 @@ from datetime import datetime, timezone
 
 import inflection
 from sqlalchemy import BigInteger, Column, DateTime
-from sqlalchemy.ext.declarative import declarative_base, declared_attr
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import DeclarativeBase
 
 import PyFunceble.storage
 
 
-class OurSchemaBase:
+class SchemaBase(DeclarativeBase):
     """
     Provides the base of all our schema.
     """
@@ -92,6 +93,3 @@ class OurSchemaBase:
         """
 
         return {x: y for x, y in self.__dict__.items() if not x.startswith("_sa")}
-
-
-SchemaBase = declarative_base(cls=OurSchemaBase)

PyFunceble/dataset/autocontinue/csv.py

@@ -66,6 +66,17 @@ class CSVContinueDataset(CSVDatasetBase, ContinueDatasetBase):
     """
     Provides the interface for the management of the continue
     CSV file.
+
+    :param bool authorized:
+        Optional, Authorizes/Disables the usage of this dataset.
+        If not set, :code:`STD_AUTHORIZED` is used.
+    :param bool remove_unneeded_fields:
+        Optional, Activates/Deactivates the removal of unneeded fields.
+        If not set, :code:`STD_REMOVE_UNNEEDED_FIELDS` is used.
+    :param str base_directory:
+        Optional, The base directory to use.
+    :param Any shared_lock:
+        Optional, The shared lock to use to access shared resources.
     """
 
     source_file: Optional[str] = None
@@ -78,12 +89,15 @@ class CSVContinueDataset(CSVDatasetBase, ContinueDatasetBase):
         authorized: Optional[bool] = None,
         remove_unneeded_fields: Optional[bool] = None,
         base_directory: Optional[str] = None,
+        shared_lock: Optional[Any] = None,
     ) -> None:
         if base_directory is not None:
             self.set_base_directory(base_directory)
 
         super().__init__(
-            authorized=authorized, remove_unneeded_fields=remove_unneeded_fields
+            authorized=authorized,
+            remove_unneeded_fields=remove_unneeded_fields,
+            shared_lock=shared_lock,
         )
 
     def __contains__(self, value: str) -> bool:

PyFunceble/dataset/base.py

@@ -57,11 +57,15 @@ import PyFunceble.storage
 from PyFunceble.downloader.base import DownloaderBase
 from PyFunceble.helpers.dict import DictHelper
 from PyFunceble.helpers.file import FileHelper
+from PyFunceble.utils.platform import PlatformUtility
 
 
 class DatasetBase:
     """
     Provides the base of all dataset.
+
+    :param Any shared_lock:
+        Optional, The shared lock to use to access shared resources.
     """
 
     STORAGE_INDEX: Optional[str] = None
@@ -69,6 +73,12 @@ class DatasetBase:
 
     source_file: Optional[str] = None
 
+    shared_lock: Optional[Any] = None
+
+    def __init__(self, *, shared_lock: Optional[Any] = None) -> None:
+        if shared_lock is not None:
+            self.shared_lock = shared_lock
+
     def __contains__(self, value: Any):  # pragma: no cover
         raise NotImplementedError()
 
@@ -110,7 +120,22 @@ class DatasetBase:
 
         return wrapper
 
+    def autolock(func):  # pylint: disable=no-self-argument
+        """
+        A decorator to automatically lock and unlock the shared lock.
+        """
+
+        @functools.wraps(func)
+        def wrapper(self, *args, **kwargs):
+            if PlatformUtility.is_windows() and self.shared_lock is not None:
+                with self.shared_lock:
+                    return func(self, *args, **kwargs)  # pylint: disable=not-callable
+            return func(self, *args, **kwargs)  # pylint: disable=not-callable
+
+        return wrapper
+
     @ensure_source_file_exists
+    @autolock
     def get_content(self) -> Optional[dict]:
         """
         Provides the cached or the real contend of the dataset (after caching)

PyFunceble/dataset/csv_base.py

@@ -118,6 +118,7 @@ class CSVDatasetBase(DBDatasetBase):
 
     @DBDatasetBase.ensure_source_file_exists
     @DBDatasetBase.execute_if_authorized(None)
+    @DBDatasetBase.autolock
     def add(self, row: dict) -> "CSVDatasetBase":
         """
         Adds the given dataset into the CSV file.
@@ -151,6 +152,7 @@ class CSVDatasetBase(DBDatasetBase):
 
     @DBDatasetBase.ensure_source_file_exists
     @DBDatasetBase.execute_if_authorized(None)
+    @DBDatasetBase.autolock
     def remove(self, row: dict) -> "CSVDatasetBase":
         """
         Removes the given dataset from the CSV file.
@@ -194,6 +196,7 @@ class CSVDatasetBase(DBDatasetBase):
 
     @DBDatasetBase.ensure_source_file_exists
     @DBDatasetBase.execute_if_authorized(None)
+    @DBDatasetBase.autolock
     def get_content(self) -> Generator[Optional[dict], None, None]:
         """
         Provides a generator which provides the next line to read.
@@ -211,7 +214,7 @@ class CSVDatasetBase(DBDatasetBase):
                         row["tested_at"] = datetime.fromisoformat(
                             row["tested_at"]
                         ).astimezone(timezone.utc)
-                    except (TypeError, ValueError):
+                    except (TypeError, ValueError, KeyError):
                         row["tested_at"] = datetime.now(timezone.utc) - timedelta(
                             days=365
                         )