def getObjectAsDictionary(instance, fieldsToExpand=[EXPAND_ALL_FIELDS], visitedIdInstances=None) : # print(instance) if ObjectHelper.isNone(visitedIdInstances) : visitedIdInstances = [] if ObjectHelper.isNativeClassInstance(instance) or ObjectHelper.isNone(instance) : return instance if EnumAnnotation.isEnumItem(instance) : return instance.enumValue if isDatetimeRelated(instance) : return str(instance) # print(f'{instance} not in {visitedIdInstances}: {instance not in visitedIdInstances}') isVisitedInstance = id(instance) in visitedIdInstances innerVisitedIdInstances = [*visitedIdInstances.copy()] if ObjectHelper.isDictionary(instance) and not isVisitedInstance : for key,value in instance.items() : instance[key] = getObjectAsDictionary(value, visitedIdInstances=innerVisitedIdInstances) return instance elif isSerializerCollection(instance) : objectValueList = [] for innerObject in instance : innerAttributeValue = getObjectAsDictionary(innerObject, visitedIdInstances=innerVisitedIdInstances) if ObjectHelper.isNotNone(innerAttributeValue) : objectValueList.append(innerAttributeValue) return objectValueList elif not isVisitedInstance : jsonInstance = {} try : # print(id(instance)) innerVisitedIdInstances.append(id(instance)) atributeNameList = ReflectionHelper.getAttributeNameList(instance.__class__) for attributeName in atributeNameList : attributeValue = getattr(instance, attributeName) if ReflectionHelper.isNotMethodInstance(attributeValue): jsonInstance[attributeName] = getObjectAsDictionary(attributeValue, visitedIdInstances=innerVisitedIdInstances) else : jsonInstance[attributeName] = None except Exception as exception : log.warning(getObjectAsDictionary, f'Not possible to get attribute name list from {ReflectionHelper.getName(ReflectionHelper.getClass(instance, muteLogs=True), muteLogs=True)}', exception=exception) if ObjectHelper.isNotEmpty(jsonInstance) : return jsonInstance return str(instance)
def serializeIt(fromJson, toClass, fatherClass=None) : # print(f'fromJson: {fromJson}, toClass: {toClass}, fatherClass: {fatherClass}') if ObjectHelper.isDictionary(fromJson) and ObjectHelper.isDictionaryClass(toClass) : # objectInstance = {} # for key, value in fromJson.items() : # innerToClass = getTargetClassFromFatherClassAndChildMethodName(fatherClass, key) # objectInstance[key] = serializeIt(fromJson, innerToClass, fatherClass=fatherClass) # return objectInstance return fromJson # print() # print() # print(fromJson) # print(f'fromJson: {fromJson}') # print(f'toClass: {toClass}') if ObjectHelper.isNativeClassInstance(fromJson) and toClass == fromJson.__class__ : return fromJson attributeNameList = ReflectionHelper.getAttributeNameList(toClass) classRole = getClassRole(toClass) # print(f' classRole = {classRole}') # print(f' attributeNameList = {attributeNameList}') fromJsonToDictionary = {} for attributeName in attributeNameList : # print(f' fromJson.get({attributeName}) = {fromJson.get(attributeName)}') jsonAttributeValue = fromJson.get(attributeName) if ObjectHelper.isNone(jsonAttributeValue) : jsonAttributeValue = fromJson.get(f'{attributeName[0].upper()}{attributeName[1:].lower()}') if ObjectHelper.isNotNone(jsonAttributeValue) : # print(f'jsonAttributeValue: {jsonAttributeValue}') fromJsonToDictionary[attributeName] = resolveValue(jsonAttributeValue, attributeName, classRole, fatherClass=fatherClass) # logList = [ # f'jsonAttributeValue: {jsonAttributeValue}', # f'attributeName: {attributeName}', # f'classRole: {classRole}', # f'fromJsonToDictionary: {fromJsonToDictionary}', # f'toClass: {toClass}' # ] # log.prettyPython(serializeIt, 'logList', logList, logLevel=log.DEBUG) else : fromJsonToDictionary[attributeName] = jsonAttributeValue # if jsonAttributeValue : # ReflectionHelper.setAttributeOrMethod(fromObject, attributeName, jsonAttributeValue) args = [] kwargs = fromJsonToDictionary.copy() # print(f'fromJsonToDictionary = {fromJsonToDictionary}') objectInstance = None for key,value in fromJsonToDictionary.items() : # print(f'*args{args},**kwargs{kwargs}') try : objectInstance = toClass(*args,**kwargs) break except : args.append(value) del kwargs[key] # print(f'args = {args}, kwargs = {kwargs}') # print(f'args = {args}, kwargs = {kwargs}') if ObjectHelper.isNone(objectInstance) : raise Exception(f'Not possible to instanciate {ReflectionHelper.getName(toClass, muteLogs=True)} class') # print(objectInstance) # print() # print() # if objectInstance is [] : # print(fromJson, toClass, fatherClass) return objectInstance
def getAttributeNameList_andPleaseSomeoneSlapTheFaceOfTheGuyWhoDidItInSqlAlchemy(instanceClass): attributeNameList = ReflectionHelper.getAttributeNameList(instanceClass) return attributeNameList if not isModelClass(instanceClass) else [attributeName for attributeName in attributeNameList if not SQL_ALCHEMY_RESGITRY_PUBLIC_REFLECTED_ATTRIBUTE_PRETTY_MUCH_THE_WORST_CODE_I_SAW_IN_MY_LIFE == attributeName]
def addDtoToUrlVerb(verb, url, dtoClass, documentation, dtoType=v.OBJECT, where=None): log.log( addDtoToUrlVerb, f'verb: {verb}, url: {url}, dtoClass: {dtoClass}, dtoType: {dtoType}, where: {where}' ) if dtoClass: if not isinstance(dtoClass, list): if not c.TYPE_DICT == ReflectionHelper.getName(dtoClass, muteLogs=True): dtoName = getDtoDocumentationName(dtoClass) if KW_REQUEST == where: documentation[k.PATHS][url][verb][k.PARAMETERS].append({ k.NAME: v.BODY, k.TYPE: v.OBJECT, k.IN: v.BODY, k.REQUIRED: True, k.DESCRIPTION: None, k.SCHEMA: getDtoSchema(dtoName, dtoType, dtoClass) }) elif KW_RESPONSE == where: documentation[k.PATHS][url][verb][k.RESPONSES][ k.DEFAULT_STATUS_CODE] = { k.DESCRIPTION: v.DEFAULT_RESPONSE, k.SCHEMA: getDtoSchema(dtoName, dtoType, dtoClass) } if not dtoName in documentation[k.DEFINITIONS]: dtoClassDoc = {} documentation[k.DEFINITIONS][dtoName] = dtoClassDoc dtoClassDoc[k.TYPE] = v.OBJECT dtoClassDoc[k.PROPERTIES] = {} dtoClassDoc[ k.REQUIRED] = ReflectionHelper.getAttributeNameList( dtoClass) for attributeName in dtoClassDoc[k.REQUIRED]: attributeType = getTypeFromAttributeNameAndChildDtoClass( attributeName, dtoType) childDtoClass = getNullableChildDtoClass( attributeName, dtoClass, verb, url, documentation) if childDtoClass: dtoClassDoc[ k.PROPERTIES][attributeName] = getDtoSchema( attributeName, attributeType, childDtoClass) else: dtoClassDoc[k.PROPERTIES][attributeName] = { k.TYPE: attributeType, k.EXAMPLE: None } else: dtoName = getDtoDocumentationName(dtoClass) if KW_REQUEST == where: documentation[k.PATHS][url][verb][k.PARAMETERS].append({ k.NAME: v.BODY, k.TYPE: v.OBJECT, k.IN: v.BODY, k.REQUIRED: True, k.DESCRIPTION: None, k.SCHEMA: getDtoSchema(dtoName, dtoType, dtoClass) }) elif KW_RESPONSE == where: documentation[k.PATHS][url][verb][k.RESPONSES][ k.DEFAULT_STATUS_CODE] = { k.DESCRIPTION: v.DEFAULT_RESPONSE, k.SCHEMA: getDtoSchema(dtoName, dtoType, dtoClass) } if not dtoName in documentation[k.DEFINITIONS]: dtoClassDoc = {} documentation[k.DEFINITIONS][dtoName] = dtoClassDoc dtoClassDoc[k.TYPE] = v.OBJECT dtoClassDoc[k.PROPERTIES] = {} dtoClassDoc[k.REQUIRED] = [] elif 1 == len(dtoClass): if dtoClass[0] and not isinstance(dtoClass[0], list): addDtoToUrlVerb(verb, url, dtoClass[0], documentation, where=where) elif 1 == len(dtoClass[0]): if dtoClass[0][0] and not isinstance(dtoClass[0][0], list): addDtoToUrlVerb(verb, url, dtoClass[0][0], documentation, dtoType=v.ARRAY, where=where)
def __init__(self, *args, **kwargs): originalClassAttributeValueList = ReflectionHelper.getAttributeNameList( OuterEnum) if instanceLog: log.prettyPython(OuterEnum, 'originalClassAttributeValueList', originalClassAttributeValueList) OuterEnum.__init__(self, *args, **kwargs) self.__associateReturnsTo__ = associateReturnsTo attributeDataList = ReflectionHelper.getAttributeDataList(self) if instanceLog: log.prettyPython(OuterEnum, 'attributeDataList', attributeDataList) for attribute, enumValue in attributeDataList: if enumValue not in ENUM_STATIC_METHOD_NAME_LIST and enumValue not in originalClassAttributeValueList: __raiseBadImplementation__(enumValue, enum=self) nativeClassDataList = [] attributeAttributeDataList = ReflectionHelper.getAttributeDataList( attribute) if instanceLog: log.prettyPython(OuterEnum, 'attributeAttributeDataList', attributeAttributeDataList) # print(f'type({attribute}): {type(attribute)}') association = ReflectionHelper.getAttributeOrMethod( attribute, self.__associateReturnsTo__, muteLogs=True) if type(association) is type(None): # print('type(association) is type(None)') ReflectionHelper.setAttributeOrMethod( attribute, ENUM_VALUE_AS_STRING_KEY, ENUM_ITEM_CLASS_DICTIONARY.get( type(enumValue))(enumValue)) nativeClassDataList = ReflectionHelper.getAttributeDataList( type(enumValue)()) # print(f'type({enumValue}): {type(enumValue)}, type({type(enumValue)}()): {type(type(enumValue)())}') else: # print('not type(association) is type(None)') ReflectionHelper.setAttributeOrMethod( attribute, ENUM_VALUE_AS_STRING_KEY, ENUM_ITEM_CLASS_DICTIONARY.get( type(association))(association)) nativeClassDataList = ReflectionHelper.getAttributeDataList( type(association)()) # print(f'type({association}): {type(association)}, type({type(association)}()): {type(type(association)())}') # print() attribute.enumValue.enumName = enumValue ReflectionHelper.setAttributeOrMethod( attribute, ENUM_NAME_AS_STRING_KEY, enumValue) if isinstance(attribute, EnumItem): # print(attribute, attribute.enumName, attribute) updateEnumItem( attribute, attribute.enumName, attribute) ###- so that __eq__ does not crash if not c.TYPE_FUNCTION == ReflectionHelper.getClassName( attribute): attribute.enumValue.__enumItemMap__ = attribute.__enumItemMap__ attribute.enumValue.__enumItemEqMap__ = attribute.__enumItemEqMap__ for dataInstance, dataName in attributeAttributeDataList: nativeData = False for _, name in nativeClassDataList: if dataName == name: nativeData = True break if not nativeData: ReflectionHelper.setAttributeOrMethod( attribute.enumValue, dataName, dataInstance) ReflectionHelper.setAttributeOrMethod( attribute.enumValue, ENUM_VALUE_AS_STRING_KEY, ReflectionHelper.getAttributeOrMethod( attribute, self.__associateReturnsTo__, muteLogs=True)) ReflectionHelper.setAttributeOrMethod( attribute.enumValue, ENUM_NAME_AS_STRING_KEY, enumValue) ReflectionHelper.setAttributeOrMethod( attribute.enumValue, ENUM_AS_STRING_KEY, self) if ObjectHelper.isEmpty(OuterEnum.__enumEqList__): for attribute, value in attributeDataList: # print(f'type({value}): {type(value)}') # print(f'type({attribute}): {type(attribute)}') valueAsString = str(attribute.enumValue) if valueAsString not in ENUM_STATIC_METHOD_NAME_LIST: if valueAsString not in self.__enumMap__: self.__enumMap__[ valueAsString] = attribute.enumValue ###- ReflectionHelper.getAttributeOrMethod(attribute, valueAsString, muteLogs=True) ###- attribute else: __raiseBadImplementation__(valueAsString, enum=self) if value not in self.__enumMap__: self.__enumMap__[value] = attribute elif not self.__enumMap__[value] == attribute: __raiseBadImplementation__(valueAsString, enum=self) self.__enumEqList__.append( f'{value}({self.__associateReturnsTo__}:{valueAsString})' )