grobid-client-python 0.0.12__py3-none-any.whl → 0.0.13__py3-none-any.whl

grobid_client/grobid_client.py

@@ -15,7 +15,6 @@ which is not implemented for the moment.
 
 """
 import os
-import io
 import json
 import argparse
 import time
@@ -23,58 +22,234 @@ import concurrent.futures
 import ntpath
 import requests
 import pathlib
+import logging
+from typing import Tuple
 
 from .client import ApiClient
 
 
 class ServerUnavailableException(Exception):
-    pass
+    """Exception raised when GROBID server is not available or not responding."""
+
+    def __init__(self, message="GROBID server is not available"):
+        super().__init__(message)
+        self.message = message
+
 
 class GrobidClient(ApiClient):
 
-    def __init__(self, grobid_server='localhost', 
-                 batch_size=1000, 
-                 coordinates=["persName", "figure", "ref", "biblStruct", "formula", "s", "note", "title"], 
-                 sleep_time=5,
-                 timeout=60,
-                 config_path=None, 
-                 check_server=True):
+    def __init__(
+            self,
+            grobid_server='http://localhost:8070',
+            batch_size=1000,
+            coordinates=None,
+            sleep_time=5,
+            timeout=60,
+            config_path=None,
+            check_server=True
+    ):
+        # Set default coordinates if None provided
+        if coordinates is None:
+            coordinates = [
+                "title",
+                "persName",
+                "affiliation",
+                "orgName",
+                "formula",
+                "figure",
+                "ref",
+                "biblStruct",
+                "head",
+                "p",
+                "s",
+                "note"
+            ]
+
         self.config = {
             'grobid_server': grobid_server,
             'batch_size': batch_size,
             'coordinates': coordinates,
             'sleep_time': sleep_time,
-            'timeout': timeout
+            'timeout': timeout,
+            'logging': {
+                'level': 'INFO',
+                'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                'console': True,
+                'file': None,  # Disabled by default
+                'max_file_size': '10MB',
+                'backup_count': 3
+            }
         }
+
+        # Load config first (which may override logging settings)
         if config_path:
             self._load_config(config_path)
+
+        # Configure logging based on config
+        self._configure_logging()
+
         if check_server:
             self._test_server_connection()
 
+    def _configure_logging(self):
+        """Configure logging based on the configuration settings."""
+        # Get logging config with defaults
+        log_config = self.config.get('logging', {})
+
+        # Parse log level
+        log_level_str = log_config.get('level', 'INFO').upper()
+        log_level = getattr(logging, log_level_str, logging.INFO)
+
+        # Parse log format
+        log_format = log_config.get('format', '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+        # Create formatter
+        formatter = logging.Formatter(log_format)
+
+        # Configure the logger
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(log_level)
+
+        # Clear any existing handlers to avoid duplicates
+        for handler in self.logger.handlers[:]:
+            self.logger.removeHandler(handler)
+
+        # Console handler
+        if log_config.get('console', True):
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(log_level)
+            console_handler.setFormatter(formatter)
+            self.logger.addHandler(console_handler)
+
+        # File handler
+        log_file = log_config.get('file')
+        if log_file:
+            try:
+                # Parse file size (support formats like "10MB", "1GB", etc.)
+                max_bytes = self._parse_file_size(log_config.get('max_file_size', '10MB'))
+                backup_count = log_config.get('backup_count', 3)
+
+                from logging.handlers import RotatingFileHandler
+                file_handler = RotatingFileHandler(
+                    log_file,
+                    maxBytes=max_bytes,
+                    backupCount=backup_count
+                )
+                file_handler.setLevel(log_level)
+                file_handler.setFormatter(formatter)
+                self.logger.addHandler(file_handler)
+
+                self.logger.debug(
+                    f"File logging configured: {log_file} (max size: {max_bytes}, backups: {backup_count})")
+            except Exception as e:
+                # Fallback to basic file handler if rotating handler fails
+                try:
+                    file_handler = logging.FileHandler(log_file)
+                    file_handler.setLevel(log_level)
+                    file_handler.setFormatter(formatter)
+                    self.logger.addHandler(file_handler)
+                    self.logger.warning(f"Using basic file handler due to error with rotating handler: {e}")
+                except Exception as file_error:
+                    self.logger.warning(f"Could not configure file logging: {file_error}")
+
+        self.logger.info(
+            f"Logging configured - Level: {log_level_str}, Console: {log_config.get('console', True)}, File: {log_file or 'disabled'}")
+
+    def _parse_file_size(self, size_str):
+        """Parse file size string like '10MB', '1GB' to bytes."""
+        size_str = str(size_str).upper().strip()
+
+        # Extract number and unit
+        import re
+        match = re.match(r'(\d+(?:\.\d+)?)\s*([KMGT]?B?)', size_str)
+        if not match:
+            return 10 * 1024 * 1024  # Default 10MB
+
+        number = float(match.group(1))
+        unit = match.group(2)
+
+        # Convert to bytes
+        multipliers = {
+            '': 1,
+            'B': 1,
+            'KB': 1024,
+            'MB': 1024 ** 2,
+            'GB': 1024 ** 3,
+            'TB': 1024 ** 4
+        }
+
+        return int(number * multipliers.get(unit, 1))
+
     def _load_config(self, path="./config.json"):
         """
-        Load the json configuration
+        Load and merge configuration from a JSON file with default values.
+        If the file doesn't exist, keep the default values.
+
+        Args:
+            path (str): Path to the JSON configuration file
+
+        Raises:
+            FileNotFoundError: If the config file is not found
+            json.JSONDecodeError: If the config file contains invalid JSON
+            Exception: For other file reading errors
         """
-        config_json = open(path).read()
-        self.config = json.loads(config_json)
+        # Create a temporary logger for configuration loading since main logger isn't configured yet
+        temp_logger = logging.getLogger(f"{__name__}.config_loader")
+        if not temp_logger.handlers:
+            temp_handler = logging.StreamHandler()
+            temp_handler.setFormatter(logging.Formatter('%(levelname)s - %(message)s'))
+            temp_logger.addHandler(temp_handler)
+            temp_logger.setLevel(logging.INFO)
 
-    def _test_server_connection(self):
-        """Test if the server is up and running."""
+        try:
+            temp_logger.info(f"Loading configuration file from {path}")
+            with open(path, 'r') as config_file:
+                config_json = config_file.read()
+                # Update the default config with values from the file
+                file_config = json.loads(config_json)
+                self.config.update(file_config)
+                temp_logger.info("Configuration file loaded successfully")
+        except FileNotFoundError as e:
+            # If config file doesn't exist, keep using default values
+            error_msg = f"The specified config file {path} was not found. Check the path or leave it blank to use the default configuration."
+            temp_logger.error(error_msg)
+            raise FileNotFoundError(error_msg) from e
+        except json.JSONDecodeError as e:
+            # If config exists, but it's invalid, we raise an exception
+            error_msg = f"Could not parse config file at {path}: {str(e)}"
+            temp_logger.error(error_msg)
+            raise json.JSONDecodeError(error_msg, e.doc, e.pos) from e
+        except Exception as e:
+            error_msg = f"Error reading config file at {path}: {str(e)}"
+            temp_logger.error(error_msg)
+            raise Exception(error_msg) from e
+
+    def _test_server_connection(self) -> Tuple[bool, int]:
+        """Test if the server is up and running.
+
+        Returns:
+            tuple: (is_available, status_code)
+
+        Raises:
+            ServerUnavailableException: If server is not reachable
+        """
         the_url = self.get_server_url("isalive")
         try:
-            r = requests.get(the_url)
-        except:
-            print("GROBID server does not appear up and running, the connection to the server failed")
-            raise ServerUnavailableException
+            r = requests.get(the_url, timeout=10)
+            status = r.status_code
 
-        status = r.status_code
+            if status != 200:
+                error_msg = f"GROBID server {self.config['grobid_server']} does not appear up and running (status: {status})"
+                self.logger.error(error_msg)
+                return False, status
+            else:
+                self.logger.info(f"GROBID server {self.config['grobid_server']} is up and running")
+                return True, status
 
-        if status != 200:
-            print("GROBID server does not appear up and running " + str(status))
-            return False, status
-        else:
-            print("GROBID server is up and running")
-            return True, status
+        except requests.exceptions.RequestException as e:
+            error_msg = f"GROBID server {self.config['grobid_server']} does not appear up and running, connection failed: {str(e)}"
+            self.logger.error(error_msg)
+            raise ServerUnavailableException(error_msg) from e
 
     def _output_file_name(self, input_file, input_path, output):
         # we use ntpath here to be sure it will work on Windows too
@@ -92,7 +267,7 @@ class GrobidClient(ApiClient):
 
         return filename
 
-    def ping(self) -> (bool, int):
+    def ping(self) -> Tuple[bool, int]:
         """
         Check the Grobid service. Returns True if the service is up.
         In addition, returns also the status code.
@@ -100,61 +275,85 @@ class GrobidClient(ApiClient):
         return self._test_server_connection()
 
     def process(
-        self,
-        service,
-        input_path,
-        output=None,
-        n=10,
-        generateIDs=False,
-        consolidate_header=True,
-        consolidate_citations=False,
-        include_raw_citations=False,
-        include_raw_affiliations=False,
-        tei_coordinates=False,
-        segment_sentences=False,
-        force=True,
-        verbose=False,
-        flavor=None
+            self,
+            service,
+            input_path,
+            output=None,
+            n=10,
+            generateIDs=False,
+            consolidate_header=True,
+            consolidate_citations=False,
+            include_raw_citations=False,
+            include_raw_affiliations=False,
+            tei_coordinates=False,
+            segment_sentences=False,
+            force=True,
+            verbose=False,
+            flavor=None
     ):
         batch_size_pdf = self.config["batch_size"]
-        input_files = []
 
+        # First pass: count all eligible files
+        all_input_files = []
         for (dirpath, dirnames, filenames) in os.walk(input_path):
             for filename in filenames:
                 if filename.endswith(".pdf") or filename.endswith(".PDF") or \
-                    (service == 'processCitationList' and (filename.endswith(".txt") or filename.endswith(".TXT"))) or \
-                    (service == 'processCitationPatentST36' and (filename.endswith(".xml") or filename.endswith(".XML"))):
-                    if verbose:
-                        try:
-                            print(filename)
-                        except Exception:
-                            # may happen on linux see https://stackoverflow.com/questions/27366479/python-3-os-walk-file-paths-unicodeencodeerror-utf-8-codec-cant-encode-s
-                            pass
-                    input_files.append(os.sep.join([dirpath, filename]))
-
-                    if len(input_files) == batch_size_pdf:
-                        self.process_batch(
-                            service,
-                            input_files,
-                            input_path,
-                            output,
-                            n,
-                            generateIDs,
-                            consolidate_header,
-                            consolidate_citations,
-                            include_raw_citations,
-                            include_raw_affiliations,
-                            tei_coordinates,
-                            segment_sentences,
-                            force,
-                            verbose,
-                            flavor
-                        )
-                        input_files = []
+                        (service == 'processCitationList' and (
+                                filename.endswith(".txt") or filename.endswith(".TXT"))) or \
+                        (service == 'processCitationPatentST36' and (
+                                filename.endswith(".xml") or filename.endswith(".XML"))):
+                    full_path = os.sep.join([dirpath, filename])
+                    all_input_files.append(full_path)
+
+        # Log total files found
+        total_files = len(all_input_files)
+        if total_files == 0:
+            self.logger.warning(f"No eligible files found in {input_path}")
+            return
+
+        self.logger.info(f"Found {total_files} file(s) to process")
+
+        # Counter for actually processed files
+        processed_files_count = 0
+        input_files = []
+
+        for input_file in all_input_files:
+            # Extract just the filename for verbose logging
+            filename = os.path.basename(input_file)
+
+            if verbose:
+                try:
+                    self.logger.info(f"Found file: {filename}")
+                except UnicodeEncodeError:
+                    # may happen on linux see https://stackoverflow.com/questions/27366479/python-3-os-walk-file-paths-unicodeencodeerror-utf-8-codec-cant-encode-s
+                    self.logger.warning(f"Could not log filename due to encoding issues")
+
+            input_files.append(input_file)
+
+            if len(input_files) == batch_size_pdf:
+                batch_processed = self.process_batch(
+                    service,
+                    input_files,
+                    input_path,
+                    output,
+                    n,
+                    generateIDs,
+                    consolidate_header,
+                    consolidate_citations,
+                    include_raw_citations,
+                    include_raw_affiliations,
+                    tei_coordinates,
+                    segment_sentences,
+                    force,
+                    verbose,
+                    flavor
+                )
+                processed_files_count += batch_processed
+                input_files = []
 
         # last batch
         if len(input_files) > 0:
-            self.process_batch(
+            batch_processed = self.process_batch(
                 service,
                 input_files,
                 input_path,
@@ -170,37 +369,44 @@ class GrobidClient(ApiClient):
                 force,
                 verbose,
             )
+            processed_files_count += batch_processed
+
+        # Log final statistics
+        self.logger.info(f"Processing completed: {processed_files_count} out of {total_files} files processed")
 
     def process_batch(
-        self,
-        service,
-        input_files,
-        input_path,
-        output,
-        n,
-        generateIDs,
-        consolidate_header,
-        consolidate_citations,
-        include_raw_citations,
-        include_raw_affiliations,
-        tei_coordinates,
-        segment_sentences,
-        force,
-        verbose=False,
-        flavor=None
+            self,
+            service,
+            input_files,
+            input_path,
+            output,
+            n,
+            generateIDs,
+            consolidate_header,
+            consolidate_citations,
+            include_raw_citations,
+            include_raw_affiliations,
+            tei_coordinates,
+            segment_sentences,
+            force,
+            verbose=False,
+            flavor=None
     ):
         if verbose:
-            print(len(input_files), "files to process in current batch")
+            self.logger.info(f"{len(input_files)} files to process in current batch")
+
+        processed_count = 0
 
         # we use ThreadPoolExecutor and not ProcessPoolExecutor because it is an I/O intensive process
         with concurrent.futures.ThreadPoolExecutor(max_workers=n) as executor:
-            #with concurrent.futures.ProcessPoolExecutor(max_workers=n) as executor:
+            # with concurrent.futures.ProcessPoolExecutor(max_workers=n) as executor:
             results = []
             for input_file in input_files:
                 # check if TEI file is already produced
                 filename = self._output_file_name(input_file, input_path, output)
                 if not force and os.path.isfile(filename):
-                    print(filename, "already exist, skipping... (use --force to reprocess pdf input files)")
+                    self.logger.info(
+                        f"{filename} already exists, skipping... (use --force to reprocess pdf input files)")
                     continue
 
                 selected_process = self.process_pdf
@@ -208,8 +414,8 @@ class GrobidClient(ApiClient):
                     selected_process = self.process_txt
 
                 if verbose:
-                    print(f"Adding {input_file} to the queue.")
-                
+                    self.logger.info(f"Adding {input_file} to the queue")
+
                 r = executor.submit(
                     selected_process,
                     service,
@@ -230,44 +436,55 @@ class GrobidClient(ApiClient):
         for r in concurrent.futures.as_completed(results):
             input_file, status, text = r.result()
             filename = self._output_file_name(input_file, input_path, output)
+            processed_count += 1
 
             if status != 200 or text is None:
-                print("Processing of", input_file, "failed with error", str(status), ",", text)
+                self.logger.error(f"Processing of {input_file} failed with error {status}: {text}")
                 # writing error file with suffixed error code
                 try:
                     pathlib.Path(os.path.dirname(filename)).mkdir(parents=True, exist_ok=True)
-                    with open(filename.replace(".grobid.tei.xml", "_"+str(status)+".txt"), 'w', encoding='utf8') as tei_file:
+                    error_filename = filename.replace(".grobid.tei.xml", f"_{status}.txt")
+                    with open(error_filename, 'w', encoding='utf8') as error_file:
                         if text is not None:
-                            tei_file.write(text)
+                            error_file.write(text)
                         else:
-                            tei_file.write("")
-                except OSError:
-                    print("Writing resulting TEI XML file", filename, "failed")
+                            error_file.write("")
+                    self.logger.info(f"Error details written to {error_filename}")
+                except OSError as e:
+                    self.logger.error(f"Failed to write error file {filename}: {str(e)}")
             else:
                 # writing TEI file
                 try:
                     pathlib.Path(os.path.dirname(filename)).mkdir(parents=True, exist_ok=True)
-                    with open(filename,'w',encoding='utf8') as tei_file:
+                    with open(filename, 'w', encoding='utf8') as tei_file:
                         tei_file.write(text)
-                except OSError:
-                   print("Writing resulting TEI XML file", filename, "failed")
+                    self.logger.debug(f"Successfully wrote TEI file: {filename}")
+                except OSError as e:
+                    self.logger.error(f"Failed to write TEI XML file {filename}: {str(e)}")
+
+        return processed_count
 
     def process_pdf(
-        self,
-        service,
-        pdf_file,
-        generateIDs,
-        consolidate_header,
-        consolidate_citations,
-        include_raw_citations,
-        include_raw_affiliations,
-        tei_coordinates,
-        segment_sentences,
-        flavor=None,
-        start=-1,
-        end=-1
+            self,
+            service,
+            pdf_file,
+            generateIDs,
+            consolidate_header,
+            consolidate_citations,
+            include_raw_citations,
+            include_raw_affiliations,
+            tei_coordinates,
+            segment_sentences,
+            flavor=None,
+            start=-1,
+            end=-1
     ):
-        pdf_handle = open(pdf_file, "rb")
+        try:
+            pdf_handle = open(pdf_file, "rb")
+        except IOError as e:
+            self.logger.error(f"Failed to open PDF file {pdf_file}: {str(e)}")
+            return (pdf_file, 500, f"Failed to open file: {str(e)}")
+
         files = {
             "input": (
                 pdf_file,
@@ -276,7 +493,7 @@ class GrobidClient(ApiClient):
                 {"Expires": "0"},
             )
         }
-        
+
         the_url = self.get_server_url(service)
 
         # set the GROBID parameters
@@ -304,10 +521,12 @@ class GrobidClient(ApiClient):
 
         try:
             res, status = self.post(
-                url=the_url, files=files, data=the_data, headers={"Accept": "text/plain"}, timeout=self.config['timeout']
+                url=the_url, files=files, data=the_data, headers={"Accept": "text/plain"},
+                timeout=self.config['timeout']
             )
 
             if status == 503:
+                self.logger.warning(f"Server busy (503), retrying {pdf_file} after {self.config['sleep_time']} seconds")
                 time.sleep(self.config["sleep_time"])
                 return self.process_pdf(
                     service,
@@ -319,13 +538,22 @@ class GrobidClient(ApiClient):
                     include_raw_affiliations,
                     tei_coordinates,
                     segment_sentences,
+                    flavor,
                     start,
-                    end,
-                    flavor
+                    end
                 )
-        except requests.exceptions.ReadTimeout:
+        except requests.exceptions.ReadTimeout as e:
+            self.logger.error(f"Request timeout for {pdf_file}: {str(e)}")
+            pdf_handle.close()
+            return (pdf_file, 408, f"Request timeout: {str(e)}")
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Request failed for {pdf_file}: {str(e)}")
             pdf_handle.close()
-            return (pdf_file, 408, None)
+            return (pdf_file, 500, f"Request failed: {str(e)}")
+        except Exception as e:
+            self.logger.error(f"Unexpected error processing {pdf_file}: {str(e)}")
+            pdf_handle.close()
+            return (pdf_file, 500, f"Unexpected error: {str(e)}")
 
         pdf_handle.close()
         return (pdf_file, status, res.text)
@@ -334,21 +562,27 @@ class GrobidClient(ApiClient):
         return self.config['grobid_server'] + "/api/" + service
 
     def process_txt(
-        self,
-        service,
-        txt_file,
-        generateIDs,
-        consolidate_header,
-        consolidate_citations,
-        include_raw_citations,
-        include_raw_affiliations,
-        tei_coordinates,
-        segment_sentences
+            self,
+            service,
+            txt_file,
+            generateIDs,
+            consolidate_header,
+            consolidate_citations,
+            include_raw_citations,
+            include_raw_affiliations,
+            tei_coordinates,
+            segment_sentences
     ):
         # create request based on file content
-        references = None
-        with open(txt_file) as f:
-            references = [line.rstrip() for line in f]
+        try:
+            with open(txt_file, 'r', encoding='utf-8') as f:
+                references = [line.rstrip() for line in f]
+        except IOError as e:
+            self.logger.error(f"Failed to read text file {txt_file}: {str(e)}")
+            return (txt_file, 500, f"Failed to read file: {str(e)}")
+        except UnicodeDecodeError as e:
+            self.logger.error(f"Unicode decode error reading {txt_file}: {str(e)}")
+            return (txt_file, 500, f"Unicode decode error: {str(e)}")
 
         the_url = self.get_server_url(service)
 
@@ -359,29 +593,46 @@ class GrobidClient(ApiClient):
         if include_raw_citations:
             the_data["includeRawCitations"] = "1"
         the_data["citations"] = references
-        res, status = self.post(
-            url=the_url, data=the_data, headers={"Accept": "application/xml"}
-        )
 
-        if status == 503:
-            time.sleep(self.config["sleep_time"])
-            return self.process_txt(
-                service,
-                txt_file,
-                generateIDs,
-                consolidate_header,
-                consolidate_citations,
-                include_raw_citations,
-                include_raw_affiliations,
-                tei_coordinates,
-                segment_sentences
+        try:
+            res, status = self.post(
+                url=the_url, data=the_data, headers={"Accept": "application/xml"}
             )
 
+            if status == 503:
+                self.logger.warning(f"Server busy (503), retrying {txt_file} after {self.config['sleep_time']} seconds")
+                time.sleep(self.config["sleep_time"])
+                return self.process_txt(
+                    service,
+                    txt_file,
+                    generateIDs,
+                    consolidate_header,
+                    consolidate_citations,
+                    include_raw_citations,
+                    include_raw_affiliations,
+                    tei_coordinates,
+                    segment_sentences
+                )
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Request failed for {txt_file}: {str(e)}")
+            return (txt_file, 500, f"Request failed: {str(e)}")
+        except Exception as e:
+            self.logger.error(f"Unexpected error processing {txt_file}: {str(e)}")
+            return (txt_file, 500, f"Unexpected error: {str(e)}")
+
         return (txt_file, status, res.text)
 
+
 def main():
+    # Basic logging setup for initialization only
+    # The actual logging configuration will be done by GrobidClient based on config.json
+    temp_logger = logging.getLogger(__name__)
+    temp_handler = logging.StreamHandler()
+    temp_handler.setFormatter(logging.Formatter('%(levelname)s - %(message)s'))
+    temp_logger.addHandler(temp_handler)
+    temp_logger.setLevel(logging.INFO)
+
     valid_services = [
-        "processFulltextDocumentBlank",
         "processFulltextDocument",
         "processHeaderDocument",
         "processReferences",
@@ -393,10 +644,13 @@ def main():
     parser = argparse.ArgumentParser(description="Client for GROBID services")
     parser.add_argument(
         "service",
-        help="one of " + str(valid_services),
+        choices=valid_services,
+        help="Grobid service to be called.",
     )
     parser.add_argument(
-        "--input", default=None, help="path to the directory containing files to process: PDF or .txt (for processCitationList only, one reference per line), or .xml for patents in ST36"
+        "--input",
+        default=None,
+        help="path to the directory containing files to process: PDF or .txt (for processCitationList only, one reference per line), or .xml for patents in ST36"
     )
     parser.add_argument(
         "--output",
@@ -405,10 +659,14 @@ def main():
     )
     parser.add_argument(
         "--config",
-        default="./config.json",
-        help="path to the config file, default is ./config.json",
+        default=None,
+        help="path to the config file (optional)",
+    )
+    parser.add_argument(
+        "--n",
+        default=10,
+        help="concurrency for service usage"
     )
-    parser.add_argument("--n", default=10, help="concurrency for service usage")
     parser.add_argument(
         "--generateIDs",
         action="store_true",
@@ -468,22 +726,35 @@ def main():
     output_path = args.output
     flavor = args.flavor
 
+    # Initialize n with default value
+    n = 10
     if args.n is not None:
         try:
             n = int(args.n)
         except ValueError:
-            print("Invalid concurrency parameter n:", n, ", n = 10 will be used by default")
-            pass
+            temp_logger.warning(f"Invalid concurrency parameter n: {args.n}. Using default value n = 10")
+
+    # Initialize GrobidClient which will configure logging based on config.json
+    try:
+        client = GrobidClient(config_path=config_path)
+        # Now use the client's logger for all subsequent logging
+        logger = client.logger
+    except ServerUnavailableException as e:
+        temp_logger.error(f"Server unavailable: {str(e)}")
+        exit(1)
+    except Exception as e:
+        temp_logger.error(f"Failed to initialize GrobidClient: {str(e)}")
+        exit(1)
 
     # if output path does not exist, we create it
     if output_path is not None and not os.path.isdir(output_path):
         try:
-            print("output directory does not exist but will be created:", output_path)
+            logger.info(f"Output directory does not exist but will be created: {output_path}")
             os.makedirs(output_path)
-        except OSError:
-            print("Creation of the directory", output_path, "failed")
-        else:
-            print("Successfully created the directory", output_path)
+            logger.info(f"Successfully created the directory {output_path}")
+        except OSError as e:
+            logger.error(f"Creation of the directory {output_path} failed: {str(e)}")
+            exit(1)
 
     service = args.service
     generateIDs = args.generateIDs
@@ -496,36 +767,36 @@ def main():
     segment_sentences = args.segmentSentences
     verbose = args.verbose
 
-    if service is None or not service in valid_services:
-        print("Missing or invalid service, must be one of", valid_services)
-        exit(1)
-
-    try:
-        client = GrobidClient(config_path=config_path)
-    except ServerUnavailableException:
+    if service is None or service not in valid_services:
+        logger.error(f"Missing or invalid service '{service}', must be one of {valid_services}")
         exit(1)
 
     start_time = time.time()
 
-    client.process(
-        service,
-        input_path,
-        output=output_path,
-        n=n,
-        generateIDs=generateIDs,
-        consolidate_header=consolidate_header,
-        consolidate_citations=consolidate_citations,
-        include_raw_citations=include_raw_citations,
-        include_raw_affiliations=include_raw_affiliations,
-        tei_coordinates=tei_coordinates,
-        segment_sentences=segment_sentences,
-        force=force,
-        verbose=verbose,
-        flavor=flavor
-    )
+    try:
+        client.process(
+            service,
+            input_path,
+            output=output_path,
+            n=n,
+            generateIDs=generateIDs,
+            consolidate_header=consolidate_header,
+            consolidate_citations=consolidate_citations,
+            include_raw_citations=include_raw_citations,
+            include_raw_affiliations=include_raw_affiliations,
+            tei_coordinates=tei_coordinates,
+            segment_sentences=segment_sentences,
+            force=force,
+            verbose=verbose,
+            flavor=flavor
+        )
+    except Exception as e:
+        logger.error(f"Processing failed: {str(e)}")
+        exit(1)
 
     runtime = round(time.time() - start_time, 3)
-    print("runtime: %s seconds " % (runtime))
+    logger.info(f"Processing completed in {runtime} seconds")
+
 
 if __name__ == "__main__":
     main()

{grobid_client_python-0.0.12.dist-info → grobid_client_python-0.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grobid-client-python
-Version: 0.0.12
+Version: 0.0.13
 Summary: Simple python client for GROBID REST services
 Author-email: Patrice Lopez <patrice.lopez@science-miner.com>
 Maintainer-email: Patrice Lopez <patrice.lopez@science-miner.com>, Luca Foppiano <lucanoro@duck.com>
@@ -218,15 +218,12 @@ Requires-Dist: requests
 [![SWH](https://archive.softwareheritage.org/badge/origin/https://github.com/kermitt2/grobid_client_python/)](https://archive.softwareheritage.org/browse/origin/https://github.com/kermitt2/grobid_client_python/)
 [![License](http://img.shields.io/:license-apache-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.html)
 
-# Simple python client for GROBID REST services
+# Simple Python client for GROBID REST services
 
 This Python client can be used to process in an efficient concurrent manner a set of PDF in a given directory by the [GROBID](https://github.com/kermitt2/grobid) service. It includes a command line for processing PDF on a file system and write results in a given output directory and a library for import in other python scripts. The client can also process similarly a list of files with reference strings (one per line) and patents in XML ST36 formats.
 
-## Before you start
-
-Please be aware that, at the moment, [grobid does not support Windows](https://grobid.readthedocs.io/en/latest/Troubleshooting/#windows-related-issues).
-If you are a Windows user, don't worry. You can still [run grobid 
-via Docker](https://grobid.readthedocs.io/en/latest/Grobid-docker/).
+> [!IMPORTANT]
+> Please be aware that, at the moment, Grobid supports windows only through Docker containers. See [here](https://grobid.readthedocs.io/en/latest/Grobid-docker/).
 
 ## Build and run
 
@@ -314,11 +311,12 @@ optional arguments:
                         with additional <s> elements
   --verbose             print information about processed files in the console
   --flavor              specifcy the flavor to be used. Current accepted
-                        values: `article/light`, `article/light-ref`, `sdo/ietf`,
-                        however better check [here](https://grobid.readthedocs.io/en/latest/Grobid-specialized-processes/#flavors).
+                        values: `article/light`, `article/light-ref`, `sdo/ietf`.
+```
 
+> [!TIP]
+> Before using flavors, check [here](https://grobid.readthedocs.io/en/latest/Grobid-specialized-processes/#flavors).
 
-```
 
 Examples:
 
@@ -367,6 +365,9 @@ See also `example.py`.
 
 ## Configuration of the client
 
+> [!TIP]
+> from version 0.0.12 the `config.json` will be optional, by default the client will connect to the local server. 
+
 There are a few parameters that can be set with the `config.json` file. 
 
 - `grobid_server` indicates the URL of the GROBID server to be used by the client. 

grobid_client_python-0.0.13.dist-info/RECORD

@@ -0,0 +1,8 @@
+grobid_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+grobid_client/client.py,sha256=crvUiVnnkn6tFwO4lKQg2cTxAHZxCBAmeNSVtuL4ZA0,6009
+grobid_client/grobid_client.py,sha256=1ZHOhlPEgPDExK8RCYpZTq4M0kfMRVgrKEEpCCqUlZg,29533
+grobid_client_python-0.0.13.dist-info/METADATA,sha256=F1h_3LtqdZRhttiwmenPLeS4BBp8Ttk7MYG6HAOBXf0,24213
+grobid_client_python-0.0.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+grobid_client_python-0.0.13.dist-info/entry_points.txt,sha256=-WwPi8D8eXEbDB6QvitvHjxSGBeyLCyFvAoZcaDGswQ,67
+grobid_client_python-0.0.13.dist-info/top_level.txt,sha256=HnjgWxdJNKTLIN86XkgRAfVeEK4C71fc9X4fe7qdMvA,14
+grobid_client_python-0.0.13.dist-info/RECORD,,

grobid_client_python-0.0.12.dist-info/RECORD

@@ -1,8 +0,0 @@
-grobid_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-grobid_client/client.py,sha256=crvUiVnnkn6tFwO4lKQg2cTxAHZxCBAmeNSVtuL4ZA0,6009
-grobid_client/grobid_client.py,sha256=bt5gdmUEkhKVojI0y5yO9bW1BLT1Mf8EZ2ZKZmjfkII,18071
-grobid_client_python-0.0.12.dist-info/METADATA,sha256=XTZ0S_vrfhuN6EboeInLPGzzqT7RjwLsVRb6thNGJvs,24226
-grobid_client_python-0.0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-grobid_client_python-0.0.12.dist-info/entry_points.txt,sha256=-WwPi8D8eXEbDB6QvitvHjxSGBeyLCyFvAoZcaDGswQ,67
-grobid_client_python-0.0.12.dist-info/top_level.txt,sha256=HnjgWxdJNKTLIN86XkgRAfVeEK4C71fc9X4fe7qdMvA,14
-grobid_client_python-0.0.12.dist-info/RECORD,,