Your query is not trivial (in fact I would put a price on it) and requires some effort from the labor of a specialized engineer. But I will still try to answer your post just to polish my skills.

What is needed is to process line by line, string by string, practice multiple extractions with regular expressions, standardize formats, operate with common units, then create a template for the result:

#!/usr/bin/env bash

options_reader() {
    while [ $# -gt 0 ]
    do
        case "$1" in
            --filename | -f )
                shift
                export _filename="$1"
                shift
                ;;
            --filename=* )
                export _filename="${1#*=}"
                shift
                ;;
            *)  
                shift
                ;;
        esac
    done
}
normalize_size_to_bytes() {
    local -r size="$1"
    local -r normalized_suffix="$2"
    local bytes="$(echo "${size}${normalized_suffix}" | numfmt --from=auto)"
    echo "$bytes"
}
normalize_size_suffix() {
    local -r size_suffix="$1"
    local -r first_size_letter="${size_suffix:0:1}"
    local -ru normalized_size_suffix="$first_size_letter"
    echo "$normalized_size_suffix"
}
extract_size_part() {
    local -r record="$1"
    local -r size_regex='(?<=\().*(?=\))'
    
    local -r size_part="$(echo "$record" | grep -Po "$size_regex")"
    echo "$size_part"
}
extract_size_number() {
    local -r size_part="$1"
    local -r number_regex='\d+'
    
    local -ri size_number="$(echo "$size_part" | grep -Po "$number_regex")"
    echo "$size_number"
}
extract_size_suffix() {
    local -r size_part="$1"
    local -r suffix_regex='[^\d ]+'
    
    local -r size_number="$(echo "$size_part" | grep -Po "$suffix_regex")"
    echo "$size_number"
}
extract_pathname() {
    local -r record="$1"
    local -r filename_regex='(?<=\/).*(?=\/)'
    
    local -r filename_match="$(echo "$record" | grep -Po "$filename_regex")"
    local -r filename="/$filename_match/"
    echo "$filename"
}
get_bytes_per_row() {
    local -r row="$1"
    local -r size_part="$(extract_size_part "$row")"
    
    local -ri size_number="$(extract_size_number "$size_part")"
    local -r size_suffix="$(extract_size_suffix "$size_part")"
    
    local normalized_size_suffix="$(normalize_size_suffix "$size_suffix")"
    
    local total_bytes="$(normalize_size_to_bytes "$size_number" "$normalized_size_suffix")"
    echo "$total_bytes"
}
calculate_percentage_per_size() {
    local size_in_bytes="$1"
    local percentage="$((size_in_bytes*100/total_bytes))"
    echo "$percentage"
}
get_bytes_per_row() {
    local row="$1"
    
    local size_part="$(extract_size_part "$row")"
    
    local size_number="$(extract_size_number "$size_part")"
    local size_suffix="$(extract_size_suffix "$size_part")"
    
    local normalized_size_suffix="$(normalize_size_suffix "$size_suffix")"
    
    local total_bytes="$(normalize_size_to_bytes "$size_number" "$normalized_size_suffix")"

    echo "$total_bytes"
}
extract_fsname() {
    local record="$1"
    local fs_name_regex='(?<=\/)\w+(?=\s*\()'
    
    local fs_name_match="$(echo "$record" | grep -Po "$fs_name_regex")"
    local fs_name="/$fs_name_match"
    echo "$fs_name"
}
create_size_with_suffix_normalized() {
    local -r row="$1"
    local -r size_part="$(extract_size_part "$row")"
    local -r size_suffix="$(extract_size_suffix "$size_part")"
    local -ri size_number="$(extract_size_number "$size_part")"
    local -r normalized_size_suffix="$(normalize_size_suffix "$size_suffix")"
    
    echo "${size_number}${normalized_size_suffix}"
}
print_fs_info() {
    local -r first_row="$1"
    local -ri percentage_occupied="$2"

    local -r fs_name="$(extract_fsname "$first_row")"
    local -r size_with_suffix="$(create_size_with_suffix_normalized "$first_row")"
    
    echo "$fs_name -> Ocupa $size_with_suffix, ocupado $percentage_occupied%"
}
process_row() {
    local -r row="$1"
    
    local -r path_name="$(extract_pathname "$row")"
    local -r size_with_suffix="$(create_size_with_suffix_normalized "$row")"
    local -ri size_in_bytes="$(normalize_size_to_bytes "$size_with_suffix")"
    local -ri percentage="$(calculate_percentage_per_size "$size_in_bytes")"
    
    ((percentage_occupied = percentage_occupied + percentage))
    
    local -r processed_row="$path_name (${size_with_suffix}), ocupa el ${percentage}% del FS $fs_name"
    result_info+=("$processed_row")  
}
process_file() {
    declare -r _file="$1"
    declare -i percentage_occupied=0
    declare -a result_info
    declare -r first_row="$(head -n 1 "$_file")"
    declare -r fs_name="$(extract_fsname "$first_row")"
    declare -ri total_bytes="$(get_bytes_per_row "$first_row")"

    set +m
    shopt -s lastpipe
    
    tail -n +2 "$_file" \
    | while read -r row || [ -n "$row" ]; do
        process_row "$row"
    done 
    
    print_fs_info "$first_row" "$percentage_occupied"
    printf '%s\n' "${result_info[@]}"
}

main() {
    options_reader $@
    process_file "$_filename"
}

main $@

sizes.txtIf you put the following content in the file :

FS : /archivos (10T)
Contenido: /archivos/test/ (8T)
Contenido: /archivos/garbage/ (10 Megas)
Contenido: /archivos/log/ (500G)
Contenido: /archivos/log2/ (500G)
Contenido: /archivos/solaris/ (5 kilobytes)

Running the program you get:

$ ./size_processor.sh --filename=sizes.txt
/archivos -> Ocupa 10T, ocupado 90%
/archivos/test/ (8T), ocupa el 80% del FS /archivos
/archivos/garbage/ (10M), ocupa el 0% del FS /archivos
/archivos/log/ (500G), ocupa el 5% del FS /archivos
/archivos/log2/ (500G), ocupa el 5% del FS /archivos
/archivos/solaris/ (5K), ocupa el 0% del FS /archivos

If you think this is a lot of code for a single file, you can separate the functions and call them with sourceat startup.

Here are a few unit tests with the suite bats:

#!/usr/bin/env bats

source "./size_processor.sh"

@test "It should normalize the size suffix" {
  # Given
  bad_suffix="mEgaBites"
  expected_suffix="M"
  
  # When
  result_suffix="$(normalize_size_suffix "$bad_suffix")"

  # Then
  [ "$result_suffix" = "$expected_suffix" ]
}

@test "It should normalize the size to bytes" {
  # Given
  kb_size="10K"
  mb_size="10M"
  tb_size="10T"

  expected_kb_size="10000"
  expected_mb_size="10000000"
  expected_tb_size="10000000000000"
  
  # When
  result_kb_size="$(normalize_size_to_bytes "$kb_size")"
  result_mb_size="$(normalize_size_to_bytes "$mb_size")"
  result_tb_size="$(normalize_size_to_bytes "$tb_size")"

  # Then
  [ "$result_kb_size" -eq "$expected_kb_size" ]
  [ "$result_mb_size" -eq "$expected_mb_size" ]
  [ "$result_tb_size" -eq "$expected_tb_size" ]
}

@test "It should extract the size part from the record" {
  # Given
  record="stuff /path1/path2/   (34TeRaBites)"
  expected_size_part="34TeRaBites"
  
  # When
  actual_size_part="$(extract_size_part "$record")"

  # Then
  [ "$actual_size_part" = "$expected_size_part" ]
}

@test "It should extract the size number from the size part" {
  # Given
  size_part="90Kilobaits"
  expected_size_number=90
  
  # When
  actual_size_number="$(extract_size_number "$size_part")"

  # Then
  [ "$actual_size_number" -eq "$expected_size_number" ]
}

@test "It should extract the path name from the record" {
  # Given
  record="Contenido: /path 1/path 2/path 3/ (10 MegaBaits)"
  expected_path="/path 1/path 2/path 3/"
  
  # When
  actual_path="$(extract_pathname "$record")"

  # Then
  [ "$actual_path" = "$expected_path" ]
}

And running them we have:

$ bats tests_size_processor.bats
 ✓ It should normalize the size suffix
 ✓ It should normalize the size to bytes
 ✓ It should extract the size part from the record
 ✓ It should extract the size number from the size part
 ✓ It should extract the path name from the record

5 tests, 0 failures

major update

Believe:

• A repository with the project,
• With a tree of files to do the extraction and calculation tasks, modularizing and encapsulating everything,
• Also with some unit tests with bats,
• With the acceptance test-driven development approach
• A Gitlab CI/CD pipeline for testing and deploying

This is the repository: Repository

This is the small CI/CD pipeline: CI/CD Pipeline

An example of how the tiny DAG passes the stages:

And from the job as a result: