Merge pull request pandas-dev#19 from Herdi2/refactor-to_time

refactor: Refactor to_time

Author: annekh99

pandas/core/tools/times.py

@@ -54,62 +54,6 @@ def to_time(
     if errors not in ("raise", "coerce"):
         raise ValueError("errors must be one of 'raise', or 'coerce'.")
 
-    def _convert_listlike(arg, format):
-        if isinstance(arg, (list, tuple)):
-            arg = np.array(arg, dtype="O")
-
-        elif getattr(arg, "ndim", 1) > 1:
-            raise TypeError(
-                "arg must be a string, datetime, list, tuple, 1-d array, or Series"
-            )
-
-        arg = np.asarray(arg, dtype="O")
-
-        if infer_time_format and format is None:
-            format = _guess_time_format_for_array(arg)
-
-        times: list[time | None] = []
-        if format is not None:
-            for element in arg:
-                try:
-                    times.append(datetime.strptime(element, format).time())
-                except (ValueError, TypeError) as err:
-                    if errors == "raise":
-                        msg = (
-                            f"Cannot convert {element} to a time with given "
-                            f"format {format}"
-                        )
-                        raise ValueError(msg) from err
-                    times.append(None)
-        else:
-            formats = _time_formats[:]
-            format_found = False
-            for element in arg:
-                time_object = None
-                try:
-                    time_object = time.fromisoformat(element)
-                except (ValueError, TypeError):
-                    for time_format in formats:
-                        try:
-                            time_object = datetime.strptime(element, time_format).time()
-                            if not format_found:
-                                # Put the found format in front
-                                fmt = formats.pop(formats.index(time_format))
-                                formats.insert(0, fmt)
-                                format_found = True
-                            break
-                        except (ValueError, TypeError):
-                            continue
-
-                if time_object is not None:
-                    times.append(time_object)
-                elif errors == "raise":
-                    raise ValueError(f"Cannot convert arg {arg} to a time")
-                else:
-                    times.append(None)
-
-        return times
-
     if arg is None:
         return arg
     elif isinstance(arg, time):
@@ -137,6 +81,81 @@ def _convert_listlike(arg, format):
     "%I%M%S%p",
 ]
 
+def _convert_listlike(
+    arg,
+    format: str | None = None,
+    infer_time_format: bool = False,
+    errors: DateTimeErrorChoices = "raise",
+):
+    if isinstance(arg, (list, tuple)):
+        arg = np.array(arg, dtype="O")
+
+    elif getattr(arg, "ndim", 1) > 1:
+        raise TypeError(
+            "arg must be a string, datetime, list, tuple, 1-d array, or Series"
+        )
+
+    arg = np.asarray(arg, dtype="O")
+
+    if infer_time_format and format is None:
+        format = _guess_time_format_for_array(arg)
+
+    # Parse times
+
+    if format is not None:
+        return _parse_with_format(arg, format, errors)
+    else:
+        return _infer_and_parse(arg,errors)
+
+
+def _parse_with_format(arg, format, errors):
+    """Given format info in input, parse and returns the time."""
+    times = []
+    for element in arg:
+        try:
+            times.append(datetime.strptime(element, format).time())
+        except (ValueError, TypeError) as err:
+            _handle_error(errors, element, format, err, times)
+    return times
+
+def _infer_and_parse(arg, errors):
+    """Lacking format info, infer format from _time_formats array. Parses and returns the time."""
+    formats = _time_formats[:]
+    format_found = False
+    times = []
+    
+    for element in arg:
+        time_object = _try_parse_time(element, formats, format_found)
+        
+        if time_object is not None:
+            times.append(time_object)
+        elif errors == "raise":
+            raise ValueError(f"Cannot convert arg {arg} to a time")
+        else:
+            times.append(None)
+
+    return times
+
+def _try_parse_time(element, formats, format_found):
+    """Attempts parsing an element with different time formats."""
+    try:
+        return time.fromisoformat(element)
+    except (ValueError, TypeError):
+        for time_format in formats:
+            try:
+                parsed_time = datetime.strptime(element, time_format).time()
+                if not format_found:
+                    formats.insert(0, formats.pop(formats.index(time_format)))
+                return parsed_time
+            except (ValueError, TypeError):
+                continue
+    return None
+
+def _handle_error(errors, element, format, err, times):
+    """Handles errors when parsing times."""
+    if errors == "raise":
+        raise ValueError(f"Cannot convert {element} to a time with format {format}") from err
+    times.append(None)
 
 def _guess_time_format_for_array(arr):
     # Try to guess the format based on the first non-NaN element