def process_relation(
items: Union[dict, Type[VisionsBaseType]]) -> IdentityRelation:
if isinstance(items, dict):
return IdentityRelation(**items)
elif issubclass(items, VisionsBaseType):
return IdentityRelation(related_type=items)
else:
raise TypeError(
"identity should be a list, a dict of params or related_type.")
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 get_relations(cls):
return [
IdentityRelation(cls, Unsupported),
# TODO: optional
# TODO: coerce
# InferenceRelation(cls, Categorical, relationship=is_date, transformer=to_date),
]
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 String, Object
relations = [
IdentityRelation(cls, Object),
InferenceRelation(cls, String, relationship=test_uuid, transformer=to_uuid),
]
return relations
def get_relations():
return [
IdentityRelation(Unsupported),
InferenceRelation(
Numeric,
relationship=numeric_is_category,
transformer=to_category,
),
]
def get_relations():
return [
IdentityRelation(Unsupported),
InferenceRelation(
Categorical,
relationship=category_is_numeric,
transformer=category_to_numeric,
),
]
def get_relations(cls) -> Sequence[TypeRelation]:
relations = [
IdentityRelation(cls, Object),
InferenceRelation(
cls,
DateTime,
),
]
return relations
def get_relations(cls) -> Sequence[TypeRelation]:
relations = [
IdentityRelation(cls, Generic),
InferenceRelation(
cls,
Float,
),
]
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 Object, String
relations = [
IdentityRelation(cls, Object),
InferenceRelation(
cls, String, relationship=string_is_geometry, transformer=to_geometry
),
]
return relations
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() -> 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() -> 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 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 DateTime, Object
relations = [
IdentityRelation(cls, Object),
InferenceRelation(
cls,
DateTime,
relationship=test_utils.coercion_test(test_date),
transformer=to_date,
),
]
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() -> 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(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) -> 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]:
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 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 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(cls) -> Sequence[TypeRelation]:
from visions.types import Generic
relations = [IdentityRelation(cls, Generic)]
return relations
def get_relations() -> Sequence[TypeRelation]:
relations = [IdentityRelation(Integer)]
return relations
def _get_relations(cls) -> Sequence[TypeRelation]:
relations = [IdentityRelation(cls, Generic)]
return relations
def _get_relations(cls) -> Sequence[TypeRelation]:
from visions.types import Path
relations = [IdentityRelation(cls, Path)]
return relations
def get_relations() -> Sequence[TypeRelation]:
relations = [
IdentityRelation(Object),
InferenceRelation(String),
]
return relations
