cocotb 1.7.2__cp36-cp36m-win_amd64.whl → 1.8.0rc1__cp36-cp36m-win_amd64.whl

cocotb/task.py

@@ -0,0 +1,325 @@
+# Copyright cocotb contributors
+# Licensed under the Revised BSD License, see LICENSE for details.
+# SPDX-License-Identifier: BSD-3-Clause
+import collections.abc
+import inspect
+import os
+import typing
+import warnings
+from asyncio import CancelledError, InvalidStateError
+
+import cocotb
+import cocotb.triggers
+from cocotb import outcomes
+from cocotb.log import SimLog
+from cocotb.result import ReturnValue
+from cocotb.utils import extract_coro_stack, lazy_property, remove_traceback_frames
+
+T = typing.TypeVar("T")
+Self = typing.TypeVar("Self")
+
+# Sadly the Python standard logging module is very slow so it's better not to
+# make any calls by testing a boolean flag first
+_debug = "COCOTB_SCHEDULER_DEBUG" in os.environ
+
+
+class Task(typing.Coroutine[typing.Any, typing.Any, T]):
+    """Concurrently executing task.
+
+    This class is not intended for users to directly instantiate.
+    Use :func:`cocotb.create_task` to create a Task object,
+    or use :func:`cocotb.start_soon` or :func:`cocotb.start` to
+    create a Task and schedule it to run.
+
+    .. versionchanged:: 1.8.0
+        Moved to the ``cocotb.task`` module.
+    """
+
+    _name: str = "Task"  # class name of schedulable task
+    _id_count = 0  # used by the scheduler for debug
+
+    def __init__(self, inst):
+
+        if isinstance(inst, collections.abc.Coroutine):
+            self._natively_awaitable = True
+        elif inspect.isgenerator(inst):
+            self._natively_awaitable = False
+        elif inspect.iscoroutinefunction(inst):
+            raise TypeError(
+                "Coroutine function {} should be called prior to being "
+                "scheduled.".format(inst)
+            )
+        elif inspect.isasyncgen(inst):
+            raise TypeError(
+                "{} is an async generator, not a coroutine. "
+                "You likely used the yield keyword instead of await.".format(
+                    inst.__qualname__
+                )
+            )
+        else:
+            raise TypeError(
+                f"{inst} isn't a valid coroutine! Did you forget to use the yield keyword?"
+            )
+        self._coro = inst
+        self._started = False
+        self._outcome: outcomes.Outcome = None
+        self._trigger: typing.Optional[cocotb.triggers.Trigger] = None
+        self._cancelled: typing.Optional[CancelledError] = None
+
+        self._task_id = self._id_count
+        type(self)._id_count += 1
+        self.__name__ = f"{type(self)._name} {self._task_id}"
+        self.__qualname__ = self.__name__
+
+    @lazy_property
+    def log(self) -> SimLog:
+        # Creating a logger is expensive, only do it if we actually plan to
+        # log anything
+        return SimLog(f"cocotb.{self.__qualname__}.{self._coro.__qualname__}")
+
+    @property
+    def retval(self) -> T:
+        """Return the result of the Task.
+
+        If the Task ran to completion, the result is returned.
+        If the Task failed with an exception, the exception is re-raised.
+        If the Task is not yet complete, a :exc:`RuntimeError` is raised.
+
+        .. deprecated:: 1.7.0
+        """
+        warnings.warn(
+            "Deprecated in favor of the result() method. "
+            "Replace `task.retval` with `task.result()`.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        if self._outcome is None:
+            raise RuntimeError("coroutine is not complete")
+        return self._outcome.get()
+
+    @property
+    def _finished(self) -> bool:
+        """``True`` if the Task is finished executing.
+
+        .. deprecated:: 1.7.0
+        """
+        warnings.warn(
+            "Deprecated in favor of the done() method. "
+            "Replace `task._finished` with `task.done()`.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._outcome is not None
+
+    def __iter__(self: Self) -> Self:
+        # for use in "yield from" statements
+        return self
+
+    def __str__(self) -> str:
+        return f"<{self.__name__}>"
+
+    def _get_coro_stack(self) -> typing.Any:
+        """Get the coroutine callstack of this Task."""
+        coro_stack = extract_coro_stack(self._coro)
+
+        # Remove Trigger.__await__() from the stack, as it's not really useful
+        if self._natively_awaitable and len(coro_stack):
+            if coro_stack[-1].name == "__await__":
+                coro_stack.pop()
+
+        return coro_stack
+
+    def __repr__(self) -> str:
+        coro_stack = self._get_coro_stack()
+
+        if cocotb.scheduler._current_task is self:
+            fmt = "<{name} running coro={coro}()>"
+        elif self.done():
+            fmt = "<{name} finished coro={coro}() outcome={outcome}>"
+        elif self._trigger is not None:
+            fmt = "<{name} pending coro={coro}() trigger={trigger}>"
+        elif not self._started:
+            fmt = "<{name} created coro={coro}()>"
+        else:
+            fmt = "<{name} adding coro={coro}()>"
+
+        try:
+            coro_name = coro_stack[-1].name
+        # coro_stack may be empty if:
+        # - exhausted generator
+        # - finished coroutine
+        except IndexError:
+            coro_name = self._coro.__name__
+
+        repr_string = fmt.format(
+            name=self.__name__,
+            coro=coro_name,
+            trigger=self._trigger,
+            outcome=self._outcome,
+        )
+        return repr_string
+
+    def _advance(self, outcome: outcomes.Outcome) -> typing.Any:
+        """Advance to the next yield in this coroutine.
+
+        Args:
+            outcome: The :any:`outcomes.Outcome` object to resume with.
+
+        Returns:
+            The object yielded from the coroutine or None if coroutine finished
+
+        """
+        try:
+            self._started = True
+            return outcome.send(self._coro)
+        except ReturnValue as e:
+            self._outcome = outcomes.Value(e.retval)
+        except StopIteration as e:
+            self._outcome = outcomes.Value(e.value)
+        except BaseException as e:
+            self._outcome = outcomes.Error(
+                remove_traceback_frames(e, ["_advance", "send"])
+            )
+
+    def send(self, value: typing.Any) -> typing.Any:
+        return self._coro.send(value)
+
+    def throw(self, exc: BaseException) -> typing.Any:
+        return self._coro.throw(exc)
+
+    def close(self) -> None:
+        return self._coro.close()
+
+    def kill(self) -> None:
+        """Kill a coroutine."""
+        if self._outcome is not None:
+            # already finished, nothing to kill
+            return
+
+        if _debug:
+            self.log.debug("kill() called on coroutine")
+        # todo: probably better to throw an exception for anyone waiting on the coroutine
+        self._outcome = outcomes.Value(None)
+        cocotb.scheduler._unschedule(self)
+
+    def join(self) -> "cocotb.triggers.Join":
+        """Return a trigger that will fire when the wrapped coroutine exits."""
+        return cocotb.triggers.Join(self)
+
+    def has_started(self) -> bool:
+        """Return ``True`` if the Task has started executing."""
+        return self._started
+
+    def cancel(self, msg: typing.Optional[str] = None) -> None:
+        """Cancel a Task's further execution.
+
+        When a Task is cancelled, a :exc:`asyncio.CancelledError` is thrown into the Task.
+        """
+        self._cancelled = CancelledError(msg)
+        warnings.warn(
+            "Calling this method will cause a CancelledError to be thrown in the "
+            "Task sometime in the future.",
+            FutureWarning,
+            stacklevel=2,
+        )
+        self.kill()
+
+    def cancelled(self) -> bool:
+        """Return ``True`` if the Task was cancelled."""
+        return self._cancelled is not None
+
+    def done(self) -> bool:
+        """Return ``True`` if the Task has finished executing."""
+        return self._outcome is not None or self.cancelled()
+
+    def result(self) -> T:
+        """Return the result of the Task.
+
+        If the Task ran to completion, the result is returned.
+        If the Task failed with an exception, the exception is re-raised.
+        If the Task was cancelled, the CancelledError is re-raised.
+        If the coroutine is not yet complete, a :exc:`asyncio.InvalidStateError` is raised.
+        """
+        if not self.done():
+            raise InvalidStateError("result is not yet available")
+        elif self.cancelled():
+            raise self._cancelled
+        else:
+            return self._outcome.get()
+
+    def exception(self) -> typing.Optional[BaseException]:
+        """Return the exception of the Task.
+
+        If the Task ran to completion, ``None`` is returned.
+        If the Task failed with an exception, the exception is returned.
+        If the Task was cancelled, the CancelledError is re-raised.
+        If the coroutine is not yet complete, a :exc:`asyncio.InvalidStateError` is raised.
+        """
+        if not self.done():
+            raise InvalidStateError("result is not yet available")
+        elif self.cancelled():
+            raise self._cancelled
+        elif isinstance(self._outcome, outcomes.Error):
+            return self._outcome.error
+        else:
+            return None
+
+    def __bool__(self) -> bool:
+        """``True`` if Task is not done.
+
+        .. deprecated:: 1.7.0
+        """
+        warnings.warn(
+            "Deprecated in favor of the done() method. "
+            "Replace with `not task.done()`.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return not self.done()
+
+    def __await__(self) -> typing.Generator[typing.Any, typing.Any, T]:
+        # It's tempting to use `return (yield from self._coro)` here,
+        # which bypasses the scheduler. Unfortunately, this means that
+        # we can't keep track of the result or state of the coroutine,
+        # things which we expose in our public API. If you want the
+        # efficiency of bypassing the scheduler, remove the `@coroutine`
+        # decorator from your `async` functions.
+
+        # Hand the coroutine back to the scheduler trampoline.
+        return (yield self)
+
+
+class _RunningCoroutine(Task[T]):
+    """
+    The result of calling a :any:`cocotb.coroutine` decorated coroutine.
+
+    All this class does is provide some extra attributes.
+
+    .. versionchanged:: 1.8.0
+        Moved to the ``cocotb.task`` module.
+    """
+
+    def __init__(self, inst, parent):
+        super().__init__(inst)
+        self._parent = parent
+        self.__doc__ = parent._func.__doc__
+        self.module = parent._func.__module__
+        self.funcname = parent._func.__name__
+
+
+class _RunningTest(_RunningCoroutine[T]):
+    """
+    The result of calling a :class:`cocotb.test` decorated object.
+
+    All this class does is change ``__name__`` to show "Test" instead of "Task".
+
+    .. versionchanged:: 1.8.0
+        Moved to the ``cocotb.task`` module.
+    """
+
+    _name: str = "Test"
+
+    def __init__(self, inst, parent):
+        super().__init__(inst, parent)
+        self.__name__ = f"{type(self)._name} {self.funcname}"
+        self.__qualname__ = self.__name__

cocotb/triggers.py

@@ -33,11 +33,12 @@ import warnings
 from collections.abc import Awaitable
 from decimal import Decimal
 from numbers import Real
-from typing import Optional, Union
+from typing import Any, Coroutine, Optional, TypeVar, Union
 
 import cocotb
 from cocotb import outcomes, simulator
 from cocotb.log import SimLog
+from cocotb.task import Task
 from cocotb.utils import (
     ParametrizedSingleton,
     get_sim_steps,
@@ -46,6 +47,8 @@ from cocotb.utils import (
     remove_traceback_frames,
 )
 
+T = TypeVar("T")
+
 
 def _pointer_str(obj):
     """
@@ -189,6 +192,10 @@ class Timer(GPITrigger):
                When *units* is ``'step'``,
                the timestep is determined by the simulator (see :make:var:`COCOTB_HDL_TIMEPRECISION`).
 
+            round_mode (str, optional):
+                String specifying how to handle time values that sit between time steps
+                (one of ``'error'``, ``'round'``, ``'ceil'``, ``'floor'``).
+
         Examples:
 
             >>> await Timer(100, units='ps')
@@ -778,7 +785,7 @@ class _AggregateWaitable(Waitable):
 
         # Do some basic type-checking up front, rather than waiting until we
         # await them.
-        allowed_types = (Trigger, Waitable, cocotb.decorators.Task)
+        allowed_types = (Trigger, Waitable, Task)
         for trigger in self.triggers:
             if not isinstance(trigger, allowed_types):
                 raise TypeError(
@@ -793,8 +800,7 @@ class _AggregateWaitable(Waitable):
         return "{}({})".format(
             type(self).__qualname__,
             ", ".join(
-                repr(Join(t)) if isinstance(t, cocotb.decorators.Task) else repr(t)
-                for t in self.triggers
+                repr(Join(t)) if isinstance(t, Task) else repr(t) for t in self.triggers
             ),
         )
 
@@ -934,7 +940,12 @@ class ClockCycles(Waitable):
         return fmt.format(type(self).__qualname__, self.signal, self.num_cycles)
 
 
-async def with_timeout(trigger, timeout_time, timeout_unit="step"):
+async def with_timeout(
+    trigger: Union[Trigger, Waitable, Task, Coroutine[Any, Any, T]],
+    timeout_time: Union[float, Decimal],
+    timeout_unit: str = "step",
+    round_mode: Optional[str] = None,
+) -> T:
     r"""
     Waits on triggers or coroutines, throws an exception if it waits longer than the given time.
 
@@ -972,12 +983,15 @@ async def with_timeout(trigger, timeout_time, timeout_unit="step"):
         await with_timeout(First(coro, event.wait()), 100, 'ns')
 
     Args:
-        trigger (:class:`~cocotb.triggers.Trigger`, :class:`~cocotb.triggers.Waitable`, :class:`~cocotb.decorators.Task`, or :term:`python:coroutine`):
+        trigger (:class:`~cocotb.triggers.Trigger`, :class:`~cocotb.triggers.Waitable`, :class:`~cocotb.task.Task`, or :term:`python:coroutine`):
             A single object that could be right of an :keyword:`await` expression in cocotb.
         timeout_time (numbers.Real or decimal.Decimal):
             Simulation time duration before timeout occurs.
         timeout_unit (str, optional):
             Units of timeout_time, accepts any units that :class:`~cocotb.triggers.Timer` does.
+        round_mode (str, optional):
+            String specifying how to handle time values that sit between time steps
+            (one of ``'error'``, ``'round'``, ``'ceil'``, ``'floor'``).
 
     Returns:
         First trigger that completed if timeout did not occur.
@@ -1005,7 +1019,9 @@ async def with_timeout(trigger, timeout_time, timeout_unit="step"):
         shielded = False
     else:
         shielded = True
-    timeout_timer = cocotb.triggers.Timer(timeout_time, timeout_unit)
+    timeout_timer = cocotb.triggers.Timer(
+        timeout_time, timeout_unit, round_mode=round_mode
+    )
     res = await First(timeout_timer, trigger)
     if res is timeout_timer:
         if not shielded:

cocotb/types/logic_array.py

@@ -28,6 +28,8 @@ class LogicArray(Array[Logic]):
     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
 
@@ -37,12 +39,15 @@ class LogicArray(Array[Logic]):
         >>> LogicArray([0, True, "X"])
         LogicArray('01X', Range(2, 'downto', 0))
 
-        >>> LogicArray(0xA)                     # picks smallest range that can fit the value
+        >>> 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(-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`.
 
@@ -115,12 +120,38 @@ class LogicArray(Array[Logic]):
 
     __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 isinstance(value, int):
+        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:

{cocotb-1.7.2.dist-info → cocotb-1.8.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cocotb
-Version: 1.7.2
+Version: 1.8.0rc1
 Summary: cocotb is a coroutine based cosimulation library for writing VHDL and Verilog testbenches in Python.
 Home-page: https://www.cocotb.org
 Author: Chris Higgs, Stuart Hodgson
@@ -39,8 +39,7 @@ Requires-Dist: cocotb-bus ; extra == 'bus'
 * Read the [documentation](https://docs.cocotb.org)
 * Get involved:
   * [Raise a bug / request an enhancement](https://github.com/cocotb/cocotb/issues/new) (Requires a GitHub account)
-  * [Join the mailing list](https://lists.librecores.org/listinfo/cocotb)
-  * [Join the Gitter chat room](https://gitter.im/cocotb)
+  * [Join the Gitter chat room](https://gitter.im/cocotb/Lobby)
 
 ## Installation
 
@@ -98,22 +97,38 @@ An example of a simple randomized cocotb testbench:
 # test_dff.py
 
 import random
+
 import cocotb
 from cocotb.clock import Clock
-from cocotb.triggers import FallingEdge
+from cocotb.triggers import RisingEdge
+from cocotb.types import LogicArray
 
 @cocotb.test()
-async def test_dff_simple(dut):
-    """ Test that d propagates to q """
+async def dff_simple_test(dut):
+    """Test that d propagates to q"""
+
+    # Assert initial output is unknown
+    assert LogicArray(dut.q.value) == LogicArray("X")
+    # Set initial input value to prevent it from floating
+    dut.d.value = 0
 
     clock = Clock(dut.clk, 10, units="us")  # Create a 10us period clock on port clk
-    cocotb.start_soon(clock.start())  # Start the clock
+    # Start the clock. Start it low to avoid issues on the first RisingEdge
+    cocotb.start_soon(clock.start(start_high=False))
 
+    # Synchronize with the clock. This will regisiter the initial `d` value
+    await RisingEdge(dut.clk)
+    expected_val = 0  # Matches initial input value
     for i in range(10):
         val = random.randint(0, 1)
         dut.d.value = val  # Assign the random value val to the input port d
-        await FallingEdge(dut.clk)
-        assert dut.q.value == val, "output q was incorrect on the {}th cycle".format(i)
+        await RisingEdge(dut.clk)
+        assert dut.q.value == expected_val, f"output q was incorrect on the {i}th cycle"
+        expected_val = val # Save random value for next RisingEdge
+
+    # Check the final input on the next clock
+    await RisingEdge(dut.clk)
+    assert dut.q.value == expected_val, "output q was incorrect on the last cycle"
 ```
 
 A simple Makefile:

cocotb-1.8.0rc1.dist-info/RECORD

@@ -0,0 +1,120 @@
+cocotb/ANSI.py,sha256=BXtYyxla8R_bHRasjDyZGibYDNoh2deY8Snyre8YT54,3458
+cocotb/__init__.py,sha256=_NKjtHVLsDKgFPI7oXqNPKxiHt7EO-0XmUkqSLgGI1A,11650
+cocotb/_deprecation.py,sha256=zCaBqq6H9GRyKgSij9NvLs6Ku5CIdvKuGW6rLwi1Hhk,1189
+cocotb/_py_compat.py,sha256=Z-6oewHZbG79nO_tILrRrClahxjYaeEShezbcLnJsc4,2754
+cocotb/_sim_versions.py,sha256=sZWOj9odl_yPo92B9k_b1c2XHll4roD-oHnVSqY4VhE,3689
+cocotb/_version.py,sha256=c_sANXIqez9-uHsDRjcYbiXfIEFV5fERPy-0EiPwtaw,306
+cocotb/binary.py,sha256=YCaXafbR2xG8CFnnToELgPyfL3rc6vEYYctmwGDQb5o,26996
+cocotb/clock.py,sha256=tyrtalfTCUiBTTfo_4kIGKG5mnCSCq3hLmAxwrmyQyM,6734
+cocotb/config.py,sha256=fW8kdxRx6_1qcWzL8r5Xm1KrHec-kVZcBv7WzBixMXs,10142
+cocotb/decorators.py,sha256=RmFedYm9gxIWIaeeADGHJCf9lvHHSbf0M6WN2KrfGG8,11802
+cocotb/handle.py,sha256=A_DojPAu_qbcOFP9U_q3A-dKRvrpLhX6ZWdy3NEHenw,42787
+cocotb/ipython_support.py,sha256=gon5kkyYVl2nJPHZmyo33vFkb0F9qEPMdPKh70WJx0g,3228
+cocotb/log.py,sha256=_pq5KzdU3dbFdSmaJfu_GhLSmIQaGuNsXQkIulSZuT0,10746
+cocotb/memdebug.py,sha256=UzsA9FtitLlxt-Y9pf_vlknKYX13mroVjZqvax9ddzs,1888
+cocotb/outcomes.py,sha256=4khaKTI7dZWhIAH1vZ7XWejQtlSGWb1-ZuHvSRClK9w,1355
+cocotb/queue.py,sha256=BoFIJ8tO2HGTPb_30I9Td7-W6VLQ54kquPrc5qLw2dk,5338
+cocotb/regression.py,sha256=XdokhhpR3GjriV3Hx-ihIayyjVLUiN27MdHldXMr1JE,33905
+cocotb/result.py,sha256=0B3i0wXair7gfKlelTrRSkFpPbyuhsW2kPtSvSasweo,6905
+cocotb/runner.py,sha256=o3KB_uPh9uhrQajGDD_JkHpZO7DDsASRsPInmaQJWGk,36621
+cocotb/scheduler.py,sha256=KxdMtIO_wOJrKYJRhC--QQuLoYmxr6h7uLofXxyKYQQ,42042
+cocotb/simulator.cp36-win_amd64.exp,sha256=lSCFohwsKno6mxp6D1nM4ZM-2bECPns6AGWSx0ka1l8,748
+cocotb/simulator.cp36-win_amd64.lib,sha256=PhDYH4viMwpPWYH2LAE1ps4k6sfiB21VbIJ40Fb5Byo,2036
+cocotb/simulator.cp36-win_amd64.pyd,sha256=gzkdDX8fzfl-FUr376qT4u-DLF-gbqdj7IIe80K1Pnc,34304
+cocotb/simulator.cp36-win_amd64.pyd.2.config,sha256=JGoavZmGw71REMRGu8DrBlQezZSCkQx7E3GOzGIf9_o,263
+cocotb/task.py,sha256=l51CgFAzBfKQD0snRuROoU24g52fd91wZM8GfSc-CQA,11360
+cocotb/triggers.py,sha256=l6jZ0rjnljCH_5iPOyoJ2uX6QC0AQn7JZdRB4vWeQtM,33259
+cocotb/utils.py,sha256=JTc870duDxUtSIM_UxXhsW9DtBvz6ziTagpn5wQ2ryU,23762
+cocotb/wavedrom.py,sha256=xQ_xG_cdUc4q4hju7Sjys-gFrJCg7RngCPFNI3A4KAA,6187
+cocotb/xunit_reporter.py,sha256=DrRM7Fn9LBY2hmtWI0PNFkiULpdNtqNzAk-1aw8Zd80,3632
+cocotb/_vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cocotb/_vendor/distutils_version.py,sha256=k4Zipnnw88hyoE5MLBbgcXh9iu7iYGK3K5s97wVpOFE,13185
+cocotb/libs/cocotb.dll,sha256=Ns9CmZwn1dH1aI0cUTpPLt5vhLVRMxQtbAJm-RFRSGk,23552
+cocotb/libs/cocotb.exp,sha256=Xt5Qhj3Zkt5YLPLcG0hvD15fOA-WoB6FPUfHXxTCcrM,1101
+cocotb/libs/cocotb.lib,sha256=A88vdah7VfZ_ovV3stbSxhO-wfcGhWKaoHU15D29nHE,2358
+cocotb/libs/cocotbfli_modelsim.dll,sha256=9r5h4TJO5Uiy0QGJISjfN5DDfrwSBSEg3t5W9gQBb4c,98304
+cocotb/libs/cocotbfli_modelsim.exp,sha256=dFQpMedewepnuPGV2Ke7P3KosjTSxBvPK2erI4m9RvE,867
+cocotb/libs/cocotbfli_modelsim.lib,sha256=fxQQiVJim1EAt5lafBwAXMzlJQfLnNjP_s8H_aA52c8,2176
+cocotb/libs/cocotbutils.dll,sha256=kWw_5oxlvz_pxPejq3cNObbPnJ9PMNdbiBVmG3fvt6M,12288
+cocotb/libs/cocotbutils.exp,sha256=Q6Wx0Rl2yF4PFhaoBftE9QjkxTSx3S2rZwBmQfE2xTs,966
+cocotb/libs/cocotbutils.lib,sha256=wHZ1lC4WqttFoZBPIqP_mSIQ-9-RHmYGf3eQhhVvF0c,2146
+cocotb/libs/cocotbvhpi_aldec.dll,sha256=eGrYmN6iNhL_aNvCY82rRagu6l9MN2nwl9ht5_YtGzU,89088
+cocotb/libs/cocotbvhpi_aldec.exp,sha256=BD1GWUfpWWs2YpJRncRevJVTHAyyXdqE_1VLwIPQT8A,1065
+cocotb/libs/cocotbvhpi_aldec.lib,sha256=MSQ9cgUHCu3cjNlr_4ZuoM-4TvbPrwov7h2XEhkoEAE,2442
+cocotb/libs/cocotbvhpi_modelsim.dll,sha256=J5exc4Yqraj3P0wgVXupNCRV62ZKlUQlgG4s8cEmMjY,89088
+cocotb/libs/cocotbvhpi_modelsim.exp,sha256=J-f2SlJW2LQ8Nw9fRjm4kSrVJ9EqNcJqmltQFdIobag,1072
+cocotb/libs/cocotbvhpi_modelsim.lib,sha256=-hHWTB-uD55isZLMHWtgTQG_2rhansUvfS6p8TlORvM,2484
+cocotb/libs/cocotbvpi_aldec.dll,sha256=7IzR925e7v93uFthAWRtHhroylTA44ScdInOgEHGnIM,74752
+cocotb/libs/cocotbvpi_aldec.exp,sha256=HQS5V_5QHDL_M0T7PqtLP1m2aXxtQZXZtTjtiFgIroM,1060
+cocotb/libs/cocotbvpi_aldec.lib,sha256=oEliaWtpPQ-gycodC1W1KGatibwSpmye4iayZYPeVhg,2418
+cocotb/libs/cocotbvpi_ghdl.dll,sha256=fSRTxahxOr7BEp6nFZYCeFZXVMLwcbAp9hC-2UYJkak,74752
+cocotb/libs/cocotbvpi_ghdl.exp,sha256=9-oJGZ4QQjDMVXSwdFZxUK-3E-uaackS7dr5wM03Cpg,1059
+cocotb/libs/cocotbvpi_ghdl.lib,sha256=1vXhVqSQGfCouzo_wGxihm10-1OXBIHFhDvHA_NMDs0,2408
+cocotb/libs/cocotbvpi_icarus.exp,sha256=HnlEhod8RVV8E7g5oJJoOnrppYaSXG6vX-VNJdbOTNI,1063
+cocotb/libs/cocotbvpi_icarus.lib,sha256=rAmfB7yOVOpAbDSg1wdxnWEyDd4ZPmyLYGd1vLonHIY,2438
+cocotb/libs/cocotbvpi_icarus.vpl,sha256=hDUS06WgJiu6RcOyQS6jSZo5BqoVkIdJWoKpLTr6gWg,74752
+cocotb/libs/cocotbvpi_modelsim.dll,sha256=kemv9RsTLKFFtaxWrzjRYJhQMiBsiK5lsfWQ8HRneGY,74752
+cocotb/libs/cocotbvpi_modelsim.exp,sha256=vMp6Pcoc0v0YH_VIyjTtWDRxdqq3HSfVLx3G-S1eyWo,1067
+cocotb/libs/cocotbvpi_modelsim.lib,sha256=RxjB0vL84fbwRnAmp-RBVgRkkzVEALu9eQao4F1TPhI,2468
+cocotb/libs/embed.dll,sha256=_vz6i1hE3SLaWbR9acMy9W0g5EAvfg56Q4T7oyBazK4,11776
+cocotb/libs/embed.exp,sha256=eSYxSbqD8JOar4-lmpAzzSyuETrf_0BeAff0_CuUonw,1088
+cocotb/libs/embed.lib,sha256=wCHsyl4vxU3zN9KnNFS9h7n6MsO_RAWUs8t1LuD0-aU,2322
+cocotb/libs/gpi.dll,sha256=ZFFWfhzfPUQqtBPgjwIfA6cySs0RSO4X6USRZV6mNTo,49152
+cocotb/libs/gpi.exp,sha256=M-hROKFpSEwIeID6SceHTPp1sFziuGiL2XMsfc9Hdsk,21023
+cocotb/libs/gpi.lib,sha256=7XS-7w5dyoGRkxcSayKrcNnNm_J5S38C8vgmGLS90tc,34400
+cocotb/libs/gpilog.dll,sha256=G2aMhs9IWJUWngFt5fflbhT0mWvEorl35DS31IVQDWc,16896
+cocotb/libs/gpilog.exp,sha256=XTlnGhzJXoouuI-pBgnoP8C3mcuPIJEFuqzTksOf8DA,1624
+cocotb/libs/gpilog.lib,sha256=TJd8hd0zQ7HHY866Ikkz4ShJOlKUH3SP5pqyAmL_fMI,3244
+cocotb/libs/pygpilog.dll,sha256=xjwB4-olbgYry5XOrlXURlwD-MUqnp909cc_-7JDis0,19968
+cocotb/libs/pygpilog.exp,sha256=dPjOvS0MFANXMGnlsc-yjLnZyngYZdipicqoc-dI6z0,1035
+cocotb/libs/pygpilog.lib,sha256=PExGeknZU_cAZBWRtIh7PW5sdzoyfUDaugN-Vh5y7tk,2272
+cocotb/share/def/.gitignore,sha256=JYPaHghbqtLFl-9QtOWaAHvoDOhVxEewSYwHgoYYgf8,46
+cocotb/share/def/README.md,sha256=dptv3zHQGzMqLt3Zv4XOd5IZeGqQS7Lwcq1XCs3BcR0,380
+cocotb/share/def/aldec.def,sha256=ItgxVlRaVuD20jGTN3JpkbHEO8jPfU5XjFlUqDUXzlU,991
+cocotb/share/def/aldec.exp,sha256=6BTwqXpD2zhOY7diSP8QYoP1HXoap_IcosQG9SLl16I,7938
+cocotb/share/def/aldec.lib,sha256=jswE2NcFB5cmrnUaW1JfTh6U6BcemhQ_zw_oyJNwGiQ,13498
+cocotb/share/def/ghdl.def,sha256=ETQh5VI72dWSJi_ig5m163GfLrxScYUamt5BjHjoKsY,705
+cocotb/share/def/ghdl.exp,sha256=cO1Zl6M5d89H07w2Y2lk5JvDM25G7yjO9zAAxEw-714,5763
+cocotb/share/def/ghdl.lib,sha256=uqbQ8EVP5O7W1EWaWp7a43zsDzajxA5CQ_0cQQS3bSY,9974
+cocotb/share/def/icarus.def,sha256=VRqkgUyzR2sa916Ra56cZVIb4kzbqDlJVWIOc3389qY,698
+cocotb/share/def/icarus.exp,sha256=T1BF2qF6-xmKxnghZhOGLSdKxEnaX-_jKre2RiivQVM,5753
+cocotb/share/def/icarus.lib,sha256=-4LqECly6d4u4fdjscQD698eq8wPNgYkXXq67M2uK9I,9612
+cocotb/share/def/modelsim.def,sha256=_6VexHTDM7geGOfedUCm6CLRpXS4DrcHUlP_BQxL1Nc,2389
+cocotb/share/def/modelsim.exp,sha256=D7GlFNxAhHutpUWaGceqIO1eVyordd6c6GtsmFIFnkI,16913
+cocotb/share/def/modelsim.lib,sha256=zbkqemzH0ct1SV0TNyYG1AbGOY_rXbrWSU2fED-o78o,28194
+cocotb/share/include/cocotb_utils.h,sha256=v3byzF0uZbks5umkKBe-mgB9J3ShtKwam0_S2vIS10A,4091
+cocotb/share/include/embed.h,sha256=Fw0szHcAsXyrK_APXxZE-t0ttqmA8IUC72XXYO5yPl8,2509
+cocotb/share/include/exports.h,sha256=RRDg9diMCUUJxdzKX0B6TGmQBNttcoVMBVCCLUUKsrA,677
+cocotb/share/include/gpi.h,sha256=FvlF0QQD1rfy_jZ6Q_EnUpymNz7BtrGCgunXV8hg40k,10264
+cocotb/share/include/gpi_logging.h,sha256=_Z00YAtMqSr5Mk3WSQ0YjQ5nyPvsxA5vmou1G8lX-B4,10553
+cocotb/share/include/py_gpi_logging.h,sha256=zuuDIsKCdLOfUwOMv5EzeQWHuM0PaHzYE1kIH6TSWys,672
+cocotb/share/include/vhpi_user_ext.h,sha256=VLXbA-oeO83mL1vR0e4Ye0zMe5ijIaXnvT2FRFgsYDY,654
+cocotb/share/include/vpi_user_ext.h,sha256=ofqT24X1KOLeIDowuZxKDYvCTgXAy_RzMz5-_LjSZas,2511
+cocotb/share/lib/verilator/verilator.cpp,sha256=DKNqW8ZZV8Xeqsf0WW8YSe1LzT6ay70fSyiI2Lkj29M,4560
+cocotb/share/makefiles/Makefile.deprecations,sha256=83TZ1sYlXpVL5erEAr1Y0ZknoX-3vVn5gcwHwaAf30k,428
+cocotb/share/makefiles/Makefile.inc,sha256=uOtUkgAFhogYPU1gJ3Y1AKaV6s86EqFfsbLObSY7dKs,7212
+cocotb/share/makefiles/Makefile.sim,sha256=mDZPxOw40n1oIYM2wQ-KNHw5Ws9xMW9NSexLWIOxLTM,5412
+cocotb/share/makefiles/simulators/Makefile.activehdl,sha256=Y5mq84jkkUo0DFSOwaP99fdv06w8J5fdflOcnYAOHD8,2728
+cocotb/share/makefiles/simulators/Makefile.cvc,sha256=wAf8qdHAeXckTixGmF5zAyWicCky5w0H41illxmD-NE,3995
+cocotb/share/makefiles/simulators/Makefile.ghdl,sha256=f0EdUOiEjjCONvQawAmmWfigzEUCt9CaheYT3x_tKW0,3627
+cocotb/share/makefiles/simulators/Makefile.icarus,sha256=N4n5-azl6YCGYsHwmVwUbN5rQ49Rl0XNt02BTiZYE50,4485
+cocotb/share/makefiles/simulators/Makefile.ius,sha256=ikm-N_uvdpTw4cSNbVOXCV59o6ZeaOoXTfpx676CCwc,5090
+cocotb/share/makefiles/simulators/Makefile.modelsim,sha256=MQYmRb59nvUkY_f7GXUQVEYXQnU4IWA2-_G0N08StuI,1938
+cocotb/share/makefiles/simulators/Makefile.questa,sha256=tSEhEoWm-UN5QzrmVAoPqnQ-sxBXQytVHKBQjRIRXHI,6595
+cocotb/share/makefiles/simulators/Makefile.riviera,sha256=GkMwjsvcTKJ-Dq_VFWFFCxio5E9Boo8uAis0TB8dSIk,6074
+cocotb/share/makefiles/simulators/Makefile.vcs,sha256=P6t3hpAQoeurusymMmck71vj9p5V5Ordbi6wyghPdHo,3788
+cocotb/share/makefiles/simulators/Makefile.verilator,sha256=gi6X6u7QqRNUPOCr_AT1iD6a_EeAGz2y0rkYwVz-2nY,2486
+cocotb/share/makefiles/simulators/Makefile.xcelium,sha256=h6Cd_bXncZUfLlLnRbRMBWXxKZDumWVtMM2MscxbheY,5545
+cocotb/types/__init__.py,sha256=-M5mR--OWtFZ7Y4pjxB9CF4kmFtroDR7kzz1ba6h0No,1853
+cocotb/types/array.py,sha256=JAg5YB84WwERF7S5SK16HvmzCYJgmc5trLATJT3TIqo,11208
+cocotb/types/logic.py,sha256=PH5zocv9SpJam9Scc8Cl3uiDtPdtixhbiVLXjJPsPW8,8791
+cocotb/types/logic_array.py,sha256=0XpStXNA7qY8FIoamb-dnn-IbzIOXIBoxd0tiWMlhVE,10255
+cocotb/types/range.py,sha256=f25nic3X8jpd14nFU61D3izEOT77zPF_txZkWNrZ7N8,6428
+pygpi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pygpi/entry.py,sha256=LDJ8WK-s9nY_A5GEvPUuJTvnGqZvkhOe7i_yGQmqrI0,972
+cocotb-1.8.0rc1.dist-info/LICENSE,sha256=oBp8aKF9rhLjG78uW4zxmiVsjA8Viwwdyj3nSbEXpmc,1570
+cocotb-1.8.0rc1.dist-info/METADATA,sha256=UlQoNYoF01IMHdfnfmlAP2iN3HzYOoepzbVWevvw2ng,6792
+cocotb-1.8.0rc1.dist-info/WHEEL,sha256=zukbZftcRdNfJ55Q_RYV9JZ3uVyqWKyq-wDJbmszs_U,101
+cocotb-1.8.0rc1.dist-info/entry_points.txt,sha256=kFnPpuolM06cgf3C7fa5JZS4vzADkrxfr0dmBvgtaYg,54
+cocotb-1.8.0rc1.dist-info/top_level.txt,sha256=w-hmA_Ca52PldJkt5ya7gRP9tpUXfeJUGLMfXdv5Ez4,393
+cocotb-1.8.0rc1.dist-info/RECORD,,