geniespec 0.1.1.dev2__py3-none-any.whl

geniespec/languages.py

@@ -0,0 +1,408 @@
+import collections
+import keyword
+
+from core.exceptions import KibaException
+
+from geniespec.renderable_types import ActionEndpointComponent
+from geniespec.renderable_types import AttributeEndpointComponent
+from geniespec.renderable_types import MappingRenderableType
+from geniespec.renderable_types import RenderableApi
+from geniespec.renderable_types import RenderableEndpointComponent
+from geniespec.renderable_types import RenderableException
+from geniespec.renderable_types import RenderableOperation
+from geniespec.renderable_types import RenderableParameter
+from geniespec.renderable_types import RenderableResource
+from geniespec.renderable_types import RenderableString
+from geniespec.renderable_types import RenderableType
+from geniespec.renderable_types import ResourceEndpointComponent
+from geniespec.renderable_types import SingleResourceEndpointComponent
+from geniespec.types import ComplexTypes
+from geniespec.types import FieldSources
+from geniespec.types import PrimitiveTypes
+from geniespec.types import ResponseTypes
+from geniespec.types import Version
+
+
+class BaseLanguageDefinition:
+    FILE_EXTENSIONS: list[str]
+    AUTOGENERATED_NOTICE: str
+
+    def boolean_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
+    def date_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
+    def datetime_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
+    def double_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
+    def float_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
+    def integer_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
+    def mapping_type(self, isNullable: bool, keyType: str, valueType: str) -> str:
+        raise NotImplementedError
+
+    def json_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
+    def list_type(self, isNullable: bool, listItemType: str) -> str:
+        raise NotImplementedError
+
+    def struct_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
+    def long_integer_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
+    def object_type(self, isNullable: bool, className: RenderableString, apiVersion: Version, isLocalReference: bool) -> str:
+        raise NotImplementedError
+
+    def one_of_type(self, isNullable: bool, subTypes: list[str]) -> str:
+        raise NotImplementedError
+
+    def string_type(self, isNullable: bool) -> str:
+        raise NotImplementedError
+
+    def enum_type(self, isNullable: bool, values: list[str]) -> str:
+        raise NotImplementedError
+
+    def package_name(self, api: RenderableApi) -> str:
+        raise NotImplementedError
+
+    def distribution_name(self, api: RenderableApi) -> str:
+        raise NotImplementedError
+
+    def validation_errors(self, api: RenderableApi) -> list[str]:
+        raise NotImplementedError
+
+    def _render_one_of_type_string(self, oneOfTypeString: str, isNullable: bool, apiVersion: Version) -> list[str]:
+        oneOfTypes = ''.join(oneOfTypeString.replace('OneOf[', '', 1).rsplit(']', 1)).split(', ')
+        return [self.render_type(renderableType=RenderableType(rawType=oneOfType, isNullable=isNullable), apiVersion=apiVersion) for oneOfType in oneOfTypes]
+
+    def _render_list_type_string(self, listTypeString: str, apiVersion: Version) -> str:
+        listItemType = ''.join(listTypeString.replace('List[', '', 1).rsplit(']', 1))
+        return self.render_type(renderableType=RenderableType(rawType=listItemType, isNullable=False), apiVersion=apiVersion)
+
+    def render_type(self, renderableType: RenderableType, apiVersion: Version, isLocalReference: bool = False) -> str:
+        yamlType = renderableType.rawType
+        isNullable = renderableType.isNullable
+        if renderableType.isList:
+            return self.list_type(isNullable=isNullable, listItemType=self.render_type(renderableType=renderableType.model_copy(update={'isList': False, 'isNullable': False}), apiVersion=apiVersion, isLocalReference=isLocalReference))
+        if yamlType == PrimitiveTypes.LONG_INTEGER:
+            return self.long_integer_type(isNullable=isNullable)
+        if yamlType == PrimitiveTypes.INTEGER:
+            return self.integer_type(isNullable=isNullable)
+        if yamlType == PrimitiveTypes.FLOAT:
+            return self.float_type(isNullable=isNullable)
+        if yamlType == PrimitiveTypes.DOUBLE:
+            return self.double_type(isNullable=isNullable)
+        if yamlType == PrimitiveTypes.STRING:
+            return self.string_type(isNullable=isNullable)
+        if yamlType == PrimitiveTypes.BOOLEAN:
+            return self.boolean_type(isNullable=isNullable)
+        if yamlType == PrimitiveTypes.DATETIME:
+            return self.datetime_type(isNullable=isNullable)
+        if yamlType == PrimitiveTypes.DATE:
+            return self.date_type(isNullable=isNullable)
+        if yamlType == PrimitiveTypes.JSON:
+            return self.json_type(isNullable=isNullable)
+        # if yamlType == PrimitiveTypes.STRUCT:
+        #     return self.struct_type(isNullable=isNullable)
+        # if yamlType.startswith(PrimitiveTypes.ENUM):
+        #     values = ''.join(yamlType.replace('Enum[', '', 1).rsplit(']', 1)).split(', ')
+        #     return self.enum_type(isNullable=isNullable, values=[RenderableString.from_kebab_case_string(string=value) for value in values])
+        # if yamlType.startswith(PrimitiveTypes.ONE_OF):
+        #     subTypes = self._render_one_of_type_string(oneOfTypeString=yamlType, isNullable=isNullable, apiVersion=apiVersion)
+        #     return self.one_of_type(isNullable=isNullable, subTypes=subTypes)
+        if yamlType == ComplexTypes.MAPPING and isinstance(renderableType, MappingRenderableType):
+            keyType = self.render_type(renderableType=renderableType.keyType, apiVersion=apiVersion, isLocalReference=isLocalReference)
+            valueType = self.render_type(renderableType=renderableType.valueType, apiVersion=apiVersion, isLocalReference=isLocalReference)
+            return self.mapping_type(isNullable=isNullable, keyType=keyType, valueType=valueType)
+        if yamlType == 'class' and isinstance(renderableType, RenderableType) and renderableType.className is not None:
+            return self.object_type(isNullable=isNullable, className=renderableType.className, apiVersion=apiVersion, isLocalReference=isLocalReference)
+        raise KibaException(f'Failed to render: {type(renderableType)} {renderableType}')
+
+    def render_parameter(self, renderableParameter: RenderableParameter, apiVersion: Version) -> str:
+        isNullable = renderableParameter.fieldType.isNullable
+        if renderableParameter.defaultValue is not None:
+            isNullable = False
+        return self.render_type(renderableType=renderableParameter.fieldType.model_copy(update={'isNullable': isNullable}), apiVersion=apiVersion)
+
+
+class PythonLanguageDefinition(BaseLanguageDefinition):
+    AUTOGENERATED_NOTICE = '# --- THIS FILE HAS BEEN AUTOGENERATED, DO NOT MODIFY MANUALLY ---'
+
+    def boolean_type(self, isNullable: bool) -> str:
+        return 'bool | None' if isNullable else 'bool'
+
+    def datetime_type(self, isNullable: bool) -> str:
+        return 'datetime.datetime | None' if isNullable else 'datetime.datetime'
+
+    def date_type(self, isNullable: bool) -> str:
+        return 'datetime.date | None' if isNullable else 'datetime.date'
+
+    def double_type(self, isNullable: bool) -> str:
+        return 'float | None' if isNullable else 'float'
+
+    def float_type(self, isNullable: bool) -> str:
+        return 'float | None' if isNullable else 'float'
+
+    def integer_type(self, isNullable: bool) -> str:
+        return 'int | None' if isNullable else 'int'
+
+    def mapping_type(self, isNullable: bool, keyType: str, valueType: str) -> str:
+        return f'collections.abc.Mapping[{keyType}, {valueType}] | None' if isNullable else f'collections.abc.Mapping[{keyType}, {valueType}]'
+
+    def json_type(self, isNullable: bool) -> str:
+        return 'pydantic.JsonValue | None' if isNullable else 'pydantic.JsonValue'
+
+    def list_type(self, isNullable: bool, listItemType: str) -> str:
+        return f'collections.abc.Sequence[{listItemType}] | None' if isNullable else f'collections.abc.Sequence[{listItemType}]'
+
+    def struct_type(self, isNullable: bool) -> str:
+        return 'typing.JsonMapping | None' if isNullable else 'JsonMapping'
+
+    def long_integer_type(self, isNullable: bool) -> str:
+        return 'int | None' if isNullable else 'int'
+
+    def object_type(self, isNullable: bool, className: RenderableString, apiVersion: Version, isLocalReference: bool) -> str:
+        typeName = f'{className.pascalCaseString}V{apiVersion.major}' if isLocalReference else f'resources.{className.pascalCaseString}V{apiVersion.major}'
+        return f'{typeName} | None' if isNullable else typeName
+
+    def one_of_type(self, isNullable: bool, subTypes: list[str]) -> str:
+        fieldTypes = ' | '.join(subTypes)
+        return f'{fieldTypes} | None' if isNullable else f'Union[{fieldTypes} | None'
+
+    def string_type(self, isNullable: bool) -> str:
+        return 'str | None' if isNullable else 'str'
+
+    def enum_type(self, isNullable: bool, values: list[str]) -> str:
+        valueString = ', '.join([f"'{value}'" for value in values])
+        return f'typing.Literal[{valueString}] | None' if isNullable else f'Literal[{valueString} | None'
+
+    @staticmethod
+    def _normalized_name(name: RenderableString) -> RenderableString:
+        if len(name.string) != 1 or name.string[0].isupper():
+            return name
+        return RenderableString.from_camel_case_string(string=name.string[0])
+
+    @classmethod
+    def identifier(cls, name: RenderableString) -> str:
+        normalizedName = cls._normalized_name(name=name)
+        if len(normalizedName.string) == 1 and normalizedName.string[0].isupper():
+            return normalizedName.string[0].lower()
+        return normalizedName.camelCaseString
+
+    @classmethod
+    def pascal_name(cls, name: RenderableString) -> str:
+        return cls._normalized_name(name=name).pascalCaseString
+
+    @classmethod
+    def snake_name(cls, name: RenderableString) -> str:
+        return cls._normalized_name(name=name).snakeCaseString
+
+    @classmethod
+    def kebab_name(cls, name: RenderableString) -> str:
+        return cls._normalized_name(name=name).kebabCaseString
+
+    def package_name(self, api: RenderableApi) -> str:
+        return f'{self.snake_name(name=api.serviceName)}_api'
+
+    def distribution_name(self, api: RenderableApi) -> str:
+        return f'{self.kebab_name(name=api.serviceName)}-api'
+
+    def internal_class_name(self, api: RenderableApi) -> str:
+        return f'{self.pascal_name(name=api.serviceName)}ApiV{api.version.major}Internal'
+
+    def resource_class_name(self, resource: RenderableResource, apiVersion: Version) -> str:
+        return f'{self.pascal_name(name=resource.singleName)}V{apiVersion.major}'
+
+    def exception_class_name(self, exception: RenderableException, apiVersion: Version) -> str:
+        return f'{self.pascal_name(name=exception.name)}V{apiVersion.major}'
+
+    def type(self, renderableType: RenderableType, apiVersion: Version, isLocalReference: bool = False) -> str:
+        return self.render_type(renderableType=renderableType, apiVersion=apiVersion, isLocalReference=isLocalReference)
+
+    def parameter_type(self, renderableParameter: RenderableParameter, apiVersion: Version) -> str:
+        return self.render_parameter(renderableParameter=renderableParameter, apiVersion=apiVersion)
+
+    @staticmethod
+    def route_auth(operation: RenderableOperation) -> str | None:
+        return operation.authentication if operation.authentication not in (None, 'none') else None
+
+    @classmethod
+    def requires_auth_resolver(cls, api: RenderableApi) -> bool:
+        return any(cls.route_auth(operation=operation) is not None for operation in api.operations)
+
+    def operation_name(self, operation: RenderableOperation) -> str:
+        return self.snake_name(name=self._operation_name(operation=operation))
+
+    def operation_class_name(self, operation: RenderableOperation) -> str:
+        return self.pascal_name(name=self._operation_name(operation=operation))
+
+    def http_method(self, operation: RenderableOperation) -> str:
+        return operation.method.method.upperCaseString
+
+    def is_undefined_parameter(self, operation: RenderableOperation, parameter: RenderableParameter) -> bool:
+        return self.http_method(operation=operation) == 'PATCH' and parameter.source == FieldSources.REQUEST and not parameter.isRequired and parameter.defaultValue is None
+
+    def requires_parameter_preprocessing(self, operation: RenderableOperation, parameter: RenderableParameter) -> bool:
+        return (parameter.defaultValue is not None and not self.is_undefined_parameter(operation=operation, parameter=parameter)) or parameter.minValue is not None or parameter.maxValue is not None
+
+    def requires_undefined(self, api: RenderableApi) -> bool:
+        return any(self.is_undefined_parameter(operation=operation, parameter=parameter) for operation in api.operations for parameter in operation.parameters)
+
+    def requires_optional_field_default(self, api: RenderableApi) -> bool:
+        return any(not self.is_undefined_parameter(operation=operation, parameter=parameter) and not parameter.isRequired and not parameter.fieldType.isNullable for operation in api.operations for parameter in self.request_parameters(operation=operation))
+
+    @staticmethod
+    def request_parameters(operation: RenderableOperation) -> list[RenderableParameter]:
+        return [parameter for parameter in operation.parameters if parameter.source == FieldSources.REQUEST]
+
+    @staticmethod
+    def is_streaming(operation: RenderableOperation) -> bool:
+        return operation.responseType == ResponseTypes.STREAM
+
+    @staticmethod
+    def is_redirect(operation: RenderableOperation) -> bool:
+        return operation.responseType == ResponseTypes.REDIRECT
+
+    def requires_streaming(self, api: RenderableApi) -> bool:
+        return any(self.is_streaming(operation=operation) for operation in api.operations)
+
+    def requires_redirect(self, api: RenderableApi) -> bool:
+        return any(self.is_redirect(operation=operation) for operation in api.operations)
+
+    def return_type(self, operation: RenderableOperation, apiVersion: Version) -> str:
+        if operation.responseType == ResponseTypes.REDIRECT:
+            return 'str'
+        if not operation.responseFields:
+            return 'None'
+        fieldType = self.type(renderableType=operation.responseFields[0].fieldType, apiVersion=apiVersion)
+        return f'collections.abc.AsyncIterator[{fieldType}]' if operation.responseType == ResponseTypes.STREAM else fieldType
+
+    def parameter_value(self, operation: RenderableOperation, parameter: RenderableParameter) -> str:
+        if parameter.source == FieldSources.QUERY_PARAMETERS:
+            return 'dict(request.query_params)'
+        parameterName = self.identifier(name=parameter.name)
+        return parameterName if self.requires_parameter_preprocessing(operation=operation, parameter=parameter) else f'request.data.{parameterName}'
+
+    @staticmethod
+    def _contains_json(renderableType: RenderableType) -> bool:
+        if isinstance(renderableType, MappingRenderableType):
+            return PythonLanguageDefinition._contains_json(renderableType=renderableType.keyType) or PythonLanguageDefinition._contains_json(renderableType=renderableType.valueType)
+        return renderableType.rawType == PrimitiveTypes.JSON
+
+    def resources_require_json(self, api: RenderableApi) -> bool:
+        return any(self._contains_json(renderableType=attribute.fieldType) for resource in api.resources for attribute in resource.attributes)
+
+    def operations_require_json(self, api: RenderableApi) -> bool:
+        fieldTypes = [parameter.fieldType for operation in api.operations for parameter in operation.parameters] + [field.fieldType for operation in api.operations for field in operation.responseFields or []]
+        return any(self._contains_json(renderableType=fieldType) for fieldType in fieldTypes)
+
+    def exceptions_require_json(self, api: RenderableApi) -> bool:
+        return any(self._contains_json(renderableType=field.fieldType) for exception in api.exceptions for field in exception.fields)
+
+    def endpoint(self, operation: RenderableOperation) -> str:
+        return '/' + '/'.join([segment for component in operation.endpoint.components for segment in self._endpoint_segments(component=component)])
+
+    def route_ordered_operations(self, api: RenderableApi) -> list[RenderableOperation]:
+        return sorted(api.operations, key=lambda operation: tuple(segment.startswith('{') for segment in self.endpoint(operation=operation).split('/')))
+
+    @staticmethod
+    def literal(value: str | float | bool) -> str:
+        return repr(value)
+
+    def _endpoint_segments(self, component: RenderableEndpointComponent) -> list[str]:
+        if isinstance(component, AttributeEndpointComponent):
+            return [self.kebab_name(name=component.attribute.name)] if component.attribute is not None else ['attributes']
+        if isinstance(component, ActionEndpointComponent):
+            return [self.kebab_name(name=component.actionName)] if component.actionName is not None else ['actions']
+        if isinstance(component, SingleResourceEndpointComponent):
+            return [self.kebab_name(name=component.relativeSingleName)]
+        if isinstance(component, ResourceEndpointComponent):
+            output = [self.kebab_name(name=component.relativeCollectionName)]
+            if component.attribute is None:
+                return output
+            if component.attribute.isUnique and not component.attribute.isPrimary:
+                output.append(self.kebab_name(name=component.attribute.name))
+            parameterName = self.identifier(name=component.attribute.name)
+            if component.attribute.fieldType.rawType in (PrimitiveTypes.INTEGER, PrimitiveTypes.LONG_INTEGER):
+                output.append(f'{{{parameterName}:int}}')
+            elif component.attribute.fieldType.rawType == PrimitiveTypes.STRING:
+                output.append(f'{{{parameterName}:str}}')
+            else:
+                raise KibaException(message=f'ResourceEndpointComponent created with an invalid attribute type of {component.attribute.fieldType}. Valid types are: integer, long integer and string.')
+            return output
+        raise KibaException(message=f'Unsupported endpoint component: {type(component)}')
+
+    def _operation_name(self, operation: RenderableOperation) -> RenderableString:
+        methodName = RenderableString(string=[])
+        if self.http_method(operation=operation) == 'POST':
+            if isinstance(operation.endpoint.lastComponent, ActionEndpointComponent) and operation.endpoint.lastComponent.actionName is not None:
+                methodName += operation.endpoint.lastComponent.actionName
+            else:
+                methodName += RenderableString(string=['create'])
+        elif self.http_method(operation=operation) == 'GET':
+            lastIsResourceCollection = isinstance(operation.endpoint.lastComponent, ResourceEndpointComponent) and operation.endpoint.lastComponent.attribute is None
+            lastIsAttributeList = isinstance(operation.endpoint.lastComponent, AttributeEndpointComponent) and operation.endpoint.lastComponent.attribute is None
+            lastIsActionList = isinstance(operation.endpoint.lastComponent, ActionEndpointComponent) and operation.endpoint.lastComponent.actionName is None
+            methodName += RenderableString(string=['list'] if lastIsResourceCollection or lastIsAttributeList or lastIsActionList else ['get'])
+            if isinstance(operation.endpoint.lastComponent, ActionEndpointComponent) and operation.endpoint.lastComponent.actionName is not None:
+                methodName += operation.endpoint.lastComponent.actionName
+        elif self.http_method(operation=operation) == 'DELETE':
+            methodName += RenderableString(string=['delete'])
+        elif self.http_method(operation=operation) == 'PATCH':
+            methodName += RenderableString(string=['update'])
+        resourceComponents = [component for component in operation.endpoint.components if isinstance(component, (ResourceEndpointComponent, SingleResourceEndpointComponent))]
+        if not resourceComponents:
+            return methodName
+        target = resourceComponents[-1]
+        parent = resourceComponents[-2] if len(resourceComponents) > 1 else None
+        lastComponent = operation.endpoint.lastComponent
+        returnsSingleTarget = any(field.fieldType.className == target.resource.singleName and not field.fieldType.isList for field in operation.responseFields or [])
+        isTargetItem = isinstance(target, SingleResourceEndpointComponent) or target.attribute is not None
+        isSingle = isTargetItem or returnsSingleTarget or (target is lastComponent and 'create' in methodName.string)
+        if operation.isIndirectAction:
+            singleName, collectionName = target.resource.singleName, target.resource.collectionName
+        elif isinstance(target, SingleResourceEndpointComponent):
+            singleName = collectionName = target.relativeSingleName
+        else:
+            singleName, collectionName = target.relativeSingleName, target.relativeCollectionName
+        targetName = singleName if isSingle else collectionName
+        if isinstance(target, ResourceEndpointComponent) and target.attribute is not None and target.attribute.isUnique and not target.attribute.isPrimary:
+            targetName += RenderableString(string=['by']) + target.attribute.name
+        if operation.isIndirectAction:
+            targetName = RenderableString(string=['for']) + targetName
+        elif parent is not None:
+            targetName += RenderableString(string=['for']) + parent.resource.singleName
+        if isinstance(lastComponent, AttributeEndpointComponent):
+            attributeName = lastComponent.attribute.name if lastComponent.attribute is not None else RenderableString(string=['attributes'])
+            return methodName + attributeName + RenderableString(string=['for']) + targetName
+        if isinstance(lastComponent, ActionEndpointComponent) and lastComponent.actionName is None:
+            return methodName + RenderableString(string=['actions', 'for']) + targetName
+        return methodName + targetName
+
+    def validation_errors(self, api: RenderableApi) -> list[str]:
+        routes = [f'{self.http_method(operation=operation)} {self.endpoint(operation=operation)}' for operation in api.operations]
+        errors = [f'Duplicate route: {route}' for route, count in collections.Counter(routes).items() if count > 1]
+        routesByOperationName: dict[str, list[str]] = collections.defaultdict(list)
+        for operation, route in zip(api.operations, routes, strict=True):
+            routesByOperationName[self.operation_name(operation=operation)].append(route)
+        errors += [f'Duplicate operation name {operationName}: {", ".join(operationRoutes)}' for operationName, operationRoutes in routesByOperationName.items() if len(operationRoutes) > 1]
+        errors += [
+            f'Duplicate parameter {name} on {route}' for operation, route in zip(api.operations, routes, strict=True) for name, count in collections.Counter(self.identifier(name=parameter.name) for parameter in operation.parameters).items() if count > 1
+        ]
+        namesWithContext = [(operationName, f'operation {", ".join(operationRoutes)}') for operationName, operationRoutes in routesByOperationName.items()]
+        namesWithContext += [(self.identifier(name=parameter.name), f'parameter of {route}') for operation, route in zip(api.operations, routes, strict=True) for parameter in operation.parameters]
+        namesWithContext += [(self.identifier(name=field.name), f'response field of {route}') for operation, route in zip(api.operations, routes, strict=True) for field in operation.responseFields or []]
+        namesWithContext += [(self.identifier(name=attribute.name), f'attribute of {resource.singleName.pascalCaseString}') for resource in api.resources for attribute in [*resource.attributes, *resource.independentAttributes]]
+        namesWithContext += [(self.identifier(name=field.name), f'field of {exception.name.pascalCaseString}') for exception in api.exceptions for field in exception.fields]
+        errors += [f'"{name}" is not a valid Python name ({context})' for name, context in namesWithContext if not name.isidentifier() or keyword.iskeyword(name)]
+        return errors

geniespec/renderable_types.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+import re
+
+from core.exceptions import KibaException
+from pydantic import BaseModel
+
+from geniespec.types import ComplexTypes
+from geniespec.types import FieldSources
+from geniespec.types import ResponseTypes
+from geniespec.types import Version
+
+
+class RenderableString(BaseModel):
+    string: list[str]
+
+    def __add__(self, other: RenderableString) -> RenderableString:
+        return RenderableString(string=self.string + other.string)
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, RenderableString) and self.lowerCaseString == other.lowerCaseString
+
+    def __hash__(self) -> int:
+        return hash(frozenset(self.string))
+
+    @property
+    def lowerCaseString(self) -> str:  # noqa: N802
+        return ''.join([s.lower() for s in self.string])
+
+    @property
+    def upperCaseString(self) -> str:  # noqa: N802
+        return ''.join([s.upper() for s in self.string])
+
+    @property
+    def pascalCaseString(self) -> str:  # noqa: N802
+        return ''.join([s.lower().capitalize() for s in self.string])
+
+    @property
+    def camelCaseString(self) -> str:  # noqa: N802
+        return self.string[0].lower() + ''.join([s.lower().capitalize() for s in self.string[1:]])
+
+    @property
+    def snakeCaseString(self) -> str:  # noqa: N802
+        return '_'.join([s.lower() for s in self.string])
+
+    @property
+    def kebabCaseString(self) -> str:  # noqa: N802
+        return '-'.join([s.lower() for s in self.string])
+
+    @property
+    def capitalizedKebabCaseString(self) -> str:  # noqa: N802
+        return '-'.join([s.capitalize() for s in self.string])
+
+    def join_string(self, separator: str) -> str:
+        return separator.join(self.string)
+
+    @property
+    def endpointUrlString(self) -> str:  # noqa: N802
+        return '/' + '/'.join([s.lower() for s in self.string])
+
+    @classmethod
+    def from_pascal_case_string(cls, string: str) -> RenderableString:
+        return cls(string=re.sub('([A-Z][a-z]+)', r' \1', re.sub('([A-Z0-9])', r' \1', string)).split())
+
+    @classmethod
+    def from_camel_case_string(cls, string: str) -> RenderableString:
+        return cls(string=re.sub('([a-z][A-Z]+)', r' \1', re.sub('([A-Z0-9])', r' \1', string)).split())
+
+    @classmethod
+    def from_snake_case_string(cls, string: str) -> RenderableString:
+        return cls.from_separated_string(string=string, separator='_')
+
+    @classmethod
+    def from_kebab_case_string(cls, string: str) -> RenderableString:
+        return cls.from_separated_string(string=string, separator='-')
+
+    @classmethod
+    def from_upper_case_string(cls, string: str) -> RenderableString:
+        return cls(string=[string])
+
+    @classmethod
+    def from_lower_case_string(cls, string: str) -> RenderableString:
+        return cls(string=[string])
+
+    @classmethod
+    def from_separated_string(cls, string: str, separator: str) -> RenderableString:
+        return cls(string=string.split(separator))
+
+
+class RenderableType(BaseModel):
+    rawType: str
+    isNullable: bool
+    isList: bool = False
+    className: RenderableString | None = None
+
+
+class MappingRenderableType(RenderableType):
+    keyType: RenderableType
+    valueType: RenderableType
+    rawType: str = ComplexTypes.MAPPING
+
+
+class RenderableField(BaseModel):
+    name: RenderableString
+    fieldType: RenderableType
+    defaultValue: str | int | float | bool | None = None
+
+
+class RenderableAttribute(RenderableField):
+    isUnique: bool = False
+    isPrimary: bool = False
+    isUpdatable: bool = False
+    isNullable: bool = False
+    isSettable: bool = False
+    isAccessibleIndependently: bool = False
+    shouldDisableGetEndpoint: bool = False
+
+
+class RenderableResource(BaseModel):
+    singleName: RenderableString
+    collectionName: RenderableString
+    parentResource: str | None = None
+    attributes: list[RenderableAttribute]
+    independentAttributes: list[RenderableAttribute] = []
+    primaryAttribute: RenderableAttribute | None = None
+    accessibleFrom: list[str] = []
+
+
+class RenderableMethod(BaseModel):
+    method: RenderableString
+
+
+class RenderableEndpointComponent(BaseModel):
+    pass
+
+
+class AttributeEndpointComponent(RenderableEndpointComponent):
+    attribute: RenderableAttribute | None
+    resource: RenderableResource | None
+
+
+class ActionEndpointComponent(RenderableEndpointComponent):
+    actionName: RenderableString | None
+
+
+class ResourceEndpointComponent(RenderableEndpointComponent):
+    resource: RenderableResource
+    attribute: RenderableAttribute | None
+    relativeSingleName: RenderableString
+    relativeCollectionName: RenderableString
+
+
+class SingleResourceEndpointComponent(RenderableEndpointComponent):
+    resource: RenderableResource
+    relativeSingleName: RenderableString
+
+
+class RenderableEndpoint(BaseModel):
+    components: list[RenderableEndpointComponent]
+
+    @property
+    def lastComponent(self) -> RenderableEndpointComponent:  # noqa: N802
+        if len(self.components) == 0:
+            raise KibaException(message=f'RenderableEndpoint with no components found')
+        return self.components[-1]
+
+    @property
+    def urlParameters(self) -> list[RenderableParameter]:  # noqa: N802
+        return [
+            RenderableParameter(name=component.attribute.name, fieldType=component.attribute.fieldType, isRequired=True, isDeprecated=False)
+            for component in self.components
+            if isinstance(component, ResourceEndpointComponent) and component.attribute is not None
+        ]
+
+
+class RenderableParameter(RenderableField):
+    maxValue: float | int | bool | str | None = None
+    minValue: float | int | bool | str | None = None
+    isRequired: bool = False
+    isDeprecated: bool = False
+    source: str = FieldSources.REQUEST
+
+
+class RenderableOperation(BaseModel):
+    method: RenderableMethod
+    endpoint: RenderableEndpoint
+    query: list[RenderableParameter] | None
+    body: list[RenderableParameter] | None
+    responseFields: list[RenderableField] | None
+    authentication: str | None
+    isIndirectAction: bool = False
+    responseType: str = ResponseTypes.JSON
+
+    @property
+    def urlParameters(self) -> list[RenderableParameter]:  # noqa: N802
+        return self.endpoint.urlParameters
+
+    @property
+    def parameters(self) -> list[RenderableParameter]:
+        deduplicatedParameters: list[RenderableParameter] = []
+        parameterList = self.urlParameters + (self.body if self.body is not None else []) + (self.query if self.query is not None else [])
+        for parameter in parameterList:
+            if parameter not in deduplicatedParameters:
+                deduplicatedParameters.append(parameter)
+        deduplicatedParameters.sort(key=lambda deduplicatedParameter: (deduplicatedParameter.isRequired, deduplicatedParameter.defaultValue is None), reverse=True)
+        return deduplicatedParameters
+
+
+class ExceptionRenderableField(RenderableField):
+    isRequired: bool = False
+
+
+class RenderableException(BaseModel):
+    name: RenderableString
+    message: str | None
+    statusCode: int | None
+    fields: list[ExceptionRenderableField]
+
+
+class RenderableApi(BaseModel):
+    version: Version
+    serviceName: RenderableString
+    pythonClientPackageName: str
+    typescriptClientPackageName: str
+    resources: list[RenderableResource]
+    operations: list[RenderableOperation]
+    exceptions: list[RenderableException]
+
+
+class ProcessableResource(BaseModel):
+    class IndependentAttributeOccurrence(BaseModel):
+        processableResource: ProcessableResource
+        attribute: RenderableAttribute
+
+    class Parent(BaseModel):
+        processableResource: ProcessableResource
+        isOneToOne: bool
+
+    renderableResource: RenderableResource
+    parent: Parent | None
+    occursAsIndependentAttribute: list[IndependentAttributeOccurrence]
+
+
+class EndpointContainer(BaseModel):
+    individualEndpoints: list[RenderableEndpoint]
+    collectionEndpoints: list[RenderableEndpoint]

geniespec/templates/python/pyproject.toml.j2

@@ -0,0 +1,8 @@
+{{ autogenerated_notice }}
+[project]
+name = "{{ target.distribution_name(api=api) }}"
+version = "0.0.0"
+
+[build-system]
+requires = ["uv_build>=0.12,<0.13"]
+build-backend = "uv_build"

geniespec/templates/python/src/{service}/__init__.py.j2

@@ -0,0 +1 @@
+{{ autogenerated_notice }}

geniespec/templates/python/src/{service}/v{version}/__init__.py.j2

@@ -0,0 +1 @@
+{{ autogenerated_notice }}