returns a word describing the type of the collection (edges or ducments) instead of a number, if you prefer the number it's in self.type
976998
def getType(self) :
        """"""
        if self.type == CONST.COLLECTION_DOCUMENT_TYPE :
            return "document"
        elif self.type == CONST.COLLECTION_EDGE_TYPE :
            return "edge"
        else :
            raise ValueError("The collection is of Unknown type %s" % self.type)
1331627
def get_element_type(_list, dimens):
    
    elem = _list
    for _ in range(len(dimens)):
        elem = elem[0]
    return type(elem)
258768
@Memoized
  public Type type() {
    int dotIndex = identifier().indexOf('.');
    if (dotIndex == 0) {
      checkArgument(BaseUtils.isIdentifierWithLeadingDot(identifier()));
      return Type.DOT_IDENT;
    } else {
      checkArgument(BaseUtils.isDottedIdentifier(identifier()));
      return dotIndex == -1 ? Type.SINGLE_IDENT : Type.DOTTED_IDENT;
    }
  }
778911
def number(self) -> int:
        
        match = self._NUMBER_SUFFIX.search(self.epno)
        return int(match.group(1))
809704
def type_string(self):
        """"""
        if self.is_tuple:
            subtypes = [item.type_string for item in self.children]
            return '{}({})'.format(
                '' if self.val_guaranteed else '*',
                ', '.join(subtypes))
        elif self.is_list:
            return '{}[{}]'.format(
                '' if self.val_guaranteed else '*',
                self.children[0].type_string)
        else:
            return '{}{}'.format(
                '' if self.val_guaranteed else '*',
                self.type_.__name__)
55427
def types(self):
        """"""
        return [term for term in self._terms
                if isinstance(term, (TypeIdentifier, String, Regex))]
753302
def piece_type_at(self, square: Square) -> Optional[PieceType]:
        """"""
        mask = BB_SQUARES[square]

        if not self.occupied & mask:
            return None  # Early return
        elif self.pawns & mask:
            return PAWN
        elif self.knights & mask:
            return KNIGHT
        elif self.bishops & mask:
            return BISHOP
        elif self.rooks & mask:
            return ROOK
        elif self.queens & mask:
            return QUEEN
        else:
            return KING
45846
def _type_string(label, case=None):
    """"""
    return label, abstractSearch.in_string, lambda s: abstractRender.default(s, case=case), ""
1101006
def type(self):
        """"""
        return self.record.type if self.record.type != "urn:nfc:wkt:Hc" \
            else self.record.carrier_type
315657
def get_data_type(data) # :nodoc:
      # Check for no data in the series.
      return 'none' unless data
      return 'none' if data.empty?
      return 'multi_str' if data.first.kind_of?(Array)

      # If the token isn't a number assume it is a string.
      data.each do |token|
        next unless token
        return 'str' unless token.kind_of?(Numeric)
      end

      # The series data was all numeric.
      'num'
    end
1039012
function (type, item, hard) {
        if (hard) {
            return harderTypes[type](getType(item), item);
        }
        return (getType(item) === simpleTypes[type]);
    }
1019329
def get_edge_string(self, i):
        """"""
        order = self.orders[i]
        if order == 0:
            return Graph.get_edge_string(self, i)
        else:
            # pad with zeros to make sure that string sort is identical to number sort
            return "%03i" % order
743093
def return_type(self):
        
        returns = self.returns
        if returns:
            return [r.type for r in returns]
        return None
270231
def _guess_type(val):
        """"""
        if isinstance(val, bool):
            return "choice"
        elif isinstance(val, int):
            return "number"
        elif isinstance(val, float):
            return "number"
        elif isinstance(val, str):
            return "text"
        elif hasattr(val, 'read'):
            return "file"
        else:
            return "text"
523022
def types(self):
        ''' 
        '''
        neurites = self._obj.neurites if hasattr(self._obj, 'neurites') else (self._obj,)
        return (neu.type for neu in neurites)
1201220
def type_name(value):
    """"""
    return type(value).__name__ if isinstance(value, EncapsulatedNode) else \
           "struct" if isinstance(value, dict) else \
           "sequence" if isinstance(value, (tuple, list)) else \
           type(value).__name__
77462
def type(self):
        
        if self._type.lower() == 'reg':
            return REGULAR_SEASON
        if self._type.lower() == 'ctourn':
            return CONFERENCE_TOURNAMENT
        if self._type.lower() == 'ncaa':
            return NCAA_TOURNAMENT
        if self._type.lower() == 'nit':
            return NIT_TOURNAMENT
        if self._type.lower() == 'cbi':
            return CBI_TOURNAMENT
        if self._type.lower() == 'cit':
            return CIT_TOURNAMENT