subtract_profiling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from line_profiler import LineProfiler\n",
    "import bioframe as bf\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_random_intervals(\n",
    "        n=1e5, \n",
    "        n_chroms=1, \n",
    "        max_coord=None, \n",
    "        max_length=10, \n",
    "        sort=False,\n",
    "        categorical_chroms=False,\n",
    "        \n",
    "    ):\n",
    "    n = int(n)\n",
    "    n_chroms = int(n_chroms)\n",
    "    max_coord = (n // n_chroms) if max_coord is None else int(max_coord)\n",
    "    max_length = int(max_length)\n",
    "    \n",
    "    chroms = np.array(['chr'+str(i+1) for i in range(n_chroms)])[\n",
    "        np.random.randint(0, n_chroms, n)]\n",
    "    starts = np.random.randint(0, max_coord, n)\n",
    "    ends = starts + np.random.randint(1, max_length, n)\n",
    "\n",
    "    df = pd.DataFrame({\n",
    "        'chrom':chroms,\n",
    "        'start':starts,\n",
    "        'end':ends\n",
    "    })\n",
    "    \n",
    "    if categorical_chroms:\n",
    "        df['chrom'] = df['chrom'].astype('category')\n",
    "\n",
    "    if sort:\n",
    "        df = df.sort_values(['chrom','start','end']).reset_index(drop=True)\n",
    "        \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_plot(lp):\n",
    "    function_info = next(iter(lp.get_stats().timings.keys()))\n",
    "    filename = function_info[0]\n",
    "    start_line = function_info[1]\n",
    "    with open(filename, 'r') as f:\n",
    "        source_lines = f.readlines()\n",
    "    function_timings = next(iter(lp.get_stats().timings.values()))\n",
    "    line_numbers = [line_no for line_no, _, _ in function_timings]\n",
    "    times_ms = [time_ns / 1_000_000 for _, _, time_ns in function_timings]  # Convert nanoseconds to milliseconds\n",
    "    line_descriptions = [source_lines[line_no - start_line].strip() for line_no, _, _ in function_timings]\n",
    "    combined = list(zip(line_numbers, times_ms, line_descriptions))\n",
    "    top_3_lines = sorted(combined, key=lambda x: x[1], reverse=True)[:3]\n",
    "    plt.figure(figsize=(12, 8))\n",
    "    bars = plt.bar(line_numbers, times_ms, color='skyblue')\n",
    "    plt.xticks(line_numbers, [f'Line {ln}' for ln in line_numbers], rotation='vertical')\n",
    "    plt.ylabel('Time (milliseconds)')\n",
    "    plt.xlabel('Source Code Line Number')\n",
    "    plt.title('Profiling Results: Time Spent per Line')\n",
    "    plt.tight_layout()  # Adjust layout to make room for the rotated x-axis labels\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = make_random_intervals(int(1e7), 300, 100)\n",
    "df2 = make_random_intervals(int(3e6), 100, 200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Timer unit: 1e-09 s\n",
      "\n",
      "Total time: 14.0205 s\n",
      "File: /Users/smitkadvani/Documents/qcb/update_bioframe/bioframe/bioframe/ops.py\n",
      "Function: subtract at line 1314\n",
      "\n",
      "Line #      Hits         Time  Per Hit   % Time  Line Contents\n",
      "==============================================================\n",
      "  1314                                           def subtract(\n",
      "  1315                                               df1,\n",
      "  1316                                               df2,\n",
      "  1317                                               return_index=False,\n",
      "  1318                                               suffixes=(\"\", \"_\"),\n",
      "  1319                                               cols1=None,\n",
      "  1320                                               cols2=None,\n",
      "  1321                                           ):\n",
      "  1322                                               \"\"\"\n",
      "  1323                                               Generate a new set of genomic intervals by subtracting the second set of\n",
      "  1324                                               genomic intervals from the first.\n",
      "  1325                                           \n",
      "  1326                                               Parameters\n",
      "  1327                                               ----------\n",
      "  1328                                               df1, df2 : pandas.DataFrame\n",
      "  1329                                                   Two sets of genomic intervals stored as a DataFrame.\n",
      "  1330                                           \n",
      "  1331                                               return_index : bool\n",
      "  1332                                                   Whether to return the indices of the original intervals\n",
      "  1333                                                   ('index'+suffixes[0]), and the indices of any sub-intervals split by\n",
      "  1334                                                   subtraction ('sub_index'+suffixes[1]). Default False.\n",
      "  1335                                           \n",
      "  1336                                               suffixes : (str,str)\n",
      "  1337                                                   Suffixes for returned indices. Only alters output if return_index is\n",
      "  1338                                                   True. Default (\"\",\"_\").\n",
      "  1339                                           \n",
      "  1340                                               cols1, cols2 : (str, str, str) or None\n",
      "  1341                                                   The names of columns containing the chromosome, start and end of the\n",
      "  1342                                                   genomic intervals, provided separately for each set. The default\n",
      "  1343                                                   values are 'chrom', 'start', 'end'.\n",
      "  1344                                           \n",
      "  1345                                               Returns\n",
      "  1346                                               -------\n",
      "  1347                                               df_subtracted : pandas.DataFrame\n",
      "  1348                                           \n",
      "  1349                                               Notes\n",
      "  1350                                               -----\n",
      "  1351                                               Resets index, drops completely subtracted (null) intervals, and casts to\n",
      "  1352                                               pd.Int64Dtype().\n",
      "  1353                                           \n",
      "  1354                                               \"\"\"\n",
      "  1355                                           \n",
      "  1356         1      27000.0  27000.0      0.0      ck1, sk1, ek1 = _get_default_colnames() if cols1 is None else cols1\n",
      "  1357         1          0.0      0.0      0.0      ck2, sk2, ek2 = _get_default_colnames() if cols2 is None else cols2\n",
      "  1358                                           \n",
      "  1359         1       1000.0   1000.0      0.0      name_updates = {\n",
      "  1360         1       1000.0   1000.0      0.0          ck1 + suffixes[0]: ck1,\n",
      "  1361         1          0.0      0.0      0.0          \"overlap_\" + sk1: sk1,\n",
      "  1362         1          0.0      0.0      0.0          \"overlap_\" + ek1: ek1,\n",
      "  1363                                               }\n",
      "  1364         4     140000.0  35000.0      0.0      extra_columns_1 = [i for i in list(df1.columns) if i not in [ck1, sk1, ek1]]\n",
      "  1365         1       1000.0   1000.0      0.0      for i in extra_columns_1:\n",
      "  1366                                                   name_updates[i + suffixes[0]] = i\n",
      "  1367         1          0.0      0.0      0.0      if return_index:\n",
      "  1368                                                   name_updates[\"index\" + suffixes[0]] = \"index\" + suffixes[0]\n",
      "  1369                                                   name_updates[\"index\" + suffixes[1]] = \"complement_index\" + suffixes[1]\n",
      "  1370                                           \n",
      "  1371         2    1907000.0 953500.0      0.0      all_chroms = np.unique(\n",
      "  1372         1  730174000.0    7e+08      5.2          list(pd.unique(df1[ck1].dropna())) + list(pd.unique(df2[ck2].dropna()))\n",
      "  1373                                               )\n",
      "  1374         1       1000.0   1000.0      0.0      if len(all_chroms) == 0:\n",
      "  1375                                                   raise ValueError(\"No chromosomes remain after dropping nulls\")\n",
      "  1376                                           \n",
      "  1377         3        1e+10    4e+09     78.6      df_subtracted = overlap(\n",
      "  1378         1          0.0      0.0      0.0          df1,\n",
      "  1379         2 2183086000.0    1e+09     15.6          complement(\n",
      "  1380       301     511000.0   1697.7      0.0              df2, view_df={i: np.iinfo(np.int64).max for i in all_chroms}, cols=cols2\n",
      "  1381         1    1340000.0    1e+06      0.0          ).astype({sk2: pd.Int64Dtype(), ek2: pd.Int64Dtype()}),\n",
      "  1382         1          0.0      0.0      0.0          how=\"left\",\n",
      "  1383         1          0.0      0.0      0.0          suffixes=suffixes,\n",
      "  1384         1          0.0      0.0      0.0          return_index=return_index,\n",
      "  1385         1          0.0      0.0      0.0          return_overlap=True,\n",
      "  1386         1          0.0      0.0      0.0          keep_order=True,\n",
      "  1387         1       1000.0   1000.0      0.0          cols1=cols1,\n",
      "  1388         1          0.0      0.0      0.0          cols2=cols2,\n",
      "  1389         1      10000.0  10000.0      0.0      )[list(name_updates)]\n",
      "  1390         1     531000.0 531000.0      0.0      df_subtracted.rename(columns=name_updates, inplace=True)\n",
      "  1391         1   86824000.0    9e+07      0.6      df_subtracted = df_subtracted.iloc[~pd.isna(df_subtracted[sk1].values)]\n",
      "  1392         1    1031000.0    1e+06      0.0      df_subtracted.reset_index(drop=True, inplace=True)\n",
      "  1393                                           \n",
      "  1394         1       1000.0   1000.0      0.0      if return_index:\n",
      "  1395                                                   inds = df_subtracted[\"index\" + suffixes[0]].values\n",
      "  1396                                                   comp_inds = df_subtracted[\"complement_index\" + suffixes[1]].copy()  # .values\n",
      "  1397                                                   for i in np.unique(inds):\n",
      "  1398                                                       comp_inds[inds == i] -= comp_inds[inds == i].min()\n",
      "  1399                                                   df_subtracted[\"sub_index\" + suffixes[1]] = comp_inds.copy()\n",
      "  1400                                                   df_subtracted.drop(columns=[\"complement_index\" + suffixes[1]], inplace=True)\n",
      "  1401         1      14000.0  14000.0      0.0      return df_subtracted\n",
      "\n"
     ]
    }
   ],
   "source": [
    "lp = LineProfiler()\n",
    "lp_wrapper = lp(bf.subtract)\n",
    "lp_wrapper(df1, df2)\n",
    "bf.subtract(df1, df2)\n",
    "lp.print_stats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "generate_plot(lp)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_chroms = np.unique(list(pd.unique(df1['chrom'].dropna())) + list(pd.unique(df2['chrom'].dropna())))\n",
    "view_df_temp = {i: np.iinfo(np.int64).max for i in all_chroms}\n",
    "compliment_df2_with_viewframe = bf.complement(df2, view_df_temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Timer unit: 1e-09 s\n",
      "\n",
      "Total time: 9.55702 s\n",
      "File: /Users/smitkadvani/Documents/qcb/update_bioframe/bioframe/bioframe/ops.py\n",
      "Function: overlap at line 396\n",
      "\n",
      "Line #      Hits         Time  Per Hit   % Time  Line Contents\n",
      "==============================================================\n",
      "   396                                           def overlap(\n",
      "   397                                               df1,\n",
      "   398                                               df2,\n",
      "   399                                               how=\"left\",\n",
      "   400                                               return_input=True,\n",
      "   401                                               return_index=False,\n",
      "   402                                               return_overlap=False,\n",
      "   403                                               suffixes=(\"\", \"_\"),\n",
      "   404                                               keep_order=None,\n",
      "   405                                               cols1=None,\n",
      "   406                                               cols2=None,\n",
      "   407                                               on=None,\n",
      "   408                                               ensure_int=True,\n",
      "   409                                           ):\n",
      "   410                                               \"\"\"\n",
      "   411                                               Find pairs of overlapping genomic intervals.\n",
      "   412                                           \n",
      "   413                                               Parameters\n",
      "   414                                               ----------\n",
      "   415                                               df1, df2 : pandas.DataFrame\n",
      "   416                                                   Two sets of genomic intervals stored as a DataFrame.\n",
      "   417                                           \n",
      "   418                                               how : {'left', 'right', 'outer', 'inner'}, default 'left'\n",
      "   419                                                   How to handle the overlaps on the two dataframes.\n",
      "   420                                                   left: use the set of intervals in df1\n",
      "   421                                                   right: use the set of intervals in df2\n",
      "   422                                                   outer: use the union of the set of intervals from df1 and df2\n",
      "   423                                                   inner: use intersection of the set of intervals from df1 and df2\n",
      "   424                                           \n",
      "   425                                               return_input : bool, optional\n",
      "   426                                                   If True, return columns from input dfs. Default True.\n",
      "   427                                           \n",
      "   428                                               return_index : bool, optional\n",
      "   429                                                   If True, return indicies of overlapping pairs as two new columns\n",
      "   430                                                   ('index'+suffixes[0] and 'index'+suffixes[1]). Default False.\n",
      "   431                                           \n",
      "   432                                               return_overlap : bool, optional\n",
      "   433                                                   If True, return overlapping intervals for the overlapping pairs\n",
      "   434                                                   as two additional columns (`overlap_start`, `overlap_end`).\n",
      "   435                                                   When `cols1` is modified, `start` and `end` are replaced accordingly.\n",
      "   436                                                   When `return_overlap` is a string, its value is used for naming the overlap\n",
      "   437                                                   columns: `return_overlap + \"_start\"`, `return_overlap + \"_end\"`.\n",
      "   438                                                   Default False.\n",
      "   439                                           \n",
      "   440                                               suffixes : (str, str), optional\n",
      "   441                                                   The suffixes for the columns of the two overlapped sets.\n",
      "   442                                           \n",
      "   443                                               keep_order : bool, optional\n",
      "   444                                                   If True and how='left', sort the output dataframe to preserve the order\n",
      "   445                                                   of the intervals in df1. Cannot be used with how='right'/'outer'/'inner'.\n",
      "   446                                                   Default True for how='left', and None otherwise.\n",
      "   447                                                   Note that it relies on sorting of index in the original dataframes,\n",
      "   448                                                   and will reorder the output by index.\n",
      "   449                                           \n",
      "   450                                               cols1, cols2 : (str, str, str) or None, optional\n",
      "   451                                                   The names of columns containing the chromosome, start and end of the\n",
      "   452                                                   genomic intervals, provided separately for each set. The default\n",
      "   453                                                   values are 'chrom', 'start', 'end'.\n",
      "   454                                           \n",
      "   455                                               on : list or None, optional\n",
      "   456                                                   List of additional shared columns to consider as separate groups\n",
      "   457                                                   when considering overlaps. A common use would be passing on=['strand'].\n",
      "   458                                                   Default is None.\n",
      "   459                                           \n",
      "   460                                               ensure_int : bool, optional [default: True]\n",
      "   461                                                   If True, ensures that the output dataframe uses integer dtypes for\n",
      "   462                                                   start and end coordinates. This may involve converting coordinate\n",
      "   463                                                   columns to nullable types in outer joins. Default True.\n",
      "   464                                           \n",
      "   465                                               Returns\n",
      "   466                                               -------\n",
      "   467                                               df_overlap : pandas.DataFrame\n",
      "   468                                           \n",
      "   469                                               Notes\n",
      "   470                                               -----\n",
      "   471                                               If ``ensure_int`` is False, inner joins will preserve coordinate dtypes\n",
      "   472                                               from the input dataframes, but outer joins will be subject to native type\n",
      "   473                                               casting rules if missing data is introduced. For example, if `df1` uses a\n",
      "   474                                               NumPy integer dtype for `start` and/or `end`, the output dataframe will\n",
      "   475                                               use the same dtype after an inner join, but, due to casting rules, may\n",
      "   476                                               produce ``float64`` after a left/right/outer join with missing data stored\n",
      "   477                                               as ``NaN``. On the other hand, if `df1` uses Pandas nullable dtypes, the\n",
      "   478                                               corresponding coordinate columns will preserve the same dtype in the\n",
      "   479                                               output, with missing data stored as ``NA``.\n",
      "   480                                               \"\"\"\n",
      "   481         1       4000.0   4000.0      0.0      ck1, sk1, ek1 = _get_default_colnames() if cols1 is None else cols1\n",
      "   482         1          0.0      0.0      0.0      ck2, sk2, ek2 = _get_default_colnames() if cols2 is None else cols2\n",
      "   483         1  277358000.0    3e+08      2.9      checks.is_bedframe(df1, raise_errors=True, cols=[ck1, sk1, ek1])\n",
      "   484         1    1244000.0    1e+06      0.0      checks.is_bedframe(df2, raise_errors=True, cols=[ck2, sk2, ek2])\n",
      "   485                                           \n",
      "   486         1          0.0      0.0      0.0      if (how == \"left\") and (keep_order is None):\n",
      "   487         1          0.0      0.0      0.0          keep_order = True\n",
      "   488         1          0.0      0.0      0.0      if (how != \"left\") and keep_order:\n",
      "   489                                                   raise ValueError(\"keep_order=True only allowed for how='left'\")\n",
      "   490                                           \n",
      "   491         1          0.0      0.0      0.0      if on is not None:\n",
      "   492                                                   if not isinstance(on, list):\n",
      "   493                                                       raise ValueError(\"on=[] must be None or list\")\n",
      "   494                                                   if (ck1 in on) or (ck2 in on):\n",
      "   495                                                       raise ValueError(\"on=[] should not contain chromosome colnames\")\n",
      "   496                                                   _verify_columns(df1, on)\n",
      "   497                                                   _verify_columns(df2, on)\n",
      "   498                                           \n",
      "   499         2 2007978000.0    1e+09     21.0      overlap_df_idxs = _overlap_intidxs(\n",
      "   500         1          0.0      0.0      0.0          df1,\n",
      "   501         1          0.0      0.0      0.0          df2,\n",
      "   502         1          0.0      0.0      0.0          how=how,\n",
      "   503         1          0.0      0.0      0.0          cols1=cols1,\n",
      "   504         1          0.0      0.0      0.0          cols2=cols2,\n",
      "   505         1          0.0      0.0      0.0          on=on,\n",
      "   506                                               )\n",
      "   507         1       3000.0   3000.0      0.0      events1 = overlap_df_idxs[:, 0]\n",
      "   508         1          0.0      0.0      0.0      events2 = overlap_df_idxs[:, 1]\n",
      "   509                                           \n",
      "   510                                               # Generate output tables.\n",
      "   511         1       3000.0   3000.0      0.0      index_col = return_index if isinstance(return_index, str) else \"index\"\n",
      "   512         1          0.0      0.0      0.0      index_col_1 = index_col + suffixes[0]\n",
      "   513         1       1000.0   1000.0      0.0      index_col_2 = index_col + suffixes[1]\n",
      "   514         1   71732000.0    7e+07      0.8      df_index_1 = pd.DataFrame({index_col_1: df1.index[events1]})\n",
      "   515         1   22265000.0    2e+07      0.2      df_index_2 = pd.DataFrame({index_col_2: df2.index[events2]})\n",
      "   516                                           \n",
      "   517         1          0.0      0.0      0.0      df_overlap = None\n",
      "   518         1       1000.0   1000.0      0.0      if return_overlap:\n",
      "   519                                                   overlap_col = return_overlap if isinstance(return_overlap, str) else \"overlap\"\n",
      "   520                                                   overlap_col_sk1 = overlap_col + \"_\" + sk1\n",
      "   521                                                   overlap_col_ek1 = overlap_col + \"_\" + ek1\n",
      "   522                                           \n",
      "   523                                                   overlap_start = np.maximum(\n",
      "   524                                                       df1[sk1].values[events1],\n",
      "   525                                                       df2[sk2].values[events2],\n",
      "   526                                                   )\n",
      "   527                                           \n",
      "   528                                                   overlap_end = np.minimum(\n",
      "   529                                                       df1[ek1].values[events1],\n",
      "   530                                                       df2[ek2].values[events2],\n",
      "   531                                                   )\n",
      "   532                                           \n",
      "   533                                                   df_overlap = pd.DataFrame({\n",
      "   534                                                       overlap_col_sk1: overlap_start,\n",
      "   535                                                       overlap_col_ek1: overlap_end\n",
      "   536                                                   })\n",
      "   537                                           \n",
      "   538         1          0.0      0.0      0.0      df_input_1 = None\n",
      "   539         1       1000.0   1000.0      0.0      df_input_2 = None\n",
      "   540         1          0.0      0.0      0.0      if return_input or str(return_input) == \"1\" or return_input == \"left\":\n",
      "   541         1  609759000.0    6e+08      6.4          df_input_1 = df1.iloc[events1].reset_index(drop=True)\n",
      "   542         4     139000.0  34750.0      0.0          df_input_1.columns = [c + suffixes[0] for c in df_input_1.columns]\n",
      "   543                                           \n",
      "   544         1       1000.0   1000.0      0.0      if return_input or str(return_input) == \"2\" or return_input == \"right\":\n",
      "   545         1  340193000.0    3e+08      3.6          df_input_2 = df2.iloc[events2].reset_index(drop=True)\n",
      "   546         5     129000.0  25800.0      0.0          df_input_2.columns = [c + suffixes[1] for c in df_input_2.columns]\n",
      "   547                                           \n",
      "   548                                               # Masking non-overlapping regions if using non-inner joins.\n",
      "   549         1          0.0      0.0      0.0      if how != \"inner\":\n",
      "   550         1    6643000.0    7e+06      0.1          is_na_left = (events1 == -1)\n",
      "   551         1    4680000.0    5e+06      0.0          is_na_right = (events2 == -1)\n",
      "   552         1     194000.0 194000.0      0.0          any_na_left = is_na_left.any()\n",
      "   553         1     191000.0 191000.0      0.0          any_na_right = is_na_right.any()\n",
      "   554         1     587000.0 587000.0      0.0          df_index_1[is_na_left] = None\n",
      "   555         1   19234000.0    2e+07      0.2          df_index_2[is_na_right] = None\n",
      "   556                                           \n",
      "   557         1          0.0      0.0      0.0          if df_input_1 is not None:\n",
      "   558         1          0.0      0.0      0.0              if ensure_int and any_na_left:\n",
      "   559                                                           df_input_1 = df_input_1.astype({\n",
      "   560                                                               sk1 + suffixes[0]: _to_nullable_dtype(df1[sk1].dtype),\n",
      "   561                                                               ek1 + suffixes[0]: _to_nullable_dtype(df1[ek1].dtype),\n",
      "   562                                                           })\n",
      "   563         1       1000.0   1000.0      0.0              if any_na_left:\n",
      "   564                                                           df_input_1[is_na_left] = None\n",
      "   565                                           \n",
      "   566         1          0.0      0.0      0.0          if df_input_2 is not None:\n",
      "   567         1          0.0      0.0      0.0              if ensure_int and any_na_right:\n",
      "   568         2  125496000.0    6e+07      1.3                  df_input_2 = df_input_2.astype({\n",
      "   569         1      80000.0  80000.0      0.0                      sk2 + suffixes[1]: _to_nullable_dtype(df2[sk2].dtype),\n",
      "   570         1      25000.0  25000.0      0.0                      ek2 + suffixes[1]: _to_nullable_dtype(df2[ek2].dtype),\n",
      "   571                                                           })\n",
      "   572         1          0.0      0.0      0.0              if any_na_right:\n",
      "   573         1   68631000.0    7e+07      0.7                  df_input_2[is_na_right] = None\n",
      "   574                                           \n",
      "   575         1       1000.0   1000.0      0.0          if df_overlap is not None:\n",
      "   576                                                       if ensure_int and (any_na_left or any_na_right):\n",
      "   577                                                           df_overlap = df_overlap.convert_dtypes()\n",
      "   578                                                           df_overlap[is_na_left | is_na_right] = None\n",
      "   579                                           \n",
      "   580         2  386840000.0    2e+08      4.0      out_df = pd.concat(\n",
      "   581         1          0.0      0.0      0.0          [df_index_1, df_input_1, df_index_2, df_input_2, df_overlap], axis=\"columns\"\n",
      "   582                                               )\n",
      "   583         1          0.0      0.0      0.0      if keep_order:\n",
      "   584         1 5301959000.0    5e+09     55.5          out_df = out_df.sort_values([index_col_1, index_col_2])\n",
      "   585                                           \n",
      "   586         1       2000.0   2000.0      0.0      if not return_index:\n",
      "   587         1  304090000.0    3e+08      3.2          out_df.drop([index_col_1, index_col_2], axis=1, inplace=True)\n",
      "   588                                           \n",
      "   589         1    7551000.0    8e+06      0.1      out_df.reset_index(drop=True, inplace=True)\n",
      "   590         1       2000.0   2000.0      0.0      return out_df\n",
      "\n"
     ]
    }
   ],
   "source": [
    "lp1 = LineProfiler()\n",
    "lp_wrapper = lp1(bf.overlap)\n",
    "lp_wrapper(df1, compliment_df2_with_viewframe)\n",
    "bf.overlap(df1, compliment_df2_with_viewframe)\n",
    "lp1.print_stats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "generate_plot(lp1)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "bioframe-setup",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}