diff --git a/demand_from_node_poi_detailed.ipynb b/demand_from_node_poi_detailed.ipynb new file mode 100644 index 0000000..c38976d --- /dev/null +++ b/demand_from_node_poi_detailed.ipynb @@ -0,0 +1,1588 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_ghEaf-d2Fdm" + }, + "source": [ + "**Step 0: load the OSM file from the repository of OSM testing datasets**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "e3xZMKsJ2Ew2" + }, + "outputs": [], + "source": [ + "!rm -rf ./grid2demand/\n", + "# !git clone https://github.com/xyluo25/grid2demand.git\n", + "\n", + "# %cd grid2demand/datasets" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CexwTGDB0D0A" + }, + "source": [ + "Check the file icon on the left hand side, makesure file map.osm exists." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "j6y7B8WX-d46" + }, + "source": [ + "**Step 1: install python packages**" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Mysg2UEz0cu5", + "outputId": "59e532c1-6abe-4854-ec00-a9ec98fe58ac", + "collapsed": true + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: osm2gmns in /usr/local/lib/python3.10/dist-packages (0.7.6)\n", + "Requirement already satisfied: numpy>=1.26.4 in /usr/local/lib/python3.10/dist-packages (from osm2gmns) (2.0.0)\n", + "Requirement already satisfied: osmium>=3.7.0 in /usr/local/lib/python3.10/dist-packages (from osm2gmns) (3.7.0)\n", + "Requirement already satisfied: pyufunc>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from osm2gmns) (0.2.9)\n", + "Requirement already satisfied: Requests>=2.31.0 in /usr/local/lib/python3.10/dist-packages (from osm2gmns) (2.31.0)\n", + "Requirement already satisfied: setuptools>=68.2.2 in /usr/local/lib/python3.10/dist-packages (from osm2gmns) (70.1.0)\n", + "Requirement already satisfied: Shapely>=2.0.3 in /usr/local/lib/python3.10/dist-packages (from osm2gmns) (2.0.4)\n", + "Requirement already satisfied: matplotlib>=3.8.2 in /usr/local/lib/python3.10/dist-packages (from osm2gmns) (3.9.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns) (4.53.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns) (24.1)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns) (2.8.2)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from pyufunc>=0.2.1->osm2gmns) (2.2.2)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from Requests>=2.31.0->osm2gmns) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from Requests>=2.31.0->osm2gmns) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from Requests>=2.31.0->osm2gmns) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from Requests>=2.31.0->osm2gmns) (2024.6.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib>=3.8.2->osm2gmns) (1.16.0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->pyufunc>=0.2.1->osm2gmns) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas->pyufunc>=0.2.1->osm2gmns) (2024.1)\n", + "Requirement already satisfied: grid2demand in /usr/local/lib/python3.10/dist-packages (0.4.7)\n", + "Requirement already satisfied: numpy>=1.26.4 in /usr/local/lib/python3.10/dist-packages (from grid2demand) (2.0.0)\n", + "Requirement already satisfied: osm2gmns>=0.7.5 in /usr/local/lib/python3.10/dist-packages (from grid2demand) (0.7.6)\n", + "Requirement already satisfied: pandas>=2.2.1 in /usr/local/lib/python3.10/dist-packages (from grid2demand) (2.2.2)\n", + "Requirement already satisfied: pyufunc>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from grid2demand) (0.2.9)\n", + "Requirement already satisfied: Shapely>=2.0.3 in /usr/local/lib/python3.10/dist-packages (from grid2demand) (2.0.4)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from grid2demand) (4.66.4)\n", + "Requirement already satisfied: osmium>=3.7.0 in /usr/local/lib/python3.10/dist-packages (from osm2gmns>=0.7.5->grid2demand) (3.7.0)\n", + "Requirement already satisfied: Requests>=2.31.0 in /usr/local/lib/python3.10/dist-packages (from osm2gmns>=0.7.5->grid2demand) (2.31.0)\n", + "Requirement already satisfied: setuptools>=68.2.2 in /usr/local/lib/python3.10/dist-packages (from osm2gmns>=0.7.5->grid2demand) (70.1.0)\n", + "Requirement already satisfied: matplotlib>=3.8.2 in /usr/local/lib/python3.10/dist-packages (from osm2gmns>=0.7.5->grid2demand) (3.9.0)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas>=2.2.1->grid2demand) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=2.2.1->grid2demand) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas>=2.2.1->grid2demand) (2024.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns>=0.7.5->grid2demand) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns>=0.7.5->grid2demand) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns>=0.7.5->grid2demand) (4.53.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns>=0.7.5->grid2demand) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns>=0.7.5->grid2demand) (24.1)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns>=0.7.5->grid2demand) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.8.2->osm2gmns>=0.7.5->grid2demand) (3.1.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas>=2.2.1->grid2demand) (1.16.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from Requests>=2.31.0->osm2gmns>=0.7.5->grid2demand) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from Requests>=2.31.0->osm2gmns>=0.7.5->grid2demand) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from Requests>=2.31.0->osm2gmns>=0.7.5->grid2demand) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from Requests>=2.31.0->osm2gmns>=0.7.5->grid2demand) (2024.6.2)\n", + "Requirement already satisfied: pyufunc in /usr/local/lib/python3.10/dist-packages (0.2.9)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from pyufunc) (2.2.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from pyufunc) (2.0.0)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas->pyufunc) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->pyufunc) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas->pyufunc) (2024.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas->pyufunc) (1.16.0)\n" + ] + } + ], + "source": [ + "!pip install osm2gmns\n", + "!pip install grid2demand\n", + "!pip install pyufunc\n" + ] + }, + { + "cell_type": "code", + "source": [ + "# load datasets from github\n", + "import pyufunc as pf\n", + "pf.github_file_downloader(r\"https://github.com/xyluo25/grid2demand/tree/main/datasets\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "collapsed": true, + "id": "4F5trI7pqHNo", + "outputId": "83e87108-f65c-4606-a4a5-85659f3e62c8" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "pyufunc supports Python 3.10 or higher.\n", + "\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"/usr/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", + " return _run_code(code, main_globals, None,\n", + " File \"/usr/lib/python3.10/runpy.py\", line 86, in _run_code\n", + " exec(code, run_globals)\n", + " File \"/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py\", line 37, in \n", + " ColabKernelApp.launch_instance()\n", + " File \"/usr/local/lib/python3.10/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n", + " app.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelapp.py\", line 619, in start\n", + " self.io_loop.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/platform/asyncio.py\", line 195, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n", + " self._run_once()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 1909, in _run_once\n", + " handle._run()\n", + " File \"/usr/lib/python3.10/asyncio/events.py\", line 80, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 685, in \n", + " lambda f: self._run_callback(functools.partial(callback, future))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 738, in _run_callback\n", + " ret = callback()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 825, in inner\n", + " self.ctx_run(self.run)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 786, in run\n", + " yielded = self.gen.send(value)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 361, in process_one\n", + " yield gen.maybe_future(dispatch(*args))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 261, in dispatch_shell\n", + " yield gen.maybe_future(handler(stream, idents, msg))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 539, in execute_request\n", + " self.do_execute(\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py\", line 302, in do_execute\n", + " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/zmqshell.py\", line 539, in run_cell\n", + " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n", + " result = self._run_cell(\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n", + " return runner(coro)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n", + " if (await self.run_code(code, result, async_=asy)):\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"\", line 2, in \n", + " import pyufunc as pf\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/__init__.py\", line 16, in \n", + " from .util_datetime import * # datetime functions # noqa: F403\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_datetime/__init__.py\", line 15, in \n", + " from ._dt_group import (group_dt_yearly,\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_datetime/_dt_group.py\", line 19, in \n", + " def group_dt_yearly(df: pd.DataFrame, interval: int = 1, col: list = [\"datetime\", \"value\"]) -> pd.DataFrame:\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in inner\n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in \n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_import_package.py\", line 236, in is_module_importable\n", + " exec(f\"import {module_name}\")\n", + " File \"\", line 1, in \n", + " File \"/usr/local/lib/python3.10/dist-packages/pandas/__init__.py\", line 26, in \n", + " from pandas.compat import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pandas/compat/__init__.py\", line 27, in \n", + " from pandas.compat.pyarrow import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pandas/compat/pyarrow.py\", line 8, in \n", + " import pyarrow as pa\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyarrow/__init__.py\", line 65, in \n", + " import pyarrow.lib as _lib\n" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "_ARRAY_API not found", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: _ARRAY_API not found" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"/usr/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", + " return _run_code(code, main_globals, None,\n", + " File \"/usr/lib/python3.10/runpy.py\", line 86, in _run_code\n", + " exec(code, run_globals)\n", + " File \"/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py\", line 37, in \n", + " ColabKernelApp.launch_instance()\n", + " File \"/usr/local/lib/python3.10/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n", + " app.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelapp.py\", line 619, in start\n", + " self.io_loop.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/platform/asyncio.py\", line 195, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n", + " self._run_once()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 1909, in _run_once\n", + " handle._run()\n", + " File \"/usr/lib/python3.10/asyncio/events.py\", line 80, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 685, in \n", + " lambda f: self._run_callback(functools.partial(callback, future))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 738, in _run_callback\n", + " ret = callback()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 825, in inner\n", + " self.ctx_run(self.run)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 786, in run\n", + " yielded = self.gen.send(value)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 361, in process_one\n", + " yield gen.maybe_future(dispatch(*args))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 261, in dispatch_shell\n", + " yield gen.maybe_future(handler(stream, idents, msg))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 539, in execute_request\n", + " self.do_execute(\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py\", line 302, in do_execute\n", + " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/zmqshell.py\", line 539, in run_cell\n", + " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n", + " result = self._run_cell(\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n", + " return runner(coro)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n", + " if (await self.run_code(code, result, async_=asy)):\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"\", line 2, in \n", + " import pyufunc as pf\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/__init__.py\", line 16, in \n", + " from .util_datetime import * # datetime functions # noqa: F403\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_datetime/__init__.py\", line 15, in \n", + " from ._dt_group import (group_dt_yearly,\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_datetime/_dt_group.py\", line 19, in \n", + " def group_dt_yearly(df: pd.DataFrame, interval: int = 1, col: list = [\"datetime\", \"value\"]) -> pd.DataFrame:\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in inner\n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in \n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_import_package.py\", line 236, in is_module_importable\n", + " exec(f\"import {module_name}\")\n", + " File \"\", line 1, in \n", + " File \"/usr/local/lib/python3.10/dist-packages/pandas/__init__.py\", line 49, in \n", + " from pandas.core.api import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pandas/core/api.py\", line 9, in \n", + " from pandas.core.dtypes.dtypes import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pandas/core/dtypes/dtypes.py\", line 24, in \n", + " from pandas._libs import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyarrow/__init__.py\", line 65, in \n", + " import pyarrow.lib as _lib\n" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "_ARRAY_API not found", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: _ARRAY_API not found" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"/usr/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", + " return _run_code(code, main_globals, None,\n", + " File \"/usr/lib/python3.10/runpy.py\", line 86, in _run_code\n", + " exec(code, run_globals)\n", + " File \"/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py\", line 37, in \n", + " ColabKernelApp.launch_instance()\n", + " File \"/usr/local/lib/python3.10/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n", + " app.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelapp.py\", line 619, in start\n", + " self.io_loop.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/platform/asyncio.py\", line 195, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n", + " self._run_once()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 1909, in _run_once\n", + " handle._run()\n", + " File \"/usr/lib/python3.10/asyncio/events.py\", line 80, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 685, in \n", + " lambda f: self._run_callback(functools.partial(callback, future))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 738, in _run_callback\n", + " ret = callback()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 825, in inner\n", + " self.ctx_run(self.run)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 786, in run\n", + " yielded = self.gen.send(value)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 361, in process_one\n", + " yield gen.maybe_future(dispatch(*args))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 261, in dispatch_shell\n", + " yield gen.maybe_future(handler(stream, idents, msg))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 539, in execute_request\n", + " self.do_execute(\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py\", line 302, in do_execute\n", + " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/zmqshell.py\", line 539, in run_cell\n", + " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n", + " result = self._run_cell(\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n", + " return runner(coro)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n", + " if (await self.run_code(code, result, async_=asy)):\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"\", line 2, in \n", + " import pyufunc as pf\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/__init__.py\", line 21, in \n", + " from .util_img import * # image functions # noqa: F403\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/__init__.py\", line 8, in \n", + " from ._img_cvt import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_cvt.py\", line 21, in \n", + " from ._img_operate import img_CV_to_PIL, img_PIL_to_CV\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_operate.py\", line 78, in \n", + " def img_PIL_to_CV(img: Image.Image) -> np.ndarray:\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in inner\n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in \n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_import_package.py\", line 236, in is_module_importable\n", + " exec(f\"import {module_name}\")\n", + " File \"\", line 1, in \n", + " File \"/usr/local/lib/python3.10/dist-packages/google/colab/_import_hooks/_cv2.py\", line 78, in load_module\n", + " cv_module = imp.load_module(name, *module_info)\n", + " File \"/usr/lib/python3.10/imp.py\", line 245, in load_module\n", + " return load_package(name, filename)\n", + " File \"/usr/lib/python3.10/imp.py\", line 217, in load_package\n", + " return _load(spec)\n", + " File \"/usr/local/lib/python3.10/dist-packages/cv2/__init__.py\", line 181, in \n", + " bootstrap()\n", + " File \"/usr/local/lib/python3.10/dist-packages/cv2/__init__.py\", line 153, in bootstrap\n", + " native_module = importlib.import_module(\"cv2\")\n", + " File \"/usr/lib/python3.10/importlib/__init__.py\", line 126, in import_module\n", + " return _bootstrap._gcd_import(name[level:], package, level)\n", + " File \"/usr/local/lib/python3.10/dist-packages/google/colab/_import_hooks/_cv2.py\", line 78, in load_module\n", + " cv_module = imp.load_module(name, *module_info)\n", + " File \"/usr/lib/python3.10/imp.py\", line 243, in load_module\n", + " return load_dynamic(name, filename, file)\n", + " File \"/usr/lib/python3.10/imp.py\", line 343, in load_dynamic\n", + " return _load(spec)\n" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "_ARRAY_API not found", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: _ARRAY_API not found" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"/usr/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", + " return _run_code(code, main_globals, None,\n", + " File \"/usr/lib/python3.10/runpy.py\", line 86, in _run_code\n", + " exec(code, run_globals)\n", + " File \"/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py\", line 37, in \n", + " ColabKernelApp.launch_instance()\n", + " File \"/usr/local/lib/python3.10/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n", + " app.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelapp.py\", line 619, in start\n", + " self.io_loop.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/platform/asyncio.py\", line 195, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n", + " self._run_once()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 1909, in _run_once\n", + " handle._run()\n", + " File \"/usr/lib/python3.10/asyncio/events.py\", line 80, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 685, in \n", + " lambda f: self._run_callback(functools.partial(callback, future))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 738, in _run_callback\n", + " ret = callback()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 825, in inner\n", + " self.ctx_run(self.run)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 786, in run\n", + " yielded = self.gen.send(value)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 361, in process_one\n", + " yield gen.maybe_future(dispatch(*args))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 261, in dispatch_shell\n", + " yield gen.maybe_future(handler(stream, idents, msg))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 539, in execute_request\n", + " self.do_execute(\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py\", line 302, in do_execute\n", + " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/zmqshell.py\", line 539, in run_cell\n", + " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n", + " result = self._run_cell(\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n", + " return runner(coro)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n", + " if (await self.run_code(code, result, async_=asy)):\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"\", line 2, in \n", + " import pyufunc as pf\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/__init__.py\", line 21, in \n", + " from .util_img import * # image functions # noqa: F403\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/__init__.py\", line 8, in \n", + " from ._img_cvt import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_cvt.py\", line 21, in \n", + " from ._img_operate import img_CV_to_PIL, img_PIL_to_CV\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_operate.py\", line 106, in \n", + " def img_CV_to_PIL(img: np.ndarray) -> Image.Image:\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in inner\n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in \n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_import_package.py\", line 236, in is_module_importable\n", + " exec(f\"import {module_name}\")\n", + " File \"\", line 1, in \n", + " File \"/usr/local/lib/python3.10/dist-packages/google/colab/_import_hooks/_cv2.py\", line 78, in load_module\n", + " cv_module = imp.load_module(name, *module_info)\n", + " File \"/usr/lib/python3.10/imp.py\", line 243, in load_module\n", + " return load_dynamic(name, filename, file)\n", + " File \"/usr/lib/python3.10/imp.py\", line 343, in load_dynamic\n", + " return _load(spec)\n" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "_ARRAY_API not found", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: _ARRAY_API not found" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"/usr/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", + " return _run_code(code, main_globals, None,\n", + " File \"/usr/lib/python3.10/runpy.py\", line 86, in _run_code\n", + " exec(code, run_globals)\n", + " File \"/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py\", line 37, in \n", + " ColabKernelApp.launch_instance()\n", + " File \"/usr/local/lib/python3.10/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n", + " app.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelapp.py\", line 619, in start\n", + " self.io_loop.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/platform/asyncio.py\", line 195, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n", + " self._run_once()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 1909, in _run_once\n", + " handle._run()\n", + " File \"/usr/lib/python3.10/asyncio/events.py\", line 80, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 685, in \n", + " lambda f: self._run_callback(functools.partial(callback, future))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 738, in _run_callback\n", + " ret = callback()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 825, in inner\n", + " self.ctx_run(self.run)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 786, in run\n", + " yielded = self.gen.send(value)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 361, in process_one\n", + " yield gen.maybe_future(dispatch(*args))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 261, in dispatch_shell\n", + " yield gen.maybe_future(handler(stream, idents, msg))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 539, in execute_request\n", + " self.do_execute(\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py\", line 302, in do_execute\n", + " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/zmqshell.py\", line 539, in run_cell\n", + " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n", + " result = self._run_cell(\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n", + " return runner(coro)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n", + " if (await self.run_code(code, result, async_=asy)):\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"\", line 2, in \n", + " import pyufunc as pf\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/__init__.py\", line 21, in \n", + " from .util_img import * # image functions # noqa: F403\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/__init__.py\", line 8, in \n", + " from ._img_cvt import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_cvt.py\", line 21, in \n", + " from ._img_operate import img_CV_to_PIL, img_PIL_to_CV\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_operate.py\", line 132, in \n", + " def img_translate(img: Union[np.ndarray, str, Image.Image],\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in inner\n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in \n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_import_package.py\", line 236, in is_module_importable\n", + " exec(f\"import {module_name}\")\n", + " File \"\", line 1, in \n", + " File \"/usr/local/lib/python3.10/dist-packages/google/colab/_import_hooks/_cv2.py\", line 78, in load_module\n", + " cv_module = imp.load_module(name, *module_info)\n", + " File \"/usr/lib/python3.10/imp.py\", line 243, in load_module\n", + " return load_dynamic(name, filename, file)\n", + " File \"/usr/lib/python3.10/imp.py\", line 343, in load_dynamic\n", + " return _load(spec)\n" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "_ARRAY_API not found", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: _ARRAY_API not found" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"/usr/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", + " return _run_code(code, main_globals, None,\n", + " File \"/usr/lib/python3.10/runpy.py\", line 86, in _run_code\n", + " exec(code, run_globals)\n", + " File \"/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py\", line 37, in \n", + " ColabKernelApp.launch_instance()\n", + " File \"/usr/local/lib/python3.10/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n", + " app.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelapp.py\", line 619, in start\n", + " self.io_loop.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/platform/asyncio.py\", line 195, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n", + " self._run_once()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 1909, in _run_once\n", + " handle._run()\n", + " File \"/usr/lib/python3.10/asyncio/events.py\", line 80, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 685, in \n", + " lambda f: self._run_callback(functools.partial(callback, future))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 738, in _run_callback\n", + " ret = callback()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 825, in inner\n", + " self.ctx_run(self.run)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 786, in run\n", + " yielded = self.gen.send(value)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 361, in process_one\n", + " yield gen.maybe_future(dispatch(*args))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 261, in dispatch_shell\n", + " yield gen.maybe_future(handler(stream, idents, msg))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 539, in execute_request\n", + " self.do_execute(\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py\", line 302, in do_execute\n", + " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/zmqshell.py\", line 539, in run_cell\n", + " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n", + " result = self._run_cell(\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n", + " return runner(coro)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n", + " if (await self.run_code(code, result, async_=asy)):\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"\", line 2, in \n", + " import pyufunc as pf\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/__init__.py\", line 21, in \n", + " from .util_img import * # image functions # noqa: F403\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/__init__.py\", line 8, in \n", + " from ._img_cvt import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_cvt.py\", line 21, in \n", + " from ._img_operate import img_CV_to_PIL, img_PIL_to_CV\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_operate.py\", line 195, in \n", + " def img_rotate(img: Union[np.ndarray, str, Image.Image],\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in inner\n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in \n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_import_package.py\", line 236, in is_module_importable\n", + " exec(f\"import {module_name}\")\n", + " File \"\", line 1, in \n", + " File \"/usr/local/lib/python3.10/dist-packages/google/colab/_import_hooks/_cv2.py\", line 78, in load_module\n", + " cv_module = imp.load_module(name, *module_info)\n", + " File \"/usr/lib/python3.10/imp.py\", line 243, in load_module\n", + " return load_dynamic(name, filename, file)\n", + " File \"/usr/lib/python3.10/imp.py\", line 343, in load_dynamic\n", + " return _load(spec)\n" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "_ARRAY_API not found", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: _ARRAY_API not found" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"/usr/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", + " return _run_code(code, main_globals, None,\n", + " File \"/usr/lib/python3.10/runpy.py\", line 86, in _run_code\n", + " exec(code, run_globals)\n", + " File \"/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py\", line 37, in \n", + " ColabKernelApp.launch_instance()\n", + " File \"/usr/local/lib/python3.10/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n", + " app.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelapp.py\", line 619, in start\n", + " self.io_loop.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/platform/asyncio.py\", line 195, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n", + " self._run_once()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 1909, in _run_once\n", + " handle._run()\n", + " File \"/usr/lib/python3.10/asyncio/events.py\", line 80, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 685, in \n", + " lambda f: self._run_callback(functools.partial(callback, future))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 738, in _run_callback\n", + " ret = callback()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 825, in inner\n", + " self.ctx_run(self.run)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 786, in run\n", + " yielded = self.gen.send(value)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 361, in process_one\n", + " yield gen.maybe_future(dispatch(*args))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 261, in dispatch_shell\n", + " yield gen.maybe_future(handler(stream, idents, msg))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 539, in execute_request\n", + " self.do_execute(\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py\", line 302, in do_execute\n", + " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/zmqshell.py\", line 539, in run_cell\n", + " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n", + " result = self._run_cell(\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n", + " return runner(coro)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n", + " if (await self.run_code(code, result, async_=asy)):\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"\", line 2, in \n", + " import pyufunc as pf\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/__init__.py\", line 21, in \n", + " from .util_img import * # image functions # noqa: F403\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/__init__.py\", line 8, in \n", + " from ._img_cvt import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_cvt.py\", line 21, in \n", + " from ._img_operate import img_CV_to_PIL, img_PIL_to_CV\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_operate.py\", line 278, in \n", + " def img_rotate_bound(img: Union[np.ndarray, str, Image.Image],\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in inner\n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in \n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_import_package.py\", line 236, in is_module_importable\n", + " exec(f\"import {module_name}\")\n", + " File \"\", line 1, in \n", + " File \"/usr/local/lib/python3.10/dist-packages/google/colab/_import_hooks/_cv2.py\", line 78, in load_module\n", + " cv_module = imp.load_module(name, *module_info)\n", + " File \"/usr/lib/python3.10/imp.py\", line 243, in load_module\n", + " return load_dynamic(name, filename, file)\n", + " File \"/usr/lib/python3.10/imp.py\", line 343, in load_dynamic\n", + " return _load(spec)\n" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "_ARRAY_API not found", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: _ARRAY_API not found" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"/usr/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", + " return _run_code(code, main_globals, None,\n", + " File \"/usr/lib/python3.10/runpy.py\", line 86, in _run_code\n", + " exec(code, run_globals)\n", + " File \"/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py\", line 37, in \n", + " ColabKernelApp.launch_instance()\n", + " File \"/usr/local/lib/python3.10/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n", + " app.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelapp.py\", line 619, in start\n", + " self.io_loop.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/platform/asyncio.py\", line 195, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n", + " self._run_once()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 1909, in _run_once\n", + " handle._run()\n", + " File \"/usr/lib/python3.10/asyncio/events.py\", line 80, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 685, in \n", + " lambda f: self._run_callback(functools.partial(callback, future))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 738, in _run_callback\n", + " ret = callback()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 825, in inner\n", + " self.ctx_run(self.run)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 786, in run\n", + " yielded = self.gen.send(value)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 361, in process_one\n", + " yield gen.maybe_future(dispatch(*args))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 261, in dispatch_shell\n", + " yield gen.maybe_future(handler(stream, idents, msg))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 539, in execute_request\n", + " self.do_execute(\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py\", line 302, in do_execute\n", + " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/zmqshell.py\", line 539, in run_cell\n", + " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n", + " result = self._run_cell(\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n", + " return runner(coro)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n", + " if (await self.run_code(code, result, async_=asy)):\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"\", line 2, in \n", + " import pyufunc as pf\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/__init__.py\", line 21, in \n", + " from .util_img import * # image functions # noqa: F403\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/__init__.py\", line 8, in \n", + " from ._img_cvt import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_cvt.py\", line 21, in \n", + " from ._img_operate import img_CV_to_PIL, img_PIL_to_CV\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_operate.py\", line 355, in \n", + " def img_resize(img: Union[np.ndarray, str, Image.Image],\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in inner\n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in \n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_import_package.py\", line 236, in is_module_importable\n", + " exec(f\"import {module_name}\")\n", + " File \"\", line 1, in \n", + " File \"/usr/local/lib/python3.10/dist-packages/google/colab/_import_hooks/_cv2.py\", line 78, in load_module\n", + " cv_module = imp.load_module(name, *module_info)\n", + " File \"/usr/lib/python3.10/imp.py\", line 243, in load_module\n", + " return load_dynamic(name, filename, file)\n", + " File \"/usr/lib/python3.10/imp.py\", line 343, in load_dynamic\n", + " return _load(spec)\n" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "_ARRAY_API not found", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: _ARRAY_API not found" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n", + "A module that was compiled using NumPy 1.x cannot be run in\n", + "NumPy 2.0.0 as it may crash. To support both 1.x and 2.x\n", + "versions of NumPy, modules must be compiled with NumPy 2.0.\n", + "Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.\n", + "\n", + "If you are a user of the module, the easiest solution will be to\n", + "downgrade to 'numpy<2' or try to upgrade the affected module.\n", + "We expect that some modules will need time to support NumPy 2.\n", + "\n", + "Traceback (most recent call last): File \"/usr/lib/python3.10/runpy.py\", line 196, in _run_module_as_main\n", + " return _run_code(code, main_globals, None,\n", + " File \"/usr/lib/python3.10/runpy.py\", line 86, in _run_code\n", + " exec(code, run_globals)\n", + " File \"/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py\", line 37, in \n", + " ColabKernelApp.launch_instance()\n", + " File \"/usr/local/lib/python3.10/dist-packages/traitlets/config/application.py\", line 992, in launch_instance\n", + " app.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelapp.py\", line 619, in start\n", + " self.io_loop.start()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/platform/asyncio.py\", line 195, in start\n", + " self.asyncio_loop.run_forever()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 603, in run_forever\n", + " self._run_once()\n", + " File \"/usr/lib/python3.10/asyncio/base_events.py\", line 1909, in _run_once\n", + " handle._run()\n", + " File \"/usr/lib/python3.10/asyncio/events.py\", line 80, in _run\n", + " self._context.run(self._callback, *self._args)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 685, in \n", + " lambda f: self._run_callback(functools.partial(callback, future))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/ioloop.py\", line 738, in _run_callback\n", + " ret = callback()\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 825, in inner\n", + " self.ctx_run(self.run)\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 786, in run\n", + " yielded = self.gen.send(value)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 361, in process_one\n", + " yield gen.maybe_future(dispatch(*args))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 261, in dispatch_shell\n", + " yield gen.maybe_future(handler(stream, idents, msg))\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/kernelbase.py\", line 539, in execute_request\n", + " self.do_execute(\n", + " File \"/usr/local/lib/python3.10/dist-packages/tornado/gen.py\", line 234, in wrapper\n", + " yielded = ctx_run(next, result)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py\", line 302, in do_execute\n", + " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", + " File \"/usr/local/lib/python3.10/dist-packages/ipykernel/zmqshell.py\", line 539, in run_cell\n", + " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 2975, in run_cell\n", + " result = self._run_cell(\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3030, in _run_cell\n", + " return runner(coro)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/async_helpers.py\", line 78, in _pseudo_sync_runner\n", + " coro.send(None)\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3257, in run_cell_async\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3473, in run_ast_nodes\n", + " if (await self.run_code(code, result, async_=asy)):\n", + " File \"/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\", line 3553, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"\", line 2, in \n", + " import pyufunc as pf\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/__init__.py\", line 21, in \n", + " from .util_img import * # image functions # noqa: F403\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/__init__.py\", line 8, in \n", + " from ._img_cvt import (\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_cvt.py\", line 21, in \n", + " from ._img_operate import img_CV_to_PIL, img_PIL_to_CV\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_img/_img_operate.py\", line 436, in \n", + " def img_show(img: Union[str, np.ndarray, Image.Image],\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in inner\n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_dependency_requires_decorator.py\", line 107, in \n", + " available = [is_module_importable(arg) for arg in arg_import_name]\n", + " File \"/usr/local/lib/python3.10/dist-packages/pyufunc/util_common/_import_package.py\", line 236, in is_module_importable\n", + " exec(f\"import {module_name}\")\n", + " File \"\", line 1, in \n", + " File \"/usr/local/lib/python3.10/dist-packages/google/colab/_import_hooks/_cv2.py\", line 78, in load_module\n", + " cv_module = imp.load_module(name, *module_info)\n", + " File \"/usr/lib/python3.10/imp.py\", line 243, in load_module\n", + " return load_dynamic(name, filename, file)\n", + " File \"/usr/lib/python3.10/imp.py\", line 343, in load_dynamic\n", + " return _load(spec)\n" + ] + }, + { + "output_type": "error", + "ename": "AttributeError", + "evalue": "_ARRAY_API not found", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mAttributeError\u001b[0m: _ARRAY_API not found" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloaded to: .//datasets/ASU/TAZ.csv\n", + "Downloaded to: .//datasets/ASU/accessibility.csv\n", + "Downloaded to: .//datasets/ASU/asu_parcels.csv\n", + "Downloaded to: .//datasets/ASU/asu_parcels.qmd\n", + "Downloaded to: .//datasets/ASU/connector.csv\n", + "Downloaded to: .//datasets/ASU/demand.csv\n", + "Downloaded to: .//datasets/ASU/demand_B3.csv\n", + "Downloaded to: .//datasets/ASU/ggis_GMNS.qgz\n", + "Downloaded to: .//datasets/ASU/input_agent.csv\n", + "Downloaded to: .//datasets/ASU/link.csv\n", + "Downloaded to: .//datasets/ASU/map.osm\n", + "Downloaded to: .//datasets/ASU/node.csv\n", + "Downloaded to: .//datasets/ASU/poi.csv\n", + "Downloaded to: .//datasets/ASU/poi_trip_rate.csv\n", + "Downloaded to: .//datasets/ASU/sample_GMNS_dataset.zip\n", + "Downloaded to: .//datasets/ASU/zone.csv\n", + "Downloaded to: .//datasets/Avondale_AZ/Avondale.osm\n", + "Downloaded to: .//datasets/Avondale_AZ/link.csv\n", + "Downloaded to: .//datasets/Avondale_AZ/node.csv\n", + "Downloaded to: .//datasets/Avondale_AZ/poi.csv\n", + "Downloaded to: .//datasets/BayArea/node.csv\n", + "Downloaded to: .//datasets/BayArea/poi.csv\n", + "Downloaded to: .//datasets/Chicago_Sketch/demand.csv\n", + "Downloaded to: .//datasets/Chicago_Sketch/link.csv\n", + "Downloaded to: .//datasets/Chicago_Sketch/node.csv\n", + "Downloaded to: .//datasets/Chicago_Sketch/settings.csv\n", + "Downloaded to: .//datasets/Chicago_Sketch/settings.yml\n", + "Downloaded to: .//datasets/DC_Downtown/DC.osm\n", + "Downloaded to: .//datasets/DC_Downtown/accessibility.csv\n", + "Downloaded to: .//datasets/DC_Downtown/demand.csv\n", + "Downloaded to: .//datasets/DC_Downtown/link.csv\n", + "Downloaded to: .//datasets/DC_Downtown/node.csv\n", + "Downloaded to: .//datasets/DC_Downtown/poi.csv\n", + "Downloaded to: .//datasets/DC_Downtown/poi_trip_rate.csv\n", + "Downloaded to: .//datasets/DC_Downtown/zone.csv\n", + "Downloaded to: .//datasets/Lima_Network/demand.csv\n", + "Downloaded to: .//datasets/Lima_Network/link.csv\n", + "Downloaded to: .//datasets/Lima_Network/node.csv\n", + "Downloaded to: .//datasets/Lima_Network/settings.csv\n", + "Downloaded to: .//datasets/Lima_Network/settings.yml\n", + "Downloaded to: .//datasets/NationalArboretum/accessibility.csv\n", + "Downloaded to: .//datasets/NationalArboretum/demand.csv\n", + "Downloaded to: .//datasets/NationalArboretum/link.csv\n", + "Downloaded to: .//datasets/NationalArboretum/map\n", + "Downloaded to: .//datasets/NationalArboretum/node.csv\n", + "Downloaded to: .//datasets/NationalArboretum/poi.csv\n", + "Downloaded to: .//datasets/NationalArboretum/poi_trip_rate.csv\n", + "Downloaded to: .//datasets/NationalArboretum/zone.csv\n", + "Downloaded to: .//datasets/Tuscon_zone/demand.csv\n", + "Downloaded to: .//datasets/Tuscon_zone/line_performance_summary.geojson\n", + "Downloaded to: .//datasets/Tuscon_zone/line_performance_summary.qmd\n", + "Downloaded to: .//datasets/Tuscon_zone/link.csv\n", + "Downloaded to: .//datasets/Tuscon_zone/link.geojson\n", + "Downloaded to: .//datasets/Tuscon_zone/link.qmd\n", + "Downloaded to: .//datasets/Tuscon_zone/link_performance_summary.csv\n", + "Downloaded to: .//datasets/Tuscon_zone/node.csv\n", + "Downloaded to: .//datasets/Tuscon_zone/node_synced.csv\n", + "Downloaded to: .//datasets/Tuscon_zone/poi.csv\n", + "Downloaded to: .//datasets/Tuscon_zone/poi_synced.csv\n", + "Downloaded to: .//datasets/Tuscon_zone/zone.csv\n", + "Downloaded to: .//datasets/Tuscon_zone/zone_synced.csv\n", + "Downloaded to: .//datasets/UMD/UMD.osm\n", + "Downloaded to: .//datasets/UMD/accessibility.csv\n", + "Downloaded to: .//datasets/UMD/demand.csv\n", + "Downloaded to: .//datasets/UMD/link.csv\n", + "Downloaded to: .//datasets/UMD/node.csv\n", + "Downloaded to: .//datasets/UMD/poi.csv\n", + "Downloaded to: .//datasets/UMD/poi_trip_rate.csv\n", + "Downloaded to: .//datasets/UMD/zone.csv\n", + "Downloaded to: .//datasets/dubai/demand.csv\n", + "Downloaded to: .//datasets/dubai/node.csv\n", + "Downloaded to: .//datasets/dubai/poi.csv\n", + "Downloaded to: .//datasets/dubai/zone.csv\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "73" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qrchDA-R0WN0" + }, + "source": [ + "**Step 2: convert OSM to GMNS Files**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KBLRJxWHpvmG" + }, + "source": [ + "go to the local folder in cloud computing environment" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zTi7DW3Zp3T0", + "outputId": "2ae21327-024c-4565-c9b8-4943653db2ed" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content\n" + ] + } + ], + "source": [ + "!pwd" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wTopPq99pubn", + "outputId": "bc3678be-c8c8-4d4c-fdb9-4b619a0bee9b" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content/datasets/ASU\n" + ] + } + ], + "source": [ + "%cd datasets/ASU" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "3UL0MUnaHAD5", + "outputId": "613f940b-5c27-418d-b209-8ddf60f67163", + "collapsed": true + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "osm2gmns, 0.7.6\n", + "arguments used for network parsing:\n", + " filename: map.osm\n", + " network_types: ('auto',)\n", + " link_types: all\n", + " POI: True\n", + " POI_sampling_ratio: 0.1\n", + " strict_mode: True\n", + " offset: no\n", + " min_nodes: 1\n", + " combine: False\n", + " bbox: None\n", + " default_lanes: False\n", + " default_speed: False\n", + " default_capacity: False\n", + " start_node_id: 0\n", + " start_link_id: 0\n", + "\n", + "Building Network from OSM file\n", + " reading osm file\n", + " parsing osm network\n", + " generating nodes and links\n", + " generating POIs\n", + " number of nodes: 823, number of links: 1614, number of pois: 125\n", + "Generating Node Activity Information\n", + "Consolidating Complex Intersections\n", + " 0 intersections have been consolidated\n", + "Outputting Network Files\n", + "Outputting Network Files\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Figure is saved to network.jpg\n" + ] + } + ], + "source": [ + "import osm2gmns as og\n", + "net = og.getNetFromFile('map.osm', POI = True, POI_sampling_ratio = 0.1 )\n", + "og.connectPOIWithNet(net)\n", + "og.generateNodeActivityInfo(net)\n", + "og.consolidateComplexIntersections(net)\n", + "og.outputNetToCSV(net, output_folder='consolidated')\n", + "og.show(net)\n", + "og.saveFig(net)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SENYsUzC03bx" + }, + "source": [ + "Check node.csv, link.csv and poi.csv exist in the left-hand-side Colab folder." + ] + }, + { + "cell_type": "code", + "source": [ + "!pwd" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0gLfN_1IruYq", + "outputId": "19fa08d7-aed1-4cf2-982c-0e33a3fd2765" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content/datasets/ASU\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_vLsOkgJ0vuZ" + }, + "source": [ + "**Step 3: Run grid2demand to generate demand based POI rates**" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EbIz8pgPJgsn", + "outputId": "8ed3ed1e-234e-42f8-fc5c-33f503e86b3a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "grid2demand, version 0.4.7, supports Python 3.10 or higher\n", + " :INFO: finished function: read_node, total: 0s \n", + "\n", + " :INFO: finished function: read_poi, total: 0s \n", + "\n", + " : Generating zone dictionary...\n", + " :INFO: finished function: net2zone, total: 0s \n", + "\n", + " : Synchronizing zone with node...\n", + "\n", + " :INFO: finished function: sync_zone_geometry_and_node, total: 0s \n", + "\n", + " : Synchronizing zone with poi...\n", + "\n", + " :INFO: finished function: sync_zone_geometry_and_poi, total: 0s \n", + "\n", + " No trip rate file provided, use default trip rate.\n", + " : Successfully generated poi trip rate with default setting.\n", + " :INFO: finished function: calc_zone_od_matrix, total: 0s \n", + "\n", + " : Successfully generated OD demands.\n", + " : Successfully saved demand.csv to /content/datasets/ASU/consolidated\n", + " : Successfully saved zone.csv to /content/datasets/ASU/consolidated\n", + " : Successfully saved updated node to node.csv to /content/datasets/ASU/consolidated\n", + " : Successfully saved updated poi to poi.csv to /content/datasets/ASU/consolidated\n" + ] + } + ], + "source": [ + "import grid2demand as gd\n", + "\n", + "\"Step 1: Read Input Network Data\"\n", + "\n", + "input_path = \"consolidated\"\n", + "net = gd.GRID2DEMAND(input_dir=input_path)\n", + "net.load_network()\n", + "\n", + "\"Step 2: Partition Grid into cells\"\n", + "zone = net.net2zone(num_x_blocks=5, num_y_blocks=5)\n", + "# user can customize number of grid cells or cell's width and height\n", + "# zone = net.net2zone(cell_width=10, cell_height=10, unit=\"km\")\n", + "net.sync_geometry_between_zone_and_node_poi()\n", + "\n", + "\"Step 3: Get Production/Attraction Rates of Each Land Use Type with a Specific Trip Purpose\"\n", + "net.gen_poi_trip_rate(trip_rate_file=\"\", trip_purpose=1)\n", + "# user can customize poi_trip_rate.csv and trip purpose\n", + "\n", + "\"Step 4: Define Production/Attraction Value of Each Node According to POI Type\"\n", + "net.gen_node_prod_attr()\n", + "\n", + "\"Step 5: Calculate Zone-to-zone Accessibility Matrix by Centroid-to-centroid Straight Distance\"\n", + "net.calc_zone_od_distance_matrix()\n", + "\n", + "\"Step 6: Apply Gravity Model to Conduct Trip Distribution\"\n", + "net.run_gravity_model()\n", + "# user can customize friction factor coefficients under a specific trip purpose\n", + "\"Step 7: Generate Agent\"\n", + "net.gen_agent_based_demand()\n", + "\n", + "# save results to foler\n", + "net.save_results_to_csv(output_dir=input_path, zone=True, node=True, poi=True, overwrite_file=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gfLuLzVs4SJS" + }, + "source": [ + "**Step 4: Download data files**\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gRYOkJyT4juC", + "outputId": "112a2713-1182-4062-9972-97cbcb8e5fec" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content/datasets\n", + " adding: content/datasets/ASU/consolidated/ (stored 0%)\n", + " adding: content/datasets/ASU/consolidated/link.csv (deflated 81%)\n", + " adding: content/datasets/ASU/consolidated/demand.csv (deflated 82%)\n", + " adding: content/datasets/ASU/consolidated/poi.csv (deflated 81%)\n", + " adding: content/datasets/ASU/consolidated/zone.csv (deflated 83%)\n", + " adding: content/datasets/ASU/consolidated/node.csv (deflated 79%)\n" + ] + } + ], + "source": [ + "%cd ../\n", + "!zip -r /content/datasets/ASU/map.zip /content/datasets/ASU/consolidated/\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "id": "mDf0i_KS7dIH", + "outputId": "f9b77faf-c2b3-4982-b3a8-0d3b29a7c6d1" + }, + "outputs": [ + { + "data": { + "application/javascript": "\n async function download(id, filename, size) {\n if (!google.colab.kernel.accessAllowed) {\n return;\n }\n const div = document.createElement('div');\n const label = document.createElement('label');\n label.textContent = `Downloading \"${filename}\": `;\n div.appendChild(label);\n const progress = document.createElement('progress');\n progress.max = size;\n div.appendChild(progress);\n document.body.appendChild(div);\n\n const buffers = [];\n let downloaded = 0;\n\n const channel = await google.colab.kernel.comms.open(id);\n // Send a message to notify the kernel that we're ready.\n channel.send({})\n\n for await (const message of channel.messages) {\n // Send a message to notify the kernel that we're ready.\n channel.send({})\n if (message.buffers) {\n for (const buffer of message.buffers) {\n buffers.push(buffer);\n downloaded += buffer.byteLength;\n progress.value = downloaded;\n }\n }\n }\n const blob = new Blob(buffers, {type: 'application/binary'});\n const a = document.createElement('a');\n a.href = window.URL.createObjectURL(blob);\n a.download = filename;\n div.appendChild(a);\n a.click();\n div.remove();\n }\n ", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "download(\"download_b04483f1-1960-4c94-9ab3-7214694ceda7\", \"map.zip\", 325810681)", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from google.colab import files\n", + "files.download(\"/content/datasets/ASU/map.zip\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b6pyZEum8Ood" + }, + "source": [ + "**Step 5: Visualization using GMNS tool:**\n", + "By simply uploading node.csv and link.csv at https://asu-trans-ai-lab.github.io/index.html#, \n", + " you can easily create custom online maps for any GMNS network files.\n", + "To view zone and demand information please visit this page to use QGIS/NeXTA tools. https://github.com/asu-trans-ai-lab/traffic-engineering-and-analysis/blob/master/undergraduate_student_project/QGIS%20For%20Gmns%20User%20Guide_v0.5.pdf" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "grPzsCuq9rcq" + }, + "source": [ + "**Option for downloading OSM map.osm file for the area of interest**\n", + "\n", + "On OpenStreetMap homepage, click the Export button to enter Export mode. Before downloading, you may need to span and zoom in/out the map to make sure that your target area is properly shown on the screen. Or, you can use Manually select a different area to select your area more precisely. Click the Export button in blue to export the network you want.\n", + "\n", + "Note that if the target area is too large, you may get an error message: “You requested too many nodes (limit is 50000). Either request a smaller area, or use planet.osm”. In this case, you can always click Overpass API to download the network you need via a mirror site.\n", + "\n", + "You can uploda the file as shown below to Google Colab environment and repeat from step 2 of running OSM2GMNS to step 5\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "A3wSE0zi9u5L" + }, + "outputs": [], + "source": [ + "from google.colab import files\n", + "uploaded = files.upload()\n", + "\n", + "for fn in uploaded.keys():\n", + " print('User uploaded file \"{name}\" with length {length} bytes'.format(\n", + " name=fn, length=len(uploaded[fn])))\n", + "\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file