pybrid-computing 0.10.0__py3-none-any.whl

pybrid/redac/protocol/protocol.py

@@ -0,0 +1,180 @@
+# Copyright (c) 2022-2024 anabrid GmbH
+# Contact: https://www.anabrid.com/licensing/
+# SPDX-License-Identifier: MIT OR GPL-2.0-or-later
+
+import asyncio
+import json
+import logging
+import typing
+import uuid
+from typing import Callable
+
+from packaging.version import Version
+from pybrid.base.hybrid.protocol import BaseProtocol, ProtocolError, MalformedDataError, UnsuccessfulRequestError
+from pybrid.base.transport import BaseTransport
+
+from ..entities import Path, Entity
+from .envelope import Envelope
+from .messages import Message, Request, Response, GetEntitiesRequest, GetConfigRequest, SetConfigRequest, \
+    StartRunRequest, HackRequest, SetDAQRequest, ResetRequest
+from .serializer import build_config
+from ..run import RunConfig, DAQConfig
+
+logger = logging.getLogger(__name__)
+
+
+class Protocol(BaseProtocol):
+
+    def __init__(self, transport: BaseTransport, version: Version = None):
+        super().__init__(transport, version)
+        self._receive_loop_task = None
+        self._expected_responses: dict[uuid, (Response, asyncio.futures.Future)] = dict()
+        self._callbacks: dict[typing.Type[Message], Callable] = dict()
+
+    async def start(self):
+        assert self._receive_loop_task is None
+        self._receive_loop_task = asyncio.create_task(self._receive_loop())
+
+    async def stop(self):
+        assert self._receive_loop_task is not None
+        self._receive_loop_task.cancel()
+        self.transport.close()
+        try:
+            await asyncio.gather(self._receive_loop_task, return_exceptions=False)
+        except asyncio.exceptions.CancelledError:
+            pass
+
+    # ███████ ███████ ███    ██ ██████  ██ ███    ██  ██████
+    # ██      ██      ████   ██ ██   ██ ██ ████   ██ ██
+    # ███████ █████   ██ ██  ██ ██   ██ ██ ██ ██  ██ ██   ███
+    #      ██ ██      ██  ██ ██ ██   ██ ██ ██  ██ ██ ██    ██
+    # ███████ ███████ ██   ████ ██████  ██ ██   ████  ██████
+
+    async def send_message_and_wait_response(self, message, timeout=3):
+        response_fut = await self.send_message(message)
+        await asyncio.wait_for(response_fut, timeout=timeout)
+        return response_fut.result()
+
+    async def send_message(self, message):
+        # Generate an envelope
+        envelope = Envelope.from_message(message)
+        # The response to this envelope is a future
+        response_future = asyncio.get_event_loop().create_future()
+        # A response is only expected for requests
+        if isinstance(message, Request):
+            self._expected_responses[envelope.id] = (message.get_expected_response_type(), response_future)
+        else:
+            # But if the message is not a request, no response will ever come, just set result to None here
+            response_future.set_result(None)
+
+        # Send out data
+        data = envelope.json().encode('ascii')
+        await self.transport.send_line(data)
+
+        # Return future to response
+        return response_future
+
+    # ██████  ███████  ██████ ███████ ██ ██    ██ ██ ███    ██  ██████
+    # ██   ██ ██      ██      ██      ██ ██    ██ ██ ████   ██ ██
+    # ██████  █████   ██      █████   ██ ██    ██ ██ ██ ██  ██ ██   ███
+    # ██   ██ ██      ██      ██      ██  ██  ██  ██ ██  ██ ██ ██    ██
+    # ██   ██ ███████  ██████ ███████ ██   ████   ██ ██   ████  ██████
+
+    async def _receive_json(self) -> dict:
+        data = await self.transport.receive_line()
+        try:
+            data_json = json.loads(data.decode("ascii"))
+        except json.decoder.JSONDecodeError as exc:
+            raise MalformedDataError(data) from exc
+        else:
+            return data_json
+
+    async def _receive_message_and_process(self):
+        data = await self._receive_json()
+        envelope = Envelope(**data)
+        if envelope.id is not None and envelope.id in self._expected_responses:
+            expected_response_type, response_future = self._expected_responses[envelope.id]
+            if not envelope.success:
+                response_future.set_exception(UnsuccessfulRequestError(envelope.error))
+            else:
+                message = envelope.get_message()
+                if callback := self.get_callback(type(message)):
+                    response_future.add_done_callback(lambda future: callback(future.result()))
+                response_future.set_result(message)
+        else:
+            message = envelope.get_message()
+            if callback := self.get_callback(type(message)):
+                callback(message)
+
+    async def _receive_loop(self):
+        while True:
+            try:
+                await self._receive_message_and_process()
+            except asyncio.CancelledError:
+                break
+            except asyncio.TimeoutError:
+                pass
+            except ProtocolError as exc:
+                logger.exception(
+                    "Error while receiving or processing envelope: %s.", exc
+                )
+            except Exception as exc:
+                logger.exception(
+                    "Unknown error: %s.", exc
+                )
+
+    #  ██████  █████  ██      ██      ██████   █████   ██████ ██   ██ ███████
+    # ██      ██   ██ ██      ██      ██   ██ ██   ██ ██      ██  ██  ██
+    # ██      ███████ ██      ██      ██████  ███████ ██      █████   ███████
+    # ██      ██   ██ ██      ██      ██   ██ ██   ██ ██      ██  ██       ██
+    #  ██████ ██   ██ ███████ ███████ ██████  ██   ██  ██████ ██   ██ ███████
+
+    def register_callback(self, msg_type: typing.Type[Message], callback: Callable):
+        self._callbacks[msg_type] = callback
+
+    def get_callback(self, msg_type: typing.Type[Message]):
+        return self._callbacks.get(msg_type, None)
+
+    #  ██████  ██████  ███    ███ ███    ███  █████  ███    ██ ██████  ███████
+    # ██      ██    ██ ████  ████ ████  ████ ██   ██ ████   ██ ██   ██ ██
+    # ██      ██    ██ ██ ████ ██ ██ ████ ██ ███████ ██ ██  ██ ██   ██ ███████
+    # ██      ██    ██ ██  ██  ██ ██  ██  ██ ██   ██ ██  ██ ██ ██   ██      ██
+    #  ██████  ██████  ██      ██ ██      ██ ██   ██ ██   ████ ██████  ███████
+
+    async def hack_request(self, cmd: str, data: typing.Any) -> typing.Any:
+        response = await self.send_message_and_wait_response(HackRequest(command=cmd, data=data))
+        return response.data
+
+    async def get_entities(self) -> dict:
+        response = await self.send_message_and_wait_response(GetEntitiesRequest())
+        return response.entities
+
+    async def get_config(self, entity: Path, recursive: bool = True) -> dict:
+        response = await self.send_message_and_wait_response(GetConfigRequest(entity=entity, recursive=recursive))
+        return response.config
+
+    async def set_config_request(self, entity: Path, config: dict, session: uuid.uuid4 = None) -> bool:
+        await self.send_message_and_wait_response(
+            SetConfigRequest(entity=entity, config=config, session=session))
+        return True
+
+    async def set_config(self, entity: Entity):
+        config = dict()
+        build_config(entity, config)
+        await self.set_config_request(entity=entity.path, config=config)
+        return True
+
+    async def set_daq_request(self, daq: DAQConfig, session: typing.Optional[uuid.UUID] = None):
+        await self.send_message_and_wait_response(
+            SetDAQRequest(daq=daq)
+        )
+
+    async def start_run_request(self, id_: uuid.UUID, config: RunConfig, daq_config: DAQConfig = None):
+        await self.send_message_and_wait_response(
+            StartRunRequest(id=id_, config=config, daq_config=daq_config, session=None)
+        )
+
+    async def reset(self, keep_calibration: bool = True, sync: bool = True):
+        await self.send_message_and_wait_response(
+            ResetRequest(keep_calibration=keep_calibration, sync=sync)
+        )

pybrid/redac/protocol/serializer.py

@@ -0,0 +1,52 @@
+# Copyright (c) 2022-2024 anabrid GmbH
+# Contact: https://www.anabrid.com/licensing/
+# SPDX-License-Identifier: MIT OR GPL-2.0-or-later
+
+from dataclasses import asdict
+from functools import singledispatch
+
+from ..blocks import ElementBlock, SwitchingBlock, CBlock
+from ..elements import ComputationElement
+from ..entities import Entity
+
+
+def exclude(*fields):
+    def _dict_factory_excluding(data):
+        return {k: v for (k, v) in data if k not in fields}
+
+    return _dict_factory_excluding
+
+
+def build_config(entity: Entity, config: dict):
+    entity_config, convert_children = to_dict(entity)
+    config.update(entity_config)
+    if convert_children:
+        for child in entity.children:
+            config["/" + str(child.id_)] = child_config = dict()
+            build_config(child, child_config)
+    return config
+
+
+@singledispatch
+def to_dict(entity: Entity):
+    return {}, True
+
+
+@to_dict.register
+def _(entity: ComputationElement):
+    return asdict(entity.computation), False
+
+
+@to_dict.register
+def _(entity: ElementBlock):
+    return {"elements": [to_dict(element)[0] for element in entity.elements]}, False
+
+
+@to_dict.register
+def _(entity: CBlock):
+    return {"elements": [element.computation.factor for element in entity.elements]}, False
+
+
+@to_dict.register
+def _(entity: SwitchingBlock):
+    return asdict(entity, dict_factory=exclude('path')), False

pybrid/redac/protocol/types.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2022-2024 anabrid GmbH
+# Contact: https://www.anabrid.com/licensing/
+# SPDX-License-Identifier: MIT OR GPL-2.0-or-later
+
+import typing
+
+from pydantic import BaseModel
+
+
+class SuccessInfo(BaseModel):
+    """
+    Data type used in responses indicating whether the associated request was successful.
+    """
+    #: :code:`True` if response was successful, :code:`False` otherwise.
+    success: bool
+    #: An optional error message. Always None if success is :code:`True`.
+    error: typing.Optional[str]

pybrid/redac/run.py

@@ -0,0 +1,131 @@
+# Copyright (c) 2022-2024 anabrid GmbH
+# Contact: https://www.anabrid.com/licensing/
+# SPDX-License-Identifier: MIT OR GPL-2.0-or-later
+
+import typing
+from collections import defaultdict
+from dataclasses import dataclass, field
+from enum import Enum
+from uuid import UUID, uuid4
+
+from pybrid.base.hybrid import BaseRun, BaseRunConfig, BaseRunFlags, BaseRunState, BaseDAQConfig
+from pybrid.base.utils.descriptors import Validator
+
+from .entities import Path
+
+
+class RunError(Exception):
+    """Base exception class for all errors during a :class:`Run`."""
+    pass
+
+
+@dataclass(kw_only=True)
+class RunConfig(BaseRunConfig):
+    """Configures parameters related to the execution of one :class:`Run`."""
+    #: Duration of IC (initial condition) mode in nanoseconds.
+    ic_time: int = 100_000
+    #: Duration of OP (operating) mode in nanoseconds.
+    op_time: int = 2_000_000
+
+    #: Whether to halt the computation when the external halt signal is triggered.
+    halt_on_external_trigger: bool = False
+    #: Whether to halt the computation when it enters an overload.
+    halt_on_overload: bool = True
+
+
+@dataclass(kw_only=True)
+class RunFlags(BaseRunFlags):
+    """
+    Flags that can be triggered by a :class:`Run`.
+    Once triggered, they are persistently `True`, even when the original condition is lost.
+    """
+    #: Whether the run was halted because of an external halt trigger.
+    externally_halted: bool = False
+    #: Any element that entered an overload during computation.
+    overloaded: typing.Optional[list[Path]] = None
+
+
+class RunState(BaseRunState, Enum):
+    """The state of a :class:`Run`."""
+    #: Run has just been created.
+    NEW = "NEW"
+    #: Run has encountered an error and has been aborted.
+    ERROR = "ERROR"
+    #: Run has successfully finished.
+    DONE = "DONE"
+    #: Run is queued for execution.
+    QUEUED = "QUEUED"
+    #: Run has been selected for execution and is being prepared to start.
+    TAKE_OFF = "TAKE_OFF"
+    #: Run is in IC (initial condition) mode.
+    IC = "IC"
+    #: Run is in OP (operating) mode.
+    OP = "OP"
+    #: Run is principally done, pending final data acquisition or other finalizing tasks.
+    OP_END = "OP_END"
+    #: Run is temporarily halted and can be resumed.
+    TMP_HALT = "TMP_HALT"
+
+    @classmethod
+    def default(cls):
+        return cls.NEW
+
+    @classmethod
+    def get_possibly_sampled_states(cls):
+        """Return a list of states in which data acquisition is possible."""
+        return cls.IC, cls.OP, cls.OP_END
+
+    def is_done(self):
+        return self in (RunState.DONE, RunState.ERROR)
+
+
+class DAQConfigurationNumChannels(Validator):
+
+    def set_default(self, instance, name, owner):
+        setattr(instance, name, 0)
+
+    def parse(self, instance, value):
+        return int(value)
+
+    def validate(self, instance, value):
+        if value > 0 and (value & (value - 1)) != 0:
+            raise ValueError("Value must be a power-of-two.")
+
+
+@dataclass(kw_only=True)
+class DAQConfig(BaseDAQConfig):
+    #: List of channels that should be sampled.
+    #: The element corresponding to each channel is implicitly defined by the computer's configuration.
+    num_channels: int = field(default=DAQConfigurationNumChannels())
+    #: Sample rate to use in samples/second.
+    sample_rate: int = 500_000
+    #: Whether to sample during IC
+    sample_op: bool = True
+    #: Whether to sample during OP_END
+    sample_op_end: bool = True
+
+
+@dataclass(kw_only=True)
+class Run(BaseRun):
+    """A run is one computation executed by the REDAC."""
+    #: A unique identifier for the run.
+    id_: UUID = field(default_factory=uuid4)
+    #: Possibly the ID of a related run, e.g. one that triggered this one.
+    related_to: typing.Optional[UUID] = None
+    #: Defines the duration the run should be executed and similar parameters.
+    #: Does not contain element configuration.
+    config: RunConfig = field(default_factory=RunConfig)
+
+    #: The current state of the run.
+    state: RunState = RunState.NEW
+    #: Flags, e.g. overload, the run has triggered. These are persistent once triggered.
+    flags: RunFlags = field(default_factory=RunFlags)
+
+    #: The configuration of the data acquisition for this run.
+    daq: DAQConfig = field(default_factory=DAQConfig)
+    #: Data captured for this run.
+    data: dict[Path | str, list[float]] = field(default_factory=lambda: defaultdict(list))
+
+    @classmethod
+    def get_persistent_attributes(cls) -> set[str]:
+        return super().get_persistent_attributes().union({"daq"})

pybrid_computing-0.10.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: pybrid-computing
+Version: 0.10.0
+Summary: Library to interact with analog computers and analog-digital hybrid computers, in particular the LUCIDAC and REDAC computers made by anabrid
+Home-page: https://anabrid.com/
+License: MIT OR GPL-2.0-or-later
+Author: Michael Steck
+Author-email: pybrid-code@anabrid.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications
+Classifier: Topic :: Scientific/Engineering :: Interface Engine/Protocol Translator
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Topic :: Terminals :: Serial
+Requires-Dist: asyncclick (>=8.1.3.4,<9.0.0.0)
+Requires-Dist: inflection (>=0.5.1,<0.6.0)
+Requires-Dist: matplotlib[examples] (>=3.5.3,<4.0.0)
+Requires-Dist: pybrid-computing-base (>=0.10.0,<1)
+Requires-Dist: pydantic (>=1.10.5,<2.0.0)
+Requires-Dist: pyqt5-qt5 (==5.15.2) ; sys_platform == "linux"
+Requires-Dist: pyqt5[examples] (>=5.15.2,<6.0.0)
+Description-Content-Type: text/markdown
+
+# pybrid-computing: The python hybrid computing code
+
+*pybrid* is a code that provides an interface to configure and control analog computers,
+in particular the network-enabled LUCIDAC/REDAC analog-digital hybrid computers made by
+[anabrid](https://anabrid.com/).
+The abstractions can be used by means of
+
+* a fully [asyncio](https://docs.python.org/3/library/asyncio.html) library
+* a framework (users providing callbacks in a clean class structure, however giving
+  up most of the program flow control) called *Read-Eval-Configure-Loop* (RECL)
+* a command line interface using [click](https://click.palletsprojects.com)
+
+This python library provides the reference implementation for the LUCIDAC/REDAC
+communication protocol (a simple ASCII yet fully asynchronous RPC message passing protocol
+ontop of JSONL) by means of [pydantic](https://docs.pydantic.dev/latest/) data type modeling.
+In particular, it is the reference implementation of a client communicating with a
+[LUCIDAC hybrid controller MCU](https://anabrid.dev/docs/hybrid-controller/) via
+USB Serial or TCP/IP.
+
+The code is successfully used on modern day GNU/Linux, Mac OS X and MS Windows.
+
+This code is written and maintained by [anabrid GmbH](https://anabrid.com/). It is released
+as open source (dual licensed as `MIT` and `GPL>=2`). It is supposed to be released at Github
+(**TODO**).
+
+## Installation
+
+Simply run `pip install pybrid-computing`. There is an explicit dependency to
+`pybrid-computing-base` released and maintained by the same authors, all other dependencies
+are widespread and thus relatively standard python packages.
+
+Installation should make a command line executable `pybrid` available on your shell. You can
+explore it by calling `pybrid` on your shell, which gives you, for instance:
+
+```
+% pybrid redac 
+Usage: pybrid redac [OPTIONS] COMMAND [ARGS]...
+
+  Entrypoint for all REDAC commands.
+
+  Use :code:`pybrid redac --help` to list all available sub-commands.
+
+Options:
+  -h, --host TEXT       Network name or address of the REDAC.
+  -p, --port INTEGER    Network port of the REDAC.
+  --reset / --no-reset  Whether to reset the REDAC after connecting.
+                        [default: reset]
+  --help                Show this message and exit.
+
+Commands:
+  display             Display the hardware structure of the REDAC.
+  get-entity-config   Get the configuration of an entity.
+  hack                Collects 'hack' commands, for development purposes...
+  reset               Reset the REDAC to initial configuration.
+  route               Route a signal on one cluster from one output of...
+  run                 Start a run (computation) and wait until it is...
+  set-alias           Define an alias for a path in an interactive...
+  set-connection      Set one or multiple connections in a U-Block or...
+  set-daq             Configure data acquisition of subsequent run commands.
+  set-element-config  Set one ATTRIBUTE to VALUE of the configuration of...
+  shell               Start an interactive shell and/or execute a REDAC...
+  user-program
+```
+
+## Documentation
+
+> **You can read the documentation online at https://anabrid.dev/docs/pybrid/html/**
+
+It is generated by the [Sphinx](https://www.sphinx-doc.org/) documentation which
+is part of this repository/package.
+
+## Getting started as developer
+
+This project is managed via the [poetry](https://python-poetry.org/) dependency
+manager for python. It allows for easy dependency installation, etc. You should
+make yourself comfortable with poetry (https://python-poetry.org/docs/basic-usage/).
+
+Note that the code is distributed amongst the `pybrid-computing` and `pybrid-computing-base`
+repositories. If you enter `poetry install` while being in one of these repositories with
+your shell, you can work on *that* python package "life". If you want to work on both of
+them, go to the `pybrid-computing` and edit the
+[path dependencies](https://python-poetry.org/docs/dependency-specification/#path-dependencies)
+in the `pyproject.toml`, for instance by replacing the line
+
+```
+...
+[tool.poetry.dependencies]
+...
+pybrid-computing-base = "^0, >=0.10.0"
+...
+```
+
+with something as in
+
+```
+pybrid-computing-base = { path = "/path/to/where/you/checked/out/pybrid-computing-base", develop = true } # instead of "^0, >=0.10.0"
+```
+
+After this edit, run `poetry install` again to update the paths.
+
+Some IDEs such as PyCharm can check this out by their own.
+
+

pybrid_computing-0.10.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+pybrid/cli/redac/__init__.py,sha256=dPUoJYWb2KcBzTbwomk1XzKTdKmyp02xBllejHOitS8,13601
+pybrid/redac/__init__.py,sha256=lOZOsXbBUcTO9YRDKBFw-odpvPWV9h3U4tsy3fkejo8,234
+pybrid/redac/blocks/__init__.py,sha256=Ur__3BVOaVR4P16oYHPtOX3Vemgz-9e4UEpKJ6-eV7g,319
+pybrid/redac/blocks/block.py,sha256=np_0lw4uT4W2SoYEcDiEEPNDntBy5h4qwd4fzicIFPo,1718
+pybrid/redac/blocks/cblock.py,sha256=_GJP-Lx_Fx0s15mPvTEl73wGtaFJw8IgCeFtV2LzFcY,945
+pybrid/redac/blocks/iblock.py,sha256=ZOWfJjtiKwwWf7gDDpJO5JzwinBw9bYtJfGRR77ljfQ,1758
+pybrid/redac/blocks/mblock.py,sha256=36Ys9DZlVLkYBzMtkL7celivwGAAqvcQWB0FkrnwxN4,1146
+pybrid/redac/blocks/ublock.py,sha256=-RX7-3ZRHEphyTtyo_xsBviTANiWTCcwzwa7mWI6ejw,2201
+pybrid/redac/carrier.py,sha256=5aNMRpb5hqP_gv1YL7AooJmWfe2FPxxpL3SWsUdUjvo,1471
+pybrid/redac/cluster.py,sha256=KLWH4hSciQtIjYtmMTRQCzLvhf5jDns9cUpADVtmgLM,3615
+pybrid/redac/computations.py,sha256=8sn6xabMSY1jfQLCCu6vfb7zVdfscA18QdQOd2GYoqo,1013
+pybrid/redac/computer.py,sha256=t5td9pCoMMDLO5u9LOsXqbw46Q8hgb63brk51CQxVJs,1145
+pybrid/redac/controller.py,sha256=wmuE03YUW1a9zthEwvZeCwJhW0YPu8b2w4iZgBSrMY0,6192
+pybrid/redac/data.py,sha256=VWQS7OKxa5H2S0jz8dyNauorWK9q8ZgPqW-CW3kzMXs,1796
+pybrid/redac/display.py,sha256=hEhRM4JzX8oN_jv9wa4uuP7oX8WDbSGBXmtYqH6iP_Q,989
+pybrid/redac/elements.py,sha256=AcX7iDYI_f2ZwsfmFCTJClPqI1MUYKBX0ZDhizXQvGE,1107
+pybrid/redac/entities.py,sha256=owgwBn0aASsgI7krRwWrvlDBiqmOH8f3giaTD3-nWNs,7678
+pybrid/redac/modules.py,sha256=5tiw-gVKeos78MUwNTKezVvVTd55_4RPFE-e5IthdOw,320
+pybrid/redac/protocol/__init__.py,sha256=PxRiShb7MZOYkTfrW5yyPBi0NiqYEp3UoBTESGzH5ac,1248
+pybrid/redac/protocol/envelope.py,sha256=2f5yMI_k0MFd6vzXJg7YrV_ed9n_VIXYYt6jnNSdasY,2522
+pybrid/redac/protocol/messages.py,sha256=AOywn4Sfuw7FQ-8kmb0xW4X7EtpnDgOYNgEGBgIIueA,27014
+pybrid/redac/protocol/protocol.py,sha256=b__SNU28cHdJaxD1HK6eLWme7jjuObtE4GTKV9GmBNY,9214
+pybrid/redac/protocol/serializer.py,sha256=-xHfCxtnrhlYCuffJ0UGcOhhUKJLog5Kmj0l1C-KYyg,1374
+pybrid/redac/protocol/types.py,sha256=IePxgxzwSGACVnTlEyuV4otwwLz8bJ_y-TVYP4BNOrM,518
+pybrid/redac/run.py,sha256=rcPHz1C8Pam6Qxac6EiE6qy7ICYEXPJFMGnd1mT8ups,4518
+pybrid_computing-0.10.0.dist-info/METADATA,sha256=I3euYeCOEiy_9KOvK8FXR9tuw346C5n2rAQVitH4Kj4,5907
+pybrid_computing-0.10.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pybrid_computing-0.10.0.dist-info/RECORD,,

pybrid_computing-0.10.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any