Test if elements end with pat.

        Parameters
        ----------
        pat : str

        Returns
        -------
        Series
194161
def endswith(self, pat):
        
        check_type(pat, str)

        return _series_bool_result(self, weld_str_endswith, pat=pat)
636876
def ltrim(self, name, start, end):
        
        with self.pipe as pipe:
            return pipe.ltrim(self.redis_key(name), start, end)
1357229
def endBy1(p, sep):
    ''''''
    return separated(p, sep, 1, maxt=float('inf'), end=True)
495144
function ends_withp(str, substr) {
        return slice(str, str.length - substr.length) == substr
    }
1311990
private boolean doesAnyTimeSeriesHaveData() {
		for (int i = 0; i < iterators.length; i++) {
			if ((timestamps[iterators.length + i]) !=  MARK_END_TIME_SERIES) {
				return true;
			}
		}
		return false;
	}
155667
def chars_after(chars, match):
    
    if match.end >= len(match.input_string):
        return True
    return match.input_string[match.end] in chars
597344
public static boolean endsWithPunc(String str) {
		if (str.endsWith(".") || str.endsWith("?") || str.endsWith("!") ||
			    str.endsWith(",") || str.endsWith(":") || str.endsWith("\"") || 
			    str.endsWith("'") || str.endsWith("''") || str.endsWith(";")) {
		    return true;
		}
		
		return false;
    }
353286
def endswith(self, suffix, ignore_case=False, options=None):
        
        return self.regex(re.escape(suffix) + '$', ignore_case=ignore_case, options=options)
954732
def ends(self, s):
        length = len(s)
        
        res = (self.b[self.k-length+1:self.k+1] == s)
        if res:
            self.j = self.k - length
        return res
1258146
def include_end(self):
        
        self.lex = self.filestack[-1][2]
        self.input_data = self.filestack[-1][3]
        self.filestack.pop()

        if not self.filestack:  # End of input?
            return

        self.filestack[-1][1] += 1  # Increment line counter of previous file

        result = lex.LexToken()
        result.value = self.put_current_line(suffix='\n')
        result.type = '_ENDFILE_'
        result.lineno = self.lex.lineno
        result.lexpos = self.lex.lexpos

        return result
64107
def endElement(self, name):
        
        if name in self.ignore_end:
            return
        try:
            handler = getattr(self, '_handle_end_%s' % name)
        except AttributeError:
            raise KeyError("Unknown element end '%s'" % name)
        handler()
36929
def ends(self, s):
        """"""
        length = len(s)
        if s[length - 1] != self.b[self.k]:  # tiny speed-up
            return 0
        if length > (self.k - self.k0 + 1):
            return 0
        if self.b[self.k - length + 1 : self.k + 1] != s:
            return 0
        self.j = self.k - length
        return 1
115062
def _get_start_end(parts, index=7):
    
    start = parts[1]
    end = [x.split("=")[-1] for x in parts[index].split(";") if x.startswith("END=")]
    if end:
        end = end[0]
        return start, end
    return None, None
882935
def endswith_strip(s, endswith='.txt', ignorecase=True):
    
    if ignorecase:
        if s.lower().endswith(endswith.lower()):
            return s[:-len(endswith)]
    else:
        if s.endswith(endswith):
            return s[:-len(endswith)]
    return s
722089
def endStep(self,key):
        
        ptime = _ptime()
        if key is not None:
            self.steps[key]['end'] = ptime
            self.steps[key]['elapsed'] = ptime[1] - self.steps[key]['start'][1]
        self.end = ptime

        print('==== Processing Step ',key,' finished at ',ptime[0])
        print('')
538793
function findEndPattern(text, offset, delta) {
        var patterns, pattern, i;

        // Find best matching end
        patterns = getPatterns();
        for (i = 0; i < patterns.length; i++) {
          pattern = patterns[i];
          if (pattern.end && text.substr(offset - pattern.end.length - delta, pattern.end.length) == pattern.end) {
            return pattern;
          }
        }
      }
809702
def cell_ends_with_code(lines):
    """"""
    if not lines:
        return False
    if not lines[-1].strip():
        return False
    if lines[-1].startswith('#'):
        return False
    return True