Qfrom performance test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "import numpy as np\n",
    "from QfromPackage.Qfrom_slim import Qfrom as Qfrom_slim\n",
    "from QfromPackage.Qfrom_slim import agg\n",
    "from QfromPackage.Qfrom_slim import func\n",
    "from QfromPackage.Qfrom_slim import out\n",
    "from QfromPackage.Qfrom_slim import col\n",
    "from QfromPackage.Qfrom_slim import plot\n",
    "import time\n",
    "from collections.abc import Iterable\n",
    "import pandas as pd\n",
    "from multiprocessing import Pool\n",
    "import inspect\n",
    "from concurrent.futures import ProcessPoolExecutor, as_completed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "def iter_array_list(array_list: list[np.ndarray]) -> Iterable|None:\n",
    "    if len(array_list) == 0:\n",
    "        return None\n",
    "    if len(array_list) == 1:\n",
    "        return iter(array_list[0])\n",
    "    else:\n",
    "        return zip(*array_list)\n",
    "def iter_table_dict(table_dict: dict[str, np.ndarray]) -> Iterable|None:\n",
    "    return iter_array_list(list(table_dict.values()))\n",
    "def first(iterable, predicate_func=None):\n",
    "    if predicate_func:\n",
    "        for item in iterable:\n",
    "            if predicate_func(item):\n",
    "                return item\n",
    "        return None\n",
    "    return next(iter(iterable))\n",
    "def array_tuple_to_tuple_array(array_list):\n",
    "        l = list(zip(*array_list))\n",
    "        #it = np.nditer(array_list, flags=['refs_ok'])\n",
    "        a = np.empty(len(array_list[0]), dtype=object)\n",
    "        a[:] = l\n",
    "        return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10000, 100000, 1000000, 5000, 50000, 500000]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_p(n):\n",
    "    return [1/(2**(i+1)) if i+1 != n else 1/(2**(i)) for i in range(n)]\n",
    "def get_data_size_list(max_potenz, count=3, half_steps=True):\n",
    "    if half_steps:\n",
    "        return [10**(i+1) for i in range(max(max_potenz-count,-1), max_potenz)]\\\n",
    "            + [5*10**(i) for i in range(max(max_potenz-count, 0), max_potenz)]\n",
    "    return [10**(i+1) for i in range(max(max_potenz-count,-1), max_potenz)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_tab_data(n):\n",
    "    name_list = ['Ann', 'Steven', 'Max', 'Jack', 'Julia', 'Clara', 'Emma', 'Bob', 'Anna' 'Lena']\n",
    "    job_list = ['manager', 'freelancer', 'employee', 'artist', 'jobless', 'technician', 'boss', 'polician']\n",
    "    max_age = 100\n",
    "    max_salary = 1000000\n",
    "    \n",
    "    name_ran_array = np.random.choice(name_list, n, p=get_p(len(name_list)))\n",
    "    age_ran_list = np.random.randint(max_age, size=n)\n",
    "    job_ran_array = np.random.choice(job_list, n, p=get_p(len(job_list)))\n",
    "    salary_ran_list = np.random.randint(max_salary, size=n)\n",
    "\n",
    "    return {\n",
    "        'name': name_ran_array,\n",
    "        'age': age_ran_list,\n",
    "        'job': job_ran_array,\n",
    "        'salary': salary_ran_list,\n",
    "        }\n",
    "\n",
    "def get_num_data(n):\n",
    "    max_value = 1000\n",
    "    return {\n",
    "        'x': np.random.randint(max_value, size=n)\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_test(test):\n",
    "    result_data = Qfrom_slim()\n",
    "\n",
    "    test_name = test['test_name']\n",
    "    data_gen_func = test['data_source_func']\n",
    "    data_size_list = test['data_size_list']\n",
    "    test_items = test['test_items']\n",
    "\n",
    "    data_sets = [data_gen_func(size) for size in data_size_list]\n",
    "\n",
    "    for item_name, setup, func in test_items:\n",
    "        for data_set, data_size in zip(data_sets, data_size_list):\n",
    "            #start_time = time.time()\n",
    "            data = setup(data_set)\n",
    "            #delta_time = time.time() - start_time\n",
    "            #print(f'{item_name} {delta_time=}')\n",
    "\n",
    "            start_time = time.time()\n",
    "            result = func(data)\n",
    "            delta_time = time.time() - start_time\n",
    "            \n",
    "            if isinstance(result, Iterable):\n",
    "                result = len(result)\n",
    "            result_data.append({\n",
    "                'test_name': test_name,\n",
    "                'item_name': item_name,\n",
    "                'data_size': data_size,\n",
    "                'delta_time': delta_time,\n",
    "                'result': result,\n",
    "                })\n",
    "\n",
    "    return result_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "class np_ext():\n",
    "    @classmethod\n",
    "    def col_stack(cls, cols):\n",
    "        col_types = ','.join([str(c.dtype) for c in cols])\n",
    "        a = np.empty(len(cols[0]), dtype=col_types)\n",
    "\n",
    "        for i in np.ndindex(len(a)):\n",
    "            a[i] = tuple(c[i] for c in cols)\n",
    "\n",
    "        return a\n",
    "    @classmethod\n",
    "    def col_add(cls, array, col):\n",
    "        col_types = [array.dtype[n] for n in array.dtype.names] + [col.dtype]\n",
    "        col_types = ','.join([str(t) for t in col_types])\n",
    "        print(col_types)\n",
    "        a = np.empty(len(array[0])+1, dtype=col_types)\n",
    "\n",
    "        for i in np.ndindex(len(a)):\n",
    "            a[i] = tuple(array[i]) + (col[i],)\n",
    "\n",
    "        return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "class setup():\n",
    "    @classmethod\n",
    "    def np(cls, data: dict[str, numpy.ndarray]):\n",
    "        return {k: np.copy(v) for k,v in data.items()}\n",
    "    @classmethod\n",
    "    def np_tpl(cls, data: dict[str, numpy.ndarray]):\n",
    "        return ({k:np.copy(v) for k,v in data[0].items()}, *data[1:])\n",
    "    @classmethod\n",
    "    def np_mtx(cls, data: dict[str, numpy.ndarray]):\n",
    "        cols = list(data.values())\n",
    "        return np_ext.col_stack(cols)\n",
    "    @classmethod\n",
    "    def df(cls, data: dict[str, numpy.ndarray]):\n",
    "        return pd.DataFrame(data)\n",
    "    @classmethod\n",
    "    def df_tpl(cls, data: dict[str, numpy.ndarray]):\n",
    "        return (pd.DataFrame(data[0]), *data[1:])\n",
    "    @classmethod\n",
    "    def l(cls, data: dict[str, numpy.ndarray]):\n",
    "        return {key: list(col) for key, col in data.items()}\n",
    "    @classmethod\n",
    "    def l_tpl(cls, data: dict[str, numpy.ndarray]):\n",
    "        return ({key: list(col) for key, col in data[0].items()}, *data[1:])\n",
    "    @classmethod\n",
    "    def qs(cls, data: dict[str, numpy.ndarray]):\n",
    "        return Qfrom_slim(data)\n",
    "    @classmethod\n",
    "    def qs_tpl(cls, data: dict[str, numpy.ndarray]):\n",
    "        return (Qfrom_slim(data[0]), *data[1:])\n",
    "    @classmethod\n",
    "    def list_items(cls, data: dict[str, numpy.ndarray]):\n",
    "        return list(iter_table_dict(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data_size_tab(q: Qfrom_slim) -> Qfrom_slim:\n",
    "    return q\\\n",
    "        .groupby('data_size')\\\n",
    "        .map(func=func.vec(lambda key, group: {\n",
    "            'data_size': key,\n",
    "            **dict(iter(group['item_name, delta_time']))\n",
    "        }))\\\n",
    "        .remove('key, group')\\\n",
    "        .orderby('data_size')\n",
    "\n",
    "def print_max_stats(q: Qfrom_slim, compareable='np'):\n",
    "    max_id = q['data_size'].agg(agg.max_id)\n",
    "    max_row = dict(zip(q.keys(), q[max_id]))\n",
    "    print('max data_size:', max_row['data_size'])\n",
    "    for key, value in max_row.items():\n",
    "        if key == 'data_size':\n",
    "                continue\n",
    "        comp = max_row[compareable]\n",
    "        percent = 0 if comp==0 else value/comp\n",
    "        #print('\\t', key, '\\t', round(value, 3), 's\\t', str(round(percent, 3))+'%')\n",
    "        print(key, '\\t', round(value, 3), 's\\t', str(round(percent, 3))+'%')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "    # - import_list\n",
    "    # - import_dict\n",
    "    # - (import_set)\n",
    "    # - (import_array)\n",
    "    # - (import_mtx)\n",
    "    # - import_dataframe\n",
    "    # - import_csv\n",
    "    # - (import_json)\n",
    "    # - import_generator\n",
    "\n",
    "    # - eq\n",
    "    # - str\n",
    "    # - repr\n",
    "    ## - append\n",
    "    # - setitem -> more dim slice support\n",
    "    ## - getitem\n",
    "    # - contains\n",
    "    ## - iter\n",
    "    # - len\n",
    "\n",
    "    # - keys\n",
    "    # - values\n",
    "    # - items\n",
    "    # - (stats)\n",
    "\n",
    "    # - remove(selection: str|tuple[str]|list[str])\n",
    "    # - rename(map: dict[str, str])\n",
    "    ## - select(selection: str|tuple[str]|list[str])\n",
    "    ## - map(args: str|tuple[str]|list[str], func: callable, out=str|tuple[str]|list[str])\n",
    "    ## - orderby(selection: str|tuple[str]|list[str], func: callable, reverse: bool)\n",
    "\n",
    "    ## - where(selection: str|tuple[str]|list[str], predicate: callable)\n",
    "    ## - groupby(selection: str|tuple[str]|list[str], func: callable)\n",
    "    # - flatten\n",
    "    # - unique\n",
    "    # - value_counts\n",
    "\n",
    "    ## - agg\n",
    "\n",
    "    # - join\n",
    "    # - join_cross\n",
    "    # - join_outer\n",
    "    # - join_outer_left\n",
    "    # - join_outer_right\n",
    "    # - join_id\n",
    "    # - join_id_outer\n",
    "    # - join_id_outer_left\n",
    "    # - join_id_outer_right\n",
    "\n",
    "    # - concat\n",
    "    # - concat_outer\n",
    "    # - concat_outer_left\n",
    "    # - concat_outer_right\n",
    "\n",
    "    # - calc\n",
    "    # - call\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "    # - import_list\n",
    "    # - import_dict\n",
    "    # - (import_set)\n",
    "    # - (import_array)\n",
    "    # - (import_mtx)\n",
    "    # - import_dataframe\n",
    "    # - import_csv\n",
    "    # - (import_json)\n",
    "    # - import_generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 10000\n",
      "np \t 0.132 s\t 1.0%\n",
      "df \t 6.862 s\t 51.802%\n",
      "qs \t 0.482 s\t 3.639%\n",
      "l \t 0.002 s\t 0.015%\n"
     ]
    }
   ],
   "source": [
    "# append\n",
    "def append_np(data):\n",
    "    result = {\n",
    "        'name': np.array([data[0][0]]),\n",
    "        'age': np.array([data[0][1]]),\n",
    "        'job': np.array([data[0][2]]),\n",
    "        'salary': np.array([data[0][3]]),\n",
    "        }\n",
    "    for name, age, job, salary in data[1:]:\n",
    "        np.append(result['name'], [name])\n",
    "        np.append(result['age'], [age])\n",
    "        np.append(result['job'], [job])\n",
    "        np.append(result['salary'], [salary])\n",
    "    return result\n",
    "\n",
    "def append_df(data):\n",
    "    result = pd.DataFrame([data[0]], columns=['name', 'age', 'job', 'salary'])\n",
    "    #for name, age, job, salary in data[1:]:\n",
    "    for t in data[1:]:\n",
    "        #row = t\n",
    "        row = pd.DataFrame([t], columns=['name', 'age', 'job', 'salary'])\n",
    "        #row = pd.Series({'name': name, 'age': age, 'job': job, 'salary': salary})\n",
    "        result.append([row], ignore_index=True)\n",
    "    return result\n",
    "\n",
    "def append_qs(data):\n",
    "    result = Qfrom_slim()\n",
    "    for t in data:\n",
    "        result.append(t)\n",
    "    return result(out.dict)\n",
    "\n",
    "def append_l(data):\n",
    "    result = {\n",
    "        'name': [],\n",
    "        'age': [],\n",
    "        'job': [],\n",
    "        'salary': [],\n",
    "    }\n",
    "    for name, age, job, salary in data:\n",
    "        result['name'].append(name)\n",
    "        result['age'].append(age)\n",
    "        result['job'].append(job)\n",
    "        result['salary'].append(salary)\n",
    "    return result\n",
    "\n",
    "test = {\n",
    "    'test_name': 'append test',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(4),\n",
    "    'test_items': [\n",
    "        ('np', setup.list_items, append_np),\n",
    "        ('df', setup.list_items, append_df),\n",
    "        ('qs', setup.list_items, append_qs),\n",
    "        ('l', setup.list_items, append_l),\n",
    "    ],\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 1000000\n",
      "np \t 0.165 s\t 1.0%\n",
      "df \t 0.172 s\t 1.039%\n",
      "qs \t 0.441 s\t 2.669%\n",
      "l \t 0.044 s\t 0.266%\n",
      "np_mtx \t 0.065 s\t 0.393%\n"
     ]
    }
   ],
   "source": [
    "# iter\n",
    "\n",
    "def iter_np(data):\n",
    "    row_count = 0\n",
    "    #for i in zip(np.nditer(a, flags=[\"refs_ok\"]) for a in data.values()):\n",
    "    #for i in np.ndindex(len(first(data.values()))):\n",
    "    for i in np.nditer(list(data.values()), flags=[\"refs_ok\"]):\n",
    "        #t = tuple(c[i] for c in data.values())\n",
    "        row_count += 1\n",
    "    return row_count\n",
    "def iter_np_mtx(data):\n",
    "    row_count = 0\n",
    "    for i in np.nditer(data, flags=[\"refs_ok\"]):\n",
    "        row_count += 1\n",
    "    return row_count\n",
    "\n",
    "def iter_df(df: pd.DataFrame):\n",
    "    row_count = 0\n",
    "    for row in df.values:\n",
    "        row_count += 1\n",
    "    return row_count\n",
    "\n",
    "def iter_qs(q: Qfrom_slim):\n",
    "    row_count = 0\n",
    "    for row in q:\n",
    "        row_count += 1\n",
    "    return row_count\n",
    "\n",
    "def iter_l(data):\n",
    "    row_count = 0\n",
    "    for row in zip(*data.values()):\n",
    "        row_count += 1\n",
    "    return row_count\n",
    "\n",
    "\n",
    "test = {\n",
    "    'test_name': 'append test',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(6),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, iter_np),\n",
    "        ('df', setup.df, iter_df),\n",
    "        ('qs', setup.qs, iter_qs),\n",
    "        ('l', setup.l, iter_l),\n",
    "        ('np_mtx', setup.np_mtx, iter_np_mtx),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 100000\n",
      "np \t 0.151 s\t 1.0%\n",
      "df \t 5.428 s\t 35.941%\n",
      "qs \t 0.159 s\t 1.054%\n",
      "l \t 0.115 s\t 0.762%\n"
     ]
    }
   ],
   "source": [
    "# getitem\n",
    "\n",
    "def getitem_std(t):\n",
    "    data, ids = t\n",
    "    \n",
    "    for id in ids:\n",
    "        tuple(col[id] for col in data.values())\n",
    "\n",
    "def getitem_df(t):\n",
    "    df, ids = t\n",
    "\n",
    "    #values = df.values\n",
    "    for id in ids:\n",
    "        df.iloc[id]\n",
    "        #values[id]\n",
    "\n",
    "def getitem_qs(t):\n",
    "    q, ids = t\n",
    "    \n",
    "    for id in ids:\n",
    "        q[id]\n",
    "\n",
    "\n",
    "data_size = 10**5\n",
    "test = {\n",
    "    'test_name': 'append test',\n",
    "    'data_source_func': lambda n: (get_tab_data(data_size), np.random.randint(data_size, size=n)),\n",
    "    'data_size_list': get_data_size_list(5),\n",
    "    'test_items': [\n",
    "        ('np', setup.np_tpl, getitem_std),\n",
    "        ('df', setup.df_tpl, getitem_df),\n",
    "        ('qs', setup.qs_tpl, getitem_std),\n",
    "        ('l', setup.l_tpl, getitem_std),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Max\\Documents\\Projekte\\GitHub\\Qfrom\\QfromPackage\\Qfrom_slim.py:1627: UserWarning: Data has no positive values, and therefore cannot be log-scaled.\n",
      "  # - box\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 1000000\n",
      "np \t 0.0 s\t 0%\n",
      "df \t 0.0 s\t 0%\n",
      "qs \t 0.0 s\t 0%\n",
      "l \t 0.0 s\t 0%\n"
     ]
    }
   ],
   "source": [
    "# select\n",
    "cols = 'name'\n",
    "\n",
    "def select_std(data):\n",
    "    return {key:value for key, value in data.items() if key in cols}\n",
    "\n",
    "def select_df(df):\n",
    "    return df[cols]\n",
    "\n",
    "def select_qs(q: Qfrom_slim):\n",
    "    #return q.select(cols)(out.dict)\n",
    "    return q[cols](out.dict)\n",
    "\n",
    "test = {\n",
    "    'test_name': 'select',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(6),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, select_std),\n",
    "        ('df', setup.df, select_df),\n",
    "        ('qs', setup.qs, select_qs),\n",
    "        ('l', setup.l, select_std),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 10000000\n",
      "np \t 0.001 s\t 1.0%\n",
      "df \t 0.095 s\t 95.179%\n",
      "qs \t 0.0 s\t 0.0%\n",
      "l \t 0.0 s\t 0.0%\n"
     ]
    }
   ],
   "source": [
    "# select mult cols\n",
    "cols = ['name', 'age']\n",
    "\n",
    "def select_std(data):\n",
    "    return {key:value for key, value in data.items() if key in cols}\n",
    "\n",
    "def select_df(df):\n",
    "    return df[cols]\n",
    "\n",
    "def select_qs(q: Qfrom_slim):\n",
    "    #return q.select(cols)(out.dict)\n",
    "    return q[cols](out.dict)\n",
    "\n",
    "test = {\n",
    "    'test_name': 'select mult cols',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(7),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, select_std),\n",
    "        ('df', setup.df, select_df),\n",
    "        ('qs', setup.qs, select_qs),\n",
    "        ('l', setup.l, select_std),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 10000000\n",
      "np \t 0.008 s\t 1.0%\n",
      "df \t 0.019 s\t 2.375%\n",
      "qs \t 0.013 s\t 1.625%\n",
      "l \t 1.202 s\t 150.247%\n"
     ]
    }
   ],
   "source": [
    "# map add\n",
    "\n",
    "def map_add_np(data):\n",
    "    data['age'] = data['age']+10\n",
    "    return data\n",
    "\n",
    "def map_add_df(df: pd.DataFrame):\n",
    "    #df['age'] = df['age'].map(lambda x: x+10)\n",
    "    data['age'] = data['age']+10\n",
    "    return df\n",
    "\n",
    "def map_add_l(data):\n",
    "    data['age'] = [x+10 for x in data['age']]\n",
    "    return data\n",
    "\n",
    "def map_add_qs(q: Qfrom_slim):\n",
    "    q = q.map(func=lambda age: age+10)\n",
    "    return q(out.dict)\n",
    "\n",
    "test = {\n",
    "    'test_name': 'append test',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(7),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, map_add_np),\n",
    "        ('df', setup.df, map_add_np),\n",
    "        ('qs', setup.qs, map_add_qs),\n",
    "        ('l', setup.l, map_add_l),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 10000000\n",
      "np \t 1.274 s\t 1.0%\n",
      "df \t 1.924 s\t 1.511%\n",
      "qs \t 1.273 s\t 0.999%\n",
      "l \t 2.551 s\t 2.003%\n"
     ]
    }
   ],
   "source": [
    "# map by func\n",
    "def test_func(x): f'i am {x} years old'\n",
    "\n",
    "def map_func_np(data):\n",
    "    map_age = np.frompyfunc(test_func, 1, 1)\n",
    "    data['age'] = map_age(data['age'])\n",
    "    return data\n",
    "\n",
    "def map_func_df(df: pd.DataFrame):\n",
    "    df['age'] = df['age'].apply(test_func)\n",
    "    return df\n",
    "\n",
    "def map_func_qs(q: Qfrom_slim):\n",
    "    q = q.map('age', func.vec(test_func))\n",
    "    return q(out.dict)\n",
    "\n",
    "def map_func_l(data):\n",
    "    data['age'] = [test_func(x) for x in data['age']]\n",
    "    return data\n",
    "\n",
    "test = {\n",
    "    'test_name': 'append test',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(7),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, map_func_np),\n",
    "        ('df', setup.df, map_func_df),\n",
    "        ('qs', setup.qs, map_func_qs),\n",
    "        ('l', setup.l, map_func_l),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def use_pool_map(f, iterable):\n",
    "    with open(f'./tmp_func.py', 'w') as file:\n",
    "        file.write(inspect.getsource(f).replace(f.__name__, \"task\"))\n",
    "        \n",
    "    from tmp_func import task\n",
    "\n",
    "    result = None\n",
    "    with Pool() as pool:\n",
    "        result = pool.map(task, iterable)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\Max\\Documents\\Projekte\\GitHub\\Qfrom\\QfromPackage\\Qfrom_slim.py:1252: RuntimeWarning: coroutine 'map_func_parallel' was never awaited\n",
      "  self.__operation_list = []\n",
      "RuntimeWarning: Enable tracemalloc to get the object allocation traceback\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data_size: 100000\n",
      "\t np \t 1.069 s\t 1.0%\n",
      "\t df \t 1.007 s\t 0.943%\n",
      "\t qs \t 1.045 s\t 0.978%\n",
      "\t l \t 1.047 s\t 0.98%\n",
      "\t pool \t 0.0 s\t 0.0%\n"
     ]
    }
   ],
   "source": [
    "# map by func\n",
    "#def test_func(x): f'i am {x} years old'\n",
    "def test_func(x):\n",
    "    return sum([i**2 for i in range(x)])\n",
    "\n",
    "def map_func_np(data):\n",
    "    map_age = np.frompyfunc(test_func, 1, 1)\n",
    "    data['age'] = map_age(data['age'])\n",
    "    return data\n",
    "\n",
    "def map_func_df(df: pd.DataFrame):\n",
    "    df['age'] = df['age'].map(test_func)\n",
    "    return df\n",
    "\n",
    "def map_func_qs(q: Qfrom_slim):\n",
    "    q = q.map('age', func.vec(test_func))\n",
    "    return q(out.dict)\n",
    "\n",
    "def map_func_l(data):\n",
    "    data['age'] = [test_func(x) for x in data['age']]\n",
    "    return data\n",
    "\n",
    "async def map_func_parallel(data):\n",
    "    #data['age'] = use_pool_map(test_func, data['age'])\n",
    "    with ProcessPoolExecutor() as executor:\n",
    "        data['age'] = await executor.map(test_func, data['age'])\n",
    "        #futures = {executor.submit(test_func, x): x for x in range(10)}\n",
    "        #data['age'] = np.array([future.result() for future in as_completed(futures)])\n",
    "        #f1 = executor.submit(test_func, data['age']) \n",
    "        #data['age'] = f1.result()\n",
    "        #data['age'] = executor.map(test_func, data['age'])\n",
    "\n",
    "test = {\n",
    "    'test_name': 'append test',\n",
    "    'data_source_func': get_tab_data,\n",
    "    #'data_size_list': [10**2, 10**3, 10**4, 10**5, 10**6] + [5*10, 5*10**2, 5*10**3, 5*10**4, 5*10**5],\n",
    "    'data_size_list': [10**2, 10**3, 10**4, 10**5] + [5*10, 5*10**2, 5*10**3, 5*10**4],\n",
    "    'item_name_list': ['np', 'df', 'qs', 'l', 'pool'],\n",
    "    'item_setup_list': [setup.np, setup.df, setup.qs, setup.l, setup.np],\n",
    "    'item_func_list': [map_func_np, map_func_df, map_func_qs, map_func_l, map_func_parallel]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size')\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 1000000\n",
      "np \t 0.226 s\t 1.0%\n",
      "df \t 7.173 s\t 31.757%\n",
      "qs \t 0.135 s\t 0.597%\n",
      "l \t 0.414 s\t 1.833%\n"
     ]
    }
   ],
   "source": [
    "# map by func 2 args\n",
    "f = lambda x, y: f'My name is {x} and i am {y} years old'\n",
    "\n",
    "def map_func_np(data):\n",
    "    map_age = np.frompyfunc(f, 2, 1)\n",
    "    data['msg'] = map_age(data['name'], data['age'])\n",
    "    return data\n",
    "\n",
    "def map_func_df(df: pd.DataFrame):\n",
    "    df['msg'] = df.apply(lambda x: f(x['name'], x['age']), axis=1)\n",
    "    #df['msg'] = [f(*a) for a in zip(df['name'], df['age'])]\n",
    "    #map_age = np.frompyfunc(f, 2, 1)\n",
    "    #map_age = np.vectorize(f)\n",
    "    #df['msg'] = map_age(df['name'], df['age'])\n",
    "    return df\n",
    "\n",
    "def map_func_q(q: Qfrom_slim):\n",
    "    q = q.map('name, age', func.vec(f), 'msg')\n",
    "    return q(out.dict)\n",
    "\n",
    "def map_func_l(data):\n",
    "    data['msg'] = [f(n,a) for n, a in zip(data['name'], data['age'])]\n",
    "    return data\n",
    "\n",
    "test = {\n",
    "    'test_name': 'append test',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(6),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, map_func_np),\n",
    "        ('df', setup.df, map_func_df),\n",
    "        ('qs', setup.qs, map_func_qs),\n",
    "        ('l', setup.l, map_func_l),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)\n",
    "\n",
    "#map_func_q(Qfrom_slim({'name': ['A', 'B', 'C'], 'age': [1, 2, 3]}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def use_pool_starmap(f, *iterables):\n",
    "    with open('./tmp_func.py', 'w') as file:\n",
    "        file.write(inspect.getsource(f).replace(f.__name__, \"task\"))\n",
    "        \n",
    "    from tmp_func import task\n",
    "\n",
    "    result = None\n",
    "    with Pool() as pool:\n",
    "        result = pool.starmap(task, zip(*iterables))\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 100000\n",
      "np \t 1.39 s\t 1.0%\n",
      "df \t 1.361 s\t 0.979%\n",
      "qs \t 1.371 s\t 0.986%\n",
      "l \t 1.473 s\t 1.06%\n",
      "pool \t 0.785 s\t 0.565%\n"
     ]
    }
   ],
   "source": [
    "# map by func 2 args\n",
    "def test_func(x, y): return f'{y/x if x > 0 else 0=}, {sum((y**2)/(i+1) for i in range(x))=}'\n",
    "\n",
    "def map_func_np(data):\n",
    "    map_age = np.frompyfunc(test_func, 2, 1)\n",
    "    data['msg'] = map_age(data['age'], data['salary'])\n",
    "    return data\n",
    "\n",
    "def map_func_df(df: pd.DataFrame):\n",
    "    map_age = np.frompyfunc(test_func, 2, 1)\n",
    "    df['msg'] = map_age(df['age'], df['salary'])\n",
    "    return df\n",
    "\n",
    "def map_func_q(q: Qfrom_slim):\n",
    "    q = q.map('age, salary', func.vec(test_func), 'msg')\n",
    "    return q(out.dict)\n",
    "\n",
    "def map_func_l(data):\n",
    "    data['msg'] = [test_func(n,a) for n, a in zip(data['age'], data['salary'])]\n",
    "    return data\n",
    "\n",
    "def map_func_parallel(data):\n",
    "    data['msg'] = use_pool_starmap(test_func, data['age'], data['salary'])\n",
    "\n",
    "test = {\n",
    "    'test_name': 'append test',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': [10**2, 10**3, 10**4, 10**5] + [5*10, 5*10**2, 5*10**3, 5*10**4],\n",
    "    'item_name_list': ['np', 'df', 'qs', 'l', 'pool'],\n",
    "    'item_setup_list': [setup.np, setup.df, setup.qs, setup.l, setup.np],\n",
    "    'item_func_list': [map_func_np, map_func_df, map_func_q, map_func_l, map_func_parallel]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>age</th>\n",
       "      <th>job</th>\n",
       "      <th>msg</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Steven</td>\n",
       "      <td>7</td>\n",
       "      <td>freelancer</td>\n",
       "      <td>My name is Steven and i am 7 years old</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Ann</td>\n",
       "      <td>88</td>\n",
       "      <td>manager</td>\n",
       "      <td>My name is Ann and i am 88 years old</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Ann</td>\n",
       "      <td>48</td>\n",
       "      <td>manager</td>\n",
       "      <td>My name is Ann and i am 48 years old</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     name  age         job                                     msg\n",
       "0  Steven    7  freelancer  My name is Steven and i am 7 years old\n",
       "1     Ann   88     manager    My name is Ann and i am 88 years old\n",
       "2     Ann   48     manager    My name is Ann and i am 48 years old"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = get_tab_data(3)\n",
    "df = setup.df(data)\n",
    "map_func_df(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 1000000\n",
      "np \t 0.094 s\t 1.0%\n",
      "df \t 0.182 s\t 1.927%\n",
      "qs \t 0.095 s\t 1.004%\n",
      "l \t 1.134 s\t 12.013%\n"
     ]
    }
   ],
   "source": [
    "# orderby\n",
    "\n",
    "def orderby_np(data):\n",
    "    key_array = data['age']\n",
    "    sorted_ids = np.argsort(key_array)\n",
    "    return {key: value[sorted_ids] for key, value in data.items()}\n",
    "\n",
    "def orderby_df(df):\n",
    "    return df.sort_values('age')\n",
    "\n",
    "def orderby_qs(q: Qfrom_slim):\n",
    "    return q.orderby('age')(out.dict)\n",
    "\n",
    "def orderby_l(data):\n",
    "    sorted_ids = sorted(range(len(data['age'])), key=lambda x: data['age'][x])\n",
    "    return {key: [value[i] for i in sorted_ids] for key, value in data.items()}\n",
    "\n",
    "test = {\n",
    "    'test_name': 'append test',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(6),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, orderby_np),\n",
    "        ('df', setup.df, orderby_df),\n",
    "        ('qs', setup.qs, orderby_qs),\n",
    "        ('l', setup.l, orderby_l),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 1000000\n",
      "np \t 0.401 s\t 1.0%\n",
      "df \t 0.234 s\t 0.585%\n",
      "qs \t 0.387 s\t 0.966%\n"
     ]
    }
   ],
   "source": [
    "# orderby multible cols\n",
    "\n",
    "def orderby_mult_np(data):\n",
    "    sorted_ids = np.lexsort([data['age'], data['name']])\n",
    "    return {key:value[sorted_ids] for key, value in data.items()}\n",
    "\n",
    "def orderby_mult_df(df):\n",
    "    return df.sort_values(['name', 'age'])\n",
    "\n",
    "def orderby_mult_qs(q: Qfrom_slim):\n",
    "    return q.orderby('name, age')(out.dict)\n",
    "\n",
    "#def orderby_mult_l(l):\n",
    "#    return sorted(l)\n",
    "\n",
    "test = {\n",
    "    'test_name': 'append test',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(7),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, orderby_mult_np),\n",
    "        ('df', setup.df, orderby_mult_df),\n",
    "        ('qs', setup.qs, orderby_mult_qs),\n",
    "        #('l', setup.l, orderby_mult_l),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 10000000\n",
      "np \t 0.237 s\t 1.0%\n",
      "df \t 0.659 s\t 2.779%\n",
      "qs \t 0.235 s\t 0.993%\n",
      "l \t 1.444 s\t 6.092%\n"
     ]
    }
   ],
   "source": [
    "# where\n",
    "\n",
    "def where_np(data):\n",
    "    job_filter = np.where(data['job']=='manager')\n",
    "    data = {key: value[job_filter] for key, value in data.items()}\n",
    "    return data\n",
    "\n",
    "def where_df(df):\n",
    "    return df[df['job']=='manager']\n",
    "\n",
    "def where_qs(q: Qfrom_slim):\n",
    "    return q.where('job', lambda x: x==\"manager\")(out.dict)\n",
    "\n",
    "def where_l(data):\n",
    "    job_filter = [i for i in range(len(data['job'])) if data['job'][i]=='manager']\n",
    "    return {key: [value[i] for i in job_filter] for key, value in data.items()}\n",
    "\n",
    "test = {\n",
    "    'test_name': 'where',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(7),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, where_np),\n",
    "        ('df', setup.df, where_df),\n",
    "        ('qs', setup.qs, where_qs),\n",
    "        ('l', setup.l, where_l),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 10000000\n",
      "np \t 2.586 s\t 1.0%\n",
      "df \t 0.617 s\t 0.239%\n",
      "qs \t 7.57 s\t 2.927%\n"
     ]
    }
   ],
   "source": [
    "# groupby\n",
    "cols = 'job'\n",
    "\n",
    "def groupby_np(data):\n",
    "    sorted_ids = np.argsort(data[cols])\n",
    "    sorted_key_array = data[cols][sorted_ids]\n",
    "    unique_keys, unique_key_ids = np.unique(sorted_key_array, return_index=True)\n",
    "    id_groups = np.split(sorted_ids, unique_key_ids[1:])\n",
    "    #return id_groups\n",
    "    group_dict = {\n",
    "        'key': unique_keys,\n",
    "        'group': np.array([{key:col[ids] for key, col in data.items()} for ids in id_groups])\n",
    "        }\n",
    "\n",
    "    return group_dict\n",
    "\n",
    "\n",
    "def groupby_df(df: pd.DataFrame):\n",
    "    return df.groupby(cols).groups\n",
    "\n",
    "def groupby_qs(q: Qfrom_slim):\n",
    "    return q.groupby(cols)(out.dict)\n",
    "\n",
    "#def groupby_l(l):\n",
    "#    return list(itertools.groupby(l, key=lambda x: x['job']))\n",
    "\n",
    "test = {\n",
    "    'test_name': 'groupby',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(7),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, groupby_np),\n",
    "        ('df', setup.df, groupby_df),\n",
    "        ('qs', setup.qs, groupby_qs),\n",
    "        #('l', setup.l, groupby_l),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 1000000\n",
      "np \t 3.509 s\t 1.0%\n",
      "df \t 0.893 s\t 0.254%\n",
      "qs \t 1.07 s\t 0.305%\n"
     ]
    }
   ],
   "source": [
    "# groupby\n",
    "cols = ['job', 'name']\n",
    "\n",
    "def group_by_dict(key_iter: Iterable):\n",
    "    group_ids_dict = {}\n",
    "    for i, key in enumerate(key_iter):\n",
    "        if key not in group_ids_dict:\n",
    "            #group_ids_dict[key] = []\n",
    "            group_ids_dict[key] = []\n",
    "        group_ids_dict[key].append(i)\n",
    "    \n",
    "    return group_ids_dict\n",
    "\n",
    "def groupby_np(data):\n",
    "    #start_time = time.time()\n",
    "    \n",
    "    sorted_ids = np.lexsort([data[c] for c in cols[::-1]])\n",
    "    \n",
    "    #print(f'sort: {time.time()-start_time}')\n",
    "    #start_time = time.time()\n",
    "    \n",
    "    sorted_key_array = array_tuple_to_tuple_array([c for k, c in data.items() if k in cols])\n",
    "    \n",
    "    #print(f'key array: {time.time()-start_time}')\n",
    "    #start_time = time.time()\n",
    "    \n",
    "    unique_keys, unique_key_ids = np.unique(sorted_key_array, return_index=True)\n",
    "    #group_by_dict(sorted_key_array)\n",
    "\n",
    "    #print(f'unique: {time.time()-start_time}')\n",
    "    #start_time = time.time()\n",
    "    \n",
    "    id_groups = np.split(sorted_ids, unique_key_ids[1:])\n",
    "    \n",
    "    #print(f'split: {time.time()-start_time}')\n",
    "    #start_time = time.time()\n",
    "    \n",
    "    group_dict = {\n",
    "        'key': unique_keys,\n",
    "        'group': np.array([{key:col[ids] for key, col in data.items()} for ids in id_groups])\n",
    "        }\n",
    "    \n",
    "    #print(f'to dict: {time.time()-start_time}')\n",
    "    \n",
    "    return group_dict\n",
    "\n",
    "\n",
    "def groupby_df(df: pd.DataFrame):\n",
    "    return df.groupby(cols).groups\n",
    "\n",
    "def groupby_qs(q: Qfrom_slim):\n",
    "    return q.groupby(cols)(out.dict)\n",
    "\n",
    "test = {\n",
    "    'test_name': 'groupby',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(6),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, groupby_np),\n",
    "        ('df', setup.df, groupby_df),\n",
    "        ('qs', setup.qs, groupby_qs),\n",
    "        #('l', setup.l, groupby_l),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max data_size: 10000000\n",
      "np \t 0.006 s\t 1.0%\n",
      "df \t 0.007 s\t 1.167%\n",
      "qs \t 0.006 s\t 0.928%\n",
      "l \t 0.379 s\t 63.103%\n"
     ]
    }
   ],
   "source": [
    "# agg\n",
    "\n",
    "def agg_np(data):\n",
    "    return np.mean(data['age'])\n",
    "\n",
    "def agg_df(df: pd.DataFrame):\n",
    "    return df['age'].agg('mean')\n",
    "\n",
    "def agg_qs(q: Qfrom_slim):\n",
    "    return q['age'].agg(agg.mean)\n",
    "\n",
    "def agg_l(data):\n",
    "    return sum(data['age']) / len(data['age'])\n",
    "\n",
    "test = {\n",
    "    'test_name': 'agg',\n",
    "    'data_source_func': get_tab_data,\n",
    "    'data_size_list': get_data_size_list(7),\n",
    "    'test_items': [\n",
    "        ('np', setup.np, agg_np),\n",
    "        ('df', setup.df, agg_df),\n",
    "        ('qs', setup.qs, agg_qs),\n",
    "        ('l', setup.l, agg_l),\n",
    "    ]\n",
    "    }\n",
    "q_results = run_test(test)\n",
    "q_results = q_results(get_data_size_tab)\n",
    "q_results(plot.plot, x='data_size', x_scale_log=True, y_scale_log=True)\n",
    "q_results(print_max_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5*10**5\n",
    "data = get_tab_data(n)\n",
    "np_data = setup.np(data)\n",
    "np_g = groupby_np(np_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': array(['Ann', 'Ann', 'Max', 'Steven'], dtype='<U8'), 'age': array([66, 48, 24, 75]), 'job': array(['manager', 'freelancer', 'freelancer', 'jobless'], dtype='<U10')}\n",
      "np_g={'key': array([('Ann', 'freelancer'), ('Ann', 'manager'), ('Max', 'freelancer'),\n",
      "       ('Steven', 'jobless')], dtype=object), 'group': array([{'name': array([], dtype='<U8'), 'age': array([], dtype=int32), 'job': array([], dtype='<U10')},\n",
      "       {'name': array(['Ann', 'Max'], dtype='<U8'), 'age': array([48, 24]), 'job': array(['freelancer', 'freelancer'], dtype='<U10')},\n",
      "       {'name': array(['Steven'], dtype='<U8'), 'age': array([75]), 'job': array(['jobless'], dtype='<U10')},\n",
      "       {'name': array(['Ann'], dtype='<U8'), 'age': array([66]), 'job': array(['manager'], dtype='<U10')}],\n",
      "      dtype=object)}\n",
      "df_g={('freelancer', 'Ann'): [1], ('freelancer', 'Max'): [2], ('jobless', 'Steven'): [3], ('manager', 'Ann'): [0]}\n",
      "qs_g={'key': array([('manager', 'Ann'), ('freelancer', 'Ann'), ('freelancer', 'Max'),\n",
      "       ('jobless', 'Steven')], dtype=object), 'group': array([Qfrom\n",
      "       name\tage\tjob\n",
      "       Ann\t66\tmanager, Qfrom\n",
      "                       name\tage\tjob\n",
      "                       Ann\t48\tfreelancer, Qfrom\n",
      "                                          name\tage\tjob\n",
      "                                          Max\t24\tfreelancer,\n",
      "       Qfrom\n",
      "       name\tage\tjob\n",
      "       Steven\t75\tjobless], dtype=object)}\n"
     ]
    }
   ],
   "source": [
    "n = 4\n",
    "data = get_tab_data(n)\n",
    "print(data)\n",
    "np_data = setup.np(data)\n",
    "df_data = setup.df(data)\n",
    "qs_data = setup.qs(data)\n",
    "np_g = groupby_np(np_data)\n",
    "df_g = groupby_df(df_data)\n",
    "qs_g = groupby_qs(qs_data)\n",
    "print(f'{np_g=}')\n",
    "print(f'{df_g=}')\n",
    "print(f'{qs_g=}')"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "28b06ec166af8c83e5882731fef908354c2d57d9b46df793dcdb4efcedb4ca54"
  },
  "kernelspec": {
   "display_name": "Python 3.10.0 64-bit",
   "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.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}