def get_relations(cls) -> Sequence[TypeRelation]:
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(cls, String),
InferenceRelation(cls, Object),
]
return relations
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import Generic, String, Integer, Object
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(
cls,
String,
relationship=lambda s: coercion_map_test(cls.string_coercions)
(s.str.lower()),
transformer=lambda s: to_bool(
coercion_map(cls.string_coercions)(s.str.lower())),
),
InferenceRelation(
cls,
Integer,
relationship=lambda s: s.isin({0, 1, np.nan}).all(),
transformer=to_bool,
),
InferenceRelation(
cls,
Object,
relationship=lambda s: s.apply(type).isin([type(None), bool]).all(
),
transformer=to_bool,
),
]
return relations
def _to_datetime(cls, func) -> InferenceRelation:
return InferenceRelation(
relationship=test_utils.coercion_test(func),
transformer=func,
related_type=String,
type=cls,
)
def _to_datetime(cls, func) -> InferenceRelation:
return InferenceRelation(
relationship=test_utils.coercion_test(lambda s: func(s.astype(str))),
transformer=to_datetime,
type=cls,
related_type=Integer,
)
def integer_to_ordinal(cls) -> InferenceRelation:
from visions.types import Integer
return InferenceRelation(cls,
Integer,
relationship=is_ordinal_int,
transformer=to_ordinal)
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import String, Object
relations = [
IdentityRelation(cls, Object),
InferenceRelation(cls, String, relationship=test_uuid, transformer=to_uuid),
]
return relations
def _get_relations(cls) -> List[TypeRelation]:
from visions.types import String, Generic, Float
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(cls,
Float,
relationship=float_is_int,
transformer=to_int),
InferenceRelation(
cls,
String,
relationship=test_utils.coercion_test(to_int),
transformer=to_int,
),
]
return relations
def _get_relations(cls) -> List[TypeRelation]:
from visions.types import Generic, Float
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(cls, Float, relationship=float_is_int, transformer=to_int),
]
return relations
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import Generic, String, Complex
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(cls,
String,
relationship=test_string_is_float,
transformer=to_float),
InferenceRelation(
cls,
Complex,
relationship=lambda s: all(np.imag(s.values) == 0),
transformer=suppress_warnings(to_float),
),
]
return relations
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import Complex, Generic, String
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(cls,
String,
relationship=string_is_float,
transformer=string_to_float),
InferenceRelation(
cls,
Complex,
relationship=complex_is_float,
transformer=complex_to_float,
),
]
return relations
def get_relations(cls) -> Sequence[TypeRelation]:
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(
cls,
Float,
),
]
return relations
def get_relations(cls) -> Sequence[TypeRelation]:
relations = [
IdentityRelation(cls, Object),
InferenceRelation(
cls,
DateTime,
),
]
return relations
def get_relations():
return [
IdentityRelation(Unsupported),
InferenceRelation(
Categorical,
relationship=category_is_numeric,
transformer=category_to_numeric,
),
]
def get_relations():
return [
IdentityRelation(Unsupported),
InferenceRelation(
Numeric,
relationship=numeric_is_category,
transformer=to_category,
),
]
def get_relations() -> Sequence[TypeRelation]:
return [
IdentityRelation(Unsupported),
InferenceRelation(
Numeric,
relationship=lambda x, y: partial(numeric_is_category,
k=config)(x, y),
transformer=to_category,
),
]
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import Generic, Object, String
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(
cls,
String,
relationship=lambda s: coercion_map_test(cls.string_coercions)
(s.str.lower()),
transformer=lambda s: to_bool(
coercion_map(cls.string_coercions)(s.str.lower())),
),
InferenceRelation(cls,
Object,
relationship=object_is_bool,
transformer=to_bool),
]
return relations
def get_relations():
# Numeric [0, 1] goes via Categorical with distinct_count_without_nan <= 2
return [
IdentityRelation(Unsupported),
InferenceRelation(
Categorical,
relationship=string_is_bool,
transformer=lambda s, st: to_bool(string_to_bool(s, st)),
),
]
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import Generic, Object, String
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(
cls,
String,
relationship=partial(string_is_bool,
string_coercions=cls.string_coercions),
transformer=partial(string_to_bool,
string_coercions=cls.string_coercions),
),
InferenceRelation(cls,
Object,
relationship=object_is_bool,
transformer=to_bool),
]
return relations
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import Object, String
relations = [
IdentityRelation(cls, Object),
InferenceRelation(
cls, String, relationship=string_is_geometry, transformer=to_geometry
),
]
return relations
def get_relations() -> Sequence[TypeRelation]:
return [
IdentityRelation(Unsupported),
InferenceRelation(
Categorical,
relationship=lambda x, y: partial(category_is_numeric,
k=config)(x, y),
transformer=category_to_numeric,
),
]
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import Generic, String
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(
cls, String, relationship=test_string_is_complex, transformer=to_complex
),
]
return relations
def get_relations():
if isinstance(identity, Sequence):
relations = [process_relation(item) for item in identity]
else:
relations = [] if identity is None else [
process_relation(identity)
]
if inference is not None:
if isinstance(inference, dict):
relations += [InferenceRelation(**inference)]
elif isinstance(inference, list):
relations += [
InferenceRelation(**params) for params in inference
]
else:
raise TypeError(
"inference should be a list or a dict of params.")
return relations
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import Object, String
relations = [
IdentityRelation(cls, Object),
InferenceRelation(cls,
String,
relationship=test_utils.coercion_test(to_ip),
transformer=to_ip),
]
return relations
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import Generic, String
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(
cls,
String,
relationship=test_utils.coercion_test(to_datetime),
transformer=to_datetime,
),
]
return relations
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import DateTime, Object
relations = [
IdentityRelation(cls, Object),
InferenceRelation(
cls,
DateTime,
relationship=datetime_is_date,
transformer=to_date,
),
]
return relations
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import DateTime, Object
relations = [
IdentityRelation(cls, Object),
InferenceRelation(
cls,
DateTime,
relationship=test_utils.coercion_test(test_date),
transformer=to_date,
),
]
return relations
def get_relations() -> Sequence[TypeRelation]:
# Numeric [0, 1] goes via Categorical with distinct_count_without_nan <= 2
mapping = config.vars.bool.mappings
return [
IdentityRelation(Unsupported),
InferenceRelation(
Categorical,
relationship=lambda x, y: partial(string_is_bool, k=mapping)(x, y),
transformer=lambda s, st: to_bool(
partial(string_to_bool, k=mapping)(s, st)
),
),
]
def get_relations() -> Sequence[TypeRelation]:
relations = [
IdentityRelation(Object),
InferenceRelation(String),
]
return relations
def get_relations() -> Sequence[TypeRelation]:
relations = [
IdentityRelation(Generic),
InferenceRelation(Float),
]
return relations
