emso-metadata-harmonizer 1.1.0.dev1__tar.gz → 1.1.0.dev2__tar.gz

{emso_metadata_harmonizer-1.1.0.dev1/src/emso_metadata_harmonizer.egg-info → emso_metadata_harmonizer-1.1.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emso-metadata-harmonizer
-Version: 1.1.0.dev1
+Version: 1.1.0.dev2
 Summary:  Toolbox for creating/assessing EMSO-compliant NetCDF datasets and integrate them into ERDDAP services
 Author-email: Enoc Martínez <enoc.martinez@upc.edu>
 Maintainer-email: Enoc Martínez <enoc.martinez@upc.edu>

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/__init__.py

@@ -1,3 +1,5 @@
+import logging
+
 from .erddap_config import erddap_config
 from .erddap import ERDDAP
 from .metadata.waterframe import WaterFrame
@@ -6,4 +8,6 @@ from .dataset_generator import generate_dataset
 from .metadata.waterframe import WaterFrame
 from .metadata import setup_log
 
-__version__ = "1.1.0dev1"
+logging.getLogger("emso_metadata_harmonizer").addHandler(logging.NullHandler())
+
+__version__ = "1.1.0dev2"

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/dataset_generator.py

@@ -13,13 +13,13 @@ import logging
 import rich
 import pandas as pd
 import yaml
-import os
+
 from .metadata import EmsoMetadata
 from .metadata.dataset import load_data
-from .metadata.utils import assert_type, get_file_list
+from .metadata.utils import assert_type, EMH_LOGGER_NAME
 from .metadata.waterframe import WaterFrame, get_coordinates_from_dataframe
 
-logger = logging.getLogger("emso_metadata_harmonizer")
+logger = logging.getLogger(EMH_LOGGER_NAME)
 
 global_elements = (
     # Array with attribute_name, type, mandatory (True, False), additional_checks

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/erddap/datasets_xml.py

@@ -54,12 +54,10 @@ def generate_erddap_dataset(wf: WaterFrame, directory, dataset_id, recursive: bo
     assert isinstance(wf, WaterFrame), f"Expected WaterFrame (got {type(wf)})"
     assert isinstance(directory, str), f"Expected str for directory (got {type(directory)})"
 
-    log = logging.getLogger()
-
     vocab = wf.vocabulary
     if mapping:
         # convert from array to a dict with source as the key
-        log.info(f"Using user-supplied variable mapping")
+        logger.info(f"Using user-supplied variable mapping")
         var_mapping = {d["source"]: d for d in mapping["mapping"]["variables"]}
         attr_mapping = mapping["mapping"]["attributes"]
     else:

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/erddap_config.py

@@ -15,8 +15,9 @@ import rich
 
 from .erddap.datasets_xml import generate_erddap_dataset, add_dataset
 from .metadata.waterframe import WaterFrame
+from .metadata.utils import EMH_LOGGER_NAME
 
-logger = logging.getLogger("emso_metadata_harmonizer")
+logger = logging.getLogger(EMH_LOGGER_NAME)
 
 def erddap_config(file: str, dataset_id: str, source_path: str, output: str = "", datasets_xml_file: str = "",
                   mapping: dict={}, filename_regex=".*", recursive=False):

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/metadata/emso.py

@@ -12,14 +12,14 @@ created: 3/3/23
 import logging
 import os
 from .vocabularies import GEMET, GCMD, SeaDataNetVocabulary, EuroSciVoc, Keyword, OSO
-from .utils import get_file_list, assert_type
+from .utils import get_file_list, assert_type, EMH_LOGGER_NAME
 from .resource_manager import ResourceManager, process_markdown_file, load_json
 
 # Specifications version used when the caller does not ask for one. "develop" keeps the behaviour of previous
 # releases; set it to "latest" to follow the newest published tag instead.
 emso_version = "develop"
 
-log = logging.getLogger("emso_metadata_harmonizer")
+logger = logging.getLogger(EMH_LOGGER_NAME)
 
 user_defined_specs_file = ""  # used to overload online specifications, used for development only
 
@@ -94,7 +94,7 @@ class EmsoMetadata:
         :param version: EMSO Metadata Specifications version. Empty uses the module default (see emso_version)
         :param max_threads: size of the download thread pool
         """
-        log.info("Loading EMSO Metadata resources...")
+        logger.info("Loading EMSO Metadata resources...")
 
         # All downloading, caching and parsing is delegated to the ResourceManager, which resolves the
         # requested version against manifest.json and fetches everything in parallel.
@@ -137,7 +137,7 @@ class EmsoMetadata:
         # ==== Load all SDN vocabularies ==== #
         # Every file was already downloaded and parsed by the ResourceManager, so this is just a re-shuffle
         for vocab in list(self.sdn_vocabs.keys()):
-            log.debug(f"    loading SDN vocabulary {vocab}")
+            logger.debug(f"    loading SDN vocabulary {vocab}")
             df = self.resource_manager.get(vocab, "csv")
             self.sdn_vocabs[vocab] = df
             self.sdn_vocabs_narrower[vocab] = self.resource_manager.get(vocab, "narrower")
@@ -149,15 +149,15 @@ class EmsoMetadata:
             self.sdn_vocabs_uris[vocab] = df["uri"].values
 
         # ==== Load Copernicus Variables ==== #
-        log.debug(f"    loading Copernicus Parameters")
+        logger.debug(f"    loading Copernicus Parameters")
         tables = self.resource_manager.get("Copernicus Parameters", "md")
 
         self.copernicus_variables = tables["Copernicus variables"]["variable name"].to_list()
-        log.debug(f"    loading EDMO codes")
+        logger.debug(f"    loading EDMO codes")
         self.edmo_codes = self.resource_manager.get("EDMO", "csv")
 
         if user_defined_specs_file:
-            log.warning(f"Using custom specifications file: {user_defined_specs_file}")
+            logger.warning(f"Using custom specifications file: {user_defined_specs_file}")
             tables = process_markdown_file(user_defined_specs_file)
         else:
             tables = self.resource_manager.get("EMSO_Metadata_Specifications", "md")
@@ -325,8 +325,6 @@ class EmsoMetadata:
         """
         Search in vocab <vocab_id> for the element with matching uri and return element identified by key
         """
-        log = logging.getLogger()
-
         uri = self.harmonize_sdn_uri(uri)
         __allowed_keys = ["prefLabel", "id", "definition", "altLabel"]
         if key not in __allowed_keys:
@@ -335,7 +333,7 @@ class EmsoMetadata:
         position = self.vocab_row(vocab_id, "uri", uri)
         if position is None:
             #raise LookupError(f"Could not get {key} for '{uri}' in vocab {vocab_id}")
-            log.warning(f"Could not get {key} for '{uri}' in vocab {vocab_id}")
+            logger.warning(f"Could not get {key} for '{uri}' in vocab {vocab_id}")
             return
 
         return self.sdn_vocabs[vocab_id][key].values[position]
@@ -380,7 +378,6 @@ class EmsoMetadata:
         :param target_vocab: id of the vocabulary terms that we want to find
         :returns: list with matches
         """
-        log = logging.getLogger()
         __valid_relations = ["narrower", "broader", "related"]
         uri = self.harmonize_sdn_uri(uri)
 
@@ -397,7 +394,7 @@ class EmsoMetadata:
         try:
             uri_relations = relations[uri]
         except KeyError:
-            log.warning(f"relation {relation} for {uri} not found!")
+            logger.warning(f"relation {relation} for {uri} not found!")
             return ""
 
         if type(uri_relations) is str:  # make sure it's a list
@@ -413,10 +410,9 @@ class EmsoMetadata:
         """
         The same as get relations but throws an error if more than one element are found
         """
-        log = logging.getLogger()
         results = self.get_relations(vocab_id, uri, relation, target_vocab)
         if len(results) == 0:
-            log.warning(f"Could not find relation {relation} for {uri}")
+            logger.warning(f"Could not find relation {relation} for {uri}")
             return ""
         elif len(results) != 1:
             raise LookupError(f"Expected 1 value, got {len(results)}")

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/metadata/resource_manager.py

@@ -34,9 +34,9 @@ from concurrent.futures import ThreadPoolExecutor
 import pandas as pd
 import requests
 
-from .utils import download_file, get_file_md5
+from .utils import download_file, get_file_md5, EMH_LOGGER_NAME
 
-log = logging.getLogger("emso_metadata_harmonizer")
+logger = logging.getLogger(EMH_LOGGER_NAME)
 
 DEFAULT_CACHE_DIR = ".emso"
 
@@ -190,10 +190,10 @@ class Resource:
         could not be established.
         """
         if not force and self.is_cached(known_md5=known_md5):
-            log.debug(f"    {self.label} is up to date")
+            logger.debug(f"    {self.label} is up to date")
             return self.md5 if self.md5 else known_md5
 
-        log.info(f"    downloading {self.label} to {self.filename}...")
+        logger.info(f"    downloading {self.label} to {self.filename}...")
         os.makedirs(os.path.dirname(self.filename) or ".", exist_ok=True)
         download_file(self.url, self.filename)
         self.downloaded = True
@@ -202,7 +202,7 @@ class Resource:
         if self.md5 and local_md5 != self.md5:
             # The vocabulary snapshot tracks a mutable branch: a mismatch means it moved between publishing the
             # manifest and this download, not that the file is corrupt.
-            log.warning(f"{self.label}: md5 mismatch (expected {self.md5}, got {local_md5}). "
+            logger.warning(f"{self.label}: md5 mismatch (expected {self.md5}, got {local_md5}). "
                         f"The upstream snapshot probably moved; the downloaded file is used anyway.")
         return local_md5
 
@@ -218,7 +218,7 @@ class Resource:
         elif extension == ".json":
             self.dict = load_json(self.filename)
         else:
-            log.debug(f"    {self.label}: extension '{extension}' not parsed, keeping file as-is")
+            logger.debug(f"    {self.label}: extension '{extension}' not parsed, keeping file as-is")
 
     def process(self, force=False, known_md5=None):
         """
@@ -231,7 +231,7 @@ class Resource:
             return local_md5
         except Exception as e:
             self.error = e
-            log.error(f"Could not process {self.label}: {e}")
+            logger.error(f"Could not process {self.label}: {e}")
             return None
 
     def get(self):
@@ -282,7 +282,7 @@ class ResourceManager:
         self.vocabularies = self.get_vocabularies()
 
         self.version = self.resolve_version(version)
-        log.info(f"Using EMSO Metadata Specifications {self.version}")
+        logger.info(f"Using EMSO Metadata Specifications {self.version}")
 
         self.resources = {}  # name -> {key: Resource}
         self.__build_resources()
@@ -302,7 +302,7 @@ class ResourceManager:
         if cached and not self.force_update:
             age = time.time() - os.path.getmtime(filename)
             if age < manifest_max_age:
-                log.debug(f"{what} is recent enough ({age / 3600:.1f} h), not checking upstream")
+                logger.debug(f"{what} is recent enough ({age / 3600:.1f} h), not checking upstream")
                 return cached
 
         for url in urls:
@@ -311,7 +311,7 @@ class ResourceManager:
                 response.raise_for_status()
                 document = response.json()
             except (requests.exceptions.RequestException, ValueError) as e:
-                log.debug(f"Could not fetch {what} from {url}: {e}")
+                logger.debug(f"Could not fetch {what} from {url}: {e}")
                 continue
 
             os.makedirs(os.path.dirname(filename) or ".", exist_ok=True)
@@ -319,11 +319,11 @@ class ResourceManager:
             with open(tmp, "w", encoding="utf-8") as f:
                 json.dump(document, f, indent=2)
             os.replace(tmp, filename)  # single atomic write
-            log.debug(f"{what} updated from {url}")
+            logger.debug(f"{what} updated from {url}")
             return document
 
         if cached:
-            log.warning(f"Could not reach any {what} URL, using the cached copy")
+            logger.warning(f"Could not reach any {what} URL, using the cached copy")
             os.utime(filename, None)  # back off instead of retrying on every call
             return cached
 
@@ -402,7 +402,7 @@ class ResourceManager:
         thread pool is the right tool here.
         """
         resources = self.__all_resources()
-        log.info(f"Loading {len(resources)} EMSO metadata resources ({self.max_threads} threads)...")
+        logger.info(f"Loading {len(resources)} EMSO metadata resources ({self.max_threads} threads)...")
         t = time.time()
 
         def worker(resource):
@@ -425,7 +425,7 @@ class ResourceManager:
         self.__save_state()
 
         downloaded = sum(1 for r in resources if r.downloaded)
-        log.info(f"Loaded {len(resources)} resources in {time.time() - t:.02f} s "
+        logger.info(f"Loaded {len(resources)} resources in {time.time() - t:.02f} s "
                  f"({downloaded} downloaded, {len(resources) - downloaded} from cache)")
 
     def __save_state(self):
@@ -435,7 +435,7 @@ class ResourceManager:
                 json.dump(self.__state, f, indent=2)
             os.replace(tmp, self.__state_file)
         except OSError as e:
-            log.debug(f"Could not write the cache state file: {e}")  # purely an optimisation, never fatal
+            logger.debug(f"Could not write the cache state file: {e}")  # purely an optimisation, never fatal
 
     # ------------------------------------------------------------------ accessors
     def __contains__(self, name):

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/metadata/tests.py

@@ -74,7 +74,7 @@ class EmsoMetadataTester:
         error = False
         for test in all_tests:
             if test not in self.implemented_tests.keys():
-                logging.error(f"ERROR test {test} not implemented!")
+                logger.error(f"ERROR test {test} not implemented!")
                 error = True
         if error:
             raise ValueError("Some tests are not implemented")
@@ -222,7 +222,7 @@ class EmsoMetadataTester:
 
         if attribute in metadata.keys():
             if test_name not in self.implemented_tests.keys():
-                logging.error(f"Test '{test_name}' not implemented!")
+                logger.error(f"Test '{test_name}' not implemented!")
 
             else:
                 implemented = True
@@ -257,7 +257,7 @@ class EmsoMetadataTester:
                     try:
                         p, m = test_method(v, args)  # apply test method
                     except Exception as e:
-                        logging.error(f"Error when executing test '{test_name}' with arguments '{args}' and value '{v}'")
+                        logger.error(f"Error when executing test '{test_name}' with arguments '{args}' and value '{v}'")
                         raise e
                     if not m:
                         m = "ok"  # instead of empty message just leave ok
@@ -340,7 +340,7 @@ class EmsoMetadataTester:
             multiple = row["Multiple"]
             annotation = row["annotations"]
             if not test_name:
-                logging.warning(f"WARNING: test for {attribute} not implemented!")
+                logger.warning(f"WARNING: test for {attribute} not implemented!")
                 continue
 
             args = []
@@ -382,7 +382,7 @@ class EmsoMetadataTester:
         else:
             dataset_id = global_attr["title"]
 
-        logging.info(f"==== Validating dataset '{CYN}{global_attr['title']}{RST}' ====")
+        logger.info(f"==== Validating dataset '{CYN}{global_attr['title']}{RST}' ====")
 
         # Test global attributes
         if "global" in variable_filter or not variable_filter:
@@ -445,7 +445,7 @@ class EmsoMetadataTester:
     # ------------ EDMO -------- #
     def edmo_code(self, value, args):
         if type(value) == str:
-            logging.warning("EDMO code should be integer! converting from string to int")
+            logger.warning("EDMO code should be integer! converting from string to int")
             try:
                 value = int(value)
             except ValueError:

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/metadata/utils.py

@@ -33,6 +33,10 @@ NRM = "\x1B[0m"
 PRL = "\033[95m"
 RST = "\033[0m"
 
+EMH_LOGGER_NAME = "emso_metadata_harmonizer"
+
+logger = logging.getLogger(EMH_LOGGER_NAME)
+
 
 def group_metadata_variables(metadata):
     """
@@ -147,12 +151,11 @@ def download_file(url: str, filename: str, headers: Optional[Dict[str, str]] = N
                 if chunk:
                     file.write(chunk)
     except (HTTPError, requests.exceptions.ConnectionError) as e:
-        log = logging.getLogger()
         if alternative:
-            log.warning(f"Failed to fetch URL, using alternative {alternative}")
+            logger.warning(f"Failed to fetch URL, using alternative {alternative}")
             download_file(alternative, filename, headers=headers, chunk_size=chunk_size, alternative="")
         else:
-            log.error(f"Failed to fetch URL {url}")
+            logger.error(f"Failed to fetch URL {url}")
             raise e
 
 
@@ -227,23 +230,21 @@ def get_dir_list(dir_name):
 
 
 class LoggerSuperclass:
-    def __init__(self, logger: logging.Logger, name: str, colour=NRM):
+    def __init__(self, name: str, colour=NRM):
         """
         SuperClass that defines logging as class methods adding a heading name
         """
         self._logger_name = name
-        self.__logger = logger
-        if not logger:
-            self.__logger = logging  # if not assign the generic module
+        self.logger = logging.getLogger(EMH_LOGGER_NAME)
         self._log_colour = colour
 
     def warning(self, *args):
         mystr = YEL + "[%s] " % self._logger_name + str(*args) + RST
-        self.__logger.warning(mystr)
+        self.logger.warning(mystr)
 
     def error(self, *args, exception: any = False):
         mystr = "[%s] " % self._logger_name + str(*args)
-        self.__logger.error(RED + mystr + RST)
+        self.logger.error(RED + mystr + RST)
         if exception:
             if isinstance(exception, bool):
                 raise ValueError(mystr)
@@ -252,14 +253,16 @@ class LoggerSuperclass:
 
     def debug(self, *args):
         mystr = self._log_colour + "[%s] " % self._logger_name + str(*args) + RST
-        self.__logger.debug(mystr)
+        self.logger.debug(mystr)
 
     def info(self, *args):
         mystr = self._log_colour + "[%s] " % self._logger_name + str(*args) + RST
-        self.__logger.info(mystr)
+        self.logger.info(mystr)
 
     def setLevel(self, level):
-        self.__logger.setLevel(level)
+        self.logger.setLevel(level)
+
+
 
 
 def setup_log(name, path="log", log_level="debug"):
@@ -298,7 +301,7 @@ def setup_log(name, path="log", log_level="debug"):
     if not filename.endswith(".log"):
         filename += ".log"
 
-    logger = logging.getLogger()
+    logger = logging.getLogger(EMH_LOGGER_NAME)
     logger.setLevel(level)
     log_formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(levelname)-7s: %(message)s',
                                       datefmt='%Y-%m-%d %H:%M:%S')

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/metadata/vocabularies.py

@@ -9,15 +9,15 @@ structures, so the harmonizer needs no RDF toolchain and no downloads of its own
 """
 import logging
 import pandas as pd
-from .utils import LoggerSuperclass, BLU
+from .utils import LoggerSuperclass, BLU, EMH_LOGGER_NAME
 
+logger = logging.getLogger(EMH_LOGGER_NAME)
 
 
 class GenericVocabulary(LoggerSuperclass):
     def __init__(self, code, name, uri) -> None:
 
-        log = logging.getLogger()
-        LoggerSuperclass.__init__(self, log, code, colour=BLU)
+        LoggerSuperclass.__init__(self, code, colour=BLU)
 
         self.labels = []  # labels as they are
         self.labels_lc = []  # labels as lower case for easier comparison
@@ -204,8 +204,6 @@ class OSO(GenericVocabulary):
     def get_uri_from_name(self, name, cls):
         assert cls in ["rfs", "sites", "platforms"]
 
-        log = logging.getLogger()
-
         if cls == "rfs":
             df = self.rfs
         elif cls == "sites":
@@ -215,17 +213,15 @@ class OSO(GenericVocabulary):
         try:
             uri = df.loc[df["label"] == name]["uri"].values[0]
         except (KeyError, IndexError):
-            log.error(f"ERROR: OSO does not have any '{cls}' with label '{name}', valid names:")
+            self.error(f"ERROR: OSO does not have any '{cls}' with label '{name}', valid names:")
             for a in df['label'].unique():
-                log.error(f"    - '{a}'")
+                self.error(f"    - '{a}'")
             return ""
         return str(uri)
 
     def get_name_from_uri(self, uri, cls):
         assert cls in ["rfs", "sites", "platforms"]
 
-        log = logging.getLogger()
-
         if cls == "rfs":
             df = self.rfs
         elif cls == "sites":
@@ -235,9 +231,9 @@ class OSO(GenericVocabulary):
         try:
             uri = df.loc[df["uri"] == uri]["label"].values[0]
         except (KeyError, IndexError):
-            log.error(f"ERROR: OSO does not have any '{cls}' with uri '{uri}', valid uris:")
+            self.error(f"ERROR: OSO does not have any '{cls}' with uri '{uri}', valid uris:")
             for a in df['uri'].unique():
-                log.info(f"    - '{a}'")
+                self.info(f"    - '{a}'")
             return ""
         return str(uri)
 
@@ -288,7 +284,7 @@ class Keyword:
         }
         r =  mapping.get(title, "undefined")
         if r == "undefined":
-            logging.warning(f"Could not find type for '{self.name}' ({self.vocab_code})")
+            logger.warning(f"Could not find type for '{self.name}' ({self.vocab_code})")
         return r
 
     def __repr__(self) -> str:

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/metadata/waterframe.py

@@ -26,7 +26,7 @@ from .metadata_templates import time_valid_names, depth_valid_names, latitude_va
 from . import init_emso_metadata
 from .constants import iso_time_format
 from .metadata_templates import dimension_metadata, quality_control_metadata
-from .utils import LoggerSuperclass, CYN
+from .utils import LoggerSuperclass, CYN, EMH_LOGGER_NAME
 from .vocabularies import Keyword
 
 try:
@@ -37,7 +37,7 @@ except ImportError:
 
 emso = None  # Global variable used to avoid duplicated EMSO metadata objects in different waterframes
 
-logger = logging.getLogger("emso_metadata_harmonizer")
+logger = logging.getLogger(EMH_LOGGER_NAME)
 
 
 # Make sure that we have all the coordinates
@@ -89,7 +89,7 @@ class WaterFrame(LoggerSuperclass):
         self._time, self._depth, self._latitude, self._longitude, self._sensor_id, self._platform_id = \
             get_coordinates_from_dataframe(df)
 
-        LoggerSuperclass.__init__(self, logger, "WF", colour=CYN)
+        LoggerSuperclass.__init__(self, "WF", colour=CYN)
         global emso
         if not emso:
             emso = init_emso_metadata()
@@ -888,7 +888,6 @@ class WaterFrame(LoggerSuperclass):
 
     @staticmethod
     def from_erddap(url, dataset_id, protocol="tabledap", permissive=True, data_from="") -> "WaterFrame":
-        logger = logging.getLogger()
         url = f"{url}/{protocol}/{dataset_id}.nc"
 
         if data_from and isinstance(data_from, pd.Timestamp):
@@ -1339,11 +1338,10 @@ class OperationalTester:
         success = len(self.errors) == 0
 
         if self.quiet:
-            log = logging.getLogger()
             if success:
-                log.info("Operational tests: ✅ the NetCDF file is operationally sound!")
+                logger.info("Operational tests: ✅ the NetCDF file is operationally sound!")
             else:
-                log.info("Operational tests: ❌ the NetCDF file is not operationally valid")
+                logger.info("Operational tests: ❌ the NetCDF file is not operationally valid")
 
         report = {
             "valid": success,
@@ -1496,11 +1494,10 @@ class KeywordTester:
 
         if self.quiet:
             # stdout is disabled, so report the outcome through the logger
-            log = logging.getLogger()
             if self.errors or self.warnings:
-                log.info("Keywords check: ❌ errors encountered")
+                logger.info("Keywords check: ❌ errors encountered")
             else:
-                log.info("Keywords check: ✅ passed")
+                logger.info("Keywords check: ✅ passed")
 
         return self.errors, self.warnings
 

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2}/src/emso_metadata_harmonizer/report.py

@@ -24,8 +24,9 @@ from .metadata import  EmsoMetadata
 from .metadata.utils import threadify
 from .metadata.dataset import get_netcdf_metadata
 from .metadata.tests import EmsoMetadataTester
+from .metadata.utils import EMH_LOGGER_NAME
 
-logger = logging.getLogger("emso_metadata_harmonizer")
+logger = logging.getLogger(EMH_LOGGER_NAME)
 
 def metadata_results_to_json(df: pd.DataFrame)-> dict:
     report = {"ERRORS": {}, "WARNINGS": {}}

{emso_metadata_harmonizer-1.1.0.dev1 → emso_metadata_harmonizer-1.1.0.dev2/src/emso_metadata_harmonizer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emso-metadata-harmonizer
-Version: 1.1.0.dev1
+Version: 1.1.0.dev2
 Summary:  Toolbox for creating/assessing EMSO-compliant NetCDF datasets and integrate them into ERDDAP services
 Author-email: Enoc Martínez <enoc.martinez@upc.edu>
 Maintainer-email: Enoc Martínez <enoc.martinez@upc.edu>