update

Author: anna-parker

preprocessing/nextclade/README.md

@@ -124,7 +124,7 @@ However, the `preprocessing` field can be customized to take an arbitrary number
 5. `concatenate`: Take multiple metadata fields (including the accessionVersion) and concatenate them in the order specified by the `arg.order` parameter, fields will first be processed based on their `arg.type` (the order of the types should correspond to the order of fields specified by the order argument).
 6. `process_options`: Only accept input that is in `args.options`, this check is case-insensitive. If input value is not in options raise an error, or return null if the submitter is in the "insdc_ingest" group.
 7. `check_regex`: Validate that the input field matches the pattern in `args.pattern`.
-8. `extract_regex`: Extracts a substring from input field using the provided regex `args.pattern` with a `args.capture_group`. For example the pattern `^(?P<segment>[^-]+)-(?P<subtype>[^-]+)$` with capture group `subtype` would extract `HA` from the field `seg1-HA`. Returns an error if the pattern does not match (and internal error if capture group does not exist in pattern).
+8. `extract_regex`: Extracts a substring from input field using the provided regex `args.pattern` with a `args.capture_group`. For example the pattern `^(?P<segment>[^-]+)-(?P<subtype>[^-]+)$` with capture group `subtype` would extract `HA` from the field `seg1-HA`. Returns an error if the pattern does not match (and internal error if capture group does not exist in pattern). If `arg.uppercase` is added the extracted string will be capitalized.
 
 Using these functions in your `values.yaml` will look like:
 

preprocessing/nextclade/src/loculus_preprocessing/processing_functions.py

@@ -862,7 +862,7 @@ def extract_regex(
     ) -> ProcessingResult:
         """
         Extracts a substring from the `regex_field` using the provided regex `pattern`
-        with a `capture_group`.
+        with a `capture_group`, if `uppercase` is set to true the extracted value is capitalized.
         e.g. ^(?P<segment>[^-]+)-(?P<subtype>[^-]+)$ where segment or subtype could be used
         as a capture_group to extract their respective value from the regex_field.
         """
@@ -871,8 +871,9 @@ def extract_regex(
         warnings: list[ProcessingAnnotation] = []
         errors: list[ProcessingAnnotation] = []
 
-        pattern = args["pattern"]
-        capture_group = args["capture_group"]
+        pattern = args.get("pattern")
+        capture_group = args.get("capture_group")
+        uppercase = args.get("uppercase", False)
 
         if not regex_field:
             return ProcessingResult(datum=None, warnings=warnings, errors=errors)
@@ -900,6 +901,8 @@ def extract_regex(
         if match:
             try:
                 result = match.group(capture_group)
+                if uppercase:
+                    result = result.upper()
                 return ProcessingResult(datum=result, warnings=warnings, errors=errors)
             except IndexError:
                 errors.append(