model.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from typing import List
import os
import numpy as np
import json

def check_format(json_file):
    if os.path.exists(json_file):
        with open(json_file,'r') as jf:
            return json.loads(jf.read())
    elif type(json_file)=str:
        return json.loads(json_file)
    elif type(json_file)=dict:
        return json_file
    else:
        raise TypeError('Input not convertible.')

class Verse:
    
    self.readings = list()
    self.author = None
    self.work = None
    self.place = None
    
    def __init__(self, verse:str):
        self.from_verse(verse)
        
    def from_verse(verse):
        self.text = verse
        pass
        
    def from_json(json_file):
        raw = check_format(json_file)
        
        self.text = raw['verse']
        self.author = raw['source']['author']
        self.work = raw['source']['work']
        self.place = raw['source']['place']
        
        for reading in raw['readings']:
            self.readings.append(Reading.from_json(reading))
            
            
class Reading:
    
    self.tokens = list()
    
    def __init__(self, tokens:List[Token]):
        self.tokens = tokens
        
    def from_json(json_file):
        raw = check_format(json_file)
        for token in raw["tokens"]:
            self.tokens.append(Token.from_json(token))
            
    
class Token:
    
    self.syllables = list()
    
    def __init__(self, token:str, span:List[int],
                 syllables:List[Syllable]=list):
        if len(token) != span[1]-span[0]:
            raise ValueError('Token length does not match token span.')
        else:
            self.text = token
            self.span = span
            self.syllables = syllables

    def from_json(json_file):
        raw = check_format(json_file)
        
        self.span = raw['span']
        self.text = raw['token']
        
        for syllable in raw['syllables']:
            self.syllables.append(Syllable.from_json(syllable))

class Syllable:

    self.phenomena = dict()

    def __init__(self, syllable:str,
                 span:List[int], idx:int,
                 syllable_length:int, vowel_length:int,
                 phenomena:dict=dict()):
        if len(syllable) != span[1]-span[0]:
            raise ValueError('Syllable length does not match syllable span.')
        else:
            self.text = syllable
            self.span = span
            self.id = idx
            self.syllable_length = syllable_length
            self.vowel_length = vowel_length
            self.phenomena = phenomena
            
    def from_json(json_file):
        raw = check_format(json_file)
        
        self.id = raw['id']
        self.span = raw['span']
        self.text = raw['syllable']
        self.syllable_length = raw['syllable_length']
        self.vowel_length = raw['vowel_length']
        if raw['phenomena']:
            for phenomenon in raw['phenomena']:
                self.phenomena.append(Syllable.from_json(syllable))
        
        
class Phenomenon:
    
    def __init__(self, name:str, caused_by=None, overruled_by=None,
                 chars=None, typus=None, omitted=None):
        self.name = name
        self.caused_by = caused_by
        self.overruled_by = overruled_by
        
        self.chars = chars
        self.typus = typus
        self.omitted = omitted

    def positional_lengthening(self, chars:str, caused_by=None, overruled_by=None):
        self.__init__(self, 'positional lengthening', caused_by, overruled_by)
        self.chars = chars
        
    def iambic_shortening(self, typus:str, caused_by=None, overruled_by=None):
        self.__init__(self, 'iambic shortening', caused_by, overruled_by)
        self.typus = typus
        
    def s_elision(self, caused_by=None, overruled_by=None):
        self.__init__(self, 's-elision', caused_by, overruled_by)
        self.omitted = 's'

    def verse_end(self, caused_by=None, overruled_by=None):
        self.__init__(self,'verse end', caused_by, overruled_by)
        

class MultisyllablePhenomenon(Phenomenon):
    
    def __init__(self, name:str, beginning:int, end:int,
                 caused_by=None, overruled_by=None):
        Phenomenon.__init__(self, name, caused_by=None, overruled_by=None)
        self.beginning = beginning
        self.end = end
      
    def apheresis(self, beginning, end, caused_by=None, overruled_by=None):
        MultisyllablePhenomenon.__init__(self, 'apheresis', beginning, end,
                                         caused_by, overruled_by)

    def synizesis(self, beginning, end, caused_by=None, overruled_by=None):
        MultisyllablePhenomenon.__init__(self, 'synizesis', beginning, end,
                                         caused_by, overruled_by)