code: def can_assign_src_to_sink(src, sink, strict=False):  # type: (Any, Any, bool) -> bool
      
  
      if src == "Any" or sink == "Any":
          return True
      if isinstance(src, MutableMapping) and isinstance(sink, MutableMapping):
          if sink.get("not_connected") and strict:
              return False
          if src["type"] == "array" and sink["type"] == "array":
              return can_assign_src_to_sink(src["items"], sink["items"], strict)
          if src["type"] == "record" and sink["type"] == "record":
              return _compare_records(src, sink, strict)
          if src["type"] == "File" and sink["type"] == "File":
              for sinksf in sink.get("secondaryFiles", []):
                  if not [1 for srcsf in src.get("secondaryFiles", []) if sinksf == srcsf]:
                      if strict:
                          return False
              return True
          return can_assign_src_to_sink(src["type"], sink["type"], strict)
      if isinstance(src, MutableSequence):
          if strict:
              for this_src in src:
                  if not can_assign_src_to_sink(this_src, sink):
                      return False
              return True
          for this_src in src:
              if can_assign_src_to_sink(this_src, sink):
                  return True
          return False
      if isinstance(sink, MutableSequence):
          for this_sink in sink:
              if can_assign_src_to_sink(src, this_sink):
                  return True
          return False
      return src == sink
docs: Check for identical type specifications, ignoring extra keys like inputBinding.
  
      src: admissible source types
      sink: admissible sink types
  
      In non-strict comparison, at least one source type must match one sink type.
      In strict comparison, all source types must match at least one sink type.