9224900341

Committed 24 May 2024 01:38PM UTC coverage: 88.273% (-0.2%) from 88.437%

Build # 9224900341

Build Type

push

github

Committed by

Christian-B

Commit Message

assert for typer

Run Details

1579 of 1883 branches covered (83.86%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

15 existing lines in 2 files now uncovered.

3329 of 3677 relevant lines covered (90.54%)

0.91 hits per line

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

85.84

/spinn_utilities/make_tools/replacer.py

# Copyright (c) 2018 The University of Manchester
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import logging
import os
import shutil
import struct
import sys
from typing import Optional, Tuple
from spinn_utilities.overrides import overrides
from spinn_utilities.config_holder import get_config_str_or_none
from spinn_utilities.log import FormatAdapter
from .file_converter import FORMAT_EXP
from .file_converter import TOKEN
from .log_sqllite_database import DB_FILE_NAME, LogSqlLiteDatabase

logger = FormatAdapter(logging.getLogger(__name__))

LEVELS = {10: "[DEBUG]",
          20: "[INFO]",
          30: "[WARN]",
          40: "[ERROR]"}


class Replacer(LogSqlLiteDatabase):
    """
    Performs replacements.
    """

    @overrides(LogSqlLiteDatabase._database_file)
    def _database_file(self) -> str:
        database_file = super()._database_file()
        if not os.path.isfile(database_file):
            external_binaries = get_config_str_or_none(
                "Mapping", "external_binaries")
            if external_binaries is not None:
                source_file = os.path.join(external_binaries, DB_FILE_NAME)
                if os.path.exists(source_file):

                    shutil.copyfile(source_file, database_file)
        return database_file

    @overrides(LogSqlLiteDatabase._extra_database_error_message)
    def _extra_database_error_message(self) -> str:
        extra__binaries = get_config_str_or_none(
            "Mapping", "external_binaries")
        if extra__binaries is None:
            return ""
        else:
            return (f"The cfg {extra__binaries=} "
                    f"also does not contain a {DB_FILE_NAME}. ")

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, exc_traceback):
        # nothing yet
        pass

    _INT_FMT = struct.Struct("!I")
    _FLT_FMT = struct.Struct("!f")
    _DBL_FMT = struct.Struct("!d")

    def _replace(self, short: str) -> Optional[Tuple[int, str, int, str]]:
        """
        Apply the replacements to a short message.

        :param str short: The short message to apply the transform to.
        :return: The expanded message.
        :rtype: str
        """
        parts = short.split(TOKEN)
        if not parts[0].isdigit():
            return None
        data = self.get_log_info(parts[0])
        if data is None:
            return None
        (log_level, file_name, line_num, original) = data

        replaced = original.encode("latin-1").decode("unicode_escape")
        if len(parts) > 1:
            matches = FORMAT_EXP.findall(original)
            # Remove any blanks due to double spacing
            matches = [x for x in matches if x != ""]
            # Start at 0 so first i+1 puts you at 1 as part 0 is the short
            i = 0
            try:
                for match in matches:
                    i += 1
                    if match.endswith("f"):
                        replacement = str(self._hex_to_float(parts[i]))
                    elif match.endswith("F"):
                        replacement = str(self._hexes_to_double(
                            parts[i], parts[i+1]))
                        i += 1
                    else:
                        replacement = parts[i]
                    replaced = replaced.replace(match, replacement, 1)
            except Exception:  # pylint: disable=broad-except
                return None
        return (log_level, file_name, line_num, replaced)

    def replace(self, short: str) -> str:
        """
        Apply the replacements to a short message.

        :param str short:
        :rtype: str
        """
        data = self._replace(short)
        if data is None:
            return short
        (log_level, file_name, line_num, replaced) = data
        return f"{LEVELS[log_level]} ({file_name}: {line_num}): {replaced}"

    def _hex_to_float(self, hex_str):
        return self._FLT_FMT.unpack(
            self._INT_FMT.pack(int(hex_str, 16)))[0]

    def _hexes_to_double(self, upper, lower):
        return self._DBL_FMT.unpack(
            self._INT_FMT.pack(int(upper, 16)) +
            self._INT_FMT.pack(int(lower, 16)))[0]


if __name__ == '__main__':
    encoded = sys.argv[1]
    LINE = "".join([c if c.isalnum() else TOKEN for c in encoded])
    with Replacer() as replacer:
        print(replacer.replace(LINE))

1	# Copyright (c) 2018 The University of Manchester
2	#
3	# Licensed under the Apache License, Version 2.0 (the "License");
4	# you may not use this file except in compliance with the License.
5	# You may obtain a copy of the License at
6	#
7	# https://www.apache.org/licenses/LICENSE-2.0
8	#
9	# Unless required by applicable law or agreed to in writing, software
10	# distributed under the License is distributed on an "AS IS" BASIS,
11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	# See the License for the specific language governing permissions and
13	# limitations under the License.
14
15	import logging	1✔
16	import os	1✔
17	import shutil	1✔
18	import struct	1✔
19	import sys	1✔
20	from typing import Optional, Tuple	1✔
21	from spinn_utilities.overrides import overrides	1✔
22	from spinn_utilities.config_holder import get_config_str_or_none	1✔
23	from spinn_utilities.log import FormatAdapter	1✔
24	from .file_converter import FORMAT_EXP	1✔
25	from .file_converter import TOKEN	1✔
26	from .log_sqllite_database import DB_FILE_NAME, LogSqlLiteDatabase	1✔
27
28	logger = FormatAdapter(logging.getLogger(__name__))	1✔
29
30	LEVELS = {10: "[DEBUG]",	1✔
31	20: "[INFO]",
32	30: "[WARN]",
33	40: "[ERROR]"}
34
35
36	class Replacer(LogSqlLiteDatabase):	1✔
37	"""
38	Performs replacements.
39	"""
40
41	@overrides(LogSqlLiteDatabase._database_file)	1✔
42	def _database_file(self) -> str:	1✔
43	database_file = super()._database_file()	1✔
44	if not os.path.isfile(database_file):	1✔
45	external_binaries = get_config_str_or_none(	1✔
46	"Mapping", "external_binaries")
47	if external_binaries is not None:	1!
48	source_file = os.path.join(external_binaries, DB_FILE_NAME)	1✔
49	if os.path.exists(source_file):	1✔
50
51	shutil.copyfile(source_file, database_file)	1✔
52	return database_file	1✔
53
54	@overrides(LogSqlLiteDatabase._extra_database_error_message)	1✔
55	def _extra_database_error_message(self) -> str:	1✔
56	extra__binaries = get_config_str_or_none(	1✔
57	"Mapping", "external_binaries")
58	if extra__binaries is None:	1!
UNCOV 59	return ""	×
60	else:
61	return (f"The cfg {extra__binaries=} "	1✔
62	f"also does not contain a {DB_FILE_NAME}. ")
63
64	def __enter__(self):	1✔
65	return self	1✔
66
67	def __exit__(self, exc_type, exc_value, exc_traceback):	1✔
68	# nothing yet
69	pass	1✔
70
71	_INT_FMT = struct.Struct("!I")	1✔
72	_FLT_FMT = struct.Struct("!f")	1✔
73	_DBL_FMT = struct.Struct("!d")	1✔
74
75	def _replace(self, short: str) -> Optional[Tuple[int, str, int, str]]:	1✔
76	"""
77	Apply the replacements to a short message.
78
79	:param str short: The short message to apply the transform to.
80	:return: The expanded message.
81	:rtype: str
82	"""
83	parts = short.split(TOKEN)	1✔
84	if not parts[0].isdigit():	1!
UNCOV 85	return None	×
86	data = self.get_log_info(parts[0])	1✔
87	if data is None:	1✔
88	return None	1✔
89	(log_level, file_name, line_num, original) = data	1✔
90
91	replaced = original.encode("latin-1").decode("unicode_escape")	1✔
92	if len(parts) > 1:	1✔
93	matches = FORMAT_EXP.findall(original)	1✔
94	# Remove any blanks due to double spacing
95	matches = [x for x in matches if x != ""]	1✔
96	# Start at 0 so first i+1 puts you at 1 as part 0 is the short
97	i = 0	1✔
98	try:	1✔
99	for match in matches:	1✔
100	i += 1	1✔
101	if match.endswith("f"):	1✔
102	replacement = str(self._hex_to_float(parts[i]))	1✔
103	elif match.endswith("F"):	1✔
104	replacement = str(self._hexes_to_double(	1✔
105	parts[i], parts[i+1]))
106	i += 1	1✔
107	else:
108	replacement = parts[i]	1✔
109	replaced = replaced.replace(match, replacement, 1)	1✔
UNCOV 110	except Exception: # pylint: disable=broad-except	×
111	return None	×
112	return (log_level, file_name, line_num, replaced)	1✔
113
114	def replace(self, short: str) -> str:	1✔
115	"""
116	Apply the replacements to a short message.
117
118	:param str short:
119	:rtype: str
120	"""
121	data = self._replace(short)	1✔
122	if data is None:	1✔
123	return short	1✔
124	(log_level, file_name, line_num, replaced) = data	1✔
125	return f"{LEVELS[log_level]} ({file_name}: {line_num}): {replaced}"	1✔
126
127	def _hex_to_float(self, hex_str):	1✔
128	return self._FLT_FMT.unpack(	1✔
129	self._INT_FMT.pack(int(hex_str, 16)))[0]
130
131	def _hexes_to_double(self, upper, lower):	1✔
132	return self._DBL_FMT.unpack(	1✔
133	self._INT_FMT.pack(int(upper, 16)) +
134	self._INT_FMT.pack(int(lower, 16)))[0]
135
136
137	if __name__ == '__main__':	1!
UNCOV 138	encoded = sys.argv[1]	×
UNCOV 139	LINE = "".join([c if c.isalnum() else TOKEN for c in encoded])	×
UNCOV 140	with Replacer() as replacer:	×
UNCOV 141	print(replacer.replace(LINE))	×

SpiNNakerManchester / SpiNNUtils / 9224900341

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