code: def num2chn(
      number_string,
      numbering_type=NUMBERING_TYPES[1],
      big=False,
      traditional=False,
      alt_zero=False,
      alt_one=False,
      alt_two=True,
      use_zeros=True,
      use_units=True,
  ):
      def get_value(value_string, use_zeros=True):
          striped_string = value_string.lstrip("0")
  
          # record nothing if all zeros
          if not striped_string:
              return []
  
          # record one digits
          elif len(striped_string) == 1:
              if use_zeros and len(value_string) != len(striped_string):
                  return [
                      system.digits[0],
                      system.digits[int(striped_string)],
                  ]
              else:
                  return [system.digits[int(striped_string)]]
  
          # recursively record multiple digits
          else:
              result_unit = next(
                  u
                  for u in reversed(system.units)
                  if u.power < len(striped_string)
              )
              result_string = value_string[: -result_unit.power]
              return (
                  get_value(result_string)
                  + [result_unit]
                  + get_value(striped_string[-result_unit.power :])
              )
  
      system = create_system(numbering_type)
  
      int_dec = number_string.split(".")
      if len(int_dec) == 1:
          int_string = int_dec[0]
          dec_string = ""
      elif len(int_dec) == 2:
          int_string = int_dec[0]
          dec_string = int_dec[1]
      else:
          raise ValueError(
              "invalid input num string with more than one dot: {}".format(
                  number_string
              )
          )
  
      if use_units and len(int_string) > 1:
          result_symbols = get_value(int_string)
      else:
          result_symbols = [system.digits[int(c)] for c in int_string]
      dec_symbols = [system.digits[int(c)] for c in dec_string]
      if dec_string:
          result_symbols += [system.math.point] + dec_symbols
  
      if alt_two:
          liang = CND(
              2,
              system.digits[2].alt_s,
              system.digits[2].alt_t,
              system.digits[2].big_s,
              system.digits[2].big_t,
          )
          for i, v in enumerate(result_symbols):
              if isinstance(v, CND) and v.value == 2:
                  next_symbol = (
                      result_symbols[i + 1]
                      if i < len(result_symbols) - 1
                      else None
                  )
                  previous_symbol = (
                      result_symbols[i - 1] if i > 0 else None
                  )
                  if isinstance(next_symbol, CNU) and isinstance(
                      previous_symbol, (CNU, type(None))
                  ):
                      if next_symbol.power != 1 and (
                          (previous_symbol is None)
                          or (previous_symbol.power != 1)
                      ):
                          result_symbols[i] = liang
  
      # if big is True, '两' will not be used and `alt_two` has no impact on output
      if big:
          attr_name = "big_"
          if traditional:
              attr_name += "t"
          else:
              attr_name += "s"
      else:
          if traditional:
              attr_name = "traditional"
          else:
              attr_name = "simplified"
  
      result = "".join([getattr(s, attr_name) for s in result_symbols])
  
      # if not use_zeros:
      #     result = result.strip(getattr(system.digits[0], attr_name))
  
      if alt_zero:
          result = result.replace(
              getattr(system.digits[0], attr_name),
              system.digits[0].alt_s,
          )
  
      if alt_one:
          result = result.replace(
              getattr(system.digits[1], attr_name),
              system.digits[1].alt_s,
          )
  
      for i, p in enumerate(POINT):
          if result.startswith(p):
              return CHINESE_DIGIS[0] + result
  
      # ^10, 11, .., 19
      if (
          len(result) >= 2
          and result[1]
          in [
              SMALLER_CHINESE_NUMERING_UNITS_SIMPLIFIED[0],
              SMALLER_CHINESE_NUMERING_UNITS_TRADITIONAL[0],
          ]
          and result[0]
          in [
              CHINESE_DIGIS[1],
              BIG_CHINESE_DIGIS_SIMPLIFIED[1],
              BIG_CHINESE_DIGIS_TRADITIONAL[1],
          ]
      ):
          result = result[1:]
  
      return result
  
imports: import argparse
  import csv
  import os
  import re
  import string
  import sys
label_desc: Use image node_id 3 for calling a global function with example usage: num2chn(number_string, numbering_type, big, traditional, alt_zero, alt_one, alt_two, use_zeros, use_units) and returns: result, list, unknown, unknown, list, list