scripts/notebooks/pybind11_examples/example_DataPlane.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python examples of DataPlane bindings\n",
    "\n",
    "Mimic the `e2sar_reas_test` in the C++ unit test suite."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import sys\n",
    "\n",
    "## IMPORTANT: Update the path to your built Python module. Use the absolute path to make life easier.\n",
    "sys.path.append(\n",
    "    '/home/ubuntu/dev-e2sar/build/src/pybind')\n",
    "\n",
    "import e2sar_py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# dir(e2sar_py.DataPlane)\n",
    "# dir(e2sar_py.DataPlane.Reassembler)\n",
    "# dir(e2sar_py.DataPlane.Segmenter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "DP_IPV4_ADDR = \"127.0.0.1\"\n",
    "DP_IPV4_PORT = 10000\n",
    "DATA_ID = 0x0505   # decimal value: 1085\n",
    "EVENTSRC_ID = 0x11223344   # decimal value: 287454020"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DPReasTest1\n",
    "\n",
    "This is a test that uses local host to send/receive fragments. It does NOT use control plane.\n",
    "\n",
    "\n",
    "1. First initialize \"Segmenter\" objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Segmenter flags:\n",
      "  syncPeriodMs=1000\n",
      "  useCP=False\n",
      "  mtu=1500\n",
      "  syncPeriods=5\n"
     ]
    }
   ],
   "source": [
    "# Set up URI for segmenter\n",
    "SEG_URI = f\"ejfat://useless@192.168.100.1:9876/lb/1?sync=192.168.0.1:12345&data={DP_IPV4_ADDR}:{DP_IPV4_PORT}\"\n",
    "seg_uri = e2sar_py.EjfatURI(uri=SEG_URI, tt=e2sar_py.EjfatURI.TokenType.instance)\n",
    "\n",
    "# Set up sflags\n",
    "sflags = e2sar_py.DataPlane.SegmenterFlags()\n",
    "sflags.useCP = False  # turn off CP. Default value is True\n",
    "sflags.syncPeriodMs = 1000\n",
    "sflags.syncPeriods = 5\n",
    "\n",
    "assert(sflags.syncPeriodMs == 1000)\n",
    "assert(sflags.useCP == False)\n",
    "assert(sflags.syncPeriods == 5)\n",
    "\n",
    "print(\"Segmenter flags:\")\n",
    "print(f\"  syncPeriodMs={sflags.syncPeriodMs}\")\n",
    "print(f\"  useCP={sflags.useCP}\")\n",
    "print(f\"  mtu={sflags.mtu}\")\n",
    "print(f\"  syncPeriods={sflags.syncPeriods}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Init segmenter object\n",
    "seg = e2sar_py.DataPlane.Segmenter(seg_uri, DATA_ID, EVENTSRC_ID, sflags)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The message we need to send."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.'\n",
      "65\n"
     ]
    }
   ],
   "source": [
    "SEND_STR = \"THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\"\n",
    "\n",
    "send_context = SEND_STR.encode('utf-8')\n",
    "print(send_context)\n",
    "print(len(send_context))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Initilize the Reassembler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instance Token: useless\n",
      "Data Plane Address (v4): 127.0.0.1\n",
      "Reassembler flags:\n",
      "  period_ms=100\n",
      "  useCP=False\n",
      "  validateCert = True\n",
      "  epoch_ms = 1000\n",
      "  setPoint = 0.0\n",
      "  [Kp, Ki, Kd] = [0.0, 0.0, 0.0]\n",
      "  [weight, min_factor, max_factor] = [1.0, 0.5, 2.0]\n",
      "  portRange = -1\n",
      "  withLBHeader = True\n"
     ]
    }
   ],
   "source": [
    "# Set the reassembler URI\n",
    "REAS_URI_ = f\"ejfat://useless@192.168.100.1:9876/lb/1?sync=192.168.0.1:12345&data={DP_IPV4_ADDR}\"\n",
    "reas_uri = e2sar_py.EjfatURI(uri=REAS_URI_, tt=e2sar_py.EjfatURI.TokenType.instance)\n",
    "\n",
    "# Make sure the token matches the one in the string\n",
    "def get_inst_token(uri : e2sar_py.EjfatURI):\n",
    "    try:\n",
    "        token = uri.get_instance_token().value()\n",
    "        print(\"Instance Token:\", token)\n",
    "    except RuntimeError as e:\n",
    "        print(\"Instance Token - Error:\", e)\n",
    "\n",
    "get_inst_token(reas_uri)\n",
    "\n",
    "# Get data plane IPv4 address\n",
    "print(\"Data Plane Address (v4):\", str(reas_uri.get_data_addr_v4().value()[0]))\n",
    "\n",
    "# Config the reassembler flags\n",
    "\n",
    "rflags = e2sar_py.DataPlane.ReassemblerFlags()\n",
    "rflags.useCP = False  # turn off CP. Default value is True\n",
    "rflags.withLBHeader = True  # LB header will be attached since there is no LB\n",
    "\n",
    "assert rflags.period_ms == 100  # default value of the C++ constructor\n",
    "assert rflags.useCP == False\n",
    "\n",
    "print(\"Reassembler flags:\")\n",
    "print(f\"  period_ms={rflags.period_ms}\")  # should be 100 according to the C++ constructor\n",
    "print(f\"  useCP={rflags.useCP}\")\n",
    "print(f\"  validateCert = {rflags.validateCert}\")\n",
    "print(f\"  epoch_ms = {rflags.epoch_ms}\")\n",
    "print(f\"  setPoint = {rflags.setPoint}\")\n",
    "print(f\"  [Kp, Ki, Kd] = [{rflags.Kp}, {rflags.Ki}, {rflags.Kd}]\")\n",
    "print(f\"  [weight, min_factor, max_factor] = [{rflags.weight}, {rflags.min_factor}, {rflags.max_factor}]\")\n",
    "print(f\"  portRange = {rflags.portRange}\")\n",
    "print(f\"  withLBHeader = {rflags.withLBHeader}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Init the reassembler object\n",
    "reas = e2sar_py.DataPlane.Reassembler(\n",
    "    reas_uri, e2sar_py.IPAddress.from_string(DP_IPV4_ADDR), DP_IPV4_PORT, 1, rflags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "res = reas.OpenAndStart()  # the DP address must be available\n",
    "assert res.value() == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0, 0, 0, 0, <E2SARErrorc.NoError: 0>)\n"
     ]
    }
   ],
   "source": [
    "res = reas.getStats()\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Send the contexts with the Segmenter object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start segmenter threads\n",
    "res = seg.OpenAndStart()\n",
    "assert res.value() == 0\n",
    "\n",
    "res = seg.getSendStats()\n",
    "if (res[1] != 0):\n",
    "    print(f\"Error encountered after opening send socket: {res[2]}\")\n",
    "    # exit(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sending data...                Rd 0\n",
      "Sending data...                Rd 1\n",
      "Sending data...                Rd 2\n",
      "Sending data...                Rd 3\n",
      "Sending data...                Rd 4\n",
      "Sent 5 data frames\n"
     ]
    }
   ],
   "source": [
    "# Send the data\n",
    "for i in range(5):\n",
    "    print(f\"Sending data...                Rd {i}\")\n",
    "    res = seg.addToSendQueue(send_context, len(send_context))\n",
    "    assert(res.value() == 0)\n",
    "    res = seg.getSendStats()\n",
    "    if (res[1] != 0):\n",
    "        print(f\"  SendStats: {res}\")\n",
    "        print(f\"  Error encountered sending event frame: {i}, error: {res[2]}\")\n",
    "    time.sleep(1)\n",
    "\n",
    "res = seg.getSendStats()\n",
    "# assert(res[0] == 5)  # hold for the first run\n",
    "print(f\"Sent {res[0]} data frames\")\n",
    "\n",
    "if (res[1] != 0):\n",
    "    print(f\"SendStats: {res}\")\n",
    "    print(f\"After sending data --  error: {res[2]}\")\n",
    "    # exit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Receiving data...                Rd 0\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\n",
      "  bufLen:\t 65\n",
      "  eventNum:\t 0\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 1\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\n",
      "  bufLen:\t 65\n",
      "  eventNum:\t 1\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 2\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\n",
      "  bufLen:\t 65\n",
      "  eventNum:\t 2\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 3\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\n",
      "  bufLen:\t 65\n",
      "  eventNum:\t 3\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 4\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\n",
      "  bufLen:\t 65\n",
      "  eventNum:\t 4\n",
      "  dataId:\t 1285\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Prepare Python list to hold the output data\n",
    "recv_bytes_list = [None]  # Placeholder for the byte buffer\n",
    "\n",
    "# Call getEvent on the instance\n",
    "for i in range(5):\n",
    "    print(f\"Receiving data...                Rd {i}\")\n",
    "    res, recv_event_len, recv_event_num, recv_data_id = reas.getEvent(recv_bytes_list)\n",
    "\n",
    "    if (res != 0):  # -1 or -2 (has_error)\n",
    "        continue\n",
    "    recv = recv_bytes_list[0].decode('utf-8')\n",
    "    print(f\"  recv_buf:\\t {recv}\")\n",
    "    assert(recv_data_id == DATA_ID)\n",
    "    print(f\"  bufLen:\\t {recv_event_len}\")\n",
    "    print(f\"  eventNum:\\t {recv_event_num}\")\n",
    "    print(f\"  dataId:\\t {recv_data_id}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "reas_status = reas.getStats()\n",
    "assert(reas_status[0] == 0)  # no losses\n",
    "assert(reas_status[1] == 5)  # all succeeded\n",
    "assert(reas_status[2] == 0)  # no errno\n",
    "assert(reas_status[3] == 0)  # no grpc errors\n",
    "assert(reas_status[4] == 0)  # no data errors\n",
    "assert(reas_status[5] == e2sar_py.E2SARErrorc.NoError) # no error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if there is any lost event."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO EVENT LOSS\n"
     ]
    }
   ],
   "source": [
    "if reas.get_LostEvent().has_error():\n",
    "    print(\"NO EVENT LOSS\")\n",
    "else:\n",
    "    print(f\"LOST EVENT: ({reas.get_LostEvent().value()[0]}, {reas.get_LostEvent().value()[1]})\")\n",
    "\n",
    "assert(reas.get_LostEvent().error().code == e2sar_py.E2SARErrorc.NotFound)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DPReasTest2\n",
    "\n",
    "Test segmentation and reassembly on local host with no control plane (basic segmentation) using small MTU."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Segmenter flags:\n",
      "  syncPeriodMs=1000\n",
      "  useCP=False\n",
      "  mtu=80\n",
      "  syncPeriods=5\n"
     ]
    }
   ],
   "source": [
    "# Set up sflags\n",
    "sflags2 = e2sar_py.DataPlane.SegmenterFlags()\n",
    "sflags2.useCP = False  # turn off CP. Default value is True\n",
    "sflags2.syncPeriodMs = 1000\n",
    "sflags2.syncPeriods = 5\n",
    "sflags2.mtu = 80\n",
    "\n",
    "assert(sflags2.syncPeriodMs == 1000)\n",
    "assert(sflags2.useCP == False)\n",
    "assert(sflags2.syncPeriods == 5)\n",
    "assert(sflags2.mtu == 80)\n",
    "\n",
    "print(\"Segmenter flags:\")\n",
    "print(f\"  syncPeriodMs={sflags2.syncPeriodMs}\")\n",
    "print(f\"  useCP={sflags2.useCP}\")\n",
    "print(f\"  mtu={sflags2.mtu}\")\n",
    "print(f\"  syncPeriods={sflags2.syncPeriods}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "SEG_URI2 = f\"ejfat://useless@192.168.100.1:9876/lb/1?sync=192.168.0.1:12345&data={DP_IPV4_ADDR}:{DP_IPV4_PORT}\"\n",
    "seg_uri2 = e2sar_py.EjfatURI(uri=SEG_URI2, tt=e2sar_py.EjfatURI.TokenType.instance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize a new Segmenter objects\n",
    "seg2 = e2sar_py.DataPlane.Segmenter(seg_uri2, DATA_ID, EVENTSRC_ID, sflags2)\n",
    "\n",
    "res = seg2.OpenAndStart()\n",
    "assert(res.value() == 0)\n",
    "\n",
    "res = seg2.getSendStats()\n",
    "if (res[1] != 0):\n",
    "    print(f\"Error encountered after opening send socket: {res[2]}\")\n",
    "    # exit(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sending data...                Rd 0\n",
      "Sending data...                Rd 1\n",
      "Sending data...                Rd 2\n",
      "Sending data...                Rd 3\n",
      "Sending data...                Rd 4\n",
      "Sent 25 data frames\n"
     ]
    }
   ],
   "source": [
    "# Send data with the small MTU\n",
    "for i in range(5):\n",
    "    print(f\"Sending data...                Rd {i}\")\n",
    "    res = seg2.addToSendQueue(send_context, len(send_context))\n",
    "    assert(res.value() == 0)\n",
    "    res = seg2.getSendStats()\n",
    "    # print(f\"  getSendStats:\\t {res}\")\n",
    "    if (res[1] != 0):\n",
    "        print(f\"  SendStats: {res}\")\n",
    "        print(f\"  Error encountered sending event frame: {i}, error: {res[2]}\")\n",
    "    time.sleep(1)\n",
    "\n",
    "res = seg2.getSendStats()\n",
    "# assert(res[0] == 25)  # hold for the 1st run\n",
    "print(f\"Sent {res[0]} data frames\")\n",
    "\n",
    "if (res[1] != 0):\n",
    "    print(f\"SendStats: {res}\")\n",
    "    print(f\"After sending data --  error: {res[2]}\")\n",
    "    # exit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Receiving data...                Rd 0\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\n",
      "  bufLen:\t 65\n",
      "  eventNum:\t 0\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 1\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\n",
      "  bufLen:\t 65\n",
      "  eventNum:\t 1\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 2\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\n",
      "  bufLen:\t 65\n",
      "  eventNum:\t 2\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 3\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\n",
      "  bufLen:\t 65\n",
      "  eventNum:\t 3\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 4\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE WE WANT TO SEND EVERY 1 SECOND.\n",
      "  bufLen:\t 65\n",
      "  eventNum:\t 4\n",
      "  dataId:\t 1285\n"
     ]
    }
   ],
   "source": [
    "# Prepare Python list to hold the output data\n",
    "recv_bytes_list = [None]  # Placeholder for the byte buffer\n",
    "\n",
    "# Call getEvent on the instance\n",
    "for i in range(5):\n",
    "    print(f\"Receiving data...                Rd {i}\")\n",
    "    res, recv_event_len, recv_event_num, recv_data_id = reas.getEvent(recv_bytes_list)\n",
    "\n",
    "    if (res != 0):  # -1 or -2 (has_error)\n",
    "        continue\n",
    "    recv = recv_bytes_list[0].decode('utf-8')\n",
    "    print(f\"  recv_buf:\\t {recv}\")\n",
    "    assert(recv_data_id == DATA_ID)\n",
    "    print(f\"  bufLen:\\t {recv_event_len}\")\n",
    "    print(f\"  eventNum:\\t {recv_event_num}\")\n",
    "    print(f\"  dataId:\\t {recv_data_id}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 10, 0, 0, 0, <E2SARErrorc.NoError: 0>)\n",
      "NO EVENT LOSS\n"
     ]
    }
   ],
   "source": [
    "# Validation\n",
    "reas_status = reas.getStats()\n",
    "print(reas_status)\n",
    "\n",
    "assert(reas_status[0] == 0)  # no losses\n",
    "# assert(reas_status[1] == 5)  # NOTE: this number is accumulated. So it's not always 5. \n",
    "assert(reas_status[2] == 0)  # no errno\n",
    "assert(reas_status[3] == 0)  # no grpc errors\n",
    "assert(reas_status[4] == 0)  # no data errors\n",
    "assert(reas_status[5] == e2sar_py.E2SARErrorc.NoError) # no error\n",
    "\n",
    "\n",
    "if reas.get_LostEvent().has_error():\n",
    "    print(\"NO EVENT LOSS\")\n",
    "else:\n",
    "    print(f\"LOST EVENT: ({reas.get_LostEvent().value()[0]}, {reas.get_LostEvent().value()[1]})\")\n",
    "\n",
    "assert(reas.get_LostEvent().error().code == e2sar_py.E2SARErrorc.NotFound)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DPReasTest3\n",
    "\n",
    "Test creationg of reassemblers with different parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This reassembler has\n",
      "   1 threads;\n",
      "   listening on ports 19522:19522;\n",
      "   using portRange: 0.\n"
     ]
    }
   ],
   "source": [
    "# Create reassembler with 1 recv thread\n",
    "\n",
    "rflags_m = e2sar_py.DataPlane.ReassemblerFlags()\n",
    "reas_a = e2sar_py.DataPlane.Reassembler(\n",
    "    reas_uri, e2sar_py.IPAddress.from_string(DP_IPV4_ADDR), 19522, 1, rflags_m)\n",
    "\n",
    "print(\"This reassembler has\")\n",
    "print(f\"   {reas_a.get_numRecvThreads()} threads;\")\n",
    "print(f\"   listening on ports {reas_a.get_recvPorts()[0]}:{reas_a.get_recvPorts()[1]};\")\n",
    "print(f\"   using portRange: {reas_a.get_portRange()}.\")\n",
    "\n",
    "assert reas_a.get_numRecvThreads() == 1\n",
    "assert reas_a.get_recvPorts() == (19522, 19522)\n",
    "assert reas_a.get_portRange() == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This reassembler has\n",
      "   4 threads;\n",
      "   listening on ports 19522:19525;\n",
      "   using portRange: 2.\n"
     ]
    }
   ],
   "source": [
    "# Create reassembler with 4 recv threads\n",
    "reas_b = e2sar_py.DataPlane.Reassembler(\n",
    "    reas_uri, e2sar_py.IPAddress.from_string(DP_IPV4_ADDR), 19522, 4, rflags_m)\n",
    "\n",
    "print(\"This reassembler has\")\n",
    "print(f\"   {reas_b.get_numRecvThreads()} threads;\")\n",
    "print(f\"   listening on ports {reas_b.get_recvPorts()[0]}:{reas_b.get_recvPorts()[1]};\")\n",
    "print(f\"   using portRange: {reas_b.get_portRange()}.\")\n",
    "\n",
    "assert reas_b.get_numRecvThreads() == 4\n",
    "assert reas_b.get_recvPorts() == (19522, 19525)\n",
    "assert reas_b.get_portRange() == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This reassembler has\n",
      "   7 threads;\n",
      "   listening on ports 19522:19529;\n",
      "   using portRange: 3.\n"
     ]
    }
   ],
   "source": [
    "# Create reassembler with 7 recv threads\n",
    "reas_c = e2sar_py.DataPlane.Reassembler(\n",
    "    reas_uri, e2sar_py.IPAddress.from_string(DP_IPV4_ADDR), 19522, 7, rflags_m)\n",
    "\n",
    "print(\"This reassembler has\")\n",
    "print(f\"   {reas_c.get_numRecvThreads()} threads;\")\n",
    "print(f\"   listening on ports {reas_c.get_recvPorts()[0]}:{reas_c.get_recvPorts()[1]};\")\n",
    "print(f\"   using portRange: {reas_c.get_portRange()}.\")\n",
    "\n",
    "assert reas_c.get_numRecvThreads() == 7\n",
    "assert reas_c.get_recvPorts() == (19522, 19529)\n",
    "assert reas_c.get_portRange() == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This reassembler has\n",
      "   4 threads;\n",
      "   listening on ports 19522:20545;\n",
      "   using portRange: 10.\n"
     ]
    }
   ],
   "source": [
    "# 4 threads with portRange override\n",
    "rflags_m.portRange = 10\n",
    "\n",
    "reas_d = e2sar_py.DataPlane.Reassembler(\n",
    "    reas_uri, e2sar_py.IPAddress.from_string(DP_IPV4_ADDR), 19522, 4, rflags_m)\n",
    "\n",
    "print(\"This reassembler has\")\n",
    "print(f\"   {reas_d.get_numRecvThreads()} threads;\")\n",
    "print(f\"   listening on ports {reas_d.get_recvPorts()[0]}:{reas_d.get_recvPorts()[1]};\")\n",
    "print(f\"   using portRange: {reas_d.get_portRange()}.\")\n",
    "\n",
    "assert reas_d.get_numRecvThreads() == 4\n",
    "assert reas_d.get_recvPorts() == (19522, 20545)\n",
    "assert reas_d.get_portRange() == 10\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This reassembler has\n",
      "   4 threads;\n",
      "   listening on ports 19522:19523;\n",
      "   using portRange: 1.\n"
     ]
    }
   ],
   "source": [
    "# 4 threads with low portRange override\n",
    "rflags_m.portRange = 1\n",
    "\n",
    "reas_e = e2sar_py.DataPlane.Reassembler(\n",
    "    reas_uri, e2sar_py.IPAddress.from_string(DP_IPV4_ADDR), 19522, 4, rflags_m)\n",
    "\n",
    "print(\"This reassembler has\")\n",
    "print(f\"   {reas_e.get_numRecvThreads()} threads;\")\n",
    "print(f\"   listening on ports {reas_e.get_recvPorts()[0]}:{reas_e.get_recvPorts()[1]};\")\n",
    "print(f\"   using portRange: {reas_e.get_portRange()}.\")\n",
    "\n",
    "assert reas_e.get_numRecvThreads() == 4\n",
    "assert reas_e.get_recvPorts() == (19522, 19523)\n",
    "assert reas_e.get_portRange() == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DPReasTest4\n",
    "\n",
    "Test segmentation and reassembly on local host (no control plane) with multiple segementer threads.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating Segmenter with uri:\n",
      "    ejfat://useless@192.168.100.1:9876/lb/1?sync=192.168.0.1:12345&data=127.0.0.1:19522\n",
      "Creating Segmenter with uri:\n",
      "    ejfat://useless@192.168.100.1:9876/lb/1?sync=192.168.0.1:12345&data=127.0.0.1:19523\n",
      "Creating Segmenter with uri:\n",
      "    ejfat://useless@192.168.100.1:9876/lb/1?sync=192.168.0.1:12345&data=127.0.0.1:19524\n",
      "Creating Segmenter with uri:\n",
      "    ejfat://useless@192.168.100.1:9876/lb/1?sync=192.168.0.1:12345&data=127.0.0.1:19525\n"
     ]
    }
   ],
   "source": [
    "# Create 4 segmenter objects\n",
    "\n",
    "SEG_URI_BASE = f\"ejfat://useless@192.168.100.1:9876/lb/1?sync=192.168.0.1:12345&data={DP_IPV4_ADDR}\"\n",
    "SEG_URI_PORT_BASE = 19522\n",
    "\n",
    "sflags = e2sar_py.DataPlane.SegmenterFlags()\n",
    "sflags.syncPeriodMs = 1000\n",
    "sflags.syncPeriods = 5\n",
    "sflags.useCP = False\n",
    "\n",
    "def create_seg_obj(\n",
    "        seg_idx: int,\n",
    "        data_idx, evt_SrcId,\n",
    "        seg_flags : e2sar_py.DataPlane.SegmenterFlags\n",
    "        ) -> e2sar_py.DataPlane.Segmenter:\n",
    "    seg_port = SEG_URI_PORT_BASE + seg_idx\n",
    "    seg_uri = SEG_URI_BASE + \":\" + str(seg_port)\n",
    "    print(f\"Creating Segmenter with uri:\\n    {seg_uri}\")\n",
    "    return e2sar_py.DataPlane.Segmenter(\n",
    "        e2sar_py.EjfatURI(uri=seg_uri, tt=e2sar_py.EjfatURI.TokenType.instance),\n",
    "        data_idx, evt_SrcId, seg_flags)\n",
    "\n",
    "\n",
    "seg_obj_list = []\n",
    "for i in range(4):\n",
    "    seg_obj_list.append(create_seg_obj(\n",
    "        i, DATA_ID, EVENTSRC_ID, sflags))\n",
    "assert len(seg_obj_list) == 4\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This reassembler has\n",
      "   1 threads;\n",
      "   listening on ports 19522:19525;\n",
      "   using portRange: 2.\n"
     ]
    }
   ],
   "source": [
    "# Create reassembler with no control plane. 1 recv thread listening on 4 ports.\n",
    "\n",
    "rflags = e2sar_py.DataPlane.ReassemblerFlags()\n",
    "rflags.useCP = False  # turn off CP\n",
    "rflags.withLBHeader = True   # LB header will be attached since there is no LB\n",
    "rflags.portRange = 2   # use 2^portRange=4 ports\n",
    "\n",
    "reas = e2sar_py.DataPlane.Reassembler(\n",
    "    reas_uri, e2sar_py.IPAddress.from_string(DP_IPV4_ADDR), 19522, 1, rflags)\n",
    "print(\"This reassembler has\")\n",
    "print(f\"   {reas.get_numRecvThreads()} threads;\")\n",
    "print(f\"   listening on ports {reas.get_recvPorts()[0]}:{reas.get_recvPorts()[1]};\")\n",
    "print(f\"   using portRange: {reas.get_portRange()}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seg1.openAndStart()\n",
      "Seg2.openAndStart()\n",
      "Seg3.openAndStart()\n",
      "Seg4.openAndStart()\n"
     ]
    }
   ],
   "source": [
    "# Start the 4 segmenters\n",
    "for i in range(4):\n",
    "    print(f\"Seg{i + 1}.openAndStart()\")\n",
    "    res = seg_obj_list[i].OpenAndStart()\n",
    "    if (res.has_error()):\n",
    "        print(f\"    Error encountered opening sockets and starting segmenter{i + 1} threads: {res.error().message()}\")\n",
    "    assert res.value() == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start the reassembler\n",
    "res = reas.OpenAndStart()\n",
    "if (res.has_error()):\n",
    "    print(f\"    Error encountered opening sockets and starting reassembler threads: {res.error().message()}\")\n",
    "    assert res.value() == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the sender stats\n",
    "for i in range(4):\n",
    "    res = seg_obj_list[i].getSendStats()\n",
    "    if (res[1] != 0):\n",
    "        print(f\"Error encountered after opening send socket in segmenter{i + 1}: {res[2]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Segmenter 1 sent 5 data frames\n",
      "Segmenter 2 sent 5 data frames\n",
      "Segmenter 3 sent 5 data frames\n",
      "Segmenter 4 sent 5 data frames\n"
     ]
    }
   ],
   "source": [
    "def get_send_str(idx):\n",
    "    prefix_str = \"THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER\"\n",
    "    suffix_str = \" WE WANT TO SEND EVERY 1 MILLISECOND.\"\n",
    "    return prefix_str + str(idx) + suffix_str\n",
    "\n",
    "def send_data_async(\n",
    "        segmenter : e2sar_py.DataPlane.Segmenter,\n",
    "        send_str : str,\n",
    "        seg_id: int,\n",
    "        msg_id: int) -> None:\n",
    "    # print(f\"Segmenter{seg_id + 1} is sending message {msg_id + 1}...\")\n",
    "    res = segmenter.addToSendQueue(send_str.encode('utf-8'), len(send_str),(1 + seg_id) * 1000 + msg_id)\n",
    "    assert res.value() == 0\n",
    "    res = segmenter.getSendStats()\n",
    "    # print(f\"  getSendStats:\\t {res}\")\n",
    "    if (res[1] != 0):\n",
    "        print(f\"  SendStats: {res}\")\n",
    "        print(f\"  Error encountered sending event frames in Segmenter{seg_id + 1}: {res[2]}\")\n",
    "\n",
    "for msg_id in range(5):\n",
    "    for seg_id in range(4):\n",
    "        send_data_async(seg_obj_list[seg_id], get_send_str(seg_id), seg_id, msg_id)\n",
    "        time.sleep(0.001)\n",
    "\n",
    "# Print the sent frames\n",
    "for seg_id in range(4):\n",
    "    res = seg_obj_list[seg_id].getSendStats()\n",
    "    print(f\"Segmenter {seg_id + 1} sent {res[0]} data frames\")\n",
    "    assert(res[1] == 0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Receiving data...                Rd 0\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER0 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 1000\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 1\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER1 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 2000\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 2\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER2 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 3000\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 3\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER3 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 4000\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 4\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER0 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 1001\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 5\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER1 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 2001\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 6\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER2 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 3001\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 7\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER3 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 4001\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 8\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER0 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 1002\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 9\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER1 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 2002\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 10\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER2 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 3002\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 11\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER3 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 4002\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 12\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER0 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 1003\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 13\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER1 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 2003\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 14\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER2 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 3003\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 15\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER3 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 4003\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 16\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER0 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 1004\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 17\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER1 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 2004\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 18\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER2 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 3004\n",
      "  dataId:\t 1285\n",
      "Receiving data...                Rd 19\n",
      "  recv_buf:\t THIS IS A VERY LONG EVENT MESSAGE FROM SEGMENTER3 WE WANT TO SEND EVERY 1 MILLISECOND.\n",
      "  bufLen:\t 86\n",
      "  eventNum:\t 4004\n",
      "  dataId:\t 1285\n",
      "Reassembler stats: (0, 20, 0, 0, 0, <E2SARErrorc.NoError: 0>)\n"
     ]
    }
   ],
   "source": [
    "# Prepare Python list to hold the output data\n",
    "recv_bytes_list = [None]  # Placeholder for the byte buffer\n",
    "\n",
    "# Call getEvent on the instance\n",
    "for i in range(20):\n",
    "    print(f\"Receiving data...                Rd {i}\")\n",
    "    res, recv_event_len, recv_event_num, recv_data_id = reas.getEvent(recv_bytes_list)\n",
    "\n",
    "    if (res != 0):  # -1 or -2 (has_error)\n",
    "        continue\n",
    "    recv = recv_bytes_list[0].decode('utf-8')\n",
    "    print(f\"  recv_buf:\\t {recv}\")\n",
    "    print(f\"  bufLen:\\t {recv_event_len}\")\n",
    "    print(f\"  eventNum:\\t {recv_event_num}\")\n",
    "    print(f\"  dataId:\\t {recv_data_id}\")\n",
    "\n",
    "res = reas.getStats()\n",
    "print(f\"Reassembler stats: {res}\")\n",
    "\n",
    "assert(res[0] == 0)  # no losses\n",
    "# assert(res[1] == 20)  # hold for the 1st try"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO EVENT LOSS\n"
     ]
    }
   ],
   "source": [
    "# Validation\n",
    "if reas.get_LostEvent().has_error():\n",
    "    print(\"NO EVENT LOSS\")\n",
    "else:\n",
    "    print(f\"LOST EVENT: ({reas.get_LostEvent().value()[0]}, {reas.get_LostEvent().value()[1]})\")\n",
    "\n",
    "assert(reas.get_LostEvent().error().code == e2sar_py.E2SARErrorc.NotFound)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DPReasTest5\n",
    "\n",
    "Examples of reading SegmenterFlags from INI files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Init ReassemblerFlag successfully!\n"
     ]
    }
   ],
   "source": [
    "# Reassembler\n",
    "res_flag = e2sar_py.DataPlane.ReassemblerFlags.getFromINI(\n",
    "    '/home/ubuntu/dev-e2sar/reassembler_config.ini'\n",
    ")\n",
    "\n",
    "if res_flag.has_error():\n",
    "    print(f\"Read from ini file failed: {res_flag.error()}\")\n",
    "else:\n",
    "    print(\"Init ReassemblerFlag successfully!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reassembler flags:\n",
      "  period_ms=100\n",
      "  useCP=True\n",
      "  validateCert = True\n",
      "  epoch_ms = 1000\n",
      "  setPoint = 0.0\n",
      "  [Kp, Ki, Kd] = [0.0, 0.0, 2.0]\n",
      "  [weight, min_factor, max_factor] = [1.0, 0.5, 2.0]\n",
      "  portRange = -1\n",
      "  withLBHeader = False\n"
     ]
    }
   ],
   "source": [
    "# Validation\n",
    "rflags = res_flag.value()\n",
    "\n",
    "assert(rflags.useCP == True)\n",
    "assert(rflags.validateCert == True)\n",
    "assert(rflags.portRange == -1)\n",
    "\n",
    "print(\"Reassembler flags:\")\n",
    "print(f\"  period_ms={rflags.period_ms}\")  # should be 100 according to the C++ constructor\n",
    "print(f\"  useCP={rflags.useCP}\")\n",
    "print(f\"  validateCert = {rflags.validateCert}\")\n",
    "print(f\"  epoch_ms = {rflags.epoch_ms}\")\n",
    "print(f\"  setPoint = {rflags.setPoint}\")\n",
    "print(f\"  [Kp, Ki, Kd] = [{rflags.Kp}, {rflags.Ki}, {rflags.Kd}]\")\n",
    "print(f\"  [weight, min_factor, max_factor] = [{rflags.weight}, {rflags.min_factor}, {rflags.max_factor}]\")\n",
    "print(f\"  portRange = {rflags.portRange}\")\n",
    "print(f\"  withLBHeader = {rflags.withLBHeader}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Init SegmenterFlag successfully!\n"
     ]
    }
   ],
   "source": [
    "# Segmenter\n",
    "res_flag = e2sar_py.DataPlane.SegmenterFlags.getFromINI(\n",
    "    '/home/ubuntu/dev-e2sar/segmenter_config.ini'\n",
    ")\n",
    "\n",
    "if res_flag.has_error():\n",
    "    print(f\"Read from ini file failed: {res_flag.error()}\")\n",
    "else:\n",
    "    print(\"Init SegmenterFlag successfully!\")\n",
    "\n",
    "sflags = res_flag.value()\n",
    "assert(sflags.useCP == True)\n",
    "assert(sflags.syncPeriodMs == 1000)\n",
    "assert(sflags.syncPeriods == 2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}