clue-api 1.0.0.dev34__tar.gz → 1.0.0.dev45__tar.gz

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clue-api
-Version: 1.0.0.dev34
+Version: 1.0.0.dev45
 Summary: Clue distributed enrichment service
 License: MIT
 License-File: LICENSE

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/app.py

@@ -1,13 +1,14 @@
 import logging
 import os
 import re
-from typing import Any
+from typing import Any, cast
 
 import elasticapm
 from authlib.integrations.flask_client import OAuth
 from elasticapm.contrib.flask import ElasticAPM
 from flasgger import Swagger
 from flask import Flask
+from flask.blueprints import Blueprint
 from flask.logging import default_handler
 from prometheus_client import make_wsgi_app
 from werkzeug.middleware.dispatcher import DispatcherMiddleware
@@ -25,10 +26,11 @@ from clue.common.logging import get_logger
 from clue.config import DEBUG, SECRET_KEY, cache, config
 from clue.cronjobs import setup_jobs as setup_cron_jobs
 from clue.error import errors
+from clue.extensions import get_extensions
 from clue.healthz import healthz
 
-SESSION_COOKIE_SAMESITE = os.environ.get("BRL_SESSION_COOKIE_SAMESITE", None)
-HSTS_MAX_AGE = os.environ.get("BRL_HSTS_MAX_AGE", None)
+SESSION_COOKIE_SAMESITE = os.environ.get("CLUE_SESSION_COOKIE_SAMESITE", None)
+HSTS_MAX_AGE = os.environ.get("CLUE_HSTS_MAX_AGE", None)
 
 logger = get_logger(__file__)
 
@@ -94,6 +96,17 @@ app.register_blueprint(fetchers_api)
 app.register_blueprint(lookup_api)
 app.register_blueprint(registration_api)
 app.register_blueprint(static_api)
+
+
+logger.info("Checking plugins for additional routes")
+for plugin in get_extensions():
+    if not plugin.modules.routes:
+        continue
+
+    for route in cast(list[Blueprint], plugin.modules.routes):
+        logger.info("Enabling additional endpoint: %s", route.url_prefix)
+        app.register_blueprint(route)
+
 # Setup OAuth providers
 if config.auth.oauth.enabled:
     providers = []

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/common/forge.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING
 from flask_caching import Cache
 
 from clue.common.dict_utils import recursive_update
-from clue.common.logging.format import BRL_DATE_FORMAT, BRL_LOG_FORMAT
+from clue.common.logging.format import CLUE_DATE_FORMAT, CLUE_LOG_FORMAT
 from clue.common.str_utils import default_string_value
 
 APP_NAME: str = default_string_value(env_name="APP_NAME", default="clue")  # type: ignore[assignment]
@@ -27,7 +27,7 @@ logger = logging.getLogger(f"{APP_NAME}.common.forge")
 logger.setLevel(logging.INFO)
 console = logging.StreamHandler()
 console.setLevel(logging.INFO)
-console.setFormatter(logging.Formatter(BRL_LOG_FORMAT, BRL_DATE_FORMAT))
+console.setFormatter(logging.Formatter(CLUE_LOG_FORMAT, CLUE_DATE_FORMAT))
 logger.addHandler(console)
 
 

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/common/logging/__init__.py

@@ -10,10 +10,10 @@ from typing import Optional, Self, Union
 from flask import request
 
 from clue.common.logging.format import (
-    BRL_DATE_FORMAT,
-    BRL_JSON_FORMAT,
-    BRL_LOG_FORMAT,
-    BRL_SYSLOG_FORMAT,
+    CLUE_DATE_FORMAT,
+    CLUE_JSON_FORMAT,
+    CLUE_LOG_FORMAT,
+    CLUE_SYSLOG_FORMAT,
 )
 from clue.common.str_utils import default_string_value
 
@@ -50,10 +50,15 @@ class JsonFormatter(logging.Formatter):
             record.exc_info = None
 
         if record.exc_text:
-            record.message += "\n" + record.exc_text
+            record.msg += "\n" + record.exc_text
             record.exc_text = None
 
-        record.message = json.dumps(record.message)
+        record.msg = json.dumps(record.msg)
+
+        record.asctime = self.formatTime(record, self.datefmt)
+
+        record.message = record.msg
+
         return self._style.format(record)
 
     def formatException(self, exc_info):  # noqa: N802
@@ -120,9 +125,9 @@ def init_logging(name: str, log_level: Optional[int] = None):  # noqa: C901
             )
             dbg_file_handler.setLevel(logging.DEBUG)
             if config.logging.log_as_json:
-                dbg_file_handler.setFormatter(JsonFormatter(BRL_JSON_FORMAT))
+                dbg_file_handler.setFormatter(JsonFormatter(CLUE_JSON_FORMAT))
             else:
-                dbg_file_handler.setFormatter(logging.Formatter(BRL_LOG_FORMAT, BRL_DATE_FORMAT))
+                dbg_file_handler.setFormatter(logging.Formatter(CLUE_LOG_FORMAT, CLUE_DATE_FORMAT))
             logger.addHandler(dbg_file_handler)
 
         if log_level <= logging.INFO:
@@ -133,9 +138,9 @@ def init_logging(name: str, log_level: Optional[int] = None):  # noqa: C901
             )
             op_file_handler.setLevel(logging.INFO)
             if config.logging.log_as_json:
-                op_file_handler.setFormatter(JsonFormatter(BRL_JSON_FORMAT))
+                op_file_handler.setFormatter(JsonFormatter(CLUE_JSON_FORMAT))
             else:
-                op_file_handler.setFormatter(logging.Formatter(BRL_LOG_FORMAT, BRL_DATE_FORMAT))
+                op_file_handler.setFormatter(logging.Formatter(CLUE_LOG_FORMAT, CLUE_DATE_FORMAT))
             logger.addHandler(op_file_handler)
 
         if log_level <= logging.ERROR:
@@ -146,24 +151,24 @@ def init_logging(name: str, log_level: Optional[int] = None):  # noqa: C901
             )
             err_file_handler.setLevel(logging.ERROR)
             if config.logging.log_as_json:
-                err_file_handler.setFormatter(JsonFormatter(BRL_JSON_FORMAT))
+                err_file_handler.setFormatter(JsonFormatter(CLUE_JSON_FORMAT))
             else:
-                err_file_handler.setFormatter(logging.Formatter(BRL_LOG_FORMAT, BRL_DATE_FORMAT))
+                err_file_handler.setFormatter(logging.Formatter(CLUE_LOG_FORMAT, CLUE_DATE_FORMAT))
             logger.addHandler(err_file_handler)
 
     if config.logging.log_to_console:
         console = logging.StreamHandler()
         if config.logging.log_as_json:
-            console.setFormatter(JsonFormatter(BRL_JSON_FORMAT))
+            console.setFormatter(JsonFormatter(CLUE_JSON_FORMAT))
         else:
-            console.setFormatter(logging.Formatter(BRL_LOG_FORMAT, BRL_DATE_FORMAT))
+            console.setFormatter(logging.Formatter(CLUE_LOG_FORMAT, CLUE_DATE_FORMAT))
         logger.addHandler(console)
 
     if config.logging.log_to_syslog and config.logging.syslog_host and config.logging.syslog_port:
         syslog_handler = logging.handlers.SysLogHandler(
             address=(config.logging.syslog_host, config.logging.syslog_port)
         )
-        syslog_handler.formatter = logging.Formatter(BRL_SYSLOG_FORMAT)
+        syslog_handler.formatter = logging.Formatter(CLUE_SYSLOG_FORMAT)
         logger.addHandler(syslog_handler)
 
     return logger.getChild(name)

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/common/logging/audit.py

@@ -5,10 +5,10 @@ import sys
 from flask import request
 
 from clue.common.logging.format import (
-    BRL_AUDIT_FORMAT,
-    BRL_DATE_FORMAT,
-    BRL_ISO_DATE_FORMAT,
-    BRL_LOG_FORMAT,
+    CLUE_AUDIT_FORMAT,
+    CLUE_DATE_FORMAT,
+    CLUE_ISO_DATE_FORMAT,
+    CLUE_LOG_FORMAT,
 )
 from clue.config import DEBUG, config
 
@@ -63,12 +63,12 @@ if AUDIT:
 if not os.path.exists(config.logging.log_directory):
     os.makedirs(config.logging.log_directory)
 
-fh = logging.FileHandler(os.path.join(config.logging.log_directory, "brl_audit.log"))
+fh = logging.FileHandler(os.path.join(config.logging.log_directory, "clue_audit.log"))
 fh.setLevel(logging.DEBUG)
 fh.setFormatter(
     logging.Formatter(
-        BRL_LOG_FORMAT if DEBUG else BRL_AUDIT_FORMAT,
-        BRL_DATE_FORMAT if DEBUG else BRL_ISO_DATE_FORMAT,
+        CLUE_LOG_FORMAT if DEBUG else CLUE_AUDIT_FORMAT,
+        CLUE_DATE_FORMAT if DEBUG else CLUE_ISO_DATE_FORMAT,
     )
 )
 AUDIT_LOG.addHandler(fh)
@@ -77,8 +77,8 @@ ch = logging.StreamHandler(sys.stdout)
 ch.setLevel(logging.INFO)
 ch.setFormatter(
     logging.Formatter(
-        BRL_LOG_FORMAT if DEBUG else BRL_AUDIT_FORMAT,
-        BRL_DATE_FORMAT if DEBUG else BRL_ISO_DATE_FORMAT,
+        CLUE_LOG_FORMAT if DEBUG else CLUE_AUDIT_FORMAT,
+        CLUE_DATE_FORMAT if DEBUG else CLUE_ISO_DATE_FORMAT,
     )
 )
 AUDIT_LOG.addHandler(ch)

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/common/logging/format.py

@@ -13,10 +13,10 @@ except Exception:  # noqa: S110
 
 APP_NAME: str = default_string_value(env_name="APP_NAME", default="clue")  # type: ignore[assignment]
 
-BRL_SYSLOG_FORMAT = f"HWL %(levelname)8s {hostname} %(process)5d %(name)40s | %(message)s"
-BRL_LOG_FORMAT = "%(asctime)s %(levelname)s %(name)s | %(message)s"
-BRL_DATE_FORMAT = "%y/%m/%d %H:%M:%S"
-BRL_JSON_FORMAT = (
+CLUE_SYSLOG_FORMAT = f"HWL %(levelname)8s {hostname} %(process)5d %(name)40s | %(message)s"
+CLUE_LOG_FORMAT = "%(asctime)s %(levelname)s %(name)s | %(message)s"
+CLUE_DATE_FORMAT = "%y/%m/%d %H:%M:%S"
+CLUE_JSON_FORMAT = (
     f"{{"
     f'"@timestamp": "%(asctime)s", '
     f'"event": {{ "module": "{APP_NAME}", "dataset": "%(name)s" }}, '
@@ -25,8 +25,8 @@ BRL_JSON_FORMAT = (
     f'"process": {{ "pid": "%(process)d" }}, '
     f'"message": %(message)s}}'
 )
-BRL_ISO_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S%z"
-BRL_AUDIT_FORMAT = json.dumps(
+CLUE_ISO_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S%z"
+CLUE_AUDIT_FORMAT = json.dumps(
     {
         "date": "%(asctime)s",
         "type": "audit",

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/cronjobs/__init__.py

@@ -27,4 +27,5 @@ def setup_jobs():
         except Exception as e:
             logger.critical("Error when initializing %s - %s", module, e)
 
-    scheduler.start()
+    if scheduler.state != 1:
+        scheduler.start()

clue_api-1.0.0.dev45/clue/extensions/__init__.py

@@ -0,0 +1,25 @@
+import importlib
+from typing import Optional
+
+from clue.common.logging import get_logger
+from clue.config import config as _config  # Python gets BIG mad if we don't alias this
+from clue.extensions.config import BaseExtensionConfig
+
+logger = get_logger(__file__)
+
+EXTENSIONS: dict[str, Optional[BaseExtensionConfig]] = {}
+
+
+def get_extensions() -> list[BaseExtensionConfig]:
+    "Get a set of extension configurations based on the clue settings."
+    for extension in _config.core.extensions:
+        if extension in EXTENSIONS:
+            continue
+
+        try:
+            EXTENSIONS[extension] = importlib.import_module(f"{extension}.config").config
+        except (ImportError, ModuleNotFoundError):
+            logger.exception("Exception when loading extension %s", extension)
+            EXTENSIONS[extension] = None
+
+    return [extension for extension in EXTENSIONS.values() if extension]

clue_api-1.0.0.dev45/clue/extensions/config.py

@@ -0,0 +1,74 @@
+import logging
+from typing import Any
+
+from pydantic import BaseModel, ImportString, model_validator
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    YamlConfigSettingsSource,
+)
+
+from clue.common.logging import CLUE_DATE_FORMAT, CLUE_LOG_FORMAT
+
+logger = logging.getLogger("clue.extensions.config")
+logger.setLevel(logging.INFO)
+console = logging.StreamHandler()
+console.setLevel(logging.INFO)
+console.setFormatter(logging.Formatter(CLUE_LOG_FORMAT, CLUE_DATE_FORMAT))
+logger.addHandler(console)
+
+
+class Modules(BaseModel):
+    "A list of components exposed for use in Clue by this plugin."
+
+    routes: list[ImportString] = []
+    obo_module: ImportString | None = None
+
+
+class BaseExtensionConfig(BaseSettings):
+    "Configuration File for Plugin"
+
+    name: str
+    features: dict[str, bool] = {}
+
+    modules: Modules = Modules()
+
+    @model_validator(mode="before")
+    @classmethod
+    def initialize_extension_configuration(cls, data: Any) -> Any:  # noqa: C901
+        "Convert a raw yaml config into an object ready for validation by pydantic"
+        if not isinstance(data, dict):
+            return data
+
+        # Default mutation requires plugin name
+        if "name" not in data:
+            logger.warning("Name is missing from configuration")
+            return data
+
+        plugin_name = data["name"]
+        logger.debug("Beginning configuration parsing for plugin %s", plugin_name)
+
+        if "modules" not in data:
+            return data
+
+        if "routes" in data["modules"] and isinstance(data["modules"]["routes"], list):
+            new_routes: list[str] = []
+            for route in data["modules"]["routes"]:
+                new_routes.append(f"{plugin_name}.routes.{route}" if "." not in route else route)
+
+            data["modules"]["routes"] = new_routes
+
+        if "obo_module" in data["modules"]:
+            if isinstance(data["modules"]["obo_module"], bool):
+                data["modules"]["obo_module"] = f"{plugin_name}.obo:get_obo_token"
+
+        return data
+
+    @classmethod
+    def settings_customise_sources(
+        cls,  # noqa: ANN102
+        *args,  # noqa: ANN002
+        **kwargs,  # noqa: ANN002, ANN102
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        "Adds a YamlConfigSettingsSource object at the end of the settings_customize_sources response."
+        return (*super().settings_customise_sources(*args, **kwargs), YamlConfigSettingsSource(cls))

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/models/config.py

@@ -4,6 +4,7 @@ import os
 from email.utils import parseaddr
 from enum import Enum
 from pathlib import Path
+from typing import Self
 from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
@@ -14,11 +15,10 @@ from pydantic_settings import (
     SettingsConfigDict,
     YamlConfigSettingsSource,
 )
-from typing_extensions import Self
 
 from clue.common import forge
 from clue.common.exceptions import ClueValueError
-from clue.common.logging.format import BRL_DATE_FORMAT, BRL_LOG_FORMAT
+from clue.common.logging.format import CLUE_DATE_FORMAT, CLUE_LOG_FORMAT
 from clue.common.str_utils import default_string_value
 
 AUTO_PROPERTY_TYPE = ["access", "classification", "type", "role", "remove_role", "group"]
@@ -216,8 +216,13 @@ class Metrics(BaseModel):
 
 
 class Core(BaseModel):
+    extensions: set[str] = Field(description="A list of extensions to load", default=set())
+
     metrics: Metrics = Metrics()
+    "Configuration for Metrics Collection"
+
     redis: RedisServer = RedisServer()
+    "Configuration for Redis instances"
 
 
 class LogLevel(str, Enum):
@@ -394,7 +399,7 @@ if os.getenv("AZURE_TEST_CONFIG", None) is not None:
     logger.setLevel(logging.INFO)
     console = logging.StreamHandler()
     console.setLevel(logging.INFO)
-    console.setFormatter(logging.Formatter(BRL_LOG_FORMAT, BRL_DATE_FORMAT))
+    console.setFormatter(logging.Formatter(CLUE_LOG_FORMAT, CLUE_DATE_FORMAT))
     logger.addHandler(console)
 
     logger.info("Azure build environment detected, adding additional config path")

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/plugin/__init__.py

@@ -22,7 +22,7 @@ from clue.common.exceptions import (
     TimeoutException,
     UnprocessableException,
 )
-from clue.common.logging.format import BRL_DATE_FORMAT, BRL_LOG_FORMAT
+from clue.common.logging.format import CLUE_DATE_FORMAT, CLUE_LOG_FORMAT
 from clue.models.actions import (
     Action,
     ActionBase,
@@ -66,7 +66,7 @@ def build_default_logger() -> logging.Logger:
     logger.setLevel(logging.INFO)
     console = logging.StreamHandler()
     console.setLevel(logging.INFO)
-    console.setFormatter(logging.Formatter(BRL_LOG_FORMAT, BRL_DATE_FORMAT))
+    console.setFormatter(logging.Formatter(CLUE_LOG_FORMAT, CLUE_DATE_FORMAT))
     logger.addHandler(console)
 
     return logger

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/remote/datatypes/cache.py

@@ -9,7 +9,7 @@ DEFAULT_TTL = 60 * 60  # 1 Hour
 
 
 class RedisCache(object):
-    def __init__(self, prefix="brl_cache", host=None, port=None, ttl=DEFAULT_TTL):
+    def __init__(self, prefix="clue_cache", host=None, port=None, ttl=DEFAULT_TTL):
         self.c = get_client(host, port, False)
         self.prefix = prefix
         self.ttl = ttl

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/security/obo.py

@@ -4,6 +4,7 @@ from typing import Optional
 from clue.common.exceptions import InvalidDataException
 from clue.common.logging import get_logger
 from clue.config import config, get_redis
+from clue.extensions import get_extensions
 from clue.remote.datatypes.set import ExpiringSet
 from clue.security.utils import decode_jwt_payload
 
@@ -31,7 +32,34 @@ def _get_token_raw(service: str, user: str) -> Optional[str]:
     return None
 
 
-def get_obo_token(service: str, access_token: str, user: str, force_refresh: bool = False):
+def try_validate_expiry(obo_access_token: str):
+    """Validates the expiry of an OBO (On-Behalf-Of) access token.
+
+    Attempts to decode the JWT payload of the provided token and checks the 'exp' (expiry) field.
+    If the token has expired, logs a warning and returns None.
+    If the token is not a JWT or the 'exp' field is missing, logs a warning and skips expiry validation.
+
+    Args:
+        obo_access_token (str): The OBO access token to validate.
+
+    Returns:
+        str or None: The original token if valid or expiry cannot be determined, otherwise None if expired.
+    """
+    try:
+        expiry = datetime.fromtimestamp(decode_jwt_payload(obo_access_token)["exp"])
+
+        if expiry < datetime.now():
+            logger.warning("Cached token has expired")
+            return None
+    except IndexError:
+        logger.warning("Token is not a JWT, skipping expiry validation")
+    except KeyError:
+        logger.warning("'exp' field is missing, skipping expiry validation")
+
+    return obo_access_token
+
+
+def get_obo_token(service: str, access_token: str, user: str, force_refresh: bool = False):  # noqa: C901
     """Gets an On-Behalf-Of token from either the Redis cache or from the provided authentication plugin.
 
     Args:
@@ -60,17 +88,22 @@ def get_obo_token(service: str, access_token: str, user: str, force_refresh: boo
             obo_access_token = _get_token_raw(service, user)
 
         if obo_access_token is not None:
-            expiry = datetime.fromtimestamp(decode_jwt_payload(obo_access_token)["exp"])
-
-            if expiry < datetime.now():
-                logger.warning("Cached token has expired")
-                obo_access_token = None
+            obo_access_token = try_validate_expiry(obo_access_token)
 
         if obo_access_token is None:
             logger.info(f"Fetching OBO token for user {user} to service {service}")
 
-            # TODO: figure out plugin-based OBO system
-            obo_access_token = None
+            extension_get_obo_token = None
+            for extension in get_extensions():
+                if extension.modules.obo_module:
+                    extension_get_obo_token = extension.modules.obo_module
+                    break
+
+            if extension_get_obo_token is None:
+                logger.info("No OBO function provided, returning provided access token")
+                return access_token
+
+            obo_access_token = extension_get_obo_token(service, access_token, user)
 
             if obo_access_token:
                 service_token_store = _get_obo_token_store(service, user)

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/clue/services/type_service.py

@@ -17,7 +17,7 @@ logger = get_logger(__file__)
 
 # Either cache for one second in debug mode, or five minutes in production
 CACHE_TIMEOUT: int = 1 if DEBUG else 5 * 60
-CACHE = RedisCache(prefix="brl_types", ttl=CACHE_TIMEOUT)
+CACHE = RedisCache(prefix="clue_types", ttl=CACHE_TIMEOUT)
 
 
 def get_types_regular_expressions(user: dict[str, Any]):

{clue_api-1.0.0.dev34 → clue_api-1.0.0.dev45}/pyproject.toml

@@ -156,7 +156,7 @@ suppress-none-returning = true
 ###################
 [tool.pytest.ini_options]
 log_cli = true
-log_cli_level = "INFO"
+log_cli_level = "WARN"
 
 ###################
 # Poetry settings #
@@ -164,7 +164,7 @@ log_cli_level = "INFO"
 [tool.poetry]
 package-mode = true
 name = "clue-api"
-version = "1.0.0.dev34"
+version = "1.0.0.dev45"
 description = "Clue distributed enrichment service"
 authors = ["Canadian Centre for Cyber Security <contact@cyber.gc.ca>"]
 license = "MIT"

clue_api-1.0.0.dev34/clue/models/utils.py

@@ -1,52 +0,0 @@
-import random
-from datetime import datetime
-from typing import Union, get_args, get_origin
-
-from pydantic import BaseModel
-from pydantic_core import Url
-
-
-def generate_example_model(model: type[BaseModel], as_list: bool = False):  # noqa: C901
-    """Populate fields with example values"""
-    result = {}
-
-    if as_list:
-        full_list = []
-        for _ in range(random.randint(1, 3)):  # noqa: S311
-            full_list.append(generate_example_model(model))
-
-        return full_list
-
-    for name, field_info in model.model_fields.items():
-        field_type = field_info.annotation
-        if field_type:
-            if get_origin(field_type) is Union and type(None) in get_args(field_type):
-                field_type = (
-                    next((_type for _type in get_args(field_type) if _type is not type(None)), None) or field_type
-                )
-
-        _as_list = False
-        if get_origin(field_type) is list:
-            _as_list = True
-            field_type = get_args(field_type)[0]
-
-        _issubclass = False
-        try:
-            if field_type:
-                _issubclass = issubclass(field_type, BaseModel)
-        except TypeError:
-            pass
-
-        if field_type and _issubclass:
-            result[name] = generate_example_model(field_type, as_list=_as_list)
-        elif field_info.examples:
-            result[name] = random.choice(field_info.examples)  # noqa: S311
-        elif field_info.default:
-            result[name] = field_info.default
-
-        if isinstance(result[name], datetime):
-            result[name] = result[name].isoformat()
-        elif isinstance(result[name], Url):
-            result[name] = str(result[name])
-
-    return dict(result)