python discord Summer Code Jam 2020 참가 qualifier.py 풀기

import datetime
import typing
import re
from itertools import count

class ArticleField:
    """The `ArticleField` class for the Advanced Requirements."""

    def __init__(self, field_type: typing.Type[typing.Any]):
        self._field_type = field_type
    
    def __set__(self, obj, val):
        if type(val) == str:
          raise TypeError("""expected an instance of type 'int' for attribute 'attribute', got 'str' instead""")
        obj._field_type = val

    def __get__(self, obj, val):
        return obj._field_type

class Article:
    """The `Article` class you need to write for the qualifier."""
    
    _ids = count(0)

    def __init__(self, title: str, author: str, publication_date: datetime.datetime, content: str):
        self._title = title
        self._author = author
        self._publication_date=publication_date
        self._content = content
        self._id = next(self._ids)
        self._last_edited = None

    @property
    def last_edited (self):
        return self._last_edited 

    @last_edited .setter
    def last_edited (self, value: datetime.datetime):
        self._last_edited  = value

    @property
    def id(self):
        return self._id

    @id.setter
    def id(self, value):
        self._id = value

    @property
    def title(self):
        return self._title

    @title.setter
    def title(self, value):
        self._title = value
        
    @property
    def author(self):
        return self._author

    @author.setter
    def author(self, value):
        self._author = value

    @property
    def publication_date(self):
        return self._publication_date

    @publication_date.setter
    def publication_date(self, value):
        self._publication_date = value

    @property
    def content(self):
        return self._content

    @content.setter
    def content(self, value):
        self.last_edited = datetime.datetime.now()
        self._content = value

    def __repr__(self):
      return (f'<{self.__class__.__name__}'
              f' title={self.title!r}'
              f' author={self.author!r}'
              f' publication_date={self.publication_date.isoformat()!r}>')
  
    def __len__(self):
      return len(self.content)

    def short_introduction(self, n_characters:int):
      ret_list = []
      content = self.content
      content = content.split()
      total_len = 0
      for i in content:
        total_len += len(i)
        if n_characters >= total_len:
          ret_list.append(i)
        else:
          break
        total_len+=1
      return " ".join(ret_list)
      
    def most_common_words(self,n:int):
      result = {}
      if n == 0 :
        return result
      content = self.content
      word_list = re.split('\W', content)
      word_list = ' '.join(word_list).split()
      word_list = list(map(lambda x:x.lower(),word_list))

      cal_dict = {}
      for idx,val in enumerate(word_list):
        try:
          cal_dict[val]["count"] += 1
        except KeyError:
          cal_dict[val] = {"count":1,"idx":idx}
      
      # dict to list
      cal_dict = sorted(cal_dict.items(), key=lambda x: (x[1]["idx"]))
      # list
      cal_dict = sorted(cal_dict, key=lambda x: (x[1]["count"]), reverse=True)

 
      count = 0
      for i in cal_dict:
        count+=1 
        if count > n :
          break
        result[i[0]] = i[1]["count"]
          
      return result
      
    def __lt__(self, other):
      return self.publication_date < other.publication_date