9646694207

Committed 24 Jun 2024 01:57PM UTC coverage: 88.657% (-0.04%) from 88.695%

Build # 9646694207

Build Type

push

github

Committed by

GuyTeichman

Commit Message

* Added additional optional parameters to automatic report generation.

Run Details

15917 of 18660 branches covered (85.3%)

Branch coverage included in aggregate %.

25 of 42 new or added lines in 2 files covered. (59.52%)

7 existing lines in 3 files now uncovered.

13840 of 14904 relevant lines covered (92.86%)

7.42 hits per line

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

85.53

/rnalysis/gui/gui_report.py

import itertools
import json
import re
import shutil
import typing
import webbrowser
from pathlib import Path
from typing import Literal, Union

import networkx
from pyvis.network import Network

from rnalysis import __version__
from rnalysis.gui import gui_windows
from rnalysis.utils import parsing, io


class Node:
    __slots__ = ('_node_id', '_node_name', '_predecessors', '_is_active', '_popup_element', '_node_type', '_filename')
    DATA_TYPES = {'Count matrix', 'Differential expression', 'Fold change', 'Other table', 'Gene set', 'Other output',
                  'Pipeline'}

    def __init__(self, node_id: int, node_name: str, predecessors: list, popup_element: str, node_type: str,
                 filename: str = None):
        self._node_id = node_id
        self._node_name = node_name
        self._predecessors = parsing.data_to_set(predecessors)
        self._popup_element = popup_element
        self._node_type = node_type
        self._is_active = True
        self._filename = None if filename is None else Path(filename)
        if node_type in self.DATA_TYPES:
            self._node_name += f' (#{node_id})'

    def to_json(self):
        # Convert the Node object to a JSON-compatible dictionary
        data = {
            "node_id": self.node_id,
            "node_name": self.node_name,
            "predecessors": parsing.data_to_list(self.predecessors),
            "popup_element": self.popup_element,
            "node_type": self.node_type,
            "filename": str(self.filename) if self.filename else None
        }
        return json.dumps(data)

    @classmethod
    def from_json(cls, json_str):
        # Convert the JSON string back to a dictionary
        data = json.loads(json_str)
        # Create a new Node object using the dictionary
        return cls(
            node_id=data["node_id"],
            node_name=data["node_name"],
            predecessors=parsing.data_to_set(data["predecessors"]),
            popup_element=data["popup_element"],
            node_type=data["node_type"],
            filename=Path(data["filename"]) if data["filename"] else None
        )

    @property
    def node_id(self) -> int:
        return self._node_id

    @property
    def node_name(self) -> str:
        return self._node_name

    @property
    def predecessors(self) -> typing.Set[int]:
        return self._predecessors

    @property
    def popup_element(self) -> str:
        return self._popup_element

    @property
    def node_type(self) -> str:
        return self._node_type

    @property
    def is_active(self) -> bool:
        return self._is_active

    @property
    def filename(self) -> typing.Union[None, Path]:
        return self._filename

    def set_active(self, is_active: bool):
        self._is_active = is_active

    def add_predecessor(self, pred: int):
        self._predecessors.add(pred)

    def update_filename(self, filename: typing.Union[None, Path]):
        self._filename = filename


class ReportGenerator:
    __slots__ = ('graph', 'nodes')
    CSS_TEMPLATE_PATHS = [Path(__file__).parent.parent.joinpath('data_files/report_templates/vis-network.min.css'),
                          Path(__file__).parent.parent.joinpath('data_files/report_templates/bootstrap.min.css')]
    JS_TEMPLATE_PATHS = [Path(__file__).parent.parent.joinpath('data_files/report_templates/vis-network.min.js'),
                         Path(__file__).parent.parent.joinpath('data_files/report_templates/bootstrap.bundle.min.js')]
    NODE_GROUPS = {'root': 'root',
                   'Count matrix': 'count',
                   'Differential expression': 'diffexp',
                   'Fold change': 'foldchange',
                   'Other table': 'table',
                   'Gene set': 'geneset',
                   'Function': 'function',
                   'Other output': 'other',
                   'Pipeline': 'pipeline'}
    ROOT_FNAME = 'session.rnal'
    TITLE = f"Data analysis report (<i>RNAlysis</i> version {__version__})"

    def __init__(self):
        self.graph = networkx.DiGraph()
        self.nodes: typing.Dict[int, Node] = {}
        self.create_legend()
        href = Path('data').joinpath(self.ROOT_FNAME).as_posix()
        root_desc = f'<a href="{href}" target="_blank" rel="noopener noreferrer">Open RNAlysis session</a>'
        self.add_node('Started RNAlysis session', 0, [], root_desc, node_type='root', filename=self.ROOT_FNAME)

    def create_legend(self):
        x = -750
        y = -350
        step = 75
        for node_type, group_id in self.NODE_GROUPS.items():
            if node_type in {'root'}:
                continue
            self.graph.add_node(node_type, group=group_id, is_legend=True, label=node_type.capitalize(), fixed=True,
                                physics=False, x=x, y=y, font={'size': 16}, widthConstraint=100, shape=None)
            y += step

    def add_node(self, name: str, node_id: int, predecessors: typing.List[int] = tuple(), popup_element: str = '',
                 node_type: Literal[tuple(NODE_GROUPS)] = 'Other table', filename: str = None):
        # parentless nodes should be attached to the root node
        if len(predecessors) == 0 and node_id > 0:
            predecessors = [0]

        if node_id in self.nodes:
            if self.nodes[node_id].is_active:
                return
            node = self.nodes[node_id]
            node.set_active(True)

            for pred in predecessors:
                if not self.nodes[pred].is_active:
                    self.add_node('', pred)
        else:
            node = Node(node_id, name, predecessors, popup_element, node_type, filename)
            self.nodes[node_id] = node
        group_id = self.NODE_GROUPS[node.node_type]
        self.graph.add_node(node.node_id, label=node.node_name, title=node.popup_element, group=group_id, shape=None)
        for pred in predecessors:
            self.graph.add_edge(pred, node_id)

    def trim_node(self, node_id: int):
        """
        Removes a node from the report graph if it is a leaf node with no outgoing edges, \
        and trims any of its predecessors that are of type 'Function' and are also now leaf nodes.

        :param node_id: The ID of the node to be trimmed.
        :type node_id: int

        This method checks if the specified node is present in the report graph, and if it is a leaf node \
        with no outgoing edges. If both conditions are met, the node is removed from the graph, \
        its corresponding `ReportNode` object is set to inactive, and any of its predecessors that are of type \
        'Function' are recursively checked to see if they are now leaf nodes themselves (i.e., have no outgoing edges).\
         If a predecessor is a leaf node, it is also trimmed from the graph and marked as inactive.

        This method is used for pruning the report graph of unnecessary nodes when a tab is closed \
        or an action is undone.
            """
        if node_id in self.graph and self.graph.out_degree(node_id) == 0:
            predecessors = self.graph.predecessors(node_id)
            self.graph.remove_node(node_id)
            self.nodes[node_id].set_active(False)
            for pred in predecessors:
                if self.nodes[pred].node_type == 'Function':
                    self.trim_node(pred)

    def _modify_html(self, html: str, title: str, title_fontsize: int) -> str:
        # remove duplicate title
        title = self.TITLE if title == 'auto' else title
        if html.count(title) > 1:
            html = re.sub(r'<center>.+?<\/h1>\s+<\/center>', '', html, 1, re.DOTALL)
        # set title font size
        fontsize_em = title_fontsize / 16
        html = html.replace('<h1>', f'<h1 style="font-size:{fontsize_em}em;">')
        # remove comments from file
        comment_regex = r"<!--[\s\S]*?-->"
        html = re.sub(comment_regex, "", html)
        # set CSS templates to the correct paths (local version under "assets")
        for css_pth in self.CSS_TEMPLATE_PATHS:
            css_line = f'<link rel="stylesheet" href="assets/{css_pth.name}"/>'
            html = re.sub(r'<link(?:\s+[\w-]+="[^"]*")*\s+href="[^"]+"\s+(?:[\w-]+="[^"]*"\s+)*?\/>', css_line, html, 1,
                          re.DOTALL)
        # set JavaScript templates to the correct paths (local version under "assets")
        for js_pth in self.JS_TEMPLATE_PATHS:
            js_line = f'<script src="assets/{js_pth.name}"></script>'
            html = re.sub(r'<script\s+src\s*=\s*"(https?:\/\/[^"]+\.js)"[^>]*><\/script>', js_line, html, 1, re.DOTALL)

        # add path highlighting script to the HTML file
        with open(Path(__file__).parent.parent.joinpath('data_files/report_misc/globalVars.js')) as f:
            global_vars = f.read()
            html = re.sub(r'(var\s+[^;]+;\s*)+', r'\g<0>' + global_vars, html, count=1)
        with open(Path(__file__).parent.parent.joinpath('data_files/report_misc/listeners.js')) as f:
            listeners = f.read()
        with open(Path(__file__).parent.parent.joinpath('data_files/report_misc/drawPath.js')) as f:
            draw_path_func = f.read()
        merged_code = listeners + '\n' + draw_path_func
        html = re.sub(r'(network\s*=\s*new\s+vis\.Network\([^;]+;\s*)', r'\g<0>' + merged_code, html, count=1)
        return html

    def _report_from_nx(self, show_settings: bool, title: Union[str, Literal['auto']],
                        hierarchical_layout: bool) -> Network:
        vis_report = Network(directed=True, layout=False, heading=self.TITLE if title == 'auto' else title)
        vis_report.from_nx(self.graph)

        with open(Path(__file__).parent.parent.joinpath('data_files/report_misc/options.json')) as f:
            options = json.load(f)
            options['configure']['enabled'] = show_settings
            options['layout']['hierarchical']['enabled'] = hierarchical_layout
            vis_report.set_options(json.dumps(options))
        return vis_report

    @staticmethod
    def generate_report_dialog(parent=None):
        dialog = ConfigureReportWindow(parent)
        return dialog

    def generate_report(self, output_folder: Path, title: Union[str, Literal['auto']] = 'auto',
                        title_fontsize: int = 24, show_settings_menu: bool = False,hierarchical_layout: bool = True):
        output_folder = Path(output_folder)
        assert output_folder.exists() and output_folder.is_dir()
        save_file = output_folder.joinpath('report.html').as_posix()
        vis_report = self._report_from_nx(show_settings_menu, title, hierarchical_layout)
        html = self._modify_html(vis_report.generate_html(save_file), title, title_fontsize)

        with open(save_file, 'w') as f:
            f.write(html)

        assets_path = output_folder.joinpath('assets')
        if assets_path.exists():
            shutil.rmtree(assets_path)
        assets_path.mkdir()
        for item in itertools.chain(self.CSS_TEMPLATE_PATHS, self.JS_TEMPLATE_PATHS):
            with open(item, encoding="utf-8") as f:
                content = f.read()
            with open(assets_path.joinpath(item.name), 'w', encoding="utf-8") as outfile:
                outfile.write(content)

        data_path = output_folder.joinpath('data')
        if data_path.exists():
            shutil.rmtree(data_path)
        data_path.mkdir()

        for ind, node in self.nodes.items():
            if ind == 0:  # skip the root node
                continue
            if not node.is_active or node.filename is None:  # skip inactive nodes, or nodes with no data file
                continue

            outfile_path = data_path.joinpath(node.filename)
            suffix = node.filename.suffix.lower()
            if suffix == '.parquet':  # convert parquet files to csv files so users can open them with Excel and such
                df = io.load_cached_gui_file(node.filename)
                io.save_table(df, outfile_path.with_suffix('.csv'))

            content: bytes = io.load_cached_gui_file(node.filename, load_as_obj=False)
            if content is not None:
                with open(outfile_path, 'wb') as f:
                    f.write(content)
        webbrowser.open(save_file)

    def serialize(self):
        data = {}
        data['graph'] = networkx.node_link_data(self.graph)
        data['nodes'] = {ind: node.to_json() for ind, node in self.nodes.items()}
        current_file_paths = {ind: node.filename for ind, node in self.nodes.items() if node.filename is not None}
        current_file_paths.pop(0)  # do not reference session file to avoid infinite recursion
        return data, current_file_paths

    @classmethod
    def deserialize(cls, data: dict):
        obj = cls.__new__(cls)
        obj.graph = networkx.node_link_graph(data['graph'])
        obj.nodes = {ind: Node.from_json(node_json) for ind, node_json in data['nodes'].items()}
        return obj


class ConfigureReportWindow(gui_windows.FuncExternalWindow):
    __slots__ = {}
    EXCLUDED_PARAMS = {'self'}

    def __init__(self, parent=None):
        func = ReportGenerator.generate_report
        super().__init__('Generate analysis report', func, None, self.EXCLUDED_PARAMS, threaded=True,
                         parent=parent)
        self.init_ui()
        self.setWindowTitle('Generate analysis report')

1	import itertools	8✔
2	import json	8✔
3	import re	8✔
4	import shutil	8✔
5	import typing	8✔
6	import webbrowser	8✔
7	from pathlib import Path	8✔
8	from typing import Literal, Union	8✔
9
10	import networkx	8✔
11	from pyvis.network import Network	8✔
12
13	from rnalysis import __version__	8✔
14	from rnalysis.gui import gui_windows	8✔
15	from rnalysis.utils import parsing, io	8✔
16
17
18	class Node:	8✔
19	__slots__ = ('_node_id', '_node_name', '_predecessors', '_is_active', '_popup_element', '_node_type', '_filename')	8✔
20	DATA_TYPES = {'Count matrix', 'Differential expression', 'Fold change', 'Other table', 'Gene set', 'Other output',	8✔
21	'Pipeline'}
22
23	def __init__(self, node_id: int, node_name: str, predecessors: list, popup_element: str, node_type: str,	8✔
24	filename: str = None):
25	self._node_id = node_id	8✔
26	self._node_name = node_name	8✔
27	self._predecessors = parsing.data_to_set(predecessors)	8✔
28	self._popup_element = popup_element	8✔
29	self._node_type = node_type	8✔
30	self._is_active = True	8✔
31	self._filename = None if filename is None else Path(filename)	8✔
32	if node_type in self.DATA_TYPES:	8✔
33	self._node_name += f' (#{node_id})'	8✔
34
35	def to_json(self):	8✔
36	# Convert the Node object to a JSON-compatible dictionary
37	data = {	8✔
38	"node_id": self.node_id,
39	"node_name": self.node_name,
40	"predecessors": parsing.data_to_list(self.predecessors),
41	"popup_element": self.popup_element,
42	"node_type": self.node_type,
43	"filename": str(self.filename) if self.filename else None
44	}
45	return json.dumps(data)	8✔
46
47	@classmethod	8✔
48	def from_json(cls, json_str):	8✔
49	# Convert the JSON string back to a dictionary
50	data = json.loads(json_str)	8✔
51	# Create a new Node object using the dictionary
52	return cls(	8✔
53	node_id=data["node_id"],
54	node_name=data["node_name"],
55	predecessors=parsing.data_to_set(data["predecessors"]),
56	popup_element=data["popup_element"],
57	node_type=data["node_type"],
58	filename=Path(data["filename"]) if data["filename"] else None
59	)
60
61	@property	8✔
62	def node_id(self) -> int:	8✔
63	return self._node_id	8✔
64
65	@property	8✔
66	def node_name(self) -> str:	8✔
67	return self._node_name	8✔
68
69	@property	8✔
70	def predecessors(self) -> typing.Set[int]:	8✔
71	return self._predecessors	8✔
72
73	@property	8✔
74	def popup_element(self) -> str:	8✔
75	return self._popup_element	8✔
76
77	@property	8✔
78	def node_type(self) -> str:	8✔
79	return self._node_type	8✔
80
81	@property	8✔
82	def is_active(self) -> bool:	8✔
83	return self._is_active	8✔
84
85	@property	8✔
86	def filename(self) -> typing.Union[None, Path]:	8✔
87	return self._filename	8✔
88
89	def set_active(self, is_active: bool):	8✔
90	self._is_active = is_active	8✔
91
92	def add_predecessor(self, pred: int):	8✔
93	self._predecessors.add(pred)	8✔
94
95	def update_filename(self, filename: typing.Union[None, Path]):	8✔
96	self._filename = filename	×
97
98
99	class ReportGenerator:	8✔
100	__slots__ = ('graph', 'nodes')	8✔
101	CSS_TEMPLATE_PATHS = [Path(__file__).parent.parent.joinpath('data_files/report_templates/vis-network.min.css'),	8✔
102	Path(__file__).parent.parent.joinpath('data_files/report_templates/bootstrap.min.css')]
103	JS_TEMPLATE_PATHS = [Path(__file__).parent.parent.joinpath('data_files/report_templates/vis-network.min.js'),	8✔
104	Path(__file__).parent.parent.joinpath('data_files/report_templates/bootstrap.bundle.min.js')]
105	NODE_GROUPS = {'root': 'root',	8✔
106	'Count matrix': 'count',
107	'Differential expression': 'diffexp',
108	'Fold change': 'foldchange',
109	'Other table': 'table',
110	'Gene set': 'geneset',
111	'Function': 'function',
112	'Other output': 'other',
113	'Pipeline': 'pipeline'}
114	ROOT_FNAME = 'session.rnal'	8✔
115	TITLE = f"Data analysis report (<i>RNAlysis</i> version {__version__})"	8✔
116
117	def __init__(self):	8✔
118	self.graph = networkx.DiGraph()	8✔
119	self.nodes: typing.Dict[int, Node] = {}	8✔
120	self.create_legend()	8✔
121	href = Path('data').joinpath(self.ROOT_FNAME).as_posix()	8✔
122	root_desc = f'<a href="{href}" target="_blank" rel="noopener noreferrer">Open RNAlysis session</a>'	8✔
123	self.add_node('Started RNAlysis session', 0, [], root_desc, node_type='root', filename=self.ROOT_FNAME)	8✔
124
125	def create_legend(self):	8✔
126	x = -750	8✔
127	y = -350	8✔
128	step = 75	8✔
129	for node_type, group_id in self.NODE_GROUPS.items():	8✔
130	if node_type in {'root'}:	8✔
131	continue	8✔
132	self.graph.add_node(node_type, group=group_id, is_legend=True, label=node_type.capitalize(), fixed=True,	8✔
133	physics=False, x=x, y=y, font={'size': 16}, widthConstraint=100, shape=None)
134	y += step	8✔
135
136	def add_node(self, name: str, node_id: int, predecessors: typing.List[int] = tuple(), popup_element: str = '',	8✔
137	node_type: Literal[tuple(NODE_GROUPS)] = 'Other table', filename: str = None):
138	# parentless nodes should be attached to the root node
139	if len(predecessors) == 0 and node_id > 0:	8✔
140	predecessors = [0]	8✔
141
142	if node_id in self.nodes:	8✔
143	if self.nodes[node_id].is_active:	8✔
144	return	8✔
145	node = self.nodes[node_id]	8✔
146	node.set_active(True)	8✔
147
148	for pred in predecessors:	8✔
149	if not self.nodes[pred].is_active:	8✔
150	self.add_node('', pred)	×
151	else:
152	node = Node(node_id, name, predecessors, popup_element, node_type, filename)	8✔
153	self.nodes[node_id] = node	8✔
154	group_id = self.NODE_GROUPS[node.node_type]	8✔
155	self.graph.add_node(node.node_id, label=node.node_name, title=node.popup_element, group=group_id, shape=None)	8✔
156	for pred in predecessors:	8✔
157	self.graph.add_edge(pred, node_id)	8✔
158
159	def trim_node(self, node_id: int):	8✔
160	"""
161	Removes a node from the report graph if it is a leaf node with no outgoing edges, \
162	and trims any of its predecessors that are of type 'Function' and are also now leaf nodes.
163
164	:param node_id: The ID of the node to be trimmed.
165	:type node_id: int
166
167	This method checks if the specified node is present in the report graph, and if it is a leaf node \
168	with no outgoing edges. If both conditions are met, the node is removed from the graph, \
169	its corresponding `ReportNode` object is set to inactive, and any of its predecessors that are of type \
170	'Function' are recursively checked to see if they are now leaf nodes themselves (i.e., have no outgoing edges).\
171	If a predecessor is a leaf node, it is also trimmed from the graph and marked as inactive.
172
173	This method is used for pruning the report graph of unnecessary nodes when a tab is closed \
174	or an action is undone.
175	"""
176	if node_id in self.graph and self.graph.out_degree(node_id) == 0:	8✔
177	predecessors = self.graph.predecessors(node_id)	8✔
178	self.graph.remove_node(node_id)	8✔
179	self.nodes[node_id].set_active(False)	8✔
180	for pred in predecessors:	8✔
181	if self.nodes[pred].node_type == 'Function':	8✔
182	self.trim_node(pred)	8✔
183
184	def _modify_html(self, html: str, title: str, title_fontsize: int) -> str:	8✔
185	# remove duplicate title
186	title = self.TITLE if title == 'auto' else title	8✔
187	if html.count(title) > 1:	8✔
188	html = re.sub(r'<center>.+?<\/h1>\s+<\/center>', '', html, 1, re.DOTALL)	8✔
189	# set title font size
190	fontsize_em = title_fontsize / 16	8!
191	html = html.replace('<h1>', f'<h1 style="font-size:{fontsize_em}em;">')	8✔
192	# remove comments from file
193	comment_regex = r"<!--[\s\S]*?-->"	8✔
194	html = re.sub(comment_regex, "", html)	8✔
195	# set CSS templates to the correct paths (local version under "assets")
196	for css_pth in self.CSS_TEMPLATE_PATHS:	8✔
197	css_line = f'<link rel="stylesheet" href="assets/{css_pth.name}"/>'	8✔
198	html = re.sub(r'<link(?:\s+[\w-]+="[^"]")\s+href="[^"]+"\s+(?:[\w-]+="[^"]"\s+)?\/>', css_line, html, 1,	8✔
199	re.DOTALL)
200	# set JavaScript templates to the correct paths (local version under "assets")
201	for js_pth in self.JS_TEMPLATE_PATHS:	8✔
202	js_line = f'<script src="assets/{js_pth.name}"></script>'	8✔
203	html = re.sub(r'<script\s+src\s=\s"(https?:\/\/[^"]+\.js)"[^>]*><\/script>', js_line, html, 1, re.DOTALL)	8✔
204
205	# add path highlighting script to the HTML file
206	with open(Path(__file__).parent.parent.joinpath('data_files/report_misc/globalVars.js')) as f:	8✔
207	global_vars = f.read()	8✔
208	html = re.sub(r'(var\s+[^;]+;\s*)+', r'\g<0>' + global_vars, html, count=1)	8✔
209	with open(Path(__file__).parent.parent.joinpath('data_files/report_misc/listeners.js')) as f:	8✔
210	listeners = f.read()	8✔
211	with open(Path(__file__).parent.parent.joinpath('data_files/report_misc/drawPath.js')) as f:	8✔
212	draw_path_func = f.read()	8✔
213	merged_code = listeners + '\n' + draw_path_func	8✔
214	html = re.sub(r'(network\s=\snew\s+vis\.Network\([^;]+;\s*)', r'\g<0>' + merged_code, html, count=1)	8✔
215	return html	8✔
216
217	def _report_from_nx(self, show_settings: bool, title: Union[str, Literal['auto']],	8✔
218	hierarchical_layout: bool) -> Network:
219	vis_report = Network(directed=True, layout=False, heading=self.TITLE if title == 'auto' else title)	8✔
220	vis_report.from_nx(self.graph)	8✔
221
222	with open(Path(__file__).parent.parent.joinpath('data_files/report_misc/options.json')) as f:	8✔
223	options = json.load(f)	8✔
224	options['configure']['enabled'] = show_settings	8✔
225	options['layout']['hierarchical']['enabled'] = hierarchical_layout	8✔
226	vis_report.set_options(json.dumps(options))	8✔
227	return vis_report	8✔
228
229	@staticmethod	8✔
230	def generate_report_dialog(parent=None):	8✔
NEW 231	dialog = ConfigureReportWindow(parent)	×
NEW 232	return dialog	×
233
234	def generate_report(self, output_folder: Path, title: Union[str, Literal['auto']] = 'auto',	8✔
235	title_fontsize: int = 24, show_settings_menu: bool = False,hierarchical_layout: bool = True):
236	output_folder = Path(output_folder)	8✔
237	assert output_folder.exists() and output_folder.is_dir()	8✔
238	save_file = output_folder.joinpath('report.html').as_posix()	8✔
239	vis_report = self._report_from_nx(show_settings_menu, title, hierarchical_layout)	8✔
240	html = self._modify_html(vis_report.generate_html(save_file), title, title_fontsize)	8✔
241
242	with open(save_file, 'w') as f:	8✔
243	f.write(html)	8✔
244
245	assets_path = output_folder.joinpath('assets')	8✔
246	if assets_path.exists():	8✔
247	shutil.rmtree(assets_path)	×
248	assets_path.mkdir()	8✔
249	for item in itertools.chain(self.CSS_TEMPLATE_PATHS, self.JS_TEMPLATE_PATHS):	8✔
250	with open(item, encoding="utf-8") as f:	8✔
251	content = f.read()	8✔
252	with open(assets_path.joinpath(item.name), 'w', encoding="utf-8") as outfile:	8✔
253	outfile.write(content)	8✔
254
255	data_path = output_folder.joinpath('data')	8✔
256	if data_path.exists():	8✔
257	shutil.rmtree(data_path)	×
258	data_path.mkdir()	8✔
259
260	for ind, node in self.nodes.items():	8!
261	if ind == 0: # skip the root node	8✔
262	continue	8✔
263	if not node.is_active or node.filename is None: # skip inactive nodes, or nodes with no data file	×
264	continue	×
265
266	outfile_path = data_path.joinpath(node.filename)	×
267	suffix = node.filename.suffix.lower()	×
268	if suffix == '.parquet': # convert parquet files to csv files so users can open them with Excel and such	×
269	df = io.load_cached_gui_file(node.filename)	×
270	io.save_table(df, outfile_path.with_suffix('.csv'))	×
271
272	content: bytes = io.load_cached_gui_file(node.filename, load_as_obj=False)	×
273	if content is not None:	×
274	with open(outfile_path, 'wb') as f:	×
275	f.write(content)	×
276	webbrowser.open(save_file)	8✔
277
278	def serialize(self):	8✔
279	data = {}	8✔
280	data['graph'] = networkx.node_link_data(self.graph)	8✔
281	data['nodes'] = {ind: node.to_json() for ind, node in self.nodes.items()}	8✔
282	current_file_paths = {ind: node.filename for ind, node in self.nodes.items() if node.filename is not None}	8✔
283	current_file_paths.pop(0) # do not reference session file to avoid infinite recursion	8✔
284	return data, current_file_paths	8✔
285
286	@classmethod	8✔
287	def deserialize(cls, data: dict):	8✔
288	obj = cls.__new__(cls)	8✔
289	obj.graph = networkx.node_link_graph(data['graph'])	8✔
290	obj.nodes = {ind: Node.from_json(node_json) for ind, node_json in data['nodes'].items()}	8✔
291	return obj	8✔
292
293
294	class ConfigureReportWindow(gui_windows.FuncExternalWindow):	8✔
295	__slots__ = {}	8✔
296	EXCLUDED_PARAMS = {'self'}	8✔
297
298	def __init__(self, parent=None):	8✔
NEW 299	func = ReportGenerator.generate_report	×
NEW 300	super().__init__('Generate analysis report', func, None, self.EXCLUDED_PARAMS, threaded=True,	×
301	parent=parent)
NEW 302	self.init_ui()	×
NEW 303	self.setWindowTitle('Generate analysis report')	×

GuyTeichman / RNAlysis / 9646694207

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