pycfdp 0.2.2__py3-none-any.whl

cfdp/shell/timer_service.py

@@ -0,0 +1,252 @@
+"""The shell's wall-clock timer table (design D6 / issue #17).
+
+A pure machine holds no clock and no thread; it only *emits* timer effects
+(``StartTimer/CancelTimer/SuspendTimer/ResumeTimer``) and *receives* an expiry
+as an injected ``EventType`` event. The :class:`TimerService` is the imperative
+shell that owns the actual wall-clock machinery: one timer per
+``(transaction, kind)``. On expiry it injects the corresponding event onto the
+entity's shared FIFO for the *owning* transaction (design D8 — the same door as
+every other event), so expiry never mutates machine state directly and never
+runs off the event thread.
+
+Semantics reproduced exactly from the old ``machines/timer.py`` +
+``base.Machine`` timer helpers (design D6, Parking-lot item 2):
+
+* **start** — (re)start: cancel any live timer for the key, then schedule anew.
+* **cancel** — cancel and *forget*: a cancelled timer cannot be resumed.
+* **suspend** — cancel *without* forgetting: the interval + event are remembered
+  so a later :meth:`resume` can restart the same timer (old
+  ``suspend_ack_timer`` = ``suspended = True`` + ``cancel()``).
+* **resume** — restart a suspended timer (old ``resume_ack_timer`` =
+  ``suspended = False`` + ``restart()``). A no-op if nothing was suspended.
+
+The **expiration-limit counter is NOT here** (design D6): it is protocol state
+that lives on the machine and survives suspend. The service just fires the
+event; the machine's handler increments its own counter and decides when the
+limit is reached. Freeze is likewise independent of the timer table — it is a
+machine-state flag, so nothing freeze-related lives here.
+
+**Thread-safety.** The default scheduler is :class:`threading.Timer`, so an
+expiry callback runs on a timer thread. The callback only calls
+``entity.trigger_event`` (a thread-safe queue put), marshalling the expiry onto
+the event thread rather than touching machine state. A lock guards the timer
+table so ``start/cancel/suspend/resume`` (run on the event thread) and an
+expiry callback (run on a timer thread) never corrupt it. :meth:`stop` cancels
+every outstanding timer so no timer thread leaks past entity shutdown.
+"""
+
+import threading
+
+from ..event import Event
+
+
+class _ThreadingScheduler:
+    """The real scheduler: one-shot :class:`threading.Timer` per timer.
+
+    Injected by default. Tests pass a manual scheduler instead so an expiry can
+    be fired synchronously with no wall-clock wait (issue #17 acceptance
+    criterion 4). The scheduler seam is intentionally tiny: ``schedule`` returns
+    an opaque handle, ``cancel`` cancels it.
+    """
+
+    def schedule(self, interval, callback):
+        timer = threading.Timer(interval, callback)
+        timer.daemon = True
+        timer.start()
+        return timer
+
+    def cancel(self, handle):
+        handle.cancel()
+        # ``Timer.cancel`` only prevents the action from running; the timer
+        # thread then unblocks and exits. Join it (briefly) so a cancelled
+        # timer leaves no lingering thread — the suite has active-thread-count
+        # assertions around entity shutdown that this must honor. Never join
+        # our own thread (an expiry callback that cancels its own timer).
+        if handle is not threading.current_thread():
+            handle.join(timeout=1)
+
+
+class _Timer:
+    """One entry in the timer table: its schedule state and how to re-arm it.
+
+    Holds the parameters needed to restart the timer (``interval``, the
+    ``event_type`` to inject) so :meth:`resume` can re-arm a suspended timer,
+    plus the live scheduler ``handle`` (``None`` when not currently running).
+    ``suspended`` records cancel-without-forget so ``resume`` knows to re-arm.
+    """
+
+    __slots__ = ("interval", "event_type", "handle", "suspended")
+
+    def __init__(self, interval, event_type):
+        self.interval = interval
+        self.event_type = event_type
+        self.handle = None
+        self.suspended = False
+
+
+class TimerService:
+    """The ``(tid, kind) -> timer`` table with suspend/resume semantics (D6)."""
+
+    def __init__(self, entity, scheduler=None):
+        self._entity = entity
+        self._scheduler = scheduler if scheduler is not None else _ThreadingScheduler()
+        # (tid, kind) -> _Timer
+        self._timers = {}
+        self._lock = threading.Lock()
+
+    # -- start / cancel ---------------------------------------------------- #
+
+    def start(self, tid, kind, interval, event_type):
+        """(Re)start the ``kind`` timer for ``tid`` (old ``restart``).
+
+        Cancels any live timer for the key first, then schedules anew. Clears
+        any suspended flag: an explicit (re)start supersedes a prior suspend.
+        """
+        stale_handle = None
+        with self._lock:
+            existing = self._timers.get((tid, kind))
+            if existing is not None:
+                # Collect the previous handle for cancellation *outside* the
+                # lock (never join under the lock — see :meth:`cancel`).
+                stale_handle = existing.handle
+            timer = _Timer(interval, event_type)
+            self._timers[(tid, kind)] = timer
+            self._arm(tid, kind, timer)
+        if stale_handle is not None:
+            self._scheduler.cancel(stale_handle)
+
+    def cancel(self, tid, kind):
+        """Cancel and *forget* the ``kind`` timer for ``tid`` (old ``cancel``).
+
+        A cancelled timer is removed entirely, so a later :meth:`resume` brings
+        nothing back. This is the difference from :meth:`suspend`.
+
+        The table entry is popped *inside* the lock so a concurrently-firing
+        :meth:`_on_expiry` sees ``timer is None`` and no-ops (no stale event is
+        injected). The scheduler ``cancel`` — which may ``join`` the timer
+        thread — runs *outside* the lock, so the event thread never blocks
+        joining a timer thread that is itself waiting on this lock.
+        """
+        handle = None
+        with self._lock:
+            timer = self._timers.pop((tid, kind), None)
+            if timer is not None:
+                handle = timer.handle
+        if handle is not None:
+            self._scheduler.cancel(handle)
+
+    # -- suspend / resume (cancel-without-forget / restart) ---------------- #
+
+    def suspend(self, tid, kind):
+        """Suspend the ``kind`` timer for ``tid`` (cancel-without-forget).
+
+        Mirrors the old ``suspend_ack_timer``: cancel the running timer but keep
+        the entry (and its interval/event) so :meth:`resume` can restart it.
+        A no-op if there is no such timer.
+        """
+        handle = None
+        with self._lock:
+            timer = self._timers.get((tid, kind))
+            if timer is None:
+                return
+            handle = timer.handle
+            timer.handle = None
+            timer.suspended = True
+        if handle is not None:
+            self._scheduler.cancel(handle)
+
+    def resume(self, tid, kind):
+        """Resume a suspended ``kind`` timer for ``tid`` (old ``resume`` = restart).
+
+        Only re-arms a timer that was actually suspended; resuming a running or
+        unknown timer is a no-op (it must not double-schedule).
+        """
+        with self._lock:
+            timer = self._timers.get((tid, kind))
+            if timer is None or not timer.suspended:
+                return
+            timer.suspended = False
+            self._arm(tid, kind, timer)
+
+    # -- cleanup ----------------------------------------------------------- #
+
+    def cancel_all(self, tid):
+        """Cancel and forget every timer for one transaction (completion/reap)."""
+        handles = []
+        with self._lock:
+            for t, kind in list(self._timers.keys()):
+                if t != tid:
+                    continue
+                timer = self._timers.pop((t, kind))
+                if timer.handle is not None:
+                    handles.append(timer.handle)
+        for handle in handles:
+            self._scheduler.cancel(handle)
+
+    def stop(self):
+        """Cancel every outstanding timer (entity shutdown). No thread leaks."""
+        handles = []
+        with self._lock:
+            for timer in self._timers.values():
+                if timer.handle is not None:
+                    handles.append(timer.handle)
+            self._timers.clear()
+        for handle in handles:
+            self._scheduler.cancel(handle)
+
+    # -- internals --------------------------------------------------------- #
+
+    def _arm(self, tid, kind, timer):
+        """Schedule ``timer`` so it injects its event on expiry. Caller holds lock."""
+        timer.handle = self._scheduler.schedule(
+            timer.interval, self._make_callback(tid, kind)
+        )
+
+    def _make_callback(self, tid, kind):
+        def _expired():
+            self._on_expiry(tid, kind)
+
+        return _expired
+
+    def _on_expiry(self, tid, kind):
+        """Timer-thread callback: marshal the expiry onto the entity FIFO (D8).
+
+        Reads the event type under the lock (the timer may have been cancelled
+        or replaced in a race), then injects the expiry outside the lock via the
+        entity's thread-safe ``trigger_event``.
+
+        **No machine mutation here (design D6, issue #29).** The ACK/NAK
+        expiration-limit counters are protocol state on the machine. Bumping them
+        from this timer thread was a lost-update race with the event thread (an
+        expiry callback reaching into ``entity.machines[tid]`` and calling
+        ``note_ack_timeout()``/``note_nak_timeout()`` while the event thread also
+        mutates the same machine). The bump now lives in
+        :meth:`cfdp.shell.dispatcher.Dispatcher.dispatch`, which runs
+        single-threaded on the event thread and bumps the counter immediately
+        before ``update_state`` reads it. E25/E26 are produced ONLY by this
+        service, so the dispatcher is the one safe place to do it. This callback
+        therefore only marshals the expiry event onto the FIFO and never touches
+        any machine state.
+        """
+        with self._lock:
+            timer = self._timers.get((tid, kind))
+            if timer is None:
+                return
+            event_type = timer.event_type
+            transaction = _TimerTransaction(tid)
+        self._entity.trigger_event(Event(transaction, event_type))
+
+
+class _TimerTransaction:
+    """A minimal transaction identity carrier for an injected expiry event.
+
+    The dispatcher routes events by ``event.transaction.id``, so the injected
+    expiry only needs to carry the owning ``tid``. This avoids the timer holding
+    a back-reference to the (frozen) transaction or the machine — the service
+    stays decoupled from both (design D6).
+    """
+
+    __slots__ = ("id",)
+
+    def __init__(self, tid):
+        self.id = tid

cfdp/transaction_handle.py

@@ -0,0 +1,50 @@
+import weakref
+
+
+class TransactionHandle:
+    """Rich return value from CfdpEntity.put() providing per-transaction controls."""
+
+    def __init__(self, entity, transaction_id):
+        self._entity_ref = weakref.ref(entity)
+        self._id = transaction_id
+
+    @property
+    def id(self):
+        return self._id
+
+    def _entity(self):
+        entity = self._entity_ref()
+        if entity is None or not entity._started:
+            raise RuntimeError("CfdpEntity has been stopped")
+        return entity
+
+    def cancel(self):
+        self._entity().cancel(self._id)
+
+    def suspend(self):
+        self._entity().suspend(self._id)
+
+    def resume(self):
+        self._entity().resume(self._id)
+
+    def report(self):
+        self._entity().report(self._id)
+
+    def is_complete(self):
+        entity = self._entity_ref()
+        if entity is None:
+            return True
+        return entity.is_complete(self._id)
+
+    def __iter__(self):
+        return iter(self._id)
+
+    def __eq__(self, other):
+        if isinstance(other, TransactionHandle):
+            return self._id == other._id
+        if isinstance(other, tuple):
+            return self._id == other
+        return NotImplemented
+
+    def __hash__(self):
+        return hash(self._id)

cfdp/transport/base.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+
+
+class Transport(ABC):
+    @abstractmethod
+    def send(self, data: bytes) -> None: ...
+    @abstractmethod
+    def start(self, on_receive) -> None: ...
+    @abstractmethod
+    def stop(self) -> None: ...
+    def is_ready(self) -> bool:
+        return True

cfdp/transport/spacepacket.py

@@ -0,0 +1,47 @@
+from spacepacket import SequenceFlags, SpacePacket
+
+from .base import Transport
+
+
+class SpacePacketTransport(Transport):
+    """Space Packet Protocol Transport for CFDP PDUs.
+
+    Wraps another Transport that carries raw bytes (e.g. UdpTransport).
+    CfdpEntity calls start(on_receive); this in turn calls the inner
+    transport's start() so no separate bind/start step is needed for it.
+    """
+
+    def __init__(self, apid, transport, packet_type):
+        super().__init__()
+        self.apid = apid
+        self.packet_type = packet_type
+        self._inner = transport
+        self._packet_sequence_count = 0
+        self._on_receive = None
+
+    def _get_next_packet_sequence_count(self):
+        self._packet_sequence_count += 1
+        return self._packet_sequence_count
+
+    def send(self, data: bytes) -> None:
+        space_packet = SpacePacket(
+            packet_type=self.packet_type,
+            packet_sec_hdr_flag=False,
+            apid=self.apid,
+            sequence_flags=SequenceFlags.UNSEGMENTED,
+            packet_sequence_count=self._get_next_packet_sequence_count(),
+            packet_data_field=data,
+        )
+        self._inner.send(space_packet.encode())
+
+    def start(self, on_receive) -> None:
+        self._on_receive = on_receive
+        self._inner.start(self._incoming_pdu_handler)
+
+    def stop(self) -> None:
+        self._inner.stop()
+
+    def _incoming_pdu_handler(self, raw: bytes) -> None:
+        packet = SpacePacket.decode(raw)
+        if self._on_receive:
+            self._on_receive(packet.packet_data_field)

cfdp/transport/udp.py

@@ -0,0 +1,90 @@
+import socket
+import threading
+
+from .base import Transport
+
+DEFAULT_MAXIMUM_PACKET_LENGTH = 4096
+
+
+class UdpTransport(Transport):
+    """UDP Transport for CFDP PDUs.
+
+    This transport is mostly used for testing and for prototypes.
+    The transport is realized by making each entity a host, which does `bind` to a port.
+    The other entity then sends directly PDUs to this other entity. Since UDP is connection-less
+    there is no need to establish a connection beforehand.
+
+    Call `bind(host, port)` to set the local address, then pass to CfdpEntity which calls
+    `start(on_receive)` to begin receiving. Call `stop()` to shut down.
+
+    Routing dictionary
+    ------------------
+    The ``routing`` parameter maps destination keys to lists of ``(host, port)`` tuples.
+
+    The special key ``"*"`` causes every outgoing PDU to be sent to all listed addresses::
+
+        routing = {"*": [("127.0.0.1", 5222)]}
+
+    Tuple keys ``(host, port)`` forward incoming PDUs received *from* that address on to
+    one or more other destinations (relay / repeater mode)::
+
+        routing = {
+            ("127.0.0.1", 5111): [("127.0.0.1", 5333)],
+        }
+
+    A typical two-entity local setup (entity 1 sends to entity 2 on port 5222)::
+
+        transport = UdpTransport(routing={"*": [("127.0.0.1", 5222)]})
+        transport.bind("127.0.0.1", 5111)
+    """
+
+    def __init__(self, routing, maximum_packet_length=DEFAULT_MAXIMUM_PACKET_LENGTH):
+        super().__init__()
+        self.routing = routing
+        self.maximum_packet_length = maximum_packet_length
+        self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 4194304)
+        self._thread = threading.Thread(target=self._incoming_pdu_handler, daemon=True)
+        self._thread.kill = False
+        self._on_receive = None
+        self._addr = None
+        self.send_count = 0
+        self.recv_count = 0
+
+    def bind(self, host, port):
+        self._addr = (host, port)
+        self._socket.bind((host, port))
+
+    def send(self, data: bytes) -> None:
+        self.send_count += 1
+        if self.routing and "*" in self.routing:
+            for address in self.routing["*"]:
+                host, port = address
+                self._socket.sendto(data, (host, int(port)))
+
+    def start(self, on_receive) -> None:
+        self._on_receive = on_receive
+        self._thread.kill = False
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._thread.kill = True
+        if self._addr:
+            self._socket.sendto(b"0", self._addr)  # break recvfrom loop
+        self._thread.join()
+        self._socket.close()
+
+    def _incoming_pdu_handler(self):
+        thread = threading.current_thread()
+        buffer_size = 10 * self.maximum_packet_length
+
+        while not thread.kill:
+            pdu, addr = self._socket.recvfrom(buffer_size)
+            self.recv_count += 1
+            if thread.kill:
+                break
+            if self.routing and addr in self.routing:
+                for dest in self.routing[addr]:
+                    self._socket.sendto(pdu, dest)
+            if self._on_receive:
+                self._on_receive(pdu)

cfdp/transport/zmq.py

@@ -0,0 +1,54 @@
+import threading
+
+import zmq
+
+from .base import Transport
+
+
+class ZmqTransport(Transport):
+    """ZMQ Transport for CFDP PDUs.
+
+    This transport is mostly used for testing and for prototypes.
+    A connection is established by making one entity the host, which does `bind` to a port,
+    and the other entity the client, which does `connect` to the host.
+
+    Call `bind(host, port)` or `connect(host, port)` to set up the socket, then pass to
+    CfdpEntity which calls `start(on_receive)` to begin receiving. Call `stop()` to shut down.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.context = zmq.Context()
+        self.socket = self.context.socket(zmq.PAIR)
+        self._thread = threading.Thread(target=self._incoming_pdu_handler, daemon=True)
+        self._thread.kill = False
+        self._on_receive = None
+
+    def bind(self, host, port):
+        self.socket.bind(f"tcp://{host}:{port}")
+
+    def connect(self, host, port):
+        self.socket.connect(f"tcp://{host}:{port}")
+
+    def send(self, data: bytes) -> None:
+        self.socket.send(data)
+
+    def start(self, on_receive) -> None:
+        self._on_receive = on_receive
+        self._thread.kill = False
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._thread.kill = True
+        self._thread.join()
+        self.context.destroy()
+
+    def _incoming_pdu_handler(self):
+        thread = threading.current_thread()
+        while not thread.kill:
+            if self.socket.poll(100):
+                if thread.kill:
+                    break
+                pdu = self.socket.recv()
+                if self._on_receive:
+                    self._on_receive(pdu)

pycfdp-0.2.2.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: pycfdp
+Version: 0.2.2
+Summary: Python implementation of CCSDS File Delivery Protocol (Modernized Fork)
+Author-email: Alex Pope <alexpopester@gmail.com>, "LibreCube (Original Codebase)" <info@librecube.org>
+License: MIT License
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Provides-Extra: zmq
+Requires-Dist: pyzmq; extra == "zmq"
+Provides-Extra: spacepacket
+Requires-Dist: spacepacket; extra == "spacepacket"
+Provides-Extra: all
+Requires-Dist: pyzmq; extra == "all"
+Requires-Dist: spacepacket; extra == "all"
+Dynamic: license-file
+
+# Python CFDP, Version 0.2
+
+The CCSDS File Delivery Protocol (CFDP) was developed by the
+[Consultative Committee for Space Data Systems (CCSDS)](https://public.ccsds.org).
+The CFDP protocol provides reliable transfer of files from one endpoint to
+another and has been designed to work well over space links that suffer
+from outtakes and long delays. The basic operation of CFDP is to transfer a
+file from a sender to a receiver (both referred to as CFDP entities). The
+sender and receiver must be configured and running at the same time to perform
+a file transfer. It can be used to perform  space to ground, ground to space,
+space to space, and ground to ground file transfers. For example it can be used
+to transfer science data from satellite over mission control to the science
+center in an automated fashion with minimal to no human intervention.
+
+This Python module is an implementation of the CCSDS File Delivery Protocol.
+It supports all features as outlined in the latest version of the [CFDP Blue Book](docs/727x0b5.pdf). These are:
+
+- Class 1 (unacknowledged) file transfer
+- Class 2 (acknowledged) file transfer
+- Filestore requests
+- Proxy operations
+- Directory listing request
+- Native filestore implementation
+- UDP as default transport layer (optional ZMQ)
+
+## Installation
+
+Clone the repository and then install via pip:
+
+```
+pip install cfdp
+```
+
+> Depending on the transport layer to use with CFDP, one needs to install additional dependencies.
+
+## Documentation
+
+Find the detailed documentation [here](docs/README.md).
+
+## Tests
+
+The protocol is tested for cross-support as outlined in CCSDS CFDP Yellow Book.
+See [tests/README.md](tests/README.md) for details.
+
+## Contribute
+
+To learn more on how to successfully contribute please read the contributing
+information in the [LibreCube documentation](https://librecube.gitlab.io/).
+
+## Support
+
+If you are having issues, please let us know. Reach us at
+[Matrix](https://app.element.io/#/room/#librecube.org:matrix.org)
+or via [Email](mailto:info@librecube.org).
+
+## License
+
+The project is licensed under the MIT license. See the [LICENSE](./LICENSE.txt) file for details.

pycfdp-0.2.2.dist-info/RECORD

@@ -0,0 +1,53 @@
+cfdp/__init__.py,sha256=LL8SZEEFxM8VuTjiyVAwmLLv87F_kISxR5B_o5SHcWc,2544
+cfdp/checksum.py,sha256=bdxNA5szavRewdMXV75UApySmkPHNPHieYcqqE8skfI,2822
+cfdp/constants.py,sha256=eZi0zmPuPVbs_G-_DnP4lwCUXZXksjC3sfr-iC3WtMU,3728
+cfdp/core.py,sha256=KiQzyXI0OOmfofkmsXAX1AkkhsIw5XV5Q_oNeNrgV6U,37885
+cfdp/event.py,sha256=TnG1pS9Jn-MFTCJO4rw1Nzko1ES8bBYN--LoENsWw3g,2651
+cfdp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfdp/remote_entity_config.py,sha256=Z6QRBZM2gGgXy1LKiMO8ULc2ElbmIwK68YkjD9psmkw,403
+cfdp/transaction_handle.py,sha256=oP8EXwQgKQaKL00YNhfciPXtga2YD0ap_hhkylczflc,1256
+cfdp/filestore/__init__.py,sha256=ikbR4utD7WuqxPp3FnXDyhceAxMtzTUwheKDCfvmP0c,83
+cfdp/filestore/base.py,sha256=_lZiY1f-cwpkKEcCRCV7wVysAllSjEr4nXfCSfZlEf0,2418
+cfdp/filestore/native.py,sha256=GSPAML-u9VT5Ijrak9G9nExSe627aFQ401OXkf-WuAo,5286
+cfdp/meta/__init__.py,sha256=B4cG2t1B_9imk4qGSDghBCGIycC6v9xfCvYnIAS_F5c,73
+cfdp/meta/datafield.py,sha256=D_gcefotAxyegNOtlASUM0DEPsa6p6g6Wqf5OH5F-zI,279
+cfdp/meta/filestore.py,sha256=tS2Kz2QMhHg54f3BaNcIHTE778m56QJZiCuo1Pvk__A,5048
+cfdp/meta/message.py,sha256=DKy6rSi8qkyELCjza50Y7BfCu0YiQSpEqujZD2lDLZw,22459
+cfdp/pdu/__init__.py,sha256=ht0APp7MeMvOiBvANzuF6x4M91NtdOPSH2Ega3cGFs0,177
+cfdp/pdu/ack.py,sha256=0OWzo4AwwbEVnu4p4A8kdwrN_9v7mcnZ3k-UwFRem78,3358
+cfdp/pdu/eof.py,sha256=jNC6DxRu-IPDYzkksNniR9RFdZqv_-sLeYZ5Jyjqdmo,4710
+cfdp/pdu/filedata.py,sha256=-Rk6MgwCypsE74fTZQoJA80dNuktLJHuny_Q9WmUEV0,3307
+cfdp/pdu/finished.py,sha256=NuuLI24FuXao21AqgfEiQKrAAtXVfPn3anvKaCbfDEk,3603
+cfdp/pdu/header.py,sha256=l-S2IaIrp8lNcz4bx9iIqmPwxXtJ5sCsm1C9gWeK5FM,5564
+cfdp/pdu/keep_alive.py,sha256=Pc9_hbHe-6rzkhll6fgj-dUuUwysGrVK8nmqZrbp-Zc,3802
+cfdp/pdu/metadata.py,sha256=6qekV8RnT-AxBeQN75HBBA5lvyiyU6nkT9TEbiQlW7c,7211
+cfdp/pdu/nak.py,sha256=6noKpP-zBg0Nuwasnq6vTOKCAJoVZL3zhtEqLXTSr-E,8250
+cfdp/pdu/prompt.py,sha256=d0Zn-2JSl-MA-vRj7mZmeIMOaKCCvVG5YSo1rz8dD3M,2779
+cfdp/pure/__init__.py,sha256=uHjS3O71KTbh1pO4MtuW0sBPvC01ECVXWpOOtTROvSQ,1669
+cfdp/pure/config.py,sha256=X4bWoyZFxJ-4k36MZMae0GygOie1DCI0gbbZyQyPsjU,5451
+cfdp/pure/indications.py,sha256=CMqcm0Ewm9hvb6U4gjX5AZ6uKFQ8cSRMkul99zQ8VWE,4761
+cfdp/pure/outputs.py,sha256=l42GkibAz7xfr3kC2rSZOrgk0dfaoY2X0gOaTUKrLTU,6151
+cfdp/pure/query_port.py,sha256=W6E91sDgXbqvAwBcPrcPfhNRvkbkErD5phKeq56KvCc,1930
+cfdp/pure/transaction.py,sha256=JJUQo6Anl_LG0-Ku6e1BY8MYgU4r-In52zZanoOCqqY,1792
+cfdp/pure/machines/__init__.py,sha256=Kq3mhWjl-4vZMqIVYz6NoonWVZP69aizo6e7HVWzcQc,1067
+cfdp/pure/machines/receiver1.py,sha256=JhGKlIb93Ea63IKhi-5Hy9PGh2CXF1LUV1hWKtcr_FA,17250
+cfdp/pure/machines/receiver2.py,sha256=775L-ykqIFkyGF3a5O_48fAfD7eZNbs5eQwYddyYx5M,34892
+cfdp/pure/machines/sender1.py,sha256=I99F3RO_xRhYzYYxUQkVzVxbySwhrMncWkimBOsYcF0,15972
+cfdp/pure/machines/sender2.py,sha256=ewQggAzj9R0of4KvJEZAzWwzptdvtPQJWoH2xb6oYmA,30902
+cfdp/shell/__init__.py,sha256=XF-aVp8CB5nK-wU4uMHqtn1yz86fwLQ8TZOXuQxGb3c,2129
+cfdp/shell/checksum_service.py,sha256=qxQn5eqbdtz_Dxn_gsEJNRiTBunTvveDHWDQ5GmUZZE,6201
+cfdp/shell/dispatcher.py,sha256=lvUck7rt33Th14xj05HksHX1QkvibOHdZ9oTE5MpqOs,8773
+cfdp/shell/effect_executor.py,sha256=atDkNmTHrh__2Mt-dgn1IdJJtox2jmjDXHBjK5wPl5Y,12369
+cfdp/shell/machine_registry.py,sha256=qcUzAB8yL4n1ss8C8MMm3vSuzA2wzNxfI9yN41cn_EI,6649
+cfdp/shell/query_port.py,sha256=Yy18A7nM8p9XjMleo02yJwlc69hKTzd_j3lvwbhIB3M,2809
+cfdp/shell/timer_service.py,sha256=We_xX1fw3DCa4zQAdClP_2DJHPQSpmijorYiJSlXxxE,10767
+cfdp/transport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfdp/transport/base.py,sha256=EknCGBCTSTan69Z6mStyfHt1Ss4465_bV8XcwbeNagc,294
+cfdp/transport/spacepacket.py,sha256=yPBO5ffhRpowA9tqIGqIQN_Ukwb4VgWx7jxC-nZyWMs,1562
+cfdp/transport/udp.py,sha256=-bAsS-uf800eyT_nVCalik8ODQ3_6C7-eHZeenGOEqA,3213
+cfdp/transport/zmq.py,sha256=y17olLqBqgd8_6lofdrztUh3M1phRBm6WCaJp7pGiXY,1680
+pycfdp-0.2.2.dist-info/licenses/LICENSE.txt,sha256=UIp30ue1HZit7tMmSK0SS3swJBqOcLLnLJn5LY5YdNE,1036
+pycfdp-0.2.2.dist-info/METADATA,sha256=i_8EQ3xDEGfzrnvrOdpveToquHERG5moj6iIptGpPVU,2747
+pycfdp-0.2.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pycfdp-0.2.2.dist-info/top_level.txt,sha256=Z1jvG2hdlWsdnR6V1AAoRebRKU-TWj41bUrGXPciBuk,5
+pycfdp-0.2.2.dist-info/RECORD,,

pycfdp-0.2.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pycfdp-0.2.2.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pycfdp-0.2.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+cfdp