Feature Request: Allow deserialization of hyphenated fields about conjure-python-client HOT 1 OPEN

  - type: KebabCaseObjectExample
    positive:
        - '{"kebab-cased-field":1}'
    negative:
        - '{"kebabCasedField":1}'
        - '{"kebab_cased_field":1}'

class CreateDatasetRequest(ConjureBeanType):
    @classmethod
    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
        return {
            "file_system_id": ConjureFieldDefinition("fileSystemId", str),
            "path": ConjureFieldDefinition("path", str),
        }

    _file_system_id: str = None
    _path: str = None

    def __init__(self, file_system_id: str, path: str) -> None:
        self._file_system_id = file_system_id
        self._path = path

    @property
    def file_system_id(self) -> str:
        return self._file_system_id

    @property
    def path(self) -> str:
        return self._path

def test_object_with_hyphen():
    decoded = ConjureDecoder().decode({"file-system-id": "foo", "path": "bar"}, CreateDatasetRequest)
    assert decoded == CreateDatasetRequest("foo", "bar")

@classmethod
    def decode_conjure_bean_type(cls, obj, conjure_type):
        """Decodes json into a conjure bean type (a plain bean, not enum
        or union).
        Args:
            obj: the json object to decode <----------------------------------- #  {"file-system-id": "foo", "path": "bar"}
            conjure_type: a class object which is the bean type
                we're decoding into
        Returns:
            A instance of a bean of type conjure_type.
        """
        deserialized: Dict[str, Any] = {}

        for (
            python_arg_name,    <----------------------------------- #  ends up being "'file_system_id'"
            field_definition,
        ) in conjure_type._fields().items():
            field_identifier = field_definition.identifier  <----------------------------------- # ends up being "'fileSystemId'

             # only checking the field_identifier means incorrectly flagging the valid hyphenated case here
            if field_identifier not in obj or obj[field_identifier] is None:
                # Logic passes here
                cls.check_null_field(
                    obj, deserialized, python_arg_name, field_definition
                )
            else:
                value = obj[field_identifier]
                field_type = field_definition.field_type
                deserialized[python_arg_name] = cls.do_decode(
                    value, field_type
                )
        return conjure_type(**deserialized)

@classmethod
    def check_null_field(
        cls, obj, deserialized, python_arg_name, field_definition
    ):
        type_origin = get_origin(field_definition.field_type)
        if isinstance(field_definition.field_type, ListType):
            deserialized[python_arg_name] = []
        elif isinstance(field_definition.field_type, DictType):
            deserialized[python_arg_name] = {}
        elif isinstance(field_definition.field_type, OptionalType):
            deserialized[python_arg_name] = None
        elif type_origin is OptionalTypeWrapper:
            deserialized[python_arg_name] = None
        elif type_origin is list:
            deserialized[python_arg_name] = []
        elif type_origin is dict:
            deserialized[python_arg_name] = {}
        else:
            raise Exception( <-----------------------------------  this is where we are throwing the exception
                "field {} not found in object {}".format(
                    field_definition.identifier, obj
                )
            )

Exception: field fileSystemId not found in object {'file-system-id': 'foo', 'path': 'bar'}