partition stringclasses 3 values | func_name stringlengths 1 134 | docstring stringlengths 1 46.9k | path stringlengths 4 223 | original_string stringlengths 75 104k | code stringlengths 75 104k | docstring_tokens listlengths 1 1.97k | repo stringlengths 7 55 | language stringclasses 1 value | url stringlengths 87 315 | code_tokens listlengths 19 28.4k | sha stringlengths 40 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|
train | ParserBase._extract_multi_indexer_columns | extract and return the names, index_names, col_names
header is a list-of-lists returned from the parsers | pandas/io/parsers.py | def _extract_multi_indexer_columns(self, header, index_names, col_names,
passed_names=False):
""" extract and return the names, index_names, col_names
header is a list-of-lists returned from the parsers """
if len(header) < 2:
return header[0], index_names, col_names, passed_names
# the names are the tuples of the header that are not the index cols
# 0 is the name of the index, assuming index_col is a list of column
# numbers
ic = self.index_col
if ic is None:
ic = []
if not isinstance(ic, (list, tuple, np.ndarray)):
ic = [ic]
sic = set(ic)
# clean the index_names
index_names = header.pop(-1)
index_names, names, index_col = _clean_index_names(index_names,
self.index_col,
self.unnamed_cols)
# extract the columns
field_count = len(header[0])
def extract(r):
return tuple(r[i] for i in range(field_count) if i not in sic)
columns = lzip(*[extract(r) for r in header])
names = ic + columns
# If we find unnamed columns all in a single
# level, then our header was too long.
for n in range(len(columns[0])):
if all(compat.to_str(c[n]) in self.unnamed_cols for c in columns):
raise ParserError(
"Passed header=[{header}] are too many rows for this "
"multi_index of columns"
.format(header=','.join(str(x) for x in self.header))
)
# Clean the column names (if we have an index_col).
if len(ic):
col_names = [r[0] if (len(r[0]) and
r[0] not in self.unnamed_cols) else None
for r in header]
else:
col_names = [None] * len(header)
passed_names = True
return names, index_names, col_names, passed_names | def _extract_multi_indexer_columns(self, header, index_names, col_names,
passed_names=False):
""" extract and return the names, index_names, col_names
header is a list-of-lists returned from the parsers """
if len(header) < 2:
return header[0], index_names, col_names, passed_names
# the names are the tuples of the header that are not the index cols
# 0 is the name of the index, assuming index_col is a list of column
# numbers
ic = self.index_col
if ic is None:
ic = []
if not isinstance(ic, (list, tuple, np.ndarray)):
ic = [ic]
sic = set(ic)
# clean the index_names
index_names = header.pop(-1)
index_names, names, index_col = _clean_index_names(index_names,
self.index_col,
self.unnamed_cols)
# extract the columns
field_count = len(header[0])
def extract(r):
return tuple(r[i] for i in range(field_count) if i not in sic)
columns = lzip(*[extract(r) for r in header])
names = ic + columns
# If we find unnamed columns all in a single
# level, then our header was too long.
for n in range(len(columns[0])):
if all(compat.to_str(c[n]) in self.unnamed_cols for c in columns):
raise ParserError(
"Passed header=[{header}] are too many rows for this "
"multi_index of columns"
.format(header=','.join(str(x) for x in self.header))
)
# Clean the column names (if we have an index_col).
if len(ic):
col_names = [r[0] if (len(r[0]) and
r[0] not in self.unnamed_cols) else None
for r in header]
else:
col_names = [None] * len(header)
passed_names = True
return names, index_names, col_names, passed_names | [
"extract",
"and",
"return",
"the",
"names",
"index_names",
"col_names",
"header",
"is",
"a",
"list",
"-",
"of",
"-",
"lists",
"returned",
"from",
"the",
"parsers"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L1451-L1504 | [
"def",
"_extract_multi_indexer_columns",
"(",
"self",
",",
"header",
",",
"index_names",
",",
"col_names",
",",
"passed_names",
"=",
"False",
")",
":",
"if",
"len",
"(",
"header",
")",
"<",
"2",
":",
"return",
"header",
"[",
"0",
"]",
",",
"index_names",
",",
"col_names",
",",
"passed_names",
"# the names are the tuples of the header that are not the index cols",
"# 0 is the name of the index, assuming index_col is a list of column",
"# numbers",
"ic",
"=",
"self",
".",
"index_col",
"if",
"ic",
"is",
"None",
":",
"ic",
"=",
"[",
"]",
"if",
"not",
"isinstance",
"(",
"ic",
",",
"(",
"list",
",",
"tuple",
",",
"np",
".",
"ndarray",
")",
")",
":",
"ic",
"=",
"[",
"ic",
"]",
"sic",
"=",
"set",
"(",
"ic",
")",
"# clean the index_names",
"index_names",
"=",
"header",
".",
"pop",
"(",
"-",
"1",
")",
"index_names",
",",
"names",
",",
"index_col",
"=",
"_clean_index_names",
"(",
"index_names",
",",
"self",
".",
"index_col",
",",
"self",
".",
"unnamed_cols",
")",
"# extract the columns",
"field_count",
"=",
"len",
"(",
"header",
"[",
"0",
"]",
")",
"def",
"extract",
"(",
"r",
")",
":",
"return",
"tuple",
"(",
"r",
"[",
"i",
"]",
"for",
"i",
"in",
"range",
"(",
"field_count",
")",
"if",
"i",
"not",
"in",
"sic",
")",
"columns",
"=",
"lzip",
"(",
"*",
"[",
"extract",
"(",
"r",
")",
"for",
"r",
"in",
"header",
"]",
")",
"names",
"=",
"ic",
"+",
"columns",
"# If we find unnamed columns all in a single",
"# level, then our header was too long.",
"for",
"n",
"in",
"range",
"(",
"len",
"(",
"columns",
"[",
"0",
"]",
")",
")",
":",
"if",
"all",
"(",
"compat",
".",
"to_str",
"(",
"c",
"[",
"n",
"]",
")",
"in",
"self",
".",
"unnamed_cols",
"for",
"c",
"in",
"columns",
")",
":",
"raise",
"ParserError",
"(",
"\"Passed header=[{header}] are too many rows for this \"",
"\"multi_index of columns\"",
".",
"format",
"(",
"header",
"=",
"','",
".",
"join",
"(",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"self",
".",
"header",
")",
")",
")",
"# Clean the column names (if we have an index_col).",
"if",
"len",
"(",
"ic",
")",
":",
"col_names",
"=",
"[",
"r",
"[",
"0",
"]",
"if",
"(",
"len",
"(",
"r",
"[",
"0",
"]",
")",
"and",
"r",
"[",
"0",
"]",
"not",
"in",
"self",
".",
"unnamed_cols",
")",
"else",
"None",
"for",
"r",
"in",
"header",
"]",
"else",
":",
"col_names",
"=",
"[",
"None",
"]",
"*",
"len",
"(",
"header",
")",
"passed_names",
"=",
"True",
"return",
"names",
",",
"index_names",
",",
"col_names",
",",
"passed_names"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | ParserBase._infer_types | Infer types of values, possibly casting
Parameters
----------
values : ndarray
na_values : set
try_num_bool : bool, default try
try to cast values to numeric (first preference) or boolean
Returns:
--------
converted : ndarray
na_count : int | pandas/io/parsers.py | def _infer_types(self, values, na_values, try_num_bool=True):
"""
Infer types of values, possibly casting
Parameters
----------
values : ndarray
na_values : set
try_num_bool : bool, default try
try to cast values to numeric (first preference) or boolean
Returns:
--------
converted : ndarray
na_count : int
"""
na_count = 0
if issubclass(values.dtype.type, (np.number, np.bool_)):
mask = algorithms.isin(values, list(na_values))
na_count = mask.sum()
if na_count > 0:
if is_integer_dtype(values):
values = values.astype(np.float64)
np.putmask(values, mask, np.nan)
return values, na_count
if try_num_bool:
try:
result = lib.maybe_convert_numeric(values, na_values, False)
na_count = isna(result).sum()
except Exception:
result = values
if values.dtype == np.object_:
na_count = parsers.sanitize_objects(result,
na_values, False)
else:
result = values
if values.dtype == np.object_:
na_count = parsers.sanitize_objects(values, na_values, False)
if result.dtype == np.object_ and try_num_bool:
result = libops.maybe_convert_bool(np.asarray(values),
true_values=self.true_values,
false_values=self.false_values)
return result, na_count | def _infer_types(self, values, na_values, try_num_bool=True):
"""
Infer types of values, possibly casting
Parameters
----------
values : ndarray
na_values : set
try_num_bool : bool, default try
try to cast values to numeric (first preference) or boolean
Returns:
--------
converted : ndarray
na_count : int
"""
na_count = 0
if issubclass(values.dtype.type, (np.number, np.bool_)):
mask = algorithms.isin(values, list(na_values))
na_count = mask.sum()
if na_count > 0:
if is_integer_dtype(values):
values = values.astype(np.float64)
np.putmask(values, mask, np.nan)
return values, na_count
if try_num_bool:
try:
result = lib.maybe_convert_numeric(values, na_values, False)
na_count = isna(result).sum()
except Exception:
result = values
if values.dtype == np.object_:
na_count = parsers.sanitize_objects(result,
na_values, False)
else:
result = values
if values.dtype == np.object_:
na_count = parsers.sanitize_objects(values, na_values, False)
if result.dtype == np.object_ and try_num_bool:
result = libops.maybe_convert_bool(np.asarray(values),
true_values=self.true_values,
false_values=self.false_values)
return result, na_count | [
"Infer",
"types",
"of",
"values",
"possibly",
"casting"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L1719-L1764 | [
"def",
"_infer_types",
"(",
"self",
",",
"values",
",",
"na_values",
",",
"try_num_bool",
"=",
"True",
")",
":",
"na_count",
"=",
"0",
"if",
"issubclass",
"(",
"values",
".",
"dtype",
".",
"type",
",",
"(",
"np",
".",
"number",
",",
"np",
".",
"bool_",
")",
")",
":",
"mask",
"=",
"algorithms",
".",
"isin",
"(",
"values",
",",
"list",
"(",
"na_values",
")",
")",
"na_count",
"=",
"mask",
".",
"sum",
"(",
")",
"if",
"na_count",
">",
"0",
":",
"if",
"is_integer_dtype",
"(",
"values",
")",
":",
"values",
"=",
"values",
".",
"astype",
"(",
"np",
".",
"float64",
")",
"np",
".",
"putmask",
"(",
"values",
",",
"mask",
",",
"np",
".",
"nan",
")",
"return",
"values",
",",
"na_count",
"if",
"try_num_bool",
":",
"try",
":",
"result",
"=",
"lib",
".",
"maybe_convert_numeric",
"(",
"values",
",",
"na_values",
",",
"False",
")",
"na_count",
"=",
"isna",
"(",
"result",
")",
".",
"sum",
"(",
")",
"except",
"Exception",
":",
"result",
"=",
"values",
"if",
"values",
".",
"dtype",
"==",
"np",
".",
"object_",
":",
"na_count",
"=",
"parsers",
".",
"sanitize_objects",
"(",
"result",
",",
"na_values",
",",
"False",
")",
"else",
":",
"result",
"=",
"values",
"if",
"values",
".",
"dtype",
"==",
"np",
".",
"object_",
":",
"na_count",
"=",
"parsers",
".",
"sanitize_objects",
"(",
"values",
",",
"na_values",
",",
"False",
")",
"if",
"result",
".",
"dtype",
"==",
"np",
".",
"object_",
"and",
"try_num_bool",
":",
"result",
"=",
"libops",
".",
"maybe_convert_bool",
"(",
"np",
".",
"asarray",
"(",
"values",
")",
",",
"true_values",
"=",
"self",
".",
"true_values",
",",
"false_values",
"=",
"self",
".",
"false_values",
")",
"return",
"result",
",",
"na_count"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | ParserBase._cast_types | Cast values to specified type
Parameters
----------
values : ndarray
cast_type : string or np.dtype
dtype to cast values to
column : string
column name - used only for error reporting
Returns
-------
converted : ndarray | pandas/io/parsers.py | def _cast_types(self, values, cast_type, column):
"""
Cast values to specified type
Parameters
----------
values : ndarray
cast_type : string or np.dtype
dtype to cast values to
column : string
column name - used only for error reporting
Returns
-------
converted : ndarray
"""
if is_categorical_dtype(cast_type):
known_cats = (isinstance(cast_type, CategoricalDtype) and
cast_type.categories is not None)
if not is_object_dtype(values) and not known_cats:
# XXX this is for consistency with
# c-parser which parses all categories
# as strings
values = astype_nansafe(values, str)
cats = Index(values).unique().dropna()
values = Categorical._from_inferred_categories(
cats, cats.get_indexer(values), cast_type,
true_values=self.true_values)
# use the EA's implementation of casting
elif is_extension_array_dtype(cast_type):
# ensure cast_type is an actual dtype and not a string
cast_type = pandas_dtype(cast_type)
array_type = cast_type.construct_array_type()
try:
return array_type._from_sequence_of_strings(values,
dtype=cast_type)
except NotImplementedError:
raise NotImplementedError(
"Extension Array: {ea} must implement "
"_from_sequence_of_strings in order "
"to be used in parser methods".format(ea=array_type))
else:
try:
values = astype_nansafe(values, cast_type,
copy=True, skipna=True)
except ValueError:
raise ValueError(
"Unable to convert column {column} to type "
"{cast_type}".format(
column=column, cast_type=cast_type))
return values | def _cast_types(self, values, cast_type, column):
"""
Cast values to specified type
Parameters
----------
values : ndarray
cast_type : string or np.dtype
dtype to cast values to
column : string
column name - used only for error reporting
Returns
-------
converted : ndarray
"""
if is_categorical_dtype(cast_type):
known_cats = (isinstance(cast_type, CategoricalDtype) and
cast_type.categories is not None)
if not is_object_dtype(values) and not known_cats:
# XXX this is for consistency with
# c-parser which parses all categories
# as strings
values = astype_nansafe(values, str)
cats = Index(values).unique().dropna()
values = Categorical._from_inferred_categories(
cats, cats.get_indexer(values), cast_type,
true_values=self.true_values)
# use the EA's implementation of casting
elif is_extension_array_dtype(cast_type):
# ensure cast_type is an actual dtype and not a string
cast_type = pandas_dtype(cast_type)
array_type = cast_type.construct_array_type()
try:
return array_type._from_sequence_of_strings(values,
dtype=cast_type)
except NotImplementedError:
raise NotImplementedError(
"Extension Array: {ea} must implement "
"_from_sequence_of_strings in order "
"to be used in parser methods".format(ea=array_type))
else:
try:
values = astype_nansafe(values, cast_type,
copy=True, skipna=True)
except ValueError:
raise ValueError(
"Unable to convert column {column} to type "
"{cast_type}".format(
column=column, cast_type=cast_type))
return values | [
"Cast",
"values",
"to",
"specified",
"type"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L1766-L1821 | [
"def",
"_cast_types",
"(",
"self",
",",
"values",
",",
"cast_type",
",",
"column",
")",
":",
"if",
"is_categorical_dtype",
"(",
"cast_type",
")",
":",
"known_cats",
"=",
"(",
"isinstance",
"(",
"cast_type",
",",
"CategoricalDtype",
")",
"and",
"cast_type",
".",
"categories",
"is",
"not",
"None",
")",
"if",
"not",
"is_object_dtype",
"(",
"values",
")",
"and",
"not",
"known_cats",
":",
"# XXX this is for consistency with",
"# c-parser which parses all categories",
"# as strings",
"values",
"=",
"astype_nansafe",
"(",
"values",
",",
"str",
")",
"cats",
"=",
"Index",
"(",
"values",
")",
".",
"unique",
"(",
")",
".",
"dropna",
"(",
")",
"values",
"=",
"Categorical",
".",
"_from_inferred_categories",
"(",
"cats",
",",
"cats",
".",
"get_indexer",
"(",
"values",
")",
",",
"cast_type",
",",
"true_values",
"=",
"self",
".",
"true_values",
")",
"# use the EA's implementation of casting",
"elif",
"is_extension_array_dtype",
"(",
"cast_type",
")",
":",
"# ensure cast_type is an actual dtype and not a string",
"cast_type",
"=",
"pandas_dtype",
"(",
"cast_type",
")",
"array_type",
"=",
"cast_type",
".",
"construct_array_type",
"(",
")",
"try",
":",
"return",
"array_type",
".",
"_from_sequence_of_strings",
"(",
"values",
",",
"dtype",
"=",
"cast_type",
")",
"except",
"NotImplementedError",
":",
"raise",
"NotImplementedError",
"(",
"\"Extension Array: {ea} must implement \"",
"\"_from_sequence_of_strings in order \"",
"\"to be used in parser methods\"",
".",
"format",
"(",
"ea",
"=",
"array_type",
")",
")",
"else",
":",
"try",
":",
"values",
"=",
"astype_nansafe",
"(",
"values",
",",
"cast_type",
",",
"copy",
"=",
"True",
",",
"skipna",
"=",
"True",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"\"Unable to convert column {column} to type \"",
"\"{cast_type}\"",
".",
"format",
"(",
"column",
"=",
"column",
",",
"cast_type",
"=",
"cast_type",
")",
")",
"return",
"values"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | CParserWrapper._set_noconvert_columns | Set the columns that should not undergo dtype conversions.
Currently, any column that is involved with date parsing will not
undergo such conversions. | pandas/io/parsers.py | def _set_noconvert_columns(self):
"""
Set the columns that should not undergo dtype conversions.
Currently, any column that is involved with date parsing will not
undergo such conversions.
"""
names = self.orig_names
if self.usecols_dtype == 'integer':
# A set of integers will be converted to a list in
# the correct order every single time.
usecols = list(self.usecols)
usecols.sort()
elif (callable(self.usecols) or
self.usecols_dtype not in ('empty', None)):
# The names attribute should have the correct columns
# in the proper order for indexing with parse_dates.
usecols = self.names[:]
else:
# Usecols is empty.
usecols = None
def _set(x):
if usecols is not None and is_integer(x):
x = usecols[x]
if not is_integer(x):
x = names.index(x)
self._reader.set_noconvert(x)
if isinstance(self.parse_dates, list):
for val in self.parse_dates:
if isinstance(val, list):
for k in val:
_set(k)
else:
_set(val)
elif isinstance(self.parse_dates, dict):
for val in self.parse_dates.values():
if isinstance(val, list):
for k in val:
_set(k)
else:
_set(val)
elif self.parse_dates:
if isinstance(self.index_col, list):
for k in self.index_col:
_set(k)
elif self.index_col is not None:
_set(self.index_col) | def _set_noconvert_columns(self):
"""
Set the columns that should not undergo dtype conversions.
Currently, any column that is involved with date parsing will not
undergo such conversions.
"""
names = self.orig_names
if self.usecols_dtype == 'integer':
# A set of integers will be converted to a list in
# the correct order every single time.
usecols = list(self.usecols)
usecols.sort()
elif (callable(self.usecols) or
self.usecols_dtype not in ('empty', None)):
# The names attribute should have the correct columns
# in the proper order for indexing with parse_dates.
usecols = self.names[:]
else:
# Usecols is empty.
usecols = None
def _set(x):
if usecols is not None and is_integer(x):
x = usecols[x]
if not is_integer(x):
x = names.index(x)
self._reader.set_noconvert(x)
if isinstance(self.parse_dates, list):
for val in self.parse_dates:
if isinstance(val, list):
for k in val:
_set(k)
else:
_set(val)
elif isinstance(self.parse_dates, dict):
for val in self.parse_dates.values():
if isinstance(val, list):
for k in val:
_set(k)
else:
_set(val)
elif self.parse_dates:
if isinstance(self.index_col, list):
for k in self.index_col:
_set(k)
elif self.index_col is not None:
_set(self.index_col) | [
"Set",
"the",
"columns",
"that",
"should",
"not",
"undergo",
"dtype",
"conversions",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L1951-L2003 | [
"def",
"_set_noconvert_columns",
"(",
"self",
")",
":",
"names",
"=",
"self",
".",
"orig_names",
"if",
"self",
".",
"usecols_dtype",
"==",
"'integer'",
":",
"# A set of integers will be converted to a list in",
"# the correct order every single time.",
"usecols",
"=",
"list",
"(",
"self",
".",
"usecols",
")",
"usecols",
".",
"sort",
"(",
")",
"elif",
"(",
"callable",
"(",
"self",
".",
"usecols",
")",
"or",
"self",
".",
"usecols_dtype",
"not",
"in",
"(",
"'empty'",
",",
"None",
")",
")",
":",
"# The names attribute should have the correct columns",
"# in the proper order for indexing with parse_dates.",
"usecols",
"=",
"self",
".",
"names",
"[",
":",
"]",
"else",
":",
"# Usecols is empty.",
"usecols",
"=",
"None",
"def",
"_set",
"(",
"x",
")",
":",
"if",
"usecols",
"is",
"not",
"None",
"and",
"is_integer",
"(",
"x",
")",
":",
"x",
"=",
"usecols",
"[",
"x",
"]",
"if",
"not",
"is_integer",
"(",
"x",
")",
":",
"x",
"=",
"names",
".",
"index",
"(",
"x",
")",
"self",
".",
"_reader",
".",
"set_noconvert",
"(",
"x",
")",
"if",
"isinstance",
"(",
"self",
".",
"parse_dates",
",",
"list",
")",
":",
"for",
"val",
"in",
"self",
".",
"parse_dates",
":",
"if",
"isinstance",
"(",
"val",
",",
"list",
")",
":",
"for",
"k",
"in",
"val",
":",
"_set",
"(",
"k",
")",
"else",
":",
"_set",
"(",
"val",
")",
"elif",
"isinstance",
"(",
"self",
".",
"parse_dates",
",",
"dict",
")",
":",
"for",
"val",
"in",
"self",
".",
"parse_dates",
".",
"values",
"(",
")",
":",
"if",
"isinstance",
"(",
"val",
",",
"list",
")",
":",
"for",
"k",
"in",
"val",
":",
"_set",
"(",
"k",
")",
"else",
":",
"_set",
"(",
"val",
")",
"elif",
"self",
".",
"parse_dates",
":",
"if",
"isinstance",
"(",
"self",
".",
"index_col",
",",
"list",
")",
":",
"for",
"k",
"in",
"self",
".",
"index_col",
":",
"_set",
"(",
"k",
")",
"elif",
"self",
".",
"index_col",
"is",
"not",
"None",
":",
"_set",
"(",
"self",
".",
"index_col",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | PythonParser._handle_usecols | Sets self._col_indices
usecols_key is used if there are string usecols. | pandas/io/parsers.py | def _handle_usecols(self, columns, usecols_key):
"""
Sets self._col_indices
usecols_key is used if there are string usecols.
"""
if self.usecols is not None:
if callable(self.usecols):
col_indices = _evaluate_usecols(self.usecols, usecols_key)
elif any(isinstance(u, str) for u in self.usecols):
if len(columns) > 1:
raise ValueError("If using multiple headers, usecols must "
"be integers.")
col_indices = []
for col in self.usecols:
if isinstance(col, str):
try:
col_indices.append(usecols_key.index(col))
except ValueError:
_validate_usecols_names(self.usecols, usecols_key)
else:
col_indices.append(col)
else:
col_indices = self.usecols
columns = [[n for i, n in enumerate(column) if i in col_indices]
for column in columns]
self._col_indices = col_indices
return columns | def _handle_usecols(self, columns, usecols_key):
"""
Sets self._col_indices
usecols_key is used if there are string usecols.
"""
if self.usecols is not None:
if callable(self.usecols):
col_indices = _evaluate_usecols(self.usecols, usecols_key)
elif any(isinstance(u, str) for u in self.usecols):
if len(columns) > 1:
raise ValueError("If using multiple headers, usecols must "
"be integers.")
col_indices = []
for col in self.usecols:
if isinstance(col, str):
try:
col_indices.append(usecols_key.index(col))
except ValueError:
_validate_usecols_names(self.usecols, usecols_key)
else:
col_indices.append(col)
else:
col_indices = self.usecols
columns = [[n for i, n in enumerate(column) if i in col_indices]
for column in columns]
self._col_indices = col_indices
return columns | [
"Sets",
"self",
".",
"_col_indices"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L2678-L2707 | [
"def",
"_handle_usecols",
"(",
"self",
",",
"columns",
",",
"usecols_key",
")",
":",
"if",
"self",
".",
"usecols",
"is",
"not",
"None",
":",
"if",
"callable",
"(",
"self",
".",
"usecols",
")",
":",
"col_indices",
"=",
"_evaluate_usecols",
"(",
"self",
".",
"usecols",
",",
"usecols_key",
")",
"elif",
"any",
"(",
"isinstance",
"(",
"u",
",",
"str",
")",
"for",
"u",
"in",
"self",
".",
"usecols",
")",
":",
"if",
"len",
"(",
"columns",
")",
">",
"1",
":",
"raise",
"ValueError",
"(",
"\"If using multiple headers, usecols must \"",
"\"be integers.\"",
")",
"col_indices",
"=",
"[",
"]",
"for",
"col",
"in",
"self",
".",
"usecols",
":",
"if",
"isinstance",
"(",
"col",
",",
"str",
")",
":",
"try",
":",
"col_indices",
".",
"append",
"(",
"usecols_key",
".",
"index",
"(",
"col",
")",
")",
"except",
"ValueError",
":",
"_validate_usecols_names",
"(",
"self",
".",
"usecols",
",",
"usecols_key",
")",
"else",
":",
"col_indices",
".",
"append",
"(",
"col",
")",
"else",
":",
"col_indices",
"=",
"self",
".",
"usecols",
"columns",
"=",
"[",
"[",
"n",
"for",
"i",
",",
"n",
"in",
"enumerate",
"(",
"column",
")",
"if",
"i",
"in",
"col_indices",
"]",
"for",
"column",
"in",
"columns",
"]",
"self",
".",
"_col_indices",
"=",
"col_indices",
"return",
"columns"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | PythonParser._check_for_bom | Checks whether the file begins with the BOM character.
If it does, remove it. In addition, if there is quoting
in the field subsequent to the BOM, remove it as well
because it technically takes place at the beginning of
the name, not the middle of it. | pandas/io/parsers.py | def _check_for_bom(self, first_row):
"""
Checks whether the file begins with the BOM character.
If it does, remove it. In addition, if there is quoting
in the field subsequent to the BOM, remove it as well
because it technically takes place at the beginning of
the name, not the middle of it.
"""
# first_row will be a list, so we need to check
# that that list is not empty before proceeding.
if not first_row:
return first_row
# The first element of this row is the one that could have the
# BOM that we want to remove. Check that the first element is a
# string before proceeding.
if not isinstance(first_row[0], str):
return first_row
# Check that the string is not empty, as that would
# obviously not have a BOM at the start of it.
if not first_row[0]:
return first_row
# Since the string is non-empty, check that it does
# in fact begin with a BOM.
first_elt = first_row[0][0]
if first_elt != _BOM:
return first_row
first_row = first_row[0]
if len(first_row) > 1 and first_row[1] == self.quotechar:
start = 2
quote = first_row[1]
end = first_row[2:].index(quote) + 2
# Extract the data between the quotation marks
new_row = first_row[start:end]
# Extract any remaining data after the second
# quotation mark.
if len(first_row) > end + 1:
new_row += first_row[end + 1:]
return [new_row]
elif len(first_row) > 1:
return [first_row[1:]]
else:
# First row is just the BOM, so we
# return an empty string.
return [""] | def _check_for_bom(self, first_row):
"""
Checks whether the file begins with the BOM character.
If it does, remove it. In addition, if there is quoting
in the field subsequent to the BOM, remove it as well
because it technically takes place at the beginning of
the name, not the middle of it.
"""
# first_row will be a list, so we need to check
# that that list is not empty before proceeding.
if not first_row:
return first_row
# The first element of this row is the one that could have the
# BOM that we want to remove. Check that the first element is a
# string before proceeding.
if not isinstance(first_row[0], str):
return first_row
# Check that the string is not empty, as that would
# obviously not have a BOM at the start of it.
if not first_row[0]:
return first_row
# Since the string is non-empty, check that it does
# in fact begin with a BOM.
first_elt = first_row[0][0]
if first_elt != _BOM:
return first_row
first_row = first_row[0]
if len(first_row) > 1 and first_row[1] == self.quotechar:
start = 2
quote = first_row[1]
end = first_row[2:].index(quote) + 2
# Extract the data between the quotation marks
new_row = first_row[start:end]
# Extract any remaining data after the second
# quotation mark.
if len(first_row) > end + 1:
new_row += first_row[end + 1:]
return [new_row]
elif len(first_row) > 1:
return [first_row[1:]]
else:
# First row is just the BOM, so we
# return an empty string.
return [""] | [
"Checks",
"whether",
"the",
"file",
"begins",
"with",
"the",
"BOM",
"character",
".",
"If",
"it",
"does",
"remove",
"it",
".",
"In",
"addition",
"if",
"there",
"is",
"quoting",
"in",
"the",
"field",
"subsequent",
"to",
"the",
"BOM",
"remove",
"it",
"as",
"well",
"because",
"it",
"technically",
"takes",
"place",
"at",
"the",
"beginning",
"of",
"the",
"name",
"not",
"the",
"middle",
"of",
"it",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L2718-L2768 | [
"def",
"_check_for_bom",
"(",
"self",
",",
"first_row",
")",
":",
"# first_row will be a list, so we need to check",
"# that that list is not empty before proceeding.",
"if",
"not",
"first_row",
":",
"return",
"first_row",
"# The first element of this row is the one that could have the",
"# BOM that we want to remove. Check that the first element is a",
"# string before proceeding.",
"if",
"not",
"isinstance",
"(",
"first_row",
"[",
"0",
"]",
",",
"str",
")",
":",
"return",
"first_row",
"# Check that the string is not empty, as that would",
"# obviously not have a BOM at the start of it.",
"if",
"not",
"first_row",
"[",
"0",
"]",
":",
"return",
"first_row",
"# Since the string is non-empty, check that it does",
"# in fact begin with a BOM.",
"first_elt",
"=",
"first_row",
"[",
"0",
"]",
"[",
"0",
"]",
"if",
"first_elt",
"!=",
"_BOM",
":",
"return",
"first_row",
"first_row",
"=",
"first_row",
"[",
"0",
"]",
"if",
"len",
"(",
"first_row",
")",
">",
"1",
"and",
"first_row",
"[",
"1",
"]",
"==",
"self",
".",
"quotechar",
":",
"start",
"=",
"2",
"quote",
"=",
"first_row",
"[",
"1",
"]",
"end",
"=",
"first_row",
"[",
"2",
":",
"]",
".",
"index",
"(",
"quote",
")",
"+",
"2",
"# Extract the data between the quotation marks",
"new_row",
"=",
"first_row",
"[",
"start",
":",
"end",
"]",
"# Extract any remaining data after the second",
"# quotation mark.",
"if",
"len",
"(",
"first_row",
")",
">",
"end",
"+",
"1",
":",
"new_row",
"+=",
"first_row",
"[",
"end",
"+",
"1",
":",
"]",
"return",
"[",
"new_row",
"]",
"elif",
"len",
"(",
"first_row",
")",
">",
"1",
":",
"return",
"[",
"first_row",
"[",
"1",
":",
"]",
"]",
"else",
":",
"# First row is just the BOM, so we",
"# return an empty string.",
"return",
"[",
"\"\"",
"]"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | PythonParser._alert_malformed | Alert a user about a malformed row.
If `self.error_bad_lines` is True, the alert will be `ParserError`.
If `self.warn_bad_lines` is True, the alert will be printed out.
Parameters
----------
msg : The error message to display.
row_num : The row number where the parsing error occurred.
Because this row number is displayed, we 1-index,
even though we 0-index internally. | pandas/io/parsers.py | def _alert_malformed(self, msg, row_num):
"""
Alert a user about a malformed row.
If `self.error_bad_lines` is True, the alert will be `ParserError`.
If `self.warn_bad_lines` is True, the alert will be printed out.
Parameters
----------
msg : The error message to display.
row_num : The row number where the parsing error occurred.
Because this row number is displayed, we 1-index,
even though we 0-index internally.
"""
if self.error_bad_lines:
raise ParserError(msg)
elif self.warn_bad_lines:
base = 'Skipping line {row_num}: '.format(row_num=row_num)
sys.stderr.write(base + msg + '\n') | def _alert_malformed(self, msg, row_num):
"""
Alert a user about a malformed row.
If `self.error_bad_lines` is True, the alert will be `ParserError`.
If `self.warn_bad_lines` is True, the alert will be printed out.
Parameters
----------
msg : The error message to display.
row_num : The row number where the parsing error occurred.
Because this row number is displayed, we 1-index,
even though we 0-index internally.
"""
if self.error_bad_lines:
raise ParserError(msg)
elif self.warn_bad_lines:
base = 'Skipping line {row_num}: '.format(row_num=row_num)
sys.stderr.write(base + msg + '\n') | [
"Alert",
"a",
"user",
"about",
"a",
"malformed",
"row",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L2837-L2856 | [
"def",
"_alert_malformed",
"(",
"self",
",",
"msg",
",",
"row_num",
")",
":",
"if",
"self",
".",
"error_bad_lines",
":",
"raise",
"ParserError",
"(",
"msg",
")",
"elif",
"self",
".",
"warn_bad_lines",
":",
"base",
"=",
"'Skipping line {row_num}: '",
".",
"format",
"(",
"row_num",
"=",
"row_num",
")",
"sys",
".",
"stderr",
".",
"write",
"(",
"base",
"+",
"msg",
"+",
"'\\n'",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | PythonParser._next_iter_line | Wrapper around iterating through `self.data` (CSV source).
When a CSV error is raised, we check for specific
error messages that allow us to customize the
error message displayed to the user.
Parameters
----------
row_num : The row number of the line being parsed. | pandas/io/parsers.py | def _next_iter_line(self, row_num):
"""
Wrapper around iterating through `self.data` (CSV source).
When a CSV error is raised, we check for specific
error messages that allow us to customize the
error message displayed to the user.
Parameters
----------
row_num : The row number of the line being parsed.
"""
try:
return next(self.data)
except csv.Error as e:
if self.warn_bad_lines or self.error_bad_lines:
msg = str(e)
if 'NULL byte' in msg:
msg = ('NULL byte detected. This byte '
'cannot be processed in Python\'s '
'native csv library at the moment, '
'so please pass in engine=\'c\' instead')
if self.skipfooter > 0:
reason = ('Error could possibly be due to '
'parsing errors in the skipped footer rows '
'(the skipfooter keyword is only applied '
'after Python\'s csv library has parsed '
'all rows).')
msg += '. ' + reason
self._alert_malformed(msg, row_num)
return None | def _next_iter_line(self, row_num):
"""
Wrapper around iterating through `self.data` (CSV source).
When a CSV error is raised, we check for specific
error messages that allow us to customize the
error message displayed to the user.
Parameters
----------
row_num : The row number of the line being parsed.
"""
try:
return next(self.data)
except csv.Error as e:
if self.warn_bad_lines or self.error_bad_lines:
msg = str(e)
if 'NULL byte' in msg:
msg = ('NULL byte detected. This byte '
'cannot be processed in Python\'s '
'native csv library at the moment, '
'so please pass in engine=\'c\' instead')
if self.skipfooter > 0:
reason = ('Error could possibly be due to '
'parsing errors in the skipped footer rows '
'(the skipfooter keyword is only applied '
'after Python\'s csv library has parsed '
'all rows).')
msg += '. ' + reason
self._alert_malformed(msg, row_num)
return None | [
"Wrapper",
"around",
"iterating",
"through",
"self",
".",
"data",
"(",
"CSV",
"source",
")",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L2858-L2892 | [
"def",
"_next_iter_line",
"(",
"self",
",",
"row_num",
")",
":",
"try",
":",
"return",
"next",
"(",
"self",
".",
"data",
")",
"except",
"csv",
".",
"Error",
"as",
"e",
":",
"if",
"self",
".",
"warn_bad_lines",
"or",
"self",
".",
"error_bad_lines",
":",
"msg",
"=",
"str",
"(",
"e",
")",
"if",
"'NULL byte'",
"in",
"msg",
":",
"msg",
"=",
"(",
"'NULL byte detected. This byte '",
"'cannot be processed in Python\\'s '",
"'native csv library at the moment, '",
"'so please pass in engine=\\'c\\' instead'",
")",
"if",
"self",
".",
"skipfooter",
">",
"0",
":",
"reason",
"=",
"(",
"'Error could possibly be due to '",
"'parsing errors in the skipped footer rows '",
"'(the skipfooter keyword is only applied '",
"'after Python\\'s csv library has parsed '",
"'all rows).'",
")",
"msg",
"+=",
"'. '",
"+",
"reason",
"self",
".",
"_alert_malformed",
"(",
"msg",
",",
"row_num",
")",
"return",
"None"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | PythonParser._remove_empty_lines | Iterate through the lines and remove any that are
either empty or contain only one whitespace value
Parameters
----------
lines : array-like
The array of lines that we are to filter.
Returns
-------
filtered_lines : array-like
The same array of lines with the "empty" ones removed. | pandas/io/parsers.py | def _remove_empty_lines(self, lines):
"""
Iterate through the lines and remove any that are
either empty or contain only one whitespace value
Parameters
----------
lines : array-like
The array of lines that we are to filter.
Returns
-------
filtered_lines : array-like
The same array of lines with the "empty" ones removed.
"""
ret = []
for l in lines:
# Remove empty lines and lines with only one whitespace value
if (len(l) > 1 or len(l) == 1 and
(not isinstance(l[0], str) or l[0].strip())):
ret.append(l)
return ret | def _remove_empty_lines(self, lines):
"""
Iterate through the lines and remove any that are
either empty or contain only one whitespace value
Parameters
----------
lines : array-like
The array of lines that we are to filter.
Returns
-------
filtered_lines : array-like
The same array of lines with the "empty" ones removed.
"""
ret = []
for l in lines:
# Remove empty lines and lines with only one whitespace value
if (len(l) > 1 or len(l) == 1 and
(not isinstance(l[0], str) or l[0].strip())):
ret.append(l)
return ret | [
"Iterate",
"through",
"the",
"lines",
"and",
"remove",
"any",
"that",
"are",
"either",
"empty",
"or",
"contain",
"only",
"one",
"whitespace",
"value"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L2912-L2934 | [
"def",
"_remove_empty_lines",
"(",
"self",
",",
"lines",
")",
":",
"ret",
"=",
"[",
"]",
"for",
"l",
"in",
"lines",
":",
"# Remove empty lines and lines with only one whitespace value",
"if",
"(",
"len",
"(",
"l",
")",
">",
"1",
"or",
"len",
"(",
"l",
")",
"==",
"1",
"and",
"(",
"not",
"isinstance",
"(",
"l",
"[",
"0",
"]",
",",
"str",
")",
"or",
"l",
"[",
"0",
"]",
".",
"strip",
"(",
")",
")",
")",
":",
"ret",
".",
"append",
"(",
"l",
")",
"return",
"ret"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | PythonParser._get_index_name | Try several cases to get lines:
0) There are headers on row 0 and row 1 and their
total summed lengths equals the length of the next line.
Treat row 0 as columns and row 1 as indices
1) Look for implicit index: there are more columns
on row 1 than row 0. If this is true, assume that row
1 lists index columns and row 0 lists normal columns.
2) Get index from the columns if it was listed. | pandas/io/parsers.py | def _get_index_name(self, columns):
"""
Try several cases to get lines:
0) There are headers on row 0 and row 1 and their
total summed lengths equals the length of the next line.
Treat row 0 as columns and row 1 as indices
1) Look for implicit index: there are more columns
on row 1 than row 0. If this is true, assume that row
1 lists index columns and row 0 lists normal columns.
2) Get index from the columns if it was listed.
"""
orig_names = list(columns)
columns = list(columns)
try:
line = self._next_line()
except StopIteration:
line = None
try:
next_line = self._next_line()
except StopIteration:
next_line = None
# implicitly index_col=0 b/c 1 fewer column names
implicit_first_cols = 0
if line is not None:
# leave it 0, #2442
# Case 1
if self.index_col is not False:
implicit_first_cols = len(line) - self.num_original_columns
# Case 0
if next_line is not None:
if len(next_line) == len(line) + self.num_original_columns:
# column and index names on diff rows
self.index_col = lrange(len(line))
self.buf = self.buf[1:]
for c in reversed(line):
columns.insert(0, c)
# Update list of original names to include all indices.
orig_names = list(columns)
self.num_original_columns = len(columns)
return line, orig_names, columns
if implicit_first_cols > 0:
# Case 1
self._implicit_index = True
if self.index_col is None:
self.index_col = lrange(implicit_first_cols)
index_name = None
else:
# Case 2
(index_name, columns_,
self.index_col) = _clean_index_names(columns, self.index_col,
self.unnamed_cols)
return index_name, orig_names, columns | def _get_index_name(self, columns):
"""
Try several cases to get lines:
0) There are headers on row 0 and row 1 and their
total summed lengths equals the length of the next line.
Treat row 0 as columns and row 1 as indices
1) Look for implicit index: there are more columns
on row 1 than row 0. If this is true, assume that row
1 lists index columns and row 0 lists normal columns.
2) Get index from the columns if it was listed.
"""
orig_names = list(columns)
columns = list(columns)
try:
line = self._next_line()
except StopIteration:
line = None
try:
next_line = self._next_line()
except StopIteration:
next_line = None
# implicitly index_col=0 b/c 1 fewer column names
implicit_first_cols = 0
if line is not None:
# leave it 0, #2442
# Case 1
if self.index_col is not False:
implicit_first_cols = len(line) - self.num_original_columns
# Case 0
if next_line is not None:
if len(next_line) == len(line) + self.num_original_columns:
# column and index names on diff rows
self.index_col = lrange(len(line))
self.buf = self.buf[1:]
for c in reversed(line):
columns.insert(0, c)
# Update list of original names to include all indices.
orig_names = list(columns)
self.num_original_columns = len(columns)
return line, orig_names, columns
if implicit_first_cols > 0:
# Case 1
self._implicit_index = True
if self.index_col is None:
self.index_col = lrange(implicit_first_cols)
index_name = None
else:
# Case 2
(index_name, columns_,
self.index_col) = _clean_index_names(columns, self.index_col,
self.unnamed_cols)
return index_name, orig_names, columns | [
"Try",
"several",
"cases",
"to",
"get",
"lines",
":"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L2973-L3035 | [
"def",
"_get_index_name",
"(",
"self",
",",
"columns",
")",
":",
"orig_names",
"=",
"list",
"(",
"columns",
")",
"columns",
"=",
"list",
"(",
"columns",
")",
"try",
":",
"line",
"=",
"self",
".",
"_next_line",
"(",
")",
"except",
"StopIteration",
":",
"line",
"=",
"None",
"try",
":",
"next_line",
"=",
"self",
".",
"_next_line",
"(",
")",
"except",
"StopIteration",
":",
"next_line",
"=",
"None",
"# implicitly index_col=0 b/c 1 fewer column names",
"implicit_first_cols",
"=",
"0",
"if",
"line",
"is",
"not",
"None",
":",
"# leave it 0, #2442",
"# Case 1",
"if",
"self",
".",
"index_col",
"is",
"not",
"False",
":",
"implicit_first_cols",
"=",
"len",
"(",
"line",
")",
"-",
"self",
".",
"num_original_columns",
"# Case 0",
"if",
"next_line",
"is",
"not",
"None",
":",
"if",
"len",
"(",
"next_line",
")",
"==",
"len",
"(",
"line",
")",
"+",
"self",
".",
"num_original_columns",
":",
"# column and index names on diff rows",
"self",
".",
"index_col",
"=",
"lrange",
"(",
"len",
"(",
"line",
")",
")",
"self",
".",
"buf",
"=",
"self",
".",
"buf",
"[",
"1",
":",
"]",
"for",
"c",
"in",
"reversed",
"(",
"line",
")",
":",
"columns",
".",
"insert",
"(",
"0",
",",
"c",
")",
"# Update list of original names to include all indices.",
"orig_names",
"=",
"list",
"(",
"columns",
")",
"self",
".",
"num_original_columns",
"=",
"len",
"(",
"columns",
")",
"return",
"line",
",",
"orig_names",
",",
"columns",
"if",
"implicit_first_cols",
">",
"0",
":",
"# Case 1",
"self",
".",
"_implicit_index",
"=",
"True",
"if",
"self",
".",
"index_col",
"is",
"None",
":",
"self",
".",
"index_col",
"=",
"lrange",
"(",
"implicit_first_cols",
")",
"index_name",
"=",
"None",
"else",
":",
"# Case 2",
"(",
"index_name",
",",
"columns_",
",",
"self",
".",
"index_col",
")",
"=",
"_clean_index_names",
"(",
"columns",
",",
"self",
".",
"index_col",
",",
"self",
".",
"unnamed_cols",
")",
"return",
"index_name",
",",
"orig_names",
",",
"columns"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | FixedWidthReader.get_rows | Read rows from self.f, skipping as specified.
We distinguish buffer_rows (the first <= infer_nrows
lines) from the rows returned to detect_colspecs
because it's simpler to leave the other locations
with skiprows logic alone than to modify them to
deal with the fact we skipped some rows here as
well.
Parameters
----------
infer_nrows : int
Number of rows to read from self.f, not counting
rows that are skipped.
skiprows: set, optional
Indices of rows to skip.
Returns
-------
detect_rows : list of str
A list containing the rows to read. | pandas/io/parsers.py | def get_rows(self, infer_nrows, skiprows=None):
"""
Read rows from self.f, skipping as specified.
We distinguish buffer_rows (the first <= infer_nrows
lines) from the rows returned to detect_colspecs
because it's simpler to leave the other locations
with skiprows logic alone than to modify them to
deal with the fact we skipped some rows here as
well.
Parameters
----------
infer_nrows : int
Number of rows to read from self.f, not counting
rows that are skipped.
skiprows: set, optional
Indices of rows to skip.
Returns
-------
detect_rows : list of str
A list containing the rows to read.
"""
if skiprows is None:
skiprows = set()
buffer_rows = []
detect_rows = []
for i, row in enumerate(self.f):
if i not in skiprows:
detect_rows.append(row)
buffer_rows.append(row)
if len(detect_rows) >= infer_nrows:
break
self.buffer = iter(buffer_rows)
return detect_rows | def get_rows(self, infer_nrows, skiprows=None):
"""
Read rows from self.f, skipping as specified.
We distinguish buffer_rows (the first <= infer_nrows
lines) from the rows returned to detect_colspecs
because it's simpler to leave the other locations
with skiprows logic alone than to modify them to
deal with the fact we skipped some rows here as
well.
Parameters
----------
infer_nrows : int
Number of rows to read from self.f, not counting
rows that are skipped.
skiprows: set, optional
Indices of rows to skip.
Returns
-------
detect_rows : list of str
A list containing the rows to read.
"""
if skiprows is None:
skiprows = set()
buffer_rows = []
detect_rows = []
for i, row in enumerate(self.f):
if i not in skiprows:
detect_rows.append(row)
buffer_rows.append(row)
if len(detect_rows) >= infer_nrows:
break
self.buffer = iter(buffer_rows)
return detect_rows | [
"Read",
"rows",
"from",
"self",
".",
"f",
"skipping",
"as",
"specified",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/parsers.py#L3535-L3571 | [
"def",
"get_rows",
"(",
"self",
",",
"infer_nrows",
",",
"skiprows",
"=",
"None",
")",
":",
"if",
"skiprows",
"is",
"None",
":",
"skiprows",
"=",
"set",
"(",
")",
"buffer_rows",
"=",
"[",
"]",
"detect_rows",
"=",
"[",
"]",
"for",
"i",
",",
"row",
"in",
"enumerate",
"(",
"self",
".",
"f",
")",
":",
"if",
"i",
"not",
"in",
"skiprows",
":",
"detect_rows",
".",
"append",
"(",
"row",
")",
"buffer_rows",
".",
"append",
"(",
"row",
")",
"if",
"len",
"(",
"detect_rows",
")",
">=",
"infer_nrows",
":",
"break",
"self",
".",
"buffer",
"=",
"iter",
"(",
"buffer_rows",
")",
"return",
"detect_rows"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | linkcode_resolve | Determine the URL corresponding to Python object | doc/source/conf.py | def linkcode_resolve(domain, info):
"""
Determine the URL corresponding to Python object
"""
if domain != 'py':
return None
modname = info['module']
fullname = info['fullname']
submod = sys.modules.get(modname)
if submod is None:
return None
obj = submod
for part in fullname.split('.'):
try:
obj = getattr(obj, part)
except AttributeError:
return None
try:
# inspect.unwrap() was added in Python version 3.4
if sys.version_info >= (3, 5):
fn = inspect.getsourcefile(inspect.unwrap(obj))
else:
fn = inspect.getsourcefile(obj)
except TypeError:
fn = None
if not fn:
return None
try:
source, lineno = inspect.getsourcelines(obj)
except OSError:
lineno = None
if lineno:
linespec = "#L{:d}-L{:d}".format(lineno, lineno + len(source) - 1)
else:
linespec = ""
fn = os.path.relpath(fn, start=os.path.dirname(pandas.__file__))
if '+' in pandas.__version__:
return ("http://github.com/pandas-dev/pandas/blob/master/pandas/"
"{}{}".format(fn, linespec))
else:
return ("http://github.com/pandas-dev/pandas/blob/"
"v{}/pandas/{}{}".format(pandas.__version__, fn, linespec)) | def linkcode_resolve(domain, info):
"""
Determine the URL corresponding to Python object
"""
if domain != 'py':
return None
modname = info['module']
fullname = info['fullname']
submod = sys.modules.get(modname)
if submod is None:
return None
obj = submod
for part in fullname.split('.'):
try:
obj = getattr(obj, part)
except AttributeError:
return None
try:
# inspect.unwrap() was added in Python version 3.4
if sys.version_info >= (3, 5):
fn = inspect.getsourcefile(inspect.unwrap(obj))
else:
fn = inspect.getsourcefile(obj)
except TypeError:
fn = None
if not fn:
return None
try:
source, lineno = inspect.getsourcelines(obj)
except OSError:
lineno = None
if lineno:
linespec = "#L{:d}-L{:d}".format(lineno, lineno + len(source) - 1)
else:
linespec = ""
fn = os.path.relpath(fn, start=os.path.dirname(pandas.__file__))
if '+' in pandas.__version__:
return ("http://github.com/pandas-dev/pandas/blob/master/pandas/"
"{}{}".format(fn, linespec))
else:
return ("http://github.com/pandas-dev/pandas/blob/"
"v{}/pandas/{}{}".format(pandas.__version__, fn, linespec)) | [
"Determine",
"the",
"URL",
"corresponding",
"to",
"Python",
"object"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/doc/source/conf.py#L629-L678 | [
"def",
"linkcode_resolve",
"(",
"domain",
",",
"info",
")",
":",
"if",
"domain",
"!=",
"'py'",
":",
"return",
"None",
"modname",
"=",
"info",
"[",
"'module'",
"]",
"fullname",
"=",
"info",
"[",
"'fullname'",
"]",
"submod",
"=",
"sys",
".",
"modules",
".",
"get",
"(",
"modname",
")",
"if",
"submod",
"is",
"None",
":",
"return",
"None",
"obj",
"=",
"submod",
"for",
"part",
"in",
"fullname",
".",
"split",
"(",
"'.'",
")",
":",
"try",
":",
"obj",
"=",
"getattr",
"(",
"obj",
",",
"part",
")",
"except",
"AttributeError",
":",
"return",
"None",
"try",
":",
"# inspect.unwrap() was added in Python version 3.4",
"if",
"sys",
".",
"version_info",
">=",
"(",
"3",
",",
"5",
")",
":",
"fn",
"=",
"inspect",
".",
"getsourcefile",
"(",
"inspect",
".",
"unwrap",
"(",
"obj",
")",
")",
"else",
":",
"fn",
"=",
"inspect",
".",
"getsourcefile",
"(",
"obj",
")",
"except",
"TypeError",
":",
"fn",
"=",
"None",
"if",
"not",
"fn",
":",
"return",
"None",
"try",
":",
"source",
",",
"lineno",
"=",
"inspect",
".",
"getsourcelines",
"(",
"obj",
")",
"except",
"OSError",
":",
"lineno",
"=",
"None",
"if",
"lineno",
":",
"linespec",
"=",
"\"#L{:d}-L{:d}\"",
".",
"format",
"(",
"lineno",
",",
"lineno",
"+",
"len",
"(",
"source",
")",
"-",
"1",
")",
"else",
":",
"linespec",
"=",
"\"\"",
"fn",
"=",
"os",
".",
"path",
".",
"relpath",
"(",
"fn",
",",
"start",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"pandas",
".",
"__file__",
")",
")",
"if",
"'+'",
"in",
"pandas",
".",
"__version__",
":",
"return",
"(",
"\"http://github.com/pandas-dev/pandas/blob/master/pandas/\"",
"\"{}{}\"",
".",
"format",
"(",
"fn",
",",
"linespec",
")",
")",
"else",
":",
"return",
"(",
"\"http://github.com/pandas-dev/pandas/blob/\"",
"\"v{}/pandas/{}{}\"",
".",
"format",
"(",
"pandas",
".",
"__version__",
",",
"fn",
",",
"linespec",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | process_class_docstrings | For those classes for which we use ::
:template: autosummary/class_without_autosummary.rst
the documented attributes/methods have to be listed in the class
docstring. However, if one of those lists is empty, we use 'None',
which then generates warnings in sphinx / ugly html output.
This "autodoc-process-docstring" event connector removes that part
from the processed docstring. | doc/source/conf.py | def process_class_docstrings(app, what, name, obj, options, lines):
"""
For those classes for which we use ::
:template: autosummary/class_without_autosummary.rst
the documented attributes/methods have to be listed in the class
docstring. However, if one of those lists is empty, we use 'None',
which then generates warnings in sphinx / ugly html output.
This "autodoc-process-docstring" event connector removes that part
from the processed docstring.
"""
if what == "class":
joined = '\n'.join(lines)
templates = [
""".. rubric:: Attributes
.. autosummary::
:toctree:
None
""",
""".. rubric:: Methods
.. autosummary::
:toctree:
None
"""
]
for template in templates:
if template in joined:
joined = joined.replace(template, '')
lines[:] = joined.split('\n') | def process_class_docstrings(app, what, name, obj, options, lines):
"""
For those classes for which we use ::
:template: autosummary/class_without_autosummary.rst
the documented attributes/methods have to be listed in the class
docstring. However, if one of those lists is empty, we use 'None',
which then generates warnings in sphinx / ugly html output.
This "autodoc-process-docstring" event connector removes that part
from the processed docstring.
"""
if what == "class":
joined = '\n'.join(lines)
templates = [
""".. rubric:: Attributes
.. autosummary::
:toctree:
None
""",
""".. rubric:: Methods
.. autosummary::
:toctree:
None
"""
]
for template in templates:
if template in joined:
joined = joined.replace(template, '')
lines[:] = joined.split('\n') | [
"For",
"those",
"classes",
"for",
"which",
"we",
"use",
"::"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/doc/source/conf.py#L688-L724 | [
"def",
"process_class_docstrings",
"(",
"app",
",",
"what",
",",
"name",
",",
"obj",
",",
"options",
",",
"lines",
")",
":",
"if",
"what",
"==",
"\"class\"",
":",
"joined",
"=",
"'\\n'",
".",
"join",
"(",
"lines",
")",
"templates",
"=",
"[",
"\"\"\".. rubric:: Attributes\n\n.. autosummary::\n :toctree:\n\n None\n\"\"\"",
",",
"\"\"\".. rubric:: Methods\n\n.. autosummary::\n :toctree:\n\n None\n\"\"\"",
"]",
"for",
"template",
"in",
"templates",
":",
"if",
"template",
"in",
"joined",
":",
"joined",
"=",
"joined",
".",
"replace",
"(",
"template",
",",
"''",
")",
"lines",
"[",
":",
"]",
"=",
"joined",
".",
"split",
"(",
"'\\n'",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | pack | Pack object `o` and write it to `stream`
See :class:`Packer` for options. | pandas/io/msgpack/__init__.py | def pack(o, stream, **kwargs):
"""
Pack object `o` and write it to `stream`
See :class:`Packer` for options.
"""
packer = Packer(**kwargs)
stream.write(packer.pack(o)) | def pack(o, stream, **kwargs):
"""
Pack object `o` and write it to `stream`
See :class:`Packer` for options.
"""
packer = Packer(**kwargs)
stream.write(packer.pack(o)) | [
"Pack",
"object",
"o",
"and",
"write",
"it",
"to",
"stream"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/msgpack/__init__.py#L26-L33 | [
"def",
"pack",
"(",
"o",
",",
"stream",
",",
"*",
"*",
"kwargs",
")",
":",
"packer",
"=",
"Packer",
"(",
"*",
"*",
"kwargs",
")",
"stream",
".",
"write",
"(",
"packer",
".",
"pack",
"(",
"o",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | get_mgr_concatenation_plan | Construct concatenation plan for given block manager and indexers.
Parameters
----------
mgr : BlockManager
indexers : dict of {axis: indexer}
Returns
-------
plan : list of (BlockPlacement, JoinUnit) tuples | pandas/core/internals/concat.py | def get_mgr_concatenation_plan(mgr, indexers):
"""
Construct concatenation plan for given block manager and indexers.
Parameters
----------
mgr : BlockManager
indexers : dict of {axis: indexer}
Returns
-------
plan : list of (BlockPlacement, JoinUnit) tuples
"""
# Calculate post-reindex shape , save for item axis which will be separate
# for each block anyway.
mgr_shape = list(mgr.shape)
for ax, indexer in indexers.items():
mgr_shape[ax] = len(indexer)
mgr_shape = tuple(mgr_shape)
if 0 in indexers:
ax0_indexer = indexers.pop(0)
blknos = algos.take_1d(mgr._blknos, ax0_indexer, fill_value=-1)
blklocs = algos.take_1d(mgr._blklocs, ax0_indexer, fill_value=-1)
else:
if mgr._is_single_block:
blk = mgr.blocks[0]
return [(blk.mgr_locs, JoinUnit(blk, mgr_shape, indexers))]
ax0_indexer = None
blknos = mgr._blknos
blklocs = mgr._blklocs
plan = []
for blkno, placements in libinternals.get_blkno_placements(blknos,
mgr.nblocks,
group=False):
assert placements.is_slice_like
join_unit_indexers = indexers.copy()
shape = list(mgr_shape)
shape[0] = len(placements)
shape = tuple(shape)
if blkno == -1:
unit = JoinUnit(None, shape)
else:
blk = mgr.blocks[blkno]
ax0_blk_indexer = blklocs[placements.indexer]
unit_no_ax0_reindexing = (len(placements) == len(blk.mgr_locs) and
# Fastpath detection of join unit not
# needing to reindex its block: no ax0
# reindexing took place and block
# placement was sequential before.
((ax0_indexer is None and
blk.mgr_locs.is_slice_like and
blk.mgr_locs.as_slice.step == 1) or
# Slow-ish detection: all indexer locs
# are sequential (and length match is
# checked above).
(np.diff(ax0_blk_indexer) == 1).all()))
# Omit indexer if no item reindexing is required.
if unit_no_ax0_reindexing:
join_unit_indexers.pop(0, None)
else:
join_unit_indexers[0] = ax0_blk_indexer
unit = JoinUnit(blk, shape, join_unit_indexers)
plan.append((placements, unit))
return plan | def get_mgr_concatenation_plan(mgr, indexers):
"""
Construct concatenation plan for given block manager and indexers.
Parameters
----------
mgr : BlockManager
indexers : dict of {axis: indexer}
Returns
-------
plan : list of (BlockPlacement, JoinUnit) tuples
"""
# Calculate post-reindex shape , save for item axis which will be separate
# for each block anyway.
mgr_shape = list(mgr.shape)
for ax, indexer in indexers.items():
mgr_shape[ax] = len(indexer)
mgr_shape = tuple(mgr_shape)
if 0 in indexers:
ax0_indexer = indexers.pop(0)
blknos = algos.take_1d(mgr._blknos, ax0_indexer, fill_value=-1)
blklocs = algos.take_1d(mgr._blklocs, ax0_indexer, fill_value=-1)
else:
if mgr._is_single_block:
blk = mgr.blocks[0]
return [(blk.mgr_locs, JoinUnit(blk, mgr_shape, indexers))]
ax0_indexer = None
blknos = mgr._blknos
blklocs = mgr._blklocs
plan = []
for blkno, placements in libinternals.get_blkno_placements(blknos,
mgr.nblocks,
group=False):
assert placements.is_slice_like
join_unit_indexers = indexers.copy()
shape = list(mgr_shape)
shape[0] = len(placements)
shape = tuple(shape)
if blkno == -1:
unit = JoinUnit(None, shape)
else:
blk = mgr.blocks[blkno]
ax0_blk_indexer = blklocs[placements.indexer]
unit_no_ax0_reindexing = (len(placements) == len(blk.mgr_locs) and
# Fastpath detection of join unit not
# needing to reindex its block: no ax0
# reindexing took place and block
# placement was sequential before.
((ax0_indexer is None and
blk.mgr_locs.is_slice_like and
blk.mgr_locs.as_slice.step == 1) or
# Slow-ish detection: all indexer locs
# are sequential (and length match is
# checked above).
(np.diff(ax0_blk_indexer) == 1).all()))
# Omit indexer if no item reindexing is required.
if unit_no_ax0_reindexing:
join_unit_indexers.pop(0, None)
else:
join_unit_indexers[0] = ax0_blk_indexer
unit = JoinUnit(blk, shape, join_unit_indexers)
plan.append((placements, unit))
return plan | [
"Construct",
"concatenation",
"plan",
"for",
"given",
"block",
"manager",
"and",
"indexers",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/internals/concat.py#L21-L98 | [
"def",
"get_mgr_concatenation_plan",
"(",
"mgr",
",",
"indexers",
")",
":",
"# Calculate post-reindex shape , save for item axis which will be separate",
"# for each block anyway.",
"mgr_shape",
"=",
"list",
"(",
"mgr",
".",
"shape",
")",
"for",
"ax",
",",
"indexer",
"in",
"indexers",
".",
"items",
"(",
")",
":",
"mgr_shape",
"[",
"ax",
"]",
"=",
"len",
"(",
"indexer",
")",
"mgr_shape",
"=",
"tuple",
"(",
"mgr_shape",
")",
"if",
"0",
"in",
"indexers",
":",
"ax0_indexer",
"=",
"indexers",
".",
"pop",
"(",
"0",
")",
"blknos",
"=",
"algos",
".",
"take_1d",
"(",
"mgr",
".",
"_blknos",
",",
"ax0_indexer",
",",
"fill_value",
"=",
"-",
"1",
")",
"blklocs",
"=",
"algos",
".",
"take_1d",
"(",
"mgr",
".",
"_blklocs",
",",
"ax0_indexer",
",",
"fill_value",
"=",
"-",
"1",
")",
"else",
":",
"if",
"mgr",
".",
"_is_single_block",
":",
"blk",
"=",
"mgr",
".",
"blocks",
"[",
"0",
"]",
"return",
"[",
"(",
"blk",
".",
"mgr_locs",
",",
"JoinUnit",
"(",
"blk",
",",
"mgr_shape",
",",
"indexers",
")",
")",
"]",
"ax0_indexer",
"=",
"None",
"blknos",
"=",
"mgr",
".",
"_blknos",
"blklocs",
"=",
"mgr",
".",
"_blklocs",
"plan",
"=",
"[",
"]",
"for",
"blkno",
",",
"placements",
"in",
"libinternals",
".",
"get_blkno_placements",
"(",
"blknos",
",",
"mgr",
".",
"nblocks",
",",
"group",
"=",
"False",
")",
":",
"assert",
"placements",
".",
"is_slice_like",
"join_unit_indexers",
"=",
"indexers",
".",
"copy",
"(",
")",
"shape",
"=",
"list",
"(",
"mgr_shape",
")",
"shape",
"[",
"0",
"]",
"=",
"len",
"(",
"placements",
")",
"shape",
"=",
"tuple",
"(",
"shape",
")",
"if",
"blkno",
"==",
"-",
"1",
":",
"unit",
"=",
"JoinUnit",
"(",
"None",
",",
"shape",
")",
"else",
":",
"blk",
"=",
"mgr",
".",
"blocks",
"[",
"blkno",
"]",
"ax0_blk_indexer",
"=",
"blklocs",
"[",
"placements",
".",
"indexer",
"]",
"unit_no_ax0_reindexing",
"=",
"(",
"len",
"(",
"placements",
")",
"==",
"len",
"(",
"blk",
".",
"mgr_locs",
")",
"and",
"# Fastpath detection of join unit not",
"# needing to reindex its block: no ax0",
"# reindexing took place and block",
"# placement was sequential before.",
"(",
"(",
"ax0_indexer",
"is",
"None",
"and",
"blk",
".",
"mgr_locs",
".",
"is_slice_like",
"and",
"blk",
".",
"mgr_locs",
".",
"as_slice",
".",
"step",
"==",
"1",
")",
"or",
"# Slow-ish detection: all indexer locs",
"# are sequential (and length match is",
"# checked above).",
"(",
"np",
".",
"diff",
"(",
"ax0_blk_indexer",
")",
"==",
"1",
")",
".",
"all",
"(",
")",
")",
")",
"# Omit indexer if no item reindexing is required.",
"if",
"unit_no_ax0_reindexing",
":",
"join_unit_indexers",
".",
"pop",
"(",
"0",
",",
"None",
")",
"else",
":",
"join_unit_indexers",
"[",
"0",
"]",
"=",
"ax0_blk_indexer",
"unit",
"=",
"JoinUnit",
"(",
"blk",
",",
"shape",
",",
"join_unit_indexers",
")",
"plan",
".",
"append",
"(",
"(",
"placements",
",",
"unit",
")",
")",
"return",
"plan"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | concatenate_join_units | Concatenate values from several join units along selected axis. | pandas/core/internals/concat.py | def concatenate_join_units(join_units, concat_axis, copy):
"""
Concatenate values from several join units along selected axis.
"""
if concat_axis == 0 and len(join_units) > 1:
# Concatenating join units along ax0 is handled in _merge_blocks.
raise AssertionError("Concatenating join units along axis0")
empty_dtype, upcasted_na = get_empty_dtype_and_na(join_units)
to_concat = [ju.get_reindexed_values(empty_dtype=empty_dtype,
upcasted_na=upcasted_na)
for ju in join_units]
if len(to_concat) == 1:
# Only one block, nothing to concatenate.
concat_values = to_concat[0]
if copy:
if isinstance(concat_values, np.ndarray):
# non-reindexed (=not yet copied) arrays are made into a view
# in JoinUnit.get_reindexed_values
if concat_values.base is not None:
concat_values = concat_values.copy()
else:
concat_values = concat_values.copy()
else:
concat_values = _concat._concat_compat(to_concat, axis=concat_axis)
return concat_values | def concatenate_join_units(join_units, concat_axis, copy):
"""
Concatenate values from several join units along selected axis.
"""
if concat_axis == 0 and len(join_units) > 1:
# Concatenating join units along ax0 is handled in _merge_blocks.
raise AssertionError("Concatenating join units along axis0")
empty_dtype, upcasted_na = get_empty_dtype_and_na(join_units)
to_concat = [ju.get_reindexed_values(empty_dtype=empty_dtype,
upcasted_na=upcasted_na)
for ju in join_units]
if len(to_concat) == 1:
# Only one block, nothing to concatenate.
concat_values = to_concat[0]
if copy:
if isinstance(concat_values, np.ndarray):
# non-reindexed (=not yet copied) arrays are made into a view
# in JoinUnit.get_reindexed_values
if concat_values.base is not None:
concat_values = concat_values.copy()
else:
concat_values = concat_values.copy()
else:
concat_values = _concat._concat_compat(to_concat, axis=concat_axis)
return concat_values | [
"Concatenate",
"values",
"from",
"several",
"join",
"units",
"along",
"selected",
"axis",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/internals/concat.py#L229-L257 | [
"def",
"concatenate_join_units",
"(",
"join_units",
",",
"concat_axis",
",",
"copy",
")",
":",
"if",
"concat_axis",
"==",
"0",
"and",
"len",
"(",
"join_units",
")",
">",
"1",
":",
"# Concatenating join units along ax0 is handled in _merge_blocks.",
"raise",
"AssertionError",
"(",
"\"Concatenating join units along axis0\"",
")",
"empty_dtype",
",",
"upcasted_na",
"=",
"get_empty_dtype_and_na",
"(",
"join_units",
")",
"to_concat",
"=",
"[",
"ju",
".",
"get_reindexed_values",
"(",
"empty_dtype",
"=",
"empty_dtype",
",",
"upcasted_na",
"=",
"upcasted_na",
")",
"for",
"ju",
"in",
"join_units",
"]",
"if",
"len",
"(",
"to_concat",
")",
"==",
"1",
":",
"# Only one block, nothing to concatenate.",
"concat_values",
"=",
"to_concat",
"[",
"0",
"]",
"if",
"copy",
":",
"if",
"isinstance",
"(",
"concat_values",
",",
"np",
".",
"ndarray",
")",
":",
"# non-reindexed (=not yet copied) arrays are made into a view",
"# in JoinUnit.get_reindexed_values",
"if",
"concat_values",
".",
"base",
"is",
"not",
"None",
":",
"concat_values",
"=",
"concat_values",
".",
"copy",
"(",
")",
"else",
":",
"concat_values",
"=",
"concat_values",
".",
"copy",
"(",
")",
"else",
":",
"concat_values",
"=",
"_concat",
".",
"_concat_compat",
"(",
"to_concat",
",",
"axis",
"=",
"concat_axis",
")",
"return",
"concat_values"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | get_empty_dtype_and_na | Return dtype and N/A values to use when concatenating specified units.
Returned N/A value may be None which means there was no casting involved.
Returns
-------
dtype
na | pandas/core/internals/concat.py | def get_empty_dtype_and_na(join_units):
"""
Return dtype and N/A values to use when concatenating specified units.
Returned N/A value may be None which means there was no casting involved.
Returns
-------
dtype
na
"""
if len(join_units) == 1:
blk = join_units[0].block
if blk is None:
return np.float64, np.nan
if is_uniform_reindex(join_units):
# XXX: integrate property
empty_dtype = join_units[0].block.dtype
upcasted_na = join_units[0].block.fill_value
return empty_dtype, upcasted_na
has_none_blocks = False
dtypes = [None] * len(join_units)
for i, unit in enumerate(join_units):
if unit.block is None:
has_none_blocks = True
else:
dtypes[i] = unit.dtype
upcast_classes = defaultdict(list)
null_upcast_classes = defaultdict(list)
for dtype, unit in zip(dtypes, join_units):
if dtype is None:
continue
if is_categorical_dtype(dtype):
upcast_cls = 'category'
elif is_datetime64tz_dtype(dtype):
upcast_cls = 'datetimetz'
elif issubclass(dtype.type, np.bool_):
upcast_cls = 'bool'
elif issubclass(dtype.type, np.object_):
upcast_cls = 'object'
elif is_datetime64_dtype(dtype):
upcast_cls = 'datetime'
elif is_timedelta64_dtype(dtype):
upcast_cls = 'timedelta'
elif is_sparse(dtype):
upcast_cls = dtype.subtype.name
elif is_extension_array_dtype(dtype):
upcast_cls = 'object'
elif is_float_dtype(dtype) or is_numeric_dtype(dtype):
upcast_cls = dtype.name
else:
upcast_cls = 'float'
# Null blocks should not influence upcast class selection, unless there
# are only null blocks, when same upcasting rules must be applied to
# null upcast classes.
if unit.is_na:
null_upcast_classes[upcast_cls].append(dtype)
else:
upcast_classes[upcast_cls].append(dtype)
if not upcast_classes:
upcast_classes = null_upcast_classes
# create the result
if 'object' in upcast_classes:
return np.dtype(np.object_), np.nan
elif 'bool' in upcast_classes:
if has_none_blocks:
return np.dtype(np.object_), np.nan
else:
return np.dtype(np.bool_), None
elif 'category' in upcast_classes:
return np.dtype(np.object_), np.nan
elif 'datetimetz' in upcast_classes:
# GH-25014. We use NaT instead of iNaT, since this eventually
# ends up in DatetimeArray.take, which does not allow iNaT.
dtype = upcast_classes['datetimetz']
return dtype[0], tslibs.NaT
elif 'datetime' in upcast_classes:
return np.dtype('M8[ns]'), tslibs.iNaT
elif 'timedelta' in upcast_classes:
return np.dtype('m8[ns]'), tslibs.iNaT
else: # pragma
try:
g = np.find_common_type(upcast_classes, [])
except TypeError:
# At least one is an ExtensionArray
return np.dtype(np.object_), np.nan
else:
if is_float_dtype(g):
return g, g.type(np.nan)
elif is_numeric_dtype(g):
if has_none_blocks:
return np.float64, np.nan
else:
return g, None
msg = "invalid dtype determination in get_concat_dtype"
raise AssertionError(msg) | def get_empty_dtype_and_na(join_units):
"""
Return dtype and N/A values to use when concatenating specified units.
Returned N/A value may be None which means there was no casting involved.
Returns
-------
dtype
na
"""
if len(join_units) == 1:
blk = join_units[0].block
if blk is None:
return np.float64, np.nan
if is_uniform_reindex(join_units):
# XXX: integrate property
empty_dtype = join_units[0].block.dtype
upcasted_na = join_units[0].block.fill_value
return empty_dtype, upcasted_na
has_none_blocks = False
dtypes = [None] * len(join_units)
for i, unit in enumerate(join_units):
if unit.block is None:
has_none_blocks = True
else:
dtypes[i] = unit.dtype
upcast_classes = defaultdict(list)
null_upcast_classes = defaultdict(list)
for dtype, unit in zip(dtypes, join_units):
if dtype is None:
continue
if is_categorical_dtype(dtype):
upcast_cls = 'category'
elif is_datetime64tz_dtype(dtype):
upcast_cls = 'datetimetz'
elif issubclass(dtype.type, np.bool_):
upcast_cls = 'bool'
elif issubclass(dtype.type, np.object_):
upcast_cls = 'object'
elif is_datetime64_dtype(dtype):
upcast_cls = 'datetime'
elif is_timedelta64_dtype(dtype):
upcast_cls = 'timedelta'
elif is_sparse(dtype):
upcast_cls = dtype.subtype.name
elif is_extension_array_dtype(dtype):
upcast_cls = 'object'
elif is_float_dtype(dtype) or is_numeric_dtype(dtype):
upcast_cls = dtype.name
else:
upcast_cls = 'float'
# Null blocks should not influence upcast class selection, unless there
# are only null blocks, when same upcasting rules must be applied to
# null upcast classes.
if unit.is_na:
null_upcast_classes[upcast_cls].append(dtype)
else:
upcast_classes[upcast_cls].append(dtype)
if not upcast_classes:
upcast_classes = null_upcast_classes
# create the result
if 'object' in upcast_classes:
return np.dtype(np.object_), np.nan
elif 'bool' in upcast_classes:
if has_none_blocks:
return np.dtype(np.object_), np.nan
else:
return np.dtype(np.bool_), None
elif 'category' in upcast_classes:
return np.dtype(np.object_), np.nan
elif 'datetimetz' in upcast_classes:
# GH-25014. We use NaT instead of iNaT, since this eventually
# ends up in DatetimeArray.take, which does not allow iNaT.
dtype = upcast_classes['datetimetz']
return dtype[0], tslibs.NaT
elif 'datetime' in upcast_classes:
return np.dtype('M8[ns]'), tslibs.iNaT
elif 'timedelta' in upcast_classes:
return np.dtype('m8[ns]'), tslibs.iNaT
else: # pragma
try:
g = np.find_common_type(upcast_classes, [])
except TypeError:
# At least one is an ExtensionArray
return np.dtype(np.object_), np.nan
else:
if is_float_dtype(g):
return g, g.type(np.nan)
elif is_numeric_dtype(g):
if has_none_blocks:
return np.float64, np.nan
else:
return g, None
msg = "invalid dtype determination in get_concat_dtype"
raise AssertionError(msg) | [
"Return",
"dtype",
"and",
"N",
"/",
"A",
"values",
"to",
"use",
"when",
"concatenating",
"specified",
"units",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/internals/concat.py#L260-L363 | [
"def",
"get_empty_dtype_and_na",
"(",
"join_units",
")",
":",
"if",
"len",
"(",
"join_units",
")",
"==",
"1",
":",
"blk",
"=",
"join_units",
"[",
"0",
"]",
".",
"block",
"if",
"blk",
"is",
"None",
":",
"return",
"np",
".",
"float64",
",",
"np",
".",
"nan",
"if",
"is_uniform_reindex",
"(",
"join_units",
")",
":",
"# XXX: integrate property",
"empty_dtype",
"=",
"join_units",
"[",
"0",
"]",
".",
"block",
".",
"dtype",
"upcasted_na",
"=",
"join_units",
"[",
"0",
"]",
".",
"block",
".",
"fill_value",
"return",
"empty_dtype",
",",
"upcasted_na",
"has_none_blocks",
"=",
"False",
"dtypes",
"=",
"[",
"None",
"]",
"*",
"len",
"(",
"join_units",
")",
"for",
"i",
",",
"unit",
"in",
"enumerate",
"(",
"join_units",
")",
":",
"if",
"unit",
".",
"block",
"is",
"None",
":",
"has_none_blocks",
"=",
"True",
"else",
":",
"dtypes",
"[",
"i",
"]",
"=",
"unit",
".",
"dtype",
"upcast_classes",
"=",
"defaultdict",
"(",
"list",
")",
"null_upcast_classes",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"dtype",
",",
"unit",
"in",
"zip",
"(",
"dtypes",
",",
"join_units",
")",
":",
"if",
"dtype",
"is",
"None",
":",
"continue",
"if",
"is_categorical_dtype",
"(",
"dtype",
")",
":",
"upcast_cls",
"=",
"'category'",
"elif",
"is_datetime64tz_dtype",
"(",
"dtype",
")",
":",
"upcast_cls",
"=",
"'datetimetz'",
"elif",
"issubclass",
"(",
"dtype",
".",
"type",
",",
"np",
".",
"bool_",
")",
":",
"upcast_cls",
"=",
"'bool'",
"elif",
"issubclass",
"(",
"dtype",
".",
"type",
",",
"np",
".",
"object_",
")",
":",
"upcast_cls",
"=",
"'object'",
"elif",
"is_datetime64_dtype",
"(",
"dtype",
")",
":",
"upcast_cls",
"=",
"'datetime'",
"elif",
"is_timedelta64_dtype",
"(",
"dtype",
")",
":",
"upcast_cls",
"=",
"'timedelta'",
"elif",
"is_sparse",
"(",
"dtype",
")",
":",
"upcast_cls",
"=",
"dtype",
".",
"subtype",
".",
"name",
"elif",
"is_extension_array_dtype",
"(",
"dtype",
")",
":",
"upcast_cls",
"=",
"'object'",
"elif",
"is_float_dtype",
"(",
"dtype",
")",
"or",
"is_numeric_dtype",
"(",
"dtype",
")",
":",
"upcast_cls",
"=",
"dtype",
".",
"name",
"else",
":",
"upcast_cls",
"=",
"'float'",
"# Null blocks should not influence upcast class selection, unless there",
"# are only null blocks, when same upcasting rules must be applied to",
"# null upcast classes.",
"if",
"unit",
".",
"is_na",
":",
"null_upcast_classes",
"[",
"upcast_cls",
"]",
".",
"append",
"(",
"dtype",
")",
"else",
":",
"upcast_classes",
"[",
"upcast_cls",
"]",
".",
"append",
"(",
"dtype",
")",
"if",
"not",
"upcast_classes",
":",
"upcast_classes",
"=",
"null_upcast_classes",
"# create the result",
"if",
"'object'",
"in",
"upcast_classes",
":",
"return",
"np",
".",
"dtype",
"(",
"np",
".",
"object_",
")",
",",
"np",
".",
"nan",
"elif",
"'bool'",
"in",
"upcast_classes",
":",
"if",
"has_none_blocks",
":",
"return",
"np",
".",
"dtype",
"(",
"np",
".",
"object_",
")",
",",
"np",
".",
"nan",
"else",
":",
"return",
"np",
".",
"dtype",
"(",
"np",
".",
"bool_",
")",
",",
"None",
"elif",
"'category'",
"in",
"upcast_classes",
":",
"return",
"np",
".",
"dtype",
"(",
"np",
".",
"object_",
")",
",",
"np",
".",
"nan",
"elif",
"'datetimetz'",
"in",
"upcast_classes",
":",
"# GH-25014. We use NaT instead of iNaT, since this eventually",
"# ends up in DatetimeArray.take, which does not allow iNaT.",
"dtype",
"=",
"upcast_classes",
"[",
"'datetimetz'",
"]",
"return",
"dtype",
"[",
"0",
"]",
",",
"tslibs",
".",
"NaT",
"elif",
"'datetime'",
"in",
"upcast_classes",
":",
"return",
"np",
".",
"dtype",
"(",
"'M8[ns]'",
")",
",",
"tslibs",
".",
"iNaT",
"elif",
"'timedelta'",
"in",
"upcast_classes",
":",
"return",
"np",
".",
"dtype",
"(",
"'m8[ns]'",
")",
",",
"tslibs",
".",
"iNaT",
"else",
":",
"# pragma",
"try",
":",
"g",
"=",
"np",
".",
"find_common_type",
"(",
"upcast_classes",
",",
"[",
"]",
")",
"except",
"TypeError",
":",
"# At least one is an ExtensionArray",
"return",
"np",
".",
"dtype",
"(",
"np",
".",
"object_",
")",
",",
"np",
".",
"nan",
"else",
":",
"if",
"is_float_dtype",
"(",
"g",
")",
":",
"return",
"g",
",",
"g",
".",
"type",
"(",
"np",
".",
"nan",
")",
"elif",
"is_numeric_dtype",
"(",
"g",
")",
":",
"if",
"has_none_blocks",
":",
"return",
"np",
".",
"float64",
",",
"np",
".",
"nan",
"else",
":",
"return",
"g",
",",
"None",
"msg",
"=",
"\"invalid dtype determination in get_concat_dtype\"",
"raise",
"AssertionError",
"(",
"msg",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | is_uniform_join_units | Check if the join units consist of blocks of uniform type that can
be concatenated using Block.concat_same_type instead of the generic
concatenate_join_units (which uses `_concat._concat_compat`). | pandas/core/internals/concat.py | def is_uniform_join_units(join_units):
"""
Check if the join units consist of blocks of uniform type that can
be concatenated using Block.concat_same_type instead of the generic
concatenate_join_units (which uses `_concat._concat_compat`).
"""
return (
# all blocks need to have the same type
all(type(ju.block) is type(join_units[0].block) for ju in join_units) and # noqa
# no blocks that would get missing values (can lead to type upcasts)
# unless we're an extension dtype.
all(not ju.is_na or ju.block.is_extension for ju in join_units) and
# no blocks with indexers (as then the dimensions do not fit)
all(not ju.indexers for ju in join_units) and
# disregard Panels
all(ju.block.ndim <= 2 for ju in join_units) and
# only use this path when there is something to concatenate
len(join_units) > 1) | def is_uniform_join_units(join_units):
"""
Check if the join units consist of blocks of uniform type that can
be concatenated using Block.concat_same_type instead of the generic
concatenate_join_units (which uses `_concat._concat_compat`).
"""
return (
# all blocks need to have the same type
all(type(ju.block) is type(join_units[0].block) for ju in join_units) and # noqa
# no blocks that would get missing values (can lead to type upcasts)
# unless we're an extension dtype.
all(not ju.is_na or ju.block.is_extension for ju in join_units) and
# no blocks with indexers (as then the dimensions do not fit)
all(not ju.indexers for ju in join_units) and
# disregard Panels
all(ju.block.ndim <= 2 for ju in join_units) and
# only use this path when there is something to concatenate
len(join_units) > 1) | [
"Check",
"if",
"the",
"join",
"units",
"consist",
"of",
"blocks",
"of",
"uniform",
"type",
"that",
"can",
"be",
"concatenated",
"using",
"Block",
".",
"concat_same_type",
"instead",
"of",
"the",
"generic",
"concatenate_join_units",
"(",
"which",
"uses",
"_concat",
".",
"_concat_compat",
")",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/internals/concat.py#L366-L384 | [
"def",
"is_uniform_join_units",
"(",
"join_units",
")",
":",
"return",
"(",
"# all blocks need to have the same type",
"all",
"(",
"type",
"(",
"ju",
".",
"block",
")",
"is",
"type",
"(",
"join_units",
"[",
"0",
"]",
".",
"block",
")",
"for",
"ju",
"in",
"join_units",
")",
"and",
"# noqa",
"# no blocks that would get missing values (can lead to type upcasts)",
"# unless we're an extension dtype.",
"all",
"(",
"not",
"ju",
".",
"is_na",
"or",
"ju",
".",
"block",
".",
"is_extension",
"for",
"ju",
"in",
"join_units",
")",
"and",
"# no blocks with indexers (as then the dimensions do not fit)",
"all",
"(",
"not",
"ju",
".",
"indexers",
"for",
"ju",
"in",
"join_units",
")",
"and",
"# disregard Panels",
"all",
"(",
"ju",
".",
"block",
".",
"ndim",
"<=",
"2",
"for",
"ju",
"in",
"join_units",
")",
"and",
"# only use this path when there is something to concatenate",
"len",
"(",
"join_units",
")",
">",
"1",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | trim_join_unit | Reduce join_unit's shape along item axis to length.
Extra items that didn't fit are returned as a separate block. | pandas/core/internals/concat.py | def trim_join_unit(join_unit, length):
"""
Reduce join_unit's shape along item axis to length.
Extra items that didn't fit are returned as a separate block.
"""
if 0 not in join_unit.indexers:
extra_indexers = join_unit.indexers
if join_unit.block is None:
extra_block = None
else:
extra_block = join_unit.block.getitem_block(slice(length, None))
join_unit.block = join_unit.block.getitem_block(slice(length))
else:
extra_block = join_unit.block
extra_indexers = copy.copy(join_unit.indexers)
extra_indexers[0] = extra_indexers[0][length:]
join_unit.indexers[0] = join_unit.indexers[0][:length]
extra_shape = (join_unit.shape[0] - length,) + join_unit.shape[1:]
join_unit.shape = (length,) + join_unit.shape[1:]
return JoinUnit(block=extra_block, indexers=extra_indexers,
shape=extra_shape) | def trim_join_unit(join_unit, length):
"""
Reduce join_unit's shape along item axis to length.
Extra items that didn't fit are returned as a separate block.
"""
if 0 not in join_unit.indexers:
extra_indexers = join_unit.indexers
if join_unit.block is None:
extra_block = None
else:
extra_block = join_unit.block.getitem_block(slice(length, None))
join_unit.block = join_unit.block.getitem_block(slice(length))
else:
extra_block = join_unit.block
extra_indexers = copy.copy(join_unit.indexers)
extra_indexers[0] = extra_indexers[0][length:]
join_unit.indexers[0] = join_unit.indexers[0][:length]
extra_shape = (join_unit.shape[0] - length,) + join_unit.shape[1:]
join_unit.shape = (length,) + join_unit.shape[1:]
return JoinUnit(block=extra_block, indexers=extra_indexers,
shape=extra_shape) | [
"Reduce",
"join_unit",
"s",
"shape",
"along",
"item",
"axis",
"to",
"length",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/internals/concat.py#L395-L421 | [
"def",
"trim_join_unit",
"(",
"join_unit",
",",
"length",
")",
":",
"if",
"0",
"not",
"in",
"join_unit",
".",
"indexers",
":",
"extra_indexers",
"=",
"join_unit",
".",
"indexers",
"if",
"join_unit",
".",
"block",
"is",
"None",
":",
"extra_block",
"=",
"None",
"else",
":",
"extra_block",
"=",
"join_unit",
".",
"block",
".",
"getitem_block",
"(",
"slice",
"(",
"length",
",",
"None",
")",
")",
"join_unit",
".",
"block",
"=",
"join_unit",
".",
"block",
".",
"getitem_block",
"(",
"slice",
"(",
"length",
")",
")",
"else",
":",
"extra_block",
"=",
"join_unit",
".",
"block",
"extra_indexers",
"=",
"copy",
".",
"copy",
"(",
"join_unit",
".",
"indexers",
")",
"extra_indexers",
"[",
"0",
"]",
"=",
"extra_indexers",
"[",
"0",
"]",
"[",
"length",
":",
"]",
"join_unit",
".",
"indexers",
"[",
"0",
"]",
"=",
"join_unit",
".",
"indexers",
"[",
"0",
"]",
"[",
":",
"length",
"]",
"extra_shape",
"=",
"(",
"join_unit",
".",
"shape",
"[",
"0",
"]",
"-",
"length",
",",
")",
"+",
"join_unit",
".",
"shape",
"[",
"1",
":",
"]",
"join_unit",
".",
"shape",
"=",
"(",
"length",
",",
")",
"+",
"join_unit",
".",
"shape",
"[",
"1",
":",
"]",
"return",
"JoinUnit",
"(",
"block",
"=",
"extra_block",
",",
"indexers",
"=",
"extra_indexers",
",",
"shape",
"=",
"extra_shape",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | combine_concat_plans | Combine multiple concatenation plans into one.
existing_plan is updated in-place. | pandas/core/internals/concat.py | def combine_concat_plans(plans, concat_axis):
"""
Combine multiple concatenation plans into one.
existing_plan is updated in-place.
"""
if len(plans) == 1:
for p in plans[0]:
yield p[0], [p[1]]
elif concat_axis == 0:
offset = 0
for plan in plans:
last_plc = None
for plc, unit in plan:
yield plc.add(offset), [unit]
last_plc = plc
if last_plc is not None:
offset += last_plc.as_slice.stop
else:
num_ended = [0]
def _next_or_none(seq):
retval = next(seq, None)
if retval is None:
num_ended[0] += 1
return retval
plans = list(map(iter, plans))
next_items = list(map(_next_or_none, plans))
while num_ended[0] != len(next_items):
if num_ended[0] > 0:
raise ValueError("Plan shapes are not aligned")
placements, units = zip(*next_items)
lengths = list(map(len, placements))
min_len, max_len = min(lengths), max(lengths)
if min_len == max_len:
yield placements[0], units
next_items[:] = map(_next_or_none, plans)
else:
yielded_placement = None
yielded_units = [None] * len(next_items)
for i, (plc, unit) in enumerate(next_items):
yielded_units[i] = unit
if len(plc) > min_len:
# trim_join_unit updates unit in place, so only
# placement needs to be sliced to skip min_len.
next_items[i] = (plc[min_len:],
trim_join_unit(unit, min_len))
else:
yielded_placement = plc
next_items[i] = _next_or_none(plans[i])
yield yielded_placement, yielded_units | def combine_concat_plans(plans, concat_axis):
"""
Combine multiple concatenation plans into one.
existing_plan is updated in-place.
"""
if len(plans) == 1:
for p in plans[0]:
yield p[0], [p[1]]
elif concat_axis == 0:
offset = 0
for plan in plans:
last_plc = None
for plc, unit in plan:
yield plc.add(offset), [unit]
last_plc = plc
if last_plc is not None:
offset += last_plc.as_slice.stop
else:
num_ended = [0]
def _next_or_none(seq):
retval = next(seq, None)
if retval is None:
num_ended[0] += 1
return retval
plans = list(map(iter, plans))
next_items = list(map(_next_or_none, plans))
while num_ended[0] != len(next_items):
if num_ended[0] > 0:
raise ValueError("Plan shapes are not aligned")
placements, units = zip(*next_items)
lengths = list(map(len, placements))
min_len, max_len = min(lengths), max(lengths)
if min_len == max_len:
yield placements[0], units
next_items[:] = map(_next_or_none, plans)
else:
yielded_placement = None
yielded_units = [None] * len(next_items)
for i, (plc, unit) in enumerate(next_items):
yielded_units[i] = unit
if len(plc) > min_len:
# trim_join_unit updates unit in place, so only
# placement needs to be sliced to skip min_len.
next_items[i] = (plc[min_len:],
trim_join_unit(unit, min_len))
else:
yielded_placement = plc
next_items[i] = _next_or_none(plans[i])
yield yielded_placement, yielded_units | [
"Combine",
"multiple",
"concatenation",
"plans",
"into",
"one",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/internals/concat.py#L424-L484 | [
"def",
"combine_concat_plans",
"(",
"plans",
",",
"concat_axis",
")",
":",
"if",
"len",
"(",
"plans",
")",
"==",
"1",
":",
"for",
"p",
"in",
"plans",
"[",
"0",
"]",
":",
"yield",
"p",
"[",
"0",
"]",
",",
"[",
"p",
"[",
"1",
"]",
"]",
"elif",
"concat_axis",
"==",
"0",
":",
"offset",
"=",
"0",
"for",
"plan",
"in",
"plans",
":",
"last_plc",
"=",
"None",
"for",
"plc",
",",
"unit",
"in",
"plan",
":",
"yield",
"plc",
".",
"add",
"(",
"offset",
")",
",",
"[",
"unit",
"]",
"last_plc",
"=",
"plc",
"if",
"last_plc",
"is",
"not",
"None",
":",
"offset",
"+=",
"last_plc",
".",
"as_slice",
".",
"stop",
"else",
":",
"num_ended",
"=",
"[",
"0",
"]",
"def",
"_next_or_none",
"(",
"seq",
")",
":",
"retval",
"=",
"next",
"(",
"seq",
",",
"None",
")",
"if",
"retval",
"is",
"None",
":",
"num_ended",
"[",
"0",
"]",
"+=",
"1",
"return",
"retval",
"plans",
"=",
"list",
"(",
"map",
"(",
"iter",
",",
"plans",
")",
")",
"next_items",
"=",
"list",
"(",
"map",
"(",
"_next_or_none",
",",
"plans",
")",
")",
"while",
"num_ended",
"[",
"0",
"]",
"!=",
"len",
"(",
"next_items",
")",
":",
"if",
"num_ended",
"[",
"0",
"]",
">",
"0",
":",
"raise",
"ValueError",
"(",
"\"Plan shapes are not aligned\"",
")",
"placements",
",",
"units",
"=",
"zip",
"(",
"*",
"next_items",
")",
"lengths",
"=",
"list",
"(",
"map",
"(",
"len",
",",
"placements",
")",
")",
"min_len",
",",
"max_len",
"=",
"min",
"(",
"lengths",
")",
",",
"max",
"(",
"lengths",
")",
"if",
"min_len",
"==",
"max_len",
":",
"yield",
"placements",
"[",
"0",
"]",
",",
"units",
"next_items",
"[",
":",
"]",
"=",
"map",
"(",
"_next_or_none",
",",
"plans",
")",
"else",
":",
"yielded_placement",
"=",
"None",
"yielded_units",
"=",
"[",
"None",
"]",
"*",
"len",
"(",
"next_items",
")",
"for",
"i",
",",
"(",
"plc",
",",
"unit",
")",
"in",
"enumerate",
"(",
"next_items",
")",
":",
"yielded_units",
"[",
"i",
"]",
"=",
"unit",
"if",
"len",
"(",
"plc",
")",
">",
"min_len",
":",
"# trim_join_unit updates unit in place, so only",
"# placement needs to be sliced to skip min_len.",
"next_items",
"[",
"i",
"]",
"=",
"(",
"plc",
"[",
"min_len",
":",
"]",
",",
"trim_join_unit",
"(",
"unit",
",",
"min_len",
")",
")",
"else",
":",
"yielded_placement",
"=",
"plc",
"next_items",
"[",
"i",
"]",
"=",
"_next_or_none",
"(",
"plans",
"[",
"i",
"]",
")",
"yield",
"yielded_placement",
",",
"yielded_units"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _Options.use | Temporarily set a parameter value using the with statement.
Aliasing allowed. | pandas/plotting/_style.py | def use(self, key, value):
"""
Temporarily set a parameter value using the with statement.
Aliasing allowed.
"""
old_value = self[key]
try:
self[key] = value
yield self
finally:
self[key] = old_value | def use(self, key, value):
"""
Temporarily set a parameter value using the with statement.
Aliasing allowed.
"""
old_value = self[key]
try:
self[key] = value
yield self
finally:
self[key] = old_value | [
"Temporarily",
"set",
"a",
"parameter",
"value",
"using",
"the",
"with",
"statement",
".",
"Aliasing",
"allowed",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_style.py#L151-L161 | [
"def",
"use",
"(",
"self",
",",
"key",
",",
"value",
")",
":",
"old_value",
"=",
"self",
"[",
"key",
"]",
"try",
":",
"self",
"[",
"key",
"]",
"=",
"value",
"yield",
"self",
"finally",
":",
"self",
"[",
"key",
"]",
"=",
"old_value"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _stata_elapsed_date_to_datetime_vec | Convert from SIF to datetime. http://www.stata.com/help.cgi?datetime
Parameters
----------
dates : Series
The Stata Internal Format date to convert to datetime according to fmt
fmt : str
The format to convert to. Can be, tc, td, tw, tm, tq, th, ty
Returns
Returns
-------
converted : Series
The converted dates
Examples
--------
>>> dates = pd.Series([52])
>>> _stata_elapsed_date_to_datetime_vec(dates , "%tw")
0 1961-01-01
dtype: datetime64[ns]
Notes
-----
datetime/c - tc
milliseconds since 01jan1960 00:00:00.000, assuming 86,400 s/day
datetime/C - tC - NOT IMPLEMENTED
milliseconds since 01jan1960 00:00:00.000, adjusted for leap seconds
date - td
days since 01jan1960 (01jan1960 = 0)
weekly date - tw
weeks since 1960w1
This assumes 52 weeks in a year, then adds 7 * remainder of the weeks.
The datetime value is the start of the week in terms of days in the
year, not ISO calendar weeks.
monthly date - tm
months since 1960m1
quarterly date - tq
quarters since 1960q1
half-yearly date - th
half-years since 1960h1 yearly
date - ty
years since 0000
If you don't have pandas with datetime support, then you can't do
milliseconds accurately. | pandas/io/stata.py | def _stata_elapsed_date_to_datetime_vec(dates, fmt):
"""
Convert from SIF to datetime. http://www.stata.com/help.cgi?datetime
Parameters
----------
dates : Series
The Stata Internal Format date to convert to datetime according to fmt
fmt : str
The format to convert to. Can be, tc, td, tw, tm, tq, th, ty
Returns
Returns
-------
converted : Series
The converted dates
Examples
--------
>>> dates = pd.Series([52])
>>> _stata_elapsed_date_to_datetime_vec(dates , "%tw")
0 1961-01-01
dtype: datetime64[ns]
Notes
-----
datetime/c - tc
milliseconds since 01jan1960 00:00:00.000, assuming 86,400 s/day
datetime/C - tC - NOT IMPLEMENTED
milliseconds since 01jan1960 00:00:00.000, adjusted for leap seconds
date - td
days since 01jan1960 (01jan1960 = 0)
weekly date - tw
weeks since 1960w1
This assumes 52 weeks in a year, then adds 7 * remainder of the weeks.
The datetime value is the start of the week in terms of days in the
year, not ISO calendar weeks.
monthly date - tm
months since 1960m1
quarterly date - tq
quarters since 1960q1
half-yearly date - th
half-years since 1960h1 yearly
date - ty
years since 0000
If you don't have pandas with datetime support, then you can't do
milliseconds accurately.
"""
MIN_YEAR, MAX_YEAR = Timestamp.min.year, Timestamp.max.year
MAX_DAY_DELTA = (Timestamp.max - datetime.datetime(1960, 1, 1)).days
MIN_DAY_DELTA = (Timestamp.min - datetime.datetime(1960, 1, 1)).days
MIN_MS_DELTA = MIN_DAY_DELTA * 24 * 3600 * 1000
MAX_MS_DELTA = MAX_DAY_DELTA * 24 * 3600 * 1000
def convert_year_month_safe(year, month):
"""
Convert year and month to datetimes, using pandas vectorized versions
when the date range falls within the range supported by pandas.
Otherwise it falls back to a slower but more robust method
using datetime.
"""
if year.max() < MAX_YEAR and year.min() > MIN_YEAR:
return to_datetime(100 * year + month, format='%Y%m')
else:
index = getattr(year, 'index', None)
return Series(
[datetime.datetime(y, m, 1) for y, m in zip(year, month)],
index=index)
def convert_year_days_safe(year, days):
"""
Converts year (e.g. 1999) and days since the start of the year to a
datetime or datetime64 Series
"""
if year.max() < (MAX_YEAR - 1) and year.min() > MIN_YEAR:
return (to_datetime(year, format='%Y') +
to_timedelta(days, unit='d'))
else:
index = getattr(year, 'index', None)
value = [datetime.datetime(y, 1, 1) + relativedelta(days=int(d))
for y, d in zip(year, days)]
return Series(value, index=index)
def convert_delta_safe(base, deltas, unit):
"""
Convert base dates and deltas to datetimes, using pandas vectorized
versions if the deltas satisfy restrictions required to be expressed
as dates in pandas.
"""
index = getattr(deltas, 'index', None)
if unit == 'd':
if deltas.max() > MAX_DAY_DELTA or deltas.min() < MIN_DAY_DELTA:
values = [base + relativedelta(days=int(d)) for d in deltas]
return Series(values, index=index)
elif unit == 'ms':
if deltas.max() > MAX_MS_DELTA or deltas.min() < MIN_MS_DELTA:
values = [base + relativedelta(microseconds=(int(d) * 1000))
for d in deltas]
return Series(values, index=index)
else:
raise ValueError('format not understood')
base = to_datetime(base)
deltas = to_timedelta(deltas, unit=unit)
return base + deltas
# TODO: If/when pandas supports more than datetime64[ns], this should be
# improved to use correct range, e.g. datetime[Y] for yearly
bad_locs = np.isnan(dates)
has_bad_values = False
if bad_locs.any():
has_bad_values = True
data_col = Series(dates)
data_col[bad_locs] = 1.0 # Replace with NaT
dates = dates.astype(np.int64)
if fmt.startswith(("%tc", "tc")): # Delta ms relative to base
base = stata_epoch
ms = dates
conv_dates = convert_delta_safe(base, ms, 'ms')
elif fmt.startswith(("%tC", "tC")):
warnings.warn("Encountered %tC format. Leaving in Stata "
"Internal Format.")
conv_dates = Series(dates, dtype=np.object)
if has_bad_values:
conv_dates[bad_locs] = NaT
return conv_dates
# Delta days relative to base
elif fmt.startswith(("%td", "td", "%d", "d")):
base = stata_epoch
days = dates
conv_dates = convert_delta_safe(base, days, 'd')
# does not count leap days - 7 days is a week.
# 52nd week may have more than 7 days
elif fmt.startswith(("%tw", "tw")):
year = stata_epoch.year + dates // 52
days = (dates % 52) * 7
conv_dates = convert_year_days_safe(year, days)
elif fmt.startswith(("%tm", "tm")): # Delta months relative to base
year = stata_epoch.year + dates // 12
month = (dates % 12) + 1
conv_dates = convert_year_month_safe(year, month)
elif fmt.startswith(("%tq", "tq")): # Delta quarters relative to base
year = stata_epoch.year + dates // 4
month = (dates % 4) * 3 + 1
conv_dates = convert_year_month_safe(year, month)
elif fmt.startswith(("%th", "th")): # Delta half-years relative to base
year = stata_epoch.year + dates // 2
month = (dates % 2) * 6 + 1
conv_dates = convert_year_month_safe(year, month)
elif fmt.startswith(("%ty", "ty")): # Years -- not delta
year = dates
month = np.ones_like(dates)
conv_dates = convert_year_month_safe(year, month)
else:
raise ValueError("Date fmt {fmt} not understood".format(fmt=fmt))
if has_bad_values: # Restore NaT for bad values
conv_dates[bad_locs] = NaT
return conv_dates | def _stata_elapsed_date_to_datetime_vec(dates, fmt):
"""
Convert from SIF to datetime. http://www.stata.com/help.cgi?datetime
Parameters
----------
dates : Series
The Stata Internal Format date to convert to datetime according to fmt
fmt : str
The format to convert to. Can be, tc, td, tw, tm, tq, th, ty
Returns
Returns
-------
converted : Series
The converted dates
Examples
--------
>>> dates = pd.Series([52])
>>> _stata_elapsed_date_to_datetime_vec(dates , "%tw")
0 1961-01-01
dtype: datetime64[ns]
Notes
-----
datetime/c - tc
milliseconds since 01jan1960 00:00:00.000, assuming 86,400 s/day
datetime/C - tC - NOT IMPLEMENTED
milliseconds since 01jan1960 00:00:00.000, adjusted for leap seconds
date - td
days since 01jan1960 (01jan1960 = 0)
weekly date - tw
weeks since 1960w1
This assumes 52 weeks in a year, then adds 7 * remainder of the weeks.
The datetime value is the start of the week in terms of days in the
year, not ISO calendar weeks.
monthly date - tm
months since 1960m1
quarterly date - tq
quarters since 1960q1
half-yearly date - th
half-years since 1960h1 yearly
date - ty
years since 0000
If you don't have pandas with datetime support, then you can't do
milliseconds accurately.
"""
MIN_YEAR, MAX_YEAR = Timestamp.min.year, Timestamp.max.year
MAX_DAY_DELTA = (Timestamp.max - datetime.datetime(1960, 1, 1)).days
MIN_DAY_DELTA = (Timestamp.min - datetime.datetime(1960, 1, 1)).days
MIN_MS_DELTA = MIN_DAY_DELTA * 24 * 3600 * 1000
MAX_MS_DELTA = MAX_DAY_DELTA * 24 * 3600 * 1000
def convert_year_month_safe(year, month):
"""
Convert year and month to datetimes, using pandas vectorized versions
when the date range falls within the range supported by pandas.
Otherwise it falls back to a slower but more robust method
using datetime.
"""
if year.max() < MAX_YEAR and year.min() > MIN_YEAR:
return to_datetime(100 * year + month, format='%Y%m')
else:
index = getattr(year, 'index', None)
return Series(
[datetime.datetime(y, m, 1) for y, m in zip(year, month)],
index=index)
def convert_year_days_safe(year, days):
"""
Converts year (e.g. 1999) and days since the start of the year to a
datetime or datetime64 Series
"""
if year.max() < (MAX_YEAR - 1) and year.min() > MIN_YEAR:
return (to_datetime(year, format='%Y') +
to_timedelta(days, unit='d'))
else:
index = getattr(year, 'index', None)
value = [datetime.datetime(y, 1, 1) + relativedelta(days=int(d))
for y, d in zip(year, days)]
return Series(value, index=index)
def convert_delta_safe(base, deltas, unit):
"""
Convert base dates and deltas to datetimes, using pandas vectorized
versions if the deltas satisfy restrictions required to be expressed
as dates in pandas.
"""
index = getattr(deltas, 'index', None)
if unit == 'd':
if deltas.max() > MAX_DAY_DELTA or deltas.min() < MIN_DAY_DELTA:
values = [base + relativedelta(days=int(d)) for d in deltas]
return Series(values, index=index)
elif unit == 'ms':
if deltas.max() > MAX_MS_DELTA or deltas.min() < MIN_MS_DELTA:
values = [base + relativedelta(microseconds=(int(d) * 1000))
for d in deltas]
return Series(values, index=index)
else:
raise ValueError('format not understood')
base = to_datetime(base)
deltas = to_timedelta(deltas, unit=unit)
return base + deltas
# TODO: If/when pandas supports more than datetime64[ns], this should be
# improved to use correct range, e.g. datetime[Y] for yearly
bad_locs = np.isnan(dates)
has_bad_values = False
if bad_locs.any():
has_bad_values = True
data_col = Series(dates)
data_col[bad_locs] = 1.0 # Replace with NaT
dates = dates.astype(np.int64)
if fmt.startswith(("%tc", "tc")): # Delta ms relative to base
base = stata_epoch
ms = dates
conv_dates = convert_delta_safe(base, ms, 'ms')
elif fmt.startswith(("%tC", "tC")):
warnings.warn("Encountered %tC format. Leaving in Stata "
"Internal Format.")
conv_dates = Series(dates, dtype=np.object)
if has_bad_values:
conv_dates[bad_locs] = NaT
return conv_dates
# Delta days relative to base
elif fmt.startswith(("%td", "td", "%d", "d")):
base = stata_epoch
days = dates
conv_dates = convert_delta_safe(base, days, 'd')
# does not count leap days - 7 days is a week.
# 52nd week may have more than 7 days
elif fmt.startswith(("%tw", "tw")):
year = stata_epoch.year + dates // 52
days = (dates % 52) * 7
conv_dates = convert_year_days_safe(year, days)
elif fmt.startswith(("%tm", "tm")): # Delta months relative to base
year = stata_epoch.year + dates // 12
month = (dates % 12) + 1
conv_dates = convert_year_month_safe(year, month)
elif fmt.startswith(("%tq", "tq")): # Delta quarters relative to base
year = stata_epoch.year + dates // 4
month = (dates % 4) * 3 + 1
conv_dates = convert_year_month_safe(year, month)
elif fmt.startswith(("%th", "th")): # Delta half-years relative to base
year = stata_epoch.year + dates // 2
month = (dates % 2) * 6 + 1
conv_dates = convert_year_month_safe(year, month)
elif fmt.startswith(("%ty", "ty")): # Years -- not delta
year = dates
month = np.ones_like(dates)
conv_dates = convert_year_month_safe(year, month)
else:
raise ValueError("Date fmt {fmt} not understood".format(fmt=fmt))
if has_bad_values: # Restore NaT for bad values
conv_dates[bad_locs] = NaT
return conv_dates | [
"Convert",
"from",
"SIF",
"to",
"datetime",
".",
"http",
":",
"//",
"www",
".",
"stata",
".",
"com",
"/",
"help",
".",
"cgi?datetime"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L203-L364 | [
"def",
"_stata_elapsed_date_to_datetime_vec",
"(",
"dates",
",",
"fmt",
")",
":",
"MIN_YEAR",
",",
"MAX_YEAR",
"=",
"Timestamp",
".",
"min",
".",
"year",
",",
"Timestamp",
".",
"max",
".",
"year",
"MAX_DAY_DELTA",
"=",
"(",
"Timestamp",
".",
"max",
"-",
"datetime",
".",
"datetime",
"(",
"1960",
",",
"1",
",",
"1",
")",
")",
".",
"days",
"MIN_DAY_DELTA",
"=",
"(",
"Timestamp",
".",
"min",
"-",
"datetime",
".",
"datetime",
"(",
"1960",
",",
"1",
",",
"1",
")",
")",
".",
"days",
"MIN_MS_DELTA",
"=",
"MIN_DAY_DELTA",
"*",
"24",
"*",
"3600",
"*",
"1000",
"MAX_MS_DELTA",
"=",
"MAX_DAY_DELTA",
"*",
"24",
"*",
"3600",
"*",
"1000",
"def",
"convert_year_month_safe",
"(",
"year",
",",
"month",
")",
":",
"\"\"\"\n Convert year and month to datetimes, using pandas vectorized versions\n when the date range falls within the range supported by pandas.\n Otherwise it falls back to a slower but more robust method\n using datetime.\n \"\"\"",
"if",
"year",
".",
"max",
"(",
")",
"<",
"MAX_YEAR",
"and",
"year",
".",
"min",
"(",
")",
">",
"MIN_YEAR",
":",
"return",
"to_datetime",
"(",
"100",
"*",
"year",
"+",
"month",
",",
"format",
"=",
"'%Y%m'",
")",
"else",
":",
"index",
"=",
"getattr",
"(",
"year",
",",
"'index'",
",",
"None",
")",
"return",
"Series",
"(",
"[",
"datetime",
".",
"datetime",
"(",
"y",
",",
"m",
",",
"1",
")",
"for",
"y",
",",
"m",
"in",
"zip",
"(",
"year",
",",
"month",
")",
"]",
",",
"index",
"=",
"index",
")",
"def",
"convert_year_days_safe",
"(",
"year",
",",
"days",
")",
":",
"\"\"\"\n Converts year (e.g. 1999) and days since the start of the year to a\n datetime or datetime64 Series\n \"\"\"",
"if",
"year",
".",
"max",
"(",
")",
"<",
"(",
"MAX_YEAR",
"-",
"1",
")",
"and",
"year",
".",
"min",
"(",
")",
">",
"MIN_YEAR",
":",
"return",
"(",
"to_datetime",
"(",
"year",
",",
"format",
"=",
"'%Y'",
")",
"+",
"to_timedelta",
"(",
"days",
",",
"unit",
"=",
"'d'",
")",
")",
"else",
":",
"index",
"=",
"getattr",
"(",
"year",
",",
"'index'",
",",
"None",
")",
"value",
"=",
"[",
"datetime",
".",
"datetime",
"(",
"y",
",",
"1",
",",
"1",
")",
"+",
"relativedelta",
"(",
"days",
"=",
"int",
"(",
"d",
")",
")",
"for",
"y",
",",
"d",
"in",
"zip",
"(",
"year",
",",
"days",
")",
"]",
"return",
"Series",
"(",
"value",
",",
"index",
"=",
"index",
")",
"def",
"convert_delta_safe",
"(",
"base",
",",
"deltas",
",",
"unit",
")",
":",
"\"\"\"\n Convert base dates and deltas to datetimes, using pandas vectorized\n versions if the deltas satisfy restrictions required to be expressed\n as dates in pandas.\n \"\"\"",
"index",
"=",
"getattr",
"(",
"deltas",
",",
"'index'",
",",
"None",
")",
"if",
"unit",
"==",
"'d'",
":",
"if",
"deltas",
".",
"max",
"(",
")",
">",
"MAX_DAY_DELTA",
"or",
"deltas",
".",
"min",
"(",
")",
"<",
"MIN_DAY_DELTA",
":",
"values",
"=",
"[",
"base",
"+",
"relativedelta",
"(",
"days",
"=",
"int",
"(",
"d",
")",
")",
"for",
"d",
"in",
"deltas",
"]",
"return",
"Series",
"(",
"values",
",",
"index",
"=",
"index",
")",
"elif",
"unit",
"==",
"'ms'",
":",
"if",
"deltas",
".",
"max",
"(",
")",
">",
"MAX_MS_DELTA",
"or",
"deltas",
".",
"min",
"(",
")",
"<",
"MIN_MS_DELTA",
":",
"values",
"=",
"[",
"base",
"+",
"relativedelta",
"(",
"microseconds",
"=",
"(",
"int",
"(",
"d",
")",
"*",
"1000",
")",
")",
"for",
"d",
"in",
"deltas",
"]",
"return",
"Series",
"(",
"values",
",",
"index",
"=",
"index",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'format not understood'",
")",
"base",
"=",
"to_datetime",
"(",
"base",
")",
"deltas",
"=",
"to_timedelta",
"(",
"deltas",
",",
"unit",
"=",
"unit",
")",
"return",
"base",
"+",
"deltas",
"# TODO: If/when pandas supports more than datetime64[ns], this should be",
"# improved to use correct range, e.g. datetime[Y] for yearly",
"bad_locs",
"=",
"np",
".",
"isnan",
"(",
"dates",
")",
"has_bad_values",
"=",
"False",
"if",
"bad_locs",
".",
"any",
"(",
")",
":",
"has_bad_values",
"=",
"True",
"data_col",
"=",
"Series",
"(",
"dates",
")",
"data_col",
"[",
"bad_locs",
"]",
"=",
"1.0",
"# Replace with NaT",
"dates",
"=",
"dates",
".",
"astype",
"(",
"np",
".",
"int64",
")",
"if",
"fmt",
".",
"startswith",
"(",
"(",
"\"%tc\"",
",",
"\"tc\"",
")",
")",
":",
"# Delta ms relative to base",
"base",
"=",
"stata_epoch",
"ms",
"=",
"dates",
"conv_dates",
"=",
"convert_delta_safe",
"(",
"base",
",",
"ms",
",",
"'ms'",
")",
"elif",
"fmt",
".",
"startswith",
"(",
"(",
"\"%tC\"",
",",
"\"tC\"",
")",
")",
":",
"warnings",
".",
"warn",
"(",
"\"Encountered %tC format. Leaving in Stata \"",
"\"Internal Format.\"",
")",
"conv_dates",
"=",
"Series",
"(",
"dates",
",",
"dtype",
"=",
"np",
".",
"object",
")",
"if",
"has_bad_values",
":",
"conv_dates",
"[",
"bad_locs",
"]",
"=",
"NaT",
"return",
"conv_dates",
"# Delta days relative to base",
"elif",
"fmt",
".",
"startswith",
"(",
"(",
"\"%td\"",
",",
"\"td\"",
",",
"\"%d\"",
",",
"\"d\"",
")",
")",
":",
"base",
"=",
"stata_epoch",
"days",
"=",
"dates",
"conv_dates",
"=",
"convert_delta_safe",
"(",
"base",
",",
"days",
",",
"'d'",
")",
"# does not count leap days - 7 days is a week.",
"# 52nd week may have more than 7 days",
"elif",
"fmt",
".",
"startswith",
"(",
"(",
"\"%tw\"",
",",
"\"tw\"",
")",
")",
":",
"year",
"=",
"stata_epoch",
".",
"year",
"+",
"dates",
"//",
"52",
"days",
"=",
"(",
"dates",
"%",
"52",
")",
"*",
"7",
"conv_dates",
"=",
"convert_year_days_safe",
"(",
"year",
",",
"days",
")",
"elif",
"fmt",
".",
"startswith",
"(",
"(",
"\"%tm\"",
",",
"\"tm\"",
")",
")",
":",
"# Delta months relative to base",
"year",
"=",
"stata_epoch",
".",
"year",
"+",
"dates",
"//",
"12",
"month",
"=",
"(",
"dates",
"%",
"12",
")",
"+",
"1",
"conv_dates",
"=",
"convert_year_month_safe",
"(",
"year",
",",
"month",
")",
"elif",
"fmt",
".",
"startswith",
"(",
"(",
"\"%tq\"",
",",
"\"tq\"",
")",
")",
":",
"# Delta quarters relative to base",
"year",
"=",
"stata_epoch",
".",
"year",
"+",
"dates",
"//",
"4",
"month",
"=",
"(",
"dates",
"%",
"4",
")",
"*",
"3",
"+",
"1",
"conv_dates",
"=",
"convert_year_month_safe",
"(",
"year",
",",
"month",
")",
"elif",
"fmt",
".",
"startswith",
"(",
"(",
"\"%th\"",
",",
"\"th\"",
")",
")",
":",
"# Delta half-years relative to base",
"year",
"=",
"stata_epoch",
".",
"year",
"+",
"dates",
"//",
"2",
"month",
"=",
"(",
"dates",
"%",
"2",
")",
"*",
"6",
"+",
"1",
"conv_dates",
"=",
"convert_year_month_safe",
"(",
"year",
",",
"month",
")",
"elif",
"fmt",
".",
"startswith",
"(",
"(",
"\"%ty\"",
",",
"\"ty\"",
")",
")",
":",
"# Years -- not delta",
"year",
"=",
"dates",
"month",
"=",
"np",
".",
"ones_like",
"(",
"dates",
")",
"conv_dates",
"=",
"convert_year_month_safe",
"(",
"year",
",",
"month",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Date fmt {fmt} not understood\"",
".",
"format",
"(",
"fmt",
"=",
"fmt",
")",
")",
"if",
"has_bad_values",
":",
"# Restore NaT for bad values",
"conv_dates",
"[",
"bad_locs",
"]",
"=",
"NaT",
"return",
"conv_dates"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _datetime_to_stata_elapsed_vec | Convert from datetime to SIF. http://www.stata.com/help.cgi?datetime
Parameters
----------
dates : Series
Series or array containing datetime.datetime or datetime64[ns] to
convert to the Stata Internal Format given by fmt
fmt : str
The format to convert to. Can be, tc, td, tw, tm, tq, th, ty | pandas/io/stata.py | def _datetime_to_stata_elapsed_vec(dates, fmt):
"""
Convert from datetime to SIF. http://www.stata.com/help.cgi?datetime
Parameters
----------
dates : Series
Series or array containing datetime.datetime or datetime64[ns] to
convert to the Stata Internal Format given by fmt
fmt : str
The format to convert to. Can be, tc, td, tw, tm, tq, th, ty
"""
index = dates.index
NS_PER_DAY = 24 * 3600 * 1000 * 1000 * 1000
US_PER_DAY = NS_PER_DAY / 1000
def parse_dates_safe(dates, delta=False, year=False, days=False):
d = {}
if is_datetime64_dtype(dates.values):
if delta:
delta = dates - stata_epoch
d['delta'] = delta.values.astype(
np.int64) // 1000 # microseconds
if days or year:
dates = DatetimeIndex(dates)
d['year'], d['month'] = dates.year, dates.month
if days:
days = (dates.astype(np.int64) -
to_datetime(d['year'], format='%Y').astype(np.int64))
d['days'] = days // NS_PER_DAY
elif infer_dtype(dates, skipna=False) == 'datetime':
if delta:
delta = dates.values - stata_epoch
f = lambda x: \
US_PER_DAY * x.days + 1000000 * x.seconds + x.microseconds
v = np.vectorize(f)
d['delta'] = v(delta)
if year:
year_month = dates.apply(lambda x: 100 * x.year + x.month)
d['year'] = year_month.values // 100
d['month'] = (year_month.values - d['year'] * 100)
if days:
f = lambda x: (x - datetime.datetime(x.year, 1, 1)).days
v = np.vectorize(f)
d['days'] = v(dates)
else:
raise ValueError('Columns containing dates must contain either '
'datetime64, datetime.datetime or null values.')
return DataFrame(d, index=index)
bad_loc = isna(dates)
index = dates.index
if bad_loc.any():
dates = Series(dates)
if is_datetime64_dtype(dates):
dates[bad_loc] = to_datetime(stata_epoch)
else:
dates[bad_loc] = stata_epoch
if fmt in ["%tc", "tc"]:
d = parse_dates_safe(dates, delta=True)
conv_dates = d.delta / 1000
elif fmt in ["%tC", "tC"]:
warnings.warn("Stata Internal Format tC not supported.")
conv_dates = dates
elif fmt in ["%td", "td"]:
d = parse_dates_safe(dates, delta=True)
conv_dates = d.delta // US_PER_DAY
elif fmt in ["%tw", "tw"]:
d = parse_dates_safe(dates, year=True, days=True)
conv_dates = (52 * (d.year - stata_epoch.year) + d.days // 7)
elif fmt in ["%tm", "tm"]:
d = parse_dates_safe(dates, year=True)
conv_dates = (12 * (d.year - stata_epoch.year) + d.month - 1)
elif fmt in ["%tq", "tq"]:
d = parse_dates_safe(dates, year=True)
conv_dates = 4 * (d.year - stata_epoch.year) + (d.month - 1) // 3
elif fmt in ["%th", "th"]:
d = parse_dates_safe(dates, year=True)
conv_dates = (2 * (d.year - stata_epoch.year) +
(d.month > 6).astype(np.int))
elif fmt in ["%ty", "ty"]:
d = parse_dates_safe(dates, year=True)
conv_dates = d.year
else:
raise ValueError(
"Format {fmt} is not a known Stata date format".format(fmt=fmt))
conv_dates = Series(conv_dates, dtype=np.float64)
missing_value = struct.unpack('<d', b'\x00\x00\x00\x00\x00\x00\xe0\x7f')[0]
conv_dates[bad_loc] = missing_value
return Series(conv_dates, index=index) | def _datetime_to_stata_elapsed_vec(dates, fmt):
"""
Convert from datetime to SIF. http://www.stata.com/help.cgi?datetime
Parameters
----------
dates : Series
Series or array containing datetime.datetime or datetime64[ns] to
convert to the Stata Internal Format given by fmt
fmt : str
The format to convert to. Can be, tc, td, tw, tm, tq, th, ty
"""
index = dates.index
NS_PER_DAY = 24 * 3600 * 1000 * 1000 * 1000
US_PER_DAY = NS_PER_DAY / 1000
def parse_dates_safe(dates, delta=False, year=False, days=False):
d = {}
if is_datetime64_dtype(dates.values):
if delta:
delta = dates - stata_epoch
d['delta'] = delta.values.astype(
np.int64) // 1000 # microseconds
if days or year:
dates = DatetimeIndex(dates)
d['year'], d['month'] = dates.year, dates.month
if days:
days = (dates.astype(np.int64) -
to_datetime(d['year'], format='%Y').astype(np.int64))
d['days'] = days // NS_PER_DAY
elif infer_dtype(dates, skipna=False) == 'datetime':
if delta:
delta = dates.values - stata_epoch
f = lambda x: \
US_PER_DAY * x.days + 1000000 * x.seconds + x.microseconds
v = np.vectorize(f)
d['delta'] = v(delta)
if year:
year_month = dates.apply(lambda x: 100 * x.year + x.month)
d['year'] = year_month.values // 100
d['month'] = (year_month.values - d['year'] * 100)
if days:
f = lambda x: (x - datetime.datetime(x.year, 1, 1)).days
v = np.vectorize(f)
d['days'] = v(dates)
else:
raise ValueError('Columns containing dates must contain either '
'datetime64, datetime.datetime or null values.')
return DataFrame(d, index=index)
bad_loc = isna(dates)
index = dates.index
if bad_loc.any():
dates = Series(dates)
if is_datetime64_dtype(dates):
dates[bad_loc] = to_datetime(stata_epoch)
else:
dates[bad_loc] = stata_epoch
if fmt in ["%tc", "tc"]:
d = parse_dates_safe(dates, delta=True)
conv_dates = d.delta / 1000
elif fmt in ["%tC", "tC"]:
warnings.warn("Stata Internal Format tC not supported.")
conv_dates = dates
elif fmt in ["%td", "td"]:
d = parse_dates_safe(dates, delta=True)
conv_dates = d.delta // US_PER_DAY
elif fmt in ["%tw", "tw"]:
d = parse_dates_safe(dates, year=True, days=True)
conv_dates = (52 * (d.year - stata_epoch.year) + d.days // 7)
elif fmt in ["%tm", "tm"]:
d = parse_dates_safe(dates, year=True)
conv_dates = (12 * (d.year - stata_epoch.year) + d.month - 1)
elif fmt in ["%tq", "tq"]:
d = parse_dates_safe(dates, year=True)
conv_dates = 4 * (d.year - stata_epoch.year) + (d.month - 1) // 3
elif fmt in ["%th", "th"]:
d = parse_dates_safe(dates, year=True)
conv_dates = (2 * (d.year - stata_epoch.year) +
(d.month > 6).astype(np.int))
elif fmt in ["%ty", "ty"]:
d = parse_dates_safe(dates, year=True)
conv_dates = d.year
else:
raise ValueError(
"Format {fmt} is not a known Stata date format".format(fmt=fmt))
conv_dates = Series(conv_dates, dtype=np.float64)
missing_value = struct.unpack('<d', b'\x00\x00\x00\x00\x00\x00\xe0\x7f')[0]
conv_dates[bad_loc] = missing_value
return Series(conv_dates, index=index) | [
"Convert",
"from",
"datetime",
"to",
"SIF",
".",
"http",
":",
"//",
"www",
".",
"stata",
".",
"com",
"/",
"help",
".",
"cgi?datetime"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L367-L461 | [
"def",
"_datetime_to_stata_elapsed_vec",
"(",
"dates",
",",
"fmt",
")",
":",
"index",
"=",
"dates",
".",
"index",
"NS_PER_DAY",
"=",
"24",
"*",
"3600",
"*",
"1000",
"*",
"1000",
"*",
"1000",
"US_PER_DAY",
"=",
"NS_PER_DAY",
"/",
"1000",
"def",
"parse_dates_safe",
"(",
"dates",
",",
"delta",
"=",
"False",
",",
"year",
"=",
"False",
",",
"days",
"=",
"False",
")",
":",
"d",
"=",
"{",
"}",
"if",
"is_datetime64_dtype",
"(",
"dates",
".",
"values",
")",
":",
"if",
"delta",
":",
"delta",
"=",
"dates",
"-",
"stata_epoch",
"d",
"[",
"'delta'",
"]",
"=",
"delta",
".",
"values",
".",
"astype",
"(",
"np",
".",
"int64",
")",
"//",
"1000",
"# microseconds",
"if",
"days",
"or",
"year",
":",
"dates",
"=",
"DatetimeIndex",
"(",
"dates",
")",
"d",
"[",
"'year'",
"]",
",",
"d",
"[",
"'month'",
"]",
"=",
"dates",
".",
"year",
",",
"dates",
".",
"month",
"if",
"days",
":",
"days",
"=",
"(",
"dates",
".",
"astype",
"(",
"np",
".",
"int64",
")",
"-",
"to_datetime",
"(",
"d",
"[",
"'year'",
"]",
",",
"format",
"=",
"'%Y'",
")",
".",
"astype",
"(",
"np",
".",
"int64",
")",
")",
"d",
"[",
"'days'",
"]",
"=",
"days",
"//",
"NS_PER_DAY",
"elif",
"infer_dtype",
"(",
"dates",
",",
"skipna",
"=",
"False",
")",
"==",
"'datetime'",
":",
"if",
"delta",
":",
"delta",
"=",
"dates",
".",
"values",
"-",
"stata_epoch",
"f",
"=",
"lambda",
"x",
":",
"US_PER_DAY",
"*",
"x",
".",
"days",
"+",
"1000000",
"*",
"x",
".",
"seconds",
"+",
"x",
".",
"microseconds",
"v",
"=",
"np",
".",
"vectorize",
"(",
"f",
")",
"d",
"[",
"'delta'",
"]",
"=",
"v",
"(",
"delta",
")",
"if",
"year",
":",
"year_month",
"=",
"dates",
".",
"apply",
"(",
"lambda",
"x",
":",
"100",
"*",
"x",
".",
"year",
"+",
"x",
".",
"month",
")",
"d",
"[",
"'year'",
"]",
"=",
"year_month",
".",
"values",
"//",
"100",
"d",
"[",
"'month'",
"]",
"=",
"(",
"year_month",
".",
"values",
"-",
"d",
"[",
"'year'",
"]",
"*",
"100",
")",
"if",
"days",
":",
"f",
"=",
"lambda",
"x",
":",
"(",
"x",
"-",
"datetime",
".",
"datetime",
"(",
"x",
".",
"year",
",",
"1",
",",
"1",
")",
")",
".",
"days",
"v",
"=",
"np",
".",
"vectorize",
"(",
"f",
")",
"d",
"[",
"'days'",
"]",
"=",
"v",
"(",
"dates",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'Columns containing dates must contain either '",
"'datetime64, datetime.datetime or null values.'",
")",
"return",
"DataFrame",
"(",
"d",
",",
"index",
"=",
"index",
")",
"bad_loc",
"=",
"isna",
"(",
"dates",
")",
"index",
"=",
"dates",
".",
"index",
"if",
"bad_loc",
".",
"any",
"(",
")",
":",
"dates",
"=",
"Series",
"(",
"dates",
")",
"if",
"is_datetime64_dtype",
"(",
"dates",
")",
":",
"dates",
"[",
"bad_loc",
"]",
"=",
"to_datetime",
"(",
"stata_epoch",
")",
"else",
":",
"dates",
"[",
"bad_loc",
"]",
"=",
"stata_epoch",
"if",
"fmt",
"in",
"[",
"\"%tc\"",
",",
"\"tc\"",
"]",
":",
"d",
"=",
"parse_dates_safe",
"(",
"dates",
",",
"delta",
"=",
"True",
")",
"conv_dates",
"=",
"d",
".",
"delta",
"/",
"1000",
"elif",
"fmt",
"in",
"[",
"\"%tC\"",
",",
"\"tC\"",
"]",
":",
"warnings",
".",
"warn",
"(",
"\"Stata Internal Format tC not supported.\"",
")",
"conv_dates",
"=",
"dates",
"elif",
"fmt",
"in",
"[",
"\"%td\"",
",",
"\"td\"",
"]",
":",
"d",
"=",
"parse_dates_safe",
"(",
"dates",
",",
"delta",
"=",
"True",
")",
"conv_dates",
"=",
"d",
".",
"delta",
"//",
"US_PER_DAY",
"elif",
"fmt",
"in",
"[",
"\"%tw\"",
",",
"\"tw\"",
"]",
":",
"d",
"=",
"parse_dates_safe",
"(",
"dates",
",",
"year",
"=",
"True",
",",
"days",
"=",
"True",
")",
"conv_dates",
"=",
"(",
"52",
"*",
"(",
"d",
".",
"year",
"-",
"stata_epoch",
".",
"year",
")",
"+",
"d",
".",
"days",
"//",
"7",
")",
"elif",
"fmt",
"in",
"[",
"\"%tm\"",
",",
"\"tm\"",
"]",
":",
"d",
"=",
"parse_dates_safe",
"(",
"dates",
",",
"year",
"=",
"True",
")",
"conv_dates",
"=",
"(",
"12",
"*",
"(",
"d",
".",
"year",
"-",
"stata_epoch",
".",
"year",
")",
"+",
"d",
".",
"month",
"-",
"1",
")",
"elif",
"fmt",
"in",
"[",
"\"%tq\"",
",",
"\"tq\"",
"]",
":",
"d",
"=",
"parse_dates_safe",
"(",
"dates",
",",
"year",
"=",
"True",
")",
"conv_dates",
"=",
"4",
"*",
"(",
"d",
".",
"year",
"-",
"stata_epoch",
".",
"year",
")",
"+",
"(",
"d",
".",
"month",
"-",
"1",
")",
"//",
"3",
"elif",
"fmt",
"in",
"[",
"\"%th\"",
",",
"\"th\"",
"]",
":",
"d",
"=",
"parse_dates_safe",
"(",
"dates",
",",
"year",
"=",
"True",
")",
"conv_dates",
"=",
"(",
"2",
"*",
"(",
"d",
".",
"year",
"-",
"stata_epoch",
".",
"year",
")",
"+",
"(",
"d",
".",
"month",
">",
"6",
")",
".",
"astype",
"(",
"np",
".",
"int",
")",
")",
"elif",
"fmt",
"in",
"[",
"\"%ty\"",
",",
"\"ty\"",
"]",
":",
"d",
"=",
"parse_dates_safe",
"(",
"dates",
",",
"year",
"=",
"True",
")",
"conv_dates",
"=",
"d",
".",
"year",
"else",
":",
"raise",
"ValueError",
"(",
"\"Format {fmt} is not a known Stata date format\"",
".",
"format",
"(",
"fmt",
"=",
"fmt",
")",
")",
"conv_dates",
"=",
"Series",
"(",
"conv_dates",
",",
"dtype",
"=",
"np",
".",
"float64",
")",
"missing_value",
"=",
"struct",
".",
"unpack",
"(",
"'<d'",
",",
"b'\\x00\\x00\\x00\\x00\\x00\\x00\\xe0\\x7f'",
")",
"[",
"0",
"]",
"conv_dates",
"[",
"bad_loc",
"]",
"=",
"missing_value",
"return",
"Series",
"(",
"conv_dates",
",",
"index",
"=",
"index",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _cast_to_stata_types | Checks the dtypes of the columns of a pandas DataFrame for
compatibility with the data types and ranges supported by Stata, and
converts if necessary.
Parameters
----------
data : DataFrame
The DataFrame to check and convert
Notes
-----
Numeric columns in Stata must be one of int8, int16, int32, float32 or
float64, with some additional value restrictions. int8 and int16 columns
are checked for violations of the value restrictions and upcast if needed.
int64 data is not usable in Stata, and so it is downcast to int32 whenever
the value are in the int32 range, and sidecast to float64 when larger than
this range. If the int64 values are outside of the range of those
perfectly representable as float64 values, a warning is raised.
bool columns are cast to int8. uint columns are converted to int of the
same size if there is no loss in precision, otherwise are upcast to a
larger type. uint64 is currently not supported since it is concerted to
object in a DataFrame. | pandas/io/stata.py | def _cast_to_stata_types(data):
"""Checks the dtypes of the columns of a pandas DataFrame for
compatibility with the data types and ranges supported by Stata, and
converts if necessary.
Parameters
----------
data : DataFrame
The DataFrame to check and convert
Notes
-----
Numeric columns in Stata must be one of int8, int16, int32, float32 or
float64, with some additional value restrictions. int8 and int16 columns
are checked for violations of the value restrictions and upcast if needed.
int64 data is not usable in Stata, and so it is downcast to int32 whenever
the value are in the int32 range, and sidecast to float64 when larger than
this range. If the int64 values are outside of the range of those
perfectly representable as float64 values, a warning is raised.
bool columns are cast to int8. uint columns are converted to int of the
same size if there is no loss in precision, otherwise are upcast to a
larger type. uint64 is currently not supported since it is concerted to
object in a DataFrame.
"""
ws = ''
# original, if small, if large
conversion_data = ((np.bool, np.int8, np.int8),
(np.uint8, np.int8, np.int16),
(np.uint16, np.int16, np.int32),
(np.uint32, np.int32, np.int64))
float32_max = struct.unpack('<f', b'\xff\xff\xff\x7e')[0]
float64_max = struct.unpack('<d', b'\xff\xff\xff\xff\xff\xff\xdf\x7f')[0]
for col in data:
dtype = data[col].dtype
# Cast from unsupported types to supported types
for c_data in conversion_data:
if dtype == c_data[0]:
if data[col].max() <= np.iinfo(c_data[1]).max:
dtype = c_data[1]
else:
dtype = c_data[2]
if c_data[2] == np.float64: # Warn if necessary
if data[col].max() >= 2 ** 53:
ws = precision_loss_doc % ('uint64', 'float64')
data[col] = data[col].astype(dtype)
# Check values and upcast if necessary
if dtype == np.int8:
if data[col].max() > 100 or data[col].min() < -127:
data[col] = data[col].astype(np.int16)
elif dtype == np.int16:
if data[col].max() > 32740 or data[col].min() < -32767:
data[col] = data[col].astype(np.int32)
elif dtype == np.int64:
if (data[col].max() <= 2147483620 and
data[col].min() >= -2147483647):
data[col] = data[col].astype(np.int32)
else:
data[col] = data[col].astype(np.float64)
if data[col].max() >= 2 ** 53 or data[col].min() <= -2 ** 53:
ws = precision_loss_doc % ('int64', 'float64')
elif dtype in (np.float32, np.float64):
value = data[col].max()
if np.isinf(value):
raise ValueError('Column {col} has a maximum value of '
'infinity which is outside the range '
'supported by Stata.'.format(col=col))
if dtype == np.float32 and value > float32_max:
data[col] = data[col].astype(np.float64)
elif dtype == np.float64:
if value > float64_max:
raise ValueError('Column {col} has a maximum value '
'({val}) outside the range supported by '
'Stata ({float64_max})'
.format(col=col, val=value,
float64_max=float64_max))
if ws:
warnings.warn(ws, PossiblePrecisionLoss)
return data | def _cast_to_stata_types(data):
"""Checks the dtypes of the columns of a pandas DataFrame for
compatibility with the data types and ranges supported by Stata, and
converts if necessary.
Parameters
----------
data : DataFrame
The DataFrame to check and convert
Notes
-----
Numeric columns in Stata must be one of int8, int16, int32, float32 or
float64, with some additional value restrictions. int8 and int16 columns
are checked for violations of the value restrictions and upcast if needed.
int64 data is not usable in Stata, and so it is downcast to int32 whenever
the value are in the int32 range, and sidecast to float64 when larger than
this range. If the int64 values are outside of the range of those
perfectly representable as float64 values, a warning is raised.
bool columns are cast to int8. uint columns are converted to int of the
same size if there is no loss in precision, otherwise are upcast to a
larger type. uint64 is currently not supported since it is concerted to
object in a DataFrame.
"""
ws = ''
# original, if small, if large
conversion_data = ((np.bool, np.int8, np.int8),
(np.uint8, np.int8, np.int16),
(np.uint16, np.int16, np.int32),
(np.uint32, np.int32, np.int64))
float32_max = struct.unpack('<f', b'\xff\xff\xff\x7e')[0]
float64_max = struct.unpack('<d', b'\xff\xff\xff\xff\xff\xff\xdf\x7f')[0]
for col in data:
dtype = data[col].dtype
# Cast from unsupported types to supported types
for c_data in conversion_data:
if dtype == c_data[0]:
if data[col].max() <= np.iinfo(c_data[1]).max:
dtype = c_data[1]
else:
dtype = c_data[2]
if c_data[2] == np.float64: # Warn if necessary
if data[col].max() >= 2 ** 53:
ws = precision_loss_doc % ('uint64', 'float64')
data[col] = data[col].astype(dtype)
# Check values and upcast if necessary
if dtype == np.int8:
if data[col].max() > 100 or data[col].min() < -127:
data[col] = data[col].astype(np.int16)
elif dtype == np.int16:
if data[col].max() > 32740 or data[col].min() < -32767:
data[col] = data[col].astype(np.int32)
elif dtype == np.int64:
if (data[col].max() <= 2147483620 and
data[col].min() >= -2147483647):
data[col] = data[col].astype(np.int32)
else:
data[col] = data[col].astype(np.float64)
if data[col].max() >= 2 ** 53 or data[col].min() <= -2 ** 53:
ws = precision_loss_doc % ('int64', 'float64')
elif dtype in (np.float32, np.float64):
value = data[col].max()
if np.isinf(value):
raise ValueError('Column {col} has a maximum value of '
'infinity which is outside the range '
'supported by Stata.'.format(col=col))
if dtype == np.float32 and value > float32_max:
data[col] = data[col].astype(np.float64)
elif dtype == np.float64:
if value > float64_max:
raise ValueError('Column {col} has a maximum value '
'({val}) outside the range supported by '
'Stata ({float64_max})'
.format(col=col, val=value,
float64_max=float64_max))
if ws:
warnings.warn(ws, PossiblePrecisionLoss)
return data | [
"Checks",
"the",
"dtypes",
"of",
"the",
"columns",
"of",
"a",
"pandas",
"DataFrame",
"for",
"compatibility",
"with",
"the",
"data",
"types",
"and",
"ranges",
"supported",
"by",
"Stata",
"and",
"converts",
"if",
"necessary",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L508-L592 | [
"def",
"_cast_to_stata_types",
"(",
"data",
")",
":",
"ws",
"=",
"''",
"# original, if small, if large",
"conversion_data",
"=",
"(",
"(",
"np",
".",
"bool",
",",
"np",
".",
"int8",
",",
"np",
".",
"int8",
")",
",",
"(",
"np",
".",
"uint8",
",",
"np",
".",
"int8",
",",
"np",
".",
"int16",
")",
",",
"(",
"np",
".",
"uint16",
",",
"np",
".",
"int16",
",",
"np",
".",
"int32",
")",
",",
"(",
"np",
".",
"uint32",
",",
"np",
".",
"int32",
",",
"np",
".",
"int64",
")",
")",
"float32_max",
"=",
"struct",
".",
"unpack",
"(",
"'<f'",
",",
"b'\\xff\\xff\\xff\\x7e'",
")",
"[",
"0",
"]",
"float64_max",
"=",
"struct",
".",
"unpack",
"(",
"'<d'",
",",
"b'\\xff\\xff\\xff\\xff\\xff\\xff\\xdf\\x7f'",
")",
"[",
"0",
"]",
"for",
"col",
"in",
"data",
":",
"dtype",
"=",
"data",
"[",
"col",
"]",
".",
"dtype",
"# Cast from unsupported types to supported types",
"for",
"c_data",
"in",
"conversion_data",
":",
"if",
"dtype",
"==",
"c_data",
"[",
"0",
"]",
":",
"if",
"data",
"[",
"col",
"]",
".",
"max",
"(",
")",
"<=",
"np",
".",
"iinfo",
"(",
"c_data",
"[",
"1",
"]",
")",
".",
"max",
":",
"dtype",
"=",
"c_data",
"[",
"1",
"]",
"else",
":",
"dtype",
"=",
"c_data",
"[",
"2",
"]",
"if",
"c_data",
"[",
"2",
"]",
"==",
"np",
".",
"float64",
":",
"# Warn if necessary",
"if",
"data",
"[",
"col",
"]",
".",
"max",
"(",
")",
">=",
"2",
"**",
"53",
":",
"ws",
"=",
"precision_loss_doc",
"%",
"(",
"'uint64'",
",",
"'float64'",
")",
"data",
"[",
"col",
"]",
"=",
"data",
"[",
"col",
"]",
".",
"astype",
"(",
"dtype",
")",
"# Check values and upcast if necessary",
"if",
"dtype",
"==",
"np",
".",
"int8",
":",
"if",
"data",
"[",
"col",
"]",
".",
"max",
"(",
")",
">",
"100",
"or",
"data",
"[",
"col",
"]",
".",
"min",
"(",
")",
"<",
"-",
"127",
":",
"data",
"[",
"col",
"]",
"=",
"data",
"[",
"col",
"]",
".",
"astype",
"(",
"np",
".",
"int16",
")",
"elif",
"dtype",
"==",
"np",
".",
"int16",
":",
"if",
"data",
"[",
"col",
"]",
".",
"max",
"(",
")",
">",
"32740",
"or",
"data",
"[",
"col",
"]",
".",
"min",
"(",
")",
"<",
"-",
"32767",
":",
"data",
"[",
"col",
"]",
"=",
"data",
"[",
"col",
"]",
".",
"astype",
"(",
"np",
".",
"int32",
")",
"elif",
"dtype",
"==",
"np",
".",
"int64",
":",
"if",
"(",
"data",
"[",
"col",
"]",
".",
"max",
"(",
")",
"<=",
"2147483620",
"and",
"data",
"[",
"col",
"]",
".",
"min",
"(",
")",
">=",
"-",
"2147483647",
")",
":",
"data",
"[",
"col",
"]",
"=",
"data",
"[",
"col",
"]",
".",
"astype",
"(",
"np",
".",
"int32",
")",
"else",
":",
"data",
"[",
"col",
"]",
"=",
"data",
"[",
"col",
"]",
".",
"astype",
"(",
"np",
".",
"float64",
")",
"if",
"data",
"[",
"col",
"]",
".",
"max",
"(",
")",
">=",
"2",
"**",
"53",
"or",
"data",
"[",
"col",
"]",
".",
"min",
"(",
")",
"<=",
"-",
"2",
"**",
"53",
":",
"ws",
"=",
"precision_loss_doc",
"%",
"(",
"'int64'",
",",
"'float64'",
")",
"elif",
"dtype",
"in",
"(",
"np",
".",
"float32",
",",
"np",
".",
"float64",
")",
":",
"value",
"=",
"data",
"[",
"col",
"]",
".",
"max",
"(",
")",
"if",
"np",
".",
"isinf",
"(",
"value",
")",
":",
"raise",
"ValueError",
"(",
"'Column {col} has a maximum value of '",
"'infinity which is outside the range '",
"'supported by Stata.'",
".",
"format",
"(",
"col",
"=",
"col",
")",
")",
"if",
"dtype",
"==",
"np",
".",
"float32",
"and",
"value",
">",
"float32_max",
":",
"data",
"[",
"col",
"]",
"=",
"data",
"[",
"col",
"]",
".",
"astype",
"(",
"np",
".",
"float64",
")",
"elif",
"dtype",
"==",
"np",
".",
"float64",
":",
"if",
"value",
">",
"float64_max",
":",
"raise",
"ValueError",
"(",
"'Column {col} has a maximum value '",
"'({val}) outside the range supported by '",
"'Stata ({float64_max})'",
".",
"format",
"(",
"col",
"=",
"col",
",",
"val",
"=",
"value",
",",
"float64_max",
"=",
"float64_max",
")",
")",
"if",
"ws",
":",
"warnings",
".",
"warn",
"(",
"ws",
",",
"PossiblePrecisionLoss",
")",
"return",
"data"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _dtype_to_stata_type | Convert dtype types to stata types. Returns the byte of the given ordinal.
See TYPE_MAP and comments for an explanation. This is also explained in
the dta spec.
1 - 244 are strings of this length
Pandas Stata
251 - for int8 byte
252 - for int16 int
253 - for int32 long
254 - for float32 float
255 - for double double
If there are dates to convert, then dtype will already have the correct
type inserted. | pandas/io/stata.py | def _dtype_to_stata_type(dtype, column):
"""
Convert dtype types to stata types. Returns the byte of the given ordinal.
See TYPE_MAP and comments for an explanation. This is also explained in
the dta spec.
1 - 244 are strings of this length
Pandas Stata
251 - for int8 byte
252 - for int16 int
253 - for int32 long
254 - for float32 float
255 - for double double
If there are dates to convert, then dtype will already have the correct
type inserted.
"""
# TODO: expand to handle datetime to integer conversion
if dtype.type == np.object_: # try to coerce it to the biggest string
# not memory efficient, what else could we
# do?
itemsize = max_len_string_array(ensure_object(column.values))
return max(itemsize, 1)
elif dtype == np.float64:
return 255
elif dtype == np.float32:
return 254
elif dtype == np.int32:
return 253
elif dtype == np.int16:
return 252
elif dtype == np.int8:
return 251
else: # pragma : no cover
raise NotImplementedError(
"Data type {dtype} not supported.".format(dtype=dtype)) | def _dtype_to_stata_type(dtype, column):
"""
Convert dtype types to stata types. Returns the byte of the given ordinal.
See TYPE_MAP and comments for an explanation. This is also explained in
the dta spec.
1 - 244 are strings of this length
Pandas Stata
251 - for int8 byte
252 - for int16 int
253 - for int32 long
254 - for float32 float
255 - for double double
If there are dates to convert, then dtype will already have the correct
type inserted.
"""
# TODO: expand to handle datetime to integer conversion
if dtype.type == np.object_: # try to coerce it to the biggest string
# not memory efficient, what else could we
# do?
itemsize = max_len_string_array(ensure_object(column.values))
return max(itemsize, 1)
elif dtype == np.float64:
return 255
elif dtype == np.float32:
return 254
elif dtype == np.int32:
return 253
elif dtype == np.int16:
return 252
elif dtype == np.int8:
return 251
else: # pragma : no cover
raise NotImplementedError(
"Data type {dtype} not supported.".format(dtype=dtype)) | [
"Convert",
"dtype",
"types",
"to",
"stata",
"types",
".",
"Returns",
"the",
"byte",
"of",
"the",
"given",
"ordinal",
".",
"See",
"TYPE_MAP",
"and",
"comments",
"for",
"an",
"explanation",
".",
"This",
"is",
"also",
"explained",
"in",
"the",
"dta",
"spec",
".",
"1",
"-",
"244",
"are",
"strings",
"of",
"this",
"length",
"Pandas",
"Stata",
"251",
"-",
"for",
"int8",
"byte",
"252",
"-",
"for",
"int16",
"int",
"253",
"-",
"for",
"int32",
"long",
"254",
"-",
"for",
"float32",
"float",
"255",
"-",
"for",
"double",
"double"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L1832-L1866 | [
"def",
"_dtype_to_stata_type",
"(",
"dtype",
",",
"column",
")",
":",
"# TODO: expand to handle datetime to integer conversion",
"if",
"dtype",
".",
"type",
"==",
"np",
".",
"object_",
":",
"# try to coerce it to the biggest string",
"# not memory efficient, what else could we",
"# do?",
"itemsize",
"=",
"max_len_string_array",
"(",
"ensure_object",
"(",
"column",
".",
"values",
")",
")",
"return",
"max",
"(",
"itemsize",
",",
"1",
")",
"elif",
"dtype",
"==",
"np",
".",
"float64",
":",
"return",
"255",
"elif",
"dtype",
"==",
"np",
".",
"float32",
":",
"return",
"254",
"elif",
"dtype",
"==",
"np",
".",
"int32",
":",
"return",
"253",
"elif",
"dtype",
"==",
"np",
".",
"int16",
":",
"return",
"252",
"elif",
"dtype",
"==",
"np",
".",
"int8",
":",
"return",
"251",
"else",
":",
"# pragma : no cover",
"raise",
"NotImplementedError",
"(",
"\"Data type {dtype} not supported.\"",
".",
"format",
"(",
"dtype",
"=",
"dtype",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _dtype_to_default_stata_fmt | Map numpy dtype to stata's default format for this type. Not terribly
important since users can change this in Stata. Semantics are
object -> "%DDs" where DD is the length of the string. If not a string,
raise ValueError
float64 -> "%10.0g"
float32 -> "%9.0g"
int64 -> "%9.0g"
int32 -> "%12.0g"
int16 -> "%8.0g"
int8 -> "%8.0g"
strl -> "%9s" | pandas/io/stata.py | def _dtype_to_default_stata_fmt(dtype, column, dta_version=114,
force_strl=False):
"""
Map numpy dtype to stata's default format for this type. Not terribly
important since users can change this in Stata. Semantics are
object -> "%DDs" where DD is the length of the string. If not a string,
raise ValueError
float64 -> "%10.0g"
float32 -> "%9.0g"
int64 -> "%9.0g"
int32 -> "%12.0g"
int16 -> "%8.0g"
int8 -> "%8.0g"
strl -> "%9s"
"""
# TODO: Refactor to combine type with format
# TODO: expand this to handle a default datetime format?
if dta_version < 117:
max_str_len = 244
else:
max_str_len = 2045
if force_strl:
return '%9s'
if dtype.type == np.object_:
inferred_dtype = infer_dtype(column, skipna=True)
if not (inferred_dtype in ('string', 'unicode') or
len(column) == 0):
raise ValueError('Column `{col}` cannot be exported.\n\nOnly '
'string-like object arrays containing all '
'strings or a mix of strings and None can be '
'exported. Object arrays containing only null '
'values are prohibited. Other object types'
'cannot be exported and must first be converted '
'to one of the supported '
'types.'.format(col=column.name))
itemsize = max_len_string_array(ensure_object(column.values))
if itemsize > max_str_len:
if dta_version >= 117:
return '%9s'
else:
raise ValueError(excessive_string_length_error % column.name)
return "%" + str(max(itemsize, 1)) + "s"
elif dtype == np.float64:
return "%10.0g"
elif dtype == np.float32:
return "%9.0g"
elif dtype == np.int32:
return "%12.0g"
elif dtype == np.int8 or dtype == np.int16:
return "%8.0g"
else: # pragma : no cover
raise NotImplementedError(
"Data type {dtype} not supported.".format(dtype=dtype)) | def _dtype_to_default_stata_fmt(dtype, column, dta_version=114,
force_strl=False):
"""
Map numpy dtype to stata's default format for this type. Not terribly
important since users can change this in Stata. Semantics are
object -> "%DDs" where DD is the length of the string. If not a string,
raise ValueError
float64 -> "%10.0g"
float32 -> "%9.0g"
int64 -> "%9.0g"
int32 -> "%12.0g"
int16 -> "%8.0g"
int8 -> "%8.0g"
strl -> "%9s"
"""
# TODO: Refactor to combine type with format
# TODO: expand this to handle a default datetime format?
if dta_version < 117:
max_str_len = 244
else:
max_str_len = 2045
if force_strl:
return '%9s'
if dtype.type == np.object_:
inferred_dtype = infer_dtype(column, skipna=True)
if not (inferred_dtype in ('string', 'unicode') or
len(column) == 0):
raise ValueError('Column `{col}` cannot be exported.\n\nOnly '
'string-like object arrays containing all '
'strings or a mix of strings and None can be '
'exported. Object arrays containing only null '
'values are prohibited. Other object types'
'cannot be exported and must first be converted '
'to one of the supported '
'types.'.format(col=column.name))
itemsize = max_len_string_array(ensure_object(column.values))
if itemsize > max_str_len:
if dta_version >= 117:
return '%9s'
else:
raise ValueError(excessive_string_length_error % column.name)
return "%" + str(max(itemsize, 1)) + "s"
elif dtype == np.float64:
return "%10.0g"
elif dtype == np.float32:
return "%9.0g"
elif dtype == np.int32:
return "%12.0g"
elif dtype == np.int8 or dtype == np.int16:
return "%8.0g"
else: # pragma : no cover
raise NotImplementedError(
"Data type {dtype} not supported.".format(dtype=dtype)) | [
"Map",
"numpy",
"dtype",
"to",
"stata",
"s",
"default",
"format",
"for",
"this",
"type",
".",
"Not",
"terribly",
"important",
"since",
"users",
"can",
"change",
"this",
"in",
"Stata",
".",
"Semantics",
"are"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L1869-L1922 | [
"def",
"_dtype_to_default_stata_fmt",
"(",
"dtype",
",",
"column",
",",
"dta_version",
"=",
"114",
",",
"force_strl",
"=",
"False",
")",
":",
"# TODO: Refactor to combine type with format",
"# TODO: expand this to handle a default datetime format?",
"if",
"dta_version",
"<",
"117",
":",
"max_str_len",
"=",
"244",
"else",
":",
"max_str_len",
"=",
"2045",
"if",
"force_strl",
":",
"return",
"'%9s'",
"if",
"dtype",
".",
"type",
"==",
"np",
".",
"object_",
":",
"inferred_dtype",
"=",
"infer_dtype",
"(",
"column",
",",
"skipna",
"=",
"True",
")",
"if",
"not",
"(",
"inferred_dtype",
"in",
"(",
"'string'",
",",
"'unicode'",
")",
"or",
"len",
"(",
"column",
")",
"==",
"0",
")",
":",
"raise",
"ValueError",
"(",
"'Column `{col}` cannot be exported.\\n\\nOnly '",
"'string-like object arrays containing all '",
"'strings or a mix of strings and None can be '",
"'exported. Object arrays containing only null '",
"'values are prohibited. Other object types'",
"'cannot be exported and must first be converted '",
"'to one of the supported '",
"'types.'",
".",
"format",
"(",
"col",
"=",
"column",
".",
"name",
")",
")",
"itemsize",
"=",
"max_len_string_array",
"(",
"ensure_object",
"(",
"column",
".",
"values",
")",
")",
"if",
"itemsize",
">",
"max_str_len",
":",
"if",
"dta_version",
">=",
"117",
":",
"return",
"'%9s'",
"else",
":",
"raise",
"ValueError",
"(",
"excessive_string_length_error",
"%",
"column",
".",
"name",
")",
"return",
"\"%\"",
"+",
"str",
"(",
"max",
"(",
"itemsize",
",",
"1",
")",
")",
"+",
"\"s\"",
"elif",
"dtype",
"==",
"np",
".",
"float64",
":",
"return",
"\"%10.0g\"",
"elif",
"dtype",
"==",
"np",
".",
"float32",
":",
"return",
"\"%9.0g\"",
"elif",
"dtype",
"==",
"np",
".",
"int32",
":",
"return",
"\"%12.0g\"",
"elif",
"dtype",
"==",
"np",
".",
"int8",
"or",
"dtype",
"==",
"np",
".",
"int16",
":",
"return",
"\"%8.0g\"",
"else",
":",
"# pragma : no cover",
"raise",
"NotImplementedError",
"(",
"\"Data type {dtype} not supported.\"",
".",
"format",
"(",
"dtype",
"=",
"dtype",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _pad_bytes_new | Takes a bytes instance and pads it with null bytes until it's length chars. | pandas/io/stata.py | def _pad_bytes_new(name, length):
"""
Takes a bytes instance and pads it with null bytes until it's length chars.
"""
if isinstance(name, str):
name = bytes(name, 'utf-8')
return name + b'\x00' * (length - len(name)) | def _pad_bytes_new(name, length):
"""
Takes a bytes instance and pads it with null bytes until it's length chars.
"""
if isinstance(name, str):
name = bytes(name, 'utf-8')
return name + b'\x00' * (length - len(name)) | [
"Takes",
"a",
"bytes",
"instance",
"and",
"pads",
"it",
"with",
"null",
"bytes",
"until",
"it",
"s",
"length",
"chars",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2477-L2483 | [
"def",
"_pad_bytes_new",
"(",
"name",
",",
"length",
")",
":",
"if",
"isinstance",
"(",
"name",
",",
"str",
")",
":",
"name",
"=",
"bytes",
"(",
"name",
",",
"'utf-8'",
")",
"return",
"name",
"+",
"b'\\x00'",
"*",
"(",
"length",
"-",
"len",
"(",
"name",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataValueLabel.generate_value_label | Parameters
----------
byteorder : str
Byte order of the output
encoding : str
File encoding
Returns
-------
value_label : bytes
Bytes containing the formatted value label | pandas/io/stata.py | def generate_value_label(self, byteorder, encoding):
"""
Parameters
----------
byteorder : str
Byte order of the output
encoding : str
File encoding
Returns
-------
value_label : bytes
Bytes containing the formatted value label
"""
self._encoding = encoding
bio = BytesIO()
null_string = '\x00'
null_byte = b'\x00'
# len
bio.write(struct.pack(byteorder + 'i', self.len))
# labname
labname = self._encode(_pad_bytes(self.labname[:32], 33))
bio.write(labname)
# padding - 3 bytes
for i in range(3):
bio.write(struct.pack('c', null_byte))
# value_label_table
# n - int32
bio.write(struct.pack(byteorder + 'i', self.n))
# textlen - int32
bio.write(struct.pack(byteorder + 'i', self.text_len))
# off - int32 array (n elements)
for offset in self.off:
bio.write(struct.pack(byteorder + 'i', offset))
# val - int32 array (n elements)
for value in self.val:
bio.write(struct.pack(byteorder + 'i', value))
# txt - Text labels, null terminated
for text in self.txt:
bio.write(self._encode(text + null_string))
bio.seek(0)
return bio.read() | def generate_value_label(self, byteorder, encoding):
"""
Parameters
----------
byteorder : str
Byte order of the output
encoding : str
File encoding
Returns
-------
value_label : bytes
Bytes containing the formatted value label
"""
self._encoding = encoding
bio = BytesIO()
null_string = '\x00'
null_byte = b'\x00'
# len
bio.write(struct.pack(byteorder + 'i', self.len))
# labname
labname = self._encode(_pad_bytes(self.labname[:32], 33))
bio.write(labname)
# padding - 3 bytes
for i in range(3):
bio.write(struct.pack('c', null_byte))
# value_label_table
# n - int32
bio.write(struct.pack(byteorder + 'i', self.n))
# textlen - int32
bio.write(struct.pack(byteorder + 'i', self.text_len))
# off - int32 array (n elements)
for offset in self.off:
bio.write(struct.pack(byteorder + 'i', offset))
# val - int32 array (n elements)
for value in self.val:
bio.write(struct.pack(byteorder + 'i', value))
# txt - Text labels, null terminated
for text in self.txt:
bio.write(self._encode(text + null_string))
bio.seek(0)
return bio.read() | [
"Parameters",
"----------",
"byteorder",
":",
"str",
"Byte",
"order",
"of",
"the",
"output",
"encoding",
":",
"str",
"File",
"encoding"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L662-L713 | [
"def",
"generate_value_label",
"(",
"self",
",",
"byteorder",
",",
"encoding",
")",
":",
"self",
".",
"_encoding",
"=",
"encoding",
"bio",
"=",
"BytesIO",
"(",
")",
"null_string",
"=",
"'\\x00'",
"null_byte",
"=",
"b'\\x00'",
"# len",
"bio",
".",
"write",
"(",
"struct",
".",
"pack",
"(",
"byteorder",
"+",
"'i'",
",",
"self",
".",
"len",
")",
")",
"# labname",
"labname",
"=",
"self",
".",
"_encode",
"(",
"_pad_bytes",
"(",
"self",
".",
"labname",
"[",
":",
"32",
"]",
",",
"33",
")",
")",
"bio",
".",
"write",
"(",
"labname",
")",
"# padding - 3 bytes",
"for",
"i",
"in",
"range",
"(",
"3",
")",
":",
"bio",
".",
"write",
"(",
"struct",
".",
"pack",
"(",
"'c'",
",",
"null_byte",
")",
")",
"# value_label_table",
"# n - int32",
"bio",
".",
"write",
"(",
"struct",
".",
"pack",
"(",
"byteorder",
"+",
"'i'",
",",
"self",
".",
"n",
")",
")",
"# textlen - int32",
"bio",
".",
"write",
"(",
"struct",
".",
"pack",
"(",
"byteorder",
"+",
"'i'",
",",
"self",
".",
"text_len",
")",
")",
"# off - int32 array (n elements)",
"for",
"offset",
"in",
"self",
".",
"off",
":",
"bio",
".",
"write",
"(",
"struct",
".",
"pack",
"(",
"byteorder",
"+",
"'i'",
",",
"offset",
")",
")",
"# val - int32 array (n elements)",
"for",
"value",
"in",
"self",
".",
"val",
":",
"bio",
".",
"write",
"(",
"struct",
".",
"pack",
"(",
"byteorder",
"+",
"'i'",
",",
"value",
")",
")",
"# txt - Text labels, null terminated",
"for",
"text",
"in",
"self",
".",
"txt",
":",
"bio",
".",
"write",
"(",
"self",
".",
"_encode",
"(",
"text",
"+",
"null_string",
")",
")",
"bio",
".",
"seek",
"(",
"0",
")",
"return",
"bio",
".",
"read",
"(",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataReader._setup_dtype | Map between numpy and state dtypes | pandas/io/stata.py | def _setup_dtype(self):
"""Map between numpy and state dtypes"""
if self._dtype is not None:
return self._dtype
dtype = [] # Convert struct data types to numpy data type
for i, typ in enumerate(self.typlist):
if typ in self.NUMPY_TYPE_MAP:
dtype.append(('s' + str(i), self.byteorder +
self.NUMPY_TYPE_MAP[typ]))
else:
dtype.append(('s' + str(i), 'S' + str(typ)))
dtype = np.dtype(dtype)
self._dtype = dtype
return self._dtype | def _setup_dtype(self):
"""Map between numpy and state dtypes"""
if self._dtype is not None:
return self._dtype
dtype = [] # Convert struct data types to numpy data type
for i, typ in enumerate(self.typlist):
if typ in self.NUMPY_TYPE_MAP:
dtype.append(('s' + str(i), self.byteorder +
self.NUMPY_TYPE_MAP[typ]))
else:
dtype.append(('s' + str(i), 'S' + str(typ)))
dtype = np.dtype(dtype)
self._dtype = dtype
return self._dtype | [
"Map",
"between",
"numpy",
"and",
"state",
"dtypes"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L1307-L1322 | [
"def",
"_setup_dtype",
"(",
"self",
")",
":",
"if",
"self",
".",
"_dtype",
"is",
"not",
"None",
":",
"return",
"self",
".",
"_dtype",
"dtype",
"=",
"[",
"]",
"# Convert struct data types to numpy data type",
"for",
"i",
",",
"typ",
"in",
"enumerate",
"(",
"self",
".",
"typlist",
")",
":",
"if",
"typ",
"in",
"self",
".",
"NUMPY_TYPE_MAP",
":",
"dtype",
".",
"append",
"(",
"(",
"'s'",
"+",
"str",
"(",
"i",
")",
",",
"self",
".",
"byteorder",
"+",
"self",
".",
"NUMPY_TYPE_MAP",
"[",
"typ",
"]",
")",
")",
"else",
":",
"dtype",
".",
"append",
"(",
"(",
"'s'",
"+",
"str",
"(",
"i",
")",
",",
"'S'",
"+",
"str",
"(",
"typ",
")",
")",
")",
"dtype",
"=",
"np",
".",
"dtype",
"(",
"dtype",
")",
"self",
".",
"_dtype",
"=",
"dtype",
"return",
"self",
".",
"_dtype"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataReader._do_convert_categoricals | Converts categorical columns to Categorical type. | pandas/io/stata.py | def _do_convert_categoricals(self, data, value_label_dict, lbllist,
order_categoricals):
"""
Converts categorical columns to Categorical type.
"""
value_labels = list(value_label_dict.keys())
cat_converted_data = []
for col, label in zip(data, lbllist):
if label in value_labels:
# Explicit call with ordered=True
cat_data = Categorical(data[col], ordered=order_categoricals)
categories = []
for category in cat_data.categories:
if category in value_label_dict[label]:
categories.append(value_label_dict[label][category])
else:
categories.append(category) # Partially labeled
try:
cat_data.categories = categories
except ValueError:
vc = Series(categories).value_counts()
repeats = list(vc.index[vc > 1])
repeats = '-' * 80 + '\n' + '\n'.join(repeats)
# GH 25772
msg = """
Value labels for column {col} are not unique. These cannot be converted to
pandas categoricals.
Either read the file with `convert_categoricals` set to False or use the
low level interface in `StataReader` to separately read the values and the
value_labels.
The repeated labels are:
{repeats}
"""
raise ValueError(msg.format(col=col, repeats=repeats))
# TODO: is the next line needed above in the data(...) method?
cat_data = Series(cat_data, index=data.index)
cat_converted_data.append((col, cat_data))
else:
cat_converted_data.append((col, data[col]))
data = DataFrame.from_dict(OrderedDict(cat_converted_data))
return data | def _do_convert_categoricals(self, data, value_label_dict, lbllist,
order_categoricals):
"""
Converts categorical columns to Categorical type.
"""
value_labels = list(value_label_dict.keys())
cat_converted_data = []
for col, label in zip(data, lbllist):
if label in value_labels:
# Explicit call with ordered=True
cat_data = Categorical(data[col], ordered=order_categoricals)
categories = []
for category in cat_data.categories:
if category in value_label_dict[label]:
categories.append(value_label_dict[label][category])
else:
categories.append(category) # Partially labeled
try:
cat_data.categories = categories
except ValueError:
vc = Series(categories).value_counts()
repeats = list(vc.index[vc > 1])
repeats = '-' * 80 + '\n' + '\n'.join(repeats)
# GH 25772
msg = """
Value labels for column {col} are not unique. These cannot be converted to
pandas categoricals.
Either read the file with `convert_categoricals` set to False or use the
low level interface in `StataReader` to separately read the values and the
value_labels.
The repeated labels are:
{repeats}
"""
raise ValueError(msg.format(col=col, repeats=repeats))
# TODO: is the next line needed above in the data(...) method?
cat_data = Series(cat_data, index=data.index)
cat_converted_data.append((col, cat_data))
else:
cat_converted_data.append((col, data[col]))
data = DataFrame.from_dict(OrderedDict(cat_converted_data))
return data | [
"Converts",
"categorical",
"columns",
"to",
"Categorical",
"type",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L1698-L1740 | [
"def",
"_do_convert_categoricals",
"(",
"self",
",",
"data",
",",
"value_label_dict",
",",
"lbllist",
",",
"order_categoricals",
")",
":",
"value_labels",
"=",
"list",
"(",
"value_label_dict",
".",
"keys",
"(",
")",
")",
"cat_converted_data",
"=",
"[",
"]",
"for",
"col",
",",
"label",
"in",
"zip",
"(",
"data",
",",
"lbllist",
")",
":",
"if",
"label",
"in",
"value_labels",
":",
"# Explicit call with ordered=True",
"cat_data",
"=",
"Categorical",
"(",
"data",
"[",
"col",
"]",
",",
"ordered",
"=",
"order_categoricals",
")",
"categories",
"=",
"[",
"]",
"for",
"category",
"in",
"cat_data",
".",
"categories",
":",
"if",
"category",
"in",
"value_label_dict",
"[",
"label",
"]",
":",
"categories",
".",
"append",
"(",
"value_label_dict",
"[",
"label",
"]",
"[",
"category",
"]",
")",
"else",
":",
"categories",
".",
"append",
"(",
"category",
")",
"# Partially labeled",
"try",
":",
"cat_data",
".",
"categories",
"=",
"categories",
"except",
"ValueError",
":",
"vc",
"=",
"Series",
"(",
"categories",
")",
".",
"value_counts",
"(",
")",
"repeats",
"=",
"list",
"(",
"vc",
".",
"index",
"[",
"vc",
">",
"1",
"]",
")",
"repeats",
"=",
"'-'",
"*",
"80",
"+",
"'\\n'",
"+",
"'\\n'",
".",
"join",
"(",
"repeats",
")",
"# GH 25772",
"msg",
"=",
"\"\"\"\nValue labels for column {col} are not unique. These cannot be converted to\npandas categoricals.\n\nEither read the file with `convert_categoricals` set to False or use the\nlow level interface in `StataReader` to separately read the values and the\nvalue_labels.\n\nThe repeated labels are:\n{repeats}\n\"\"\"",
"raise",
"ValueError",
"(",
"msg",
".",
"format",
"(",
"col",
"=",
"col",
",",
"repeats",
"=",
"repeats",
")",
")",
"# TODO: is the next line needed above in the data(...) method?",
"cat_data",
"=",
"Series",
"(",
"cat_data",
",",
"index",
"=",
"data",
".",
"index",
")",
"cat_converted_data",
".",
"append",
"(",
"(",
"col",
",",
"cat_data",
")",
")",
"else",
":",
"cat_converted_data",
".",
"append",
"(",
"(",
"col",
",",
"data",
"[",
"col",
"]",
")",
")",
"data",
"=",
"DataFrame",
".",
"from_dict",
"(",
"OrderedDict",
"(",
"cat_converted_data",
")",
")",
"return",
"data"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataWriter._write | Helper to call encode before writing to file for Python 3 compat. | pandas/io/stata.py | def _write(self, to_write):
"""
Helper to call encode before writing to file for Python 3 compat.
"""
self._file.write(to_write.encode(self._encoding or
self._default_encoding)) | def _write(self, to_write):
"""
Helper to call encode before writing to file for Python 3 compat.
"""
self._file.write(to_write.encode(self._encoding or
self._default_encoding)) | [
"Helper",
"to",
"call",
"encode",
"before",
"writing",
"to",
"file",
"for",
"Python",
"3",
"compat",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2018-L2023 | [
"def",
"_write",
"(",
"self",
",",
"to_write",
")",
":",
"self",
".",
"_file",
".",
"write",
"(",
"to_write",
".",
"encode",
"(",
"self",
".",
"_encoding",
"or",
"self",
".",
"_default_encoding",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataWriter._prepare_categoricals | Check for categorical columns, retain categorical information for
Stata file and convert categorical data to int | pandas/io/stata.py | def _prepare_categoricals(self, data):
"""Check for categorical columns, retain categorical information for
Stata file and convert categorical data to int"""
is_cat = [is_categorical_dtype(data[col]) for col in data]
self._is_col_cat = is_cat
self._value_labels = []
if not any(is_cat):
return data
get_base_missing_value = StataMissingValue.get_base_missing_value
data_formatted = []
for col, col_is_cat in zip(data, is_cat):
if col_is_cat:
self._value_labels.append(StataValueLabel(data[col]))
dtype = data[col].cat.codes.dtype
if dtype == np.int64:
raise ValueError('It is not possible to export '
'int64-based categorical data to Stata.')
values = data[col].cat.codes.values.copy()
# Upcast if needed so that correct missing values can be set
if values.max() >= get_base_missing_value(dtype):
if dtype == np.int8:
dtype = np.int16
elif dtype == np.int16:
dtype = np.int32
else:
dtype = np.float64
values = np.array(values, dtype=dtype)
# Replace missing values with Stata missing value for type
values[values == -1] = get_base_missing_value(dtype)
data_formatted.append((col, values))
else:
data_formatted.append((col, data[col]))
return DataFrame.from_dict(OrderedDict(data_formatted)) | def _prepare_categoricals(self, data):
"""Check for categorical columns, retain categorical information for
Stata file and convert categorical data to int"""
is_cat = [is_categorical_dtype(data[col]) for col in data]
self._is_col_cat = is_cat
self._value_labels = []
if not any(is_cat):
return data
get_base_missing_value = StataMissingValue.get_base_missing_value
data_formatted = []
for col, col_is_cat in zip(data, is_cat):
if col_is_cat:
self._value_labels.append(StataValueLabel(data[col]))
dtype = data[col].cat.codes.dtype
if dtype == np.int64:
raise ValueError('It is not possible to export '
'int64-based categorical data to Stata.')
values = data[col].cat.codes.values.copy()
# Upcast if needed so that correct missing values can be set
if values.max() >= get_base_missing_value(dtype):
if dtype == np.int8:
dtype = np.int16
elif dtype == np.int16:
dtype = np.int32
else:
dtype = np.float64
values = np.array(values, dtype=dtype)
# Replace missing values with Stata missing value for type
values[values == -1] = get_base_missing_value(dtype)
data_formatted.append((col, values))
else:
data_formatted.append((col, data[col]))
return DataFrame.from_dict(OrderedDict(data_formatted)) | [
"Check",
"for",
"categorical",
"columns",
"retain",
"categorical",
"information",
"for",
"Stata",
"file",
"and",
"convert",
"categorical",
"data",
"to",
"int"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2025-L2061 | [
"def",
"_prepare_categoricals",
"(",
"self",
",",
"data",
")",
":",
"is_cat",
"=",
"[",
"is_categorical_dtype",
"(",
"data",
"[",
"col",
"]",
")",
"for",
"col",
"in",
"data",
"]",
"self",
".",
"_is_col_cat",
"=",
"is_cat",
"self",
".",
"_value_labels",
"=",
"[",
"]",
"if",
"not",
"any",
"(",
"is_cat",
")",
":",
"return",
"data",
"get_base_missing_value",
"=",
"StataMissingValue",
".",
"get_base_missing_value",
"data_formatted",
"=",
"[",
"]",
"for",
"col",
",",
"col_is_cat",
"in",
"zip",
"(",
"data",
",",
"is_cat",
")",
":",
"if",
"col_is_cat",
":",
"self",
".",
"_value_labels",
".",
"append",
"(",
"StataValueLabel",
"(",
"data",
"[",
"col",
"]",
")",
")",
"dtype",
"=",
"data",
"[",
"col",
"]",
".",
"cat",
".",
"codes",
".",
"dtype",
"if",
"dtype",
"==",
"np",
".",
"int64",
":",
"raise",
"ValueError",
"(",
"'It is not possible to export '",
"'int64-based categorical data to Stata.'",
")",
"values",
"=",
"data",
"[",
"col",
"]",
".",
"cat",
".",
"codes",
".",
"values",
".",
"copy",
"(",
")",
"# Upcast if needed so that correct missing values can be set",
"if",
"values",
".",
"max",
"(",
")",
">=",
"get_base_missing_value",
"(",
"dtype",
")",
":",
"if",
"dtype",
"==",
"np",
".",
"int8",
":",
"dtype",
"=",
"np",
".",
"int16",
"elif",
"dtype",
"==",
"np",
".",
"int16",
":",
"dtype",
"=",
"np",
".",
"int32",
"else",
":",
"dtype",
"=",
"np",
".",
"float64",
"values",
"=",
"np",
".",
"array",
"(",
"values",
",",
"dtype",
"=",
"dtype",
")",
"# Replace missing values with Stata missing value for type",
"values",
"[",
"values",
"==",
"-",
"1",
"]",
"=",
"get_base_missing_value",
"(",
"dtype",
")",
"data_formatted",
".",
"append",
"(",
"(",
"col",
",",
"values",
")",
")",
"else",
":",
"data_formatted",
".",
"append",
"(",
"(",
"col",
",",
"data",
"[",
"col",
"]",
")",
")",
"return",
"DataFrame",
".",
"from_dict",
"(",
"OrderedDict",
"(",
"data_formatted",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataWriter._replace_nans | Checks floating point data columns for nans, and replaces these with
the generic Stata for missing value (.) | pandas/io/stata.py | def _replace_nans(self, data):
# return data
"""Checks floating point data columns for nans, and replaces these with
the generic Stata for missing value (.)"""
for c in data:
dtype = data[c].dtype
if dtype in (np.float32, np.float64):
if dtype == np.float32:
replacement = self.MISSING_VALUES['f']
else:
replacement = self.MISSING_VALUES['d']
data[c] = data[c].fillna(replacement)
return data | def _replace_nans(self, data):
# return data
"""Checks floating point data columns for nans, and replaces these with
the generic Stata for missing value (.)"""
for c in data:
dtype = data[c].dtype
if dtype in (np.float32, np.float64):
if dtype == np.float32:
replacement = self.MISSING_VALUES['f']
else:
replacement = self.MISSING_VALUES['d']
data[c] = data[c].fillna(replacement)
return data | [
"Checks",
"floating",
"point",
"data",
"columns",
"for",
"nans",
"and",
"replaces",
"these",
"with",
"the",
"generic",
"Stata",
"for",
"missing",
"value",
"(",
".",
")"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2063-L2076 | [
"def",
"_replace_nans",
"(",
"self",
",",
"data",
")",
":",
"# return data",
"for",
"c",
"in",
"data",
":",
"dtype",
"=",
"data",
"[",
"c",
"]",
".",
"dtype",
"if",
"dtype",
"in",
"(",
"np",
".",
"float32",
",",
"np",
".",
"float64",
")",
":",
"if",
"dtype",
"==",
"np",
".",
"float32",
":",
"replacement",
"=",
"self",
".",
"MISSING_VALUES",
"[",
"'f'",
"]",
"else",
":",
"replacement",
"=",
"self",
".",
"MISSING_VALUES",
"[",
"'d'",
"]",
"data",
"[",
"c",
"]",
"=",
"data",
"[",
"c",
"]",
".",
"fillna",
"(",
"replacement",
")",
"return",
"data"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataWriter._check_column_names | Checks column names to ensure that they are valid Stata column names.
This includes checks for:
* Non-string names
* Stata keywords
* Variables that start with numbers
* Variables with names that are too long
When an illegal variable name is detected, it is converted, and if
dates are exported, the variable name is propagated to the date
conversion dictionary | pandas/io/stata.py | def _check_column_names(self, data):
"""
Checks column names to ensure that they are valid Stata column names.
This includes checks for:
* Non-string names
* Stata keywords
* Variables that start with numbers
* Variables with names that are too long
When an illegal variable name is detected, it is converted, and if
dates are exported, the variable name is propagated to the date
conversion dictionary
"""
converted_names = {}
columns = list(data.columns)
original_columns = columns[:]
duplicate_var_id = 0
for j, name in enumerate(columns):
orig_name = name
if not isinstance(name, str):
name = str(name)
for c in name:
if ((c < 'A' or c > 'Z') and (c < 'a' or c > 'z') and
(c < '0' or c > '9') and c != '_'):
name = name.replace(c, '_')
# Variable name must not be a reserved word
if name in self.RESERVED_WORDS:
name = '_' + name
# Variable name may not start with a number
if name[0] >= '0' and name[0] <= '9':
name = '_' + name
name = name[:min(len(name), 32)]
if not name == orig_name:
# check for duplicates
while columns.count(name) > 0:
# prepend ascending number to avoid duplicates
name = '_' + str(duplicate_var_id) + name
name = name[:min(len(name), 32)]
duplicate_var_id += 1
converted_names[orig_name] = name
columns[j] = name
data.columns = columns
# Check date conversion, and fix key if needed
if self._convert_dates:
for c, o in zip(columns, original_columns):
if c != o:
self._convert_dates[c] = self._convert_dates[o]
del self._convert_dates[o]
if converted_names:
conversion_warning = []
for orig_name, name in converted_names.items():
# need to possibly encode the orig name if its unicode
try:
orig_name = orig_name.encode('utf-8')
except (UnicodeDecodeError, AttributeError):
pass
msg = '{0} -> {1}'.format(orig_name, name)
conversion_warning.append(msg)
ws = invalid_name_doc.format('\n '.join(conversion_warning))
warnings.warn(ws, InvalidColumnName)
self._converted_names = converted_names
self._update_strl_names()
return data | def _check_column_names(self, data):
"""
Checks column names to ensure that they are valid Stata column names.
This includes checks for:
* Non-string names
* Stata keywords
* Variables that start with numbers
* Variables with names that are too long
When an illegal variable name is detected, it is converted, and if
dates are exported, the variable name is propagated to the date
conversion dictionary
"""
converted_names = {}
columns = list(data.columns)
original_columns = columns[:]
duplicate_var_id = 0
for j, name in enumerate(columns):
orig_name = name
if not isinstance(name, str):
name = str(name)
for c in name:
if ((c < 'A' or c > 'Z') and (c < 'a' or c > 'z') and
(c < '0' or c > '9') and c != '_'):
name = name.replace(c, '_')
# Variable name must not be a reserved word
if name in self.RESERVED_WORDS:
name = '_' + name
# Variable name may not start with a number
if name[0] >= '0' and name[0] <= '9':
name = '_' + name
name = name[:min(len(name), 32)]
if not name == orig_name:
# check for duplicates
while columns.count(name) > 0:
# prepend ascending number to avoid duplicates
name = '_' + str(duplicate_var_id) + name
name = name[:min(len(name), 32)]
duplicate_var_id += 1
converted_names[orig_name] = name
columns[j] = name
data.columns = columns
# Check date conversion, and fix key if needed
if self._convert_dates:
for c, o in zip(columns, original_columns):
if c != o:
self._convert_dates[c] = self._convert_dates[o]
del self._convert_dates[o]
if converted_names:
conversion_warning = []
for orig_name, name in converted_names.items():
# need to possibly encode the orig name if its unicode
try:
orig_name = orig_name.encode('utf-8')
except (UnicodeDecodeError, AttributeError):
pass
msg = '{0} -> {1}'.format(orig_name, name)
conversion_warning.append(msg)
ws = invalid_name_doc.format('\n '.join(conversion_warning))
warnings.warn(ws, InvalidColumnName)
self._converted_names = converted_names
self._update_strl_names()
return data | [
"Checks",
"column",
"names",
"to",
"ensure",
"that",
"they",
"are",
"valid",
"Stata",
"column",
"names",
".",
"This",
"includes",
"checks",
"for",
":",
"*",
"Non",
"-",
"string",
"names",
"*",
"Stata",
"keywords",
"*",
"Variables",
"that",
"start",
"with",
"numbers",
"*",
"Variables",
"with",
"names",
"that",
"are",
"too",
"long"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2082-L2157 | [
"def",
"_check_column_names",
"(",
"self",
",",
"data",
")",
":",
"converted_names",
"=",
"{",
"}",
"columns",
"=",
"list",
"(",
"data",
".",
"columns",
")",
"original_columns",
"=",
"columns",
"[",
":",
"]",
"duplicate_var_id",
"=",
"0",
"for",
"j",
",",
"name",
"in",
"enumerate",
"(",
"columns",
")",
":",
"orig_name",
"=",
"name",
"if",
"not",
"isinstance",
"(",
"name",
",",
"str",
")",
":",
"name",
"=",
"str",
"(",
"name",
")",
"for",
"c",
"in",
"name",
":",
"if",
"(",
"(",
"c",
"<",
"'A'",
"or",
"c",
">",
"'Z'",
")",
"and",
"(",
"c",
"<",
"'a'",
"or",
"c",
">",
"'z'",
")",
"and",
"(",
"c",
"<",
"'0'",
"or",
"c",
">",
"'9'",
")",
"and",
"c",
"!=",
"'_'",
")",
":",
"name",
"=",
"name",
".",
"replace",
"(",
"c",
",",
"'_'",
")",
"# Variable name must not be a reserved word",
"if",
"name",
"in",
"self",
".",
"RESERVED_WORDS",
":",
"name",
"=",
"'_'",
"+",
"name",
"# Variable name may not start with a number",
"if",
"name",
"[",
"0",
"]",
">=",
"'0'",
"and",
"name",
"[",
"0",
"]",
"<=",
"'9'",
":",
"name",
"=",
"'_'",
"+",
"name",
"name",
"=",
"name",
"[",
":",
"min",
"(",
"len",
"(",
"name",
")",
",",
"32",
")",
"]",
"if",
"not",
"name",
"==",
"orig_name",
":",
"# check for duplicates",
"while",
"columns",
".",
"count",
"(",
"name",
")",
">",
"0",
":",
"# prepend ascending number to avoid duplicates",
"name",
"=",
"'_'",
"+",
"str",
"(",
"duplicate_var_id",
")",
"+",
"name",
"name",
"=",
"name",
"[",
":",
"min",
"(",
"len",
"(",
"name",
")",
",",
"32",
")",
"]",
"duplicate_var_id",
"+=",
"1",
"converted_names",
"[",
"orig_name",
"]",
"=",
"name",
"columns",
"[",
"j",
"]",
"=",
"name",
"data",
".",
"columns",
"=",
"columns",
"# Check date conversion, and fix key if needed",
"if",
"self",
".",
"_convert_dates",
":",
"for",
"c",
",",
"o",
"in",
"zip",
"(",
"columns",
",",
"original_columns",
")",
":",
"if",
"c",
"!=",
"o",
":",
"self",
".",
"_convert_dates",
"[",
"c",
"]",
"=",
"self",
".",
"_convert_dates",
"[",
"o",
"]",
"del",
"self",
".",
"_convert_dates",
"[",
"o",
"]",
"if",
"converted_names",
":",
"conversion_warning",
"=",
"[",
"]",
"for",
"orig_name",
",",
"name",
"in",
"converted_names",
".",
"items",
"(",
")",
":",
"# need to possibly encode the orig name if its unicode",
"try",
":",
"orig_name",
"=",
"orig_name",
".",
"encode",
"(",
"'utf-8'",
")",
"except",
"(",
"UnicodeDecodeError",
",",
"AttributeError",
")",
":",
"pass",
"msg",
"=",
"'{0} -> {1}'",
".",
"format",
"(",
"orig_name",
",",
"name",
")",
"conversion_warning",
".",
"append",
"(",
"msg",
")",
"ws",
"=",
"invalid_name_doc",
".",
"format",
"(",
"'\\n '",
".",
"join",
"(",
"conversion_warning",
")",
")",
"warnings",
".",
"warn",
"(",
"ws",
",",
"InvalidColumnName",
")",
"self",
".",
"_converted_names",
"=",
"converted_names",
"self",
".",
"_update_strl_names",
"(",
")",
"return",
"data"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataWriter._close | Close the file if it was created by the writer.
If a buffer or file-like object was passed in, for example a GzipFile,
then leave this file open for the caller to close. In either case,
attempt to flush the file contents to ensure they are written to disk
(if supported) | pandas/io/stata.py | def _close(self):
"""
Close the file if it was created by the writer.
If a buffer or file-like object was passed in, for example a GzipFile,
then leave this file open for the caller to close. In either case,
attempt to flush the file contents to ensure they are written to disk
(if supported)
"""
# Some file-like objects might not support flush
try:
self._file.flush()
except AttributeError:
pass
if self._own_file:
self._file.close() | def _close(self):
"""
Close the file if it was created by the writer.
If a buffer or file-like object was passed in, for example a GzipFile,
then leave this file open for the caller to close. In either case,
attempt to flush the file contents to ensure they are written to disk
(if supported)
"""
# Some file-like objects might not support flush
try:
self._file.flush()
except AttributeError:
pass
if self._own_file:
self._file.close() | [
"Close",
"the",
"file",
"if",
"it",
"was",
"created",
"by",
"the",
"writer",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2249-L2264 | [
"def",
"_close",
"(",
"self",
")",
":",
"# Some file-like objects might not support flush",
"try",
":",
"self",
".",
"_file",
".",
"flush",
"(",
")",
"except",
"AttributeError",
":",
"pass",
"if",
"self",
".",
"_own_file",
":",
"self",
".",
"_file",
".",
"close",
"(",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataStrLWriter.generate_table | Generates the GSO lookup table for the DataFRame
Returns
-------
gso_table : OrderedDict
Ordered dictionary using the string found as keys
and their lookup position (v,o) as values
gso_df : DataFrame
DataFrame where strl columns have been converted to
(v,o) values
Notes
-----
Modifies the DataFrame in-place.
The DataFrame returned encodes the (v,o) values as uint64s. The
encoding depends on teh dta version, and can be expressed as
enc = v + o * 2 ** (o_size * 8)
so that v is stored in the lower bits and o is in the upper
bits. o_size is
* 117: 4
* 118: 6
* 119: 5 | pandas/io/stata.py | def generate_table(self):
"""
Generates the GSO lookup table for the DataFRame
Returns
-------
gso_table : OrderedDict
Ordered dictionary using the string found as keys
and their lookup position (v,o) as values
gso_df : DataFrame
DataFrame where strl columns have been converted to
(v,o) values
Notes
-----
Modifies the DataFrame in-place.
The DataFrame returned encodes the (v,o) values as uint64s. The
encoding depends on teh dta version, and can be expressed as
enc = v + o * 2 ** (o_size * 8)
so that v is stored in the lower bits and o is in the upper
bits. o_size is
* 117: 4
* 118: 6
* 119: 5
"""
gso_table = self._gso_table
gso_df = self.df
columns = list(gso_df.columns)
selected = gso_df[self.columns]
col_index = [(col, columns.index(col)) for col in self.columns]
keys = np.empty(selected.shape, dtype=np.uint64)
for o, (idx, row) in enumerate(selected.iterrows()):
for j, (col, v) in enumerate(col_index):
val = row[col]
# Allow columns with mixed str and None (GH 23633)
val = '' if val is None else val
key = gso_table.get(val, None)
if key is None:
# Stata prefers human numbers
key = (v + 1, o + 1)
gso_table[val] = key
keys[o, j] = self._convert_key(key)
for i, col in enumerate(self.columns):
gso_df[col] = keys[:, i]
return gso_table, gso_df | def generate_table(self):
"""
Generates the GSO lookup table for the DataFRame
Returns
-------
gso_table : OrderedDict
Ordered dictionary using the string found as keys
and their lookup position (v,o) as values
gso_df : DataFrame
DataFrame where strl columns have been converted to
(v,o) values
Notes
-----
Modifies the DataFrame in-place.
The DataFrame returned encodes the (v,o) values as uint64s. The
encoding depends on teh dta version, and can be expressed as
enc = v + o * 2 ** (o_size * 8)
so that v is stored in the lower bits and o is in the upper
bits. o_size is
* 117: 4
* 118: 6
* 119: 5
"""
gso_table = self._gso_table
gso_df = self.df
columns = list(gso_df.columns)
selected = gso_df[self.columns]
col_index = [(col, columns.index(col)) for col in self.columns]
keys = np.empty(selected.shape, dtype=np.uint64)
for o, (idx, row) in enumerate(selected.iterrows()):
for j, (col, v) in enumerate(col_index):
val = row[col]
# Allow columns with mixed str and None (GH 23633)
val = '' if val is None else val
key = gso_table.get(val, None)
if key is None:
# Stata prefers human numbers
key = (v + 1, o + 1)
gso_table[val] = key
keys[o, j] = self._convert_key(key)
for i, col in enumerate(self.columns):
gso_df[col] = keys[:, i]
return gso_table, gso_df | [
"Generates",
"the",
"GSO",
"lookup",
"table",
"for",
"the",
"DataFRame"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2546-L2596 | [
"def",
"generate_table",
"(",
"self",
")",
":",
"gso_table",
"=",
"self",
".",
"_gso_table",
"gso_df",
"=",
"self",
".",
"df",
"columns",
"=",
"list",
"(",
"gso_df",
".",
"columns",
")",
"selected",
"=",
"gso_df",
"[",
"self",
".",
"columns",
"]",
"col_index",
"=",
"[",
"(",
"col",
",",
"columns",
".",
"index",
"(",
"col",
")",
")",
"for",
"col",
"in",
"self",
".",
"columns",
"]",
"keys",
"=",
"np",
".",
"empty",
"(",
"selected",
".",
"shape",
",",
"dtype",
"=",
"np",
".",
"uint64",
")",
"for",
"o",
",",
"(",
"idx",
",",
"row",
")",
"in",
"enumerate",
"(",
"selected",
".",
"iterrows",
"(",
")",
")",
":",
"for",
"j",
",",
"(",
"col",
",",
"v",
")",
"in",
"enumerate",
"(",
"col_index",
")",
":",
"val",
"=",
"row",
"[",
"col",
"]",
"# Allow columns with mixed str and None (GH 23633)",
"val",
"=",
"''",
"if",
"val",
"is",
"None",
"else",
"val",
"key",
"=",
"gso_table",
".",
"get",
"(",
"val",
",",
"None",
")",
"if",
"key",
"is",
"None",
":",
"# Stata prefers human numbers",
"key",
"=",
"(",
"v",
"+",
"1",
",",
"o",
"+",
"1",
")",
"gso_table",
"[",
"val",
"]",
"=",
"key",
"keys",
"[",
"o",
",",
"j",
"]",
"=",
"self",
".",
"_convert_key",
"(",
"key",
")",
"for",
"i",
",",
"col",
"in",
"enumerate",
"(",
"self",
".",
"columns",
")",
":",
"gso_df",
"[",
"col",
"]",
"=",
"keys",
"[",
":",
",",
"i",
"]",
"return",
"gso_table",
",",
"gso_df"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataStrLWriter.generate_blob | Generates the binary blob of GSOs that is written to the dta file.
Parameters
----------
gso_table : OrderedDict
Ordered dictionary (str, vo)
Returns
-------
gso : bytes
Binary content of dta file to be placed between strl tags
Notes
-----
Output format depends on dta version. 117 uses two uint32s to
express v and o while 118+ uses a uint32 for v and a uint64 for o. | pandas/io/stata.py | def generate_blob(self, gso_table):
"""
Generates the binary blob of GSOs that is written to the dta file.
Parameters
----------
gso_table : OrderedDict
Ordered dictionary (str, vo)
Returns
-------
gso : bytes
Binary content of dta file to be placed between strl tags
Notes
-----
Output format depends on dta version. 117 uses two uint32s to
express v and o while 118+ uses a uint32 for v and a uint64 for o.
"""
# Format information
# Length includes null term
# 117
# GSOvvvvooootllllxxxxxxxxxxxxxxx...x
# 3 u4 u4 u1 u4 string + null term
#
# 118, 119
# GSOvvvvooooooootllllxxxxxxxxxxxxxxx...x
# 3 u4 u8 u1 u4 string + null term
bio = BytesIO()
gso = bytes('GSO', 'ascii')
gso_type = struct.pack(self._byteorder + 'B', 130)
null = struct.pack(self._byteorder + 'B', 0)
v_type = self._byteorder + self._gso_v_type
o_type = self._byteorder + self._gso_o_type
len_type = self._byteorder + 'I'
for strl, vo in gso_table.items():
if vo == (0, 0):
continue
v, o = vo
# GSO
bio.write(gso)
# vvvv
bio.write(struct.pack(v_type, v))
# oooo / oooooooo
bio.write(struct.pack(o_type, o))
# t
bio.write(gso_type)
# llll
utf8_string = bytes(strl, 'utf-8')
bio.write(struct.pack(len_type, len(utf8_string) + 1))
# xxx...xxx
bio.write(utf8_string)
bio.write(null)
bio.seek(0)
return bio.read() | def generate_blob(self, gso_table):
"""
Generates the binary blob of GSOs that is written to the dta file.
Parameters
----------
gso_table : OrderedDict
Ordered dictionary (str, vo)
Returns
-------
gso : bytes
Binary content of dta file to be placed between strl tags
Notes
-----
Output format depends on dta version. 117 uses two uint32s to
express v and o while 118+ uses a uint32 for v and a uint64 for o.
"""
# Format information
# Length includes null term
# 117
# GSOvvvvooootllllxxxxxxxxxxxxxxx...x
# 3 u4 u4 u1 u4 string + null term
#
# 118, 119
# GSOvvvvooooooootllllxxxxxxxxxxxxxxx...x
# 3 u4 u8 u1 u4 string + null term
bio = BytesIO()
gso = bytes('GSO', 'ascii')
gso_type = struct.pack(self._byteorder + 'B', 130)
null = struct.pack(self._byteorder + 'B', 0)
v_type = self._byteorder + self._gso_v_type
o_type = self._byteorder + self._gso_o_type
len_type = self._byteorder + 'I'
for strl, vo in gso_table.items():
if vo == (0, 0):
continue
v, o = vo
# GSO
bio.write(gso)
# vvvv
bio.write(struct.pack(v_type, v))
# oooo / oooooooo
bio.write(struct.pack(o_type, o))
# t
bio.write(gso_type)
# llll
utf8_string = bytes(strl, 'utf-8')
bio.write(struct.pack(len_type, len(utf8_string) + 1))
# xxx...xxx
bio.write(utf8_string)
bio.write(null)
bio.seek(0)
return bio.read() | [
"Generates",
"the",
"binary",
"blob",
"of",
"GSOs",
"that",
"is",
"written",
"to",
"the",
"dta",
"file",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2604-L2666 | [
"def",
"generate_blob",
"(",
"self",
",",
"gso_table",
")",
":",
"# Format information",
"# Length includes null term",
"# 117",
"# GSOvvvvooootllllxxxxxxxxxxxxxxx...x",
"# 3 u4 u4 u1 u4 string + null term",
"#",
"# 118, 119",
"# GSOvvvvooooooootllllxxxxxxxxxxxxxxx...x",
"# 3 u4 u8 u1 u4 string + null term",
"bio",
"=",
"BytesIO",
"(",
")",
"gso",
"=",
"bytes",
"(",
"'GSO'",
",",
"'ascii'",
")",
"gso_type",
"=",
"struct",
".",
"pack",
"(",
"self",
".",
"_byteorder",
"+",
"'B'",
",",
"130",
")",
"null",
"=",
"struct",
".",
"pack",
"(",
"self",
".",
"_byteorder",
"+",
"'B'",
",",
"0",
")",
"v_type",
"=",
"self",
".",
"_byteorder",
"+",
"self",
".",
"_gso_v_type",
"o_type",
"=",
"self",
".",
"_byteorder",
"+",
"self",
".",
"_gso_o_type",
"len_type",
"=",
"self",
".",
"_byteorder",
"+",
"'I'",
"for",
"strl",
",",
"vo",
"in",
"gso_table",
".",
"items",
"(",
")",
":",
"if",
"vo",
"==",
"(",
"0",
",",
"0",
")",
":",
"continue",
"v",
",",
"o",
"=",
"vo",
"# GSO",
"bio",
".",
"write",
"(",
"gso",
")",
"# vvvv",
"bio",
".",
"write",
"(",
"struct",
".",
"pack",
"(",
"v_type",
",",
"v",
")",
")",
"# oooo / oooooooo",
"bio",
".",
"write",
"(",
"struct",
".",
"pack",
"(",
"o_type",
",",
"o",
")",
")",
"# t",
"bio",
".",
"write",
"(",
"gso_type",
")",
"# llll",
"utf8_string",
"=",
"bytes",
"(",
"strl",
",",
"'utf-8'",
")",
"bio",
".",
"write",
"(",
"struct",
".",
"pack",
"(",
"len_type",
",",
"len",
"(",
"utf8_string",
")",
"+",
"1",
")",
")",
"# xxx...xxx",
"bio",
".",
"write",
"(",
"utf8_string",
")",
"bio",
".",
"write",
"(",
"null",
")",
"bio",
".",
"seek",
"(",
"0",
")",
"return",
"bio",
".",
"read",
"(",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataWriter117._tag | Surround val with <tag></tag> | pandas/io/stata.py | def _tag(val, tag):
"""Surround val with <tag></tag>"""
if isinstance(val, str):
val = bytes(val, 'utf-8')
return (bytes('<' + tag + '>', 'utf-8') + val +
bytes('</' + tag + '>', 'utf-8')) | def _tag(val, tag):
"""Surround val with <tag></tag>"""
if isinstance(val, str):
val = bytes(val, 'utf-8')
return (bytes('<' + tag + '>', 'utf-8') + val +
bytes('</' + tag + '>', 'utf-8')) | [
"Surround",
"val",
"with",
"<tag",
">",
"<",
"/",
"tag",
">"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2761-L2766 | [
"def",
"_tag",
"(",
"val",
",",
"tag",
")",
":",
"if",
"isinstance",
"(",
"val",
",",
"str",
")",
":",
"val",
"=",
"bytes",
"(",
"val",
",",
"'utf-8'",
")",
"return",
"(",
"bytes",
"(",
"'<'",
"+",
"tag",
"+",
"'>'",
",",
"'utf-8'",
")",
"+",
"val",
"+",
"bytes",
"(",
"'</'",
"+",
"tag",
"+",
"'>'",
",",
"'utf-8'",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataWriter117._write_header | Write the file header | pandas/io/stata.py | def _write_header(self, data_label=None, time_stamp=None):
"""Write the file header"""
byteorder = self._byteorder
self._file.write(bytes('<stata_dta>', 'utf-8'))
bio = BytesIO()
# ds_format - 117
bio.write(self._tag(bytes('117', 'utf-8'), 'release'))
# byteorder
bio.write(self._tag(byteorder == ">" and "MSF" or "LSF", 'byteorder'))
# number of vars, 2 bytes
assert self.nvar < 2 ** 16
bio.write(self._tag(struct.pack(byteorder + "H", self.nvar), 'K'))
# number of obs, 4 bytes
bio.write(self._tag(struct.pack(byteorder + "I", self.nobs), 'N'))
# data label 81 bytes, char, null terminated
label = data_label[:80] if data_label is not None else ''
label_len = struct.pack(byteorder + "B", len(label))
label = label_len + bytes(label, 'utf-8')
bio.write(self._tag(label, 'label'))
# time stamp, 18 bytes, char, null terminated
# format dd Mon yyyy hh:mm
if time_stamp is None:
time_stamp = datetime.datetime.now()
elif not isinstance(time_stamp, datetime.datetime):
raise ValueError("time_stamp should be datetime type")
# Avoid locale-specific month conversion
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
'Sep', 'Oct', 'Nov', 'Dec']
month_lookup = {i + 1: month for i, month in enumerate(months)}
ts = (time_stamp.strftime("%d ") +
month_lookup[time_stamp.month] +
time_stamp.strftime(" %Y %H:%M"))
# '\x11' added due to inspection of Stata file
ts = b'\x11' + bytes(ts, 'utf8')
bio.write(self._tag(ts, 'timestamp'))
bio.seek(0)
self._file.write(self._tag(bio.read(), 'header')) | def _write_header(self, data_label=None, time_stamp=None):
"""Write the file header"""
byteorder = self._byteorder
self._file.write(bytes('<stata_dta>', 'utf-8'))
bio = BytesIO()
# ds_format - 117
bio.write(self._tag(bytes('117', 'utf-8'), 'release'))
# byteorder
bio.write(self._tag(byteorder == ">" and "MSF" or "LSF", 'byteorder'))
# number of vars, 2 bytes
assert self.nvar < 2 ** 16
bio.write(self._tag(struct.pack(byteorder + "H", self.nvar), 'K'))
# number of obs, 4 bytes
bio.write(self._tag(struct.pack(byteorder + "I", self.nobs), 'N'))
# data label 81 bytes, char, null terminated
label = data_label[:80] if data_label is not None else ''
label_len = struct.pack(byteorder + "B", len(label))
label = label_len + bytes(label, 'utf-8')
bio.write(self._tag(label, 'label'))
# time stamp, 18 bytes, char, null terminated
# format dd Mon yyyy hh:mm
if time_stamp is None:
time_stamp = datetime.datetime.now()
elif not isinstance(time_stamp, datetime.datetime):
raise ValueError("time_stamp should be datetime type")
# Avoid locale-specific month conversion
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
'Sep', 'Oct', 'Nov', 'Dec']
month_lookup = {i + 1: month for i, month in enumerate(months)}
ts = (time_stamp.strftime("%d ") +
month_lookup[time_stamp.month] +
time_stamp.strftime(" %Y %H:%M"))
# '\x11' added due to inspection of Stata file
ts = b'\x11' + bytes(ts, 'utf8')
bio.write(self._tag(ts, 'timestamp'))
bio.seek(0)
self._file.write(self._tag(bio.read(), 'header')) | [
"Write",
"the",
"file",
"header"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2772-L2808 | [
"def",
"_write_header",
"(",
"self",
",",
"data_label",
"=",
"None",
",",
"time_stamp",
"=",
"None",
")",
":",
"byteorder",
"=",
"self",
".",
"_byteorder",
"self",
".",
"_file",
".",
"write",
"(",
"bytes",
"(",
"'<stata_dta>'",
",",
"'utf-8'",
")",
")",
"bio",
"=",
"BytesIO",
"(",
")",
"# ds_format - 117",
"bio",
".",
"write",
"(",
"self",
".",
"_tag",
"(",
"bytes",
"(",
"'117'",
",",
"'utf-8'",
")",
",",
"'release'",
")",
")",
"# byteorder",
"bio",
".",
"write",
"(",
"self",
".",
"_tag",
"(",
"byteorder",
"==",
"\">\"",
"and",
"\"MSF\"",
"or",
"\"LSF\"",
",",
"'byteorder'",
")",
")",
"# number of vars, 2 bytes",
"assert",
"self",
".",
"nvar",
"<",
"2",
"**",
"16",
"bio",
".",
"write",
"(",
"self",
".",
"_tag",
"(",
"struct",
".",
"pack",
"(",
"byteorder",
"+",
"\"H\"",
",",
"self",
".",
"nvar",
")",
",",
"'K'",
")",
")",
"# number of obs, 4 bytes",
"bio",
".",
"write",
"(",
"self",
".",
"_tag",
"(",
"struct",
".",
"pack",
"(",
"byteorder",
"+",
"\"I\"",
",",
"self",
".",
"nobs",
")",
",",
"'N'",
")",
")",
"# data label 81 bytes, char, null terminated",
"label",
"=",
"data_label",
"[",
":",
"80",
"]",
"if",
"data_label",
"is",
"not",
"None",
"else",
"''",
"label_len",
"=",
"struct",
".",
"pack",
"(",
"byteorder",
"+",
"\"B\"",
",",
"len",
"(",
"label",
")",
")",
"label",
"=",
"label_len",
"+",
"bytes",
"(",
"label",
",",
"'utf-8'",
")",
"bio",
".",
"write",
"(",
"self",
".",
"_tag",
"(",
"label",
",",
"'label'",
")",
")",
"# time stamp, 18 bytes, char, null terminated",
"# format dd Mon yyyy hh:mm",
"if",
"time_stamp",
"is",
"None",
":",
"time_stamp",
"=",
"datetime",
".",
"datetime",
".",
"now",
"(",
")",
"elif",
"not",
"isinstance",
"(",
"time_stamp",
",",
"datetime",
".",
"datetime",
")",
":",
"raise",
"ValueError",
"(",
"\"time_stamp should be datetime type\"",
")",
"# Avoid locale-specific month conversion",
"months",
"=",
"[",
"'Jan'",
",",
"'Feb'",
",",
"'Mar'",
",",
"'Apr'",
",",
"'May'",
",",
"'Jun'",
",",
"'Jul'",
",",
"'Aug'",
",",
"'Sep'",
",",
"'Oct'",
",",
"'Nov'",
",",
"'Dec'",
"]",
"month_lookup",
"=",
"{",
"i",
"+",
"1",
":",
"month",
"for",
"i",
",",
"month",
"in",
"enumerate",
"(",
"months",
")",
"}",
"ts",
"=",
"(",
"time_stamp",
".",
"strftime",
"(",
"\"%d \"",
")",
"+",
"month_lookup",
"[",
"time_stamp",
".",
"month",
"]",
"+",
"time_stamp",
".",
"strftime",
"(",
"\" %Y %H:%M\"",
")",
")",
"# '\\x11' added due to inspection of Stata file",
"ts",
"=",
"b'\\x11'",
"+",
"bytes",
"(",
"ts",
",",
"'utf8'",
")",
"bio",
".",
"write",
"(",
"self",
".",
"_tag",
"(",
"ts",
",",
"'timestamp'",
")",
")",
"bio",
".",
"seek",
"(",
"0",
")",
"self",
".",
"_file",
".",
"write",
"(",
"self",
".",
"_tag",
"(",
"bio",
".",
"read",
"(",
")",
",",
"'header'",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataWriter117._write_map | Called twice during file write. The first populates the values in
the map with 0s. The second call writes the final map locations when
all blocks have been written. | pandas/io/stata.py | def _write_map(self):
"""Called twice during file write. The first populates the values in
the map with 0s. The second call writes the final map locations when
all blocks have been written."""
if self._map is None:
self._map = OrderedDict((('stata_data', 0),
('map', self._file.tell()),
('variable_types', 0),
('varnames', 0),
('sortlist', 0),
('formats', 0),
('value_label_names', 0),
('variable_labels', 0),
('characteristics', 0),
('data', 0),
('strls', 0),
('value_labels', 0),
('stata_data_close', 0),
('end-of-file', 0)))
# Move to start of map
self._file.seek(self._map['map'])
bio = BytesIO()
for val in self._map.values():
bio.write(struct.pack(self._byteorder + 'Q', val))
bio.seek(0)
self._file.write(self._tag(bio.read(), 'map')) | def _write_map(self):
"""Called twice during file write. The first populates the values in
the map with 0s. The second call writes the final map locations when
all blocks have been written."""
if self._map is None:
self._map = OrderedDict((('stata_data', 0),
('map', self._file.tell()),
('variable_types', 0),
('varnames', 0),
('sortlist', 0),
('formats', 0),
('value_label_names', 0),
('variable_labels', 0),
('characteristics', 0),
('data', 0),
('strls', 0),
('value_labels', 0),
('stata_data_close', 0),
('end-of-file', 0)))
# Move to start of map
self._file.seek(self._map['map'])
bio = BytesIO()
for val in self._map.values():
bio.write(struct.pack(self._byteorder + 'Q', val))
bio.seek(0)
self._file.write(self._tag(bio.read(), 'map')) | [
"Called",
"twice",
"during",
"file",
"write",
".",
"The",
"first",
"populates",
"the",
"values",
"in",
"the",
"map",
"with",
"0s",
".",
"The",
"second",
"call",
"writes",
"the",
"final",
"map",
"locations",
"when",
"all",
"blocks",
"have",
"been",
"written",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2810-L2835 | [
"def",
"_write_map",
"(",
"self",
")",
":",
"if",
"self",
".",
"_map",
"is",
"None",
":",
"self",
".",
"_map",
"=",
"OrderedDict",
"(",
"(",
"(",
"'stata_data'",
",",
"0",
")",
",",
"(",
"'map'",
",",
"self",
".",
"_file",
".",
"tell",
"(",
")",
")",
",",
"(",
"'variable_types'",
",",
"0",
")",
",",
"(",
"'varnames'",
",",
"0",
")",
",",
"(",
"'sortlist'",
",",
"0",
")",
",",
"(",
"'formats'",
",",
"0",
")",
",",
"(",
"'value_label_names'",
",",
"0",
")",
",",
"(",
"'variable_labels'",
",",
"0",
")",
",",
"(",
"'characteristics'",
",",
"0",
")",
",",
"(",
"'data'",
",",
"0",
")",
",",
"(",
"'strls'",
",",
"0",
")",
",",
"(",
"'value_labels'",
",",
"0",
")",
",",
"(",
"'stata_data_close'",
",",
"0",
")",
",",
"(",
"'end-of-file'",
",",
"0",
")",
")",
")",
"# Move to start of map",
"self",
".",
"_file",
".",
"seek",
"(",
"self",
".",
"_map",
"[",
"'map'",
"]",
")",
"bio",
"=",
"BytesIO",
"(",
")",
"for",
"val",
"in",
"self",
".",
"_map",
".",
"values",
"(",
")",
":",
"bio",
".",
"write",
"(",
"struct",
".",
"pack",
"(",
"self",
".",
"_byteorder",
"+",
"'Q'",
",",
"val",
")",
")",
"bio",
".",
"seek",
"(",
"0",
")",
"self",
".",
"_file",
".",
"write",
"(",
"self",
".",
"_tag",
"(",
"bio",
".",
"read",
"(",
")",
",",
"'map'",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataWriter117._update_strl_names | Update column names for conversion to strl if they might have been
changed to comply with Stata naming rules | pandas/io/stata.py | def _update_strl_names(self):
"""Update column names for conversion to strl if they might have been
changed to comply with Stata naming rules"""
# Update convert_strl if names changed
for orig, new in self._converted_names.items():
if orig in self._convert_strl:
idx = self._convert_strl.index(orig)
self._convert_strl[idx] = new | def _update_strl_names(self):
"""Update column names for conversion to strl if they might have been
changed to comply with Stata naming rules"""
# Update convert_strl if names changed
for orig, new in self._converted_names.items():
if orig in self._convert_strl:
idx = self._convert_strl.index(orig)
self._convert_strl[idx] = new | [
"Update",
"column",
"names",
"for",
"conversion",
"to",
"strl",
"if",
"they",
"might",
"have",
"been",
"changed",
"to",
"comply",
"with",
"Stata",
"naming",
"rules"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2948-L2955 | [
"def",
"_update_strl_names",
"(",
"self",
")",
":",
"# Update convert_strl if names changed",
"for",
"orig",
",",
"new",
"in",
"self",
".",
"_converted_names",
".",
"items",
"(",
")",
":",
"if",
"orig",
"in",
"self",
".",
"_convert_strl",
":",
"idx",
"=",
"self",
".",
"_convert_strl",
".",
"index",
"(",
"orig",
")",
"self",
".",
"_convert_strl",
"[",
"idx",
"]",
"=",
"new"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | StataWriter117._convert_strls | Convert columns to StrLs if either very large or in the
convert_strl variable | pandas/io/stata.py | def _convert_strls(self, data):
"""Convert columns to StrLs if either very large or in the
convert_strl variable"""
convert_cols = [
col for i, col in enumerate(data)
if self.typlist[i] == 32768 or col in self._convert_strl]
if convert_cols:
ssw = StataStrLWriter(data, convert_cols)
tab, new_data = ssw.generate_table()
data = new_data
self._strl_blob = ssw.generate_blob(tab)
return data | def _convert_strls(self, data):
"""Convert columns to StrLs if either very large or in the
convert_strl variable"""
convert_cols = [
col for i, col in enumerate(data)
if self.typlist[i] == 32768 or col in self._convert_strl]
if convert_cols:
ssw = StataStrLWriter(data, convert_cols)
tab, new_data = ssw.generate_table()
data = new_data
self._strl_blob = ssw.generate_blob(tab)
return data | [
"Convert",
"columns",
"to",
"StrLs",
"if",
"either",
"very",
"large",
"or",
"in",
"the",
"convert_strl",
"variable"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/stata.py#L2957-L2969 | [
"def",
"_convert_strls",
"(",
"self",
",",
"data",
")",
":",
"convert_cols",
"=",
"[",
"col",
"for",
"i",
",",
"col",
"in",
"enumerate",
"(",
"data",
")",
"if",
"self",
".",
"typlist",
"[",
"i",
"]",
"==",
"32768",
"or",
"col",
"in",
"self",
".",
"_convert_strl",
"]",
"if",
"convert_cols",
":",
"ssw",
"=",
"StataStrLWriter",
"(",
"data",
",",
"convert_cols",
")",
"tab",
",",
"new_data",
"=",
"ssw",
".",
"generate_table",
"(",
")",
"data",
"=",
"new_data",
"self",
".",
"_strl_blob",
"=",
"ssw",
".",
"generate_blob",
"(",
"tab",
")",
"return",
"data"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | register | Register Pandas Formatters and Converters with matplotlib
This function modifies the global ``matplotlib.units.registry``
dictionary. Pandas adds custom converters for
* pd.Timestamp
* pd.Period
* np.datetime64
* datetime.datetime
* datetime.date
* datetime.time
See Also
--------
deregister_matplotlib_converter | pandas/plotting/_converter.py | def register(explicit=True):
"""
Register Pandas Formatters and Converters with matplotlib
This function modifies the global ``matplotlib.units.registry``
dictionary. Pandas adds custom converters for
* pd.Timestamp
* pd.Period
* np.datetime64
* datetime.datetime
* datetime.date
* datetime.time
See Also
--------
deregister_matplotlib_converter
"""
# Renamed in pandas.plotting.__init__
global _WARN
if explicit:
_WARN = False
pairs = get_pairs()
for type_, cls in pairs:
converter = cls()
if type_ in units.registry:
previous = units.registry[type_]
_mpl_units[type_] = previous
units.registry[type_] = converter | def register(explicit=True):
"""
Register Pandas Formatters and Converters with matplotlib
This function modifies the global ``matplotlib.units.registry``
dictionary. Pandas adds custom converters for
* pd.Timestamp
* pd.Period
* np.datetime64
* datetime.datetime
* datetime.date
* datetime.time
See Also
--------
deregister_matplotlib_converter
"""
# Renamed in pandas.plotting.__init__
global _WARN
if explicit:
_WARN = False
pairs = get_pairs()
for type_, cls in pairs:
converter = cls()
if type_ in units.registry:
previous = units.registry[type_]
_mpl_units[type_] = previous
units.registry[type_] = converter | [
"Register",
"Pandas",
"Formatters",
"and",
"Converters",
"with",
"matplotlib"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L54-L84 | [
"def",
"register",
"(",
"explicit",
"=",
"True",
")",
":",
"# Renamed in pandas.plotting.__init__",
"global",
"_WARN",
"if",
"explicit",
":",
"_WARN",
"=",
"False",
"pairs",
"=",
"get_pairs",
"(",
")",
"for",
"type_",
",",
"cls",
"in",
"pairs",
":",
"converter",
"=",
"cls",
"(",
")",
"if",
"type_",
"in",
"units",
".",
"registry",
":",
"previous",
"=",
"units",
".",
"registry",
"[",
"type_",
"]",
"_mpl_units",
"[",
"type_",
"]",
"=",
"previous",
"units",
".",
"registry",
"[",
"type_",
"]",
"=",
"converter"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | deregister | Remove pandas' formatters and converters
Removes the custom converters added by :func:`register`. This
attempts to set the state of the registry back to the state before
pandas registered its own units. Converters for pandas' own types like
Timestamp and Period are removed completely. Converters for types
pandas overwrites, like ``datetime.datetime``, are restored to their
original value.
See Also
--------
deregister_matplotlib_converters | pandas/plotting/_converter.py | def deregister():
"""
Remove pandas' formatters and converters
Removes the custom converters added by :func:`register`. This
attempts to set the state of the registry back to the state before
pandas registered its own units. Converters for pandas' own types like
Timestamp and Period are removed completely. Converters for types
pandas overwrites, like ``datetime.datetime``, are restored to their
original value.
See Also
--------
deregister_matplotlib_converters
"""
# Renamed in pandas.plotting.__init__
for type_, cls in get_pairs():
# We use type to catch our classes directly, no inheritance
if type(units.registry.get(type_)) is cls:
units.registry.pop(type_)
# restore the old keys
for unit, formatter in _mpl_units.items():
if type(formatter) not in {DatetimeConverter, PeriodConverter,
TimeConverter}:
# make it idempotent by excluding ours.
units.registry[unit] = formatter | def deregister():
"""
Remove pandas' formatters and converters
Removes the custom converters added by :func:`register`. This
attempts to set the state of the registry back to the state before
pandas registered its own units. Converters for pandas' own types like
Timestamp and Period are removed completely. Converters for types
pandas overwrites, like ``datetime.datetime``, are restored to their
original value.
See Also
--------
deregister_matplotlib_converters
"""
# Renamed in pandas.plotting.__init__
for type_, cls in get_pairs():
# We use type to catch our classes directly, no inheritance
if type(units.registry.get(type_)) is cls:
units.registry.pop(type_)
# restore the old keys
for unit, formatter in _mpl_units.items():
if type(formatter) not in {DatetimeConverter, PeriodConverter,
TimeConverter}:
# make it idempotent by excluding ours.
units.registry[unit] = formatter | [
"Remove",
"pandas",
"formatters",
"and",
"converters"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L87-L113 | [
"def",
"deregister",
"(",
")",
":",
"# Renamed in pandas.plotting.__init__",
"for",
"type_",
",",
"cls",
"in",
"get_pairs",
"(",
")",
":",
"# We use type to catch our classes directly, no inheritance",
"if",
"type",
"(",
"units",
".",
"registry",
".",
"get",
"(",
"type_",
")",
")",
"is",
"cls",
":",
"units",
".",
"registry",
".",
"pop",
"(",
"type_",
")",
"# restore the old keys",
"for",
"unit",
",",
"formatter",
"in",
"_mpl_units",
".",
"items",
"(",
")",
":",
"if",
"type",
"(",
"formatter",
")",
"not",
"in",
"{",
"DatetimeConverter",
",",
"PeriodConverter",
",",
"TimeConverter",
"}",
":",
"# make it idempotent by excluding ours.",
"units",
".",
"registry",
"[",
"unit",
"]",
"=",
"formatter"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _dt_to_float_ordinal | Convert :mod:`datetime` to the Gregorian date as UTC float days,
preserving hours, minutes, seconds and microseconds. Return value
is a :func:`float`. | pandas/plotting/_converter.py | def _dt_to_float_ordinal(dt):
"""
Convert :mod:`datetime` to the Gregorian date as UTC float days,
preserving hours, minutes, seconds and microseconds. Return value
is a :func:`float`.
"""
if (isinstance(dt, (np.ndarray, Index, ABCSeries)
) and is_datetime64_ns_dtype(dt)):
base = dates.epoch2num(dt.asi8 / 1.0E9)
else:
base = dates.date2num(dt)
return base | def _dt_to_float_ordinal(dt):
"""
Convert :mod:`datetime` to the Gregorian date as UTC float days,
preserving hours, minutes, seconds and microseconds. Return value
is a :func:`float`.
"""
if (isinstance(dt, (np.ndarray, Index, ABCSeries)
) and is_datetime64_ns_dtype(dt)):
base = dates.epoch2num(dt.asi8 / 1.0E9)
else:
base = dates.date2num(dt)
return base | [
"Convert",
":",
"mod",
":",
"datetime",
"to",
"the",
"Gregorian",
"date",
"as",
"UTC",
"float",
"days",
"preserving",
"hours",
"minutes",
"seconds",
"and",
"microseconds",
".",
"Return",
"value",
"is",
"a",
":",
"func",
":",
"float",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L269-L280 | [
"def",
"_dt_to_float_ordinal",
"(",
"dt",
")",
":",
"if",
"(",
"isinstance",
"(",
"dt",
",",
"(",
"np",
".",
"ndarray",
",",
"Index",
",",
"ABCSeries",
")",
")",
"and",
"is_datetime64_ns_dtype",
"(",
"dt",
")",
")",
":",
"base",
"=",
"dates",
".",
"epoch2num",
"(",
"dt",
".",
"asi8",
"/",
"1.0E9",
")",
"else",
":",
"base",
"=",
"dates",
".",
"date2num",
"(",
"dt",
")",
"return",
"base"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _get_default_annual_spacing | Returns a default spacing between consecutive ticks for annual data. | pandas/plotting/_converter.py | def _get_default_annual_spacing(nyears):
"""
Returns a default spacing between consecutive ticks for annual data.
"""
if nyears < 11:
(min_spacing, maj_spacing) = (1, 1)
elif nyears < 20:
(min_spacing, maj_spacing) = (1, 2)
elif nyears < 50:
(min_spacing, maj_spacing) = (1, 5)
elif nyears < 100:
(min_spacing, maj_spacing) = (5, 10)
elif nyears < 200:
(min_spacing, maj_spacing) = (5, 25)
elif nyears < 600:
(min_spacing, maj_spacing) = (10, 50)
else:
factor = nyears // 1000 + 1
(min_spacing, maj_spacing) = (factor * 20, factor * 100)
return (min_spacing, maj_spacing) | def _get_default_annual_spacing(nyears):
"""
Returns a default spacing between consecutive ticks for annual data.
"""
if nyears < 11:
(min_spacing, maj_spacing) = (1, 1)
elif nyears < 20:
(min_spacing, maj_spacing) = (1, 2)
elif nyears < 50:
(min_spacing, maj_spacing) = (1, 5)
elif nyears < 100:
(min_spacing, maj_spacing) = (5, 10)
elif nyears < 200:
(min_spacing, maj_spacing) = (5, 25)
elif nyears < 600:
(min_spacing, maj_spacing) = (10, 50)
else:
factor = nyears // 1000 + 1
(min_spacing, maj_spacing) = (factor * 20, factor * 100)
return (min_spacing, maj_spacing) | [
"Returns",
"a",
"default",
"spacing",
"between",
"consecutive",
"ticks",
"for",
"annual",
"data",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L537-L556 | [
"def",
"_get_default_annual_spacing",
"(",
"nyears",
")",
":",
"if",
"nyears",
"<",
"11",
":",
"(",
"min_spacing",
",",
"maj_spacing",
")",
"=",
"(",
"1",
",",
"1",
")",
"elif",
"nyears",
"<",
"20",
":",
"(",
"min_spacing",
",",
"maj_spacing",
")",
"=",
"(",
"1",
",",
"2",
")",
"elif",
"nyears",
"<",
"50",
":",
"(",
"min_spacing",
",",
"maj_spacing",
")",
"=",
"(",
"1",
",",
"5",
")",
"elif",
"nyears",
"<",
"100",
":",
"(",
"min_spacing",
",",
"maj_spacing",
")",
"=",
"(",
"5",
",",
"10",
")",
"elif",
"nyears",
"<",
"200",
":",
"(",
"min_spacing",
",",
"maj_spacing",
")",
"=",
"(",
"5",
",",
"25",
")",
"elif",
"nyears",
"<",
"600",
":",
"(",
"min_spacing",
",",
"maj_spacing",
")",
"=",
"(",
"10",
",",
"50",
")",
"else",
":",
"factor",
"=",
"nyears",
"//",
"1000",
"+",
"1",
"(",
"min_spacing",
",",
"maj_spacing",
")",
"=",
"(",
"factor",
"*",
"20",
",",
"factor",
"*",
"100",
")",
"return",
"(",
"min_spacing",
",",
"maj_spacing",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | period_break | Returns the indices where the given period changes.
Parameters
----------
dates : PeriodIndex
Array of intervals to monitor.
period : string
Name of the period to monitor. | pandas/plotting/_converter.py | def period_break(dates, period):
"""
Returns the indices where the given period changes.
Parameters
----------
dates : PeriodIndex
Array of intervals to monitor.
period : string
Name of the period to monitor.
"""
current = getattr(dates, period)
previous = getattr(dates - 1 * dates.freq, period)
return np.nonzero(current - previous)[0] | def period_break(dates, period):
"""
Returns the indices where the given period changes.
Parameters
----------
dates : PeriodIndex
Array of intervals to monitor.
period : string
Name of the period to monitor.
"""
current = getattr(dates, period)
previous = getattr(dates - 1 * dates.freq, period)
return np.nonzero(current - previous)[0] | [
"Returns",
"the",
"indices",
"where",
"the",
"given",
"period",
"changes",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L559-L572 | [
"def",
"period_break",
"(",
"dates",
",",
"period",
")",
":",
"current",
"=",
"getattr",
"(",
"dates",
",",
"period",
")",
"previous",
"=",
"getattr",
"(",
"dates",
"-",
"1",
"*",
"dates",
".",
"freq",
",",
"period",
")",
"return",
"np",
".",
"nonzero",
"(",
"current",
"-",
"previous",
")",
"[",
"0",
"]"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | has_level_label | Returns true if the ``label_flags`` indicate there is at least one label
for this level.
if the minimum view limit is not an exact integer, then the first tick
label won't be shown, so we must adjust for that. | pandas/plotting/_converter.py | def has_level_label(label_flags, vmin):
"""
Returns true if the ``label_flags`` indicate there is at least one label
for this level.
if the minimum view limit is not an exact integer, then the first tick
label won't be shown, so we must adjust for that.
"""
if label_flags.size == 0 or (label_flags.size == 1 and
label_flags[0] == 0 and
vmin % 1 > 0.0):
return False
else:
return True | def has_level_label(label_flags, vmin):
"""
Returns true if the ``label_flags`` indicate there is at least one label
for this level.
if the minimum view limit is not an exact integer, then the first tick
label won't be shown, so we must adjust for that.
"""
if label_flags.size == 0 or (label_flags.size == 1 and
label_flags[0] == 0 and
vmin % 1 > 0.0):
return False
else:
return True | [
"Returns",
"true",
"if",
"the",
"label_flags",
"indicate",
"there",
"is",
"at",
"least",
"one",
"label",
"for",
"this",
"level",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L575-L588 | [
"def",
"has_level_label",
"(",
"label_flags",
",",
"vmin",
")",
":",
"if",
"label_flags",
".",
"size",
"==",
"0",
"or",
"(",
"label_flags",
".",
"size",
"==",
"1",
"and",
"label_flags",
"[",
"0",
"]",
"==",
"0",
"and",
"vmin",
"%",
"1",
">",
"0.0",
")",
":",
"return",
"False",
"else",
":",
"return",
"True"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | DatetimeConverter.axisinfo | Return the :class:`~matplotlib.units.AxisInfo` for *unit*.
*unit* is a tzinfo instance or None.
The *axis* argument is required but not used. | pandas/plotting/_converter.py | def axisinfo(unit, axis):
"""
Return the :class:`~matplotlib.units.AxisInfo` for *unit*.
*unit* is a tzinfo instance or None.
The *axis* argument is required but not used.
"""
tz = unit
majloc = PandasAutoDateLocator(tz=tz)
majfmt = PandasAutoDateFormatter(majloc, tz=tz)
datemin = pydt.date(2000, 1, 1)
datemax = pydt.date(2010, 1, 1)
return units.AxisInfo(majloc=majloc, majfmt=majfmt, label='',
default_limits=(datemin, datemax)) | def axisinfo(unit, axis):
"""
Return the :class:`~matplotlib.units.AxisInfo` for *unit*.
*unit* is a tzinfo instance or None.
The *axis* argument is required but not used.
"""
tz = unit
majloc = PandasAutoDateLocator(tz=tz)
majfmt = PandasAutoDateFormatter(majloc, tz=tz)
datemin = pydt.date(2000, 1, 1)
datemax = pydt.date(2010, 1, 1)
return units.AxisInfo(majloc=majloc, majfmt=majfmt, label='',
default_limits=(datemin, datemax)) | [
"Return",
"the",
":",
"class",
":",
"~matplotlib",
".",
"units",
".",
"AxisInfo",
"for",
"*",
"unit",
"*",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L340-L355 | [
"def",
"axisinfo",
"(",
"unit",
",",
"axis",
")",
":",
"tz",
"=",
"unit",
"majloc",
"=",
"PandasAutoDateLocator",
"(",
"tz",
"=",
"tz",
")",
"majfmt",
"=",
"PandasAutoDateFormatter",
"(",
"majloc",
",",
"tz",
"=",
"tz",
")",
"datemin",
"=",
"pydt",
".",
"date",
"(",
"2000",
",",
"1",
",",
"1",
")",
"datemax",
"=",
"pydt",
".",
"date",
"(",
"2010",
",",
"1",
",",
"1",
")",
"return",
"units",
".",
"AxisInfo",
"(",
"majloc",
"=",
"majloc",
",",
"majfmt",
"=",
"majfmt",
",",
"label",
"=",
"''",
",",
"default_limits",
"=",
"(",
"datemin",
",",
"datemax",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | PandasAutoDateLocator.get_locator | Pick the best locator based on a distance. | pandas/plotting/_converter.py | def get_locator(self, dmin, dmax):
'Pick the best locator based on a distance.'
_check_implicitly_registered()
delta = relativedelta(dmax, dmin)
num_days = (delta.years * 12.0 + delta.months) * 31.0 + delta.days
num_sec = (delta.hours * 60.0 + delta.minutes) * 60.0 + delta.seconds
tot_sec = num_days * 86400. + num_sec
if abs(tot_sec) < self.minticks:
self._freq = -1
locator = MilliSecondLocator(self.tz)
locator.set_axis(self.axis)
locator.set_view_interval(*self.axis.get_view_interval())
locator.set_data_interval(*self.axis.get_data_interval())
return locator
return dates.AutoDateLocator.get_locator(self, dmin, dmax) | def get_locator(self, dmin, dmax):
'Pick the best locator based on a distance.'
_check_implicitly_registered()
delta = relativedelta(dmax, dmin)
num_days = (delta.years * 12.0 + delta.months) * 31.0 + delta.days
num_sec = (delta.hours * 60.0 + delta.minutes) * 60.0 + delta.seconds
tot_sec = num_days * 86400. + num_sec
if abs(tot_sec) < self.minticks:
self._freq = -1
locator = MilliSecondLocator(self.tz)
locator.set_axis(self.axis)
locator.set_view_interval(*self.axis.get_view_interval())
locator.set_data_interval(*self.axis.get_data_interval())
return locator
return dates.AutoDateLocator.get_locator(self, dmin, dmax) | [
"Pick",
"the",
"best",
"locator",
"based",
"on",
"a",
"distance",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L369-L387 | [
"def",
"get_locator",
"(",
"self",
",",
"dmin",
",",
"dmax",
")",
":",
"_check_implicitly_registered",
"(",
")",
"delta",
"=",
"relativedelta",
"(",
"dmax",
",",
"dmin",
")",
"num_days",
"=",
"(",
"delta",
".",
"years",
"*",
"12.0",
"+",
"delta",
".",
"months",
")",
"*",
"31.0",
"+",
"delta",
".",
"days",
"num_sec",
"=",
"(",
"delta",
".",
"hours",
"*",
"60.0",
"+",
"delta",
".",
"minutes",
")",
"*",
"60.0",
"+",
"delta",
".",
"seconds",
"tot_sec",
"=",
"num_days",
"*",
"86400.",
"+",
"num_sec",
"if",
"abs",
"(",
"tot_sec",
")",
"<",
"self",
".",
"minticks",
":",
"self",
".",
"_freq",
"=",
"-",
"1",
"locator",
"=",
"MilliSecondLocator",
"(",
"self",
".",
"tz",
")",
"locator",
".",
"set_axis",
"(",
"self",
".",
"axis",
")",
"locator",
".",
"set_view_interval",
"(",
"*",
"self",
".",
"axis",
".",
"get_view_interval",
"(",
")",
")",
"locator",
".",
"set_data_interval",
"(",
"*",
"self",
".",
"axis",
".",
"get_data_interval",
"(",
")",
")",
"return",
"locator",
"return",
"dates",
".",
"AutoDateLocator",
".",
"get_locator",
"(",
"self",
",",
"dmin",
",",
"dmax",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | MilliSecondLocator.autoscale | Set the view limits to include the data range. | pandas/plotting/_converter.py | def autoscale(self):
"""
Set the view limits to include the data range.
"""
dmin, dmax = self.datalim_to_dt()
if dmin > dmax:
dmax, dmin = dmin, dmax
# We need to cap at the endpoints of valid datetime
# TODO(wesm): unused?
# delta = relativedelta(dmax, dmin)
# try:
# start = dmin - delta
# except ValueError:
# start = _from_ordinal(1.0)
# try:
# stop = dmax + delta
# except ValueError:
# # The magic number!
# stop = _from_ordinal(3652059.9999999)
dmin, dmax = self.datalim_to_dt()
vmin = dates.date2num(dmin)
vmax = dates.date2num(dmax)
return self.nonsingular(vmin, vmax) | def autoscale(self):
"""
Set the view limits to include the data range.
"""
dmin, dmax = self.datalim_to_dt()
if dmin > dmax:
dmax, dmin = dmin, dmax
# We need to cap at the endpoints of valid datetime
# TODO(wesm): unused?
# delta = relativedelta(dmax, dmin)
# try:
# start = dmin - delta
# except ValueError:
# start = _from_ordinal(1.0)
# try:
# stop = dmax + delta
# except ValueError:
# # The magic number!
# stop = _from_ordinal(3652059.9999999)
dmin, dmax = self.datalim_to_dt()
vmin = dates.date2num(dmin)
vmax = dates.date2num(dmax)
return self.nonsingular(vmin, vmax) | [
"Set",
"the",
"view",
"limits",
"to",
"include",
"the",
"data",
"range",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L478-L507 | [
"def",
"autoscale",
"(",
"self",
")",
":",
"dmin",
",",
"dmax",
"=",
"self",
".",
"datalim_to_dt",
"(",
")",
"if",
"dmin",
">",
"dmax",
":",
"dmax",
",",
"dmin",
"=",
"dmin",
",",
"dmax",
"# We need to cap at the endpoints of valid datetime",
"# TODO(wesm): unused?",
"# delta = relativedelta(dmax, dmin)",
"# try:",
"# start = dmin - delta",
"# except ValueError:",
"# start = _from_ordinal(1.0)",
"# try:",
"# stop = dmax + delta",
"# except ValueError:",
"# # The magic number!",
"# stop = _from_ordinal(3652059.9999999)",
"dmin",
",",
"dmax",
"=",
"self",
".",
"datalim_to_dt",
"(",
")",
"vmin",
"=",
"dates",
".",
"date2num",
"(",
"dmin",
")",
"vmax",
"=",
"dates",
".",
"date2num",
"(",
"dmax",
")",
"return",
"self",
".",
"nonsingular",
"(",
"vmin",
",",
"vmax",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | TimeSeries_DateLocator._get_default_locs | Returns the default locations of ticks. | pandas/plotting/_converter.py | def _get_default_locs(self, vmin, vmax):
"Returns the default locations of ticks."
if self.plot_obj.date_axis_info is None:
self.plot_obj.date_axis_info = self.finder(vmin, vmax, self.freq)
locator = self.plot_obj.date_axis_info
if self.isminor:
return np.compress(locator['min'], locator['val'])
return np.compress(locator['maj'], locator['val']) | def _get_default_locs(self, vmin, vmax):
"Returns the default locations of ticks."
if self.plot_obj.date_axis_info is None:
self.plot_obj.date_axis_info = self.finder(vmin, vmax, self.freq)
locator = self.plot_obj.date_axis_info
if self.isminor:
return np.compress(locator['min'], locator['val'])
return np.compress(locator['maj'], locator['val']) | [
"Returns",
"the",
"default",
"locations",
"of",
"ticks",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L1002-L1012 | [
"def",
"_get_default_locs",
"(",
"self",
",",
"vmin",
",",
"vmax",
")",
":",
"if",
"self",
".",
"plot_obj",
".",
"date_axis_info",
"is",
"None",
":",
"self",
".",
"plot_obj",
".",
"date_axis_info",
"=",
"self",
".",
"finder",
"(",
"vmin",
",",
"vmax",
",",
"self",
".",
"freq",
")",
"locator",
"=",
"self",
".",
"plot_obj",
".",
"date_axis_info",
"if",
"self",
".",
"isminor",
":",
"return",
"np",
".",
"compress",
"(",
"locator",
"[",
"'min'",
"]",
",",
"locator",
"[",
"'val'",
"]",
")",
"return",
"np",
".",
"compress",
"(",
"locator",
"[",
"'maj'",
"]",
",",
"locator",
"[",
"'val'",
"]",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | TimeSeries_DateLocator.autoscale | Sets the view limits to the nearest multiples of base that contain the
data. | pandas/plotting/_converter.py | def autoscale(self):
"""
Sets the view limits to the nearest multiples of base that contain the
data.
"""
# requires matplotlib >= 0.98.0
(vmin, vmax) = self.axis.get_data_interval()
locs = self._get_default_locs(vmin, vmax)
(vmin, vmax) = locs[[0, -1]]
if vmin == vmax:
vmin -= 1
vmax += 1
return nonsingular(vmin, vmax) | def autoscale(self):
"""
Sets the view limits to the nearest multiples of base that contain the
data.
"""
# requires matplotlib >= 0.98.0
(vmin, vmax) = self.axis.get_data_interval()
locs = self._get_default_locs(vmin, vmax)
(vmin, vmax) = locs[[0, -1]]
if vmin == vmax:
vmin -= 1
vmax += 1
return nonsingular(vmin, vmax) | [
"Sets",
"the",
"view",
"limits",
"to",
"the",
"nearest",
"multiples",
"of",
"base",
"that",
"contain",
"the",
"data",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L1035-L1048 | [
"def",
"autoscale",
"(",
"self",
")",
":",
"# requires matplotlib >= 0.98.0",
"(",
"vmin",
",",
"vmax",
")",
"=",
"self",
".",
"axis",
".",
"get_data_interval",
"(",
")",
"locs",
"=",
"self",
".",
"_get_default_locs",
"(",
"vmin",
",",
"vmax",
")",
"(",
"vmin",
",",
"vmax",
")",
"=",
"locs",
"[",
"[",
"0",
",",
"-",
"1",
"]",
"]",
"if",
"vmin",
"==",
"vmax",
":",
"vmin",
"-=",
"1",
"vmax",
"+=",
"1",
"return",
"nonsingular",
"(",
"vmin",
",",
"vmax",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | TimeSeries_DateFormatter._set_default_format | Returns the default ticks spacing. | pandas/plotting/_converter.py | def _set_default_format(self, vmin, vmax):
"Returns the default ticks spacing."
if self.plot_obj.date_axis_info is None:
self.plot_obj.date_axis_info = self.finder(vmin, vmax, self.freq)
info = self.plot_obj.date_axis_info
if self.isminor:
format = np.compress(info['min'] & np.logical_not(info['maj']),
info)
else:
format = np.compress(info['maj'], info)
self.formatdict = {x: f for (x, _, _, f) in format}
return self.formatdict | def _set_default_format(self, vmin, vmax):
"Returns the default ticks spacing."
if self.plot_obj.date_axis_info is None:
self.plot_obj.date_axis_info = self.finder(vmin, vmax, self.freq)
info = self.plot_obj.date_axis_info
if self.isminor:
format = np.compress(info['min'] & np.logical_not(info['maj']),
info)
else:
format = np.compress(info['maj'], info)
self.formatdict = {x: f for (x, _, _, f) in format}
return self.formatdict | [
"Returns",
"the",
"default",
"ticks",
"spacing",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L1084-L1097 | [
"def",
"_set_default_format",
"(",
"self",
",",
"vmin",
",",
"vmax",
")",
":",
"if",
"self",
".",
"plot_obj",
".",
"date_axis_info",
"is",
"None",
":",
"self",
".",
"plot_obj",
".",
"date_axis_info",
"=",
"self",
".",
"finder",
"(",
"vmin",
",",
"vmax",
",",
"self",
".",
"freq",
")",
"info",
"=",
"self",
".",
"plot_obj",
".",
"date_axis_info",
"if",
"self",
".",
"isminor",
":",
"format",
"=",
"np",
".",
"compress",
"(",
"info",
"[",
"'min'",
"]",
"&",
"np",
".",
"logical_not",
"(",
"info",
"[",
"'maj'",
"]",
")",
",",
"info",
")",
"else",
":",
"format",
"=",
"np",
".",
"compress",
"(",
"info",
"[",
"'maj'",
"]",
",",
"info",
")",
"self",
".",
"formatdict",
"=",
"{",
"x",
":",
"f",
"for",
"(",
"x",
",",
"_",
",",
"_",
",",
"f",
")",
"in",
"format",
"}",
"return",
"self",
".",
"formatdict"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | TimeSeries_DateFormatter.set_locs | Sets the locations of the ticks | pandas/plotting/_converter.py | def set_locs(self, locs):
'Sets the locations of the ticks'
# don't actually use the locs. This is just needed to work with
# matplotlib. Force to use vmin, vmax
_check_implicitly_registered()
self.locs = locs
(vmin, vmax) = vi = tuple(self.axis.get_view_interval())
if vi != self.plot_obj.view_interval:
self.plot_obj.date_axis_info = None
self.plot_obj.view_interval = vi
if vmax < vmin:
(vmin, vmax) = (vmax, vmin)
self._set_default_format(vmin, vmax) | def set_locs(self, locs):
'Sets the locations of the ticks'
# don't actually use the locs. This is just needed to work with
# matplotlib. Force to use vmin, vmax
_check_implicitly_registered()
self.locs = locs
(vmin, vmax) = vi = tuple(self.axis.get_view_interval())
if vi != self.plot_obj.view_interval:
self.plot_obj.date_axis_info = None
self.plot_obj.view_interval = vi
if vmax < vmin:
(vmin, vmax) = (vmax, vmin)
self._set_default_format(vmin, vmax) | [
"Sets",
"the",
"locations",
"of",
"the",
"ticks"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/plotting/_converter.py#L1099-L1113 | [
"def",
"set_locs",
"(",
"self",
",",
"locs",
")",
":",
"# don't actually use the locs. This is just needed to work with",
"# matplotlib. Force to use vmin, vmax",
"_check_implicitly_registered",
"(",
")",
"self",
".",
"locs",
"=",
"locs",
"(",
"vmin",
",",
"vmax",
")",
"=",
"vi",
"=",
"tuple",
"(",
"self",
".",
"axis",
".",
"get_view_interval",
"(",
")",
")",
"if",
"vi",
"!=",
"self",
".",
"plot_obj",
".",
"view_interval",
":",
"self",
".",
"plot_obj",
".",
"date_axis_info",
"=",
"None",
"self",
".",
"plot_obj",
".",
"view_interval",
"=",
"vi",
"if",
"vmax",
"<",
"vmin",
":",
"(",
"vmin",
",",
"vmax",
")",
"=",
"(",
"vmax",
",",
"vmin",
")",
"self",
".",
"_set_default_format",
"(",
"vmin",
",",
"vmax",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | set_default_names | Sets index names to 'index' for regular, or 'level_x' for Multi | pandas/io/json/table_schema.py | def set_default_names(data):
"""Sets index names to 'index' for regular, or 'level_x' for Multi"""
if com._all_not_none(*data.index.names):
nms = data.index.names
if len(nms) == 1 and data.index.name == 'index':
warnings.warn("Index name of 'index' is not round-trippable")
elif len(nms) > 1 and any(x.startswith('level_') for x in nms):
warnings.warn("Index names beginning with 'level_' are not "
"round-trippable")
return data
data = data.copy()
if data.index.nlevels > 1:
names = [name if name is not None else 'level_{}'.format(i)
for i, name in enumerate(data.index.names)]
data.index.names = names
else:
data.index.name = data.index.name or 'index'
return data | def set_default_names(data):
"""Sets index names to 'index' for regular, or 'level_x' for Multi"""
if com._all_not_none(*data.index.names):
nms = data.index.names
if len(nms) == 1 and data.index.name == 'index':
warnings.warn("Index name of 'index' is not round-trippable")
elif len(nms) > 1 and any(x.startswith('level_') for x in nms):
warnings.warn("Index names beginning with 'level_' are not "
"round-trippable")
return data
data = data.copy()
if data.index.nlevels > 1:
names = [name if name is not None else 'level_{}'.format(i)
for i, name in enumerate(data.index.names)]
data.index.names = names
else:
data.index.name = data.index.name or 'index'
return data | [
"Sets",
"index",
"names",
"to",
"index",
"for",
"regular",
"or",
"level_x",
"for",
"Multi"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/json/table_schema.py#L71-L89 | [
"def",
"set_default_names",
"(",
"data",
")",
":",
"if",
"com",
".",
"_all_not_none",
"(",
"*",
"data",
".",
"index",
".",
"names",
")",
":",
"nms",
"=",
"data",
".",
"index",
".",
"names",
"if",
"len",
"(",
"nms",
")",
"==",
"1",
"and",
"data",
".",
"index",
".",
"name",
"==",
"'index'",
":",
"warnings",
".",
"warn",
"(",
"\"Index name of 'index' is not round-trippable\"",
")",
"elif",
"len",
"(",
"nms",
")",
">",
"1",
"and",
"any",
"(",
"x",
".",
"startswith",
"(",
"'level_'",
")",
"for",
"x",
"in",
"nms",
")",
":",
"warnings",
".",
"warn",
"(",
"\"Index names beginning with 'level_' are not \"",
"\"round-trippable\"",
")",
"return",
"data",
"data",
"=",
"data",
".",
"copy",
"(",
")",
"if",
"data",
".",
"index",
".",
"nlevels",
">",
"1",
":",
"names",
"=",
"[",
"name",
"if",
"name",
"is",
"not",
"None",
"else",
"'level_{}'",
".",
"format",
"(",
"i",
")",
"for",
"i",
",",
"name",
"in",
"enumerate",
"(",
"data",
".",
"index",
".",
"names",
")",
"]",
"data",
".",
"index",
".",
"names",
"=",
"names",
"else",
":",
"data",
".",
"index",
".",
"name",
"=",
"data",
".",
"index",
".",
"name",
"or",
"'index'",
"return",
"data"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | convert_json_field_to_pandas_type | Converts a JSON field descriptor into its corresponding NumPy / pandas type
Parameters
----------
field
A JSON field descriptor
Returns
-------
dtype
Raises
-----
ValueError
If the type of the provided field is unknown or currently unsupported
Examples
--------
>>> convert_json_field_to_pandas_type({'name': 'an_int',
'type': 'integer'})
'int64'
>>> convert_json_field_to_pandas_type({'name': 'a_categorical',
'type': 'any',
'contraints': {'enum': [
'a', 'b', 'c']},
'ordered': True})
'CategoricalDtype(categories=['a', 'b', 'c'], ordered=True)'
>>> convert_json_field_to_pandas_type({'name': 'a_datetime',
'type': 'datetime'})
'datetime64[ns]'
>>> convert_json_field_to_pandas_type({'name': 'a_datetime_with_tz',
'type': 'datetime',
'tz': 'US/Central'})
'datetime64[ns, US/Central]' | pandas/io/json/table_schema.py | def convert_json_field_to_pandas_type(field):
"""
Converts a JSON field descriptor into its corresponding NumPy / pandas type
Parameters
----------
field
A JSON field descriptor
Returns
-------
dtype
Raises
-----
ValueError
If the type of the provided field is unknown or currently unsupported
Examples
--------
>>> convert_json_field_to_pandas_type({'name': 'an_int',
'type': 'integer'})
'int64'
>>> convert_json_field_to_pandas_type({'name': 'a_categorical',
'type': 'any',
'contraints': {'enum': [
'a', 'b', 'c']},
'ordered': True})
'CategoricalDtype(categories=['a', 'b', 'c'], ordered=True)'
>>> convert_json_field_to_pandas_type({'name': 'a_datetime',
'type': 'datetime'})
'datetime64[ns]'
>>> convert_json_field_to_pandas_type({'name': 'a_datetime_with_tz',
'type': 'datetime',
'tz': 'US/Central'})
'datetime64[ns, US/Central]'
"""
typ = field['type']
if typ == 'string':
return 'object'
elif typ == 'integer':
return 'int64'
elif typ == 'number':
return 'float64'
elif typ == 'boolean':
return 'bool'
elif typ == 'duration':
return 'timedelta64'
elif typ == 'datetime':
if field.get('tz'):
return 'datetime64[ns, {tz}]'.format(tz=field['tz'])
else:
return 'datetime64[ns]'
elif typ == 'any':
if 'constraints' in field and 'ordered' in field:
return CategoricalDtype(categories=field['constraints']['enum'],
ordered=field['ordered'])
else:
return 'object'
raise ValueError("Unsupported or invalid field type: {}".format(typ)) | def convert_json_field_to_pandas_type(field):
"""
Converts a JSON field descriptor into its corresponding NumPy / pandas type
Parameters
----------
field
A JSON field descriptor
Returns
-------
dtype
Raises
-----
ValueError
If the type of the provided field is unknown or currently unsupported
Examples
--------
>>> convert_json_field_to_pandas_type({'name': 'an_int',
'type': 'integer'})
'int64'
>>> convert_json_field_to_pandas_type({'name': 'a_categorical',
'type': 'any',
'contraints': {'enum': [
'a', 'b', 'c']},
'ordered': True})
'CategoricalDtype(categories=['a', 'b', 'c'], ordered=True)'
>>> convert_json_field_to_pandas_type({'name': 'a_datetime',
'type': 'datetime'})
'datetime64[ns]'
>>> convert_json_field_to_pandas_type({'name': 'a_datetime_with_tz',
'type': 'datetime',
'tz': 'US/Central'})
'datetime64[ns, US/Central]'
"""
typ = field['type']
if typ == 'string':
return 'object'
elif typ == 'integer':
return 'int64'
elif typ == 'number':
return 'float64'
elif typ == 'boolean':
return 'bool'
elif typ == 'duration':
return 'timedelta64'
elif typ == 'datetime':
if field.get('tz'):
return 'datetime64[ns, {tz}]'.format(tz=field['tz'])
else:
return 'datetime64[ns]'
elif typ == 'any':
if 'constraints' in field and 'ordered' in field:
return CategoricalDtype(categories=field['constraints']['enum'],
ordered=field['ordered'])
else:
return 'object'
raise ValueError("Unsupported or invalid field type: {}".format(typ)) | [
"Converts",
"a",
"JSON",
"field",
"descriptor",
"into",
"its",
"corresponding",
"NumPy",
"/",
"pandas",
"type"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/json/table_schema.py#L120-L180 | [
"def",
"convert_json_field_to_pandas_type",
"(",
"field",
")",
":",
"typ",
"=",
"field",
"[",
"'type'",
"]",
"if",
"typ",
"==",
"'string'",
":",
"return",
"'object'",
"elif",
"typ",
"==",
"'integer'",
":",
"return",
"'int64'",
"elif",
"typ",
"==",
"'number'",
":",
"return",
"'float64'",
"elif",
"typ",
"==",
"'boolean'",
":",
"return",
"'bool'",
"elif",
"typ",
"==",
"'duration'",
":",
"return",
"'timedelta64'",
"elif",
"typ",
"==",
"'datetime'",
":",
"if",
"field",
".",
"get",
"(",
"'tz'",
")",
":",
"return",
"'datetime64[ns, {tz}]'",
".",
"format",
"(",
"tz",
"=",
"field",
"[",
"'tz'",
"]",
")",
"else",
":",
"return",
"'datetime64[ns]'",
"elif",
"typ",
"==",
"'any'",
":",
"if",
"'constraints'",
"in",
"field",
"and",
"'ordered'",
"in",
"field",
":",
"return",
"CategoricalDtype",
"(",
"categories",
"=",
"field",
"[",
"'constraints'",
"]",
"[",
"'enum'",
"]",
",",
"ordered",
"=",
"field",
"[",
"'ordered'",
"]",
")",
"else",
":",
"return",
"'object'",
"raise",
"ValueError",
"(",
"\"Unsupported or invalid field type: {}\"",
".",
"format",
"(",
"typ",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | build_table_schema | Create a Table schema from ``data``.
Parameters
----------
data : Series, DataFrame
index : bool, default True
Whether to include ``data.index`` in the schema.
primary_key : bool or None, default True
column names to designate as the primary key.
The default `None` will set `'primaryKey'` to the index
level or levels if the index is unique.
version : bool, default True
Whether to include a field `pandas_version` with the version
of pandas that generated the schema.
Returns
-------
schema : dict
Notes
-----
See `_as_json_table_type` for conversion types.
Timedeltas as converted to ISO8601 duration format with
9 decimal places after the seconds field for nanosecond precision.
Categoricals are converted to the `any` dtype, and use the `enum` field
constraint to list the allowed values. The `ordered` attribute is included
in an `ordered` field.
Examples
--------
>>> df = pd.DataFrame(
... {'A': [1, 2, 3],
... 'B': ['a', 'b', 'c'],
... 'C': pd.date_range('2016-01-01', freq='d', periods=3),
... }, index=pd.Index(range(3), name='idx'))
>>> build_table_schema(df)
{'fields': [{'name': 'idx', 'type': 'integer'},
{'name': 'A', 'type': 'integer'},
{'name': 'B', 'type': 'string'},
{'name': 'C', 'type': 'datetime'}],
'pandas_version': '0.20.0',
'primaryKey': ['idx']} | pandas/io/json/table_schema.py | def build_table_schema(data, index=True, primary_key=None, version=True):
"""
Create a Table schema from ``data``.
Parameters
----------
data : Series, DataFrame
index : bool, default True
Whether to include ``data.index`` in the schema.
primary_key : bool or None, default True
column names to designate as the primary key.
The default `None` will set `'primaryKey'` to the index
level or levels if the index is unique.
version : bool, default True
Whether to include a field `pandas_version` with the version
of pandas that generated the schema.
Returns
-------
schema : dict
Notes
-----
See `_as_json_table_type` for conversion types.
Timedeltas as converted to ISO8601 duration format with
9 decimal places after the seconds field for nanosecond precision.
Categoricals are converted to the `any` dtype, and use the `enum` field
constraint to list the allowed values. The `ordered` attribute is included
in an `ordered` field.
Examples
--------
>>> df = pd.DataFrame(
... {'A': [1, 2, 3],
... 'B': ['a', 'b', 'c'],
... 'C': pd.date_range('2016-01-01', freq='d', periods=3),
... }, index=pd.Index(range(3), name='idx'))
>>> build_table_schema(df)
{'fields': [{'name': 'idx', 'type': 'integer'},
{'name': 'A', 'type': 'integer'},
{'name': 'B', 'type': 'string'},
{'name': 'C', 'type': 'datetime'}],
'pandas_version': '0.20.0',
'primaryKey': ['idx']}
"""
if index is True:
data = set_default_names(data)
schema = {}
fields = []
if index:
if data.index.nlevels > 1:
for level in data.index.levels:
fields.append(convert_pandas_type_to_json_field(level))
else:
fields.append(convert_pandas_type_to_json_field(data.index))
if data.ndim > 1:
for column, s in data.iteritems():
fields.append(convert_pandas_type_to_json_field(s))
else:
fields.append(convert_pandas_type_to_json_field(data))
schema['fields'] = fields
if index and data.index.is_unique and primary_key is None:
if data.index.nlevels == 1:
schema['primaryKey'] = [data.index.name]
else:
schema['primaryKey'] = data.index.names
elif primary_key is not None:
schema['primaryKey'] = primary_key
if version:
schema['pandas_version'] = '0.20.0'
return schema | def build_table_schema(data, index=True, primary_key=None, version=True):
"""
Create a Table schema from ``data``.
Parameters
----------
data : Series, DataFrame
index : bool, default True
Whether to include ``data.index`` in the schema.
primary_key : bool or None, default True
column names to designate as the primary key.
The default `None` will set `'primaryKey'` to the index
level or levels if the index is unique.
version : bool, default True
Whether to include a field `pandas_version` with the version
of pandas that generated the schema.
Returns
-------
schema : dict
Notes
-----
See `_as_json_table_type` for conversion types.
Timedeltas as converted to ISO8601 duration format with
9 decimal places after the seconds field for nanosecond precision.
Categoricals are converted to the `any` dtype, and use the `enum` field
constraint to list the allowed values. The `ordered` attribute is included
in an `ordered` field.
Examples
--------
>>> df = pd.DataFrame(
... {'A': [1, 2, 3],
... 'B': ['a', 'b', 'c'],
... 'C': pd.date_range('2016-01-01', freq='d', periods=3),
... }, index=pd.Index(range(3), name='idx'))
>>> build_table_schema(df)
{'fields': [{'name': 'idx', 'type': 'integer'},
{'name': 'A', 'type': 'integer'},
{'name': 'B', 'type': 'string'},
{'name': 'C', 'type': 'datetime'}],
'pandas_version': '0.20.0',
'primaryKey': ['idx']}
"""
if index is True:
data = set_default_names(data)
schema = {}
fields = []
if index:
if data.index.nlevels > 1:
for level in data.index.levels:
fields.append(convert_pandas_type_to_json_field(level))
else:
fields.append(convert_pandas_type_to_json_field(data.index))
if data.ndim > 1:
for column, s in data.iteritems():
fields.append(convert_pandas_type_to_json_field(s))
else:
fields.append(convert_pandas_type_to_json_field(data))
schema['fields'] = fields
if index and data.index.is_unique and primary_key is None:
if data.index.nlevels == 1:
schema['primaryKey'] = [data.index.name]
else:
schema['primaryKey'] = data.index.names
elif primary_key is not None:
schema['primaryKey'] = primary_key
if version:
schema['pandas_version'] = '0.20.0'
return schema | [
"Create",
"a",
"Table",
"schema",
"from",
"data",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/json/table_schema.py#L183-L259 | [
"def",
"build_table_schema",
"(",
"data",
",",
"index",
"=",
"True",
",",
"primary_key",
"=",
"None",
",",
"version",
"=",
"True",
")",
":",
"if",
"index",
"is",
"True",
":",
"data",
"=",
"set_default_names",
"(",
"data",
")",
"schema",
"=",
"{",
"}",
"fields",
"=",
"[",
"]",
"if",
"index",
":",
"if",
"data",
".",
"index",
".",
"nlevels",
">",
"1",
":",
"for",
"level",
"in",
"data",
".",
"index",
".",
"levels",
":",
"fields",
".",
"append",
"(",
"convert_pandas_type_to_json_field",
"(",
"level",
")",
")",
"else",
":",
"fields",
".",
"append",
"(",
"convert_pandas_type_to_json_field",
"(",
"data",
".",
"index",
")",
")",
"if",
"data",
".",
"ndim",
">",
"1",
":",
"for",
"column",
",",
"s",
"in",
"data",
".",
"iteritems",
"(",
")",
":",
"fields",
".",
"append",
"(",
"convert_pandas_type_to_json_field",
"(",
"s",
")",
")",
"else",
":",
"fields",
".",
"append",
"(",
"convert_pandas_type_to_json_field",
"(",
"data",
")",
")",
"schema",
"[",
"'fields'",
"]",
"=",
"fields",
"if",
"index",
"and",
"data",
".",
"index",
".",
"is_unique",
"and",
"primary_key",
"is",
"None",
":",
"if",
"data",
".",
"index",
".",
"nlevels",
"==",
"1",
":",
"schema",
"[",
"'primaryKey'",
"]",
"=",
"[",
"data",
".",
"index",
".",
"name",
"]",
"else",
":",
"schema",
"[",
"'primaryKey'",
"]",
"=",
"data",
".",
"index",
".",
"names",
"elif",
"primary_key",
"is",
"not",
"None",
":",
"schema",
"[",
"'primaryKey'",
"]",
"=",
"primary_key",
"if",
"version",
":",
"schema",
"[",
"'pandas_version'",
"]",
"=",
"'0.20.0'",
"return",
"schema"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | parse_table_schema | Builds a DataFrame from a given schema
Parameters
----------
json :
A JSON table schema
precise_float : boolean
Flag controlling precision when decoding string to double values, as
dictated by ``read_json``
Returns
-------
df : DataFrame
Raises
------
NotImplementedError
If the JSON table schema contains either timezone or timedelta data
Notes
-----
Because :func:`DataFrame.to_json` uses the string 'index' to denote a
name-less :class:`Index`, this function sets the name of the returned
:class:`DataFrame` to ``None`` when said string is encountered with a
normal :class:`Index`. For a :class:`MultiIndex`, the same limitation
applies to any strings beginning with 'level_'. Therefore, an
:class:`Index` name of 'index' and :class:`MultiIndex` names starting
with 'level_' are not supported.
See Also
--------
build_table_schema : Inverse function.
pandas.read_json | pandas/io/json/table_schema.py | def parse_table_schema(json, precise_float):
"""
Builds a DataFrame from a given schema
Parameters
----------
json :
A JSON table schema
precise_float : boolean
Flag controlling precision when decoding string to double values, as
dictated by ``read_json``
Returns
-------
df : DataFrame
Raises
------
NotImplementedError
If the JSON table schema contains either timezone or timedelta data
Notes
-----
Because :func:`DataFrame.to_json` uses the string 'index' to denote a
name-less :class:`Index`, this function sets the name of the returned
:class:`DataFrame` to ``None`` when said string is encountered with a
normal :class:`Index`. For a :class:`MultiIndex`, the same limitation
applies to any strings beginning with 'level_'. Therefore, an
:class:`Index` name of 'index' and :class:`MultiIndex` names starting
with 'level_' are not supported.
See Also
--------
build_table_schema : Inverse function.
pandas.read_json
"""
table = loads(json, precise_float=precise_float)
col_order = [field['name'] for field in table['schema']['fields']]
df = DataFrame(table['data'], columns=col_order)[col_order]
dtypes = {field['name']: convert_json_field_to_pandas_type(field)
for field in table['schema']['fields']}
# Cannot directly use as_type with timezone data on object; raise for now
if any(str(x).startswith('datetime64[ns, ') for x in dtypes.values()):
raise NotImplementedError('table="orient" can not yet read timezone '
'data')
# No ISO constructor for Timedelta as of yet, so need to raise
if 'timedelta64' in dtypes.values():
raise NotImplementedError('table="orient" can not yet read '
'ISO-formatted Timedelta data')
df = df.astype(dtypes)
if 'primaryKey' in table['schema']:
df = df.set_index(table['schema']['primaryKey'])
if len(df.index.names) == 1:
if df.index.name == 'index':
df.index.name = None
else:
df.index.names = [None if x.startswith('level_') else x for x in
df.index.names]
return df | def parse_table_schema(json, precise_float):
"""
Builds a DataFrame from a given schema
Parameters
----------
json :
A JSON table schema
precise_float : boolean
Flag controlling precision when decoding string to double values, as
dictated by ``read_json``
Returns
-------
df : DataFrame
Raises
------
NotImplementedError
If the JSON table schema contains either timezone or timedelta data
Notes
-----
Because :func:`DataFrame.to_json` uses the string 'index' to denote a
name-less :class:`Index`, this function sets the name of the returned
:class:`DataFrame` to ``None`` when said string is encountered with a
normal :class:`Index`. For a :class:`MultiIndex`, the same limitation
applies to any strings beginning with 'level_'. Therefore, an
:class:`Index` name of 'index' and :class:`MultiIndex` names starting
with 'level_' are not supported.
See Also
--------
build_table_schema : Inverse function.
pandas.read_json
"""
table = loads(json, precise_float=precise_float)
col_order = [field['name'] for field in table['schema']['fields']]
df = DataFrame(table['data'], columns=col_order)[col_order]
dtypes = {field['name']: convert_json_field_to_pandas_type(field)
for field in table['schema']['fields']}
# Cannot directly use as_type with timezone data on object; raise for now
if any(str(x).startswith('datetime64[ns, ') for x in dtypes.values()):
raise NotImplementedError('table="orient" can not yet read timezone '
'data')
# No ISO constructor for Timedelta as of yet, so need to raise
if 'timedelta64' in dtypes.values():
raise NotImplementedError('table="orient" can not yet read '
'ISO-formatted Timedelta data')
df = df.astype(dtypes)
if 'primaryKey' in table['schema']:
df = df.set_index(table['schema']['primaryKey'])
if len(df.index.names) == 1:
if df.index.name == 'index':
df.index.name = None
else:
df.index.names = [None if x.startswith('level_') else x for x in
df.index.names]
return df | [
"Builds",
"a",
"DataFrame",
"from",
"a",
"given",
"schema"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/io/json/table_schema.py#L262-L326 | [
"def",
"parse_table_schema",
"(",
"json",
",",
"precise_float",
")",
":",
"table",
"=",
"loads",
"(",
"json",
",",
"precise_float",
"=",
"precise_float",
")",
"col_order",
"=",
"[",
"field",
"[",
"'name'",
"]",
"for",
"field",
"in",
"table",
"[",
"'schema'",
"]",
"[",
"'fields'",
"]",
"]",
"df",
"=",
"DataFrame",
"(",
"table",
"[",
"'data'",
"]",
",",
"columns",
"=",
"col_order",
")",
"[",
"col_order",
"]",
"dtypes",
"=",
"{",
"field",
"[",
"'name'",
"]",
":",
"convert_json_field_to_pandas_type",
"(",
"field",
")",
"for",
"field",
"in",
"table",
"[",
"'schema'",
"]",
"[",
"'fields'",
"]",
"}",
"# Cannot directly use as_type with timezone data on object; raise for now",
"if",
"any",
"(",
"str",
"(",
"x",
")",
".",
"startswith",
"(",
"'datetime64[ns, '",
")",
"for",
"x",
"in",
"dtypes",
".",
"values",
"(",
")",
")",
":",
"raise",
"NotImplementedError",
"(",
"'table=\"orient\" can not yet read timezone '",
"'data'",
")",
"# No ISO constructor for Timedelta as of yet, so need to raise",
"if",
"'timedelta64'",
"in",
"dtypes",
".",
"values",
"(",
")",
":",
"raise",
"NotImplementedError",
"(",
"'table=\"orient\" can not yet read '",
"'ISO-formatted Timedelta data'",
")",
"df",
"=",
"df",
".",
"astype",
"(",
"dtypes",
")",
"if",
"'primaryKey'",
"in",
"table",
"[",
"'schema'",
"]",
":",
"df",
"=",
"df",
".",
"set_index",
"(",
"table",
"[",
"'schema'",
"]",
"[",
"'primaryKey'",
"]",
")",
"if",
"len",
"(",
"df",
".",
"index",
".",
"names",
")",
"==",
"1",
":",
"if",
"df",
".",
"index",
".",
"name",
"==",
"'index'",
":",
"df",
".",
"index",
".",
"name",
"=",
"None",
"else",
":",
"df",
".",
"index",
".",
"names",
"=",
"[",
"None",
"if",
"x",
".",
"startswith",
"(",
"'level_'",
")",
"else",
"x",
"for",
"x",
"in",
"df",
".",
"index",
".",
"names",
"]",
"return",
"df"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | get_op_result_name | Find the appropriate name to pin to an operation result. This result
should always be either an Index or a Series.
Parameters
----------
left : {Series, Index}
right : object
Returns
-------
name : object
Usually a string | pandas/core/ops.py | def get_op_result_name(left, right):
"""
Find the appropriate name to pin to an operation result. This result
should always be either an Index or a Series.
Parameters
----------
left : {Series, Index}
right : object
Returns
-------
name : object
Usually a string
"""
# `left` is always a pd.Series when called from within ops
if isinstance(right, (ABCSeries, pd.Index)):
name = _maybe_match_name(left, right)
else:
name = left.name
return name | def get_op_result_name(left, right):
"""
Find the appropriate name to pin to an operation result. This result
should always be either an Index or a Series.
Parameters
----------
left : {Series, Index}
right : object
Returns
-------
name : object
Usually a string
"""
# `left` is always a pd.Series when called from within ops
if isinstance(right, (ABCSeries, pd.Index)):
name = _maybe_match_name(left, right)
else:
name = left.name
return name | [
"Find",
"the",
"appropriate",
"name",
"to",
"pin",
"to",
"an",
"operation",
"result",
".",
"This",
"result",
"should",
"always",
"be",
"either",
"an",
"Index",
"or",
"a",
"Series",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L38-L58 | [
"def",
"get_op_result_name",
"(",
"left",
",",
"right",
")",
":",
"# `left` is always a pd.Series when called from within ops",
"if",
"isinstance",
"(",
"right",
",",
"(",
"ABCSeries",
",",
"pd",
".",
"Index",
")",
")",
":",
"name",
"=",
"_maybe_match_name",
"(",
"left",
",",
"right",
")",
"else",
":",
"name",
"=",
"left",
".",
"name",
"return",
"name"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _maybe_match_name | Try to find a name to attach to the result of an operation between
a and b. If only one of these has a `name` attribute, return that
name. Otherwise return a consensus name if they match of None if
they have different names.
Parameters
----------
a : object
b : object
Returns
-------
name : str or None
See Also
--------
pandas.core.common.consensus_name_attr | pandas/core/ops.py | def _maybe_match_name(a, b):
"""
Try to find a name to attach to the result of an operation between
a and b. If only one of these has a `name` attribute, return that
name. Otherwise return a consensus name if they match of None if
they have different names.
Parameters
----------
a : object
b : object
Returns
-------
name : str or None
See Also
--------
pandas.core.common.consensus_name_attr
"""
a_has = hasattr(a, 'name')
b_has = hasattr(b, 'name')
if a_has and b_has:
if a.name == b.name:
return a.name
else:
# TODO: what if they both have np.nan for their names?
return None
elif a_has:
return a.name
elif b_has:
return b.name
return None | def _maybe_match_name(a, b):
"""
Try to find a name to attach to the result of an operation between
a and b. If only one of these has a `name` attribute, return that
name. Otherwise return a consensus name if they match of None if
they have different names.
Parameters
----------
a : object
b : object
Returns
-------
name : str or None
See Also
--------
pandas.core.common.consensus_name_attr
"""
a_has = hasattr(a, 'name')
b_has = hasattr(b, 'name')
if a_has and b_has:
if a.name == b.name:
return a.name
else:
# TODO: what if they both have np.nan for their names?
return None
elif a_has:
return a.name
elif b_has:
return b.name
return None | [
"Try",
"to",
"find",
"a",
"name",
"to",
"attach",
"to",
"the",
"result",
"of",
"an",
"operation",
"between",
"a",
"and",
"b",
".",
"If",
"only",
"one",
"of",
"these",
"has",
"a",
"name",
"attribute",
"return",
"that",
"name",
".",
"Otherwise",
"return",
"a",
"consensus",
"name",
"if",
"they",
"match",
"of",
"None",
"if",
"they",
"have",
"different",
"names",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L61-L93 | [
"def",
"_maybe_match_name",
"(",
"a",
",",
"b",
")",
":",
"a_has",
"=",
"hasattr",
"(",
"a",
",",
"'name'",
")",
"b_has",
"=",
"hasattr",
"(",
"b",
",",
"'name'",
")",
"if",
"a_has",
"and",
"b_has",
":",
"if",
"a",
".",
"name",
"==",
"b",
".",
"name",
":",
"return",
"a",
".",
"name",
"else",
":",
"# TODO: what if they both have np.nan for their names?",
"return",
"None",
"elif",
"a_has",
":",
"return",
"a",
".",
"name",
"elif",
"b_has",
":",
"return",
"b",
".",
"name",
"return",
"None"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | maybe_upcast_for_op | Cast non-pandas objects to pandas types to unify behavior of arithmetic
and comparison operations.
Parameters
----------
obj: object
Returns
-------
out : object
Notes
-----
Be careful to call this *after* determining the `name` attribute to be
attached to the result of the arithmetic operation. | pandas/core/ops.py | def maybe_upcast_for_op(obj):
"""
Cast non-pandas objects to pandas types to unify behavior of arithmetic
and comparison operations.
Parameters
----------
obj: object
Returns
-------
out : object
Notes
-----
Be careful to call this *after* determining the `name` attribute to be
attached to the result of the arithmetic operation.
"""
if type(obj) is datetime.timedelta:
# GH#22390 cast up to Timedelta to rely on Timedelta
# implementation; otherwise operation against numeric-dtype
# raises TypeError
return pd.Timedelta(obj)
elif isinstance(obj, np.timedelta64) and not isna(obj):
# In particular non-nanosecond timedelta64 needs to be cast to
# nanoseconds, or else we get undesired behavior like
# np.timedelta64(3, 'D') / 2 == np.timedelta64(1, 'D')
# The isna check is to avoid casting timedelta64("NaT"), which would
# return NaT and incorrectly be treated as a datetime-NaT.
return pd.Timedelta(obj)
elif isinstance(obj, np.ndarray) and is_timedelta64_dtype(obj):
# GH#22390 Unfortunately we need to special-case right-hand
# timedelta64 dtypes because numpy casts integer dtypes to
# timedelta64 when operating with timedelta64
return pd.TimedeltaIndex(obj)
return obj | def maybe_upcast_for_op(obj):
"""
Cast non-pandas objects to pandas types to unify behavior of arithmetic
and comparison operations.
Parameters
----------
obj: object
Returns
-------
out : object
Notes
-----
Be careful to call this *after* determining the `name` attribute to be
attached to the result of the arithmetic operation.
"""
if type(obj) is datetime.timedelta:
# GH#22390 cast up to Timedelta to rely on Timedelta
# implementation; otherwise operation against numeric-dtype
# raises TypeError
return pd.Timedelta(obj)
elif isinstance(obj, np.timedelta64) and not isna(obj):
# In particular non-nanosecond timedelta64 needs to be cast to
# nanoseconds, or else we get undesired behavior like
# np.timedelta64(3, 'D') / 2 == np.timedelta64(1, 'D')
# The isna check is to avoid casting timedelta64("NaT"), which would
# return NaT and incorrectly be treated as a datetime-NaT.
return pd.Timedelta(obj)
elif isinstance(obj, np.ndarray) and is_timedelta64_dtype(obj):
# GH#22390 Unfortunately we need to special-case right-hand
# timedelta64 dtypes because numpy casts integer dtypes to
# timedelta64 when operating with timedelta64
return pd.TimedeltaIndex(obj)
return obj | [
"Cast",
"non",
"-",
"pandas",
"objects",
"to",
"pandas",
"types",
"to",
"unify",
"behavior",
"of",
"arithmetic",
"and",
"comparison",
"operations",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L96-L131 | [
"def",
"maybe_upcast_for_op",
"(",
"obj",
")",
":",
"if",
"type",
"(",
"obj",
")",
"is",
"datetime",
".",
"timedelta",
":",
"# GH#22390 cast up to Timedelta to rely on Timedelta",
"# implementation; otherwise operation against numeric-dtype",
"# raises TypeError",
"return",
"pd",
".",
"Timedelta",
"(",
"obj",
")",
"elif",
"isinstance",
"(",
"obj",
",",
"np",
".",
"timedelta64",
")",
"and",
"not",
"isna",
"(",
"obj",
")",
":",
"# In particular non-nanosecond timedelta64 needs to be cast to",
"# nanoseconds, or else we get undesired behavior like",
"# np.timedelta64(3, 'D') / 2 == np.timedelta64(1, 'D')",
"# The isna check is to avoid casting timedelta64(\"NaT\"), which would",
"# return NaT and incorrectly be treated as a datetime-NaT.",
"return",
"pd",
".",
"Timedelta",
"(",
"obj",
")",
"elif",
"isinstance",
"(",
"obj",
",",
"np",
".",
"ndarray",
")",
"and",
"is_timedelta64_dtype",
"(",
"obj",
")",
":",
"# GH#22390 Unfortunately we need to special-case right-hand",
"# timedelta64 dtypes because numpy casts integer dtypes to",
"# timedelta64 when operating with timedelta64",
"return",
"pd",
".",
"TimedeltaIndex",
"(",
"obj",
")",
"return",
"obj"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | make_invalid_op | Return a binary method that always raises a TypeError.
Parameters
----------
name : str
Returns
-------
invalid_op : function | pandas/core/ops.py | def make_invalid_op(name):
"""
Return a binary method that always raises a TypeError.
Parameters
----------
name : str
Returns
-------
invalid_op : function
"""
def invalid_op(self, other=None):
raise TypeError("cannot perform {name} with this index type: "
"{typ}".format(name=name, typ=type(self).__name__))
invalid_op.__name__ = name
return invalid_op | def make_invalid_op(name):
"""
Return a binary method that always raises a TypeError.
Parameters
----------
name : str
Returns
-------
invalid_op : function
"""
def invalid_op(self, other=None):
raise TypeError("cannot perform {name} with this index type: "
"{typ}".format(name=name, typ=type(self).__name__))
invalid_op.__name__ = name
return invalid_op | [
"Return",
"a",
"binary",
"method",
"that",
"always",
"raises",
"a",
"TypeError",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L195-L212 | [
"def",
"make_invalid_op",
"(",
"name",
")",
":",
"def",
"invalid_op",
"(",
"self",
",",
"other",
"=",
"None",
")",
":",
"raise",
"TypeError",
"(",
"\"cannot perform {name} with this index type: \"",
"\"{typ}\"",
".",
"format",
"(",
"name",
"=",
"name",
",",
"typ",
"=",
"type",
"(",
"self",
")",
".",
"__name__",
")",
")",
"invalid_op",
".",
"__name__",
"=",
"name",
"return",
"invalid_op"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _gen_eval_kwargs | Find the keyword arguments to pass to numexpr for the given operation.
Parameters
----------
name : str
Returns
-------
eval_kwargs : dict
Examples
--------
>>> _gen_eval_kwargs("__add__")
{}
>>> _gen_eval_kwargs("rtruediv")
{'reversed': True, 'truediv': True} | pandas/core/ops.py | def _gen_eval_kwargs(name):
"""
Find the keyword arguments to pass to numexpr for the given operation.
Parameters
----------
name : str
Returns
-------
eval_kwargs : dict
Examples
--------
>>> _gen_eval_kwargs("__add__")
{}
>>> _gen_eval_kwargs("rtruediv")
{'reversed': True, 'truediv': True}
"""
kwargs = {}
# Series and Panel appear to only pass __add__, __radd__, ...
# but DataFrame gets both these dunder names _and_ non-dunder names
# add, radd, ...
name = name.replace('__', '')
if name.startswith('r'):
if name not in ['radd', 'rand', 'ror', 'rxor']:
# Exclude commutative operations
kwargs['reversed'] = True
if name in ['truediv', 'rtruediv']:
kwargs['truediv'] = True
if name in ['ne']:
kwargs['masker'] = True
return kwargs | def _gen_eval_kwargs(name):
"""
Find the keyword arguments to pass to numexpr for the given operation.
Parameters
----------
name : str
Returns
-------
eval_kwargs : dict
Examples
--------
>>> _gen_eval_kwargs("__add__")
{}
>>> _gen_eval_kwargs("rtruediv")
{'reversed': True, 'truediv': True}
"""
kwargs = {}
# Series and Panel appear to only pass __add__, __radd__, ...
# but DataFrame gets both these dunder names _and_ non-dunder names
# add, radd, ...
name = name.replace('__', '')
if name.startswith('r'):
if name not in ['radd', 'rand', 'ror', 'rxor']:
# Exclude commutative operations
kwargs['reversed'] = True
if name in ['truediv', 'rtruediv']:
kwargs['truediv'] = True
if name in ['ne']:
kwargs['masker'] = True
return kwargs | [
"Find",
"the",
"keyword",
"arguments",
"to",
"pass",
"to",
"numexpr",
"for",
"the",
"given",
"operation",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L215-L253 | [
"def",
"_gen_eval_kwargs",
"(",
"name",
")",
":",
"kwargs",
"=",
"{",
"}",
"# Series and Panel appear to only pass __add__, __radd__, ...",
"# but DataFrame gets both these dunder names _and_ non-dunder names",
"# add, radd, ...",
"name",
"=",
"name",
".",
"replace",
"(",
"'__'",
",",
"''",
")",
"if",
"name",
".",
"startswith",
"(",
"'r'",
")",
":",
"if",
"name",
"not",
"in",
"[",
"'radd'",
",",
"'rand'",
",",
"'ror'",
",",
"'rxor'",
"]",
":",
"# Exclude commutative operations",
"kwargs",
"[",
"'reversed'",
"]",
"=",
"True",
"if",
"name",
"in",
"[",
"'truediv'",
",",
"'rtruediv'",
"]",
":",
"kwargs",
"[",
"'truediv'",
"]",
"=",
"True",
"if",
"name",
"in",
"[",
"'ne'",
"]",
":",
"kwargs",
"[",
"'masker'",
"]",
"=",
"True",
"return",
"kwargs"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _gen_fill_zeros | Find the appropriate fill value to use when filling in undefined values
in the results of the given operation caused by operating on
(generally dividing by) zero.
Parameters
----------
name : str
Returns
-------
fill_value : {None, np.nan, np.inf} | pandas/core/ops.py | def _gen_fill_zeros(name):
"""
Find the appropriate fill value to use when filling in undefined values
in the results of the given operation caused by operating on
(generally dividing by) zero.
Parameters
----------
name : str
Returns
-------
fill_value : {None, np.nan, np.inf}
"""
name = name.strip('__')
if 'div' in name:
# truediv, floordiv, div, and reversed variants
fill_value = np.inf
elif 'mod' in name:
# mod, rmod
fill_value = np.nan
else:
fill_value = None
return fill_value | def _gen_fill_zeros(name):
"""
Find the appropriate fill value to use when filling in undefined values
in the results of the given operation caused by operating on
(generally dividing by) zero.
Parameters
----------
name : str
Returns
-------
fill_value : {None, np.nan, np.inf}
"""
name = name.strip('__')
if 'div' in name:
# truediv, floordiv, div, and reversed variants
fill_value = np.inf
elif 'mod' in name:
# mod, rmod
fill_value = np.nan
else:
fill_value = None
return fill_value | [
"Find",
"the",
"appropriate",
"fill",
"value",
"to",
"use",
"when",
"filling",
"in",
"undefined",
"values",
"in",
"the",
"results",
"of",
"the",
"given",
"operation",
"caused",
"by",
"operating",
"on",
"(",
"generally",
"dividing",
"by",
")",
"zero",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L256-L279 | [
"def",
"_gen_fill_zeros",
"(",
"name",
")",
":",
"name",
"=",
"name",
".",
"strip",
"(",
"'__'",
")",
"if",
"'div'",
"in",
"name",
":",
"# truediv, floordiv, div, and reversed variants",
"fill_value",
"=",
"np",
".",
"inf",
"elif",
"'mod'",
"in",
"name",
":",
"# mod, rmod",
"fill_value",
"=",
"np",
".",
"nan",
"else",
":",
"fill_value",
"=",
"None",
"return",
"fill_value"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _get_opstr | Find the operation string, if any, to pass to numexpr for this
operation.
Parameters
----------
op : binary operator
cls : class
Returns
-------
op_str : string or None | pandas/core/ops.py | def _get_opstr(op, cls):
"""
Find the operation string, if any, to pass to numexpr for this
operation.
Parameters
----------
op : binary operator
cls : class
Returns
-------
op_str : string or None
"""
# numexpr is available for non-sparse classes
subtyp = getattr(cls, '_subtyp', '')
use_numexpr = 'sparse' not in subtyp
if not use_numexpr:
# if we're not using numexpr, then don't pass a str_rep
return None
return {operator.add: '+',
radd: '+',
operator.mul: '*',
rmul: '*',
operator.sub: '-',
rsub: '-',
operator.truediv: '/',
rtruediv: '/',
operator.floordiv: '//',
rfloordiv: '//',
operator.mod: None, # TODO: Why None for mod but '%' for rmod?
rmod: '%',
operator.pow: '**',
rpow: '**',
operator.eq: '==',
operator.ne: '!=',
operator.le: '<=',
operator.lt: '<',
operator.ge: '>=',
operator.gt: '>',
operator.and_: '&',
rand_: '&',
operator.or_: '|',
ror_: '|',
operator.xor: '^',
rxor: '^',
divmod: None,
rdivmod: None}[op] | def _get_opstr(op, cls):
"""
Find the operation string, if any, to pass to numexpr for this
operation.
Parameters
----------
op : binary operator
cls : class
Returns
-------
op_str : string or None
"""
# numexpr is available for non-sparse classes
subtyp = getattr(cls, '_subtyp', '')
use_numexpr = 'sparse' not in subtyp
if not use_numexpr:
# if we're not using numexpr, then don't pass a str_rep
return None
return {operator.add: '+',
radd: '+',
operator.mul: '*',
rmul: '*',
operator.sub: '-',
rsub: '-',
operator.truediv: '/',
rtruediv: '/',
operator.floordiv: '//',
rfloordiv: '//',
operator.mod: None, # TODO: Why None for mod but '%' for rmod?
rmod: '%',
operator.pow: '**',
rpow: '**',
operator.eq: '==',
operator.ne: '!=',
operator.le: '<=',
operator.lt: '<',
operator.ge: '>=',
operator.gt: '>',
operator.and_: '&',
rand_: '&',
operator.or_: '|',
ror_: '|',
operator.xor: '^',
rxor: '^',
divmod: None,
rdivmod: None}[op] | [
"Find",
"the",
"operation",
"string",
"if",
"any",
"to",
"pass",
"to",
"numexpr",
"for",
"this",
"operation",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L307-L356 | [
"def",
"_get_opstr",
"(",
"op",
",",
"cls",
")",
":",
"# numexpr is available for non-sparse classes",
"subtyp",
"=",
"getattr",
"(",
"cls",
",",
"'_subtyp'",
",",
"''",
")",
"use_numexpr",
"=",
"'sparse'",
"not",
"in",
"subtyp",
"if",
"not",
"use_numexpr",
":",
"# if we're not using numexpr, then don't pass a str_rep",
"return",
"None",
"return",
"{",
"operator",
".",
"add",
":",
"'+'",
",",
"radd",
":",
"'+'",
",",
"operator",
".",
"mul",
":",
"'*'",
",",
"rmul",
":",
"'*'",
",",
"operator",
".",
"sub",
":",
"'-'",
",",
"rsub",
":",
"'-'",
",",
"operator",
".",
"truediv",
":",
"'/'",
",",
"rtruediv",
":",
"'/'",
",",
"operator",
".",
"floordiv",
":",
"'//'",
",",
"rfloordiv",
":",
"'//'",
",",
"operator",
".",
"mod",
":",
"None",
",",
"# TODO: Why None for mod but '%' for rmod?",
"rmod",
":",
"'%'",
",",
"operator",
".",
"pow",
":",
"'**'",
",",
"rpow",
":",
"'**'",
",",
"operator",
".",
"eq",
":",
"'=='",
",",
"operator",
".",
"ne",
":",
"'!='",
",",
"operator",
".",
"le",
":",
"'<='",
",",
"operator",
".",
"lt",
":",
"'<'",
",",
"operator",
".",
"ge",
":",
"'>='",
",",
"operator",
".",
"gt",
":",
"'>'",
",",
"operator",
".",
"and_",
":",
"'&'",
",",
"rand_",
":",
"'&'",
",",
"operator",
".",
"or_",
":",
"'|'",
",",
"ror_",
":",
"'|'",
",",
"operator",
".",
"xor",
":",
"'^'",
",",
"rxor",
":",
"'^'",
",",
"divmod",
":",
"None",
",",
"rdivmod",
":",
"None",
"}",
"[",
"op",
"]"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _get_op_name | Find the name to attach to this method according to conventions
for special and non-special methods.
Parameters
----------
op : binary operator
special : bool
Returns
-------
op_name : str | pandas/core/ops.py | def _get_op_name(op, special):
"""
Find the name to attach to this method according to conventions
for special and non-special methods.
Parameters
----------
op : binary operator
special : bool
Returns
-------
op_name : str
"""
opname = op.__name__.strip('_')
if special:
opname = '__{opname}__'.format(opname=opname)
return opname | def _get_op_name(op, special):
"""
Find the name to attach to this method according to conventions
for special and non-special methods.
Parameters
----------
op : binary operator
special : bool
Returns
-------
op_name : str
"""
opname = op.__name__.strip('_')
if special:
opname = '__{opname}__'.format(opname=opname)
return opname | [
"Find",
"the",
"name",
"to",
"attach",
"to",
"this",
"method",
"according",
"to",
"conventions",
"for",
"special",
"and",
"non",
"-",
"special",
"methods",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L359-L376 | [
"def",
"_get_op_name",
"(",
"op",
",",
"special",
")",
":",
"opname",
"=",
"op",
".",
"__name__",
".",
"strip",
"(",
"'_'",
")",
"if",
"special",
":",
"opname",
"=",
"'__{opname}__'",
".",
"format",
"(",
"opname",
"=",
"opname",
")",
"return",
"opname"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _make_flex_doc | Make the appropriate substitutions for the given operation and class-typ
into either _flex_doc_SERIES or _flex_doc_FRAME to return the docstring
to attach to a generated method.
Parameters
----------
op_name : str {'__add__', '__sub__', ... '__eq__', '__ne__', ...}
typ : str {series, 'dataframe']}
Returns
-------
doc : str | pandas/core/ops.py | def _make_flex_doc(op_name, typ):
"""
Make the appropriate substitutions for the given operation and class-typ
into either _flex_doc_SERIES or _flex_doc_FRAME to return the docstring
to attach to a generated method.
Parameters
----------
op_name : str {'__add__', '__sub__', ... '__eq__', '__ne__', ...}
typ : str {series, 'dataframe']}
Returns
-------
doc : str
"""
op_name = op_name.replace('__', '')
op_desc = _op_descriptions[op_name]
if op_desc['reversed']:
equiv = 'other ' + op_desc['op'] + ' ' + typ
else:
equiv = typ + ' ' + op_desc['op'] + ' other'
if typ == 'series':
base_doc = _flex_doc_SERIES
doc_no_examples = base_doc.format(
desc=op_desc['desc'],
op_name=op_name,
equiv=equiv,
reverse=op_desc['reverse']
)
if op_desc['series_examples']:
doc = doc_no_examples + op_desc['series_examples']
else:
doc = doc_no_examples
elif typ == 'dataframe':
base_doc = _flex_doc_FRAME
doc = base_doc.format(
desc=op_desc['desc'],
op_name=op_name,
equiv=equiv,
reverse=op_desc['reverse']
)
elif typ == 'panel':
base_doc = _flex_doc_PANEL
doc = base_doc.format(
desc=op_desc['desc'],
op_name=op_name,
equiv=equiv,
reverse=op_desc['reverse']
)
else:
raise AssertionError('Invalid typ argument.')
return doc | def _make_flex_doc(op_name, typ):
"""
Make the appropriate substitutions for the given operation and class-typ
into either _flex_doc_SERIES or _flex_doc_FRAME to return the docstring
to attach to a generated method.
Parameters
----------
op_name : str {'__add__', '__sub__', ... '__eq__', '__ne__', ...}
typ : str {series, 'dataframe']}
Returns
-------
doc : str
"""
op_name = op_name.replace('__', '')
op_desc = _op_descriptions[op_name]
if op_desc['reversed']:
equiv = 'other ' + op_desc['op'] + ' ' + typ
else:
equiv = typ + ' ' + op_desc['op'] + ' other'
if typ == 'series':
base_doc = _flex_doc_SERIES
doc_no_examples = base_doc.format(
desc=op_desc['desc'],
op_name=op_name,
equiv=equiv,
reverse=op_desc['reverse']
)
if op_desc['series_examples']:
doc = doc_no_examples + op_desc['series_examples']
else:
doc = doc_no_examples
elif typ == 'dataframe':
base_doc = _flex_doc_FRAME
doc = base_doc.format(
desc=op_desc['desc'],
op_name=op_name,
equiv=equiv,
reverse=op_desc['reverse']
)
elif typ == 'panel':
base_doc = _flex_doc_PANEL
doc = base_doc.format(
desc=op_desc['desc'],
op_name=op_name,
equiv=equiv,
reverse=op_desc['reverse']
)
else:
raise AssertionError('Invalid typ argument.')
return doc | [
"Make",
"the",
"appropriate",
"substitutions",
"for",
"the",
"given",
"operation",
"and",
"class",
"-",
"typ",
"into",
"either",
"_flex_doc_SERIES",
"or",
"_flex_doc_FRAME",
"to",
"return",
"the",
"docstring",
"to",
"attach",
"to",
"a",
"generated",
"method",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1029-L1082 | [
"def",
"_make_flex_doc",
"(",
"op_name",
",",
"typ",
")",
":",
"op_name",
"=",
"op_name",
".",
"replace",
"(",
"'__'",
",",
"''",
")",
"op_desc",
"=",
"_op_descriptions",
"[",
"op_name",
"]",
"if",
"op_desc",
"[",
"'reversed'",
"]",
":",
"equiv",
"=",
"'other '",
"+",
"op_desc",
"[",
"'op'",
"]",
"+",
"' '",
"+",
"typ",
"else",
":",
"equiv",
"=",
"typ",
"+",
"' '",
"+",
"op_desc",
"[",
"'op'",
"]",
"+",
"' other'",
"if",
"typ",
"==",
"'series'",
":",
"base_doc",
"=",
"_flex_doc_SERIES",
"doc_no_examples",
"=",
"base_doc",
".",
"format",
"(",
"desc",
"=",
"op_desc",
"[",
"'desc'",
"]",
",",
"op_name",
"=",
"op_name",
",",
"equiv",
"=",
"equiv",
",",
"reverse",
"=",
"op_desc",
"[",
"'reverse'",
"]",
")",
"if",
"op_desc",
"[",
"'series_examples'",
"]",
":",
"doc",
"=",
"doc_no_examples",
"+",
"op_desc",
"[",
"'series_examples'",
"]",
"else",
":",
"doc",
"=",
"doc_no_examples",
"elif",
"typ",
"==",
"'dataframe'",
":",
"base_doc",
"=",
"_flex_doc_FRAME",
"doc",
"=",
"base_doc",
".",
"format",
"(",
"desc",
"=",
"op_desc",
"[",
"'desc'",
"]",
",",
"op_name",
"=",
"op_name",
",",
"equiv",
"=",
"equiv",
",",
"reverse",
"=",
"op_desc",
"[",
"'reverse'",
"]",
")",
"elif",
"typ",
"==",
"'panel'",
":",
"base_doc",
"=",
"_flex_doc_PANEL",
"doc",
"=",
"base_doc",
".",
"format",
"(",
"desc",
"=",
"op_desc",
"[",
"'desc'",
"]",
",",
"op_name",
"=",
"op_name",
",",
"equiv",
"=",
"equiv",
",",
"reverse",
"=",
"op_desc",
"[",
"'reverse'",
"]",
")",
"else",
":",
"raise",
"AssertionError",
"(",
"'Invalid typ argument.'",
")",
"return",
"doc"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | fill_binop | If a non-None fill_value is given, replace null entries in left and right
with this value, but only in positions where _one_ of left/right is null,
not both.
Parameters
----------
left : array-like
right : array-like
fill_value : object
Returns
-------
left : array-like
right : array-like
Notes
-----
Makes copies if fill_value is not None | pandas/core/ops.py | def fill_binop(left, right, fill_value):
"""
If a non-None fill_value is given, replace null entries in left and right
with this value, but only in positions where _one_ of left/right is null,
not both.
Parameters
----------
left : array-like
right : array-like
fill_value : object
Returns
-------
left : array-like
right : array-like
Notes
-----
Makes copies if fill_value is not None
"""
# TODO: can we make a no-copy implementation?
if fill_value is not None:
left_mask = isna(left)
right_mask = isna(right)
left = left.copy()
right = right.copy()
# one but not both
mask = left_mask ^ right_mask
left[left_mask & mask] = fill_value
right[right_mask & mask] = fill_value
return left, right | def fill_binop(left, right, fill_value):
"""
If a non-None fill_value is given, replace null entries in left and right
with this value, but only in positions where _one_ of left/right is null,
not both.
Parameters
----------
left : array-like
right : array-like
fill_value : object
Returns
-------
left : array-like
right : array-like
Notes
-----
Makes copies if fill_value is not None
"""
# TODO: can we make a no-copy implementation?
if fill_value is not None:
left_mask = isna(left)
right_mask = isna(right)
left = left.copy()
right = right.copy()
# one but not both
mask = left_mask ^ right_mask
left[left_mask & mask] = fill_value
right[right_mask & mask] = fill_value
return left, right | [
"If",
"a",
"non",
"-",
"None",
"fill_value",
"is",
"given",
"replace",
"null",
"entries",
"in",
"left",
"and",
"right",
"with",
"this",
"value",
"but",
"only",
"in",
"positions",
"where",
"_one_",
"of",
"left",
"/",
"right",
"is",
"null",
"not",
"both",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1088-L1120 | [
"def",
"fill_binop",
"(",
"left",
",",
"right",
",",
"fill_value",
")",
":",
"# TODO: can we make a no-copy implementation?",
"if",
"fill_value",
"is",
"not",
"None",
":",
"left_mask",
"=",
"isna",
"(",
"left",
")",
"right_mask",
"=",
"isna",
"(",
"right",
")",
"left",
"=",
"left",
".",
"copy",
"(",
")",
"right",
"=",
"right",
".",
"copy",
"(",
")",
"# one but not both",
"mask",
"=",
"left_mask",
"^",
"right_mask",
"left",
"[",
"left_mask",
"&",
"mask",
"]",
"=",
"fill_value",
"right",
"[",
"right_mask",
"&",
"mask",
"]",
"=",
"fill_value",
"return",
"left",
",",
"right"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | mask_cmp_op | Apply the function `op` to only non-null points in x and y.
Parameters
----------
x : array-like
y : array-like
op : binary operation
allowed_types : class or tuple of classes
Returns
-------
result : ndarray[bool] | pandas/core/ops.py | def mask_cmp_op(x, y, op, allowed_types):
"""
Apply the function `op` to only non-null points in x and y.
Parameters
----------
x : array-like
y : array-like
op : binary operation
allowed_types : class or tuple of classes
Returns
-------
result : ndarray[bool]
"""
# TODO: Can we make the allowed_types arg unnecessary?
xrav = x.ravel()
result = np.empty(x.size, dtype=bool)
if isinstance(y, allowed_types):
yrav = y.ravel()
mask = notna(xrav) & notna(yrav)
result[mask] = op(np.array(list(xrav[mask])),
np.array(list(yrav[mask])))
else:
mask = notna(xrav)
result[mask] = op(np.array(list(xrav[mask])), y)
if op == operator.ne: # pragma: no cover
np.putmask(result, ~mask, True)
else:
np.putmask(result, ~mask, False)
result = result.reshape(x.shape)
return result | def mask_cmp_op(x, y, op, allowed_types):
"""
Apply the function `op` to only non-null points in x and y.
Parameters
----------
x : array-like
y : array-like
op : binary operation
allowed_types : class or tuple of classes
Returns
-------
result : ndarray[bool]
"""
# TODO: Can we make the allowed_types arg unnecessary?
xrav = x.ravel()
result = np.empty(x.size, dtype=bool)
if isinstance(y, allowed_types):
yrav = y.ravel()
mask = notna(xrav) & notna(yrav)
result[mask] = op(np.array(list(xrav[mask])),
np.array(list(yrav[mask])))
else:
mask = notna(xrav)
result[mask] = op(np.array(list(xrav[mask])), y)
if op == operator.ne: # pragma: no cover
np.putmask(result, ~mask, True)
else:
np.putmask(result, ~mask, False)
result = result.reshape(x.shape)
return result | [
"Apply",
"the",
"function",
"op",
"to",
"only",
"non",
"-",
"null",
"points",
"in",
"x",
"and",
"y",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1123-L1155 | [
"def",
"mask_cmp_op",
"(",
"x",
",",
"y",
",",
"op",
",",
"allowed_types",
")",
":",
"# TODO: Can we make the allowed_types arg unnecessary?",
"xrav",
"=",
"x",
".",
"ravel",
"(",
")",
"result",
"=",
"np",
".",
"empty",
"(",
"x",
".",
"size",
",",
"dtype",
"=",
"bool",
")",
"if",
"isinstance",
"(",
"y",
",",
"allowed_types",
")",
":",
"yrav",
"=",
"y",
".",
"ravel",
"(",
")",
"mask",
"=",
"notna",
"(",
"xrav",
")",
"&",
"notna",
"(",
"yrav",
")",
"result",
"[",
"mask",
"]",
"=",
"op",
"(",
"np",
".",
"array",
"(",
"list",
"(",
"xrav",
"[",
"mask",
"]",
")",
")",
",",
"np",
".",
"array",
"(",
"list",
"(",
"yrav",
"[",
"mask",
"]",
")",
")",
")",
"else",
":",
"mask",
"=",
"notna",
"(",
"xrav",
")",
"result",
"[",
"mask",
"]",
"=",
"op",
"(",
"np",
".",
"array",
"(",
"list",
"(",
"xrav",
"[",
"mask",
"]",
")",
")",
",",
"y",
")",
"if",
"op",
"==",
"operator",
".",
"ne",
":",
"# pragma: no cover",
"np",
".",
"putmask",
"(",
"result",
",",
"~",
"mask",
",",
"True",
")",
"else",
":",
"np",
".",
"putmask",
"(",
"result",
",",
"~",
"mask",
",",
"False",
")",
"result",
"=",
"result",
".",
"reshape",
"(",
"x",
".",
"shape",
")",
"return",
"result"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | masked_arith_op | If the given arithmetic operation fails, attempt it again on
only the non-null elements of the input array(s).
Parameters
----------
x : np.ndarray
y : np.ndarray, Series, Index
op : binary operator | pandas/core/ops.py | def masked_arith_op(x, y, op):
"""
If the given arithmetic operation fails, attempt it again on
only the non-null elements of the input array(s).
Parameters
----------
x : np.ndarray
y : np.ndarray, Series, Index
op : binary operator
"""
# For Series `x` is 1D so ravel() is a no-op; calling it anyway makes
# the logic valid for both Series and DataFrame ops.
xrav = x.ravel()
assert isinstance(x, (np.ndarray, ABCSeries)), type(x)
if isinstance(y, (np.ndarray, ABCSeries, ABCIndexClass)):
dtype = find_common_type([x.dtype, y.dtype])
result = np.empty(x.size, dtype=dtype)
# PeriodIndex.ravel() returns int64 dtype, so we have
# to work around that case. See GH#19956
yrav = y if is_period_dtype(y) else y.ravel()
mask = notna(xrav) & notna(yrav)
if yrav.shape != mask.shape:
# FIXME: GH#5284, GH#5035, GH#19448
# Without specifically raising here we get mismatched
# errors in Py3 (TypeError) vs Py2 (ValueError)
# Note: Only = an issue in DataFrame case
raise ValueError('Cannot broadcast operands together.')
if mask.any():
with np.errstate(all='ignore'):
result[mask] = op(xrav[mask],
com.values_from_object(yrav[mask]))
else:
assert is_scalar(y), type(y)
assert isinstance(x, np.ndarray), type(x)
# mask is only meaningful for x
result = np.empty(x.size, dtype=x.dtype)
mask = notna(xrav)
# 1 ** np.nan is 1. So we have to unmask those.
if op == pow:
mask = np.where(x == 1, False, mask)
elif op == rpow:
mask = np.where(y == 1, False, mask)
if mask.any():
with np.errstate(all='ignore'):
result[mask] = op(xrav[mask], y)
result, changed = maybe_upcast_putmask(result, ~mask, np.nan)
result = result.reshape(x.shape) # 2D compat
return result | def masked_arith_op(x, y, op):
"""
If the given arithmetic operation fails, attempt it again on
only the non-null elements of the input array(s).
Parameters
----------
x : np.ndarray
y : np.ndarray, Series, Index
op : binary operator
"""
# For Series `x` is 1D so ravel() is a no-op; calling it anyway makes
# the logic valid for both Series and DataFrame ops.
xrav = x.ravel()
assert isinstance(x, (np.ndarray, ABCSeries)), type(x)
if isinstance(y, (np.ndarray, ABCSeries, ABCIndexClass)):
dtype = find_common_type([x.dtype, y.dtype])
result = np.empty(x.size, dtype=dtype)
# PeriodIndex.ravel() returns int64 dtype, so we have
# to work around that case. See GH#19956
yrav = y if is_period_dtype(y) else y.ravel()
mask = notna(xrav) & notna(yrav)
if yrav.shape != mask.shape:
# FIXME: GH#5284, GH#5035, GH#19448
# Without specifically raising here we get mismatched
# errors in Py3 (TypeError) vs Py2 (ValueError)
# Note: Only = an issue in DataFrame case
raise ValueError('Cannot broadcast operands together.')
if mask.any():
with np.errstate(all='ignore'):
result[mask] = op(xrav[mask],
com.values_from_object(yrav[mask]))
else:
assert is_scalar(y), type(y)
assert isinstance(x, np.ndarray), type(x)
# mask is only meaningful for x
result = np.empty(x.size, dtype=x.dtype)
mask = notna(xrav)
# 1 ** np.nan is 1. So we have to unmask those.
if op == pow:
mask = np.where(x == 1, False, mask)
elif op == rpow:
mask = np.where(y == 1, False, mask)
if mask.any():
with np.errstate(all='ignore'):
result[mask] = op(xrav[mask], y)
result, changed = maybe_upcast_putmask(result, ~mask, np.nan)
result = result.reshape(x.shape) # 2D compat
return result | [
"If",
"the",
"given",
"arithmetic",
"operation",
"fails",
"attempt",
"it",
"again",
"on",
"only",
"the",
"non",
"-",
"null",
"elements",
"of",
"the",
"input",
"array",
"(",
"s",
")",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1158-L1213 | [
"def",
"masked_arith_op",
"(",
"x",
",",
"y",
",",
"op",
")",
":",
"# For Series `x` is 1D so ravel() is a no-op; calling it anyway makes",
"# the logic valid for both Series and DataFrame ops.",
"xrav",
"=",
"x",
".",
"ravel",
"(",
")",
"assert",
"isinstance",
"(",
"x",
",",
"(",
"np",
".",
"ndarray",
",",
"ABCSeries",
")",
")",
",",
"type",
"(",
"x",
")",
"if",
"isinstance",
"(",
"y",
",",
"(",
"np",
".",
"ndarray",
",",
"ABCSeries",
",",
"ABCIndexClass",
")",
")",
":",
"dtype",
"=",
"find_common_type",
"(",
"[",
"x",
".",
"dtype",
",",
"y",
".",
"dtype",
"]",
")",
"result",
"=",
"np",
".",
"empty",
"(",
"x",
".",
"size",
",",
"dtype",
"=",
"dtype",
")",
"# PeriodIndex.ravel() returns int64 dtype, so we have",
"# to work around that case. See GH#19956",
"yrav",
"=",
"y",
"if",
"is_period_dtype",
"(",
"y",
")",
"else",
"y",
".",
"ravel",
"(",
")",
"mask",
"=",
"notna",
"(",
"xrav",
")",
"&",
"notna",
"(",
"yrav",
")",
"if",
"yrav",
".",
"shape",
"!=",
"mask",
".",
"shape",
":",
"# FIXME: GH#5284, GH#5035, GH#19448",
"# Without specifically raising here we get mismatched",
"# errors in Py3 (TypeError) vs Py2 (ValueError)",
"# Note: Only = an issue in DataFrame case",
"raise",
"ValueError",
"(",
"'Cannot broadcast operands together.'",
")",
"if",
"mask",
".",
"any",
"(",
")",
":",
"with",
"np",
".",
"errstate",
"(",
"all",
"=",
"'ignore'",
")",
":",
"result",
"[",
"mask",
"]",
"=",
"op",
"(",
"xrav",
"[",
"mask",
"]",
",",
"com",
".",
"values_from_object",
"(",
"yrav",
"[",
"mask",
"]",
")",
")",
"else",
":",
"assert",
"is_scalar",
"(",
"y",
")",
",",
"type",
"(",
"y",
")",
"assert",
"isinstance",
"(",
"x",
",",
"np",
".",
"ndarray",
")",
",",
"type",
"(",
"x",
")",
"# mask is only meaningful for x",
"result",
"=",
"np",
".",
"empty",
"(",
"x",
".",
"size",
",",
"dtype",
"=",
"x",
".",
"dtype",
")",
"mask",
"=",
"notna",
"(",
"xrav",
")",
"# 1 ** np.nan is 1. So we have to unmask those.",
"if",
"op",
"==",
"pow",
":",
"mask",
"=",
"np",
".",
"where",
"(",
"x",
"==",
"1",
",",
"False",
",",
"mask",
")",
"elif",
"op",
"==",
"rpow",
":",
"mask",
"=",
"np",
".",
"where",
"(",
"y",
"==",
"1",
",",
"False",
",",
"mask",
")",
"if",
"mask",
".",
"any",
"(",
")",
":",
"with",
"np",
".",
"errstate",
"(",
"all",
"=",
"'ignore'",
")",
":",
"result",
"[",
"mask",
"]",
"=",
"op",
"(",
"xrav",
"[",
"mask",
"]",
",",
"y",
")",
"result",
",",
"changed",
"=",
"maybe_upcast_putmask",
"(",
"result",
",",
"~",
"mask",
",",
"np",
".",
"nan",
")",
"result",
"=",
"result",
".",
"reshape",
"(",
"x",
".",
"shape",
")",
"# 2D compat",
"return",
"result"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | invalid_comparison | If a comparison has mismatched types and is not necessarily meaningful,
follow python3 conventions by:
- returning all-False for equality
- returning all-True for inequality
- raising TypeError otherwise
Parameters
----------
left : array-like
right : scalar, array-like
op : operator.{eq, ne, lt, le, gt}
Raises
------
TypeError : on inequality comparisons | pandas/core/ops.py | def invalid_comparison(left, right, op):
"""
If a comparison has mismatched types and is not necessarily meaningful,
follow python3 conventions by:
- returning all-False for equality
- returning all-True for inequality
- raising TypeError otherwise
Parameters
----------
left : array-like
right : scalar, array-like
op : operator.{eq, ne, lt, le, gt}
Raises
------
TypeError : on inequality comparisons
"""
if op is operator.eq:
res_values = np.zeros(left.shape, dtype=bool)
elif op is operator.ne:
res_values = np.ones(left.shape, dtype=bool)
else:
raise TypeError("Invalid comparison between dtype={dtype} and {typ}"
.format(dtype=left.dtype, typ=type(right).__name__))
return res_values | def invalid_comparison(left, right, op):
"""
If a comparison has mismatched types and is not necessarily meaningful,
follow python3 conventions by:
- returning all-False for equality
- returning all-True for inequality
- raising TypeError otherwise
Parameters
----------
left : array-like
right : scalar, array-like
op : operator.{eq, ne, lt, le, gt}
Raises
------
TypeError : on inequality comparisons
"""
if op is operator.eq:
res_values = np.zeros(left.shape, dtype=bool)
elif op is operator.ne:
res_values = np.ones(left.shape, dtype=bool)
else:
raise TypeError("Invalid comparison between dtype={dtype} and {typ}"
.format(dtype=left.dtype, typ=type(right).__name__))
return res_values | [
"If",
"a",
"comparison",
"has",
"mismatched",
"types",
"and",
"is",
"not",
"necessarily",
"meaningful",
"follow",
"python3",
"conventions",
"by",
":"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1216-L1242 | [
"def",
"invalid_comparison",
"(",
"left",
",",
"right",
",",
"op",
")",
":",
"if",
"op",
"is",
"operator",
".",
"eq",
":",
"res_values",
"=",
"np",
".",
"zeros",
"(",
"left",
".",
"shape",
",",
"dtype",
"=",
"bool",
")",
"elif",
"op",
"is",
"operator",
".",
"ne",
":",
"res_values",
"=",
"np",
".",
"ones",
"(",
"left",
".",
"shape",
",",
"dtype",
"=",
"bool",
")",
"else",
":",
"raise",
"TypeError",
"(",
"\"Invalid comparison between dtype={dtype} and {typ}\"",
".",
"format",
"(",
"dtype",
"=",
"left",
".",
"dtype",
",",
"typ",
"=",
"type",
"(",
"right",
")",
".",
"__name__",
")",
")",
"return",
"res_values"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | should_series_dispatch | Identify cases where a DataFrame operation should dispatch to its
Series counterpart.
Parameters
----------
left : DataFrame
right : DataFrame
op : binary operator
Returns
-------
override : bool | pandas/core/ops.py | def should_series_dispatch(left, right, op):
"""
Identify cases where a DataFrame operation should dispatch to its
Series counterpart.
Parameters
----------
left : DataFrame
right : DataFrame
op : binary operator
Returns
-------
override : bool
"""
if left._is_mixed_type or right._is_mixed_type:
return True
if not len(left.columns) or not len(right.columns):
# ensure obj.dtypes[0] exists for each obj
return False
ldtype = left.dtypes.iloc[0]
rdtype = right.dtypes.iloc[0]
if ((is_timedelta64_dtype(ldtype) and is_integer_dtype(rdtype)) or
(is_timedelta64_dtype(rdtype) and is_integer_dtype(ldtype))):
# numpy integer dtypes as timedelta64 dtypes in this scenario
return True
if is_datetime64_dtype(ldtype) and is_object_dtype(rdtype):
# in particular case where right is an array of DateOffsets
return True
return False | def should_series_dispatch(left, right, op):
"""
Identify cases where a DataFrame operation should dispatch to its
Series counterpart.
Parameters
----------
left : DataFrame
right : DataFrame
op : binary operator
Returns
-------
override : bool
"""
if left._is_mixed_type or right._is_mixed_type:
return True
if not len(left.columns) or not len(right.columns):
# ensure obj.dtypes[0] exists for each obj
return False
ldtype = left.dtypes.iloc[0]
rdtype = right.dtypes.iloc[0]
if ((is_timedelta64_dtype(ldtype) and is_integer_dtype(rdtype)) or
(is_timedelta64_dtype(rdtype) and is_integer_dtype(ldtype))):
# numpy integer dtypes as timedelta64 dtypes in this scenario
return True
if is_datetime64_dtype(ldtype) and is_object_dtype(rdtype):
# in particular case where right is an array of DateOffsets
return True
return False | [
"Identify",
"cases",
"where",
"a",
"DataFrame",
"operation",
"should",
"dispatch",
"to",
"its",
"Series",
"counterpart",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1248-L1282 | [
"def",
"should_series_dispatch",
"(",
"left",
",",
"right",
",",
"op",
")",
":",
"if",
"left",
".",
"_is_mixed_type",
"or",
"right",
".",
"_is_mixed_type",
":",
"return",
"True",
"if",
"not",
"len",
"(",
"left",
".",
"columns",
")",
"or",
"not",
"len",
"(",
"right",
".",
"columns",
")",
":",
"# ensure obj.dtypes[0] exists for each obj",
"return",
"False",
"ldtype",
"=",
"left",
".",
"dtypes",
".",
"iloc",
"[",
"0",
"]",
"rdtype",
"=",
"right",
".",
"dtypes",
".",
"iloc",
"[",
"0",
"]",
"if",
"(",
"(",
"is_timedelta64_dtype",
"(",
"ldtype",
")",
"and",
"is_integer_dtype",
"(",
"rdtype",
")",
")",
"or",
"(",
"is_timedelta64_dtype",
"(",
"rdtype",
")",
"and",
"is_integer_dtype",
"(",
"ldtype",
")",
")",
")",
":",
"# numpy integer dtypes as timedelta64 dtypes in this scenario",
"return",
"True",
"if",
"is_datetime64_dtype",
"(",
"ldtype",
")",
"and",
"is_object_dtype",
"(",
"rdtype",
")",
":",
"# in particular case where right is an array of DateOffsets",
"return",
"True",
"return",
"False"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | dispatch_to_series | Evaluate the frame operation func(left, right) by evaluating
column-by-column, dispatching to the Series implementation.
Parameters
----------
left : DataFrame
right : scalar or DataFrame
func : arithmetic or comparison operator
str_rep : str or None, default None
axis : {None, 0, 1, "index", "columns"}
Returns
-------
DataFrame | pandas/core/ops.py | def dispatch_to_series(left, right, func, str_rep=None, axis=None):
"""
Evaluate the frame operation func(left, right) by evaluating
column-by-column, dispatching to the Series implementation.
Parameters
----------
left : DataFrame
right : scalar or DataFrame
func : arithmetic or comparison operator
str_rep : str or None, default None
axis : {None, 0, 1, "index", "columns"}
Returns
-------
DataFrame
"""
# Note: we use iloc to access columns for compat with cases
# with non-unique columns.
import pandas.core.computation.expressions as expressions
right = lib.item_from_zerodim(right)
if lib.is_scalar(right) or np.ndim(right) == 0:
def column_op(a, b):
return {i: func(a.iloc[:, i], b)
for i in range(len(a.columns))}
elif isinstance(right, ABCDataFrame):
assert right._indexed_same(left)
def column_op(a, b):
return {i: func(a.iloc[:, i], b.iloc[:, i])
for i in range(len(a.columns))}
elif isinstance(right, ABCSeries) and axis == "columns":
# We only get here if called via left._combine_match_columns,
# in which case we specifically want to operate row-by-row
assert right.index.equals(left.columns)
def column_op(a, b):
return {i: func(a.iloc[:, i], b.iloc[i])
for i in range(len(a.columns))}
elif isinstance(right, ABCSeries):
assert right.index.equals(left.index) # Handle other cases later
def column_op(a, b):
return {i: func(a.iloc[:, i], b)
for i in range(len(a.columns))}
else:
# Remaining cases have less-obvious dispatch rules
raise NotImplementedError(right)
new_data = expressions.evaluate(column_op, str_rep, left, right)
result = left._constructor(new_data, index=left.index, copy=False)
# Pin columns instead of passing to constructor for compat with
# non-unique columns case
result.columns = left.columns
return result | def dispatch_to_series(left, right, func, str_rep=None, axis=None):
"""
Evaluate the frame operation func(left, right) by evaluating
column-by-column, dispatching to the Series implementation.
Parameters
----------
left : DataFrame
right : scalar or DataFrame
func : arithmetic or comparison operator
str_rep : str or None, default None
axis : {None, 0, 1, "index", "columns"}
Returns
-------
DataFrame
"""
# Note: we use iloc to access columns for compat with cases
# with non-unique columns.
import pandas.core.computation.expressions as expressions
right = lib.item_from_zerodim(right)
if lib.is_scalar(right) or np.ndim(right) == 0:
def column_op(a, b):
return {i: func(a.iloc[:, i], b)
for i in range(len(a.columns))}
elif isinstance(right, ABCDataFrame):
assert right._indexed_same(left)
def column_op(a, b):
return {i: func(a.iloc[:, i], b.iloc[:, i])
for i in range(len(a.columns))}
elif isinstance(right, ABCSeries) and axis == "columns":
# We only get here if called via left._combine_match_columns,
# in which case we specifically want to operate row-by-row
assert right.index.equals(left.columns)
def column_op(a, b):
return {i: func(a.iloc[:, i], b.iloc[i])
for i in range(len(a.columns))}
elif isinstance(right, ABCSeries):
assert right.index.equals(left.index) # Handle other cases later
def column_op(a, b):
return {i: func(a.iloc[:, i], b)
for i in range(len(a.columns))}
else:
# Remaining cases have less-obvious dispatch rules
raise NotImplementedError(right)
new_data = expressions.evaluate(column_op, str_rep, left, right)
result = left._constructor(new_data, index=left.index, copy=False)
# Pin columns instead of passing to constructor for compat with
# non-unique columns case
result.columns = left.columns
return result | [
"Evaluate",
"the",
"frame",
"operation",
"func",
"(",
"left",
"right",
")",
"by",
"evaluating",
"column",
"-",
"by",
"-",
"column",
"dispatching",
"to",
"the",
"Series",
"implementation",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1285-L1346 | [
"def",
"dispatch_to_series",
"(",
"left",
",",
"right",
",",
"func",
",",
"str_rep",
"=",
"None",
",",
"axis",
"=",
"None",
")",
":",
"# Note: we use iloc to access columns for compat with cases",
"# with non-unique columns.",
"import",
"pandas",
".",
"core",
".",
"computation",
".",
"expressions",
"as",
"expressions",
"right",
"=",
"lib",
".",
"item_from_zerodim",
"(",
"right",
")",
"if",
"lib",
".",
"is_scalar",
"(",
"right",
")",
"or",
"np",
".",
"ndim",
"(",
"right",
")",
"==",
"0",
":",
"def",
"column_op",
"(",
"a",
",",
"b",
")",
":",
"return",
"{",
"i",
":",
"func",
"(",
"a",
".",
"iloc",
"[",
":",
",",
"i",
"]",
",",
"b",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"a",
".",
"columns",
")",
")",
"}",
"elif",
"isinstance",
"(",
"right",
",",
"ABCDataFrame",
")",
":",
"assert",
"right",
".",
"_indexed_same",
"(",
"left",
")",
"def",
"column_op",
"(",
"a",
",",
"b",
")",
":",
"return",
"{",
"i",
":",
"func",
"(",
"a",
".",
"iloc",
"[",
":",
",",
"i",
"]",
",",
"b",
".",
"iloc",
"[",
":",
",",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"a",
".",
"columns",
")",
")",
"}",
"elif",
"isinstance",
"(",
"right",
",",
"ABCSeries",
")",
"and",
"axis",
"==",
"\"columns\"",
":",
"# We only get here if called via left._combine_match_columns,",
"# in which case we specifically want to operate row-by-row",
"assert",
"right",
".",
"index",
".",
"equals",
"(",
"left",
".",
"columns",
")",
"def",
"column_op",
"(",
"a",
",",
"b",
")",
":",
"return",
"{",
"i",
":",
"func",
"(",
"a",
".",
"iloc",
"[",
":",
",",
"i",
"]",
",",
"b",
".",
"iloc",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"a",
".",
"columns",
")",
")",
"}",
"elif",
"isinstance",
"(",
"right",
",",
"ABCSeries",
")",
":",
"assert",
"right",
".",
"index",
".",
"equals",
"(",
"left",
".",
"index",
")",
"# Handle other cases later",
"def",
"column_op",
"(",
"a",
",",
"b",
")",
":",
"return",
"{",
"i",
":",
"func",
"(",
"a",
".",
"iloc",
"[",
":",
",",
"i",
"]",
",",
"b",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"a",
".",
"columns",
")",
")",
"}",
"else",
":",
"# Remaining cases have less-obvious dispatch rules",
"raise",
"NotImplementedError",
"(",
"right",
")",
"new_data",
"=",
"expressions",
".",
"evaluate",
"(",
"column_op",
",",
"str_rep",
",",
"left",
",",
"right",
")",
"result",
"=",
"left",
".",
"_constructor",
"(",
"new_data",
",",
"index",
"=",
"left",
".",
"index",
",",
"copy",
"=",
"False",
")",
"# Pin columns instead of passing to constructor for compat with",
"# non-unique columns case",
"result",
".",
"columns",
"=",
"left",
".",
"columns",
"return",
"result"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | dispatch_to_index_op | Wrap Series left in the given index_class to delegate the operation op
to the index implementation. DatetimeIndex and TimedeltaIndex perform
type checking, timezone handling, overflow checks, etc.
Parameters
----------
op : binary operator (operator.add, operator.sub, ...)
left : Series
right : object
index_class : DatetimeIndex or TimedeltaIndex
Returns
-------
result : object, usually DatetimeIndex, TimedeltaIndex, or Series | pandas/core/ops.py | def dispatch_to_index_op(op, left, right, index_class):
"""
Wrap Series left in the given index_class to delegate the operation op
to the index implementation. DatetimeIndex and TimedeltaIndex perform
type checking, timezone handling, overflow checks, etc.
Parameters
----------
op : binary operator (operator.add, operator.sub, ...)
left : Series
right : object
index_class : DatetimeIndex or TimedeltaIndex
Returns
-------
result : object, usually DatetimeIndex, TimedeltaIndex, or Series
"""
left_idx = index_class(left)
# avoid accidentally allowing integer add/sub. For datetime64[tz] dtypes,
# left_idx may inherit a freq from a cached DatetimeIndex.
# See discussion in GH#19147.
if getattr(left_idx, 'freq', None) is not None:
left_idx = left_idx._shallow_copy(freq=None)
try:
result = op(left_idx, right)
except NullFrequencyError:
# DatetimeIndex and TimedeltaIndex with freq == None raise ValueError
# on add/sub of integers (or int-like). We re-raise as a TypeError.
raise TypeError('incompatible type for a datetime/timedelta '
'operation [{name}]'.format(name=op.__name__))
return result | def dispatch_to_index_op(op, left, right, index_class):
"""
Wrap Series left in the given index_class to delegate the operation op
to the index implementation. DatetimeIndex and TimedeltaIndex perform
type checking, timezone handling, overflow checks, etc.
Parameters
----------
op : binary operator (operator.add, operator.sub, ...)
left : Series
right : object
index_class : DatetimeIndex or TimedeltaIndex
Returns
-------
result : object, usually DatetimeIndex, TimedeltaIndex, or Series
"""
left_idx = index_class(left)
# avoid accidentally allowing integer add/sub. For datetime64[tz] dtypes,
# left_idx may inherit a freq from a cached DatetimeIndex.
# See discussion in GH#19147.
if getattr(left_idx, 'freq', None) is not None:
left_idx = left_idx._shallow_copy(freq=None)
try:
result = op(left_idx, right)
except NullFrequencyError:
# DatetimeIndex and TimedeltaIndex with freq == None raise ValueError
# on add/sub of integers (or int-like). We re-raise as a TypeError.
raise TypeError('incompatible type for a datetime/timedelta '
'operation [{name}]'.format(name=op.__name__))
return result | [
"Wrap",
"Series",
"left",
"in",
"the",
"given",
"index_class",
"to",
"delegate",
"the",
"operation",
"op",
"to",
"the",
"index",
"implementation",
".",
"DatetimeIndex",
"and",
"TimedeltaIndex",
"perform",
"type",
"checking",
"timezone",
"handling",
"overflow",
"checks",
"etc",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1349-L1380 | [
"def",
"dispatch_to_index_op",
"(",
"op",
",",
"left",
",",
"right",
",",
"index_class",
")",
":",
"left_idx",
"=",
"index_class",
"(",
"left",
")",
"# avoid accidentally allowing integer add/sub. For datetime64[tz] dtypes,",
"# left_idx may inherit a freq from a cached DatetimeIndex.",
"# See discussion in GH#19147.",
"if",
"getattr",
"(",
"left_idx",
",",
"'freq'",
",",
"None",
")",
"is",
"not",
"None",
":",
"left_idx",
"=",
"left_idx",
".",
"_shallow_copy",
"(",
"freq",
"=",
"None",
")",
"try",
":",
"result",
"=",
"op",
"(",
"left_idx",
",",
"right",
")",
"except",
"NullFrequencyError",
":",
"# DatetimeIndex and TimedeltaIndex with freq == None raise ValueError",
"# on add/sub of integers (or int-like). We re-raise as a TypeError.",
"raise",
"TypeError",
"(",
"'incompatible type for a datetime/timedelta '",
"'operation [{name}]'",
".",
"format",
"(",
"name",
"=",
"op",
".",
"__name__",
")",
")",
"return",
"result"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | dispatch_to_extension_op | Assume that left or right is a Series backed by an ExtensionArray,
apply the operator defined by op. | pandas/core/ops.py | def dispatch_to_extension_op(op, left, right):
"""
Assume that left or right is a Series backed by an ExtensionArray,
apply the operator defined by op.
"""
# The op calls will raise TypeError if the op is not defined
# on the ExtensionArray
# unbox Series and Index to arrays
if isinstance(left, (ABCSeries, ABCIndexClass)):
new_left = left._values
else:
new_left = left
if isinstance(right, (ABCSeries, ABCIndexClass)):
new_right = right._values
else:
new_right = right
res_values = op(new_left, new_right)
res_name = get_op_result_name(left, right)
if op.__name__ in ['divmod', 'rdivmod']:
return _construct_divmod_result(
left, res_values, left.index, res_name)
return _construct_result(left, res_values, left.index, res_name) | def dispatch_to_extension_op(op, left, right):
"""
Assume that left or right is a Series backed by an ExtensionArray,
apply the operator defined by op.
"""
# The op calls will raise TypeError if the op is not defined
# on the ExtensionArray
# unbox Series and Index to arrays
if isinstance(left, (ABCSeries, ABCIndexClass)):
new_left = left._values
else:
new_left = left
if isinstance(right, (ABCSeries, ABCIndexClass)):
new_right = right._values
else:
new_right = right
res_values = op(new_left, new_right)
res_name = get_op_result_name(left, right)
if op.__name__ in ['divmod', 'rdivmod']:
return _construct_divmod_result(
left, res_values, left.index, res_name)
return _construct_result(left, res_values, left.index, res_name) | [
"Assume",
"that",
"left",
"or",
"right",
"is",
"a",
"Series",
"backed",
"by",
"an",
"ExtensionArray",
"apply",
"the",
"operator",
"defined",
"by",
"op",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1383-L1410 | [
"def",
"dispatch_to_extension_op",
"(",
"op",
",",
"left",
",",
"right",
")",
":",
"# The op calls will raise TypeError if the op is not defined",
"# on the ExtensionArray",
"# unbox Series and Index to arrays",
"if",
"isinstance",
"(",
"left",
",",
"(",
"ABCSeries",
",",
"ABCIndexClass",
")",
")",
":",
"new_left",
"=",
"left",
".",
"_values",
"else",
":",
"new_left",
"=",
"left",
"if",
"isinstance",
"(",
"right",
",",
"(",
"ABCSeries",
",",
"ABCIndexClass",
")",
")",
":",
"new_right",
"=",
"right",
".",
"_values",
"else",
":",
"new_right",
"=",
"right",
"res_values",
"=",
"op",
"(",
"new_left",
",",
"new_right",
")",
"res_name",
"=",
"get_op_result_name",
"(",
"left",
",",
"right",
")",
"if",
"op",
".",
"__name__",
"in",
"[",
"'divmod'",
",",
"'rdivmod'",
"]",
":",
"return",
"_construct_divmod_result",
"(",
"left",
",",
"res_values",
",",
"left",
".",
"index",
",",
"res_name",
")",
"return",
"_construct_result",
"(",
"left",
",",
"res_values",
",",
"left",
".",
"index",
",",
"res_name",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _get_method_wrappers | Find the appropriate operation-wrappers to use when defining flex/special
arithmetic, boolean, and comparison operations with the given class.
Parameters
----------
cls : class
Returns
-------
arith_flex : function or None
comp_flex : function or None
arith_special : function
comp_special : function
bool_special : function
Notes
-----
None is only returned for SparseArray | pandas/core/ops.py | def _get_method_wrappers(cls):
"""
Find the appropriate operation-wrappers to use when defining flex/special
arithmetic, boolean, and comparison operations with the given class.
Parameters
----------
cls : class
Returns
-------
arith_flex : function or None
comp_flex : function or None
arith_special : function
comp_special : function
bool_special : function
Notes
-----
None is only returned for SparseArray
"""
if issubclass(cls, ABCSparseSeries):
# Be sure to catch this before ABCSeries and ABCSparseArray,
# as they will both come see SparseSeries as a subclass
arith_flex = _flex_method_SERIES
comp_flex = _flex_method_SERIES
arith_special = _arith_method_SPARSE_SERIES
comp_special = _arith_method_SPARSE_SERIES
bool_special = _bool_method_SERIES
# TODO: I don't think the functions defined by bool_method are tested
elif issubclass(cls, ABCSeries):
# Just Series; SparseSeries is caught above
arith_flex = _flex_method_SERIES
comp_flex = _flex_method_SERIES
arith_special = _arith_method_SERIES
comp_special = _comp_method_SERIES
bool_special = _bool_method_SERIES
elif issubclass(cls, ABCSparseArray):
arith_flex = None
comp_flex = None
arith_special = _arith_method_SPARSE_ARRAY
comp_special = _arith_method_SPARSE_ARRAY
bool_special = _arith_method_SPARSE_ARRAY
elif issubclass(cls, ABCPanel):
arith_flex = _flex_method_PANEL
comp_flex = _comp_method_PANEL
arith_special = _arith_method_PANEL
comp_special = _comp_method_PANEL
bool_special = _arith_method_PANEL
elif issubclass(cls, ABCDataFrame):
# Same for DataFrame and SparseDataFrame
arith_flex = _arith_method_FRAME
comp_flex = _flex_comp_method_FRAME
arith_special = _arith_method_FRAME
comp_special = _comp_method_FRAME
bool_special = _arith_method_FRAME
return arith_flex, comp_flex, arith_special, comp_special, bool_special | def _get_method_wrappers(cls):
"""
Find the appropriate operation-wrappers to use when defining flex/special
arithmetic, boolean, and comparison operations with the given class.
Parameters
----------
cls : class
Returns
-------
arith_flex : function or None
comp_flex : function or None
arith_special : function
comp_special : function
bool_special : function
Notes
-----
None is only returned for SparseArray
"""
if issubclass(cls, ABCSparseSeries):
# Be sure to catch this before ABCSeries and ABCSparseArray,
# as they will both come see SparseSeries as a subclass
arith_flex = _flex_method_SERIES
comp_flex = _flex_method_SERIES
arith_special = _arith_method_SPARSE_SERIES
comp_special = _arith_method_SPARSE_SERIES
bool_special = _bool_method_SERIES
# TODO: I don't think the functions defined by bool_method are tested
elif issubclass(cls, ABCSeries):
# Just Series; SparseSeries is caught above
arith_flex = _flex_method_SERIES
comp_flex = _flex_method_SERIES
arith_special = _arith_method_SERIES
comp_special = _comp_method_SERIES
bool_special = _bool_method_SERIES
elif issubclass(cls, ABCSparseArray):
arith_flex = None
comp_flex = None
arith_special = _arith_method_SPARSE_ARRAY
comp_special = _arith_method_SPARSE_ARRAY
bool_special = _arith_method_SPARSE_ARRAY
elif issubclass(cls, ABCPanel):
arith_flex = _flex_method_PANEL
comp_flex = _comp_method_PANEL
arith_special = _arith_method_PANEL
comp_special = _comp_method_PANEL
bool_special = _arith_method_PANEL
elif issubclass(cls, ABCDataFrame):
# Same for DataFrame and SparseDataFrame
arith_flex = _arith_method_FRAME
comp_flex = _flex_comp_method_FRAME
arith_special = _arith_method_FRAME
comp_special = _comp_method_FRAME
bool_special = _arith_method_FRAME
return arith_flex, comp_flex, arith_special, comp_special, bool_special | [
"Find",
"the",
"appropriate",
"operation",
"-",
"wrappers",
"to",
"use",
"when",
"defining",
"flex",
"/",
"special",
"arithmetic",
"boolean",
"and",
"comparison",
"operations",
"with",
"the",
"given",
"class",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1417-L1473 | [
"def",
"_get_method_wrappers",
"(",
"cls",
")",
":",
"if",
"issubclass",
"(",
"cls",
",",
"ABCSparseSeries",
")",
":",
"# Be sure to catch this before ABCSeries and ABCSparseArray,",
"# as they will both come see SparseSeries as a subclass",
"arith_flex",
"=",
"_flex_method_SERIES",
"comp_flex",
"=",
"_flex_method_SERIES",
"arith_special",
"=",
"_arith_method_SPARSE_SERIES",
"comp_special",
"=",
"_arith_method_SPARSE_SERIES",
"bool_special",
"=",
"_bool_method_SERIES",
"# TODO: I don't think the functions defined by bool_method are tested",
"elif",
"issubclass",
"(",
"cls",
",",
"ABCSeries",
")",
":",
"# Just Series; SparseSeries is caught above",
"arith_flex",
"=",
"_flex_method_SERIES",
"comp_flex",
"=",
"_flex_method_SERIES",
"arith_special",
"=",
"_arith_method_SERIES",
"comp_special",
"=",
"_comp_method_SERIES",
"bool_special",
"=",
"_bool_method_SERIES",
"elif",
"issubclass",
"(",
"cls",
",",
"ABCSparseArray",
")",
":",
"arith_flex",
"=",
"None",
"comp_flex",
"=",
"None",
"arith_special",
"=",
"_arith_method_SPARSE_ARRAY",
"comp_special",
"=",
"_arith_method_SPARSE_ARRAY",
"bool_special",
"=",
"_arith_method_SPARSE_ARRAY",
"elif",
"issubclass",
"(",
"cls",
",",
"ABCPanel",
")",
":",
"arith_flex",
"=",
"_flex_method_PANEL",
"comp_flex",
"=",
"_comp_method_PANEL",
"arith_special",
"=",
"_arith_method_PANEL",
"comp_special",
"=",
"_comp_method_PANEL",
"bool_special",
"=",
"_arith_method_PANEL",
"elif",
"issubclass",
"(",
"cls",
",",
"ABCDataFrame",
")",
":",
"# Same for DataFrame and SparseDataFrame",
"arith_flex",
"=",
"_arith_method_FRAME",
"comp_flex",
"=",
"_flex_comp_method_FRAME",
"arith_special",
"=",
"_arith_method_FRAME",
"comp_special",
"=",
"_comp_method_FRAME",
"bool_special",
"=",
"_arith_method_FRAME",
"return",
"arith_flex",
",",
"comp_flex",
",",
"arith_special",
",",
"comp_special",
",",
"bool_special"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | add_special_arithmetic_methods | Adds the full suite of special arithmetic methods (``__add__``,
``__sub__``, etc.) to the class.
Parameters
----------
cls : class
special methods will be defined and pinned to this class | pandas/core/ops.py | def add_special_arithmetic_methods(cls):
"""
Adds the full suite of special arithmetic methods (``__add__``,
``__sub__``, etc.) to the class.
Parameters
----------
cls : class
special methods will be defined and pinned to this class
"""
_, _, arith_method, comp_method, bool_method = _get_method_wrappers(cls)
new_methods = _create_methods(cls, arith_method, comp_method, bool_method,
special=True)
# inplace operators (I feel like these should get passed an `inplace=True`
# or just be removed
def _wrap_inplace_method(method):
"""
return an inplace wrapper for this method
"""
def f(self, other):
result = method(self, other)
# this makes sure that we are aligned like the input
# we are updating inplace so we want to ignore is_copy
self._update_inplace(result.reindex_like(self, copy=False)._data,
verify_is_copy=False)
return self
f.__name__ = "__i{name}__".format(name=method.__name__.strip("__"))
return f
new_methods.update(
dict(__iadd__=_wrap_inplace_method(new_methods["__add__"]),
__isub__=_wrap_inplace_method(new_methods["__sub__"]),
__imul__=_wrap_inplace_method(new_methods["__mul__"]),
__itruediv__=_wrap_inplace_method(new_methods["__truediv__"]),
__ifloordiv__=_wrap_inplace_method(new_methods["__floordiv__"]),
__imod__=_wrap_inplace_method(new_methods["__mod__"]),
__ipow__=_wrap_inplace_method(new_methods["__pow__"])))
new_methods.update(
dict(__iand__=_wrap_inplace_method(new_methods["__and__"]),
__ior__=_wrap_inplace_method(new_methods["__or__"]),
__ixor__=_wrap_inplace_method(new_methods["__xor__"])))
add_methods(cls, new_methods=new_methods) | def add_special_arithmetic_methods(cls):
"""
Adds the full suite of special arithmetic methods (``__add__``,
``__sub__``, etc.) to the class.
Parameters
----------
cls : class
special methods will be defined and pinned to this class
"""
_, _, arith_method, comp_method, bool_method = _get_method_wrappers(cls)
new_methods = _create_methods(cls, arith_method, comp_method, bool_method,
special=True)
# inplace operators (I feel like these should get passed an `inplace=True`
# or just be removed
def _wrap_inplace_method(method):
"""
return an inplace wrapper for this method
"""
def f(self, other):
result = method(self, other)
# this makes sure that we are aligned like the input
# we are updating inplace so we want to ignore is_copy
self._update_inplace(result.reindex_like(self, copy=False)._data,
verify_is_copy=False)
return self
f.__name__ = "__i{name}__".format(name=method.__name__.strip("__"))
return f
new_methods.update(
dict(__iadd__=_wrap_inplace_method(new_methods["__add__"]),
__isub__=_wrap_inplace_method(new_methods["__sub__"]),
__imul__=_wrap_inplace_method(new_methods["__mul__"]),
__itruediv__=_wrap_inplace_method(new_methods["__truediv__"]),
__ifloordiv__=_wrap_inplace_method(new_methods["__floordiv__"]),
__imod__=_wrap_inplace_method(new_methods["__mod__"]),
__ipow__=_wrap_inplace_method(new_methods["__pow__"])))
new_methods.update(
dict(__iand__=_wrap_inplace_method(new_methods["__and__"]),
__ior__=_wrap_inplace_method(new_methods["__or__"]),
__ixor__=_wrap_inplace_method(new_methods["__xor__"])))
add_methods(cls, new_methods=new_methods) | [
"Adds",
"the",
"full",
"suite",
"of",
"special",
"arithmetic",
"methods",
"(",
"__add__",
"__sub__",
"etc",
".",
")",
"to",
"the",
"class",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1551-L1599 | [
"def",
"add_special_arithmetic_methods",
"(",
"cls",
")",
":",
"_",
",",
"_",
",",
"arith_method",
",",
"comp_method",
",",
"bool_method",
"=",
"_get_method_wrappers",
"(",
"cls",
")",
"new_methods",
"=",
"_create_methods",
"(",
"cls",
",",
"arith_method",
",",
"comp_method",
",",
"bool_method",
",",
"special",
"=",
"True",
")",
"# inplace operators (I feel like these should get passed an `inplace=True`",
"# or just be removed",
"def",
"_wrap_inplace_method",
"(",
"method",
")",
":",
"\"\"\"\n return an inplace wrapper for this method\n \"\"\"",
"def",
"f",
"(",
"self",
",",
"other",
")",
":",
"result",
"=",
"method",
"(",
"self",
",",
"other",
")",
"# this makes sure that we are aligned like the input",
"# we are updating inplace so we want to ignore is_copy",
"self",
".",
"_update_inplace",
"(",
"result",
".",
"reindex_like",
"(",
"self",
",",
"copy",
"=",
"False",
")",
".",
"_data",
",",
"verify_is_copy",
"=",
"False",
")",
"return",
"self",
"f",
".",
"__name__",
"=",
"\"__i{name}__\"",
".",
"format",
"(",
"name",
"=",
"method",
".",
"__name__",
".",
"strip",
"(",
"\"__\"",
")",
")",
"return",
"f",
"new_methods",
".",
"update",
"(",
"dict",
"(",
"__iadd__",
"=",
"_wrap_inplace_method",
"(",
"new_methods",
"[",
"\"__add__\"",
"]",
")",
",",
"__isub__",
"=",
"_wrap_inplace_method",
"(",
"new_methods",
"[",
"\"__sub__\"",
"]",
")",
",",
"__imul__",
"=",
"_wrap_inplace_method",
"(",
"new_methods",
"[",
"\"__mul__\"",
"]",
")",
",",
"__itruediv__",
"=",
"_wrap_inplace_method",
"(",
"new_methods",
"[",
"\"__truediv__\"",
"]",
")",
",",
"__ifloordiv__",
"=",
"_wrap_inplace_method",
"(",
"new_methods",
"[",
"\"__floordiv__\"",
"]",
")",
",",
"__imod__",
"=",
"_wrap_inplace_method",
"(",
"new_methods",
"[",
"\"__mod__\"",
"]",
")",
",",
"__ipow__",
"=",
"_wrap_inplace_method",
"(",
"new_methods",
"[",
"\"__pow__\"",
"]",
")",
")",
")",
"new_methods",
".",
"update",
"(",
"dict",
"(",
"__iand__",
"=",
"_wrap_inplace_method",
"(",
"new_methods",
"[",
"\"__and__\"",
"]",
")",
",",
"__ior__",
"=",
"_wrap_inplace_method",
"(",
"new_methods",
"[",
"\"__or__\"",
"]",
")",
",",
"__ixor__",
"=",
"_wrap_inplace_method",
"(",
"new_methods",
"[",
"\"__xor__\"",
"]",
")",
")",
")",
"add_methods",
"(",
"cls",
",",
"new_methods",
"=",
"new_methods",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | add_flex_arithmetic_methods | Adds the full suite of flex arithmetic methods (``pow``, ``mul``, ``add``)
to the class.
Parameters
----------
cls : class
flex methods will be defined and pinned to this class | pandas/core/ops.py | def add_flex_arithmetic_methods(cls):
"""
Adds the full suite of flex arithmetic methods (``pow``, ``mul``, ``add``)
to the class.
Parameters
----------
cls : class
flex methods will be defined and pinned to this class
"""
flex_arith_method, flex_comp_method, _, _, _ = _get_method_wrappers(cls)
new_methods = _create_methods(cls, flex_arith_method,
flex_comp_method, bool_method=None,
special=False)
new_methods.update(dict(multiply=new_methods['mul'],
subtract=new_methods['sub'],
divide=new_methods['div']))
# opt out of bool flex methods for now
assert not any(kname in new_methods for kname in ('ror_', 'rxor', 'rand_'))
add_methods(cls, new_methods=new_methods) | def add_flex_arithmetic_methods(cls):
"""
Adds the full suite of flex arithmetic methods (``pow``, ``mul``, ``add``)
to the class.
Parameters
----------
cls : class
flex methods will be defined and pinned to this class
"""
flex_arith_method, flex_comp_method, _, _, _ = _get_method_wrappers(cls)
new_methods = _create_methods(cls, flex_arith_method,
flex_comp_method, bool_method=None,
special=False)
new_methods.update(dict(multiply=new_methods['mul'],
subtract=new_methods['sub'],
divide=new_methods['div']))
# opt out of bool flex methods for now
assert not any(kname in new_methods for kname in ('ror_', 'rxor', 'rand_'))
add_methods(cls, new_methods=new_methods) | [
"Adds",
"the",
"full",
"suite",
"of",
"flex",
"arithmetic",
"methods",
"(",
"pow",
"mul",
"add",
")",
"to",
"the",
"class",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1602-L1622 | [
"def",
"add_flex_arithmetic_methods",
"(",
"cls",
")",
":",
"flex_arith_method",
",",
"flex_comp_method",
",",
"_",
",",
"_",
",",
"_",
"=",
"_get_method_wrappers",
"(",
"cls",
")",
"new_methods",
"=",
"_create_methods",
"(",
"cls",
",",
"flex_arith_method",
",",
"flex_comp_method",
",",
"bool_method",
"=",
"None",
",",
"special",
"=",
"False",
")",
"new_methods",
".",
"update",
"(",
"dict",
"(",
"multiply",
"=",
"new_methods",
"[",
"'mul'",
"]",
",",
"subtract",
"=",
"new_methods",
"[",
"'sub'",
"]",
",",
"divide",
"=",
"new_methods",
"[",
"'div'",
"]",
")",
")",
"# opt out of bool flex methods for now",
"assert",
"not",
"any",
"(",
"kname",
"in",
"new_methods",
"for",
"kname",
"in",
"(",
"'ror_'",
",",
"'rxor'",
",",
"'rand_'",
")",
")",
"add_methods",
"(",
"cls",
",",
"new_methods",
"=",
"new_methods",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _align_method_SERIES | align lhs and rhs Series | pandas/core/ops.py | def _align_method_SERIES(left, right, align_asobject=False):
""" align lhs and rhs Series """
# ToDo: Different from _align_method_FRAME, list, tuple and ndarray
# are not coerced here
# because Series has inconsistencies described in #13637
if isinstance(right, ABCSeries):
# avoid repeated alignment
if not left.index.equals(right.index):
if align_asobject:
# to keep original value's dtype for bool ops
left = left.astype(object)
right = right.astype(object)
left, right = left.align(right, copy=False)
return left, right | def _align_method_SERIES(left, right, align_asobject=False):
""" align lhs and rhs Series """
# ToDo: Different from _align_method_FRAME, list, tuple and ndarray
# are not coerced here
# because Series has inconsistencies described in #13637
if isinstance(right, ABCSeries):
# avoid repeated alignment
if not left.index.equals(right.index):
if align_asobject:
# to keep original value's dtype for bool ops
left = left.astype(object)
right = right.astype(object)
left, right = left.align(right, copy=False)
return left, right | [
"align",
"lhs",
"and",
"rhs",
"Series"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1628-L1646 | [
"def",
"_align_method_SERIES",
"(",
"left",
",",
"right",
",",
"align_asobject",
"=",
"False",
")",
":",
"# ToDo: Different from _align_method_FRAME, list, tuple and ndarray",
"# are not coerced here",
"# because Series has inconsistencies described in #13637",
"if",
"isinstance",
"(",
"right",
",",
"ABCSeries",
")",
":",
"# avoid repeated alignment",
"if",
"not",
"left",
".",
"index",
".",
"equals",
"(",
"right",
".",
"index",
")",
":",
"if",
"align_asobject",
":",
"# to keep original value's dtype for bool ops",
"left",
"=",
"left",
".",
"astype",
"(",
"object",
")",
"right",
"=",
"right",
".",
"astype",
"(",
"object",
")",
"left",
",",
"right",
"=",
"left",
".",
"align",
"(",
"right",
",",
"copy",
"=",
"False",
")",
"return",
"left",
",",
"right"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _construct_result | If the raw op result has a non-None name (e.g. it is an Index object) and
the name argument is None, then passing name to the constructor will
not be enough; we still need to override the name attribute. | pandas/core/ops.py | def _construct_result(left, result, index, name, dtype=None):
"""
If the raw op result has a non-None name (e.g. it is an Index object) and
the name argument is None, then passing name to the constructor will
not be enough; we still need to override the name attribute.
"""
out = left._constructor(result, index=index, dtype=dtype)
out = out.__finalize__(left)
out.name = name
return out | def _construct_result(left, result, index, name, dtype=None):
"""
If the raw op result has a non-None name (e.g. it is an Index object) and
the name argument is None, then passing name to the constructor will
not be enough; we still need to override the name attribute.
"""
out = left._constructor(result, index=index, dtype=dtype)
out = out.__finalize__(left)
out.name = name
return out | [
"If",
"the",
"raw",
"op",
"result",
"has",
"a",
"non",
"-",
"None",
"name",
"(",
"e",
".",
"g",
".",
"it",
"is",
"an",
"Index",
"object",
")",
"and",
"the",
"name",
"argument",
"is",
"None",
"then",
"passing",
"name",
"to",
"the",
"constructor",
"will",
"not",
"be",
"enough",
";",
"we",
"still",
"need",
"to",
"override",
"the",
"name",
"attribute",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1649-L1658 | [
"def",
"_construct_result",
"(",
"left",
",",
"result",
",",
"index",
",",
"name",
",",
"dtype",
"=",
"None",
")",
":",
"out",
"=",
"left",
".",
"_constructor",
"(",
"result",
",",
"index",
"=",
"index",
",",
"dtype",
"=",
"dtype",
")",
"out",
"=",
"out",
".",
"__finalize__",
"(",
"left",
")",
"out",
".",
"name",
"=",
"name",
"return",
"out"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _construct_divmod_result | divmod returns a tuple of like indexed series instead of a single series. | pandas/core/ops.py | def _construct_divmod_result(left, result, index, name, dtype=None):
"""divmod returns a tuple of like indexed series instead of a single series.
"""
return (
_construct_result(left, result[0], index=index, name=name,
dtype=dtype),
_construct_result(left, result[1], index=index, name=name,
dtype=dtype),
) | def _construct_divmod_result(left, result, index, name, dtype=None):
"""divmod returns a tuple of like indexed series instead of a single series.
"""
return (
_construct_result(left, result[0], index=index, name=name,
dtype=dtype),
_construct_result(left, result[1], index=index, name=name,
dtype=dtype),
) | [
"divmod",
"returns",
"a",
"tuple",
"of",
"like",
"indexed",
"series",
"instead",
"of",
"a",
"single",
"series",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1661-L1669 | [
"def",
"_construct_divmod_result",
"(",
"left",
",",
"result",
",",
"index",
",",
"name",
",",
"dtype",
"=",
"None",
")",
":",
"return",
"(",
"_construct_result",
"(",
"left",
",",
"result",
"[",
"0",
"]",
",",
"index",
"=",
"index",
",",
"name",
"=",
"name",
",",
"dtype",
"=",
"dtype",
")",
",",
"_construct_result",
"(",
"left",
",",
"result",
"[",
"1",
"]",
",",
"index",
"=",
"index",
",",
"name",
"=",
"name",
",",
"dtype",
"=",
"dtype",
")",
",",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _arith_method_SERIES | Wrapper function for Series arithmetic operations, to avoid
code duplication. | pandas/core/ops.py | def _arith_method_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
str_rep = _get_opstr(op, cls)
op_name = _get_op_name(op, special)
eval_kwargs = _gen_eval_kwargs(op_name)
fill_zeros = _gen_fill_zeros(op_name)
construct_result = (_construct_divmod_result
if op in [divmod, rdivmod] else _construct_result)
def na_op(x, y):
import pandas.core.computation.expressions as expressions
try:
result = expressions.evaluate(op, str_rep, x, y, **eval_kwargs)
except TypeError:
result = masked_arith_op(x, y, op)
result = missing.fill_zeros(result, x, y, op_name, fill_zeros)
return result
def safe_na_op(lvalues, rvalues):
"""
return the result of evaluating na_op on the passed in values
try coercion to object type if the native types are not compatible
Parameters
----------
lvalues : array-like
rvalues : array-like
Raises
------
TypeError: invalid operation
"""
try:
with np.errstate(all='ignore'):
return na_op(lvalues, rvalues)
except Exception:
if is_object_dtype(lvalues):
return libalgos.arrmap_object(lvalues,
lambda x: op(x, rvalues))
raise
def wrapper(left, right):
if isinstance(right, ABCDataFrame):
return NotImplemented
left, right = _align_method_SERIES(left, right)
res_name = get_op_result_name(left, right)
right = maybe_upcast_for_op(right)
if is_categorical_dtype(left):
raise TypeError("{typ} cannot perform the operation "
"{op}".format(typ=type(left).__name__, op=str_rep))
elif is_datetime64_dtype(left) or is_datetime64tz_dtype(left):
# Give dispatch_to_index_op a chance for tests like
# test_dt64_series_add_intlike, which the index dispatching handles
# specifically.
result = dispatch_to_index_op(op, left, right, pd.DatetimeIndex)
return construct_result(left, result,
index=left.index, name=res_name,
dtype=result.dtype)
elif (is_extension_array_dtype(left) or
(is_extension_array_dtype(right) and not is_scalar(right))):
# GH#22378 disallow scalar to exclude e.g. "category", "Int64"
return dispatch_to_extension_op(op, left, right)
elif is_timedelta64_dtype(left):
result = dispatch_to_index_op(op, left, right, pd.TimedeltaIndex)
return construct_result(left, result,
index=left.index, name=res_name)
elif is_timedelta64_dtype(right):
# We should only get here with non-scalar or timedelta64('NaT')
# values for right
# Note: we cannot use dispatch_to_index_op because
# that may incorrectly raise TypeError when we
# should get NullFrequencyError
result = op(pd.Index(left), right)
return construct_result(left, result,
index=left.index, name=res_name,
dtype=result.dtype)
lvalues = left.values
rvalues = right
if isinstance(rvalues, ABCSeries):
rvalues = rvalues.values
result = safe_na_op(lvalues, rvalues)
return construct_result(left, result,
index=left.index, name=res_name, dtype=None)
wrapper.__name__ = op_name
return wrapper | def _arith_method_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
str_rep = _get_opstr(op, cls)
op_name = _get_op_name(op, special)
eval_kwargs = _gen_eval_kwargs(op_name)
fill_zeros = _gen_fill_zeros(op_name)
construct_result = (_construct_divmod_result
if op in [divmod, rdivmod] else _construct_result)
def na_op(x, y):
import pandas.core.computation.expressions as expressions
try:
result = expressions.evaluate(op, str_rep, x, y, **eval_kwargs)
except TypeError:
result = masked_arith_op(x, y, op)
result = missing.fill_zeros(result, x, y, op_name, fill_zeros)
return result
def safe_na_op(lvalues, rvalues):
"""
return the result of evaluating na_op on the passed in values
try coercion to object type if the native types are not compatible
Parameters
----------
lvalues : array-like
rvalues : array-like
Raises
------
TypeError: invalid operation
"""
try:
with np.errstate(all='ignore'):
return na_op(lvalues, rvalues)
except Exception:
if is_object_dtype(lvalues):
return libalgos.arrmap_object(lvalues,
lambda x: op(x, rvalues))
raise
def wrapper(left, right):
if isinstance(right, ABCDataFrame):
return NotImplemented
left, right = _align_method_SERIES(left, right)
res_name = get_op_result_name(left, right)
right = maybe_upcast_for_op(right)
if is_categorical_dtype(left):
raise TypeError("{typ} cannot perform the operation "
"{op}".format(typ=type(left).__name__, op=str_rep))
elif is_datetime64_dtype(left) or is_datetime64tz_dtype(left):
# Give dispatch_to_index_op a chance for tests like
# test_dt64_series_add_intlike, which the index dispatching handles
# specifically.
result = dispatch_to_index_op(op, left, right, pd.DatetimeIndex)
return construct_result(left, result,
index=left.index, name=res_name,
dtype=result.dtype)
elif (is_extension_array_dtype(left) or
(is_extension_array_dtype(right) and not is_scalar(right))):
# GH#22378 disallow scalar to exclude e.g. "category", "Int64"
return dispatch_to_extension_op(op, left, right)
elif is_timedelta64_dtype(left):
result = dispatch_to_index_op(op, left, right, pd.TimedeltaIndex)
return construct_result(left, result,
index=left.index, name=res_name)
elif is_timedelta64_dtype(right):
# We should only get here with non-scalar or timedelta64('NaT')
# values for right
# Note: we cannot use dispatch_to_index_op because
# that may incorrectly raise TypeError when we
# should get NullFrequencyError
result = op(pd.Index(left), right)
return construct_result(left, result,
index=left.index, name=res_name,
dtype=result.dtype)
lvalues = left.values
rvalues = right
if isinstance(rvalues, ABCSeries):
rvalues = rvalues.values
result = safe_na_op(lvalues, rvalues)
return construct_result(left, result,
index=left.index, name=res_name, dtype=None)
wrapper.__name__ = op_name
return wrapper | [
"Wrapper",
"function",
"for",
"Series",
"arithmetic",
"operations",
"to",
"avoid",
"code",
"duplication",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1672-L1770 | [
"def",
"_arith_method_SERIES",
"(",
"cls",
",",
"op",
",",
"special",
")",
":",
"str_rep",
"=",
"_get_opstr",
"(",
"op",
",",
"cls",
")",
"op_name",
"=",
"_get_op_name",
"(",
"op",
",",
"special",
")",
"eval_kwargs",
"=",
"_gen_eval_kwargs",
"(",
"op_name",
")",
"fill_zeros",
"=",
"_gen_fill_zeros",
"(",
"op_name",
")",
"construct_result",
"=",
"(",
"_construct_divmod_result",
"if",
"op",
"in",
"[",
"divmod",
",",
"rdivmod",
"]",
"else",
"_construct_result",
")",
"def",
"na_op",
"(",
"x",
",",
"y",
")",
":",
"import",
"pandas",
".",
"core",
".",
"computation",
".",
"expressions",
"as",
"expressions",
"try",
":",
"result",
"=",
"expressions",
".",
"evaluate",
"(",
"op",
",",
"str_rep",
",",
"x",
",",
"y",
",",
"*",
"*",
"eval_kwargs",
")",
"except",
"TypeError",
":",
"result",
"=",
"masked_arith_op",
"(",
"x",
",",
"y",
",",
"op",
")",
"result",
"=",
"missing",
".",
"fill_zeros",
"(",
"result",
",",
"x",
",",
"y",
",",
"op_name",
",",
"fill_zeros",
")",
"return",
"result",
"def",
"safe_na_op",
"(",
"lvalues",
",",
"rvalues",
")",
":",
"\"\"\"\n return the result of evaluating na_op on the passed in values\n\n try coercion to object type if the native types are not compatible\n\n Parameters\n ----------\n lvalues : array-like\n rvalues : array-like\n\n Raises\n ------\n TypeError: invalid operation\n \"\"\"",
"try",
":",
"with",
"np",
".",
"errstate",
"(",
"all",
"=",
"'ignore'",
")",
":",
"return",
"na_op",
"(",
"lvalues",
",",
"rvalues",
")",
"except",
"Exception",
":",
"if",
"is_object_dtype",
"(",
"lvalues",
")",
":",
"return",
"libalgos",
".",
"arrmap_object",
"(",
"lvalues",
",",
"lambda",
"x",
":",
"op",
"(",
"x",
",",
"rvalues",
")",
")",
"raise",
"def",
"wrapper",
"(",
"left",
",",
"right",
")",
":",
"if",
"isinstance",
"(",
"right",
",",
"ABCDataFrame",
")",
":",
"return",
"NotImplemented",
"left",
",",
"right",
"=",
"_align_method_SERIES",
"(",
"left",
",",
"right",
")",
"res_name",
"=",
"get_op_result_name",
"(",
"left",
",",
"right",
")",
"right",
"=",
"maybe_upcast_for_op",
"(",
"right",
")",
"if",
"is_categorical_dtype",
"(",
"left",
")",
":",
"raise",
"TypeError",
"(",
"\"{typ} cannot perform the operation \"",
"\"{op}\"",
".",
"format",
"(",
"typ",
"=",
"type",
"(",
"left",
")",
".",
"__name__",
",",
"op",
"=",
"str_rep",
")",
")",
"elif",
"is_datetime64_dtype",
"(",
"left",
")",
"or",
"is_datetime64tz_dtype",
"(",
"left",
")",
":",
"# Give dispatch_to_index_op a chance for tests like",
"# test_dt64_series_add_intlike, which the index dispatching handles",
"# specifically.",
"result",
"=",
"dispatch_to_index_op",
"(",
"op",
",",
"left",
",",
"right",
",",
"pd",
".",
"DatetimeIndex",
")",
"return",
"construct_result",
"(",
"left",
",",
"result",
",",
"index",
"=",
"left",
".",
"index",
",",
"name",
"=",
"res_name",
",",
"dtype",
"=",
"result",
".",
"dtype",
")",
"elif",
"(",
"is_extension_array_dtype",
"(",
"left",
")",
"or",
"(",
"is_extension_array_dtype",
"(",
"right",
")",
"and",
"not",
"is_scalar",
"(",
"right",
")",
")",
")",
":",
"# GH#22378 disallow scalar to exclude e.g. \"category\", \"Int64\"",
"return",
"dispatch_to_extension_op",
"(",
"op",
",",
"left",
",",
"right",
")",
"elif",
"is_timedelta64_dtype",
"(",
"left",
")",
":",
"result",
"=",
"dispatch_to_index_op",
"(",
"op",
",",
"left",
",",
"right",
",",
"pd",
".",
"TimedeltaIndex",
")",
"return",
"construct_result",
"(",
"left",
",",
"result",
",",
"index",
"=",
"left",
".",
"index",
",",
"name",
"=",
"res_name",
")",
"elif",
"is_timedelta64_dtype",
"(",
"right",
")",
":",
"# We should only get here with non-scalar or timedelta64('NaT')",
"# values for right",
"# Note: we cannot use dispatch_to_index_op because",
"# that may incorrectly raise TypeError when we",
"# should get NullFrequencyError",
"result",
"=",
"op",
"(",
"pd",
".",
"Index",
"(",
"left",
")",
",",
"right",
")",
"return",
"construct_result",
"(",
"left",
",",
"result",
",",
"index",
"=",
"left",
".",
"index",
",",
"name",
"=",
"res_name",
",",
"dtype",
"=",
"result",
".",
"dtype",
")",
"lvalues",
"=",
"left",
".",
"values",
"rvalues",
"=",
"right",
"if",
"isinstance",
"(",
"rvalues",
",",
"ABCSeries",
")",
":",
"rvalues",
"=",
"rvalues",
".",
"values",
"result",
"=",
"safe_na_op",
"(",
"lvalues",
",",
"rvalues",
")",
"return",
"construct_result",
"(",
"left",
",",
"result",
",",
"index",
"=",
"left",
".",
"index",
",",
"name",
"=",
"res_name",
",",
"dtype",
"=",
"None",
")",
"wrapper",
".",
"__name__",
"=",
"op_name",
"return",
"wrapper"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _comp_method_SERIES | Wrapper function for Series arithmetic operations, to avoid
code duplication. | pandas/core/ops.py | def _comp_method_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
op_name = _get_op_name(op, special)
masker = _gen_eval_kwargs(op_name).get('masker', False)
def na_op(x, y):
# TODO:
# should have guarantess on what x, y can be type-wise
# Extension Dtypes are not called here
# Checking that cases that were once handled here are no longer
# reachable.
assert not (is_categorical_dtype(y) and not is_scalar(y))
if is_object_dtype(x.dtype):
result = _comp_method_OBJECT_ARRAY(op, x, y)
elif is_datetimelike_v_numeric(x, y):
return invalid_comparison(x, y, op)
else:
# we want to compare like types
# we only want to convert to integer like if
# we are not NotImplemented, otherwise
# we would allow datetime64 (but viewed as i8) against
# integer comparisons
# we have a datetime/timedelta and may need to convert
assert not needs_i8_conversion(x)
mask = None
if not is_scalar(y) and needs_i8_conversion(y):
mask = isna(x) | isna(y)
y = y.view('i8')
x = x.view('i8')
method = getattr(x, op_name, None)
if method is not None:
with np.errstate(all='ignore'):
result = method(y)
if result is NotImplemented:
return invalid_comparison(x, y, op)
else:
result = op(x, y)
if mask is not None and mask.any():
result[mask] = masker
return result
def wrapper(self, other, axis=None):
# Validate the axis parameter
if axis is not None:
self._get_axis_number(axis)
res_name = get_op_result_name(self, other)
if isinstance(other, list):
# TODO: same for tuples?
other = np.asarray(other)
if isinstance(other, ABCDataFrame): # pragma: no cover
# Defer to DataFrame implementation; fail early
return NotImplemented
elif isinstance(other, ABCSeries) and not self._indexed_same(other):
raise ValueError("Can only compare identically-labeled "
"Series objects")
elif is_categorical_dtype(self):
# Dispatch to Categorical implementation; pd.CategoricalIndex
# behavior is non-canonical GH#19513
res_values = dispatch_to_index_op(op, self, other, pd.Categorical)
return self._constructor(res_values, index=self.index,
name=res_name)
elif is_datetime64_dtype(self) or is_datetime64tz_dtype(self):
# Dispatch to DatetimeIndex to ensure identical
# Series/Index behavior
if (isinstance(other, datetime.date) and
not isinstance(other, datetime.datetime)):
# https://github.com/pandas-dev/pandas/issues/21152
# Compatibility for difference between Series comparison w/
# datetime and date
msg = (
"Comparing Series of datetimes with 'datetime.date'. "
"Currently, the 'datetime.date' is coerced to a "
"datetime. In the future pandas will not coerce, "
"and {future}. "
"To retain the current behavior, "
"convert the 'datetime.date' to a datetime with "
"'pd.Timestamp'."
)
if op in {operator.lt, operator.le, operator.gt, operator.ge}:
future = "a TypeError will be raised"
else:
future = (
"'the values will not compare equal to the "
"'datetime.date'"
)
msg = '\n'.join(textwrap.wrap(msg.format(future=future)))
warnings.warn(msg, FutureWarning, stacklevel=2)
other = pd.Timestamp(other)
res_values = dispatch_to_index_op(op, self, other,
pd.DatetimeIndex)
return self._constructor(res_values, index=self.index,
name=res_name)
elif is_timedelta64_dtype(self):
res_values = dispatch_to_index_op(op, self, other,
pd.TimedeltaIndex)
return self._constructor(res_values, index=self.index,
name=res_name)
elif (is_extension_array_dtype(self) or
(is_extension_array_dtype(other) and not is_scalar(other))):
# Note: the `not is_scalar(other)` condition rules out
# e.g. other == "category"
return dispatch_to_extension_op(op, self, other)
elif isinstance(other, ABCSeries):
# By this point we have checked that self._indexed_same(other)
res_values = na_op(self.values, other.values)
# rename is needed in case res_name is None and res_values.name
# is not.
return self._constructor(res_values, index=self.index,
name=res_name).rename(res_name)
elif isinstance(other, (np.ndarray, pd.Index)):
# do not check length of zerodim array
# as it will broadcast
if other.ndim != 0 and len(self) != len(other):
raise ValueError('Lengths must match to compare')
res_values = na_op(self.values, np.asarray(other))
result = self._constructor(res_values, index=self.index)
# rename is needed in case res_name is None and self.name
# is not.
return result.__finalize__(self).rename(res_name)
elif is_scalar(other) and isna(other):
# numpy does not like comparisons vs None
if op is operator.ne:
res_values = np.ones(len(self), dtype=bool)
else:
res_values = np.zeros(len(self), dtype=bool)
return self._constructor(res_values, index=self.index,
name=res_name, dtype='bool')
else:
values = self.get_values()
with np.errstate(all='ignore'):
res = na_op(values, other)
if is_scalar(res):
raise TypeError('Could not compare {typ} type with Series'
.format(typ=type(other)))
# always return a full value series here
res_values = com.values_from_object(res)
return self._constructor(res_values, index=self.index,
name=res_name, dtype='bool')
wrapper.__name__ = op_name
return wrapper | def _comp_method_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
op_name = _get_op_name(op, special)
masker = _gen_eval_kwargs(op_name).get('masker', False)
def na_op(x, y):
# TODO:
# should have guarantess on what x, y can be type-wise
# Extension Dtypes are not called here
# Checking that cases that were once handled here are no longer
# reachable.
assert not (is_categorical_dtype(y) and not is_scalar(y))
if is_object_dtype(x.dtype):
result = _comp_method_OBJECT_ARRAY(op, x, y)
elif is_datetimelike_v_numeric(x, y):
return invalid_comparison(x, y, op)
else:
# we want to compare like types
# we only want to convert to integer like if
# we are not NotImplemented, otherwise
# we would allow datetime64 (but viewed as i8) against
# integer comparisons
# we have a datetime/timedelta and may need to convert
assert not needs_i8_conversion(x)
mask = None
if not is_scalar(y) and needs_i8_conversion(y):
mask = isna(x) | isna(y)
y = y.view('i8')
x = x.view('i8')
method = getattr(x, op_name, None)
if method is not None:
with np.errstate(all='ignore'):
result = method(y)
if result is NotImplemented:
return invalid_comparison(x, y, op)
else:
result = op(x, y)
if mask is not None and mask.any():
result[mask] = masker
return result
def wrapper(self, other, axis=None):
# Validate the axis parameter
if axis is not None:
self._get_axis_number(axis)
res_name = get_op_result_name(self, other)
if isinstance(other, list):
# TODO: same for tuples?
other = np.asarray(other)
if isinstance(other, ABCDataFrame): # pragma: no cover
# Defer to DataFrame implementation; fail early
return NotImplemented
elif isinstance(other, ABCSeries) and not self._indexed_same(other):
raise ValueError("Can only compare identically-labeled "
"Series objects")
elif is_categorical_dtype(self):
# Dispatch to Categorical implementation; pd.CategoricalIndex
# behavior is non-canonical GH#19513
res_values = dispatch_to_index_op(op, self, other, pd.Categorical)
return self._constructor(res_values, index=self.index,
name=res_name)
elif is_datetime64_dtype(self) or is_datetime64tz_dtype(self):
# Dispatch to DatetimeIndex to ensure identical
# Series/Index behavior
if (isinstance(other, datetime.date) and
not isinstance(other, datetime.datetime)):
# https://github.com/pandas-dev/pandas/issues/21152
# Compatibility for difference between Series comparison w/
# datetime and date
msg = (
"Comparing Series of datetimes with 'datetime.date'. "
"Currently, the 'datetime.date' is coerced to a "
"datetime. In the future pandas will not coerce, "
"and {future}. "
"To retain the current behavior, "
"convert the 'datetime.date' to a datetime with "
"'pd.Timestamp'."
)
if op in {operator.lt, operator.le, operator.gt, operator.ge}:
future = "a TypeError will be raised"
else:
future = (
"'the values will not compare equal to the "
"'datetime.date'"
)
msg = '\n'.join(textwrap.wrap(msg.format(future=future)))
warnings.warn(msg, FutureWarning, stacklevel=2)
other = pd.Timestamp(other)
res_values = dispatch_to_index_op(op, self, other,
pd.DatetimeIndex)
return self._constructor(res_values, index=self.index,
name=res_name)
elif is_timedelta64_dtype(self):
res_values = dispatch_to_index_op(op, self, other,
pd.TimedeltaIndex)
return self._constructor(res_values, index=self.index,
name=res_name)
elif (is_extension_array_dtype(self) or
(is_extension_array_dtype(other) and not is_scalar(other))):
# Note: the `not is_scalar(other)` condition rules out
# e.g. other == "category"
return dispatch_to_extension_op(op, self, other)
elif isinstance(other, ABCSeries):
# By this point we have checked that self._indexed_same(other)
res_values = na_op(self.values, other.values)
# rename is needed in case res_name is None and res_values.name
# is not.
return self._constructor(res_values, index=self.index,
name=res_name).rename(res_name)
elif isinstance(other, (np.ndarray, pd.Index)):
# do not check length of zerodim array
# as it will broadcast
if other.ndim != 0 and len(self) != len(other):
raise ValueError('Lengths must match to compare')
res_values = na_op(self.values, np.asarray(other))
result = self._constructor(res_values, index=self.index)
# rename is needed in case res_name is None and self.name
# is not.
return result.__finalize__(self).rename(res_name)
elif is_scalar(other) and isna(other):
# numpy does not like comparisons vs None
if op is operator.ne:
res_values = np.ones(len(self), dtype=bool)
else:
res_values = np.zeros(len(self), dtype=bool)
return self._constructor(res_values, index=self.index,
name=res_name, dtype='bool')
else:
values = self.get_values()
with np.errstate(all='ignore'):
res = na_op(values, other)
if is_scalar(res):
raise TypeError('Could not compare {typ} type with Series'
.format(typ=type(other)))
# always return a full value series here
res_values = com.values_from_object(res)
return self._constructor(res_values, index=self.index,
name=res_name, dtype='bool')
wrapper.__name__ = op_name
return wrapper | [
"Wrapper",
"function",
"for",
"Series",
"arithmetic",
"operations",
"to",
"avoid",
"code",
"duplication",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1789-L1959 | [
"def",
"_comp_method_SERIES",
"(",
"cls",
",",
"op",
",",
"special",
")",
":",
"op_name",
"=",
"_get_op_name",
"(",
"op",
",",
"special",
")",
"masker",
"=",
"_gen_eval_kwargs",
"(",
"op_name",
")",
".",
"get",
"(",
"'masker'",
",",
"False",
")",
"def",
"na_op",
"(",
"x",
",",
"y",
")",
":",
"# TODO:",
"# should have guarantess on what x, y can be type-wise",
"# Extension Dtypes are not called here",
"# Checking that cases that were once handled here are no longer",
"# reachable.",
"assert",
"not",
"(",
"is_categorical_dtype",
"(",
"y",
")",
"and",
"not",
"is_scalar",
"(",
"y",
")",
")",
"if",
"is_object_dtype",
"(",
"x",
".",
"dtype",
")",
":",
"result",
"=",
"_comp_method_OBJECT_ARRAY",
"(",
"op",
",",
"x",
",",
"y",
")",
"elif",
"is_datetimelike_v_numeric",
"(",
"x",
",",
"y",
")",
":",
"return",
"invalid_comparison",
"(",
"x",
",",
"y",
",",
"op",
")",
"else",
":",
"# we want to compare like types",
"# we only want to convert to integer like if",
"# we are not NotImplemented, otherwise",
"# we would allow datetime64 (but viewed as i8) against",
"# integer comparisons",
"# we have a datetime/timedelta and may need to convert",
"assert",
"not",
"needs_i8_conversion",
"(",
"x",
")",
"mask",
"=",
"None",
"if",
"not",
"is_scalar",
"(",
"y",
")",
"and",
"needs_i8_conversion",
"(",
"y",
")",
":",
"mask",
"=",
"isna",
"(",
"x",
")",
"|",
"isna",
"(",
"y",
")",
"y",
"=",
"y",
".",
"view",
"(",
"'i8'",
")",
"x",
"=",
"x",
".",
"view",
"(",
"'i8'",
")",
"method",
"=",
"getattr",
"(",
"x",
",",
"op_name",
",",
"None",
")",
"if",
"method",
"is",
"not",
"None",
":",
"with",
"np",
".",
"errstate",
"(",
"all",
"=",
"'ignore'",
")",
":",
"result",
"=",
"method",
"(",
"y",
")",
"if",
"result",
"is",
"NotImplemented",
":",
"return",
"invalid_comparison",
"(",
"x",
",",
"y",
",",
"op",
")",
"else",
":",
"result",
"=",
"op",
"(",
"x",
",",
"y",
")",
"if",
"mask",
"is",
"not",
"None",
"and",
"mask",
".",
"any",
"(",
")",
":",
"result",
"[",
"mask",
"]",
"=",
"masker",
"return",
"result",
"def",
"wrapper",
"(",
"self",
",",
"other",
",",
"axis",
"=",
"None",
")",
":",
"# Validate the axis parameter",
"if",
"axis",
"is",
"not",
"None",
":",
"self",
".",
"_get_axis_number",
"(",
"axis",
")",
"res_name",
"=",
"get_op_result_name",
"(",
"self",
",",
"other",
")",
"if",
"isinstance",
"(",
"other",
",",
"list",
")",
":",
"# TODO: same for tuples?",
"other",
"=",
"np",
".",
"asarray",
"(",
"other",
")",
"if",
"isinstance",
"(",
"other",
",",
"ABCDataFrame",
")",
":",
"# pragma: no cover",
"# Defer to DataFrame implementation; fail early",
"return",
"NotImplemented",
"elif",
"isinstance",
"(",
"other",
",",
"ABCSeries",
")",
"and",
"not",
"self",
".",
"_indexed_same",
"(",
"other",
")",
":",
"raise",
"ValueError",
"(",
"\"Can only compare identically-labeled \"",
"\"Series objects\"",
")",
"elif",
"is_categorical_dtype",
"(",
"self",
")",
":",
"# Dispatch to Categorical implementation; pd.CategoricalIndex",
"# behavior is non-canonical GH#19513",
"res_values",
"=",
"dispatch_to_index_op",
"(",
"op",
",",
"self",
",",
"other",
",",
"pd",
".",
"Categorical",
")",
"return",
"self",
".",
"_constructor",
"(",
"res_values",
",",
"index",
"=",
"self",
".",
"index",
",",
"name",
"=",
"res_name",
")",
"elif",
"is_datetime64_dtype",
"(",
"self",
")",
"or",
"is_datetime64tz_dtype",
"(",
"self",
")",
":",
"# Dispatch to DatetimeIndex to ensure identical",
"# Series/Index behavior",
"if",
"(",
"isinstance",
"(",
"other",
",",
"datetime",
".",
"date",
")",
"and",
"not",
"isinstance",
"(",
"other",
",",
"datetime",
".",
"datetime",
")",
")",
":",
"# https://github.com/pandas-dev/pandas/issues/21152",
"# Compatibility for difference between Series comparison w/",
"# datetime and date",
"msg",
"=",
"(",
"\"Comparing Series of datetimes with 'datetime.date'. \"",
"\"Currently, the 'datetime.date' is coerced to a \"",
"\"datetime. In the future pandas will not coerce, \"",
"\"and {future}. \"",
"\"To retain the current behavior, \"",
"\"convert the 'datetime.date' to a datetime with \"",
"\"'pd.Timestamp'.\"",
")",
"if",
"op",
"in",
"{",
"operator",
".",
"lt",
",",
"operator",
".",
"le",
",",
"operator",
".",
"gt",
",",
"operator",
".",
"ge",
"}",
":",
"future",
"=",
"\"a TypeError will be raised\"",
"else",
":",
"future",
"=",
"(",
"\"'the values will not compare equal to the \"",
"\"'datetime.date'\"",
")",
"msg",
"=",
"'\\n'",
".",
"join",
"(",
"textwrap",
".",
"wrap",
"(",
"msg",
".",
"format",
"(",
"future",
"=",
"future",
")",
")",
")",
"warnings",
".",
"warn",
"(",
"msg",
",",
"FutureWarning",
",",
"stacklevel",
"=",
"2",
")",
"other",
"=",
"pd",
".",
"Timestamp",
"(",
"other",
")",
"res_values",
"=",
"dispatch_to_index_op",
"(",
"op",
",",
"self",
",",
"other",
",",
"pd",
".",
"DatetimeIndex",
")",
"return",
"self",
".",
"_constructor",
"(",
"res_values",
",",
"index",
"=",
"self",
".",
"index",
",",
"name",
"=",
"res_name",
")",
"elif",
"is_timedelta64_dtype",
"(",
"self",
")",
":",
"res_values",
"=",
"dispatch_to_index_op",
"(",
"op",
",",
"self",
",",
"other",
",",
"pd",
".",
"TimedeltaIndex",
")",
"return",
"self",
".",
"_constructor",
"(",
"res_values",
",",
"index",
"=",
"self",
".",
"index",
",",
"name",
"=",
"res_name",
")",
"elif",
"(",
"is_extension_array_dtype",
"(",
"self",
")",
"or",
"(",
"is_extension_array_dtype",
"(",
"other",
")",
"and",
"not",
"is_scalar",
"(",
"other",
")",
")",
")",
":",
"# Note: the `not is_scalar(other)` condition rules out",
"# e.g. other == \"category\"",
"return",
"dispatch_to_extension_op",
"(",
"op",
",",
"self",
",",
"other",
")",
"elif",
"isinstance",
"(",
"other",
",",
"ABCSeries",
")",
":",
"# By this point we have checked that self._indexed_same(other)",
"res_values",
"=",
"na_op",
"(",
"self",
".",
"values",
",",
"other",
".",
"values",
")",
"# rename is needed in case res_name is None and res_values.name",
"# is not.",
"return",
"self",
".",
"_constructor",
"(",
"res_values",
",",
"index",
"=",
"self",
".",
"index",
",",
"name",
"=",
"res_name",
")",
".",
"rename",
"(",
"res_name",
")",
"elif",
"isinstance",
"(",
"other",
",",
"(",
"np",
".",
"ndarray",
",",
"pd",
".",
"Index",
")",
")",
":",
"# do not check length of zerodim array",
"# as it will broadcast",
"if",
"other",
".",
"ndim",
"!=",
"0",
"and",
"len",
"(",
"self",
")",
"!=",
"len",
"(",
"other",
")",
":",
"raise",
"ValueError",
"(",
"'Lengths must match to compare'",
")",
"res_values",
"=",
"na_op",
"(",
"self",
".",
"values",
",",
"np",
".",
"asarray",
"(",
"other",
")",
")",
"result",
"=",
"self",
".",
"_constructor",
"(",
"res_values",
",",
"index",
"=",
"self",
".",
"index",
")",
"# rename is needed in case res_name is None and self.name",
"# is not.",
"return",
"result",
".",
"__finalize__",
"(",
"self",
")",
".",
"rename",
"(",
"res_name",
")",
"elif",
"is_scalar",
"(",
"other",
")",
"and",
"isna",
"(",
"other",
")",
":",
"# numpy does not like comparisons vs None",
"if",
"op",
"is",
"operator",
".",
"ne",
":",
"res_values",
"=",
"np",
".",
"ones",
"(",
"len",
"(",
"self",
")",
",",
"dtype",
"=",
"bool",
")",
"else",
":",
"res_values",
"=",
"np",
".",
"zeros",
"(",
"len",
"(",
"self",
")",
",",
"dtype",
"=",
"bool",
")",
"return",
"self",
".",
"_constructor",
"(",
"res_values",
",",
"index",
"=",
"self",
".",
"index",
",",
"name",
"=",
"res_name",
",",
"dtype",
"=",
"'bool'",
")",
"else",
":",
"values",
"=",
"self",
".",
"get_values",
"(",
")",
"with",
"np",
".",
"errstate",
"(",
"all",
"=",
"'ignore'",
")",
":",
"res",
"=",
"na_op",
"(",
"values",
",",
"other",
")",
"if",
"is_scalar",
"(",
"res",
")",
":",
"raise",
"TypeError",
"(",
"'Could not compare {typ} type with Series'",
".",
"format",
"(",
"typ",
"=",
"type",
"(",
"other",
")",
")",
")",
"# always return a full value series here",
"res_values",
"=",
"com",
".",
"values_from_object",
"(",
"res",
")",
"return",
"self",
".",
"_constructor",
"(",
"res_values",
",",
"index",
"=",
"self",
".",
"index",
",",
"name",
"=",
"res_name",
",",
"dtype",
"=",
"'bool'",
")",
"wrapper",
".",
"__name__",
"=",
"op_name",
"return",
"wrapper"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _bool_method_SERIES | Wrapper function for Series arithmetic operations, to avoid
code duplication. | pandas/core/ops.py | def _bool_method_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
op_name = _get_op_name(op, special)
def na_op(x, y):
try:
result = op(x, y)
except TypeError:
assert not isinstance(y, (list, ABCSeries, ABCIndexClass))
if isinstance(y, np.ndarray):
# bool-bool dtype operations should be OK, should not get here
assert not (is_bool_dtype(x) and is_bool_dtype(y))
x = ensure_object(x)
y = ensure_object(y)
result = libops.vec_binop(x, y, op)
else:
# let null fall thru
assert lib.is_scalar(y)
if not isna(y):
y = bool(y)
try:
result = libops.scalar_binop(x, y, op)
except (TypeError, ValueError, AttributeError,
OverflowError, NotImplementedError):
raise TypeError("cannot compare a dtyped [{dtype}] array "
"with a scalar of type [{typ}]"
.format(dtype=x.dtype,
typ=type(y).__name__))
return result
fill_int = lambda x: x.fillna(0)
fill_bool = lambda x: x.fillna(False).astype(bool)
def wrapper(self, other):
is_self_int_dtype = is_integer_dtype(self.dtype)
self, other = _align_method_SERIES(self, other, align_asobject=True)
res_name = get_op_result_name(self, other)
if isinstance(other, ABCDataFrame):
# Defer to DataFrame implementation; fail early
return NotImplemented
elif isinstance(other, (ABCSeries, ABCIndexClass)):
is_other_int_dtype = is_integer_dtype(other.dtype)
other = fill_int(other) if is_other_int_dtype else fill_bool(other)
ovalues = other.values
finalizer = lambda x: x
else:
# scalars, list, tuple, np.array
is_other_int_dtype = is_integer_dtype(np.asarray(other))
if is_list_like(other) and not isinstance(other, np.ndarray):
# TODO: Can we do this before the is_integer_dtype check?
# could the is_integer_dtype check be checking the wrong
# thing? e.g. other = [[0, 1], [2, 3], [4, 5]]?
other = construct_1d_object_array_from_listlike(other)
ovalues = other
finalizer = lambda x: x.__finalize__(self)
# For int vs int `^`, `|`, `&` are bitwise operators and return
# integer dtypes. Otherwise these are boolean ops
filler = (fill_int if is_self_int_dtype and is_other_int_dtype
else fill_bool)
res_values = na_op(self.values, ovalues)
unfilled = self._constructor(res_values,
index=self.index, name=res_name)
filled = filler(unfilled)
return finalizer(filled)
wrapper.__name__ = op_name
return wrapper | def _bool_method_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
op_name = _get_op_name(op, special)
def na_op(x, y):
try:
result = op(x, y)
except TypeError:
assert not isinstance(y, (list, ABCSeries, ABCIndexClass))
if isinstance(y, np.ndarray):
# bool-bool dtype operations should be OK, should not get here
assert not (is_bool_dtype(x) and is_bool_dtype(y))
x = ensure_object(x)
y = ensure_object(y)
result = libops.vec_binop(x, y, op)
else:
# let null fall thru
assert lib.is_scalar(y)
if not isna(y):
y = bool(y)
try:
result = libops.scalar_binop(x, y, op)
except (TypeError, ValueError, AttributeError,
OverflowError, NotImplementedError):
raise TypeError("cannot compare a dtyped [{dtype}] array "
"with a scalar of type [{typ}]"
.format(dtype=x.dtype,
typ=type(y).__name__))
return result
fill_int = lambda x: x.fillna(0)
fill_bool = lambda x: x.fillna(False).astype(bool)
def wrapper(self, other):
is_self_int_dtype = is_integer_dtype(self.dtype)
self, other = _align_method_SERIES(self, other, align_asobject=True)
res_name = get_op_result_name(self, other)
if isinstance(other, ABCDataFrame):
# Defer to DataFrame implementation; fail early
return NotImplemented
elif isinstance(other, (ABCSeries, ABCIndexClass)):
is_other_int_dtype = is_integer_dtype(other.dtype)
other = fill_int(other) if is_other_int_dtype else fill_bool(other)
ovalues = other.values
finalizer = lambda x: x
else:
# scalars, list, tuple, np.array
is_other_int_dtype = is_integer_dtype(np.asarray(other))
if is_list_like(other) and not isinstance(other, np.ndarray):
# TODO: Can we do this before the is_integer_dtype check?
# could the is_integer_dtype check be checking the wrong
# thing? e.g. other = [[0, 1], [2, 3], [4, 5]]?
other = construct_1d_object_array_from_listlike(other)
ovalues = other
finalizer = lambda x: x.__finalize__(self)
# For int vs int `^`, `|`, `&` are bitwise operators and return
# integer dtypes. Otherwise these are boolean ops
filler = (fill_int if is_self_int_dtype and is_other_int_dtype
else fill_bool)
res_values = na_op(self.values, ovalues)
unfilled = self._constructor(res_values,
index=self.index, name=res_name)
filled = filler(unfilled)
return finalizer(filled)
wrapper.__name__ = op_name
return wrapper | [
"Wrapper",
"function",
"for",
"Series",
"arithmetic",
"operations",
"to",
"avoid",
"code",
"duplication",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L1962-L2039 | [
"def",
"_bool_method_SERIES",
"(",
"cls",
",",
"op",
",",
"special",
")",
":",
"op_name",
"=",
"_get_op_name",
"(",
"op",
",",
"special",
")",
"def",
"na_op",
"(",
"x",
",",
"y",
")",
":",
"try",
":",
"result",
"=",
"op",
"(",
"x",
",",
"y",
")",
"except",
"TypeError",
":",
"assert",
"not",
"isinstance",
"(",
"y",
",",
"(",
"list",
",",
"ABCSeries",
",",
"ABCIndexClass",
")",
")",
"if",
"isinstance",
"(",
"y",
",",
"np",
".",
"ndarray",
")",
":",
"# bool-bool dtype operations should be OK, should not get here",
"assert",
"not",
"(",
"is_bool_dtype",
"(",
"x",
")",
"and",
"is_bool_dtype",
"(",
"y",
")",
")",
"x",
"=",
"ensure_object",
"(",
"x",
")",
"y",
"=",
"ensure_object",
"(",
"y",
")",
"result",
"=",
"libops",
".",
"vec_binop",
"(",
"x",
",",
"y",
",",
"op",
")",
"else",
":",
"# let null fall thru",
"assert",
"lib",
".",
"is_scalar",
"(",
"y",
")",
"if",
"not",
"isna",
"(",
"y",
")",
":",
"y",
"=",
"bool",
"(",
"y",
")",
"try",
":",
"result",
"=",
"libops",
".",
"scalar_binop",
"(",
"x",
",",
"y",
",",
"op",
")",
"except",
"(",
"TypeError",
",",
"ValueError",
",",
"AttributeError",
",",
"OverflowError",
",",
"NotImplementedError",
")",
":",
"raise",
"TypeError",
"(",
"\"cannot compare a dtyped [{dtype}] array \"",
"\"with a scalar of type [{typ}]\"",
".",
"format",
"(",
"dtype",
"=",
"x",
".",
"dtype",
",",
"typ",
"=",
"type",
"(",
"y",
")",
".",
"__name__",
")",
")",
"return",
"result",
"fill_int",
"=",
"lambda",
"x",
":",
"x",
".",
"fillna",
"(",
"0",
")",
"fill_bool",
"=",
"lambda",
"x",
":",
"x",
".",
"fillna",
"(",
"False",
")",
".",
"astype",
"(",
"bool",
")",
"def",
"wrapper",
"(",
"self",
",",
"other",
")",
":",
"is_self_int_dtype",
"=",
"is_integer_dtype",
"(",
"self",
".",
"dtype",
")",
"self",
",",
"other",
"=",
"_align_method_SERIES",
"(",
"self",
",",
"other",
",",
"align_asobject",
"=",
"True",
")",
"res_name",
"=",
"get_op_result_name",
"(",
"self",
",",
"other",
")",
"if",
"isinstance",
"(",
"other",
",",
"ABCDataFrame",
")",
":",
"# Defer to DataFrame implementation; fail early",
"return",
"NotImplemented",
"elif",
"isinstance",
"(",
"other",
",",
"(",
"ABCSeries",
",",
"ABCIndexClass",
")",
")",
":",
"is_other_int_dtype",
"=",
"is_integer_dtype",
"(",
"other",
".",
"dtype",
")",
"other",
"=",
"fill_int",
"(",
"other",
")",
"if",
"is_other_int_dtype",
"else",
"fill_bool",
"(",
"other",
")",
"ovalues",
"=",
"other",
".",
"values",
"finalizer",
"=",
"lambda",
"x",
":",
"x",
"else",
":",
"# scalars, list, tuple, np.array",
"is_other_int_dtype",
"=",
"is_integer_dtype",
"(",
"np",
".",
"asarray",
"(",
"other",
")",
")",
"if",
"is_list_like",
"(",
"other",
")",
"and",
"not",
"isinstance",
"(",
"other",
",",
"np",
".",
"ndarray",
")",
":",
"# TODO: Can we do this before the is_integer_dtype check?",
"# could the is_integer_dtype check be checking the wrong",
"# thing? e.g. other = [[0, 1], [2, 3], [4, 5]]?",
"other",
"=",
"construct_1d_object_array_from_listlike",
"(",
"other",
")",
"ovalues",
"=",
"other",
"finalizer",
"=",
"lambda",
"x",
":",
"x",
".",
"__finalize__",
"(",
"self",
")",
"# For int vs int `^`, `|`, `&` are bitwise operators and return",
"# integer dtypes. Otherwise these are boolean ops",
"filler",
"=",
"(",
"fill_int",
"if",
"is_self_int_dtype",
"and",
"is_other_int_dtype",
"else",
"fill_bool",
")",
"res_values",
"=",
"na_op",
"(",
"self",
".",
"values",
",",
"ovalues",
")",
"unfilled",
"=",
"self",
".",
"_constructor",
"(",
"res_values",
",",
"index",
"=",
"self",
".",
"index",
",",
"name",
"=",
"res_name",
")",
"filled",
"=",
"filler",
"(",
"unfilled",
")",
"return",
"finalizer",
"(",
"filled",
")",
"wrapper",
".",
"__name__",
"=",
"op_name",
"return",
"wrapper"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _combine_series_frame | Apply binary operator `func` to self, other using alignment and fill
conventions determined by the fill_value, axis, and level kwargs.
Parameters
----------
self : DataFrame
other : Series
func : binary operator
fill_value : object, default None
axis : {0, 1, 'columns', 'index', None}, default None
level : int or None, default None
Returns
-------
result : DataFrame | pandas/core/ops.py | def _combine_series_frame(self, other, func, fill_value=None, axis=None,
level=None):
"""
Apply binary operator `func` to self, other using alignment and fill
conventions determined by the fill_value, axis, and level kwargs.
Parameters
----------
self : DataFrame
other : Series
func : binary operator
fill_value : object, default None
axis : {0, 1, 'columns', 'index', None}, default None
level : int or None, default None
Returns
-------
result : DataFrame
"""
if fill_value is not None:
raise NotImplementedError("fill_value {fill} not supported."
.format(fill=fill_value))
if axis is not None:
axis = self._get_axis_number(axis)
if axis == 0:
return self._combine_match_index(other, func, level=level)
else:
return self._combine_match_columns(other, func, level=level)
else:
if not len(other):
return self * np.nan
if not len(self):
# Ambiguous case, use _series so works with DataFrame
return self._constructor(data=self._series, index=self.index,
columns=self.columns)
# default axis is columns
return self._combine_match_columns(other, func, level=level) | def _combine_series_frame(self, other, func, fill_value=None, axis=None,
level=None):
"""
Apply binary operator `func` to self, other using alignment and fill
conventions determined by the fill_value, axis, and level kwargs.
Parameters
----------
self : DataFrame
other : Series
func : binary operator
fill_value : object, default None
axis : {0, 1, 'columns', 'index', None}, default None
level : int or None, default None
Returns
-------
result : DataFrame
"""
if fill_value is not None:
raise NotImplementedError("fill_value {fill} not supported."
.format(fill=fill_value))
if axis is not None:
axis = self._get_axis_number(axis)
if axis == 0:
return self._combine_match_index(other, func, level=level)
else:
return self._combine_match_columns(other, func, level=level)
else:
if not len(other):
return self * np.nan
if not len(self):
# Ambiguous case, use _series so works with DataFrame
return self._constructor(data=self._series, index=self.index,
columns=self.columns)
# default axis is columns
return self._combine_match_columns(other, func, level=level) | [
"Apply",
"binary",
"operator",
"func",
"to",
"self",
"other",
"using",
"alignment",
"and",
"fill",
"conventions",
"determined",
"by",
"the",
"fill_value",
"axis",
"and",
"level",
"kwargs",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L2073-L2112 | [
"def",
"_combine_series_frame",
"(",
"self",
",",
"other",
",",
"func",
",",
"fill_value",
"=",
"None",
",",
"axis",
"=",
"None",
",",
"level",
"=",
"None",
")",
":",
"if",
"fill_value",
"is",
"not",
"None",
":",
"raise",
"NotImplementedError",
"(",
"\"fill_value {fill} not supported.\"",
".",
"format",
"(",
"fill",
"=",
"fill_value",
")",
")",
"if",
"axis",
"is",
"not",
"None",
":",
"axis",
"=",
"self",
".",
"_get_axis_number",
"(",
"axis",
")",
"if",
"axis",
"==",
"0",
":",
"return",
"self",
".",
"_combine_match_index",
"(",
"other",
",",
"func",
",",
"level",
"=",
"level",
")",
"else",
":",
"return",
"self",
".",
"_combine_match_columns",
"(",
"other",
",",
"func",
",",
"level",
"=",
"level",
")",
"else",
":",
"if",
"not",
"len",
"(",
"other",
")",
":",
"return",
"self",
"*",
"np",
".",
"nan",
"if",
"not",
"len",
"(",
"self",
")",
":",
"# Ambiguous case, use _series so works with DataFrame",
"return",
"self",
".",
"_constructor",
"(",
"data",
"=",
"self",
".",
"_series",
",",
"index",
"=",
"self",
".",
"index",
",",
"columns",
"=",
"self",
".",
"columns",
")",
"# default axis is columns",
"return",
"self",
".",
"_combine_match_columns",
"(",
"other",
",",
"func",
",",
"level",
"=",
"level",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _align_method_FRAME | convert rhs to meet lhs dims if input is list, tuple or np.ndarray | pandas/core/ops.py | def _align_method_FRAME(left, right, axis):
""" convert rhs to meet lhs dims if input is list, tuple or np.ndarray """
def to_series(right):
msg = ('Unable to coerce to Series, length must be {req_len}: '
'given {given_len}')
if axis is not None and left._get_axis_name(axis) == 'index':
if len(left.index) != len(right):
raise ValueError(msg.format(req_len=len(left.index),
given_len=len(right)))
right = left._constructor_sliced(right, index=left.index)
else:
if len(left.columns) != len(right):
raise ValueError(msg.format(req_len=len(left.columns),
given_len=len(right)))
right = left._constructor_sliced(right, index=left.columns)
return right
if isinstance(right, np.ndarray):
if right.ndim == 1:
right = to_series(right)
elif right.ndim == 2:
if right.shape == left.shape:
right = left._constructor(right, index=left.index,
columns=left.columns)
elif right.shape[0] == left.shape[0] and right.shape[1] == 1:
# Broadcast across columns
right = np.broadcast_to(right, left.shape)
right = left._constructor(right,
index=left.index,
columns=left.columns)
elif right.shape[1] == left.shape[1] and right.shape[0] == 1:
# Broadcast along rows
right = to_series(right[0, :])
else:
raise ValueError("Unable to coerce to DataFrame, shape "
"must be {req_shape}: given {given_shape}"
.format(req_shape=left.shape,
given_shape=right.shape))
elif right.ndim > 2:
raise ValueError('Unable to coerce to Series/DataFrame, dim '
'must be <= 2: {dim}'.format(dim=right.shape))
elif (is_list_like(right) and
not isinstance(right, (ABCSeries, ABCDataFrame))):
# GH17901
right = to_series(right)
return right | def _align_method_FRAME(left, right, axis):
""" convert rhs to meet lhs dims if input is list, tuple or np.ndarray """
def to_series(right):
msg = ('Unable to coerce to Series, length must be {req_len}: '
'given {given_len}')
if axis is not None and left._get_axis_name(axis) == 'index':
if len(left.index) != len(right):
raise ValueError(msg.format(req_len=len(left.index),
given_len=len(right)))
right = left._constructor_sliced(right, index=left.index)
else:
if len(left.columns) != len(right):
raise ValueError(msg.format(req_len=len(left.columns),
given_len=len(right)))
right = left._constructor_sliced(right, index=left.columns)
return right
if isinstance(right, np.ndarray):
if right.ndim == 1:
right = to_series(right)
elif right.ndim == 2:
if right.shape == left.shape:
right = left._constructor(right, index=left.index,
columns=left.columns)
elif right.shape[0] == left.shape[0] and right.shape[1] == 1:
# Broadcast across columns
right = np.broadcast_to(right, left.shape)
right = left._constructor(right,
index=left.index,
columns=left.columns)
elif right.shape[1] == left.shape[1] and right.shape[0] == 1:
# Broadcast along rows
right = to_series(right[0, :])
else:
raise ValueError("Unable to coerce to DataFrame, shape "
"must be {req_shape}: given {given_shape}"
.format(req_shape=left.shape,
given_shape=right.shape))
elif right.ndim > 2:
raise ValueError('Unable to coerce to Series/DataFrame, dim '
'must be <= 2: {dim}'.format(dim=right.shape))
elif (is_list_like(right) and
not isinstance(right, (ABCSeries, ABCDataFrame))):
# GH17901
right = to_series(right)
return right | [
"convert",
"rhs",
"to",
"meet",
"lhs",
"dims",
"if",
"input",
"is",
"list",
"tuple",
"or",
"np",
".",
"ndarray"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L2115-L2169 | [
"def",
"_align_method_FRAME",
"(",
"left",
",",
"right",
",",
"axis",
")",
":",
"def",
"to_series",
"(",
"right",
")",
":",
"msg",
"=",
"(",
"'Unable to coerce to Series, length must be {req_len}: '",
"'given {given_len}'",
")",
"if",
"axis",
"is",
"not",
"None",
"and",
"left",
".",
"_get_axis_name",
"(",
"axis",
")",
"==",
"'index'",
":",
"if",
"len",
"(",
"left",
".",
"index",
")",
"!=",
"len",
"(",
"right",
")",
":",
"raise",
"ValueError",
"(",
"msg",
".",
"format",
"(",
"req_len",
"=",
"len",
"(",
"left",
".",
"index",
")",
",",
"given_len",
"=",
"len",
"(",
"right",
")",
")",
")",
"right",
"=",
"left",
".",
"_constructor_sliced",
"(",
"right",
",",
"index",
"=",
"left",
".",
"index",
")",
"else",
":",
"if",
"len",
"(",
"left",
".",
"columns",
")",
"!=",
"len",
"(",
"right",
")",
":",
"raise",
"ValueError",
"(",
"msg",
".",
"format",
"(",
"req_len",
"=",
"len",
"(",
"left",
".",
"columns",
")",
",",
"given_len",
"=",
"len",
"(",
"right",
")",
")",
")",
"right",
"=",
"left",
".",
"_constructor_sliced",
"(",
"right",
",",
"index",
"=",
"left",
".",
"columns",
")",
"return",
"right",
"if",
"isinstance",
"(",
"right",
",",
"np",
".",
"ndarray",
")",
":",
"if",
"right",
".",
"ndim",
"==",
"1",
":",
"right",
"=",
"to_series",
"(",
"right",
")",
"elif",
"right",
".",
"ndim",
"==",
"2",
":",
"if",
"right",
".",
"shape",
"==",
"left",
".",
"shape",
":",
"right",
"=",
"left",
".",
"_constructor",
"(",
"right",
",",
"index",
"=",
"left",
".",
"index",
",",
"columns",
"=",
"left",
".",
"columns",
")",
"elif",
"right",
".",
"shape",
"[",
"0",
"]",
"==",
"left",
".",
"shape",
"[",
"0",
"]",
"and",
"right",
".",
"shape",
"[",
"1",
"]",
"==",
"1",
":",
"# Broadcast across columns",
"right",
"=",
"np",
".",
"broadcast_to",
"(",
"right",
",",
"left",
".",
"shape",
")",
"right",
"=",
"left",
".",
"_constructor",
"(",
"right",
",",
"index",
"=",
"left",
".",
"index",
",",
"columns",
"=",
"left",
".",
"columns",
")",
"elif",
"right",
".",
"shape",
"[",
"1",
"]",
"==",
"left",
".",
"shape",
"[",
"1",
"]",
"and",
"right",
".",
"shape",
"[",
"0",
"]",
"==",
"1",
":",
"# Broadcast along rows",
"right",
"=",
"to_series",
"(",
"right",
"[",
"0",
",",
":",
"]",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Unable to coerce to DataFrame, shape \"",
"\"must be {req_shape}: given {given_shape}\"",
".",
"format",
"(",
"req_shape",
"=",
"left",
".",
"shape",
",",
"given_shape",
"=",
"right",
".",
"shape",
")",
")",
"elif",
"right",
".",
"ndim",
">",
"2",
":",
"raise",
"ValueError",
"(",
"'Unable to coerce to Series/DataFrame, dim '",
"'must be <= 2: {dim}'",
".",
"format",
"(",
"dim",
"=",
"right",
".",
"shape",
")",
")",
"elif",
"(",
"is_list_like",
"(",
"right",
")",
"and",
"not",
"isinstance",
"(",
"right",
",",
"(",
"ABCSeries",
",",
"ABCDataFrame",
")",
")",
")",
":",
"# GH17901",
"right",
"=",
"to_series",
"(",
"right",
")",
"return",
"right"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _cast_sparse_series_op | For SparseSeries operation, coerce to float64 if the result is expected
to have NaN or inf values
Parameters
----------
left : SparseArray
right : SparseArray
opname : str
Returns
-------
left : SparseArray
right : SparseArray | pandas/core/ops.py | def _cast_sparse_series_op(left, right, opname):
"""
For SparseSeries operation, coerce to float64 if the result is expected
to have NaN or inf values
Parameters
----------
left : SparseArray
right : SparseArray
opname : str
Returns
-------
left : SparseArray
right : SparseArray
"""
from pandas.core.sparse.api import SparseDtype
opname = opname.strip('_')
# TODO: This should be moved to the array?
if is_integer_dtype(left) and is_integer_dtype(right):
# series coerces to float64 if result should have NaN/inf
if opname in ('floordiv', 'mod') and (right.values == 0).any():
left = left.astype(SparseDtype(np.float64, left.fill_value))
right = right.astype(SparseDtype(np.float64, right.fill_value))
elif opname in ('rfloordiv', 'rmod') and (left.values == 0).any():
left = left.astype(SparseDtype(np.float64, left.fill_value))
right = right.astype(SparseDtype(np.float64, right.fill_value))
return left, right | def _cast_sparse_series_op(left, right, opname):
"""
For SparseSeries operation, coerce to float64 if the result is expected
to have NaN or inf values
Parameters
----------
left : SparseArray
right : SparseArray
opname : str
Returns
-------
left : SparseArray
right : SparseArray
"""
from pandas.core.sparse.api import SparseDtype
opname = opname.strip('_')
# TODO: This should be moved to the array?
if is_integer_dtype(left) and is_integer_dtype(right):
# series coerces to float64 if result should have NaN/inf
if opname in ('floordiv', 'mod') and (right.values == 0).any():
left = left.astype(SparseDtype(np.float64, left.fill_value))
right = right.astype(SparseDtype(np.float64, right.fill_value))
elif opname in ('rfloordiv', 'rmod') and (left.values == 0).any():
left = left.astype(SparseDtype(np.float64, left.fill_value))
right = right.astype(SparseDtype(np.float64, right.fill_value))
return left, right | [
"For",
"SparseSeries",
"operation",
"coerce",
"to",
"float64",
"if",
"the",
"result",
"is",
"expected",
"to",
"have",
"NaN",
"or",
"inf",
"values"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L2389-L2419 | [
"def",
"_cast_sparse_series_op",
"(",
"left",
",",
"right",
",",
"opname",
")",
":",
"from",
"pandas",
".",
"core",
".",
"sparse",
".",
"api",
"import",
"SparseDtype",
"opname",
"=",
"opname",
".",
"strip",
"(",
"'_'",
")",
"# TODO: This should be moved to the array?",
"if",
"is_integer_dtype",
"(",
"left",
")",
"and",
"is_integer_dtype",
"(",
"right",
")",
":",
"# series coerces to float64 if result should have NaN/inf",
"if",
"opname",
"in",
"(",
"'floordiv'",
",",
"'mod'",
")",
"and",
"(",
"right",
".",
"values",
"==",
"0",
")",
".",
"any",
"(",
")",
":",
"left",
"=",
"left",
".",
"astype",
"(",
"SparseDtype",
"(",
"np",
".",
"float64",
",",
"left",
".",
"fill_value",
")",
")",
"right",
"=",
"right",
".",
"astype",
"(",
"SparseDtype",
"(",
"np",
".",
"float64",
",",
"right",
".",
"fill_value",
")",
")",
"elif",
"opname",
"in",
"(",
"'rfloordiv'",
",",
"'rmod'",
")",
"and",
"(",
"left",
".",
"values",
"==",
"0",
")",
".",
"any",
"(",
")",
":",
"left",
"=",
"left",
".",
"astype",
"(",
"SparseDtype",
"(",
"np",
".",
"float64",
",",
"left",
".",
"fill_value",
")",
")",
"right",
"=",
"right",
".",
"astype",
"(",
"SparseDtype",
"(",
"np",
".",
"float64",
",",
"right",
".",
"fill_value",
")",
")",
"return",
"left",
",",
"right"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _arith_method_SPARSE_SERIES | Wrapper function for Series arithmetic operations, to avoid
code duplication. | pandas/core/ops.py | def _arith_method_SPARSE_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
op_name = _get_op_name(op, special)
def wrapper(self, other):
if isinstance(other, ABCDataFrame):
return NotImplemented
elif isinstance(other, ABCSeries):
if not isinstance(other, ABCSparseSeries):
other = other.to_sparse(fill_value=self.fill_value)
return _sparse_series_op(self, other, op, op_name)
elif is_scalar(other):
with np.errstate(all='ignore'):
new_values = op(self.values, other)
return self._constructor(new_values,
index=self.index,
name=self.name)
else: # pragma: no cover
raise TypeError('operation with {other} not supported'
.format(other=type(other)))
wrapper.__name__ = op_name
return wrapper | def _arith_method_SPARSE_SERIES(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
op_name = _get_op_name(op, special)
def wrapper(self, other):
if isinstance(other, ABCDataFrame):
return NotImplemented
elif isinstance(other, ABCSeries):
if not isinstance(other, ABCSparseSeries):
other = other.to_sparse(fill_value=self.fill_value)
return _sparse_series_op(self, other, op, op_name)
elif is_scalar(other):
with np.errstate(all='ignore'):
new_values = op(self.values, other)
return self._constructor(new_values,
index=self.index,
name=self.name)
else: # pragma: no cover
raise TypeError('operation with {other} not supported'
.format(other=type(other)))
wrapper.__name__ = op_name
return wrapper | [
"Wrapper",
"function",
"for",
"Series",
"arithmetic",
"operations",
"to",
"avoid",
"code",
"duplication",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L2422-L2447 | [
"def",
"_arith_method_SPARSE_SERIES",
"(",
"cls",
",",
"op",
",",
"special",
")",
":",
"op_name",
"=",
"_get_op_name",
"(",
"op",
",",
"special",
")",
"def",
"wrapper",
"(",
"self",
",",
"other",
")",
":",
"if",
"isinstance",
"(",
"other",
",",
"ABCDataFrame",
")",
":",
"return",
"NotImplemented",
"elif",
"isinstance",
"(",
"other",
",",
"ABCSeries",
")",
":",
"if",
"not",
"isinstance",
"(",
"other",
",",
"ABCSparseSeries",
")",
":",
"other",
"=",
"other",
".",
"to_sparse",
"(",
"fill_value",
"=",
"self",
".",
"fill_value",
")",
"return",
"_sparse_series_op",
"(",
"self",
",",
"other",
",",
"op",
",",
"op_name",
")",
"elif",
"is_scalar",
"(",
"other",
")",
":",
"with",
"np",
".",
"errstate",
"(",
"all",
"=",
"'ignore'",
")",
":",
"new_values",
"=",
"op",
"(",
"self",
".",
"values",
",",
"other",
")",
"return",
"self",
".",
"_constructor",
"(",
"new_values",
",",
"index",
"=",
"self",
".",
"index",
",",
"name",
"=",
"self",
".",
"name",
")",
"else",
":",
"# pragma: no cover",
"raise",
"TypeError",
"(",
"'operation with {other} not supported'",
".",
"format",
"(",
"other",
"=",
"type",
"(",
"other",
")",
")",
")",
"wrapper",
".",
"__name__",
"=",
"op_name",
"return",
"wrapper"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _arith_method_SPARSE_ARRAY | Wrapper function for Series arithmetic operations, to avoid
code duplication. | pandas/core/ops.py | def _arith_method_SPARSE_ARRAY(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
op_name = _get_op_name(op, special)
def wrapper(self, other):
from pandas.core.arrays.sparse.array import (
SparseArray, _sparse_array_op, _wrap_result, _get_fill)
if isinstance(other, np.ndarray):
if len(self) != len(other):
raise AssertionError("length mismatch: {self} vs. {other}"
.format(self=len(self), other=len(other)))
if not isinstance(other, SparseArray):
dtype = getattr(other, 'dtype', None)
other = SparseArray(other, fill_value=self.fill_value,
dtype=dtype)
return _sparse_array_op(self, other, op, op_name)
elif is_scalar(other):
with np.errstate(all='ignore'):
fill = op(_get_fill(self), np.asarray(other))
result = op(self.sp_values, other)
return _wrap_result(op_name, result, self.sp_index, fill)
else: # pragma: no cover
raise TypeError('operation with {other} not supported'
.format(other=type(other)))
wrapper.__name__ = op_name
return wrapper | def _arith_method_SPARSE_ARRAY(cls, op, special):
"""
Wrapper function for Series arithmetic operations, to avoid
code duplication.
"""
op_name = _get_op_name(op, special)
def wrapper(self, other):
from pandas.core.arrays.sparse.array import (
SparseArray, _sparse_array_op, _wrap_result, _get_fill)
if isinstance(other, np.ndarray):
if len(self) != len(other):
raise AssertionError("length mismatch: {self} vs. {other}"
.format(self=len(self), other=len(other)))
if not isinstance(other, SparseArray):
dtype = getattr(other, 'dtype', None)
other = SparseArray(other, fill_value=self.fill_value,
dtype=dtype)
return _sparse_array_op(self, other, op, op_name)
elif is_scalar(other):
with np.errstate(all='ignore'):
fill = op(_get_fill(self), np.asarray(other))
result = op(self.sp_values, other)
return _wrap_result(op_name, result, self.sp_index, fill)
else: # pragma: no cover
raise TypeError('operation with {other} not supported'
.format(other=type(other)))
wrapper.__name__ = op_name
return wrapper | [
"Wrapper",
"function",
"for",
"Series",
"arithmetic",
"operations",
"to",
"avoid",
"code",
"duplication",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/ops.py#L2461-L2491 | [
"def",
"_arith_method_SPARSE_ARRAY",
"(",
"cls",
",",
"op",
",",
"special",
")",
":",
"op_name",
"=",
"_get_op_name",
"(",
"op",
",",
"special",
")",
"def",
"wrapper",
"(",
"self",
",",
"other",
")",
":",
"from",
"pandas",
".",
"core",
".",
"arrays",
".",
"sparse",
".",
"array",
"import",
"(",
"SparseArray",
",",
"_sparse_array_op",
",",
"_wrap_result",
",",
"_get_fill",
")",
"if",
"isinstance",
"(",
"other",
",",
"np",
".",
"ndarray",
")",
":",
"if",
"len",
"(",
"self",
")",
"!=",
"len",
"(",
"other",
")",
":",
"raise",
"AssertionError",
"(",
"\"length mismatch: {self} vs. {other}\"",
".",
"format",
"(",
"self",
"=",
"len",
"(",
"self",
")",
",",
"other",
"=",
"len",
"(",
"other",
")",
")",
")",
"if",
"not",
"isinstance",
"(",
"other",
",",
"SparseArray",
")",
":",
"dtype",
"=",
"getattr",
"(",
"other",
",",
"'dtype'",
",",
"None",
")",
"other",
"=",
"SparseArray",
"(",
"other",
",",
"fill_value",
"=",
"self",
".",
"fill_value",
",",
"dtype",
"=",
"dtype",
")",
"return",
"_sparse_array_op",
"(",
"self",
",",
"other",
",",
"op",
",",
"op_name",
")",
"elif",
"is_scalar",
"(",
"other",
")",
":",
"with",
"np",
".",
"errstate",
"(",
"all",
"=",
"'ignore'",
")",
":",
"fill",
"=",
"op",
"(",
"_get_fill",
"(",
"self",
")",
",",
"np",
".",
"asarray",
"(",
"other",
")",
")",
"result",
"=",
"op",
"(",
"self",
".",
"sp_values",
",",
"other",
")",
"return",
"_wrap_result",
"(",
"op_name",
",",
"result",
",",
"self",
".",
"sp_index",
",",
"fill",
")",
"else",
":",
"# pragma: no cover",
"raise",
"TypeError",
"(",
"'operation with {other} not supported'",
".",
"format",
"(",
"other",
"=",
"type",
"(",
"other",
")",
")",
")",
"wrapper",
".",
"__name__",
"=",
"op_name",
"return",
"wrapper"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | validate_periods | If a `periods` argument is passed to the Datetime/Timedelta Array/Index
constructor, cast it to an integer.
Parameters
----------
periods : None, float, int
Returns
-------
periods : None or int
Raises
------
TypeError
if periods is None, float, or int | pandas/core/arrays/datetimelike.py | def validate_periods(periods):
"""
If a `periods` argument is passed to the Datetime/Timedelta Array/Index
constructor, cast it to an integer.
Parameters
----------
periods : None, float, int
Returns
-------
periods : None or int
Raises
------
TypeError
if periods is None, float, or int
"""
if periods is not None:
if lib.is_float(periods):
periods = int(periods)
elif not lib.is_integer(periods):
raise TypeError('periods must be a number, got {periods}'
.format(periods=periods))
return periods | def validate_periods(periods):
"""
If a `periods` argument is passed to the Datetime/Timedelta Array/Index
constructor, cast it to an integer.
Parameters
----------
periods : None, float, int
Returns
-------
periods : None or int
Raises
------
TypeError
if periods is None, float, or int
"""
if periods is not None:
if lib.is_float(periods):
periods = int(periods)
elif not lib.is_integer(periods):
raise TypeError('periods must be a number, got {periods}'
.format(periods=periods))
return periods | [
"If",
"a",
"periods",
"argument",
"is",
"passed",
"to",
"the",
"Datetime",
"/",
"Timedelta",
"Array",
"/",
"Index",
"constructor",
"cast",
"it",
"to",
"an",
"integer",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/arrays/datetimelike.py#L1441-L1465 | [
"def",
"validate_periods",
"(",
"periods",
")",
":",
"if",
"periods",
"is",
"not",
"None",
":",
"if",
"lib",
".",
"is_float",
"(",
"periods",
")",
":",
"periods",
"=",
"int",
"(",
"periods",
")",
"elif",
"not",
"lib",
".",
"is_integer",
"(",
"periods",
")",
":",
"raise",
"TypeError",
"(",
"'periods must be a number, got {periods}'",
".",
"format",
"(",
"periods",
"=",
"periods",
")",
")",
"return",
"periods"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | validate_endpoints | Check that the `closed` argument is among [None, "left", "right"]
Parameters
----------
closed : {None, "left", "right"}
Returns
-------
left_closed : bool
right_closed : bool
Raises
------
ValueError : if argument is not among valid values | pandas/core/arrays/datetimelike.py | def validate_endpoints(closed):
"""
Check that the `closed` argument is among [None, "left", "right"]
Parameters
----------
closed : {None, "left", "right"}
Returns
-------
left_closed : bool
right_closed : bool
Raises
------
ValueError : if argument is not among valid values
"""
left_closed = False
right_closed = False
if closed is None:
left_closed = True
right_closed = True
elif closed == "left":
left_closed = True
elif closed == "right":
right_closed = True
else:
raise ValueError("Closed has to be either 'left', 'right' or None")
return left_closed, right_closed | def validate_endpoints(closed):
"""
Check that the `closed` argument is among [None, "left", "right"]
Parameters
----------
closed : {None, "left", "right"}
Returns
-------
left_closed : bool
right_closed : bool
Raises
------
ValueError : if argument is not among valid values
"""
left_closed = False
right_closed = False
if closed is None:
left_closed = True
right_closed = True
elif closed == "left":
left_closed = True
elif closed == "right":
right_closed = True
else:
raise ValueError("Closed has to be either 'left', 'right' or None")
return left_closed, right_closed | [
"Check",
"that",
"the",
"closed",
"argument",
"is",
"among",
"[",
"None",
"left",
"right",
"]"
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/arrays/datetimelike.py#L1468-L1498 | [
"def",
"validate_endpoints",
"(",
"closed",
")",
":",
"left_closed",
"=",
"False",
"right_closed",
"=",
"False",
"if",
"closed",
"is",
"None",
":",
"left_closed",
"=",
"True",
"right_closed",
"=",
"True",
"elif",
"closed",
"==",
"\"left\"",
":",
"left_closed",
"=",
"True",
"elif",
"closed",
"==",
"\"right\"",
":",
"right_closed",
"=",
"True",
"else",
":",
"raise",
"ValueError",
"(",
"\"Closed has to be either 'left', 'right' or None\"",
")",
"return",
"left_closed",
",",
"right_closed"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | validate_inferred_freq | If the user passes a freq and another freq is inferred from passed data,
require that they match.
Parameters
----------
freq : DateOffset or None
inferred_freq : DateOffset or None
freq_infer : bool
Returns
-------
freq : DateOffset or None
freq_infer : bool
Notes
-----
We assume at this point that `maybe_infer_freq` has been called, so
`freq` is either a DateOffset object or None. | pandas/core/arrays/datetimelike.py | def validate_inferred_freq(freq, inferred_freq, freq_infer):
"""
If the user passes a freq and another freq is inferred from passed data,
require that they match.
Parameters
----------
freq : DateOffset or None
inferred_freq : DateOffset or None
freq_infer : bool
Returns
-------
freq : DateOffset or None
freq_infer : bool
Notes
-----
We assume at this point that `maybe_infer_freq` has been called, so
`freq` is either a DateOffset object or None.
"""
if inferred_freq is not None:
if freq is not None and freq != inferred_freq:
raise ValueError('Inferred frequency {inferred} from passed '
'values does not conform to passed frequency '
'{passed}'
.format(inferred=inferred_freq,
passed=freq.freqstr))
elif freq is None:
freq = inferred_freq
freq_infer = False
return freq, freq_infer | def validate_inferred_freq(freq, inferred_freq, freq_infer):
"""
If the user passes a freq and another freq is inferred from passed data,
require that they match.
Parameters
----------
freq : DateOffset or None
inferred_freq : DateOffset or None
freq_infer : bool
Returns
-------
freq : DateOffset or None
freq_infer : bool
Notes
-----
We assume at this point that `maybe_infer_freq` has been called, so
`freq` is either a DateOffset object or None.
"""
if inferred_freq is not None:
if freq is not None and freq != inferred_freq:
raise ValueError('Inferred frequency {inferred} from passed '
'values does not conform to passed frequency '
'{passed}'
.format(inferred=inferred_freq,
passed=freq.freqstr))
elif freq is None:
freq = inferred_freq
freq_infer = False
return freq, freq_infer | [
"If",
"the",
"user",
"passes",
"a",
"freq",
"and",
"another",
"freq",
"is",
"inferred",
"from",
"passed",
"data",
"require",
"that",
"they",
"match",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/arrays/datetimelike.py#L1501-L1533 | [
"def",
"validate_inferred_freq",
"(",
"freq",
",",
"inferred_freq",
",",
"freq_infer",
")",
":",
"if",
"inferred_freq",
"is",
"not",
"None",
":",
"if",
"freq",
"is",
"not",
"None",
"and",
"freq",
"!=",
"inferred_freq",
":",
"raise",
"ValueError",
"(",
"'Inferred frequency {inferred} from passed '",
"'values does not conform to passed frequency '",
"'{passed}'",
".",
"format",
"(",
"inferred",
"=",
"inferred_freq",
",",
"passed",
"=",
"freq",
".",
"freqstr",
")",
")",
"elif",
"freq",
"is",
"None",
":",
"freq",
"=",
"inferred_freq",
"freq_infer",
"=",
"False",
"return",
"freq",
",",
"freq_infer"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | maybe_infer_freq | Comparing a DateOffset to the string "infer" raises, so we need to
be careful about comparisons. Make a dummy variable `freq_infer` to
signify the case where the given freq is "infer" and set freq to None
to avoid comparison trouble later on.
Parameters
----------
freq : {DateOffset, None, str}
Returns
-------
freq : {DateOffset, None}
freq_infer : bool | pandas/core/arrays/datetimelike.py | def maybe_infer_freq(freq):
"""
Comparing a DateOffset to the string "infer" raises, so we need to
be careful about comparisons. Make a dummy variable `freq_infer` to
signify the case where the given freq is "infer" and set freq to None
to avoid comparison trouble later on.
Parameters
----------
freq : {DateOffset, None, str}
Returns
-------
freq : {DateOffset, None}
freq_infer : bool
"""
freq_infer = False
if not isinstance(freq, DateOffset):
# if a passed freq is None, don't infer automatically
if freq != 'infer':
freq = frequencies.to_offset(freq)
else:
freq_infer = True
freq = None
return freq, freq_infer | def maybe_infer_freq(freq):
"""
Comparing a DateOffset to the string "infer" raises, so we need to
be careful about comparisons. Make a dummy variable `freq_infer` to
signify the case where the given freq is "infer" and set freq to None
to avoid comparison trouble later on.
Parameters
----------
freq : {DateOffset, None, str}
Returns
-------
freq : {DateOffset, None}
freq_infer : bool
"""
freq_infer = False
if not isinstance(freq, DateOffset):
# if a passed freq is None, don't infer automatically
if freq != 'infer':
freq = frequencies.to_offset(freq)
else:
freq_infer = True
freq = None
return freq, freq_infer | [
"Comparing",
"a",
"DateOffset",
"to",
"the",
"string",
"infer",
"raises",
"so",
"we",
"need",
"to",
"be",
"careful",
"about",
"comparisons",
".",
"Make",
"a",
"dummy",
"variable",
"freq_infer",
"to",
"signify",
"the",
"case",
"where",
"the",
"given",
"freq",
"is",
"infer",
"and",
"set",
"freq",
"to",
"None",
"to",
"avoid",
"comparison",
"trouble",
"later",
"on",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/arrays/datetimelike.py#L1536-L1560 | [
"def",
"maybe_infer_freq",
"(",
"freq",
")",
":",
"freq_infer",
"=",
"False",
"if",
"not",
"isinstance",
"(",
"freq",
",",
"DateOffset",
")",
":",
"# if a passed freq is None, don't infer automatically",
"if",
"freq",
"!=",
"'infer'",
":",
"freq",
"=",
"frequencies",
".",
"to_offset",
"(",
"freq",
")",
"else",
":",
"freq_infer",
"=",
"True",
"freq",
"=",
"None",
"return",
"freq",
",",
"freq_infer"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | _ensure_datetimelike_to_i8 | Helper for coercing an input scalar or array to i8.
Parameters
----------
other : 1d array
to_utc : bool, default False
If True, convert the values to UTC before extracting the i8 values
If False, extract the i8 values directly.
Returns
-------
i8 1d array | pandas/core/arrays/datetimelike.py | def _ensure_datetimelike_to_i8(other, to_utc=False):
"""
Helper for coercing an input scalar or array to i8.
Parameters
----------
other : 1d array
to_utc : bool, default False
If True, convert the values to UTC before extracting the i8 values
If False, extract the i8 values directly.
Returns
-------
i8 1d array
"""
from pandas import Index
from pandas.core.arrays import PeriodArray
if lib.is_scalar(other) and isna(other):
return iNaT
elif isinstance(other, (PeriodArray, ABCIndexClass,
DatetimeLikeArrayMixin)):
# convert tz if needed
if getattr(other, 'tz', None) is not None:
if to_utc:
other = other.tz_convert('UTC')
else:
other = other.tz_localize(None)
else:
try:
return np.array(other, copy=False).view('i8')
except TypeError:
# period array cannot be coerced to int
other = Index(other)
return other.asi8 | def _ensure_datetimelike_to_i8(other, to_utc=False):
"""
Helper for coercing an input scalar or array to i8.
Parameters
----------
other : 1d array
to_utc : bool, default False
If True, convert the values to UTC before extracting the i8 values
If False, extract the i8 values directly.
Returns
-------
i8 1d array
"""
from pandas import Index
from pandas.core.arrays import PeriodArray
if lib.is_scalar(other) and isna(other):
return iNaT
elif isinstance(other, (PeriodArray, ABCIndexClass,
DatetimeLikeArrayMixin)):
# convert tz if needed
if getattr(other, 'tz', None) is not None:
if to_utc:
other = other.tz_convert('UTC')
else:
other = other.tz_localize(None)
else:
try:
return np.array(other, copy=False).view('i8')
except TypeError:
# period array cannot be coerced to int
other = Index(other)
return other.asi8 | [
"Helper",
"for",
"coercing",
"an",
"input",
"scalar",
"or",
"array",
"to",
"i8",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/arrays/datetimelike.py#L1563-L1597 | [
"def",
"_ensure_datetimelike_to_i8",
"(",
"other",
",",
"to_utc",
"=",
"False",
")",
":",
"from",
"pandas",
"import",
"Index",
"from",
"pandas",
".",
"core",
".",
"arrays",
"import",
"PeriodArray",
"if",
"lib",
".",
"is_scalar",
"(",
"other",
")",
"and",
"isna",
"(",
"other",
")",
":",
"return",
"iNaT",
"elif",
"isinstance",
"(",
"other",
",",
"(",
"PeriodArray",
",",
"ABCIndexClass",
",",
"DatetimeLikeArrayMixin",
")",
")",
":",
"# convert tz if needed",
"if",
"getattr",
"(",
"other",
",",
"'tz'",
",",
"None",
")",
"is",
"not",
"None",
":",
"if",
"to_utc",
":",
"other",
"=",
"other",
".",
"tz_convert",
"(",
"'UTC'",
")",
"else",
":",
"other",
"=",
"other",
".",
"tz_localize",
"(",
"None",
")",
"else",
":",
"try",
":",
"return",
"np",
".",
"array",
"(",
"other",
",",
"copy",
"=",
"False",
")",
".",
"view",
"(",
"'i8'",
")",
"except",
"TypeError",
":",
"# period array cannot be coerced to int",
"other",
"=",
"Index",
"(",
"other",
")",
"return",
"other",
".",
"asi8"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | AttributesMixin._scalar_from_string | Construct a scalar type from a string.
Parameters
----------
value : str
Returns
-------
Period, Timestamp, or Timedelta, or NaT
Whatever the type of ``self._scalar_type`` is.
Notes
-----
This should call ``self._check_compatible_with`` before
unboxing the result. | pandas/core/arrays/datetimelike.py | def _scalar_from_string(
self,
value: str,
) -> Union[Period, Timestamp, Timedelta, NaTType]:
"""
Construct a scalar type from a string.
Parameters
----------
value : str
Returns
-------
Period, Timestamp, or Timedelta, or NaT
Whatever the type of ``self._scalar_type`` is.
Notes
-----
This should call ``self._check_compatible_with`` before
unboxing the result.
"""
raise AbstractMethodError(self) | def _scalar_from_string(
self,
value: str,
) -> Union[Period, Timestamp, Timedelta, NaTType]:
"""
Construct a scalar type from a string.
Parameters
----------
value : str
Returns
-------
Period, Timestamp, or Timedelta, or NaT
Whatever the type of ``self._scalar_type`` is.
Notes
-----
This should call ``self._check_compatible_with`` before
unboxing the result.
"""
raise AbstractMethodError(self) | [
"Construct",
"a",
"scalar",
"type",
"from",
"a",
"string",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/arrays/datetimelike.py#L68-L89 | [
"def",
"_scalar_from_string",
"(",
"self",
",",
"value",
":",
"str",
",",
")",
"->",
"Union",
"[",
"Period",
",",
"Timestamp",
",",
"Timedelta",
",",
"NaTType",
"]",
":",
"raise",
"AbstractMethodError",
"(",
"self",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | AttributesMixin._unbox_scalar | Unbox the integer value of a scalar `value`.
Parameters
----------
value : Union[Period, Timestamp, Timedelta]
Returns
-------
int
Examples
--------
>>> self._unbox_scalar(Timedelta('10s')) # DOCTEST: +SKIP
10000000000 | pandas/core/arrays/datetimelike.py | def _unbox_scalar(
self,
value: Union[Period, Timestamp, Timedelta, NaTType],
) -> int:
"""
Unbox the integer value of a scalar `value`.
Parameters
----------
value : Union[Period, Timestamp, Timedelta]
Returns
-------
int
Examples
--------
>>> self._unbox_scalar(Timedelta('10s')) # DOCTEST: +SKIP
10000000000
"""
raise AbstractMethodError(self) | def _unbox_scalar(
self,
value: Union[Period, Timestamp, Timedelta, NaTType],
) -> int:
"""
Unbox the integer value of a scalar `value`.
Parameters
----------
value : Union[Period, Timestamp, Timedelta]
Returns
-------
int
Examples
--------
>>> self._unbox_scalar(Timedelta('10s')) # DOCTEST: +SKIP
10000000000
"""
raise AbstractMethodError(self) | [
"Unbox",
"the",
"integer",
"value",
"of",
"a",
"scalar",
"value",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/arrays/datetimelike.py#L91-L111 | [
"def",
"_unbox_scalar",
"(",
"self",
",",
"value",
":",
"Union",
"[",
"Period",
",",
"Timestamp",
",",
"Timedelta",
",",
"NaTType",
"]",
",",
")",
"->",
"int",
":",
"raise",
"AbstractMethodError",
"(",
"self",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | AttributesMixin._check_compatible_with | Verify that `self` and `other` are compatible.
* DatetimeArray verifies that the timezones (if any) match
* PeriodArray verifies that the freq matches
* Timedelta has no verification
In each case, NaT is considered compatible.
Parameters
----------
other
Raises
------
Exception | pandas/core/arrays/datetimelike.py | def _check_compatible_with(
self,
other: Union[Period, Timestamp, Timedelta, NaTType],
) -> None:
"""
Verify that `self` and `other` are compatible.
* DatetimeArray verifies that the timezones (if any) match
* PeriodArray verifies that the freq matches
* Timedelta has no verification
In each case, NaT is considered compatible.
Parameters
----------
other
Raises
------
Exception
"""
raise AbstractMethodError(self) | def _check_compatible_with(
self,
other: Union[Period, Timestamp, Timedelta, NaTType],
) -> None:
"""
Verify that `self` and `other` are compatible.
* DatetimeArray verifies that the timezones (if any) match
* PeriodArray verifies that the freq matches
* Timedelta has no verification
In each case, NaT is considered compatible.
Parameters
----------
other
Raises
------
Exception
"""
raise AbstractMethodError(self) | [
"Verify",
"that",
"self",
"and",
"other",
"are",
"compatible",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/arrays/datetimelike.py#L113-L134 | [
"def",
"_check_compatible_with",
"(",
"self",
",",
"other",
":",
"Union",
"[",
"Period",
",",
"Timestamp",
",",
"Timedelta",
",",
"NaTType",
"]",
",",
")",
"->",
"None",
":",
"raise",
"AbstractMethodError",
"(",
"self",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | DatelikeOps.strftime | Convert to Index using specified date_format.
Return an Index of formatted strings specified by date_format, which
supports the same string format as the python standard library. Details
of the string format can be found in `python string format
doc <%(URL)s>`__.
Parameters
----------
date_format : str
Date format string (e.g. "%%Y-%%m-%%d").
Returns
-------
Index
Index of formatted strings.
See Also
--------
to_datetime : Convert the given argument to datetime.
DatetimeIndex.normalize : Return DatetimeIndex with times to midnight.
DatetimeIndex.round : Round the DatetimeIndex to the specified freq.
DatetimeIndex.floor : Floor the DatetimeIndex to the specified freq.
Examples
--------
>>> rng = pd.date_range(pd.Timestamp("2018-03-10 09:00"),
... periods=3, freq='s')
>>> rng.strftime('%%B %%d, %%Y, %%r')
Index(['March 10, 2018, 09:00:00 AM', 'March 10, 2018, 09:00:01 AM',
'March 10, 2018, 09:00:02 AM'],
dtype='object') | pandas/core/arrays/datetimelike.py | def strftime(self, date_format):
"""
Convert to Index using specified date_format.
Return an Index of formatted strings specified by date_format, which
supports the same string format as the python standard library. Details
of the string format can be found in `python string format
doc <%(URL)s>`__.
Parameters
----------
date_format : str
Date format string (e.g. "%%Y-%%m-%%d").
Returns
-------
Index
Index of formatted strings.
See Also
--------
to_datetime : Convert the given argument to datetime.
DatetimeIndex.normalize : Return DatetimeIndex with times to midnight.
DatetimeIndex.round : Round the DatetimeIndex to the specified freq.
DatetimeIndex.floor : Floor the DatetimeIndex to the specified freq.
Examples
--------
>>> rng = pd.date_range(pd.Timestamp("2018-03-10 09:00"),
... periods=3, freq='s')
>>> rng.strftime('%%B %%d, %%Y, %%r')
Index(['March 10, 2018, 09:00:00 AM', 'March 10, 2018, 09:00:01 AM',
'March 10, 2018, 09:00:02 AM'],
dtype='object')
"""
from pandas import Index
return Index(self._format_native_types(date_format=date_format)) | def strftime(self, date_format):
"""
Convert to Index using specified date_format.
Return an Index of formatted strings specified by date_format, which
supports the same string format as the python standard library. Details
of the string format can be found in `python string format
doc <%(URL)s>`__.
Parameters
----------
date_format : str
Date format string (e.g. "%%Y-%%m-%%d").
Returns
-------
Index
Index of formatted strings.
See Also
--------
to_datetime : Convert the given argument to datetime.
DatetimeIndex.normalize : Return DatetimeIndex with times to midnight.
DatetimeIndex.round : Round the DatetimeIndex to the specified freq.
DatetimeIndex.floor : Floor the DatetimeIndex to the specified freq.
Examples
--------
>>> rng = pd.date_range(pd.Timestamp("2018-03-10 09:00"),
... periods=3, freq='s')
>>> rng.strftime('%%B %%d, %%Y, %%r')
Index(['March 10, 2018, 09:00:00 AM', 'March 10, 2018, 09:00:01 AM',
'March 10, 2018, 09:00:02 AM'],
dtype='object')
"""
from pandas import Index
return Index(self._format_native_types(date_format=date_format)) | [
"Convert",
"to",
"Index",
"using",
"specified",
"date_format",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/arrays/datetimelike.py#L144-L180 | [
"def",
"strftime",
"(",
"self",
",",
"date_format",
")",
":",
"from",
"pandas",
"import",
"Index",
"return",
"Index",
"(",
"self",
".",
"_format_native_types",
"(",
"date_format",
"=",
"date_format",
")",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
train | DatetimeLikeArrayMixin.searchsorted | Find indices where elements should be inserted to maintain order.
Find the indices into a sorted array `self` such that, if the
corresponding elements in `value` were inserted before the indices,
the order of `self` would be preserved.
Parameters
----------
value : array_like
Values to insert into `self`.
side : {'left', 'right'}, optional
If 'left', the index of the first suitable location found is given.
If 'right', return the last such index. If there is no suitable
index, return either 0 or N (where N is the length of `self`).
sorter : 1-D array_like, optional
Optional array of integer indices that sort `self` into ascending
order. They are typically the result of ``np.argsort``.
Returns
-------
indices : array of ints
Array of insertion points with the same shape as `value`. | pandas/core/arrays/datetimelike.py | def searchsorted(self, value, side='left', sorter=None):
"""
Find indices where elements should be inserted to maintain order.
Find the indices into a sorted array `self` such that, if the
corresponding elements in `value` were inserted before the indices,
the order of `self` would be preserved.
Parameters
----------
value : array_like
Values to insert into `self`.
side : {'left', 'right'}, optional
If 'left', the index of the first suitable location found is given.
If 'right', return the last such index. If there is no suitable
index, return either 0 or N (where N is the length of `self`).
sorter : 1-D array_like, optional
Optional array of integer indices that sort `self` into ascending
order. They are typically the result of ``np.argsort``.
Returns
-------
indices : array of ints
Array of insertion points with the same shape as `value`.
"""
if isinstance(value, str):
value = self._scalar_from_string(value)
if not (isinstance(value, (self._scalar_type, type(self)))
or isna(value)):
raise ValueError("Unexpected type for 'value': {valtype}"
.format(valtype=type(value)))
self._check_compatible_with(value)
if isinstance(value, type(self)):
value = value.asi8
else:
value = self._unbox_scalar(value)
return self.asi8.searchsorted(value, side=side, sorter=sorter) | def searchsorted(self, value, side='left', sorter=None):
"""
Find indices where elements should be inserted to maintain order.
Find the indices into a sorted array `self` such that, if the
corresponding elements in `value` were inserted before the indices,
the order of `self` would be preserved.
Parameters
----------
value : array_like
Values to insert into `self`.
side : {'left', 'right'}, optional
If 'left', the index of the first suitable location found is given.
If 'right', return the last such index. If there is no suitable
index, return either 0 or N (where N is the length of `self`).
sorter : 1-D array_like, optional
Optional array of integer indices that sort `self` into ascending
order. They are typically the result of ``np.argsort``.
Returns
-------
indices : array of ints
Array of insertion points with the same shape as `value`.
"""
if isinstance(value, str):
value = self._scalar_from_string(value)
if not (isinstance(value, (self._scalar_type, type(self)))
or isna(value)):
raise ValueError("Unexpected type for 'value': {valtype}"
.format(valtype=type(value)))
self._check_compatible_with(value)
if isinstance(value, type(self)):
value = value.asi8
else:
value = self._unbox_scalar(value)
return self.asi8.searchsorted(value, side=side, sorter=sorter) | [
"Find",
"indices",
"where",
"elements",
"should",
"be",
"inserted",
"to",
"maintain",
"order",
"."
] | pandas-dev/pandas | python | https://github.com/pandas-dev/pandas/blob/9feb3ad92cc0397a04b665803a49299ee7aa1037/pandas/core/arrays/datetimelike.py#L627-L666 | [
"def",
"searchsorted",
"(",
"self",
",",
"value",
",",
"side",
"=",
"'left'",
",",
"sorter",
"=",
"None",
")",
":",
"if",
"isinstance",
"(",
"value",
",",
"str",
")",
":",
"value",
"=",
"self",
".",
"_scalar_from_string",
"(",
"value",
")",
"if",
"not",
"(",
"isinstance",
"(",
"value",
",",
"(",
"self",
".",
"_scalar_type",
",",
"type",
"(",
"self",
")",
")",
")",
"or",
"isna",
"(",
"value",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"Unexpected type for 'value': {valtype}\"",
".",
"format",
"(",
"valtype",
"=",
"type",
"(",
"value",
")",
")",
")",
"self",
".",
"_check_compatible_with",
"(",
"value",
")",
"if",
"isinstance",
"(",
"value",
",",
"type",
"(",
"self",
")",
")",
":",
"value",
"=",
"value",
".",
"asi8",
"else",
":",
"value",
"=",
"self",
".",
"_unbox_scalar",
"(",
"value",
")",
"return",
"self",
".",
"asi8",
".",
"searchsorted",
"(",
"value",
",",
"side",
"=",
"side",
",",
"sorter",
"=",
"sorter",
")"
] | 9feb3ad92cc0397a04b665803a49299ee7aa1037 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.