robotframework-openapitools 1.0.0b3__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

OpenApiLibCore/data_generation/data_generation_core.py

@@ -16,13 +16,20 @@ from OpenApiLibCore.dto_base import (
     Dto,
     PropertyValueConstraint,
     ResourceRelation,
-    resolve_schema,
 )
 from OpenApiLibCore.dto_utils import DefaultDto
+from OpenApiLibCore.models import (
+    ObjectSchema,
+    OpenApiObject,
+    OperationObject,
+    ParameterObject,
+    RequestBodyObject,
+    UnionTypeSchema,
+)
 from OpenApiLibCore.parameter_utils import get_safe_name_for_oas_name
 from OpenApiLibCore.protocols import GetDtoClassType, GetIdPropertyNameType
 from OpenApiLibCore.request_data import RequestData
-from OpenApiLibCore.value_utils import IGNORE, get_valid_value
+from OpenApiLibCore.value_utils import IGNORE
 
 from .body_data_generation import (
     get_json_data_for_dto_class as _get_json_data_for_dto_class,
@@ -34,7 +41,7 @@ def get_request_data(
     method: str,
     get_dto_class: GetDtoClassType,
     get_id_property_name: GetIdPropertyNameType,
-    openapi_spec: dict[str, Any],
+    openapi_spec: OpenApiObject,
 ) -> RequestData:
     method = method.lower()
     dto_cls_name = get_dto_cls_name(path=path, method=method)
@@ -43,21 +50,24 @@ def get_request_data(
     spec_path = pf.get_parametrized_path(path=path, openapi_spec=openapi_spec)
     dto_class = get_dto_class(path=spec_path, method=method)
     try:
-        method_spec = openapi_spec["paths"][spec_path][method]
-    except KeyError:
+        path_item = openapi_spec.paths[spec_path]
+        operation_spec = getattr(path_item, method)
+        if operation_spec is None:
+            raise AttributeError
+    except AttributeError:
         logger.info(
             f"method '{method}' not supported on '{spec_path}, using empty spec."
         )
-        method_spec = {}
+        operation_spec = OperationObject(operationId="")
 
     parameters, params, headers = get_request_parameters(
-        dto_class=dto_class, method_spec=method_spec
+        dto_class=dto_class, method_spec=operation_spec
     )
-    if (body_spec := method_spec.get("requestBody", None)) is None:
+    if operation_spec.requestBody is None:
         dto_instance = _get_dto_instance_for_empty_body(
             dto_class=dto_class,
             dto_cls_name=dto_cls_name,
-            method_spec=method_spec,
+            method_spec=operation_spec,
         )
         return RequestData(
             dto=dto_instance,
@@ -67,25 +77,46 @@ def get_request_data(
             has_body=False,
         )
 
-    headers.update({"content-type": get_content_type(body_spec)})
+    headers.update({"content-type": get_content_type(operation_spec.requestBody)})
+
+    body_schema = operation_spec.requestBody
+    media_type_dict = body_schema.content
+    supported_types = [v for k, v in media_type_dict.items() if "json" in k]
+    supported_schemas = [t.schema_ for t in supported_types if t.schema_ is not None]
+
+    if not supported_schemas:
+        raise ValueError(f"No supported content schema found: {media_type_dict}")
+
+    if len(supported_schemas) > 1:
+        logger.warn(
+            f"Multiple JSON media types defined for requestBody, using the first candidate {media_type_dict}"
+        )
+
+    schema = supported_schemas[0]
+
+    if isinstance(schema, UnionTypeSchema):
+        resolved_schemas = schema.resolved_schemas
+        schema = choice(resolved_schemas)
+
+    if not isinstance(schema, ObjectSchema):
+        raise ValueError(f"Selected schema is not an object schema: {schema}")
 
-    content_schema = resolve_schema(get_content_schema(body_spec))
     dto_data = _get_json_data_for_dto_class(
-        schema=content_schema,
+        schema=schema,
         dto_class=dto_class,
         get_id_property_name=get_id_property_name,
-        operation_id=method_spec.get("operationId", ""),
+        operation_id=operation_spec.operationId,
     )
     dto_instance = _get_dto_instance_from_dto_data(
-        content_schema=content_schema,
+        object_schema=schema,
         dto_class=dto_class,
         dto_data=dto_data,
-        method_spec=method_spec,
+        method_spec=operation_spec,
         dto_cls_name=dto_cls_name,
     )
     return RequestData(
         dto=dto_instance,
-        dto_schema=content_schema,
+        body_schema=schema,
         parameters=parameters,
         params=params,
         headers=headers,
@@ -95,13 +126,14 @@ def get_request_data(
 def _get_dto_instance_for_empty_body(
     dto_class: type[Dto],
     dto_cls_name: str,
-    method_spec: dict[str, Any],
+    method_spec: OperationObject,
 ) -> Dto:
     if dto_class == DefaultDto:
         dto_instance: Dto = DefaultDto()
     else:
+        cls_name = method_spec.operationId if method_spec.operationId else dto_cls_name
         dto_class = make_dataclass(
-            cls_name=method_spec.get("operationId", dto_cls_name),
+            cls_name=cls_name,
             fields=[],
             bases=(dto_class,),
         )
@@ -110,10 +142,10 @@ def _get_dto_instance_for_empty_body(
 
 
 def _get_dto_instance_from_dto_data(
-    content_schema: dict[str, Any],
+    object_schema: ObjectSchema,
     dto_class: type[Dto],
     dto_data: JSON,
-    method_spec: dict[str, Any],
+    method_spec: OperationObject,
     dto_cls_name: str,
 ) -> Dto:
     if not isinstance(dto_data, (dict, list)):
@@ -122,48 +154,41 @@ def _get_dto_instance_from_dto_data(
     if isinstance(dto_data, list):
         raise NotImplementedError
 
-    fields = get_fields_from_dto_data(content_schema, dto_data)
+    fields = get_fields_from_dto_data(object_schema, dto_data)
+    cls_name = method_spec.operationId if method_spec.operationId else dto_cls_name
     dto_class_ = make_dataclass(
-        cls_name=method_spec.get("operationId", dto_cls_name),
+        cls_name=cls_name,
         fields=fields,
         bases=(dto_class,),
     )
-    dto_data = {get_safe_key(key): value for key, value in dto_data.items()}
+    # dto_data = {get_safe_key(key): value for key, value in dto_data.items()}
+    dto_data = {
+        get_safe_name_for_oas_name(key): value for key, value in dto_data.items()
+    }
     return cast(Dto, dto_class_(**dto_data))
 
 
 def get_fields_from_dto_data(
-    content_schema: dict[str, Any], dto_data: dict[str, JSON]
-) -> list[tuple[str, type[Any], Field[Any]]]:
+    object_schema: ObjectSchema, dto_data: dict[str, JSON]
+) -> list[tuple[str, type[object], Field[object]]]:
     """Get a dataclasses fields list based on the content_schema and dto_data."""
-    fields: list[tuple[str, type[Any], Field[Any]]] = []
+    fields: list[tuple[str, type[object], Field[object]]] = []
+
     for key, value in dto_data.items():
-        required_properties = content_schema.get("required", [])
-        safe_key = get_safe_key(key)
-        metadata = {"original_property_name": key}
-        if key in required_properties:
+        # safe_key = get_safe_key(key)
+        safe_key = get_safe_name_for_oas_name(key)
+        # metadata = {"original_property_name": key}
+        if key in object_schema.required:
             # The fields list is used to create a dataclass, so non-default fields
             # must go before fields with a default
-            field_ = cast(Field[Any], field(metadata=metadata))  # pylint: disable=invalid-field-call
+            field_ = cast(Field[Any], field())  # pylint: disable=invalid-field-call
             fields.insert(0, (safe_key, type(value), field_))
         else:
-            field_ = cast(Field[Any], field(default=None, metadata=metadata))  # pylint: disable=invalid-field-call
+            field_ = cast(Field[Any], field(default=None))  # pylint: disable=invalid-field-call
             fields.append((safe_key, type(value), field_))
     return fields
 
 
-def get_safe_key(key: str) -> str:
-    """
-    Helper function to convert a valid JSON property name to a string that can be used
-    as a Python variable or function / method name.
-    """
-    key = key.replace("-", "_")
-    key = key.replace("@", "_")
-    if key[0].isdigit():
-        key = f"_{key}"
-    return key
-
-
 def get_dto_cls_name(path: str, method: str) -> str:
     method = method.capitalize()
     path = path.translate({ord(i): None for i in "{}"})
@@ -173,20 +198,13 @@ def get_dto_cls_name(path: str, method: str) -> str:
     return result
 
 
-def get_content_schema(body_spec: dict[str, Any]) -> dict[str, Any]:
-    """Get the content schema from the requestBody spec."""
-    content_type = get_content_type(body_spec)
-    content_schema = body_spec["content"][content_type]["schema"]
-    return resolve_schema(content_schema)
-
-
-def get_content_type(body_spec: dict[str, Any]) -> str:
+def get_content_type(body_spec: RequestBodyObject) -> str:
     """Get and validate the first supported content type from the requested body spec
 
     Should be application/json like content type,
     e.g "application/json;charset=utf-8" or "application/merge-patch+json"
     """
-    content_types: list[str] = body_spec["content"].keys()
+    content_types: list[str] = list(body_spec.content.keys())
     json_regex = r"application/([a-z\-]+\+)?json(;\s?charset=(.+))?"
     for content_type in content_types:
         if re.search(json_regex, content_type):
@@ -200,30 +218,29 @@ def get_content_type(body_spec: dict[str, Any]) -> str:
 
 
 def get_request_parameters(
-    dto_class: Dto | type[Dto], method_spec: dict[str, Any]
-) -> tuple[list[dict[str, Any]], dict[str, Any], dict[str, str]]:
+    dto_class: Dto | type[Dto], method_spec: OperationObject
+) -> tuple[list[ParameterObject], dict[str, Any], dict[str, str]]:
     """Get the methods parameter spec and params and headers with valid data."""
-    parameters = method_spec.get("parameters", [])
+    parameters = method_spec.parameters if method_spec.parameters else []
     parameter_relations = dto_class.get_parameter_relations()
-    query_params = [p for p in parameters if p.get("in") == "query"]
-    header_params = [p for p in parameters if p.get("in") == "header"]
+    query_params = [p for p in parameters if p.in_ == "query"]
+    header_params = [p for p in parameters if p.in_ == "header"]
     params = get_parameter_data(query_params, parameter_relations)
     headers = get_parameter_data(header_params, parameter_relations)
     return parameters, params, headers
 
 
 def get_parameter_data(
-    parameters: list[dict[str, Any]],
+    parameters: list[ParameterObject],
     parameter_relations: list[ResourceRelation],
 ) -> dict[str, str]:
     """Generate a valid list of key-value pairs for all parameters."""
     result: dict[str, str] = {}
     value: Any = None
     for parameter in parameters:
-        parameter_name = parameter["name"]
+        parameter_name = parameter.name
         # register the oas_name
         _ = get_safe_name_for_oas_name(parameter_name)
-        parameter_schema = resolve_schema(parameter["schema"])
         relations = [
             r for r in parameter_relations if r.property_name == parameter_name
         ]
@@ -235,6 +252,9 @@ def get_parameter_data(
                 continue
             result[parameter_name] = value
             continue
-        value = get_valid_value(parameter_schema)
+
+        if parameter.schema_ is None:
+            continue
+        value = parameter.schema_.get_valid_value()
         result[parameter_name] = value
     return result

OpenApiLibCore/data_invalidation.py

@@ -11,6 +11,7 @@ from requests import Response
 from robot.api import logger
 from robot.libraries.BuiltIn import BuiltIn
 
+from OpenApiLibCore.annotations import JSON
 from OpenApiLibCore.dto_base import (
     NOT_SET,
     Dto,
@@ -18,15 +19,15 @@ from OpenApiLibCore.dto_base import (
     PathPropertiesConstraint,
     PropertyValueConstraint,
     UniquePropertyValueConstraint,
-    resolve_schema,
 )
+from OpenApiLibCore.models import ParameterObject, UnionTypeSchema
 from OpenApiLibCore.request_data import RequestData
-from OpenApiLibCore.value_utils import IGNORE, get_invalid_value, get_valid_value
+from OpenApiLibCore.value_utils import IGNORE, get_invalid_value
 
 run_keyword = BuiltIn().run_keyword
 
 
-def get_invalid_json_data(
+def get_invalid_body_data(
     url: str,
     method: str,
     status_code: int,
@@ -39,12 +40,12 @@ def get_invalid_json_data(
         r for r in data_relations if not isinstance(r, PathPropertiesConstraint)
     ]
     if not data_relations:
-        if not request_data.dto_schema:
+        if request_data.body_schema is None:
             raise ValueError(
-                "Failed to invalidate: no data_relations and empty schema."
+                "Failed to invalidate: request_data does not contain a body_schema."
             )
         json_data = request_data.dto.get_invalidated_data(
-            schema=request_data.dto_schema,
+            schema=request_data.body_schema,
             status_code=status_code,
             invalid_property_default_code=invalid_property_default_response,
         )
@@ -62,8 +63,12 @@ def get_invalid_json_data(
         run_keyword("ensure_in_use", url, resource_relation)
         json_data = request_data.dto.as_dict()
     else:
+        if request_data.body_schema is None:
+            raise ValueError(
+                "Failed to invalidate: request_data does not contain a body_schema."
+            )
         json_data = request_data.dto.get_invalidated_data(
-            schema=request_data.dto_schema,
+            schema=request_data.body_schema,
             status_code=status_code,
             invalid_property_default_code=invalid_property_default_response,
         )
@@ -72,7 +77,7 @@ def get_invalid_json_data(
 
 def get_invalidated_parameters(
     status_code: int, request_data: RequestData, invalid_property_default_response: int
-) -> tuple[dict[str, Any], dict[str, str]]:
+) -> tuple[dict[str, JSON], dict[str, JSON]]:
     if not request_data.parameters:
         raise ValueError("No params or headers to invalidate.")
 
@@ -115,7 +120,7 @@ def get_invalidated_parameters(
 
     # Dto mappings may contain generic mappings for properties that are not present
     # in this specific schema
-    request_data_parameter_names = [p.get("name") for p in request_data.parameters]
+    request_data_parameter_names = [p.name for p in request_data.parameters]
     additional_relation_property_names = {
         n for n in relation_property_names if n not in request_data_parameter_names
     }
@@ -140,7 +145,7 @@ def get_invalidated_parameters(
         [parameter_data] = [
             data
             for data in request_data.parameters
-            if data["name"] == parameter_to_invalidate
+            if data.name == parameter_to_invalidate
         ]
     except Exception:
         raise ValueError(
@@ -186,7 +191,14 @@ def get_invalidated_parameters(
         else:
             valid_value = headers[parameter_to_invalidate]
 
-        value_schema = resolve_schema(parameter_data["schema"])
+        value_schema = parameter_data.schema_
+        if value_schema is None:
+            raise ValueError(f"No schema defined for parameter: {parameter_data}.")
+
+        if isinstance(value_schema, UnionTypeSchema):
+            # FIXME: extra handling may be needed in case of values_from_constraint
+            value_schema = choice(value_schema.resolved_schemas)
+
         invalid_value = get_invalid_value(
             value_schema=value_schema,
             current_value=valid_value,
@@ -204,11 +216,11 @@ def get_invalidated_parameters(
 
 def ensure_parameter_in_parameters(
     parameter_to_invalidate: str,
-    params: dict[str, Any],
-    headers: dict[str, str],
-    parameter_data: dict[str, Any],
-    values_from_constraint: list[Any],
-) -> tuple[dict[str, Any], dict[str, str]]:
+    params: dict[str, JSON],
+    headers: dict[str, JSON],
+    parameter_data: ParameterObject,
+    values_from_constraint: list[JSON],
+) -> tuple[dict[str, JSON], dict[str, JSON]]:
     """
     Returns the params, headers tuple with parameter_to_invalidate with a valid
     value to params or headers if not originally present.
@@ -220,15 +232,20 @@ def ensure_parameter_in_parameters(
         if values_from_constraint:
             valid_value = choice(values_from_constraint)
         else:
-            parameter_schema = resolve_schema(parameter_data["schema"])
-            valid_value = get_valid_value(parameter_schema)
+            value_schema = parameter_data.schema_
+            if value_schema is None:
+                raise ValueError(f"No schema defined for parameter: {parameter_data}.")
+
+            if isinstance(value_schema, UnionTypeSchema):
+                value_schema = choice(value_schema.resolved_schemas)
+            valid_value = value_schema.get_valid_value()
         if (
-            parameter_data["in"] == "query"
+            parameter_data.in_ == "query"
             and parameter_to_invalidate not in params.keys()
         ):
             params[parameter_to_invalidate] = valid_value
         if (
-            parameter_data["in"] == "header"
+            parameter_data.in_ == "header"
             and parameter_to_invalidate not in headers.keys()
         ):
             headers[parameter_to_invalidate] = str(valid_value)

OpenApiLibCore/dto_base.py

@@ -5,7 +5,6 @@ test and constraints / restrictions on properties of the resources.
 """
 
 from abc import ABC
-from copy import deepcopy
 from dataclasses import dataclass, fields
 from random import choice, shuffle
 from typing import Any
@@ -14,77 +13,13 @@ from uuid import uuid4
 from robot.api import logger
 
 from OpenApiLibCore import value_utils
+from OpenApiLibCore.models import NullSchema, ObjectSchema, UnionTypeSchema
+from OpenApiLibCore.parameter_utils import get_oas_name_from_safe_name
 
 NOT_SET = object()
 SENTINEL = object()
 
 
-def resolve_schema(schema: dict[str, Any]) -> dict[str, Any]:
-    """
-    Helper function to resolve allOf, anyOf and oneOf instances in a schema.
-
-    The schemas are used to generate values for headers, query parameters and json
-    bodies to be able to make requests.
-    """
-    # Schema is mutable, so deepcopy to prevent mutation of original schema argument
-    resolved_schema = deepcopy(schema)
-
-    # allOf / anyOf / oneOf may be nested, so recursively resolve the dict-typed values
-    for key, value in resolved_schema.items():
-        if isinstance(value, dict):
-            resolved_schema[key] = resolve_schema(value)
-
-    # When handling allOf there should no duplicate keys, so the schema parts can
-    # just be merged after resolving the individual parts
-    if schema_parts := resolved_schema.pop("allOf", None):
-        for schema_part in schema_parts:
-            resolved_part = resolve_schema(schema_part)
-            resolved_schema = merge_schemas(resolved_schema, resolved_part)
-    # Handling anyOf and oneOf requires extra logic to deal with the "type" information.
-    # Some properties / parameters may be of different types and each type may have its
-    # own restrictions e.g. a parameter that accepts an enum value (string) or an
-    # integer value within a certain range.
-    # Since the library needs all this information for different purposes, the
-    # schema_parts cannot be merged, so a helper property / key "types" is introduced.
-    any_of = resolved_schema.pop("anyOf", [])
-    one_of = resolved_schema.pop("oneOf", [])
-    schema_parts = any_of if any_of else one_of
-
-    for schema_part in schema_parts:
-        resolved_part = resolve_schema(schema_part)
-        if isinstance(resolved_part, dict) and "type" in resolved_part.keys():
-            if "types" in resolved_schema.keys():
-                resolved_schema["types"].append(resolved_part)
-            else:
-                resolved_schema["types"] = [resolved_part]
-        else:
-            resolved_schema = merge_schemas(resolved_schema, resolved_part)
-
-    return resolved_schema
-
-
-def merge_schemas(first: dict[str, Any], second: dict[str, Any]) -> dict[str, Any]:
-    """Helper method to merge two schemas, recursively."""
-    merged_schema = deepcopy(first)
-    for key, value in second.items():
-        # for existing keys, merge dict and list values, leave others unchanged
-        if key in merged_schema.keys():
-            if isinstance(value, dict):
-                # if the key holds a dict, merge the values (e.g. 'properties')
-                merged_schema[key].update(value)
-            elif isinstance(value, list):
-                # if the key holds a list, extend the values (e.g. 'required')
-                merged_schema[key].extend(value)
-            elif value != merged_schema[key]:
-                logger.debug(
-                    f"key '{key}' with value '{merged_schema[key]}'"
-                    f" not updated to '{value}'"
-                )
-        else:
-            merged_schema[key] = value
-    return merged_schema
-
-
 class ResourceRelation(ABC):
     """ABC for all resource relations or restrictions within the API."""
 
@@ -197,14 +132,14 @@ class Dto(ABC):
 
     def get_invalidated_data(
         self,
-        schema: dict[str, Any],
+        schema: ObjectSchema,
         status_code: int,
         invalid_property_default_code: int,
     ) -> dict[str, Any]:
         """Return a data set with one of the properties set to an invalid value or type."""
         properties: dict[str, Any] = self.as_dict()
 
-        schema = resolve_schema(schema)
+        # schema = resolve_schema(schema)
 
         relations = self.get_relations_for_error_code(error_code=status_code)
         # filter PathProperyConstraints since in that case no data can be invalidated
@@ -212,9 +147,9 @@ class Dto(ABC):
             r for r in relations if not isinstance(r, PathPropertiesConstraint)
         ]
         property_names = [r.property_name for r in relations]
-        if status_code == invalid_property_default_code and schema.get("properties"):
+        if status_code == invalid_property_default_code:
             # add all properties defined in the schema, including optional properties
-            property_names.extend((schema["properties"].keys()))
+            property_names.extend((schema.properties.root.keys()))
         if not property_names:
             raise ValueError(
                 f"No property can be invalidated to cause status_code {status_code}"
@@ -256,31 +191,30 @@ class Dto(ABC):
                 )
                 return properties
 
-            value_schema = schema["properties"][property_name]
-            value_schema = resolve_schema(value_schema)
-
-            # Filter "type": "null" from the possible types since this indicates an
-            # optional / nullable property that can only be invalidated by sending
-            # invalid data of a non-null type
-            if value_schemas := value_schema.get("types"):
-                if len(value_schemas) > 1:
-                    value_schemas = [
-                        schema for schema in value_schemas if schema["type"] != "null"
-                    ]
-                value_schema = choice(value_schemas)
+            value_schema = schema.properties.root[property_name]
+            if isinstance(value_schema, UnionTypeSchema):
+                # Filter "type": "null" from the possible types since this indicates an
+                # optional / nullable property that can only be invalidated by sending
+                # invalid data of a non-null type
+                non_null_schemas = [
+                    s
+                    for s in value_schema.resolved_schemas
+                    if not isinstance(s, NullSchema)
+                ]
+                value_schema = choice(non_null_schemas)
 
             # there may not be a current_value when invalidating an optional property
             current_value = properties.get(property_name, SENTINEL)
             if current_value is SENTINEL:
                 # the current_value isn't very relevant as long as the type is correct
                 # so no logic to handle Relations / objects / arrays here
-                property_type = value_schema["type"]
+                property_type = value_schema.type
                 if property_type == "object":
                     current_value = {}
                 elif property_type == "array":
                     current_value = []
                 else:
-                    current_value = value_utils.get_valid_value(value_schema)
+                    current_value = value_schema.get_valid_value()
 
             values_from_constraint = [
                 r.values[0]
@@ -311,7 +245,7 @@ class Dto(ABC):
             field_name = field.name
             if field_name not in self.__dict__:
                 continue
-            original_name = field.metadata["original_property_name"]
+            original_name = get_oas_name_from_safe_name(field_name)
             result[original_name] = getattr(self, field_name)
 
         return result

OpenApiLibCore/localized_faker.py

@@ -0,0 +1,88 @@
+import datetime
+from typing import Callable
+
+import faker
+
+
+def fake_string(string_format: str) -> str:
+    """
+    Generate a random string based on the provided format if the format is supported.
+    """
+    # format names may contain -, which is invalid in Python naming
+    string_format = string_format.replace("-", "_")
+    fake_generator = getattr(FAKE, string_format, FAKE.uuid)
+    value: str = fake_generator()
+    if isinstance(value, datetime.datetime):
+        return value.strftime("%Y-%m-%dT%H:%M:%SZ")
+    return value
+
+
+class LocalizedFaker:
+    """Class to support setting a locale post-init."""
+
+    # pylint: disable=missing-function-docstring
+    def __init__(self) -> None:
+        self.fake = faker.Faker()
+
+    def set_locale(self, locale: str | list[str]) -> None:
+        """Update the fake attribute with a Faker instance with the provided locale."""
+        self.fake = faker.Faker(locale)
+
+    @property
+    def date(self) -> Callable[[], str]:
+        return self.fake.date
+
+    @property
+    def date_time(self) -> Callable[[], datetime.datetime]:
+        return self.fake.date_time
+
+    @property
+    def password(self) -> Callable[[], str]:
+        return self.fake.password
+
+    @property
+    def binary(self) -> Callable[[], bytes]:
+        return self.fake.binary
+
+    @property
+    def email(self) -> Callable[[], str]:
+        return self.fake.safe_email
+
+    @property
+    def uuid(self) -> Callable[[], str]:
+        return self.fake.uuid4
+
+    @property
+    def uri(self) -> Callable[[], str]:
+        return self.fake.uri
+
+    @property
+    def url(self) -> Callable[[], str]:
+        return self.fake.url
+
+    @property
+    def hostname(self) -> Callable[[], str]:
+        return self.fake.hostname
+
+    @property
+    def ipv4(self) -> Callable[[], str]:
+        return self.fake.ipv4
+
+    @property
+    def ipv6(self) -> Callable[[], str]:
+        return self.fake.ipv6
+
+    @property
+    def name(self) -> Callable[[], str]:
+        return self.fake.name
+
+    @property
+    def text(self) -> Callable[[], str]:
+        return self.fake.text
+
+    @property
+    def description(self) -> Callable[[], str]:
+        return self.fake.text
+
+
+FAKE = LocalizedFaker()