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 })}