Merge pull request #676 from transformerlab/fix/logging-print

Change all incorrect logging statements in jobs router to print

Author: deep1401

transformerlab/routers/data.py

@@ -30,29 +30,19 @@
 
 from jinja2 import Environment
 from jinja2.sandbox import SandboxedEnvironment
-import logging
 from transformerlab.services import dataset_service as dataset_service_module
 
 
 jinja_environment = Environment()
 sandboxed_jinja2_environment = SandboxedEnvironment()
 
-logging.basicConfig(level=logging.ERROR)
-
-
-# Configure logging
-
 
 def log(msg):
     global_log_path = get_global_log_path()
     with open(global_log_path, "a") as f:
         f.write(msg + "\n")
 
 
-# logging.basicConfig(filename=GLOBAL_LOG_PATH, level=logging.INFO,
-#                     format='%(asctime)s - %(levelname)s - %(message)s')
-
-
 router = APIRouter(prefix="/data", tags=["datasets"])
 
 # Get list of datasets that we have in our hardcoded gallery
@@ -193,7 +183,7 @@ async def dataset_preview(
             else:
                 dataset = load_dataset(dataset_id, trust_remote_code=True, streaming=streaming)
     except Exception as e:
-        logging.error(f"Exception occurred: {type(e).__name__}: {e}")
+        print(f"Exception occurred: {type(e).__name__}: {e}")
         return {"status": "error", "message": "An internal error has occurred."}
 
     if split is None or split == "":
@@ -335,7 +325,7 @@ async def load_and_slice_dataset(dataset_id: str, offset: int, limit: int):
         try:
             dataset = dataset_service_module.load_local_dataset(dirs.dataset_dir_by_id(dataset_id))
         except Exception as e:
-            logging.error(f"Error loading dataset: {type(e).__name__}: {e}")
+            print(f"Error loading dataset: {type(e).__name__}: {e}")
             return {"status": "error", "message": "An internal error has occurred."}
         dataset_len = len(dataset["train"])
         result["columns"] = dataset["train"][offset : min(offset + limit, dataset_len)]
@@ -492,7 +482,7 @@ async def dataset_edit_with_template(
                     else:
                         continue
                 except Exception as e:
-                    logging.error(f"Failed to read metadata from {metadata_path}: {e}")
+                    print(f"Failed to read metadata from {metadata_path}: {e}")
                     return {"status": "error", "message": "Failed to read metadata file!"}
 
                 for entry in data:
@@ -523,7 +513,7 @@ async def dataset_edit_with_template(
                             encoded_img = base64.b64encode(buffer.getvalue()).decode("utf-8")
                             image_data_url = f"data:image/jpeg;base64,{encoded_img}"
                     except Exception as e:
-                        logging.error(f"Failed to process image {image_path}: {e}")
+                        print(f"Failed to process image {image_path}: {e}")
                         return {"status": "error", "message": "Failed to process images!"}
 
                     row = dict(entry)  # Start with all metadata fields
@@ -583,7 +573,7 @@ async def save_metadata(dataset_id: str, new_dataset_id: str, file: UploadFile):
     try:
         updates = json.loads(updates_raw.decode("utf-8"))
     except Exception as e:
-        logging.error(f"Invalid JSON file: {e}")
+        print(f"Invalid JSON file: {e}")
         return {"status": "error", "message": "Invalid JSON file!"}
 
     # Scan source metadata
@@ -627,7 +617,7 @@ async def save_metadata(dataset_id: str, new_dataset_id: str, file: UploadFile):
                             "metadata_root": root,
                         }
                 except Exception as e:
-                    logging.error(f"Error reading metadata {metadata_path}: {e}")
+                    print(f"Error reading metadata {metadata_path}: {e}")
                     return {"status": "error", "message": "Failed to read metadata!"}
 
     metadata_accumulator = {}
@@ -660,7 +650,7 @@ async def save_metadata(dataset_id: str, new_dataset_id: str, file: UploadFile):
         try:
             shutil.copy2(source_path, dest_path)
         except Exception as e:
-            logging.error(f"Failed to copy {source_path} to {dest_path}: {e}")
+            print(f"Failed to copy {source_path} to {dest_path}: {e}")
             return {"status": "error", "message": "Failed to copy from source to destination"}
 
         # Prepare metadata entry
@@ -687,7 +677,7 @@ async def save_metadata(dataset_id: str, new_dataset_id: str, file: UploadFile):
                     full_entry = {col: entry.get(col, "") for col in all_columns}
                     f.write(json.dumps(full_entry) + "\n")
         except Exception as e:
-            logging.error(f"Failed to write metadata file {metadata_file}: {e}")
+            print(f"Failed to write metadata file {metadata_file}: {e}")
             return {"status": "error", "message": "Failed to write metadata file!"}
 
     result = await dataset_new(dataset_id=new_dataset_id, generated=False)
@@ -778,7 +768,7 @@ async def dataset_download(dataset_id: str, config_name: str = None):
         )
         log(f"Dataset created in filesystem for dataset_id: {dataset_id}")
     except Exception as e:
-        logging.error(f"Failed to write dataset metadata to SDK store: {type(e).__name__}: {e}")
+        print(f"Failed to write dataset metadata to SDK store: {type(e).__name__}: {e}")
 
     # Download the dataset
     # Later on we can move this to a job
@@ -892,7 +882,7 @@ async def dataset_new(dataset_id: str, generated: bool = False):
             json_data={"generated": True} if generated else {},
         )
     except Exception as e:
-        logging.error(f"Failed to write dataset metadata to SDK store: {type(e).__name__}: {e}")
+        print(f"Failed to write dataset metadata to SDK store: {type(e).__name__}: {e}")
     return {"status": "success", "dataset_id": dataset_id}
 
 

transformerlab/routers/evals.py

@@ -87,7 +87,5 @@ async def compare_eval(job_list: str = ""):
         return JSONResponse(content=combined.to_json(orient="records"), media_type="application/json")
 
     except Exception:
-        import logging
-
-        logging.error("An error occurred while comparing evaluations", exc_info=True)
+        print("An error occurred while comparing evaluations")
         return {"error": "An internal error has occurred. Please try again later."}

transformerlab/routers/experiment/export.py

@@ -167,9 +167,8 @@ async def run_exporter_script(
                 }
 
     except Exception as e:
-        import logging
 
-        logging.error(f"Failed to export model. Exception: {e}")
+        print(f"Failed to export model. Exception: {e}")
         job = job_get(job_id)
         experiment_id = job["experiment_id"]
         await job_update_status(job_id=job_id, status="FAILED", experiment_id=experiment_id)

transformerlab/routers/experiment/jobs.py

@@ -4,7 +4,6 @@
 import os
 import csv
 import pandas as pd
-import logging
 from fastapi import APIRouter, Body, Response, Request
 from fastapi.responses import StreamingResponse, FileResponse
 
@@ -169,7 +168,7 @@ async def get_tasks_job_output(job_id: str, sweeps: bool = False):
             try:
                 job_data = json.loads(job_data)
             except JSONDecodeError:
-                logging.error(f"Error decoding job_data for job {job_id}. Using empty job_data.")
+                print(f"Error decoding job_data for job {job_id}. Using empty job_data.")
                 job_data = {}
 
         # Handle sweeps case first
@@ -198,7 +197,7 @@ async def get_tasks_job_output(job_id: str, sweeps: bool = False):
         # If the value error starts with "No output file found for job" then wait 4 seconds and try again
         # because the file might not have been created yet
         if str(e).startswith("No output file found for job"):
-            logging.info(f"Output file not found for job {job_id}, retrying in 4 seconds...")
+            print(f"Output file not found for job {job_id}, retrying in 4 seconds...")
             await asyncio.sleep(4)
             try:
                 output_file_name = await shared.get_job_output_file_name(job_id)
@@ -212,7 +211,7 @@ async def get_tasks_job_output(job_id: str, sweeps: bool = False):
                     return ["Output file not found after retry"]
             except Exception as retry_e:
                 # If still no file after retry, create an empty one in the jobs directory
-                logging.warning(
+                print(
                     f"Still no output file found for job {job_id} after retry, creating empty file: {retry_e}"
                 )
                 # Use the Job class to get the proper directory and create the file
@@ -223,11 +222,11 @@ async def get_tasks_job_output(job_id: str, sweeps: bool = False):
                     f.write("")
                 return []
         else:
-            logging.error(f"ValueError in get_tasks_job_output: {e}")
+            print(f"ValueError in get_tasks_job_output: {e}")
             return ["An internal error has occurred!"]
     except Exception as e:
         # Handle general error
-        logging.error(f"Error in get_tasks_job_output: {e}")
+        print(f"Error in get_tasks_job_output: {e}")
         return ["An internal error has occurred!"]
 
 
@@ -252,10 +251,10 @@ async def update_training_template(
         datasets = configObject["dataset_name"]
         job_service.update_training_template(template_id, name, description, type, datasets, config)
     except JSONDecodeError as e:
-        logging.error(f"JSON decode error: {e}")
+        print(f"JSON decode error: {e}")
         return {"status": "error", "message": "An error occurred while processing the request."}
     except Exception as e:
-        logging.error(f"Unexpected error: {e}")
+        print(f"Unexpected error: {e}")
         return {"status": "error", "message": "An internal error has occurred."}
     return {"status": "success"}
 
@@ -276,7 +275,7 @@ async def stream_job_output(job_id: str, sweeps: bool = False):
             try:
                 job_data = json.loads(job_data)
             except JSONDecodeError:
-                logging.error(f"Error decoding job_data for job {job_id}. Using empty job_data.")
+                print(f"Error decoding job_data for job {job_id}. Using empty job_data.")
                 job_data = {}
 
         # Handle sweeps case first
@@ -295,13 +294,13 @@ async def stream_job_output(job_id: str, sweeps: bool = False):
         # If the value error starts with "No output file found for job" then wait 4 seconds and try again
         # because the file might not have been created yet
         if str(e).startswith("No output file found for job"):
-            logging.info(f"Output file not found for job {job_id}, retrying in 4 seconds...")
+            print(f"Output file not found for job {job_id}, retrying in 4 seconds...")
             await asyncio.sleep(4)
             try:
                 output_file_name = await shared.get_job_output_file_name(job_id)
             except Exception as retry_e:
                 # If still no file after retry, create an empty one in the jobs directory
-                logging.warning(
+                print(
                     f"Still no output file found for job {job_id} after retry, creating empty file: {retry_e}"
                 )
                 # Use the Job class to get the proper directory and create the file
@@ -311,15 +310,15 @@ async def stream_job_output(job_id: str, sweeps: bool = False):
                 with open(output_file_name, "w") as f:
                     f.write("")
         else:
-            logging.error(f"ValueError in stream_job_output: {e}")
+            print(f"ValueError in stream_job_output: {e}")
             return StreamingResponse(
                 iter(["data: Error: An internal error has occurred!\n\n"]),
                 media_type="text/event-stream",
                 headers={"Cache-Control": "no-cache", "Connection": "keep-alive", "Access-Control-Allow-Origin": "*"},
             )
     except Exception as e:
         # Handle general error
-        logging.error(f"Error in stream_job_output: {e}")
+        print(f"Error in stream_job_output: {e}")
         return StreamingResponse(
             iter(["data: Error: An internal error has occurred!\n\n"]),
             media_type="text/event-stream",
@@ -461,7 +460,7 @@ async def get_eval_images(job_id: str):
                         }
                     )
     except OSError as e:
-        logging.error(f"Error reading images directory {images_dir}: {e}")
+        print(f"Error reading images directory {images_dir}: {e}")
         return {"images": []}
 
     # Sort by filename for consistent ordering
@@ -625,7 +624,7 @@ async def get_checkpoints(job_id: str, request: Request):
                     # Format the timestamp as ISO 8601 string
                     formatted_time = datetime.fromtimestamp(modified_time).isoformat()
                 except Exception as e:
-                    logging.error(f"Error getting stat for file {file_path}: {e}")
+                    print(f"Error getting stat for file {file_path}: {e}")
                     formatted_time = None
                     filesize = None
                 checkpoints.append({"filename": filename, "date": formatted_time, "size": filesize})
@@ -675,14 +674,14 @@ async def get_artifacts(job_id: str, request: Request):
                     filename = os.path.basename(artifact_path)
                     artifacts.append({"filename": filename, "date": formatted_time, "size": filesize})
                 except Exception as e:
-                    logging.error(f"Error getting stat for artifact {artifact_path}: {e}")
+                    print(f"Error getting stat for artifact {artifact_path}: {e}")
                     continue
 
             # Sort artifacts by filename in reverse (descending) order for consistent ordering
             artifacts.sort(key=lambda x: x["filename"], reverse=True)
             return {"artifacts": artifacts}
     except Exception as e:
-        logging.info(f"SDK artifact method failed for job {job_id}, falling back to legacy method: {e}")
+        print(f"SDK artifact method failed for job {job_id}, falling back to legacy method: {e}")
 
     # Fallback to the original logic if SDK method doesn't work or returns nothing
     # Get artifacts directory from job_data or use default location
@@ -708,12 +707,12 @@ async def get_artifacts(job_id: str, request: Request):
                     # Format the timestamp as ISO 8601 string
                     formatted_time = datetime.fromtimestamp(modified_time).isoformat()
                 except Exception as e:
-                    logging.error(f"Error getting stat for file {file_path}: {e}")
+                    print(f"Error getting stat for file {file_path}: {e}")
                     formatted_time = None
                     filesize = None
                 artifacts.append({"filename": filename, "date": formatted_time, "size": filesize})
     except OSError as e:
-        logging.error(f"Error reading artifacts directory {artifacts_dir}: {e}")
+        print(f"Error reading artifacts directory {artifacts_dir}: {e}")
 
     # Sort artifacts by filename in reverse (descending) order for consistent ordering
     artifacts.sort(key=lambda x: x["filename"], reverse=True)
@@ -752,11 +751,11 @@ async def get_training_job_output_jobpath(job_id: str, sweeps: bool = False):
         return output
     except ValueError as e:
         # Handle specific error
-        logging.error(f"ValueError: {e}")
+        print(f"ValueError: {e}")
         return "An internal error has occurred!"
     except Exception as e:
         # Handle general error
-        logging.error(f"Error: {e}")
+        print(f"Error: {e}")
         return "An internal error has occurred!"
 
 
@@ -773,12 +772,12 @@ async def sweep_results(job_id: str):
                     output = json.load(f)
                 return {"status": "success", "data": output}
             except json.JSONDecodeError as e:
-                logging.error(f"JSON decode error for job {job_id}: {e}")
+                print(f"JSON decode error for job {job_id}: {e}")
                 return {"status": "error", "message": "Invalid JSON format in sweep results file."}
         else:
-            logging.warning(f"Sweep results file not found for job {job_id}: {output_file}")
+            print(f"Sweep results file not found for job {job_id}: {output_file}")
             return {"status": "error", "message": "Sweep results file not found."}
 
     except Exception as e:
-        logging.error(f"Error loading sweep results for job {job_id}: {e}")
+        print(f"Error loading sweep results for job {job_id}: {e}")
         return {"status": "error", "message": "An internal error has occurred!"}