Add files using upload-large-folder tool

.cache/pip/http-v2/5/1/f/2/8/51f28abf47f08a699c067b6b49e9b61d7ffb241813480943666c7bcf.body

@@ -0,0 +1,87 @@
+Metadata-Version: 2.1
+Name: pyarrow
+Version: 17.0.0
+Summary: Python library for Apache Arrow
+Maintainer-email: Apache Arrow Developers <[email protected]>
+License: Apache Software License
+Project-URL: Homepage, https://arrow.apache.org/
+Project-URL: Documentation, https://arrow.apache.org/docs/python
+Project-URL: Repository, https://github.com/apache/arrow
+Project-URL: Issues, https://github.com/apache/arrow/issues
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: ../LICENSE.txt
+License-File: ../NOTICE.txt
+Requires-Dist: numpy >=1.16.6
+Provides-Extra: test
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: hypothesis ; extra == 'test'
+Requires-Dist: cffi ; extra == 'test'
+Requires-Dist: pytz ; extra == 'test'
+Requires-Dist: pandas ; extra == 'test'
+
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+## Python library for Apache Arrow
+
+[![pypi](https://img.shields.io/pypi/v/pyarrow.svg)](https://pypi.org/project/pyarrow/) [![conda-forge](https://img.shields.io/conda/vn/conda-forge/pyarrow.svg)](https://anaconda.org/conda-forge/pyarrow)
+
+This library provides a Python API for functionality provided by the Arrow C++
+libraries, along with tools for Arrow integration and interoperability with
+pandas, NumPy, and other software in the Python ecosystem.
+
+## Installing
+
+Across platforms, you can install a recent version of pyarrow with the conda
+package manager:
+
+```shell
+conda install pyarrow -c conda-forge
+```
+
+On Linux, macOS, and Windows, you can also install binary wheels from PyPI with
+pip:
+
+```shell
+pip install pyarrow
+```
+
+If you encounter any issues importing the pip wheels on Windows, you may need
+to install the [Visual C++ Redistributable for Visual Studio 2015][6].
+
+## Development
+
+See [Python Development][2] in the documentation subproject.
+
+### Building the documentation
+
+See [documentation build instructions][1] in the documentation subproject.
+
+[1]: https://github.com/apache/arrow/blob/main/docs/source/developers/documentation.rst
+[2]: https://github.com/apache/arrow/blob/main/docs/source/developers/python.rst
+[3]: https://github.com/pandas-dev/pandas
+[5]: https://arrow.apache.org/docs/latest/python/benchmarks.html
+[6]: https://www.microsoft.com/en-us/download/details.aspx?id=48145

.cache/pip/http-v2/5/a/2/6/c/5a26cc45879e115d5aabd5f6ef627d6747bf3160bca5548379570c58.body

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: smmap
+Version: 5.0.1
+Summary: A pure Python implementation of a sliding window memory map manager
+Home-page: https://github.com/gitpython-developers/smmap
+Author: Sebastian Thiel
+Author-email: [email protected]
+License: BSD
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+## Motivation
+
+When reading from many possibly large files in a fashion similar to random access, it is usually the fastest and most efficient to use memory maps.
+
+Although memory maps have many advantages, they represent a very limited system resource as every map uses one file descriptor, whose amount is limited per process. On 32 bit systems, the amount of memory you can have mapped at a time is naturally limited to theoretical 4GB of memory, which may not be enough for some applications.
+
+
+## Limitations
+
+* **System resources (file-handles) are likely to be leaked!** This is due to the library authors reliance on a deterministic `__del__()` destructor.
+* The memory access is read-only by design.
+
+
+## Overview
+
+![Python package](https://github.com/gitpython-developers/smmap/workflows/Python%20package/badge.svg)
+
+Smmap wraps an interface around mmap and tracks the mapped files as well as the amount of clients who use it. If the system runs out of resources, or if a memory limit is reached, it will automatically unload unused maps to allow continued operation.
+
+To allow processing large files even on 32 bit systems, it allows only portions of the file to be mapped. Once the user reads beyond the mapped region, smmap will automatically map the next required region, unloading unused regions using a LRU algorithm.
+
+Although the library can be used most efficiently with its native interface, a Buffer implementation is provided to hide these details behind a simple string-like interface.
+
+For performance critical 64 bit applications, a simplified version of memory mapping is provided which always maps the whole file, but still provides the benefit of unloading unused mappings on demand.
+
+
+
+## Prerequisites
+
+* Python 3.7+
+* OSX, Windows or Linux
+
+The package was tested on all of the previously mentioned configurations.
+
+## Installing smmap
+
+[![Documentation Status](https://readthedocs.org/projects/smmap/badge/?version=latest)](https://readthedocs.org/projects/smmap/?badge=latest)
+
+Its easiest to install smmap using the [pip](http://www.pip-installer.org/en/latest) program:
+
+```bash
+$ pip install smmap
+```
+
+As the command will install smmap in your respective python distribution, you will most likely need root permissions to authorize the required changes.
+
+If you have downloaded the source archive, the package can be installed by running the `setup.py` script:
+
+```bash
+$ python setup.py install
+```
+
+It is advised to have a look at the **Usage Guide** for a brief introduction on the different database implementations.
+
+
+
+## Homepage and Links
+
+The project is home on github at https://github.com/gitpython-developers/smmap .
+
+The latest source can be cloned from github as well:
+
+* git://github.com/gitpython-developers/smmap.git
+
+
+For support, please use the git-python mailing list:
+
+* http://groups.google.com/group/git-python
+
+
+Issues can be filed on github:
+
+* https://github.com/gitpython-developers/smmap/issues
+
+A link to the pypi page related to this repository:
+
+* https://pypi.org/project/smmap/
+
+
+## License Information
+
+*smmap* is licensed under the New BSD License.
+

.cache/pip/http-v2/8/9/2/3/0/89230ee5375192cd78aff8dee73d946e2bcfcfb4c3ec4374132fe597.body

@@ -0,0 +1,122 @@
+Metadata-Version: 2.1
+Name: aiohappyeyeballs
+Version: 2.4.0
+Summary: Happy Eyeballs for asyncio
+Home-page: https://github.com/aio-libs/aiohappyeyeballs
+License: Python-2.0.1
+Author: J. Nick Koston
+Author-email: [email protected]
+Requires-Python: >=3.8
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Python Software Foundation License
+Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Project-URL: Bug Tracker, https://github.com/aio-libs/aiohappyeyeballs/issues
+Project-URL: Changelog, https://github.com/aio-libs/aiohappyeyeballs/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://aiohappyeyeballs.readthedocs.io
+Project-URL: Repository, https://github.com/aio-libs/aiohappyeyeballs
+Description-Content-Type: text/markdown
+
+# aiohappyeyeballs
+
+<p align="center">
+  <a href="https://github.com/aio-libs/aiohappyeyeballs/actions/workflows/ci.yml?query=branch%3Amain">
+    <img src="https://img.shields.io/github/actions/workflow/status/aio-libs/aiohappyeyeballs/ci-cd.yml?branch=main&label=CI&logo=github&style=flat-square" alt="CI Status" >
+  </a>
+  <a href="https://aiohappyeyeballs.readthedocs.io">
+    <img src="https://img.shields.io/readthedocs/aiohappyeyeballs.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
+  </a>
+  <a href="https://codecov.io/gh/aio-libs/aiohappyeyeballs">
+    <img src="https://img.shields.io/codecov/c/github/aio-libs/aiohappyeyeballs.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
+  </a>
+</p>
+<p align="center">
+  <a href="https://python-poetry.org/">
+    <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
+  </a>
+  <a href="https://github.com/ambv/black">
+    <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
+  </a>
+  <a href="https://github.com/pre-commit/pre-commit">
+    <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
+  </a>
+</p>
+<p align="center">
+  <a href="https://pypi.org/project/aiohappyeyeballs/">
+    <img src="https://img.shields.io/pypi/v/aiohappyeyeballs.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/aiohappyeyeballs.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
+  <img src="https://img.shields.io/pypi/l/aiohappyeyeballs.svg?style=flat-square" alt="License">
+</p>
+
+---
+
+**Documentation**: <a href="https://aiohappyeyeballs.readthedocs.io" target="_blank">https://aiohappyeyeballs.readthedocs.io </a>
+
+**Source Code**: <a href="https://github.com/aio-libs/aiohappyeyeballs" target="_blank">https://github.com/aio-libs/aiohappyeyeballs </a>
+
+---
+
+[Happy Eyeballs](https://en.wikipedia.org/wiki/Happy_Eyeballs)
+([RFC 8305](https://www.rfc-editor.org/rfc/rfc8305.html))
+
+## Use case
+
+This library exists to allow connecting with
+[Happy Eyeballs](https://en.wikipedia.org/wiki/Happy_Eyeballs)
+([RFC 8305](https://www.rfc-editor.org/rfc/rfc8305.html))
+when you
+already have a list of addrinfo and not a DNS name.
+
+The stdlib version of `loop.create_connection()`
+will only work when you pass in an unresolved name which
+is not a good fit when using DNS caching or resolving
+names via another method such as `zeroconf`.
+
+## Installation
+
+Install this via pip (or your favourite package manager):
+
+`pip install aiohappyeyeballs`
+
+## Example usage
+
+```python
+
+addr_infos = await loop.getaddrinfo("example.org", 80)
+
+socket = await start_connection(addr_infos)
+socket = await start_connection(addr_infos, local_addr_infos=local_addr_infos, happy_eyeballs_delay=0.2)
+
+transport, protocol = await loop.create_connection(
+    MyProtocol, sock=socket, ...)
+
+# Remove the first address for each family from addr_info
+pop_addr_infos_interleave(addr_info, 1)
+
+# Remove all matching address from addr_info
+remove_addr_infos(addr_info, "dead::beef::")
+
+# Convert a local_addr to local_addr_infos
+local_addr_infos = addr_to_addr_infos(("127.0.0.1",0))
+```
+
+## Credits
+
+This package contains code from cpython and is licensed under the same terms as cpython itself.
+
+This package was created with
+[Copier](https://copier.readthedocs.io/) and the
+[browniebroke/pypackage-template](https://github.com/browniebroke/pypackage-template)
+project template.
+

.cache/pip/http-v2/8/c/3/e/c/8c3ecf585c815a73af16247323d407e99afb8fdc40cee3542187ad49.body

@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: click
+Version: 8.1.7
+Summary: Composable command line interface toolkit
+Home-page: https://palletsprojects.com/p/click/
+Maintainer: Pallets
+Maintainer-email: [email protected]
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://click.palletsprojects.com/
+Project-URL: Changes, https://click.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/click/
+Project-URL: Issue Tracker, https://github.com/pallets/click/issues/
+Project-URL: Chat, https://discord.gg/pallets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+Requires-Dist: colorama ; platform_system == "Windows"
+Requires-Dist: importlib-metadata ; python_version < "3.8"
+
+\$ click\_
+==========
+
+Click is a Python package for creating beautiful command line interfaces
+in a composable way with as little code as necessary. It's the "Command
+Line Interface Creation Kit". It's highly configurable but comes with
+sensible defaults out of the box.
+
+It aims to make the process of writing command line tools quick and fun
+while also preventing any frustration caused by the inability to
+implement an intended CLI API.
+
+Click in three points:
+
+-   Arbitrary nesting of commands
+-   Automatic help page generation
+-   Supports lazy loading of subcommands at runtime
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    $ pip install -U click
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+A Simple Example
+----------------
+
+.. code-block:: python
+
+    import click
+
+    @click.command()
+    @click.option("--count", default=1, help="Number of greetings.")
+    @click.option("--name", prompt="Your name", help="The person to greet.")
+    def hello(count, name):
+        """Simple program that greets NAME for a total of COUNT times."""
+        for _ in range(count):
+            click.echo(f"Hello, {name}!")
+
+    if __name__ == '__main__':
+        hello()
+
+.. code-block:: text
+
+    $ python hello.py --count=3
+    Your name: Click
+    Hello, Click!
+    Hello, Click!
+    Hello, Click!
+
+
+Donate
+------
+
+The Pallets organization develops and supports Click and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, `please
+donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+-   Documentation: https://click.palletsprojects.com/
+-   Changes: https://click.palletsprojects.com/changes/
+-   PyPI Releases: https://pypi.org/project/click/
+-   Source Code: https://github.com/pallets/click
+-   Issue Tracker: https://github.com/pallets/click/issues
+-   Chat: https://discord.gg/pallets

.cache/pip/http-v2/f/4/3/c/e/f43ce2cb74a8c7ad77da70314e043a539a7f01416550c3167312132b.body

@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: async-timeout
+Version: 4.0.3
+Summary: Timeout context manager for asyncio programs
+Home-page: https://github.com/aio-libs/async-timeout
+Author: Andrew Svetlov <[email protected]>
+Author-email: [email protected]
+License: Apache 2
+Project-URL: Chat: Gitter, https://gitter.im/aio-libs/Lobby
+Project-URL: CI: GitHub Actions, https://github.com/aio-libs/async-timeout/actions
+Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/async-timeout
+Project-URL: GitHub: issues, https://github.com/aio-libs/async-timeout/issues
+Project-URL: GitHub: repo, https://github.com/aio-libs/async-timeout
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: typing-extensions >=3.6.5 ; python_version < "3.8"
+
+async-timeout
+=============
+.. image:: https://travis-ci.com/aio-libs/async-timeout.svg?branch=master
+    :target: https://travis-ci.com/aio-libs/async-timeout
+.. image:: https://codecov.io/gh/aio-libs/async-timeout/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/aio-libs/async-timeout
+.. image:: https://img.shields.io/pypi/v/async-timeout.svg
+    :target: https://pypi.python.org/pypi/async-timeout
+.. image:: https://badges.gitter.im/Join%20Chat.svg
+    :target: https://gitter.im/aio-libs/Lobby
+    :alt: Chat on Gitter
+
+asyncio-compatible timeout context manager.
+
+
+Usage example
+-------------
+
+
+The context manager is useful in cases when you want to apply timeout
+logic around block of code or in cases when ``asyncio.wait_for()`` is
+not suitable. Also it's much faster than ``asyncio.wait_for()``
+because ``timeout`` doesn't create a new task.
+
+The ``timeout(delay, *, loop=None)`` call returns a context manager
+that cancels a block on *timeout* expiring::
+
+   from async_timeout import timeout
+   async with timeout(1.5):
+       await inner()
+
+1. If ``inner()`` is executed faster than in ``1.5`` seconds nothing
+   happens.
+2. Otherwise ``inner()`` is cancelled internally by sending
+   ``asyncio.CancelledError`` into but ``asyncio.TimeoutError`` is
+   raised outside of context manager scope.
+
+*timeout* parameter could be ``None`` for skipping timeout functionality.
+
+
+Alternatively, ``timeout_at(when)`` can be used for scheduling
+at the absolute time::
+
+   loop = asyncio.get_event_loop()
+   now = loop.time()
+
+   async with timeout_at(now + 1.5):
+       await inner()
+
+
+Please note: it is not POSIX time but a time with
+undefined starting base, e.g. the time of the system power on.
+
+
+Context manager has ``.expired`` property for check if timeout happens
+exactly in context manager::
+
+   async with timeout(1.5) as cm:
+       await inner()
+   print(cm.expired)
+
+The property is ``True`` if ``inner()`` execution is cancelled by
+timeout context manager.
+
+If ``inner()`` call explicitly raises ``TimeoutError`` ``cm.expired``
+is ``False``.
+
+The scheduled deadline time is available as ``.deadline`` property::
+
+   async with timeout(1.5) as cm:
+       cm.deadline
+
+Not finished yet timeout can be rescheduled by ``shift_by()``
+or ``shift_to()`` methods::
+
+   async with timeout(1.5) as cm:
+       cm.shift(1)  # add another second on waiting
+       cm.update(loop.time() + 5)  # reschedule to now+5 seconds
+
+Rescheduling is forbidden if the timeout is expired or after exit from ``async with``
+code block.
+
+
+Installation
+------------
+
+::
+
+   $ pip install async-timeout
+
+The library is Python 3 only!
+
+
+
+Authors and License
+-------------------
+
+The module is written by Andrew Svetlov.
+
+It's *Apache 2* licensed and freely available.

.cache/pip/http-v2/f/b/e/3/a/fbe3a5eb3735a745707ab3bf39e17d76ea29c7cd1eaa7763f11e1766.body

@@ -0,0 +1,128 @@
+Metadata-Version: 2.1
+Name: aiosignal
+Version: 1.3.1
+Summary: aiosignal: a list of registered asynchronous callbacks
+Home-page: https://github.com/aio-libs/aiosignal
+Maintainer: aiohttp team <[email protected]>
+Maintainer-email: [email protected]
+License: Apache 2.0
+Project-URL: Chat: Gitter, https://gitter.im/aio-libs/Lobby
+Project-URL: CI: GitHub Actions, https://github.com/aio-libs/aiosignal/actions
+Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/aiosignal
+Project-URL: Docs: RTD, https://docs.aiosignal.org
+Project-URL: GitHub: issues, https://github.com/aio-libs/aiosignal/issues
+Project-URL: GitHub: repo, https://github.com/aio-libs/aiosignal
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: frozenlist (>=1.1.0)
+
+=========
+aiosignal
+=========
+
+.. image:: https://github.com/aio-libs/aiosignal/workflows/CI/badge.svg
+   :target: https://github.com/aio-libs/aiosignal/actions?query=workflow%3ACI
+   :alt: GitHub status for master branch
+
+.. image:: https://codecov.io/gh/aio-libs/aiosignal/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/aio-libs/aiosignal
+   :alt: codecov.io status for master branch
+
+.. image:: https://badge.fury.io/py/aiosignal.svg
+   :target: https://pypi.org/project/aiosignal
+   :alt: Latest PyPI package version
+
+.. image:: https://readthedocs.org/projects/aiosignal/badge/?version=latest
+   :target: https://aiosignal.readthedocs.io/
+   :alt: Latest Read The Docs
+
+.. image:: https://img.shields.io/discourse/topics?server=https%3A%2F%2Faio-libs.discourse.group%2F
+   :target: https://aio-libs.discourse.group/
+   :alt: Discourse group for io-libs
+
+.. image:: https://badges.gitter.im/Join%20Chat.svg
+   :target: https://gitter.im/aio-libs/Lobby
+   :alt: Chat on Gitter
+
+Introduction
+============
+
+A project to manage callbacks in `asyncio` projects.
+
+``Signal`` is a list of registered asynchronous callbacks.
+
+The signal's life-cycle has two stages: after creation its content
+could be filled by using standard list operations: ``sig.append()``
+etc.
+
+After you call ``sig.freeze()`` the signal is *frozen*: adding, removing
+and dropping callbacks is forbidden.
+
+The only available operation is calling the previously registered
+callbacks by using ``await sig.send(data)``.
+
+For concrete usage examples see the `Signals
+<https://docs.aiohttp.org/en/stable/web_advanced.html#aiohttp-web-signals>
+section of the `Web Server Advanced
+<https://docs.aiohttp.org/en/stable/web_advanced.html>` chapter of the `aiohttp
+documentation`_.
+
+
+Installation
+------------
+
+::
+
+   $ pip install aiosignal
+
+The library requires Python 3.6 or newer.
+
+
+Documentation
+=============
+
+https://aiosignal.readthedocs.io/
+
+Communication channels
+======================
+
+*gitter chat* https://gitter.im/aio-libs/Lobby
+
+Requirements
+============
+
+- Python >= 3.6
+- frozenlist >= 1.0.0
+
+License
+=======
+
+``aiosignal`` is offered under the Apache 2 license.
+
+Source code
+===========
+
+The project is hosted on GitHub_
+
+Please file an issue in the `bug tracker
+<https://github.com/aio-libs/aiosignal/issues>`_ if you have found a bug
+or have some suggestions to improve the library.
+
+.. _GitHub: https://github.com/aio-libs/aiosignal
+.. _aiohttp documentation: https://docs.aiohttp.org/

.cache/pip/wheels/7e/e3/c3/89c7a2f3c4adc07cd1c675f8bb7b9ad4d18f64a72bccdfe826/origin.json

@@ -0,0 +1 @@
+{"archive_info": {"hash": "sha256=5bfae9500ad8e7d2937ebccb4906f3bc464d1bf66eedd0e4adabd520811c7b52", "hashes": {"sha256": "5bfae9500ad8e7d2937ebccb4906f3bc464d1bf66eedd0e4adabd520811c7b52"}}, "url": "https://files.pythonhosted.org/packages/cd/1e/21321670cd3c2f225026d9fd89272cae661529238850e79f48ccf2f9e4e3/flash_attn-2.6.3.tar.gz"}

.cache/wandb/logs/core-debug-20240926_180107.log

@@ -0,0 +1,9 @@
+{"time":"2024-09-26T18:01:07.637065841Z","level":"INFO","msg":"started logging, with flags","port-filename":"/tmp/tmpn3byfp8o/port-5326.txt","pid":5326,"debug":false,"disable-analytics":false}
+{"time":"2024-09-26T18:01:07.637109316Z","level":"INFO","msg":"FeatureState","shutdownOnParentExitEnabled":false}
+{"time":"2024-09-26T18:01:07.637939058Z","level":"INFO","msg":"Will exit if parent process dies.","ppid":5326}
+{"time":"2024-09-26T18:01:07.637918908Z","level":"INFO","msg":"server is running","addr":{"IP":"127.0.0.1","Port":38193,"Zone":""}}
+{"time":"2024-09-26T18:01:07.833948201Z","level":"INFO","msg":"created new connection","id":"127.0.0.1:53288"}
+{"time":"2024-09-26T18:01:08.272107166Z","level":"INFO","msg":"connection init received","streamId":"qqp17sde","id":"127.0.0.1:53288"}
+{"time":"2024-09-26T18:01:08.272615297Z","level":"ERROR","msg":"error creating symlink","error":"symlink /root/.cache/wandb/logs/core-debug-20240926_180107.log /root/wandb/run-20240926_180108-qqp17sde/logs/debug-core.log: file exists"}
+{"time":"2024-09-26T18:01:08.275500036Z","level":"INFO","msg":"connection init completed","streamId":"qqp17sde","id":"127.0.0.1:53288"}
+{"time":"2024-09-26T18:06:51.692081081Z","level":"INFO","msg":"Parent process exited, terminating service process."}

.jupyter/migrated

@@ -0,0 +1 @@
+2024-09-25T18:27:22.795502+00:00

.jupyter/nbconfig/notebook.json

@@ -0,0 +1,7 @@
+{
+  "load_extensions": {
+    "nbextensions_configurator/config_menu/main": true,
+    "contrib_nbextensions_help_item/main": true,
+    "jupyter-js-widgets/extension": true
+  }
+}

.jupyter/nbconfig/tree.json

@@ -0,0 +1,6 @@
+{
+  "load_extensions": {
+    "nbextensions_configurator/tree_tab/main": true,
+    "nbzip/tree": true
+  }
+}

.local/share/jupyter/nbextensions/addbefore/readme.md

@@ -0,0 +1,12 @@
+Addbefore
+=========
+
+This extension adds a button to add a empty cell before the currently active cell.
+As was present in IPython 1.0.
+It is with a circled up arrow.
+The plus signed "Add Cell After button" is moved to be next to Add Cell Before,
+and given matching circled down arrow icon.
+
+The functionality of the buttons are as per in the Insert Menu,
+for Insert Cell Above, and Insert Cell Below.
+A empty cell is added, and it takes the cursor focus.

.local/share/jupyter/nbextensions/autosavetime/README.md

@@ -0,0 +1,20 @@
+autosavetime
+============
+
+
+Description
+-----------
+
+Optionally set the notebook autosave interval, and/or add a selector to the
+toolbar to set it.
+
+
+Parameters
+----------
+
+* `autosavetime_set_starting_interval` -
+  Set an autosave interval on notebook load. If false, the default is unchanged.
+* `autosavetime_starting_interval` -
+  Autosave interval (in minutes) which would be set on notebook load.
+* `autosavetime_show_selector` -
+  Add a selector to the toolbar to change the autosave interval

.local/share/jupyter/nbextensions/autosavetime/autosavetime.yaml

@@ -0,0 +1,22 @@
+Type: IPython Notebook Extension
+Compatibility: 3.x, 4.x, 5.x
+Name: AutoSaveTime
+Main: main.js
+Icon: icon.png
+Link: README.md
+Description: Optionally set the notebook autosave interval, and/or add a selector to the toolbar to set it
+Parameters:
+- name: autosavetime_set_starting_interval
+  description: Set an autosave interval on notebook load. If false, the default is unchanged.
+  input_type: checkbox
+  default: false
+- name: autosavetime_starting_interval
+  description: Autosave interval (in minutes) which would be set on notebook load.
+  input_type: number
+  min: 0
+  step: 1
+  default: 2
+- name: autosavetime_show_selector
+  description: add a selector to the toolbar to change the autosave interval
+  input_type: checkbox
+  default: true

.local/share/jupyter/nbextensions/cell_filter/cell_filter.yml

@@ -0,0 +1,7 @@
+Type: Jupyter Notebook Extension
+Compatibility: 4.x, 5.x
+Name: Cell Filter
+Main: cell_filter.js
+Link: README.md
+Description: |
+  An extension that allows you to filter cells by tags. Keywords entered into the search bar separated by spaces joins them with logical AND.

.local/share/jupyter/nbextensions/code_prettify/README.md

@@ -0,0 +1,302 @@
+KernelExecOnCells library and nbextensions
+==========================================
+
+The KernelExecOnCells library is a shared library for creating Jupyter
+nbextensions which transform code cell text using calls to the active kernel.
+
+This scheme has been applied to create several nbextensions which are also
+included in the repository.
+For instance, to prettify code, see the [code-prettify] nbextension, or to
+refactor python 2 code for python 3, see the [2to3] extension.
+These nbextensions are defined as simple plugins of the main KernelExecOnCells
+library. Defining such a plugin, [jupyter-autopep8], is described in the last section below.
+
+
+Compatible Kernels
+------------------
+
+The library is kernel-language agnostic, as described in the [internals]
+section below. Essentially any kernel capable of interpreting and creating
+json-formatted strings, and sending them to the stream output (where print
+statements in most languages go) should be easy to integrate.
+Hopefully, that covers pretty much all languages!
+
+
+Options
+-------
+
+The library uses a series of options, describing the configuration of the
+plugin. Default values for these options are specified as an object in the
+plugin source file, and can be overriden by values loaded from config.
+There are a few nbextension-wide options, configurable using the
+[jupyter_nbextensions_configurator] or by editing the `notebook` section config
+file directly.
+If `mod_name` is the name of the plugin module (e.g. `code_prettify`, `2to3`,
+...) and `LANG` the lowercased kernel language (eg julia, python, r ...), then
+the options are as follows:
+
+- `mod_name.add_toolbar_button`:
+  Whether to add a toolbar button to transform the selected cell(s).
+  Defaults to `true`.
+
+- `mod_name.button_icon`:
+  A font-awesome class defining the icon used for the toolbar button and
+  actions. See [fontawesome] for available icon classes.
+  Defaults to `fa-legal`.
+
+- `mod_name.button_label`:
+  Toolbar button label text. Also used in the actions' help text.
+  Defaults to `mod_name`.
+
+- `mod_name.register_hotkey`:
+  Whether to register hotkeys to transform the selected cell(s)/whole notebook.
+  Defaults to `true`.
+
+- `mod_name.hotkeys.process_all`:
+  Hotkey to use to transform all the code cells in the notebook.
+  Defaults to `Ctrl-Shift-L`.
+
+- `mod_name.hotkeys.process_selected`:
+  Hotkey to use to transform the selected cell(s).
+  Defaults to `Ctrl-L`.
+
+- `mod_name.show_alerts_for_errors`:
+  Whether to show alerts for errors in the kernel calls.
+  Defaults to `true`.
+
+- `mod_name.kernel_config_map_json`:
+  The value of this key is a string which can be parsed into a json object
+  giving the config for each kernel language.
+
+  The following give the per-kernel options of the parsed json, using the
+  language key `LANG`, to be replaced as appropriate:
+
+  * `mod_name.kernel_config_map_json.LANG.library`:
+  String to execute in the kernel in order to load any necessary kernel
+  libraries.
+
+  * `mod_name.kernel_config_map_json.LANG.replacements_json_to_kernel`:
+    a list of pairs of strings, used as arguments to javascript's
+    `String.replace(from, to)` to translate from a json string into a valid
+    representation of the same string in the kernel language. Since json
+    strings are particularly simple, this can often (as with the python
+    language) be left as the default, an empty list.
+
+  * `mod_name.kernel_config_map_json.LANG.prefix` and
+    `mod_name.kernel_config_map_json.LANG.postfix`:
+    strings added as bookends to the kernel string (translated from the json
+    string using the replacements above) to make up the kernel prettifier call
+    kernel's prettifier libraries.
+
+  * `mod_name.kernel_config_map_json.LANG.trim_formatted_text`:
+    Whether to trim whitespace from the transformed cell text. Since jupyter
+    cells don't usually have leading or trailing whitespace, the default
+    behaviour is to trim the transformed text, in order to prevent the
+    transform adding extra newlines at the end (a common behaviour for source
+    files, where having a trailing newline is often considered good practice).
+
+
+Internals
+---------
+
+The model is essentially:
+
+1.  The cell text is grabbed by client-side javascript, then turned into a json
+    string using javascript `JSON.stringify`. Since json-compatible strings are
+    a particularly simple string format, which is compatible with many other
+    programming languages without much modification (e.g. a valid json string
+    is also a valid string in python 3, and also in python 2 when prefixed with
+    a `u`), and easily converted for use in others (because of its simplicity).
+
+2.  Optional regex replacements are used to translate the json-format string
+    into a valid kernel string. Python, R and javascript don't require this
+    step, but other  languages may do, so it's implemented for flexibility
+    using the per-kernel config key `replacements_json_to_kernel`, which is a
+    list of pairs of arguments to javascript `String.replace`.
+
+3.  The kernel-specific prettifier call is then composed from
+    `kernel_config.prefix` + `kernel_text_string` + `kernel_config.postfix` and
+    sent to the kernel for execution. This kernel call is expected to get the
+    formatted cell text _printed_ as a json-compatible string. Since most
+    kernel languages have json packages, this should hopefully be easy to
+    arrange. The reason for the printing text rather than simply displaying it,
+    is that it prevents us having to translate from a kernel string
+    representing a json string.
+
+4.  The callback for the kernel execution in client-side javascript parses the
+    printed json-format string, optionally trims trailing whitespace according
+    to the `trim_formatted_text` key (which defaults to `true`) in the
+    per-kernel config, and then sets the cell text using the result.
+
+The process is probably best illustrated using an example for the python
+implementation in `code_prettify`:
+
+1.  **At nbextension load**, the `code_prettify.kernel_config_map_json` config
+    option is parsed to give the json object
+
+    ```json
+    {
+      "python": {
+        "library": "import json\nimport yapf.yapflib.yapf_api",
+        "prefix": "print(json.dumps(yapf.yapflib.yapf_api.FormatCode(u",
+        "postfix": ")[0]))"
+      }
+    }
+    ```
+
+    (other kernel languages are omitted for clarity).
+
+2.  **On kernel becoming ready**, the nbextension looks up the config for the
+    kernel's language (in our example, this is the `python` key of the kernel
+    config json object above). It then sends the kernel config's `library`
+    string to the kernel for execution. Thus the python implementation above
+    executes
+
+    ```python
+    import json
+    import yapf.yapflib.yapf_api
+    ```
+
+3.  **On requesting a cell be prettified** which can happen by clicking the
+    toolbar, or with a (configurable) hotkey, the following happens:
+
+    Say the cell to be formatted contains the following ugly python code:
+
+    ```python
+    msg= 'hello '+"world"
+    print  (
+                        msg    )
+    ```
+
+    Then the result of the `JSON.stringify` call will be a string containing
+
+    ```json
+    "msg= 'hello '+\"world\"\nprint  (\n                    msg    )"
+    ```
+
+    (note the opening and closing quotes). Concatenating this with the prefix &
+    postfix strings from the python kernel config above, gives us the kernel
+    code to execute. The call sent to the python kernel is therefore
+
+    ```python
+    print(json.dumps(yapf.yapflib.yapf_api.FormatCode(u"msg= 'hello '+\"world\"\nprint  (\n                    msg    )")[0]))
+    ```
+
+4.  What gets 'printed' by the kernel (i.e. returned to the javascript stream
+    callback) is the following json-format string:
+
+    ```json
+    "msg = 'hello ' + \"world\"\nprint(msg)\n"
+    ```
+
+    The default is to trim whitepace from the returned prettified text, which
+    results in the final prettified python code for the cell:
+
+    ```python
+    msg = 'hello ' + "world"
+    print(msg)
+    ```
+
+
+Defining a new plugin
+---------------------
+
+As an example, we will add a new plugin which reformats code using the
+[autopep8] module in python, rather than the [yapf] library used by
+`code_prettify`. Such a plugin, [jupyter-autopep8] was developed by [@kenkoooo]
+as a fork of an old version of `code_prettify`. Redefining it here has the
+advantage of using the updated and more-robust architecture, in addition to
+making it possible to reformat the whole notebook in one go.
+
+For this new nbextension, we just have to run `import autopep8` as the kernel
+library code, and then call the `autopep8.fix_code` function on cells' text.
+Hence what we have to do is:
+
+- copy `code_prettify.js` to `autopep8.js`
+
+- update `mod_name`, `hotkeys`, `button_icon` default config values in the new
+  `autopep8.js`. Also update the `cfg.kernel_config_map` value to use the
+  correct kernel code:
+  ```javascript
+  cfg.kernel_config_map = { // map of options for supported kernels
+      "python": {
+          "library": "import json\nimport autopep8",
+          "prefix": "print(json.dumps(autopep8.fix_code(u",
+          "postfix": ")))"
+      }
+  };
+  ```
+
+- copy `code_prettify.yaml` to `autopep8.yaml`, and update its values (name,
+  require, readme, plus the new defaults for hotkeys, icon, and
+  kernel_config_map
+
+- that's all :-)
+
+Of course, for this simple case, one could equally have just updated the
+configuration of `code_prettify` using the [jupyter_nbextensions_configurator]
+to use [autopep8] instead of [yapf] to reformat the python code.
+But, if you want two alternative prettifiers available for the same kernel
+language, we need to define separate plugins.
+
+Custom Yapf Styles
+------------------
+
+Using the default `yapf` engine, one may define a custom formatting style according to the [package documentation](https://github.com/google/yapf#formatting-style).
+
+The `code_prettify` extension is configured to follow the default `yapf` ordering (minus the command line option) and will search for the formatting style in the following manner:
+
+> 1. In the [style] section of a .style.yapf file in either the current directory or one of its parent directories.
+> 2. In the [yapf] section of a setup.cfg file in either the current directory or one of its parent directories.
+> 3. In the ~/.config/yapf/style file in your home directory.
+>
+> If none of those files are found, the default style is used (PEP8).
+
+This means that one can set up a globa custom yapf style using `~/.config/yapf/style` or a project-specific one using the project directory.
+
+History
+-------
+
+- [@jfbercher], august 14, 2016, first version, named `yapf_ext`
+- [@jfbercher], august 19, 2016, second version `code_prettify`
+  - introduced support for R and javascript.
+  - changed extension name from `yapf_ext` to `code_prettify`
+- [@jcb91], december 2016
+  - made addition of toolbar button & hotkey configurable
+  - reworked to avoid regex replacements for conversion to/from kernel string
+    formats, in favour of json-string interchange
+  - made kernel-specific prettifier calls configurable, allowing support for
+    different prettifiers & arbitrary kernels
+  - improved documentation
+- [@jfbercher], december 2016-january 2017
+  - added a configurable shortkey to reflow the whole notebook
+  - extracted most of the code to build a general library of functions,
+    `kernel_exec_on_cell.js`, which can be used for all nbextensions which
+    needs to exec some code (via the current kernel) on the text from cells.
+  - added 2to3 as a plugin to the shared library
+- [@jcb91], january 2017
+  - library: Use actions to avoid problems with auto-generated actions
+    generated by keyboard_manager, which were overwriting each other.
+    Also fix toolbar button removal.
+- [@jfbercher], january 2017
+  - updated documentation
+  - added autopep8 nbextension as a plugin using the shared library
+- [@artificialsoph], Jan 2018
+  - updated documentation
+  - changed default behavior to load custom yapf styles
+- [@jfbercher], April 2019
+  - corrected an issue in configs merge
+  - added an option for displaying an alert if kernel is not supported and turned it off by default (instead issue a warning in the js console). 
+
+[2to3]: README_2to3.md
+[@jcb91]: https://github.com/jcb91
+[@jfbercher]: https://github.com/jfbercher
+[@kenkoooo]: https://github.com/kenkoooo
+[autopep8]: https://github.com/hhatto/autopep8
+[code-prettify]: README_code_prettify.md
+[jupyter-autopep8]: README_autopep8.md
+[fontawesome]: https://fontawesome.com/icons
+[internals]: #Internals
+[jupyter-autopep8]: https://github.com/kenkoooo/jupyter-autopep8
+[jupyter_nbextensions_configurator]: https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator
+[yapf]: https://github.com/google/yapf

.local/share/jupyter/nbextensions/codefolding/foldgutter.css

@@ -0,0 +1,5 @@
+.CodeMirror-foldgutter {
+  width: .9em;
+}
+
+

.local/share/jupyter/nbextensions/codefolding/main.js

@@ -0,0 +1,282 @@
+// Allow codefolding in code cells
+//
+// This extension enables the CodeMirror feature
+// It works by adding a gutter area to each code cell.
+// Fold-able code is marked using small triangles in the gutter.
+//
+// The current folding state is saved in the cell metadata as an array
+// of line numbers.
+// Format: cell.metadata.code_folding = [ line1, line2, line3, ...]
+//
+
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'base/js/events',
+    'services/config',
+    'notebook/js/codecell',
+    'codemirror/lib/codemirror',
+    'codemirror/addon/fold/foldcode',
+    'codemirror/addon/fold/foldgutter',
+    'codemirror/addon/fold/brace-fold',
+    'codemirror/addon/fold/indent-fold'
+], function (Jupyter, $, requirejs, events, configmod, codecell, CodeMirror) {
+    "use strict";
+
+    // define default config parameter values
+    var params = {
+        codefolding_hotkey : 'Alt-f',
+        init_delay : 1000
+    };
+
+    // updates default params with any specified in the provided config data
+    var update_params = function (config_data) {
+        for (var key in params) {
+            if (config_data.hasOwnProperty(key)) {
+                params[key] = config_data[key];
+            }
+        }
+    };
+
+    var on_config_loaded = function () {
+        if (Jupyter.notebook !== undefined) {
+            // register actions with ActionHandler instance
+            var prefix = 'auto';
+            var name = 'toggle-codefolding';
+            var action = {
+                icon: 'fa-comment-o',
+                help    : 'Toggle codefolding',
+                help_index : 'ec',
+                id : 'toggle_codefolding',
+                handler : toggleFolding
+            };
+            var action_full_name = Jupyter.keyboard_manager.actions.register(action, name, prefix);
+
+            // define keyboard shortcuts
+            var edit_mode_shortcuts = {};
+            edit_mode_shortcuts[params.codefolding_hotkey] = action_full_name;
+
+            // register keyboard shortcuts with keyboard_manager
+            Jupyter.notebook.keyboard_manager.edit_shortcuts.add_shortcuts(edit_mode_shortcuts);
+            Jupyter.notebook.keyboard_manager.command_shortcuts.add_shortcuts(edit_mode_shortcuts);
+        }
+        else {
+            // we're in edit view
+            var extraKeys = Jupyter.editor.codemirror.getOption('extraKeys');
+            extraKeys[params.codefolding_hotkey] = toggleFolding;
+            CodeMirror.normalizeKeyMap(extraKeys);
+            console.log('[codefolding] binding hotkey', params.codefolding_hotkey);
+            Jupyter.editor.codemirror.setOption('extraKeys', extraKeys);
+        }
+    };
+
+    /*
+     * Toggle folding on/off at current line
+     *
+     * @param cm CodeMirror instance
+     *
+     */
+    function toggleFolding () {
+        var cm;
+        var pos = {line: 0, ch: 0, xRel: 0};
+        if (Jupyter.notebook !== undefined) {
+            cm = Jupyter.notebook.get_selected_cell().code_mirror;
+            if (Jupyter.notebook.mode === 'edit') {
+                pos = cm.getCursor();
+            }
+        }
+        else {
+            cm = Jupyter.editor.codemirror;
+            pos = cm.getCursor();
+        }
+        var opts = cm.state.foldGutter.options;
+        cm.foldCode(pos, opts.rangeFinder);
+    }
+
+    /**
+     * Update cell metadata with folding info, so folding state can be restored after reloading notebook
+     *
+     * @param cm CodeMirror instance
+     */
+    function updateMetadata (cm) {
+        var list = cm.getAllMarks();
+        var lines = [];
+        for (var i = 0; i < list.length; i++) {
+            if (list[i].__isFold) {
+                var range = list[i].find();
+                lines.push(range.from.line);
+            }
+        }
+        /* User can click on gutter of unselected cells, so make sure we store metadata in the correct cell */
+        var cell = Jupyter.notebook.get_selected_cell();
+        if (cell.code_mirror !== cm) {
+            var cells = Jupyter.notebook.get_cells();
+            var ncells = Jupyter.notebook.ncells();
+            for (var k = 0; k < ncells; k++) {
+                var _cell = cells[k];
+                if (_cell.code_mirror === cm ) { cell = _cell; break; }
+            }
+        }
+        cell.metadata.code_folding = lines;
+    }
+
+    /**
+     * Activate codefolding in CodeMirror options, don't overwrite other settings
+     *
+     * @param cm codemirror instance
+     */
+    function activate_cm_folding (cm) {
+        var gutters = cm.getOption('gutters').slice();
+        if ( $.inArray("CodeMirror-foldgutter", gutters) < 0) {
+                gutters.push('CodeMirror-foldgutter');
+                cm.setOption('gutters', gutters);
+            }
+
+        /* set indent or brace folding */
+        var opts = true;
+        if (Jupyter.notebook) {
+            opts = {
+                rangeFinder: new CodeMirror.fold.combine(
+                    CodeMirror.fold.firstline,
+                    CodeMirror.fold.magic,
+                    CodeMirror.fold.blockcomment,
+                    cm.getMode().fold === 'indent' ? CodeMirror.fold.indent : CodeMirror.fold.brace
+                )
+            };
+        }
+        cm.setOption('foldGutter', opts);
+    }
+
+    /**
+     * Restore folding status from metadata
+     * @param cell
+     */
+    var restoreFolding = function (cell) {
+        if (cell.metadata.code_folding === undefined || !(cell instanceof codecell.CodeCell)) {
+            return;
+        }
+        // visit in reverse order, as otherwise nested folds un-fold outer ones
+        var lines = cell.metadata.code_folding.slice().sort();
+        for (var idx = lines.length - 1; idx >= 0; idx--) {
+            var line = lines[idx];
+            var opts = cell.code_mirror.state.foldGutter.options;
+            var linetext = cell.code_mirror.getLine(line);
+            if (linetext !== undefined) {
+                cell.code_mirror.foldCode(CodeMirror.Pos(line, 0), opts.rangeFinder);
+            }
+            else {
+                // the line doesn't exist, so we should remove it from metadata
+                cell.metadata.code_folding = lines.slice(0, idx);
+            }
+            cell.code_mirror.refresh();
+        }
+    };
+
+    /**
+     * Add codefolding gutter to a new cell
+     *
+     * @param event
+     * @param nbcell
+     *
+     */
+    var createCell = function (event, nbcell) {
+        var cell = nbcell.cell;
+        if ((cell instanceof codecell.CodeCell)) {
+            activate_cm_folding(cell.code_mirror);
+            cell.code_mirror.on('fold', updateMetadata);
+            cell.code_mirror.on('unfold', updateMetadata);
+            // queue restoring folding, to run once metadata is set, hopefully.
+            // This can be useful if cells are un-deleted, for example.
+            setTimeout(function () { restoreFolding(cell); }, 500);
+        }
+    };
+
+    /*
+     * Initialize gutter in existing cells
+     *
+     */
+    var initExistingCells = function () {
+        var cells = Jupyter.notebook.get_cells();
+        var ncells = Jupyter.notebook.ncells();
+        for (var i = 0; i < ncells; i++) {
+            var cell = cells[i];
+            if ((cell instanceof codecell.CodeCell)) {
+                activate_cm_folding(cell.code_mirror);
+                /* restore folding state if previously saved */
+                restoreFolding(cell);
+                cell.code_mirror.on('fold', updateMetadata);
+                cell.code_mirror.on('unfold', updateMetadata);
+            }
+        }
+        events.on('create.Cell', createCell);
+    };
+
+    /**
+     * Load my own CSS file
+     *
+     * @param name off CSS file
+     *
+     */
+    var load_css = function (name) {
+        var link = document.createElement("link");
+        link.type = "text/css";
+        link.rel = "stylesheet";
+        link.href = requirejs.toUrl(name, 'css');
+        document.getElementsByTagName("head")[0].appendChild(link);
+    };
+
+    /**
+     * Initialize extension
+     *
+     */
+    var load_extension = function () {
+        // first, check which view we're in, in order to decide whether to load
+        var conf_sect;
+        if (Jupyter.notebook) {
+            // we're in notebook view
+            conf_sect = Jupyter.notebook.config;
+        }
+        else if (Jupyter.editor) {
+            // we're in file-editor view
+            conf_sect = new configmod.ConfigSection('notebook', {base_url: Jupyter.editor.base_url});
+            conf_sect.load();
+        }
+        else {
+            // we're some other view like dashboard, terminal, etc, so bail now
+            return;
+        }
+
+        load_css('codemirror/addon/fold/foldgutter.css');
+        /* change default gutter width */
+        load_css( './foldgutter.css');
+
+        conf_sect.loaded
+        .then(function () { update_params(conf_sect.data); })
+        .then(on_config_loaded);
+
+        if (Jupyter.notebook) {
+            /* require our additional custom codefolding modes before initialising fully */
+            requirejs(['./firstline-fold', './magic-fold', './blockcomment-fold'], function () {
+                if (Jupyter.notebook._fully_loaded) {
+                    setTimeout(function () {
+                        console.log('Codefolding: Wait for', params.init_delay, 'ms');
+                        initExistingCells();
+                    }, params.init_delay);
+                }
+                else {
+                    events.one('notebook_loaded.Notebook', initExistingCells);
+                }
+            });
+        }
+        else {
+            activate_cm_folding(Jupyter.editor.codemirror);
+            setTimeout(function () {
+                console.log('Codefolding: Wait for', params.init_delay, 'ms');
+                Jupyter.editor.codemirror.refresh();
+            }, params.init_delay);
+        }
+    };
+
+    return {load_ipython_extension : load_extension};
+});

.local/share/jupyter/nbextensions/codefolding/readme.md

@@ -0,0 +1,105 @@
+Codefolding
+===========
+
+This extension adds codefolding functionality from CodeMirror to a codecell.
+
+In edit mode, clicking on the triangle in the gutter (left margin of codecell) or typing the codefolding hotkey 
+(default is `Alt+F`), folds the code. 
+In command mode, the folding hotkey relates to the first line of the codecell. 
+
+See the examples below. The folding status is saved in the cell metadata of the notebook, so reloading of a notebook will restore the folding view.
+
+Supported modes
+---------------
+
+Three different folding modes are supported:
+
+
+### Indent Folding
+
+In the image below, the Codefolding extension detects unfolded, Python-style indentations:
+
+![Unfolded](codefolding_indent_unfolded.png)
+
+The unfolded code above can be folded like this:
+
+![](codefolding_indent_folded_1.png)
+
+or this:
+
+![](codefolding_indent_folded_2.png)
+
+
+### Bracket Folding
+
+Other languages like Javascript use brackets to designate code blocks. Codefolding is supported for Javascript in using the `%%javascript` magic in a codecell.
+
+
+### Firstline Comment Folding
+
+Allows collapsing of Python code cells to a single comment line. This is useful for long codecells. The algorithm simply looks for a comment in the first line and allows folding in the rest of the cell.
+
+![](codefolding_firstline_unfolded.png)
+
+The code above can be folded like this:
+
+![](codefolding_firstline_folded.png)
+
+
+### Magics Folding
+
+If you specify a magic in the first line of a cell, it can be folded, too.
+
+![](magic-unfolded.png)
+
+Folded:
+
+![](magic-folded.png)
+
+
+
+Installation
+------------
+
+Note that there are two extensions: one for the notebook interface (`notebook:codefolding/main`),
+and one for the editor (`edit:codefolding/edit`) which have slightly different installation syntax:
+
+```bash
+jupyter nbextension enable codefolding/main
+jupyter nbextension enable --section edit codefolding/edit
+```
+
+
+Internals
+---------
+
+When saving a notebook, the folding information is saved in the metadata of
+each codecell.
+The number of the folding start line (beginning with 0) is stored in an array:
+
+```javascript
+cell.metadata.code_folding = [ 3, 20, 33 ]
+```
+
+When reloading the notebook, the folding status is restored.
+
+The codefolding hotkey can be customized using the notebook extensions configurator.
+The settings are stored as `"codefolding_hotkey": "alt-f"` in `the notebook.json` configuration file.
+
+
+Exporting
+---------
+
+To export a notebook containing folded cells, you will need to apply a custom
+preprocessor for nbconvert.
+The preprocessor is located in
+`jupyter_contrib_nbextensions.nbconvert_support.pre_codefolding`.
+
+The preprocessor is installed when you install the
+`jupyter_contrib_nbextensions` package.
+To activate the preprocessor manually,
+add the following lines to `jupyter_nbconvert_config.py`:
+
+```python
+Exporter.preprocessors += ['jupyter_contrib_nbextensions.nbconvert_support.CodeFoldingPreprocessor']
+```

.local/share/jupyter/nbextensions/codemirror_mode_extensions/codemirror_mode_extensions.yaml

@@ -0,0 +1,7 @@
+Type: Jupyter Notebook Extension
+Name: CodeMirror mode extensions
+Description: |
+  Extends some CodeMirror modes with extra features. Currently just adds
+  support for comment/uncomment and folding for octave/MATLAB mode.
+Main: main.js
+Compatibility: 4.x

.local/share/jupyter/nbextensions/collapsible_headings/collapsible_headings.yaml

@@ -0,0 +1,129 @@
+Type: Jupyter Notebook Extension
+Compatibility: 4.x, 5.x
+Name: Collapsible Headings
+Main: main.js
+Description: "Allows notebook to have collapsible sections, separated by headings"
+Link: readme.md
+Icon: icon.png
+Parameters:
+
+- name: collapsible_headings.add_button
+  description: Add a toolbar button to collapse the closest header cell
+  input_type: checkbox
+  default: false
+
+- name: collapsible_headings.add_all_cells_button
+  description: Add a toolbar button to collapse/uncollapse all header cells
+  input_type: checkbox
+  default: false
+
+- name: collapsible_headings.add_insert_header_buttons
+  description: Add toolbar buttons to insert heading cells above/below the selected cell
+  input_type: checkbox
+  default: false
+
+- name: collapsible_headings.use_toggle_controls
+  description: Add a control in each heading cell's input prompt to collapse/uncollapse it
+  input_type: checkbox
+  default: true
+
+- name: collapsible_headings.toggle_color
+  description: Color for the toggle control icon
+  input_type: color
+  default: '#aaaaaa'
+
+- name: collapsible_headings.toggle_closed_icon
+  description: font-awesome class for the toggle control icon on collapsed headings
+  default: fa-caret-right
+
+- name: collapsible_headings.toggle_open_icon
+  description: font-awesome class for the toggle control icon on uncollapsed (expanded) headings
+  default: fa-caret-down
+
+- name: collapsible_headings.make_toggle_controls_buttons
+  description: "Make the toggle control into a button (if false, it's just an icon)"
+  input_type: checkbox
+  default: false
+
+- name: collapsible_headings.size_toggle_controls_by_level
+  description: Adjust the size of the toggle controls to match their heading levels
+  input_type: checkbox
+  default: true
+
+- name: collapsible_headings.show_section_brackets
+  description: show Mathematica-style brackets around each collapsible section
+  input_type: checkbox
+  default: false
+
+- name: collapsible_headings.section_bracket_width
+  description: 'Width, in pixels, of the Mathematica-style brackets around sections'
+  input_type: number
+  min: 2
+  max: 100
+  default: 10
+
+- name: collapsible_headings.show_ellipsis
+  description: show a gray bracketed ellipsis at the end of collapsed heading cells
+  input_type: checkbox
+  default: true
+
+- name: collapsible_headings.use_shortcuts
+  description: Add command-mode keyboard shortcuts to collapse/uncollapse the selected heading cell
+  input_type: checkbox
+  default: true
+
+- name: collapsible_headings.shortcuts.collapse
+  description: Command-mode shortcut to collapse the selected heading cell
+  input_type: hotkey
+  default: left
+
+- name: collapsible_headings.shortcuts.uncollapse
+  description: Command-mode shortcut to uncollapse (expand) the selected heading cell
+  input_type: hotkey
+  default: right
+
+- name: collapsible_headings.shortcuts.collapse_all
+  description: Command-mode shortcut to collapse all heading cells
+  input_type: hotkey
+  default: ctrl-shift-left
+
+- name: collapsible_headings.shortcuts.uncollapse_all
+  description: Command-mode shortcut to uncollapse (expand) all heading cells
+  input_type: hotkey
+  default: ctrl-shift-right
+
+- name: collapsible_headings.shortcuts.select
+  description: Command-mode shortcut to select all cells in the selected heading cell's section
+  input_type: hotkey
+  default: shift-right
+
+- name: collapsible_headings.shortcuts.insert_above
+  description: Command-mode shortcut to insert a heading cell above the selected cell
+  input_type: hotkey
+  default: shift-a
+
+- name: collapsible_headings.shortcuts.insert_below
+  description: Command-mode shortcut to insert a heading cell below the selected cell's section
+  input_type: hotkey
+  default: shift-b
+
+- name: collapsible_headings.select_reveals
+  description: "By default, selecting a whole section also expands the section to reveal its last cell. Set this option to false to disable the expansion."
+  input_type: checkbox
+  default: true
+
+- name: collapsible_headings.collapse_to_match_toc
+  description: |
+    Collapse/uncollapse notebook sections when the ToC2 nbextension is used to
+    collapse/uncollapse sections in the table of contents. For the inverse
+    behaviour, see ToC2's configuration
+  input_type: checkbox
+  default: false
+
+- name: collapsible_headings.indent_px
+  description: |
+    Shift the collapsible heading controls left by this many pixels per level,
+    such that more significant headings (lower levels) appear further to the
+    left
+  input_type: number
+  default: 8