cocotb 1.9.2__cp310-cp310-win_amd64.whl → 2.0.0rc2__cp310-cp310-win_amd64.whl

cocotb/types/logic_array.py

@@ -1,298 +0,0 @@
-# Copyright cocotb contributors
-# Licensed under the Revised BSD License, see LICENSE for details.
-# SPDX-License-Identifier: BSD-3-Clause
-import typing
-
-from cocotb.binary import BinaryRepresentation, BinaryValue
-from cocotb.types.array import Array
-from cocotb.types.logic import Logic, LogicConstructibleT
-from cocotb.types.range import Range
-
-LogicT = typing.TypeVar("LogicT", bound=Logic)
-S = typing.TypeVar("S")
-Self = typing.TypeVar("Self", bound="LogicArray")
-
-
-class LogicArray(Array[Logic]):
-    r"""
-    Fixed-sized, arbitrarily-indexed, array of :class:`cocotb.types.Logic`.
-
-    .. currentmodule:: cocotb.types
-
-    :class:`LogicArray`\ s can be constructed from either iterables of values
-    constructible into :class:`Logic`: like :class:`bool`, :class:`str`, :class:`int`;
-    or from integers.
-    If constructed from a positive integer, an unsigned bit representation is used to
-    construct the :class:`LogicArray`.
-    If constructed from a negative integer, a two's complement bit representation is
-    used.
-    Like :class:`Array`, if no *range* argument is given, it is deduced from the length
-    of the iterable or bit string used to initialize the variable.
-    If a *range* argument is given, but no value,
-    the array is filled with the default value of Logic().
-
-    .. code-block:: python3
-
-        >>> LogicArray("01XZ")
-        LogicArray('01XZ', Range(3, 'downto', 0))
-
-        >>> LogicArray([0, True, "X"])
-        LogicArray('01X', Range(2, 'downto', 0))
-
-        >>> LogicArray(0xA)  # picks smallest range that can fit the value
-        LogicArray('1010', Range(3, 'downto', 0))
-
-        >>> LogicArray(-4, Range(0, "to", 3))  # will sign-extend
-        LogicArray('1100', Range(0, 'to', 3))
-
-        >>> LogicArray(range=Range(0, "to", 3))  # default values
-        LogicArray('XXXX', Range(0, 'to', 3))
-
-    :class:`LogicArray`\ s support the same operations as :class:`Array`;
-    however, it enforces the condition that all elements must be a :class:`Logic`.
-
-    .. code-block:: python3
-
-        >>> la = LogicArray("1010")
-        >>> la[0]                               # is indexable
-        Logic('0')
-
-        >>> la[1:]                              # is slice-able
-        LogicArray('10', Range(1, 'downto', 0))
-
-        >>> Logic("0") in la                    # is a collection
-        True
-
-        >>> list(la)                            # is an iterable
-        [Logic('1'), Logic('0'), Logic('1'), Logic('0')]
-
-    When setting an element or slice, the *value* is first constructed into a
-    :class:`Logic`.
-
-    .. code-block:: python3
-
-        >>> la = LogicArray("1010")
-        >>> la[3] = "Z"
-        >>> la[3]
-        Logic('Z')
-
-        >>> la[2:] = ['X', True, 0]
-        >>> la
-        LogicArray('ZX10', Range(3, 'downto', 0))
-
-    :class:`LogicArray`\ s can be converted into :class:`str`\ s or :class:`int`\ s.
-
-    .. code-block:: python3
-
-        >>> la = LogicArray("1010")
-        >>> la.binstr
-        '1010'
-
-        >>> la.integer          # uses unsigned representation
-        10
-
-        >>> la.signed_integer   # uses two's complement representation
-        -6
-
-    :class:`LogicArray`\ s also support element-wise logical operations: ``&``, ``|``,
-    ``^``, and ``~``.
-
-    .. code-block:: python3
-
-        >>> def big_mux(a: LogicArray, b: LogicArray, sel: Logic) -> LogicArray:
-        ...     s = LogicArray([sel] * len(a))
-        ...     return (a & ~s) | (b & s)
-
-        >>> la = LogicArray("0110")
-        >>> p = LogicArray("1110")
-        >>> sel = Logic('1')        # choose second option
-        >>> big_mux(la, p, sel)
-        LogicArray('1110', Range(3, 'downto', 0))
-
-    Args:
-        value: Initial value for the array.
-        range: Indexing scheme of the array.
-
-    Raises:
-        ValueError: When argument values cannot be used to construct an array.
-        TypeError: When invalid argument types are used.
-    """
-
-    __slots__ = ()
-
-    @typing.overload
-    def __init__(
-        self,
-        value: typing.Union[int, typing.Iterable[LogicConstructibleT], BinaryValue],
-        range: typing.Optional[Range],
-    ):
-        ...
-
-    @typing.overload
-    def __init__(
-        self,
-        value: typing.Union[
-            int, typing.Iterable[LogicConstructibleT], BinaryValue, None
-        ],
-        range: Range,
-    ):
-        ...
-
-    def __init__(
-        self,
-        value: typing.Union[
-            int, typing.Iterable[LogicConstructibleT], BinaryValue, None
-        ] = None,
-        range: typing.Optional[Range] = None,
-    ) -> None:
-        if value is None and range is None:
-            raise ValueError(
-                "at least one of the value and range input parameters must be given"
-            )
-        if value is None:
-            self._value = [Logic() for _ in range]
-        elif isinstance(value, int):
-            if value < 0:
-                bitlen = int.bit_length(value + 1) + 1
-            else:
-                bitlen = max(1, int.bit_length(value))
-            if range is None:
-                self._value = [Logic(v) for v in _int_to_bitstr(value, bitlen)]
-            else:
-                if bitlen > len(range):
-                    raise ValueError(f"{value} will not fit in {range}")
-                self._value = [Logic(v) for v in _int_to_bitstr(value, len(range))]
-        elif isinstance(value, typing.Iterable):
-            self._value = [Logic(v) for v in value]
-        elif isinstance(value, BinaryValue):
-            self._value = [Logic(v) for v in value.binstr]
-        else:
-            raise TypeError(
-                f"cannot construct {type(self).__qualname__} from value of type {type(value).__qualname__}"
-            )
-        if range is None:
-            self._range = Range(len(self._value) - 1, "downto", 0)
-        else:
-            self._range = range
-        if len(self._value) != len(self._range):
-            raise ValueError(
-                f"value of length {len(self._value)} will not fit in {self._range}"
-            )
-
-    @property
-    def binstr(self) -> str:
-        return "".join(str(bit) for bit in self)
-
-    @property
-    def is_resolvable(self) -> bool:
-        return all(bit in (Logic(0), Logic(1)) for bit in self)
-
-    @property
-    def integer(self) -> int:
-        value = 0
-        for bit in self:
-            value = value << 1 | int(bit)
-        return value
-
-    @property
-    def signed_integer(self) -> int:
-        value = self.integer
-        if value >= (1 << (len(self) - 1)):
-            value -= 1 << len(self)
-        return value
-
-    @typing.overload
-    def __setitem__(self, item: int, value: LogicConstructibleT) -> None:
-        ...
-
-    @typing.overload
-    def __setitem__(
-        self, item: slice, value: typing.Iterable[LogicConstructibleT]
-    ) -> None:
-        ...
-
-    def __setitem__(
-        self,
-        item: typing.Union[int, slice],
-        value: typing.Union[LogicConstructibleT, typing.Iterable[LogicConstructibleT]],
-    ) -> None:
-        if isinstance(item, int):
-            super().__setitem__(item, Logic(typing.cast(LogicConstructibleT, value)))
-        elif isinstance(item, slice):
-            super().__setitem__(
-                item,
-                (
-                    Logic(v)
-                    for v in typing.cast(typing.Iterable[LogicConstructibleT], value)
-                ),
-            )
-        else:
-            raise TypeError(
-                f"indexes must be ints or slices, not {type(item).__name__}"
-            )
-
-    def __repr__(self) -> str:
-        return "{}({!r}, {!r})".format(type(self).__qualname__, self.binstr, self.range)
-
-    def __and__(self: Self, other: Self) -> Self:
-        if isinstance(other, type(self)):
-            if len(self) != len(other):
-                raise ValueError(
-                    f"cannot perform bitwise & "
-                    f"between {type(self).__qualname__} of length {len(self)} "
-                    f"and {type(other).__qualname__} of length {len(other)}"
-                )
-            return type(self)(a & b for a, b in zip(self, other))  # type: ignore
-        return NotImplemented
-
-    def __rand__(self: Self, other: Self) -> Self:
-        return self & other
-
-    def __or__(self: Self, other: Self) -> Self:
-        if isinstance(other, type(self)):
-            if len(self) != len(other):
-                raise ValueError(
-                    f"cannot perform bitwise | "
-                    f"between {type(self).__qualname__} of length {len(self)} "
-                    f"and {type(other).__qualname__} of length {len(other)}"
-                )
-            return type(self)(a | b for a, b in zip(self, other))  # type: ignore
-        return NotImplemented
-
-    def __ror__(self: Self, other: Self) -> Self:
-        return self | other
-
-    def __xor__(self: Self, other: Self) -> Self:
-        if isinstance(other, type(self)):
-            if len(self) != len(other):
-                raise ValueError(
-                    f"cannot perform bitwise ^ "
-                    f"between {type(self).__qualname__} of length {len(self)} "
-                    f"and {type(other).__qualname__} of length {len(other)}"
-                )
-            return type(self)(a ^ b for a, b in zip(self, other))  # type: ignore
-        return NotImplemented
-
-    def __rxor__(self: Self, other: Self) -> Self:
-        return self ^ other
-
-    def __invert__(self: Self) -> Self:
-        return type(self)(~v for v in self)
-
-    def to_BinaryValue(
-        self,
-        bigEndian: bool = True,
-        binaryRepresentation: BinaryRepresentation = BinaryRepresentation.UNSIGNED,
-    ) -> BinaryValue:
-        return BinaryValue(
-            value=self.binstr,
-            n_bits=len(self),
-            bigEndian=bigEndian,
-            binaryRepresentation=binaryRepresentation,
-        )
-
-
-def _int_to_bitstr(value: int, n_bits: int) -> str:
-    if value < 0:
-        value += 1 << n_bits
-    return format(value, f"0{n_bits}b")

cocotb/wavedrom.py

@@ -1,199 +0,0 @@
-# Copyright cocotb contributors
-# Copyright (c) 2014 Potential Ventures Ltd
-# Licensed under the Revised BSD License, see LICENSE for details.
-# SPDX-License-Identifier: BSD-3-Clause
-
-import json
-from collections import OrderedDict, defaultdict
-from collections.abc import Mapping
-
-import cocotb
-from cocotb.handle import SimHandleBase
-from cocotb.triggers import ReadOnly, RisingEdge
-
-try:
-    from cocotb_bus.bus import Bus
-except ImportError:
-    Bus = None
-
-
-class Wavedrom:
-    """Base class for a WaveDrom compatible tracer."""
-
-    def __init__(self, obj, name=""):
-        self._hdls = OrderedDict()
-        self._name = name
-        if isinstance(obj, Mapping):
-            self._hdls.update(obj)
-        elif isinstance(obj, SimHandleBase):
-            name = obj._name.split(".")[-1]
-            self._hdls[name] = obj
-            self._name = name
-        elif Bus is not None and isinstance(obj, Bus):
-            self._hdls.update(obj._signals)
-            self._name = obj._name
-        else:
-            raise TypeError(
-                "Cannot use {} with {} objects".format(
-                    type(self).__qualname__, type(obj).__name__
-                )
-            ) from None
-        self.clear()
-
-    def sample(self):
-        """Record a sample of the signal value at this point in time."""
-
-        def _lastval(samples):
-            for x in range(len(samples) - 1, -1, -1):
-                if samples[x] not in "=.|":
-                    return samples[x]
-            return None
-
-        for name, hdl in self._hdls.items():
-            val = hdl.value
-            valstr = val.binstr.lower()
-
-            # Decide what character to use to represent this signal
-            if len(valstr) == 1:
-                char = valstr
-            elif "x" in valstr:
-                char = "x"
-            elif "u" in valstr:
-                char = "u"
-            elif "z" in valstr:
-                char = "z"
-            else:
-                if (
-                    len(self._data[name])
-                    and self._data[name][-1] == int(val)
-                    and self._samples[name][-1] in "=."
-                ):
-                    char = "."
-                else:
-                    char = "="
-                    self._data[name].append(int(val))
-
-            # Detect if this is unchanged
-            if len(valstr) == 1 and char == _lastval(self._samples[name]):
-                char = "."
-            self._samples[name].append(char)
-
-    def clear(self):
-        """Delete all sampled data."""
-        self._samples = defaultdict(list)
-        self._data = defaultdict(list)
-
-    def gap(self):
-        for name, hdl in self._hdls.items():
-            self._samples[name].append("|")
-
-    def get(self, add_clock=True):
-        """Return the samples as a list suitable for use with WaveDrom."""
-        siglist = []
-        traces = []
-        for name in self._hdls.keys():
-            samples = self._samples[name]
-            traces.append({"name": name, "wave": "".join(samples)})
-            if name in self._data:
-                traces[-1]["data"] = " ".join([repr(s) for s in self._data[name]])
-
-        if len(traces) > 1:
-            traces.insert(0, self._name)
-            siglist.append(traces)
-        else:
-            siglist.append(traces[0])
-
-        if add_clock:
-            tracelen = len(traces[-1]["wave"])
-            siglist.insert(0, {"name": "clk", "wave": "p" + "." * (tracelen - 1)})
-
-        return siglist
-
-
-class trace:
-    """Context manager to enable tracing of signals.
-
-    Arguments are an arbitrary number of signals or buses to trace.
-    We also require a clock to sample on, passed in as a keyword argument.
-
-    Usage::
-
-        with trace(sig1, sig2, a_bus, clk=clk) as waves:
-            # Stuff happens, we trace it
-
-            # Dump to JSON format compatible with WaveDrom
-            j = waves.dumpj()
-    """
-
-    def __init__(self, *args, clk=None):
-        self._clock = clk
-        self._signals = []
-        for arg in args:
-            self._signals.append(Wavedrom(arg))
-        self._coro = None
-        self._clocks = 0
-        self._enabled = False
-
-        if self._clock is None:
-            raise ValueError("Trace requires a clock to sample")
-
-    async def _monitor(self):
-        self._clocks = 0
-        while True:
-            await RisingEdge(self._clock)
-            await ReadOnly()
-            if not self._enabled:
-                continue
-            self._clocks += 1
-            for sig in self._signals:
-                sig.sample()
-
-    def insert_gap(self):
-        self._clocks += 1
-        for sig in self._signals:
-            sig.gap()
-
-    def disable(self):
-        self._enabled = False
-
-    def enable(self):
-        self._enabled = True
-
-    def __enter__(self):
-        for sig in self._signals:
-            sig.clear()
-        self.enable()
-        self._coro = cocotb.start_soon(self._monitor())
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._coro.kill()
-        for sig in self._signals:
-            sig.clear()
-        self.disable()
-        return None
-
-    def write(self, filename, **kwargs):
-        with open(filename, "w") as f:
-            f.write(self.dumpj(**kwargs))
-
-    def dumpj(self, header="", footer="", config=""):
-        trace = {"signal": []}
-        trace["signal"].append(
-            {"name": "clock", "wave": "p" + "." * (self._clocks - 1)}
-        )
-        for sig in self._signals:
-            trace["signal"].extend(sig.get(add_clock=False))
-        if header:
-            if isinstance(header, dict):
-                trace["head"] = header
-            else:
-                trace["head"] = {"text": header}
-        if footer:
-            if isinstance(footer, dict):
-                trace["foot"] = footer
-            else:
-                trace["foot"] = {"text": footer}
-        if config:
-            trace["config"] = config
-        return json.dumps(trace, indent=4, sort_keys=False)

cocotb/xunit_reporter.py

@@ -1,80 +0,0 @@
-# Copyright (c) 2013 Potential Ventures Ltd
-# Copyright (c) 2013 SolarFlare Communications Inc
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#     * Redistributions of source code must retain the above copyright
-#       notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright
-#       notice, this list of conditions and the following disclaimer in the
-#       documentation and/or other materials provided with the distribution.
-#     * Neither the name of Potential Ventures Ltd,
-#       SolarFlare Communications Inc nor the
-#       names of its contributors may be used to endorse or promote products
-#       derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL POTENTIAL VENTURES LTD BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import xml.etree.ElementTree as ET
-from xml.etree.ElementTree import Element, SubElement
-
-
-class XUnitReporter:
-    def __init__(self, filename="results.xml"):
-        self.results = Element("testsuites", name="results")
-        self.filename = filename
-
-    def add_testsuite(self, **kwargs):
-        self.last_testsuite = SubElement(self.results, "testsuite", **kwargs)
-        return self.last_testsuite
-
-    def add_testcase(self, testsuite=None, **kwargs):
-        if testsuite is None:
-            testsuite = self.last_testsuite
-        self.last_testcase = SubElement(testsuite, "testcase", **kwargs)
-        return self.last_testcase
-
-    def add_property(self, testsuite=None, **kwargs):
-        if testsuite is None:
-            testsuite = self.last_testsuite
-        self.last_property = SubElement(testsuite, "property", **kwargs)
-        return self.last_property
-
-    def add_failure(self, testcase=None, **kwargs):
-        if testcase is None:
-            testcase = self.last_testcase
-        SubElement(testcase, "failure", **kwargs)
-
-    def add_skipped(self, testcase=None, **kwargs):
-        if testcase is None:
-            testcase = self.last_testcase
-        SubElement(testcase, "skipped", **kwargs)
-
-    def indent(self, elem, level=0):
-        i = "\n" + level * "  "
-        if len(elem):
-            if not elem.text or not elem.text.strip():
-                elem.text = i + "  "
-            if not elem.tail or not elem.tail.strip():
-                elem.tail = i
-            for elem in elem:
-                self.indent(elem, level + 1)
-            if not elem.tail or not elem.tail.strip():
-                elem.tail = i
-        else:
-            if level and (not elem.tail or not elem.tail.strip()):
-                elem.tail = i
-
-    def write(self):
-        self.indent(self.results)
-        ET.ElementTree(self.results).write(self.filename, encoding="UTF-8")