def test_formatter_parser(self): import _string l = list(_string.formatter_parser('abcd')) assert l == [('abcd', None, None, None)] # l = list(_string.formatter_parser('ab{0}cd')) assert l == [('ab', '0', '', None), ('cd', None, None, None)] # l = list(_string.formatter_parser('{0}cd')) assert l == [('', '0', '', None), ('cd', None, None, None)] # l = list(_string.formatter_parser('ab{0}')) assert l == [('ab', '0', '', None)] # l = list(_string.formatter_parser('')) assert l == [] # l = list(_string.formatter_parser('{0:123}')) assert l == [('', '0', '123', None)] # l = list(_string.formatter_parser('{0!x:123}')) assert l == [('', '0', '123', 'x')] # l = list(_string.formatter_parser('{0!x:12{sdd}3}')) assert l == [('', '0', '12{sdd}3', 'x')]
def execute(self) -> DataFrame: """ Returns a DataFrame for which the SQL statement has been executed by the underlying SQL engine. >>> str0 = 'abc' >>> ks.sql("select {str0}") abc 0 abc >>> str1 = 'abc"abc' >>> str2 = "abc'abc" >>> ks.sql("select {str0}, {str1}, {str2}") abc abc"abc abc'abc 0 abc abc"abc abc'abc >>> strs = ['a', 'b'] >>> ks.sql("select 'a' in {strs} as cond1, 'c' in {strs} as cond2") cond1 cond2 0 True False """ blocks = _string.formatter_parser(self._statement) # TODO: use a string builder res = "" try: for (pre, inner, _, _) in blocks: var_next = "" if inner is None else self._convert(inner) res = res + pre + var_next self._normalized_statement = res sdf = self._session.sql(self._normalized_statement) finally: for v in self._temp_views: self._session.catalog.dropTempView(v) return DataFrame(sdf)
def varnames_from_fmt(fmt: TemplateLike): import _string if isinstance(fmt, TemplateString): fmt = fmt.get_format_string() return [fname for _, fname, _, _ in _string.formatter_parser(fmt) if fname]
def __init__(self, format_string, default=None): self.default = default key = (format_string, default) try: self.result, self.fields = self.CACHE[key] except KeyError: self.result = [] self.fields = [] for literal_text, field_name, format_spec, conv in \ _string.formatter_parser(format_string): if literal_text: self.result.append(literal_text) if field_name: self.fields.append(( len(self.result), self._field_access(field_name, format_spec, conv), )) self.result.append("") self.CACHE[key] = (self.result, self.fields) if len(self.result) == 1: if self.fields: self.format_map = self.fields[0][1] else: self.format_map = lambda _: format_string del self.result, self.fields
def test(): for _ in range(9999): try: list(_string.formatter_field_name_split(fstr())[1]) except ValueError: pass try: list(_string.formatter_parser(fstr())) except ValueError: pass
def _total_replacement_field_number(format_str: str) -> int: """Get the total number of replacement field in the format string :param format_str: The string which contains replacement field. :return: Total number of replacement field. """ field_count = 0 for _, field_name, _, _ in _string.formatter_parser(format_str): if field_name is not None: field_count += 1 return field_count
def __init__(self, format_string, default=None): self.default = default self.result = [] self.fields = [] for literal_text, field_name, format_spec, conversion in \ _string.formatter_parser(format_string): if literal_text: self.result.append(literal_text) if field_name: self.fields.append((len(self.result), self._field_access(field_name, format_spec, conversion))) self.result.append("")
def __init__(self, format_string, default=None): self.default = default self.result = [] self.fields = [] for literal_text, field_name, format_spec, conversion in \ _string.formatter_parser(format_string): if literal_text: self.result.append(literal_text) if field_name: self.fields.append(( len(self.result), self._field_access(field_name, format_spec, conversion) )) self.result.append("")
def execute(self, index_col: Optional[Union[str, List[str]]]) -> DataFrame: """ Returns a DataFrame for which the SQL statement has been executed by the underlying SQL engine. >>> from pyspark.pandas import sql_processor >>> # we will call 'sql_processor' directly in doctests so decrease one level. >>> sql_processor._CAPTURE_SCOPES = 2 >>> sql = sql_processor.sql >>> str0 = 'abc' >>> sql("select {str0}") abc 0 abc >>> str1 = 'abc"abc' >>> str2 = "abc'abc" >>> sql("select {str0}, {str1}, {str2}") abc abc"abc abc'abc 0 abc abc"abc abc'abc >>> strs = ['a', 'b'] >>> sql("select 'a' in {strs} as cond1, 'c' in {strs} as cond2") cond1 cond2 0 True False """ blocks = _string.formatter_parser(self._statement) # TODO: use a string builder res = "" try: for (pre, inner, _, _) in blocks: var_next = "" if inner is None else self._convert(inner) res = res + pre + var_next self._normalized_statement = res sdf = self._session.sql(self._normalized_statement) finally: for v in self._temp_views: self._session.catalog.dropTempView(v) index_spark_columns, index_names = _get_index_map(sdf, index_col) return DataFrame( InternalFrame(spark_frame=sdf, index_spark_columns=index_spark_columns, index_names=index_names))
def __init__(self, format_string, default=None): self.default = default self.result = [] self.fields = [] for literal_text, field_name, format_spec, conversion in \ _string.formatter_parser(format_string): if literal_text: self.result.append(literal_text) if field_name: self.fields.append(( len(self.result), self._field_access(field_name, format_spec, conversion), )) self.result.append("") if len(self.result) == 1: if self.fields: self.format_map = self.fields[0][1] else: self.format_map = lambda _: format_string del self.result, self.fields
def vformat(self, format_string, kwargs): """Apply 'kwargs' to the initial format_string and return its result""" result = [] append = result.append for literal_text, field_name, format_spec, conversion in \ _string.formatter_parser(format_string): if literal_text: append(literal_text) if field_name: obj = self.get_field(field_name, kwargs) if conversion: obj = self.conversions[conversion](obj) if format_spec: format_spec = format_spec.format_map(kwargs) obj = self.format_field(obj, format_spec) else: obj = str(obj) append(obj) return "".join(result)
def parse(self, format_string): return _string.formatter_parser(format_string)
def test_formatter_parser_escape(self): import _string l = list(_string.formatter_parser("{{a}}")) assert l == [('{', None, None, None), ('a}', None, None, None)] l = list(_string.formatter_parser("{{{{")) assert l == [('{', None, None, None), ('{', None, None, None)]
def test_u_formatter_parser(self): import _string l = list(_string.formatter_parser('{0!x:12{sdd}3}')) assert l == [('', '0', '12{sdd}3', 'x')] for x in l[0]: assert isinstance(x, str)
MethodWrapperType = type(object.__call__) NoneType = type(None) NotImplementedType = type(NotImplemented) QuitterType = type(exit) WrapperDescriptorType = type(type.__call__) if PY2: StrFormatterIteratorType = type(str()._formatter_parser()) StrFieldNameIteratorType = type(str()._formatter_field_name_split()[1]) UnicodeFormatterIteratorType = type(unicode()._formatter_parser()) UnicodeFieldNameIteratorType = type(unicode()._formatter_field_name_split()[1]) if PY3: import _string StrFormatterIteratorType = type(_string.formatter_parser(str())) StrFieldNameIteratorType = type(_string.formatter_field_name_split(str())[1]) if PY3: ModuleDefType = only(stubtool.name.search_for_type('builtins.moduledef', object)) StdPrinterType = only(stubtool.name.search_for_type('builtins.stderrprinter', object)) if PY33: ManagedBufferType = type(only(gc.get_referents(memoryview(b'')))) if PY35: exec('async def func(): pass') coro = func() wrapper = coro.__await__() coro.close() CoroutineWrapperType = type(wrapper)
def parse(self, format_string): if PY3: return _string.formatter_parser(format_string) # pragma: no cover else: return format_string._formatter_parser() # pragma: no cover