scidash / sciunit / 608

pending completion

Build # 608

Build Type

Pull #143

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/scidash/sciunit/commit/<a class=hub.com/scidash/sciunit/commit/4cdf95009e87cae391ffea0b5310d2a2ee75f0bb">4cdf95009<a href="https://github.com/scidash/sciunit/commit/4cdf95009e87cae391ffea0b5310d2a2ee75f0bb">">Merge </a><a class="double-link" href="https://github.com/scidash/sciunit/commit/<a class="double-link" href="https://github.com/scidash/sciunit/commit/a34fac317c9b09c3d516238cabda5e99a8cec907">a34fac317</a>">a34fac317</a><a href="https://github.com/scidash/sciunit/commit/4cdf95009e87cae391ffea0b5310d2a2ee75f0bb"> into 1b8bef6e9">1b8bef6e9</a>

Pull Request Pull Request #143: Add Most Type Hints

Run Details

307 of 307 new or added lines in 18 files covered. (100.0%)

1598 of 2144 relevant lines covered (74.53%)

2.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.22

/sciunit/scores/collections.py

"""SciUnit score collections, such as arrays and matrices.

These collections allow scores to be organized and visualized
by model, test, or both.
"""

from datetime import datetime
import warnings

import numpy as np
import pandas as pd
import bs4
from IPython.display import display, Javascript

from sciunit.base import SciUnit, TestWeighted
from sciunit.models import Model
from sciunit.tests import Test
from sciunit.scores import Score, NoneScore
from typing import Union, Tuple, List

class ScoreArray(pd.Series, SciUnit,TestWeighted):
    """Represents an array of scores derived from a test suite.

    Extends the pandas Series such that items are either
    models subject to a test or tests taken by a model.
    Also displays and compute score summaries in sciunit-specific ways.

    Can use like this, assuming n tests and m models:

    >>> sm[test]

    >>> sm[test]
    (score_1, ..., score_m)
    >>> sm[model]
    (score_1, ..., score_n)
    """

    def __init__(self, tests_or_models, scores=None, weights=None):
        if scores is None:
            scores = [NoneScore for tom in tests_or_models]
        tests_or_models = self.check_tests_and_models(tests_or_models)
        self.weights_ = [] if not weights else list(weights)
        super(ScoreArray, self).__init__(data=scores, index=tests_or_models)
        self.index_type = 'tests' if isinstance(tests_or_models[0], Test) \
                          else 'models'
        setattr(self, self.index_type, tests_or_models)

    direct_attrs = ['score', 'norm_scores', 'related_data']

    def check_tests_and_models(self, tests_or_models: Union[Test, Model]) -> Union[Test, Model]:
        assert all([isinstance(tom, Test) for tom in tests_or_models]) or \
               all([isinstance(tom, Model) for tom in tests_or_models]), \
               "A ScoreArray may be indexed by only test or models"
        return tests_or_models

    def __getitem__(self, item):
        if isinstance(item, str):
            result = self.get_by_name(item)
        else:
            result = super(ScoreArray, self).__getitem__(item)
        return result

    def get_by_name(self, name: str) -> Union[Model, Test]:
        """Get a test or a model by `name`.

        Args:
            name (str): The name of the model or test.

        Raises:
            KeyError: No model or test with name `name`.

        Returns:
            Union[Model, Test]: The model or test found.
        """
        item = None
        for test_or_model in self.index:
            if test_or_model.name == name:
                item = self.__getitem__(test_or_model)
        if item is None:
            raise KeyError("No model or test with name '%s'" % item)
        return item

    def __getattr__(self, name):
        if name in self.direct_attrs:
            attr = self.apply(lambda x: getattr(x, name))
        else:
            attr = super(ScoreArray, self).__getattribute__(name)
        return attr

    @property
    def norm_scores(self) -> float:
        """Return the `norm_score` for each test.

        Returns:
            float: The `norm_score` for each test.
        """
        return self.map(lambda x: x.norm_score)

    def mean(self) -> float:
        """Compute a total score for each model over all the tests.

        Uses the `norm_score` attribute, since otherwise direct comparison
        across different kinds of scores would not be possible.

        Returns:
            float: The computed total score for each model over all the tests.
        """

        return np.dot(np.array(self.norm_scores), self.weights)

    def stature(self, test_or_model: Union[Model, Test]) -> int:
        """Compute the relative rank of a model on a test.

        Rank is against other models that were asked to take the test.

        Args:
            test_or_model (Union[Model, Test]): [description]

        Returns:
            int: [description]
        """
        return self.norm_scores.rank(ascending=False)[test_or_model]


class ScoreMatrix(pd.DataFrame, SciUnit, TestWeighted):
    """ Represents a matrix of scores derived from a test suite.
    Extends the pandas DataFrame such that tests are columns and models
    are the index. Also displays and compute score summaries in sciunit-specific ways.

    Can use like this, assuming n tests and m models:

    >>> sm[test]

    >>> sm[test]
    (score_1, ..., score_m)
    >>> sm[model]
    (score_1, ..., score_n)

    Args:
        pd ([type]): [description]
        SciUnit ([type]): [description]
        TestWeighted ([type]): [description]
    """

    def __init__(self, tests, models,
                 scores=None, weights=None, transpose=False):
        tests, models, scores = self.check_tests_models_scores(
                                                    tests, models, scores)
        if transpose:
            super(ScoreMatrix, self).__init__(data=scores.T, index=tests,
                                              columns=models)
        else:
            super(ScoreMatrix, self).__init__(data=scores, index=models,
                                              columns=tests)
        with warnings.catch_warnings():
            warnings.filterwarnings("ignore",
                                    message=(".*Pandas doesn't allow columns "
                                             "to be created via a new "))
            self.tests = tests
            self.models = models
            self.weights_ = [] if not weights else list(weights)
            self.transposed = transpose

    show_mean = False
    sortable = False
    direct_attrs = ['score', 'norm_scores', 'related_data']

    def check_tests_models_scores(self, tests: List[Test], models: List[Model], scores: List[Score]) \
        -> Tuple[List[Test], List[Model], List[Score]]:
        """[summary]

        Args:
            tests (List[Test]): [description]
            models (List[Model]): [description]
            scores (List[Score]): [description]

        Returns:
            Tuple[List[Test], List[Model], List[Score]]: [description]
        """
        if isinstance(tests, Test):
            tests = [tests]
        if isinstance(models, Model):
            models = [models]
        if scores is None:
            scores = [[NoneScore for test in tests] for model in models]
        return tests, models, scores

    def __getitem__(self, item):
        if isinstance(item, Test):
            return self.get_test(item)
        elif isinstance(item, Model):
            return self.get_model(item)
        elif isinstance(item, str):
            return self.get_by_name(item)
        elif isinstance(item, (list, tuple)) and len(item) == 2:
            return self.get_group(item)
        raise TypeError("Expected test; model; test,model; or model,test")

    def get_test(self, test: Test) -> ScoreArray:
        """Generate a `ScoreArray` instance with all models and the `test`.

        Args:
            test (Test): The test that will be included in the `ScoreArray` instance.

        Returns:
            ScoreArray: The generated ScoreArray instance.
        """
        return ScoreArray(self.models,
                          scores=super(ScoreMatrix, self).__getitem__(test),
                          weights=self.weights)

    def get_model(self, model: Model) -> ScoreArray:
        """Generate a `ScoreArray` instance with all tests and the `model`.

        Args:
            model (Model): The model that will be included in the `ScoreArray` instance.

        Returns:
            ScoreArray: The generated ScoreArray instance.
        """
        return ScoreArray(self.tests,
                          scores=self.loc[model, :],
                          weights=self.weights)

    def get_group(self, x: Tuple[Union[Test, Model]]) -> Union[Test, Model]:
        """[summary]

        Args:
            x (Tuple[Union[Test, Model]]): [description]

        Raises:
            TypeError: [description]

        Returns:
            Union[Test, Model]: [description]
        """
        t = int(bool(self.transposed))
        if isinstance(x[0], Test) and isinstance(x[1], Model):
            result = self.loc[x[1-t], x[t]]
        elif isinstance(x[1], Test) and isinstance(x[0], Model):
            result = self.loc[x[t], x[1-t]]
        elif isinstance(x[0], str):
            result = self.__getitem__(x[t]).__getitem__(x[1-t])
        else:
            raise TypeError("Expected test,model or model,test")
        return result

    def get_by_name(self, name: str) -> Union[Model, Test]:
        """Get a model or a test from the model or test list by `name`.

        Args:
            name (str): The name of the test or model.

        Raises:
            KeyError: No model or test found by `name`.

        Returns:
            Union[Model, Test]: The model or test found.
        """
        for model in self.models:
            if model.name == name:
                return self.__getitem__(model)
        for test in self.tests:
            if test.name == name:
                return self.__getitem__(test)
        raise KeyError("No model or test with name '%s'" % name)

    def __getattr__(self, name):
        if name in self.direct_attrs:
            attr = self.applymap(lambda x: getattr(x, name))
        else:
            attr = super(ScoreMatrix, self).__getattribute__(name)
        return attr

    @property
    def norm_scores(self) -> pd.DataFrame:
        """[summary]

        Returns:
            DaraFrame: [description]
        """
        return self.applymap(lambda x: x.norm_score)

    def stature(self, test: Test, model: Model):
        """Computes the relative rank of a model on a test compared to other models that were asked to take the test.

        Args:
            test (Test): [description]
            model (Model): [description]

        Returns:
            [type]: [description]
        """

        return self[test].stature(model)

    @property
    def T(self) -> "ScoreMatrix":
        """Get transpose of this ScoreMatrix.

        Returns:
            ScoreMatrix: [description]
        """
        return ScoreMatrix(self.tests, self.models, scores=self.values,
                           weights=self.weights, transpose=True)

    def to_html(self, show_mean: bool=None, sortable: bool=None, colorize: bool=True, *args,
                **kwargs) -> str:
        """Extend Pandas built in `to_html` method for rendering a DataFrame and use it to render a ScoreMatrix.

        Args:
            show_mean (bool, optional): [description]. Defaults to None.
            sortable (bool, optional): [description]. Defaults to None.
            colorize (bool, optional): [description]. Defaults to True.

        Returns:
            str: [description]
        """
        if show_mean is None:
            show_mean = self.show_mean
        if sortable is None:
            sortable = self.sortable
        df = self.copy()
        if show_mean:
            df.insert(0, 'Mean', None)
            df.loc[:, 'Mean'] = ['%.3f' % self[m].mean() for m in self.models]
        html = df.to_html(*args, **kwargs)  # Pandas method
        html, table_id = self.annotate(df, html, show_mean, colorize)
        if sortable:
            self.dynamify(table_id)
        return html

    def annotate(self, df: pd.DataFrame, html: str, show_mean: bool, colorize: bool) -> Tuple[str, int]:
        """[summary]

        Args:
            df (DataFrame): [description]
            html (str): [description]
            show_mean (bool): [description]
            colorize (bool): [description]

        Returns:
            Tuple[str, int]: [description]
        """
        soup = bs4.BeautifulSoup(html, "lxml")
        if colorize:
            self.annotate_headers(soup, df, show_mean)
            self.annotate_body(soup, df, show_mean)
        table = soup.find('table')
        table_id = table['id'] = hash(datetime.now())
        html = str(soup)
        return html, table_id

    def annotate_headers(self, soup: bs4.BeautifulSoup, df: pd.DataFrame, show_mean: bool) -> None:
        """[summary]

        Args:
            soup ([type]): [description]
            df (DataFrame): [description]
            show_mean (bool): [description]
        """
        for i, row in enumerate(soup.find('thead').findAll('tr')):
            for j, cell in enumerate(row.findAll('th')[1:]):
                self.annotate_header_cell(cell, df, show_mean, i, j)

    def annotate_header_cell(self, cell, df: pd.DataFrame, show_mean: bool, i: int, j: int) -> None:
        """[summary]

        Args:
            cell ([type]): [description]
            df (DataFrame): [description]
            show_mean (bool): [description]
            i (int): [description]
            j (int): [description]
        """
        if show_mean and j == 0:
            self.annotate_mean(cell, df, i)
        else:
            j_ = j-bool(show_mean)
            test = self.tests[j_]
            cell['title'] = test.description
        # Remove ' test' from column headers
        if cell.string[-5:] == ' test':
            cell.string = cell.string[:-5]

    def annotate_body(self, soup: bs4.BeautifulSoup, df: pd.DataFrame, show_mean: bool) -> None:
        """[summary]

        Args:
            soup (BeautifulSoup): [description]
            df (DataFrame): [description]
            show_mean (bool): [description]
        """
        for i, row in enumerate(soup.find('tbody').findAll('tr')):
            cell = row.find('th')
            if self.transposed:
                cell['title'] = self.tests[i].describe()
            else:
                cell['title'] = self.models[i].describe()
            for j, cell in enumerate(row.findAll('td')):
                self.annotate_body_cell(cell, df, show_mean, i, j)

    def annotate_body_cell(self, cell, df: pd.DataFrame, show_mean: bool, i: int, j: int) -> None:
        """[summary]

        Args:
            cell ([type]): [description]
            df (DataFrame): [description]
            show_mean (bool): [description]
            i (int): [description]
            j (int): [description]
        """
        if show_mean and j == 0:
            value = self.annotate_mean(cell, df, i)
        else:
            j_ = j-bool(show_mean)
            if self.transposed:
                score = self[self.models[j_], self.tests[i]]
            else:
                score = self[self.models[i], self.tests[j_]]
            value = score.norm_score
            cell['title'] = score.describe(quiet=True)
        rgb = Score.value_color(value)
        cell['style'] = 'background-color: rgb(%d,%d,%d);' % rgb

    def annotate_mean(self, cell, df: pd.DataFrame, i: int) -> float:
        """[summary]

        Args:
            cell ([type]): [description]
            df (DataFrame): [description]
            i (int): [description]

        Returns:
            float: [description]
        """
        value = float(df.loc[self.models[i], 'Mean'])
        cell['title'] = 'Mean sort key value across tests'
        return value

    def dynamify(self, table_id: str) -> None:
        """[summary]

        Args:
            table_id ([type]): [description]
        """
        prefix = "//ajax.aspnetcdn.com/ajax/jquery.dataTables/1.9.0"
        js = Javascript("$('#%s').dataTable();" % table_id,
                        lib=["%s/jquery.dataTables.min.js" % prefix],
                        css=["%s/css/jquery.dataTables.css" % prefix])
        display(js)

1	"""SciUnit score collections, such as arrays and matrices.
2
3	These collections allow scores to be organized and visualized
4	by model, test, or both.
5	"""
6
7	from datetime import datetime	4✔
8	import warnings	4✔
9
10	import numpy as np	4✔
11	import pandas as pd	4✔
12	import bs4	4✔
13	from IPython.display import display, Javascript	4✔
14
15	from sciunit.base import SciUnit, TestWeighted	4✔
16	from sciunit.models import Model	4✔
17	from sciunit.tests import Test	4✔
18	from sciunit.scores import Score, NoneScore	4✔
19	from typing import Union, Tuple, List	4✔
20
21	class ScoreArray(pd.Series, SciUnit,TestWeighted):	4✔
22	"""Represents an array of scores derived from a test suite.
23
24	Extends the pandas Series such that items are either
25	models subject to a test or tests taken by a model.
26	Also displays and compute score summaries in sciunit-specific ways.
27
28	Can use like this, assuming n tests and m models:
29
30	>>> sm[test]
31
32	>>> sm[test]
33	(score_1, ..., score_m)
34	>>> sm[model]
35	(score_1, ..., score_n)
36	"""
37
38	def __init__(self, tests_or_models, scores=None, weights=None):	4✔
39	if scores is None:	4✔
40	scores = [NoneScore for tom in tests_or_models]	×
41	tests_or_models = self.check_tests_and_models(tests_or_models)	4✔
42	self.weights_ = [] if not weights else list(weights)	4✔
43	super(ScoreArray, self).__init__(data=scores, index=tests_or_models)	4✔
44	self.index_type = 'tests' if isinstance(tests_or_models[0], Test) \	4✔
45	else 'models'
46	setattr(self, self.index_type, tests_or_models)	4✔
47
48	direct_attrs = ['score', 'norm_scores', 'related_data']	4✔
49
50	def check_tests_and_models(self, tests_or_models: Union[Test, Model]) -> Union[Test, Model]:	4✔
51	assert all([isinstance(tom, Test) for tom in tests_or_models]) or \	4✔
52	all([isinstance(tom, Model) for tom in tests_or_models]), \
53	"A ScoreArray may be indexed by only test or models"
54	return tests_or_models	4✔
55
56	def __getitem__(self, item):	4✔
57	if isinstance(item, str):	4✔
58	result = self.get_by_name(item)	4✔
59	else:
60	result = super(ScoreArray, self).__getitem__(item)	4✔
61	return result	4✔
62
63	def get_by_name(self, name: str) -> Union[Model, Test]:	4✔
64	"""Get a test or a model by `name`.
65
66	Args:
67	name (str): The name of the model or test.
68
69	Raises:
70	KeyError: No model or test with name `name`.
71
72	Returns:
73	Union[Model, Test]: The model or test found.
74	"""
75	item = None	4✔
76	for test_or_model in self.index:	4✔
77	if test_or_model.name == name:	4✔
78	item = self.__getitem__(test_or_model)	4✔
79	if item is None:	4✔
80	raise KeyError("No model or test with name '%s'" % item)	×
81	return item	4✔
82
83	def __getattr__(self, name):	4✔
84	if name in self.direct_attrs:	4✔
85	attr = self.apply(lambda x: getattr(x, name))	×
86	else:
87	attr = super(ScoreArray, self).__getattribute__(name)	4✔
88	return attr	×
89
90	@property	4✔
91	def norm_scores(self) -> float:	4✔
92	"""Return the `norm_score` for each test.
93
94	Returns:
95	float: The `norm_score` for each test.
96	"""
97	return self.map(lambda x: x.norm_score)	4✔
98
99	def mean(self) -> float:	4✔
100	"""Compute a total score for each model over all the tests.
101
102	Uses the `norm_score` attribute, since otherwise direct comparison
103	across different kinds of scores would not be possible.
104
105	Returns:
106	float: The computed total score for each model over all the tests.
107	"""
108
109	return np.dot(np.array(self.norm_scores), self.weights)	×
110
111	def stature(self, test_or_model: Union[Model, Test]) -> int:	4✔
112	"""Compute the relative rank of a model on a test.
113
114	Rank is against other models that were asked to take the test.
115
116	Args:
117	test_or_model (Union[Model, Test]): [description]
118
119	Returns:
120	int: [description]
121	"""
122	return self.norm_scores.rank(ascending=False)[test_or_model]	4✔
123
124
125	class ScoreMatrix(pd.DataFrame, SciUnit, TestWeighted):	4✔
126	""" Represents a matrix of scores derived from a test suite.
127	Extends the pandas DataFrame such that tests are columns and models
128	are the index. Also displays and compute score summaries in sciunit-specific ways.
129
130	Can use like this, assuming n tests and m models:
131
132	>>> sm[test]
133
134	>>> sm[test]
135	(score_1, ..., score_m)
136	>>> sm[model]
137	(score_1, ..., score_n)
138
139	Args:
140	pd ([type]): [description]
141	SciUnit ([type]): [description]
142	TestWeighted ([type]): [description]
143	"""
144
145	def __init__(self, tests, models,	4✔
146	scores=None, weights=None, transpose=False):
147	tests, models, scores = self.check_tests_models_scores(	4✔
148	tests, models, scores)
149	if transpose:	4✔
150	super(ScoreMatrix, self).__init__(data=scores.T, index=tests,	×
151	columns=models)
152	else:
153	super(ScoreMatrix, self).__init__(data=scores, index=models,	4✔
154	columns=tests)
155	with warnings.catch_warnings():	4✔
156	warnings.filterwarnings("ignore",	4✔
157	message=(".*Pandas doesn't allow columns "
158	"to be created via a new "))
159	self.tests = tests	4✔
160	self.models = models	4✔
161	self.weights_ = [] if not weights else list(weights)	4✔
162	self.transposed = transpose	4✔
163
164	show_mean = False	4✔
165	sortable = False	4✔
166	direct_attrs = ['score', 'norm_scores', 'related_data']	4✔
167
168	def check_tests_models_scores(self, tests: List[Test], models: List[Model], scores: List[Score]) \	4✔
169	-> Tuple[List[Test], List[Model], List[Score]]:
170	"""[summary]
171
172	Args:
173	tests (List[Test]): [description]
174	models (List[Model]): [description]
175	scores (List[Score]): [description]
176
177	Returns:
178	Tuple[List[Test], List[Model], List[Score]]: [description]
179	"""
180	if isinstance(tests, Test):	4✔
181	tests = [tests]	×
182	if isinstance(models, Model):	4✔
183	models = [models]	×
184	if scores is None:	4✔
185	scores = [[NoneScore for test in tests] for model in models]	4✔
186	return tests, models, scores	4✔
187
188	def __getitem__(self, item):	4✔
189	if isinstance(item, Test):	4✔
190	return self.get_test(item)	4✔
191	elif isinstance(item, Model):	4✔
192	return self.get_model(item)	4✔
193	elif isinstance(item, str):	4✔
194	return self.get_by_name(item)	4✔
195	elif isinstance(item, (list, tuple)) and len(item) == 2:	4✔
196	return self.get_group(item)	4✔
197	raise TypeError("Expected test; model; test,model; or model,test")	×
198
199	def get_test(self, test: Test) -> ScoreArray:	4✔
200	"""Generate a `ScoreArray` instance with all models and the `test`.
201
202	Args:
203	test (Test): The test that will be included in the `ScoreArray` instance.
204
205	Returns:
206	ScoreArray: The generated ScoreArray instance.
207	"""
208	return ScoreArray(self.models,	4✔
209	scores=super(ScoreMatrix, self).__getitem__(test),
210	weights=self.weights)
211
212	def get_model(self, model: Model) -> ScoreArray:	4✔
213	"""Generate a `ScoreArray` instance with all tests and the `model`.
214
215	Args:
216	model (Model): The model that will be included in the `ScoreArray` instance.
217
218	Returns:
219	ScoreArray: The generated ScoreArray instance.
220	"""
221	return ScoreArray(self.tests,	4✔
222	scores=self.loc[model, :],
223	weights=self.weights)
224
225	def get_group(self, x: Tuple[Union[Test, Model]]) -> Union[Test, Model]:	4✔
226	"""[summary]
227
228	Args:
229	x (Tuple[Union[Test, Model]]): [description]
230
231	Raises:
232	TypeError: [description]
233
234	Returns:
235	Union[Test, Model]: [description]
236	"""
237	t = int(bool(self.transposed))	4✔
238	if isinstance(x[0], Test) and isinstance(x[1], Model):	4✔
239	result = self.loc[x[1-t], x[t]]	×
240	elif isinstance(x[1], Test) and isinstance(x[0], Model):	4✔
241	result = self.loc[x[t], x[1-t]]	4✔
242	elif isinstance(x[0], str):	×
243	result = self.__getitem__(x[t]).__getitem__(x[1-t])	×
244	else:
245	raise TypeError("Expected test,model or model,test")	×
246	return result	4✔
247
248	def get_by_name(self, name: str) -> Union[Model, Test]:	4✔
249	"""Get a model or a test from the model or test list by `name`.
250
251	Args:
252	name (str): The name of the test or model.
253
254	Raises:
255	KeyError: No model or test found by `name`.
256
257	Returns:
258	Union[Model, Test]: The model or test found.
259	"""
260	for model in self.models:	4✔
261	if model.name == name:	4✔
262	return self.__getitem__(model)	×
263	for test in self.tests:	4✔
264	if test.name == name:	4✔
265	return self.__getitem__(test)	4✔
266	raise KeyError("No model or test with name '%s'" % name)	×
267
268	def __getattr__(self, name):	4✔
269	if name in self.direct_attrs:	4✔
270	attr = self.applymap(lambda x: getattr(x, name))	×
271	else:
272	attr = super(ScoreMatrix, self).__getattribute__(name)	4✔
273	return attr	×
274
275	@property	4✔
276	def norm_scores(self) -> pd.DataFrame:	4✔
277	"""[summary]
278
279	Returns:
280	DaraFrame: [description]
281	"""
282	return self.applymap(lambda x: x.norm_score)	×
283
284	def stature(self, test: Test, model: Model):	4✔
285	"""Computes the relative rank of a model on a test compared to other models that were asked to take the test.
286
287	Args:
288	test (Test): [description]
289	model (Model): [description]
290
291	Returns:
292	[type]: [description]
293	"""
294
295	return self[test].stature(model)	4✔
296
297	@property	4✔
298	def T(self) -> "ScoreMatrix":	4✔
299	"""Get transpose of this ScoreMatrix.
300
301	Returns:
302	ScoreMatrix: [description]
303	"""
304	return ScoreMatrix(self.tests, self.models, scores=self.values,	×
305	weights=self.weights, transpose=True)
306
307	def to_html(self, show_mean: bool=None, sortable: bool=None, colorize: bool=True, *args,	4✔
308	**kwargs) -> str:
309	"""Extend Pandas built in `to_html` method for rendering a DataFrame and use it to render a ScoreMatrix.
310
311	Args:
312	show_mean (bool, optional): [description]. Defaults to None.
313	sortable (bool, optional): [description]. Defaults to None.
314	colorize (bool, optional): [description]. Defaults to True.
315
316	Returns:
317	str: [description]
318	"""
319	if show_mean is None:	×
320	show_mean = self.show_mean	×
321	if sortable is None:	×
322	sortable = self.sortable	×
323	df = self.copy()	×
324	if show_mean:	×
325	df.insert(0, 'Mean', None)	×
326	df.loc[:, 'Mean'] = ['%.3f' % self[m].mean() for m in self.models]	×
327	html = df.to_html(args, *kwargs) # Pandas method	×
328	html, table_id = self.annotate(df, html, show_mean, colorize)	×
329	if sortable:	×
330	self.dynamify(table_id)	×
331	return html	×
332
333	def annotate(self, df: pd.DataFrame, html: str, show_mean: bool, colorize: bool) -> Tuple[str, int]:	4✔
334	"""[summary]
335
336	Args:
337	df (DataFrame): [description]
338	html (str): [description]
339	show_mean (bool): [description]
340	colorize (bool): [description]
341
342	Returns:
343	Tuple[str, int]: [description]
344	"""
345	soup = bs4.BeautifulSoup(html, "lxml")	×
346	if colorize:	×
347	self.annotate_headers(soup, df, show_mean)	×
348	self.annotate_body(soup, df, show_mean)	×
349	table = soup.find('table')	×
350	table_id = table['id'] = hash(datetime.now())	×
351	html = str(soup)	×
352	return html, table_id	×
353
354	def annotate_headers(self, soup: bs4.BeautifulSoup, df: pd.DataFrame, show_mean: bool) -> None:	4✔
355	"""[summary]
356
357	Args:
358	soup ([type]): [description]
359	df (DataFrame): [description]
360	show_mean (bool): [description]
361	"""
362	for i, row in enumerate(soup.find('thead').findAll('tr')):	×
363	for j, cell in enumerate(row.findAll('th')[1:]):	×
364	self.annotate_header_cell(cell, df, show_mean, i, j)	×
365
366	def annotate_header_cell(self, cell, df: pd.DataFrame, show_mean: bool, i: int, j: int) -> None:	4✔
367	"""[summary]
368
369	Args:
370	cell ([type]): [description]
371	df (DataFrame): [description]
372	show_mean (bool): [description]
373	i (int): [description]
374	j (int): [description]
375	"""
376	if show_mean and j == 0:	×
377	self.annotate_mean(cell, df, i)	×
378	else:
379	j_ = j-bool(show_mean)	×
380	test = self.tests[j_]	×
381	cell['title'] = test.description	×
382	# Remove ' test' from column headers
383	if cell.string[-5:] == ' test':	×
384	cell.string = cell.string[:-5]	×
385
386	def annotate_body(self, soup: bs4.BeautifulSoup, df: pd.DataFrame, show_mean: bool) -> None:	4✔
387	"""[summary]
388
389	Args:
390	soup (BeautifulSoup): [description]
391	df (DataFrame): [description]
392	show_mean (bool): [description]
393	"""
394	for i, row in enumerate(soup.find('tbody').findAll('tr')):	×
395	cell = row.find('th')	×
396	if self.transposed:	×
397	cell['title'] = self.tests[i].describe()	×
398	else:
399	cell['title'] = self.models[i].describe()	×
400	for j, cell in enumerate(row.findAll('td')):	×
401	self.annotate_body_cell(cell, df, show_mean, i, j)	×
402
403	def annotate_body_cell(self, cell, df: pd.DataFrame, show_mean: bool, i: int, j: int) -> None:	4✔
404	"""[summary]
405
406	Args:
407	cell ([type]): [description]
408	df (DataFrame): [description]
409	show_mean (bool): [description]
410	i (int): [description]
411	j (int): [description]
412	"""
413	if show_mean and j == 0:	×
414	value = self.annotate_mean(cell, df, i)	×
415	else:
416	j_ = j-bool(show_mean)	×
417	if self.transposed:	×
418	score = self[self.models[j_], self.tests[i]]	×
419	else:
420	score = self[self.models[i], self.tests[j_]]	×
421	value = score.norm_score	×
422	cell['title'] = score.describe(quiet=True)	×
423	rgb = Score.value_color(value)	×
424	cell['style'] = 'background-color: rgb(%d,%d,%d);' % rgb	×
425
426	def annotate_mean(self, cell, df: pd.DataFrame, i: int) -> float:	4✔
427	"""[summary]
428
429	Args:
430	cell ([type]): [description]
431	df (DataFrame): [description]
432	i (int): [description]
433
434	Returns:
435	float: [description]
436	"""
437	value = float(df.loc[self.models[i], 'Mean'])	×
438	cell['title'] = 'Mean sort key value across tests'	×
439	return value	×
440
441	def dynamify(self, table_id: str) -> None:	4✔
442	"""[summary]
443
444	Args:
445	table_id ([type]): [description]
446	"""
447	prefix = "//ajax.aspnetcdn.com/ajax/jquery.dataTables/1.9.0"	×
448	js = Javascript("$('#%s').dataTable();" % table_id,	×
449	lib=["%s/jquery.dataTables.min.js" % prefix],
450	css=["%s/css/jquery.dataTables.css" % prefix])
451	display(js)	×

scidash / sciunit / 608

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous