source: packson3/packson/ObjectMapper.py@ 136

import json
from packson.JsonTypeInfo import Id,As, getTypeWrappingInfo
# from packson.JsonSubTypes import getSubTypes
from typing import _GenericAlias, cast , Dict, Any
from packson.JsonTools import isPrimitive, getActualClass, getInitArgs,addTypeInfo,getListClass
from pip._vendor.pyparsing import dictOf

class ObjectMapper:  
    '''
    A very simple packson-style objectmapper.
    '''
    def parse(self, data:object, clas:object )->object:
        '''
        @param data either a dict or a built-in object like an int
        @param clas the expected class contained in the data.
        If a dict, this class must have a __init__ function specifying the params
        needed and the data in this case should be a dict.
        @return a clas instance matching the data
        '''
        if getTypeWrappingInfo(clas):
            if not isinstance(data, dict):
                raise ValueError("Expected class, therefore data must be a dict but got "+str(data))
            (data, clas) = getActualClass(cast(dict, data),clas)
        # now distinguish 
        if isPrimitive(clas):
            return self.parseBase(data, clas)
        if (clas==list):
            raise ValueError("Illegal type, use List[X] instead of list")
        if (clas==dict):
            raise ValueError("Illegal type, use Dict[X] instead of dict")
        if type(clas)==_GenericAlias:
            return self.parseGeneric(data,clas)
            raise ValueError("GenericAlias not yet supported")
        if type(data)==dict: # if it contains class, data must be dict
            return self.parseClass(cast(dict,data), clas)
        raise ValueError("Unexpected type of data:"+str(clas))
        
    def parseBase(self,obj, clas)->object:
        '''
        @param obj a built-in object like an int
        @param clas the class of the expected object
        class does not contain __init__, it must be a built-in type
        @return the obj, after checking it's indeed a clas
        '''
        if not type(obj)==clas:
            raise ValueError("expected "+str(clas)+", got "+str(obj))
        return obj
             
 
    def parseClass(self, data:dict, clas)->object:
        '''
        @param data a dict with the values for class.__init__ function
        @return a clas instance matching the data
        '''
        if not isinstance(data,dict ):
            raise ValueError("data "+str(data)+" must be dict")
        # then this class needs initialization
        initargs={}
        argclasses=getInitArgs(clas)
        for arg in argclasses:
            if not arg in data:
                raise ValueError(str(clas)+" constructor takes "+str(arg)+", but value missing in dict "+str(data))
            try:
                initargs[arg] = self.parse(data[arg], argclasses[arg])
            except ValueError as e:
                raise ValueError("Error parsing "+json.dumps(data),e)
        return clas(**initargs)
    
    def parseGeneric(self, data, clas:_GenericAlias)->object:
        '''
        @param data may be list or dict, depending on the exact clas
        @return instance of the clas. Don't know how to write this for typing
        '''
        gname =clas._name
        
        if gname=='List' or gname=='Set':
            elementclas = clas.__args__[0]
            if type(data)!=list:
                raise ValueError("expected list[{elementclas}] but got "+str(data))
            res=[self.parse(listitem, elementclas) for listitem in data]
            if gname=='List':
                return res
            else:
                return set(res)
        
        if gname=='Dict':
            keyclas = clas.__args__[0]
            if not keyclas.__hash__:
                raise ValueError("Dict cannot be serialized, key class "+str(keyclas)+" does not  have __hash__")
            elementclas = clas.__args__[1]
            if type(data)!=dict:
                raise ValueError("expected dict[{keyclass, elementclas}] but got "+str(data))
            return { self.parse(key, keyclas) : self.parse(val, elementclas)\
                     for key,val in data.items() }

        raise ValueError("Unsupported generic type "+gname)
    
    def toJson(self, data)->dict:
        '''
        @param data either a dict or a built-in object like an int
        @return a dict containing this object 
        '''
        res:dict
        clas = type(data)
        if isPrimitive(clas):
            return self.toJsonBase(data) 
        if clas==list or clas==tuple or clas==set:
            res=self.toJsonList(data)
        elif clas==dict:
            res=self.toJsonDict(data)
        elif type(clas)==type:
            # is it general class? FIXME can this be done better?
            res = self.toJsonClass(data)
        else:
            raise ValueError("Unsupported object of type "+str(clas))
        # check if wrapper setting is requested for this class
        if getTypeWrappingInfo(clas):
            res=addTypeInfo(clas,res);
        return res
        
    def toJsonClass(self,data:object)->dict:
        ''' 
        @param data a class instance
        @return data a dict with the values 
        The values are based on the  class.__init__ function
        '''
        clas=type(data)
        res={}
        for arg in getInitArgs(clas):
            gettername = 'get'+arg
            if not hasattr(data, gettername) :# in clas.__dict__:
                raise ValueError("The object "+str(data)+ "of type "+ str(clas)+" has no function "+gettername)
            argvalue = getattr(data, gettername)() #.__dict__[gettername]()
            res[arg]=self.toJson(argvalue)
        return res
        
    
    def toJsonBase(self,obj):
        '''
        @param obj a built-in object like an int
        obj does not contain __init__, it must be a built-in type
        '''
        return obj
    
    def toJsonList(self, listofobj):
        '''
        @param listofobj list or tuple of objects each to be serialized separately.
        @return list object to be put in the json representation,  
        '''
        if len(listofobj)==0:
            return [] # empty list has no type. 
        clas = getListClass(listofobj)
        #         if isPrimitive(clas):
        #             return listofobj
        if not (isPrimitive(clas) or getTypeWrappingInfo(clas)):
            raise ValueError("@JsonTypeInfo is required for list objects, but found "+str(clas))
        return [self.toJson(elt) for elt in listofobj]
    
    def toJsonDict(self, dictofobj:Dict[Any,Any]):
        '''
        @param dictofobj dict with objects each to be serialized separately.
        The keys must be primitive, values must be all the same class.
        @return list object to be put in the json representation,  
        '''
        if len(dictofobj)==0:
            return {} # empty list has no type. 
        keyclas = getListClass(list(dictofobj.keys()))
        valclas = getListClass(list(dictofobj.values()))
        #         if isPrimitive(clas):
        #             return listofobj
        if not isPrimitive(keyclas):
            raise ValueError("key of dict must be primitive, but keys are of type "+\
                             str(keyclas)+" in "+str(dictofobj))
        if not getTypeWrappingInfo(valclas):
            raise ValueError("@JsonTypeInfo is required for list objects, but found "+str(valclas))
        return { self.toJson(key):self.toJson(val) for key,val in dictofobj.items()}