coursebuilder/coursebuilder/schema.py

import string

class Schema:

    def __init__(self,schema) -> None:
        self.__schema = schema

    def keys(self):
        return self.__schema.keys()

    # def get_template(self,field,lang='de'):
    #     if 'template' in self.__schema[field]:
    #         return self.__schema[field]['template'][lang]
    #     else:
    #         return "$value"        
        
    def is_translatable(self,field):
        if 'translatable' in self.__schema[field]:
            return self.__schema[field]['translatable']
        else:
            return True        

    def needs_spec(self,field):
        if 'spec' in self.__schema[field]:
            return self.__schema[field]
        else:
            return False
        
    # def process_label(self,field,lang='de'):
    #     # processes the label of a field item
    #     return self.__schema[field]['label'][lang]

    # def process_str(self,meta,field,lang='de'):
    #     if self.is_translatable(field):
    #         return [self.process_label(field,lang),meta[field][lang]]
    #     else:
    #         if not 'value' in meta[field]:
    #             raise AssertionError(field,'incomplete')
            
    #         return [self.process_label(field,lang),meta[field]['value']]

    # def process_enum(self,meta,field,lang='de'):
    #     """
    #     enum have a specification 'specs' option 
    #     that can be forced by the scheme
    #     """
    #     vv = meta[field]['value']
    #     enum_val = self.__schema[field]['values'][vv][lang]

    #     if self.needs_spec(field):

    #         t = string.Template(self.get_template(field=field,lang=lang))

    #         spec = meta[field]['spec'][lang]

    #         return [self.process_label(field,lang),t.substitute({'value': enum_val,'spec': spec})]
    #     else:
    #         return [self.process_label(field,lang),enum_val]

    # def process_num(self,meta,field,lang='de'):
    #     v = meta[field]['value']
    #     t = string.Template(self.get_template(field,lang))
    #     return [self.process_label(field,lang),t.substitute({'value' : v})]
    

    # def process_multinum(self,meta,field,lang='de'):
    #     """multinums have various values"""
    #     v = meta[field]['value']
    #     t = string.Template(self.get_template(field,lang))
    #     if hasattr(v, "__len__"):
    #         vv = [t.substitute({'value' : ev}) for ev in v]
    #         return [self.process_label(field,lang),', '.join(vv)]
    #     else:
    #         return self.process_num(meta=meta,field=field,lang=lang)
    
    
    # def process_multikey(self,meta,field,lang='de'):
    #     """
    #     multikey need to assign a numeric value to a key
    #     """
    #     vs = meta[field]['value']
    #     t = string.Template(self.get_template(field,lang))

    #     k = self.process_label(field,lang)

    #     parts = []

    #     for e in vs:
    #         kk = self.__schema[field]['keys'][e][lang]
    #         parts.append(t.substitute({'key': kk, 'value' : vs[e]}))

    #     return [k,', '.join(parts)]


    # def process(self,meta,fields,lang):

    #     table_items = []

    #     # iterate over requested fields
    #     for field in fields:
    #         try:
    #             # correlate with schema and append
    #             match self.__schema[field]['type']: 
    #                 case 'str': table_items.append(self.process_str(meta,field,lang)) 
    #                 case 'enum': table_items.append(self.process_enum(meta,field,lang))
    #                 case 'int' | 'num' : table_items.append(self.process_num(meta,field,lang))
    #                 case 'multinum' : table_items.append(self.process_multinum(meta,field,lang))
    #                 case 'multikey': table_items.append(self.process_multikey(meta,field,lang))
    #                 case _: raise ValueError
    #         except Exception as exp:
    #             print(field,' not resolvable in ',self.__schema,exp)

    #     # maybe return tableitems as np.Dataframe?
    #     return table_items
    
    def get_value(self,meta,field,lang):
        """
        treats receiving the value like a variant, 
        returns values with their language specific representations
        """
        match self.__schema[field]['type']: 
            case 'str': return meta[field][lang] if self.is_translatable(field) else meta[field]['value']
            case 'enum' | 'int' | 'num' | 'multikey' : return meta[field]['value']
            case 'multinum': return meta[field]['value'] if hasattr(meta[field]['value'],'__iter__') else (meta[field]['value'],) # force list!
    
    def to_list_of_dict(self,meta,fields,lang):
        """
        generates a list of dict which can easily be converted 
        to a pandas dataframe
        """
        # list comprehension for rows
        return [{'field' : field,   # field name
                  'lang' : lang,    # language shortcode
                  'type' : self.__schema[field]['type'], # datatype
                  'label' : self.__schema[field]['label'][lang], # label
                  'value' : self.get_value(meta,field,lang), # actual value
                  'template' : self.__schema[field]['template'][lang] if 'template' in self.__schema[field] else None,
                  # getting crazy with nested dict comprehension
                  'enum_values' : { k:v[lang] for (k,v) in self.__schema[field]['values'].items()} if 'enum' in self.__schema[field]['type'] else None,
                  'key_values' : { k:v[lang] for (k,v) in self.__schema[field]['keys'].items()} if 'multikey' in self.__schema[field]['type'] else None,
                  'spec' : meta[field]['spec'][lang] if 'spec' in meta[field] else None
                  }
                  for field in fields]
    
    def to_list_of_tuple(self,meta,fields,lang):
        """
        generates a list of tuples with a label and value (text)
        this is usually consumed by a Markdown generator

        todo: needs deuglyfication of free standing loop, templates are possible for all
        """
        list = []
        for r in self.to_list_of_dict(meta,fields,lang):
            match r['type']:
                case 'str' : 
                    list.append( (r['label'],r['value']) )
                case 'int' | 'num' : 
                    list.append( ( r['label'], r['template'].format(value=r['value'],spec=r['spec']) if r['template'] else r['value']) )
                case 'enum' : 
                    list.append( ( r['label'], r['template'].format(value=r['enum_values'][r['value']],spec=r['spec']) 
                                  if r['template'] else r['enum_values'][r['value']] ) )
                case 'multikey' : 
                    list.append( ( r['label'], ', '.join( [r['template'].format(key=r['key_values'][k],value=v) for k,v in r['value'].items()] ) ) )
                case 'multinum' :
                    list.append( (r['label'], ', '.join( r['template'].format(value=v) for v in r['value'])) )

        return list