def _analyseAndCache(self, board):
boardList = DecisionModelProxy.GetBoardList()
if board not in boardList:
return NullBoardAnalysis()
boardDecisions = DecisionModelProxy.GetAllForBoardOrderedByDecisionDate(
board)
count = len(boardDecisions)
early = boardDecisions[:5]
if count >= 5:
late = boardDecisions[count - 5:]
else:
late = boardDecisions
ipcTop5 = AnalysisHelpers.IpcMainFrequencyForBoard_TopN_withPercentage(
board, 5, count)
articleTop5 = AnalysisHelpers.AttributeFrequencyForBoard_TopN_withPercentage(
board, 5, count)
citationTop5 = AnalysisHelpers.ArticleFrequencyForBoard_TopN(board, 5)
analysis = BoardAnalysis(board, count, early, late, ipcTop5,
articleTop5, citationTop5)
self._cache[board] = analysis
return analysis
def __getAttributeFrequency(attribute, decisions):
if not attribute in DecisionModelProxy.GetBibliographyAttributeList():
return None
result = {}
for decision in decisions:
value = decision.__dict__[attribute]
# TODO: stop needing IsListAttribute
if DecisionModelProxy.IsListAttribute(attribute):
values = [x.strip() for x in value.split(',')]
else:
values = [value.strip()]
for v in values:
result[v] = result.get(v, 0) + 1
return result
def test_GetListFromDate(self):
from DecisionsPlus import DecisionModelProxy
casedate = datetime.strptime('26.09.2002', '%d.%m.%Y').date()
results = DecisionModelProxy.GetListFromKeywords(DecisionDate=casedate)
self.assertGreaterEqual(len(results), 13)
for res in results:
self.assertEqual(res.DecisionDate, casedate)
def __pkValueToDecisionValue(pairs):
result = []
for (pk, value) in pairs:
decision = DecisionModelProxy.GetDecisionFromPrimaryKey(pk)
if decision:
result.append((decision, value))
return result
def __init__(self):
boardList = DecisionModelProxy.GetBoardList()
boardGroups = self.__groupBoards(boardList)
for group in boardGroups:
boardGroups[group] = sorted(boardGroups[group])
self.Context = {'boards': sorted(boardGroups.items())}
def _getCitingDecisions(self, decision):
citing = decision.AllCiting
citinglist = [
DecisionModelProxy.GetRepresentativeForCaseNumber(x)
for x in citing
]
return citinglist
def test_GetCitingFromCaseNumber(self):
from DecisionsPlus import DecisionModelProxy
cn = 'T 0641/00'
result = DecisionModelProxy.GetCitingCasesFromCaseNumber(cn)
result_cns = [x.CaseNumber for x in result]
self.assertTrue('G 0003/08' in result_cns)
self.assertTrue('T 1421/08' in result_cns)
self.assertTrue('T 1769/10' in result_cns)
def test_GetCitedFromCaseNumber(self):
from DecisionsPlus import DecisionModelProxy
cn = 'T 0641/00'
result = DecisionModelProxy.GetCitedCasesFromCaseNumber(cn)
result_cns = [x.CaseNumber for x in result]
self.assertTrue('T 0026/81' in result_cns)
self.assertTrue('T 0026/86' in result_cns)
self.assertTrue('T 0931/95' in result_cns)
def decision(request, pk, highlightterms='[]'):
"""Renders a single decision."""
assert isinstance(request, HttpRequest)
from ast import literal_eval
decision = DecisionModelProxy.GetDecisionFromPrimaryKey(pk)
decisions = DecisionModelProxy.GetListFromKeywords(
CaseNumber=decision.CaseNumber)
hlterms = literal_eval(highlightterms)
viewModel = DecisionVM.DecisionViewModel(decisions,
pk=pk,
highlightterms=hlterms)
return render(
request,
'DecisionViewer/decision.html',
viewModel.Context,
)
def test_GetListFromApplicant__contains(self):
from DecisionsPlus import DecisionModelProxy
appl = 'COMVIK'
results = DecisionModelProxy.GetListFromKeywords(
Applicant__contains=appl)
self.assertEqual(len(results), 3)
for res in results:
self.assertIn(appl, res.Applicant)
def test_GetLatest(self):
from DecisionsPlus import DecisionModelProxy
result = DecisionModelProxy.GetLatest(3)
for index in range(0, 2):
this = result[index].DecisionDate
next = result[index + 1].DecisionDate
self.assertTrue(this >= next,
'this {} not <= next {}'.format(this, next))
self.assertEqual(result[0].DecisionDate.year, 2017)
def __init__(self):
super(IndexViewModel, self).__init__()
decisions = DecisionModelProxy.GetLatest(5)
self.Context.update( {
'decisions': decisions,
'title': 'Welcome',
} )
def test_GetListFromCaseNumber(self):
from DecisionsPlus import DecisionModelProxy
casenumber = 'T 0641/00'
casedate = datetime.strptime('26.09.2002', '%d.%m.%Y').date()
results = DecisionModelProxy.GetListFromKeywords(CaseNumber=casenumber)
self.assertEqual(len(results), 3)
for res in results:
self.assertEqual(res.CaseNumber, casenumber)
self.assertEqual(res.DecisionDate, casedate)
def test_GetAllForBoardOrderedByDecisionDate(self):
from DecisionsPlus import DecisionModelProxy
board = '3.5.07'
result = DecisionModelProxy.GetAllForBoardOrderedByDecisionDate(board)
for index in range(0, len(result) - 1):
this = result[index].DecisionDate
next = result[index + 1].DecisionDate
self.assertTrue(this <= next,
'this {} not <= next {}'.format(this, next))
def __decisionListFromPkString(string):
if not string:
return []
pkList = [int(x) for x in string.split(',')]
result = []
for pk in pkList:
decision = DecisionModelProxy.GetDecisionFromPrimaryKey(pk)
if decision:
result.append(decision)
return result
def test_GetAllForBoard(self):
from DecisionsPlus import DecisionModelProxy
board = '3.5.01'
result = DecisionModelProxy.GetAllForBoard(board)
casenumberlist = [x.CaseNumber for x in result]
casenumberset = set(casenumberlist)
self.assertTrue('T 0641/00' in casenumberset)
self.assertTrue('T 1411/08' in casenumberset)
for res in result:
self.assertEqual(res.Board, board)
def __init__(self):
super(DbStateViewModel, self).__init__()
earliest = DecisionModelProxy.GetEarliest()[0]
latest = DecisionModelProxy.GetLatest()[0]
self.Context.update ( {
'title':'About',
'GCount': DecisionModelProxy.GetCasetypeCount('G'),
'RCount': DecisionModelProxy.GetCasetypeCount('R'),
'JCount': DecisionModelProxy.GetCasetypeCount('J'),
'TCount': DecisionModelProxy.GetCasetypeCount('T'),
'WCount': DecisionModelProxy.GetCasetypeCount('W'),
'DCount': DecisionModelProxy.GetCasetypeCount('D'),
'TotalCount': DecisionModelProxy.GetBibliographyCount(),
'TotalTxtCount': DecisionModelProxy.GetTextCount(),
'Earliest': earliest,
'EarliestDate': earliest.DecisionDate,
'Latest': latest,
'LatestDate': latest.DecisionDate,
} )
def __extractResults(self):
self.__extractedResults = []
for sort in self.__sorts:
for result in self.__collatedResults[sort]:
decision = DecisionModelProxy.GetDecisionFromPrimaryKey(result)
extract = self.__getTextExtract(decision, sort)
self.__extractedResults.append(
TextSearchResult(
decision,
extract,
)
)
def decisionFromCaseNumber(request, cn):
"""Renders a single decision."""
assert isinstance(request, HttpRequest)
caseNumber = Formatters.formatCaseNumber(cn)
#decisions = DecisionModelProxy.GetListFromCaseNumber(caseNumber)
decisions = DecisionModelProxy.GetListFromKeywords(CaseNumber=caseNumber)
viewModel = DecisionVM.DecisionViewModel(decisions)
return render(
request,
'DecisionViewer/decision.html',
viewModel.Context,
)
def _analyseAndCache(self, board):
boardList = DecisionModelProxy.GetBoardList()
if board not in boardList:
return NullBoardTimelineAnalysis()
boardDecisions = DecisionModelProxy.GetAllForBoardOrderedByDecisionDate(
board)
if not boardDecisions:
return EmptyBoardTimelineAnalysis(board)
earliestDate = boardDecisions[0].DecisionDate
latestDate = boardDecisions[-1].DecisionDate
yearlyCases = {}
for year in DateHelpers.YearIterator(earliestDate, latestDate):
yearDecisions = [
x for x in boardDecisions if x.DecisionDate.year == year.year
]
yearCount = len(yearDecisions)
yearlyCases[year.year] = yearCount
result = BoardTimelineAnalysis(board, yearlyCases)
self._cache[board] = result
return result
def __getAllAnalyses_andEarliestAndLatestYears(self):
self.__boardList = DecisionModelProxy.GetBoardList()
self.__boardanalyses = {}
self.__timelines = {}
self.__earliest = date.max.year
self.__latest = date.min.year
for board in self.__boardList:
timeline = BoardTimelineAnalysisToDB.GetBoardTimelineAnalysisFromDB(
board)
self.__boardanalyses[board] = timeline
self.__timelines[board] = []
years = [year for year in timeline.YearlyDecisions]
self.__earliest = min(years + [self.__earliest])
self.__latest = max(years + [self.__latest])
def test_GetListFromTitle__contains(self):
from DecisionsPlus import DecisionModelProxy
word = 'identities'
results = DecisionModelProxy.GetListFromKeywords(Title__contains=word)
for res in results:
self.assertIn(word, res.Title)
def test_GetListFromFacts__contains(self):
from DecisionsPlus import DecisionModelProxy
word = 'identities'
results = DecisionModelProxy.GetListFromKeywords(Facts__contains=word)
for res in results:
self.assertIn(word, ' '.join(res.Facts))
def CitationFrequency(decisions):
result = {}
for decision in decisions:
#result[decision] = len(DecisionModelProxy.GetCitingCasesFromCaseNumber(decision.CaseNumber))
result[decision] = len(DecisionModelProxy.GetCitingCasesFromCaseNumber(decision.CaseNumber))
return result
def CitationFrequencyForBoard(board):
decisions = DecisionModelProxy.GetAllForBoard(board)
return CitationFrequency(decisions)
def RuleFrequencyForBoard(board):
decisions = DecisionModelProxy.GetAllForBoard(board)
return RuleFrequency(decisions)
def AttributeFrequencyForBoard(board):
decisions = DecisionModelProxy.GetAllForBoard(board)
return AttributeFrequency(decisions)
def test_GetListFromBadFacts__contains(self):
from DecisionsPlus import DecisionModelProxy
word = 'zzzzzzzz####'
results = DecisionModelProxy.GetListFromKeywords(Facts__contains=word)
self.assertEqual(len(results), 0)
def test_GetRepresenttiveFromBadCaseNumber(self):
from DecisionsPlus import DecisionModelProxy
cn = 'zzzzzzzz####'
result = DecisionModelProxy.GetRepresentativeForCaseNumber(cn)
self.assertEqual(result.CaseNumber, cn)
def __makeSetFromText(self, kw, term):
return {x.pk for x in DecisionModelProxy.GetListFromTextKeywords(**{kw + '__contains': term })}
