6946939792

Committed 21 Nov 2023 04:42PM UTC coverage: 84.028% (+0.9%) from 83.081%

Build # 6946939792

Build Type

push

github

Committed by

Christian-B

Commit Message

Type fix

Run Details

1542 of 2015 branches covered (0.0%)

Branch coverage included in aggregate %.

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

535 existing lines in 55 files now uncovered.

5066 of 5849 relevant lines covered (86.61%)

0.87 hits per line

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

82.02

/pacman/model/graphs/common/slice.py

# Copyright (c) 2014 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.
from __future__ import annotations
from typing import Tuple, Union
import numpy
from numpy.typing import NDArray
from pacman.exceptions import PacmanValueError, PacmanTypeError


class Slice(object):
    """
    Represents a simple single-dimensional slice of a vertex.

    .. note::
        Multi-dimensional slices are supported by :py:class:`MDSlice`.
    """

    __slots__ = ("_lo_atom", "_n_atoms")

    def __init__(self, lo_atom: int, hi_atom: int):
        """
        :param int lo_atom: Index of the lowest atom to represent.
        :param int hi_atom: Index of the highest atom to represent.
        :raises PacmanTypeError: If non-integer arguments are used.
        :raises PacmanValueError: If the bounds of the slice are invalid.
        """
        if not isinstance(lo_atom, int):
            raise PacmanTypeError("lo_atom needs to be a int")
        if not isinstance(hi_atom, int):
            raise PacmanTypeError("hi_atom needs to be a int")

        if lo_atom < 0:
            raise PacmanValueError('lo_atom < 0')
        if hi_atom < lo_atom:
            raise PacmanValueError(
                'hi_atom {:d} < lo_atom {:d}'.format(hi_atom, lo_atom))

        self._lo_atom = lo_atom
        # Number of atoms represented by this slice
        self._n_atoms = hi_atom - lo_atom + 1

    @property
    def lo_atom(self) -> int:
        """
        The lowest atom represented in the slice.

        :rtype: int
        """
        return self._lo_atom

    @property
    def hi_atom(self) -> int:
        """
        The highest atom represented in the slice.

        .. note::
            Use of this method is *not* recommended.
            It fails for multi-dimensional slices and may be removed

        :rtype: int
        """
        return self._lo_atom + self._n_atoms - 1

    @property
    def n_atoms(self) -> int:
        """
        The number of atoms represented by the slice.

        :rtype: int
        """
        return self._n_atoms

    @property
    def shape(self) -> Tuple[int, ...]:
        """
        The shape of the atoms over multiple dimensions.
        By default the shape will be 1-dimensional.

        :rtype: tuple(int,...)
        """
        return (self._n_atoms, )

    @property
    def start(self) -> Tuple[int, ...]:
        """
        The start coordinates of the slice.
        By default this will be `lo_atom` in 1 dimension.

        :rtype: tuple(int,...)
        """
        return (self._lo_atom, )

    @property
    def as_slice(self) -> slice:
        """
        Converts the Slice to a standard slice object *if possible.*

        .. note::
            Use of this method is *not* recommended.
            It fails for multi-dimensional slices and may be removed.

        :return: a standard built-in slice object
        :rtype: slice
        :raises NotImplementedError: If called on a multi-dimensional slice
        """
        # slice for accessing arrays of values
        return slice(self._lo_atom, self._lo_atom + self._n_atoms)

    def get_slice(self, n: int) -> slice:
        """
        Get a slice in the `n`'Th dimension.

        :param int n: Must be 0
        :type: slice
        """
        if n == 0:
            return slice(self._lo_atom, self._lo_atom + self._n_atoms)
        raise IndexError(f"{n} is invalid for a 1 dimension Slice ")

    @property
    def dimension(self) -> Tuple[slice, ...]:
        """
        Get directions or edges as slices for every dimension

        This is the width and if available height, depth, etc., of the
        Slice/Grid as represented as slices form the origin along in that
        direction.

        :rtype: tuple(slice, ...)
        """
        return (slice(self._lo_atom, self._lo_atom + self._n_atoms), )

    @property
    def end(self) -> Tuple[int, ...]:
        """
        The end positions of the slice in each dimension

        :rtype: tuple(int, ...)
        """
        return (self._lo_atom + self._n_atoms, )

    def get_ids_as_slice_or_list(self) -> Union[slice, numpy.ndarray]:
        """
        Returns the IDs as a built-in slice if possible,
        otherwise as a list of IDs.

        :return: a slice or list of IDs
        :rtype: slice or list(int)
        """
        return slice(self._lo_atom, self._lo_atom + self._n_atoms)

    def get_raster_ids(self) -> NDArray[numpy.integer]:
        """
        Get the IDs of the atoms in the slice as they would appear in a
        "raster scan" of the atoms over the whole shape.

        :return: A list of the global raster IDs of the atoms in this slice
        :rtype: ~numpy.ndarray
        """
        return numpy.array(range(self._lo_atom, self._lo_atom + self._n_atoms))

    def __str__(self):
        return (f"({self.lo_atom}:{self.hi_atom})")

    def __eq__(self, other):
        if not isinstance(other, Slice):
            return False
        if self._lo_atom != other.lo_atom:
            return False
        # These checks are mainly to comparing to an extended slice
        if self.shape != other.shape:
            return False
        if self.start != other.start:
            return False
        return self._n_atoms == other.n_atoms

    def __hash__(self):
        # Slices will generally only be hashed in sets for the same Vertex
        return self._lo_atom

    @classmethod
    def from_string(cls, as_str: str) -> Slice:
        """
        Convert the string form of a :py:class:`Slice` into an object instance.

        :param str as_str: The string to parse
        :rtype: Slice
        """
        if as_str[0] != "(":
            raise NotImplementedError("Please use MDSlice method")

        parts = as_str[1:-1].split(":")
        lo_atom = int(parts[0])
        hi_atom = int(parts[1])
        return Slice(lo_atom, hi_atom)

1	# Copyright (c) 2014 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	from __future__ import annotations	1✔
15	from typing import Tuple, Union	1✔
16	import numpy	1✔
17	from numpy.typing import NDArray	1✔
18	from pacman.exceptions import PacmanValueError, PacmanTypeError	1✔
19
20
21	class Slice(object):	1✔
22	"""
23	Represents a simple single-dimensional slice of a vertex.
24
25	.. note::
26	Multi-dimensional slices are supported by :py:class:`MDSlice`.
27	"""
28
29	__slots__ = ("_lo_atom", "_n_atoms")	1✔
30
31	def __init__(self, lo_atom: int, hi_atom: int):	1✔
32	"""
33	:param int lo_atom: Index of the lowest atom to represent.
34	:param int hi_atom: Index of the highest atom to represent.
35	:raises PacmanTypeError: If non-integer arguments are used.
36	:raises PacmanValueError: If the bounds of the slice are invalid.
37	"""
38	if not isinstance(lo_atom, int):	1✔
39	raise PacmanTypeError("lo_atom needs to be a int")	1✔
40	if not isinstance(hi_atom, int):	1✔
41	raise PacmanTypeError("hi_atom needs to be a int")	1✔
42
43	if lo_atom < 0:	1✔
44	raise PacmanValueError('lo_atom < 0')	1✔
45	if hi_atom < lo_atom:	1✔
46	raise PacmanValueError(	1✔
47	'hi_atom {:d} < lo_atom {:d}'.format(hi_atom, lo_atom))
48
49	self._lo_atom = lo_atom	1✔
50	# Number of atoms represented by this slice
51	self._n_atoms = hi_atom - lo_atom + 1	1✔
52
53	@property	1✔
54	def lo_atom(self) -> int:	1✔
55	"""
56	The lowest atom represented in the slice.
57
58	:rtype: int
59	"""
60	return self._lo_atom	1✔
61
62	@property	1✔
63	def hi_atom(self) -> int:	1✔
64	"""
65	The highest atom represented in the slice.
66
67	.. note::
68	Use of this method is not recommended.
69	It fails for multi-dimensional slices and may be removed
70
71	:rtype: int
72	"""
73	return self._lo_atom + self._n_atoms - 1	1✔
74
75	@property	1✔
76	def n_atoms(self) -> int:	1✔
77	"""
78	The number of atoms represented by the slice.
79
80	:rtype: int
81	"""
82	return self._n_atoms	1✔
83
84	@property	1✔
85	def shape(self) -> Tuple[int, ...]:	1✔
86	"""
87	The shape of the atoms over multiple dimensions.
88	By default the shape will be 1-dimensional.
89
90	:rtype: tuple(int,...)
91	"""
92	return (self._n_atoms, )	1✔
93
94	@property	1✔
95	def start(self) -> Tuple[int, ...]:	1✔
96	"""
97	The start coordinates of the slice.
98	By default this will be `lo_atom` in 1 dimension.
99
100	:rtype: tuple(int,...)
101	"""
102	return (self._lo_atom, )	1✔
103
104	@property	1✔
105	def as_slice(self) -> slice:	1✔
106	"""
107	Converts the Slice to a standard slice object if possible.
108
109	.. note::
110	Use of this method is not recommended.
111	It fails for multi-dimensional slices and may be removed.
112
113	:return: a standard built-in slice object
114	:rtype: slice
115	:raises NotImplementedError: If called on a multi-dimensional slice
116	"""
117	# slice for accessing arrays of values
118	return slice(self._lo_atom, self._lo_atom + self._n_atoms)	1✔
119
120	def get_slice(self, n: int) -> slice:	1✔
121	"""
122	Get a slice in the `n`'Th dimension.
123
124	:param int n: Must be 0
125	:type: slice
126	"""
127	if n == 0:	×
UNCOV 128	return slice(self._lo_atom, self._lo_atom + self._n_atoms)	×
UNCOV 129	raise IndexError(f"{n} is invalid for a 1 dimension Slice ")	×
130
131	@property	1✔
132	def dimension(self) -> Tuple[slice, ...]:	1✔
133	"""
134	Get directions or edges as slices for every dimension
135
136	This is the width and if available height, depth, etc., of the
137	Slice/Grid as represented as slices form the origin along in that
138	direction.
139
140	:rtype: tuple(slice, ...)
141	"""
142	return (slice(self._lo_atom, self._lo_atom + self._n_atoms), )	1✔
143
144	@property	1✔
145	def end(self) -> Tuple[int, ...]:	1✔
146	"""
147	The end positions of the slice in each dimension
148
149	:rtype: tuple(int, ...)
150	"""
UNCOV 151	return (self._lo_atom + self._n_atoms, )	×
152
153	def get_ids_as_slice_or_list(self) -> Union[slice, numpy.ndarray]:	1✔
154	"""
155	Returns the IDs as a built-in slice if possible,
156	otherwise as a list of IDs.
157
158	:return: a slice or list of IDs
159	:rtype: slice or list(int)
160	"""
UNCOV 161	return slice(self._lo_atom, self._lo_atom + self._n_atoms)	×
162
163	def get_raster_ids(self) -> NDArray[numpy.integer]:	1✔
164	"""
165	Get the IDs of the atoms in the slice as they would appear in a
166	"raster scan" of the atoms over the whole shape.
167
168	:return: A list of the global raster IDs of the atoms in this slice
169	:rtype: ~numpy.ndarray
170	"""
171	return numpy.array(range(self._lo_atom, self._lo_atom + self._n_atoms))	1✔
172
173	def __str__(self):	1✔
174	return (f"({self.lo_atom}:{self.hi_atom})")	1✔
175
176	def __eq__(self, other):	1✔
177	if not isinstance(other, Slice):	1!
178	return False	×
179	if self._lo_atom != other.lo_atom:	1!
UNCOV 180	return False	×
181	# These checks are mainly to comparing to an extended slice
182	if self.shape != other.shape:	1!
183	return False	×
184	if self.start != other.start:	1!
UNCOV 185	return False	×
186	return self._n_atoms == other.n_atoms	1✔
187
188	def __hash__(self):	1✔
189	# Slices will generally only be hashed in sets for the same Vertex
UNCOV 190	return self._lo_atom	×
191
192	@classmethod	1✔
193	def from_string(cls, as_str: str) -> Slice:	1✔
194	"""
195	Convert the string form of a :py:class:`Slice` into an object instance.
196
197	:param str as_str: The string to parse
198	:rtype: Slice
199	"""
200	if as_str[0] != "(":	1✔
201	raise NotImplementedError("Please use MDSlice method")
202
203	parts = as_str[1:-1].split(":")	1✔
204	lo_atom = int(parts[0])	1✔
205	hi_atom = int(parts[1])	1✔
206	return Slice(lo_atom, hi_atom)	1✔

SpiNNakerManchester / PACMAN / 6946939792

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