Add files using upload-large-folder tool

.cache/pip/http-v2/c/2/0/9/b/c209b6730b4a3a67d7d68f436a023e57f848dcba7c8db3fd04a54862.body

@@ -0,0 +1,1060 @@
+Metadata-Version: 2.1
+Name: regex
+Version: 2024.9.11
+Summary: Alternative regular expression module, to replace re.
+Home-page: https://github.com/mrabarnett/mrab-regex
+Author: Matthew Barnett
+Author-email: [email protected]
+License: Apache Software License
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+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 :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Text Processing :: General
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+
+Introduction
+------------
+
+This regex implementation is backwards-compatible with the standard 're' module, but offers additional functionality.
+
+Python 2
+--------
+
+Python 2 is no longer supported. The last release that supported Python 2 was 2021.11.10.
+
+PyPy
+----
+
+This module is targeted at CPython. It expects that all codepoints are the same width, so it won't behave properly with PyPy outside U+0000..U+007F because PyPy stores strings as UTF-8.
+
+Multithreading
+--------------
+
+The regex module releases the GIL during matching on instances of the built-in (immutable) string classes, enabling other Python threads to run concurrently. It is also possible to force the regex module to release the GIL during matching by calling the matching methods with the keyword argument ``concurrent=True``. The behaviour is undefined if the string changes during matching, so use it *only* when it is guaranteed that that won't happen.
+
+Unicode
+-------
+
+This module supports Unicode 16.0.0. Full Unicode case-folding is supported.
+
+Flags
+-----
+
+There are 2 kinds of flag: scoped and global. Scoped flags can apply to only part of a pattern and can be turned on or off; global flags apply to the entire pattern and can only be turned on.
+
+The scoped flags are: ``ASCII (?a)``, ``FULLCASE (?f)``, ``IGNORECASE (?i)``, ``LOCALE (?L)``, ``MULTILINE (?m)``, ``DOTALL (?s)``, ``UNICODE (?u)``, ``VERBOSE (?x)``, ``WORD (?w)``.
+
+The global flags are: ``BESTMATCH (?b)``, ``ENHANCEMATCH (?e)``, ``POSIX (?p)``, ``REVERSE (?r)``, ``VERSION0 (?V0)``, ``VERSION1 (?V1)``.
+
+If neither the ``ASCII``, ``LOCALE`` nor ``UNICODE`` flag is specified, it will default to ``UNICODE`` if the regex pattern is a Unicode string and ``ASCII`` if it's a bytestring.
+
+The ``ENHANCEMATCH`` flag makes fuzzy matching attempt to improve the fit of the next match that it finds.
+
+The ``BESTMATCH`` flag makes fuzzy matching search for the best match instead of the next match.
+
+Old vs new behaviour
+--------------------
+
+In order to be compatible with the re module, this module has 2 behaviours:
+
+* **Version 0** behaviour (old behaviour, compatible with the re module):
+
+  Please note that the re module's behaviour may change over time, and I'll endeavour to match that behaviour in version 0.
+
+  * Indicated by the ``VERSION0`` flag.
+
+  * Zero-width matches are not handled correctly in the re module before Python 3.7. The behaviour in those earlier versions is:
+
+    * ``.split`` won't split a string at a zero-width match.
+
+    * ``.sub`` will advance by one character after a zero-width match.
+
+  * Inline flags apply to the entire pattern, and they can't be turned off.
+
+  * Only simple sets are supported.
+
+  * Case-insensitive matches in Unicode use simple case-folding by default.
+
+* **Version 1** behaviour (new behaviour, possibly different from the re module):
+
+  * Indicated by the ``VERSION1`` flag.
+
+  * Zero-width matches are handled correctly.
+
+  * Inline flags apply to the end of the group or pattern, and they can be turned off.
+
+  * Nested sets and set operations are supported.
+
+  * Case-insensitive matches in Unicode use full case-folding by default.
+
+If no version is specified, the regex module will default to ``regex.DEFAULT_VERSION``.
+
+Case-insensitive matches in Unicode
+-----------------------------------
+
+The regex module supports both simple and full case-folding for case-insensitive matches in Unicode. Use of full case-folding can be turned on using the ``FULLCASE`` flag. Please note that this flag affects how the ``IGNORECASE`` flag works; the ``FULLCASE`` flag itself does not turn on case-insensitive matching.
+
+Version 0 behaviour: the flag is off by default.
+
+Version 1 behaviour: the flag is on by default.
+
+Nested sets and set operations
+------------------------------
+
+It's not possible to support both simple sets, as used in the re module, and nested sets at the same time because of a difference in the meaning of an unescaped ``"["`` in a set.
+
+For example, the pattern ``[[a-z]--[aeiou]]`` is treated in the version 0 behaviour (simple sets, compatible with the re module) as:
+
+* Set containing "[" and the letters "a" to "z"
+
+* Literal "--"
+
+* Set containing letters "a", "e", "i", "o", "u"
+
+* Literal "]"
+
+but in the version 1 behaviour (nested sets, enhanced behaviour) as:
+
+* Set which is:
+
+  * Set containing the letters "a" to "z"
+
+* but excluding:
+
+  * Set containing the letters "a", "e", "i", "o", "u"
+
+Version 0 behaviour: only simple sets are supported.
+
+Version 1 behaviour: nested sets and set operations are supported.
+
+Notes on named groups
+---------------------
+
+All groups have a group number, starting from 1.
+
+Groups with the same group name will have the same group number, and groups with a different group name will have a different group number.
+
+The same name can be used by more than one group, with later captures 'overwriting' earlier captures. All the captures of the group will be available from the ``captures`` method of the match object.
+
+Group numbers will be reused across different branches of a branch reset, eg. ``(?|(first)|(second))`` has only group 1. If groups have different group names then they will, of course, have different group numbers, eg. ``(?|(?P<foo>first)|(?P<bar>second))`` has group 1 ("foo") and group 2 ("bar").
+
+In the regex ``(\s+)(?|(?P<foo>[A-Z]+)|(\w+) (?P<foo>[0-9]+)`` there are 2 groups:
+
+* ``(\s+)`` is group 1.
+
+* ``(?P<foo>[A-Z]+)`` is group 2, also called "foo".
+
+* ``(\w+)`` is group 2 because of the branch reset.
+
+* ``(?P<foo>[0-9]+)`` is group 2 because it's called "foo".
+
+If you want to prevent ``(\w+)`` from being group 2, you need to name it (different name, different group number).
+
+Additional features
+-------------------
+
+The issue numbers relate to the Python bug tracker, except where listed otherwise.
+
+Added ``\p{Horiz_Space}`` and ``\p{Vert_Space}`` (`GitHub issue 477 <https://github.com/mrabarnett/mrab-regex/issues/477#issuecomment-1216779547>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``\p{Horiz_Space}`` or ``\p{H}`` matches horizontal whitespace and ``\p{Vert_Space}`` or ``\p{V}`` matches vertical whitespace.
+
+Added support for lookaround in conditional pattern (`Hg issue 163 <https://github.com/mrabarnett/mrab-regex/issues/163>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The test of a conditional pattern can be a lookaround.
+
+.. sourcecode:: python
+
+  >>> regex.match(r'(?(?=\d)\d+|\w+)', '123abc')
+  <regex.Match object; span=(0, 3), match='123'>
+  >>> regex.match(r'(?(?=\d)\d+|\w+)', 'abc123')
+  <regex.Match object; span=(0, 6), match='abc123'>
+
+This is not quite the same as putting a lookaround in the first branch of a pair of alternatives.
+
+.. sourcecode:: python
+
+  >>> print(regex.match(r'(?:(?=\d)\d+\b|\w+)', '123abc'))
+  <regex.Match object; span=(0, 6), match='123abc'>
+  >>> print(regex.match(r'(?(?=\d)\d+\b|\w+)', '123abc'))
+  None
+
+In the first example, the lookaround matched, but the remainder of the first branch failed to match, and so the second branch was attempted, whereas in the second example, the lookaround matched, and the first branch failed to match, but the second branch was **not** attempted.
+
+Added POSIX matching (leftmost longest) (`Hg issue 150 <https://github.com/mrabarnett/mrab-regex/issues/150>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The POSIX standard for regex is to return the leftmost longest match. This can be turned on using the ``POSIX`` flag.
+
+.. sourcecode:: python
+
+  >>> # Normal matching.
+  >>> regex.search(r'Mr|Mrs', 'Mrs')
+  <regex.Match object; span=(0, 2), match='Mr'>
+  >>> regex.search(r'one(self)?(selfsufficient)?', 'oneselfsufficient')
+  <regex.Match object; span=(0, 7), match='oneself'>
+  >>> # POSIX matching.
+  >>> regex.search(r'(?p)Mr|Mrs', 'Mrs')
+  <regex.Match object; span=(0, 3), match='Mrs'>
+  >>> regex.search(r'(?p)one(self)?(selfsufficient)?', 'oneselfsufficient')
+  <regex.Match object; span=(0, 17), match='oneselfsufficient'>
+
+Note that it will take longer to find matches because when it finds a match at a certain position, it won't return that immediately, but will keep looking to see if there's another longer match there.
+
+Added ``(?(DEFINE)...)`` (`Hg issue 152 <https://github.com/mrabarnett/mrab-regex/issues/152>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If there's no group called "DEFINE", then ... will be ignored except that any groups defined within it can be called and that the normal rules for numbering groups still apply.
+
+.. sourcecode:: python
+
+  >>> regex.search(r'(?(DEFINE)(?P<quant>\d+)(?P<item>\w+))(?&quant) (?&item)', '5 elephants')
+  <regex.Match object; span=(0, 11), match='5 elephants'>
+
+Added ``(*PRUNE)``, ``(*SKIP)`` and ``(*FAIL)`` (`Hg issue 153 <https://github.com/mrabarnett/mrab-regex/issues/153>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``(*PRUNE)`` discards the backtracking info up to that point. When used in an atomic group or a lookaround, it won't affect the enclosing pattern.
+
+``(*SKIP)`` is similar to ``(*PRUNE)``, except that it also sets where in the text the next attempt to match will start. When used in an atomic group or a lookaround, it won't affect the enclosing pattern.
+
+``(*FAIL)`` causes immediate backtracking. ``(*F)`` is a permitted abbreviation.
+
+Added ``\K`` (`Hg issue 151 <https://github.com/mrabarnett/mrab-regex/issues/151>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Keeps the part of the entire match after the position where ``\K`` occurred; the part before it is discarded.
+
+It does not affect what groups return.
+
+.. sourcecode:: python
+
+  >>> m = regex.search(r'(\w\w\K\w\w\w)', 'abcdef')
+  >>> m[0]
+  'cde'
+  >>> m[1]
+  'abcde'
+  >>>
+  >>> m = regex.search(r'(?r)(\w\w\K\w\w\w)', 'abcdef')
+  >>> m[0]
+  'bc'
+  >>> m[1]
+  'bcdef'
+
+Added capture subscripting for ``expandf`` and ``subf``/``subfn`` (`Hg issue 133 <https://github.com/mrabarnett/mrab-regex/issues/133>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+You can use subscripting to get the captures of a repeated group.
+
+.. sourcecode:: python
+
+  >>> m = regex.match(r"(\w)+", "abc")
+  >>> m.expandf("{1}")
+  'c'
+  >>> m.expandf("{1[0]} {1[1]} {1[2]}")
+  'a b c'
+  >>> m.expandf("{1[-1]} {1[-2]} {1[-3]}")
+  'c b a'
+  >>>
+  >>> m = regex.match(r"(?P<letter>\w)+", "abc")
+  >>> m.expandf("{letter}")
+  'c'
+  >>> m.expandf("{letter[0]} {letter[1]} {letter[2]}")
+  'a b c'
+  >>> m.expandf("{letter[-1]} {letter[-2]} {letter[-3]}")
+  'c b a'
+
+Added support for referring to a group by number using ``(?P=...)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This is in addition to the existing ``\g<...>``.
+
+Fixed the handling of locale-sensitive regexes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``LOCALE`` flag is intended for legacy code and has limited support. You're still recommended to use Unicode instead.
+
+Added partial matches (`Hg issue 102 <https://github.com/mrabarnett/mrab-regex/issues/102>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A partial match is one that matches up to the end of string, but that string has been truncated and you want to know whether a complete match could be possible if the string had not been truncated.
+
+Partial matches are supported by ``match``, ``search``, ``fullmatch`` and ``finditer`` with the ``partial`` keyword argument.
+
+Match objects have a ``partial`` attribute, which is ``True`` if it's a partial match.
+
+For example, if you wanted a user to enter a 4-digit number and check it character by character as it was being entered:
+
+.. sourcecode:: python
+
+  >>> pattern = regex.compile(r'\d{4}')
+
+  >>> # Initially, nothing has been entered:
+  >>> print(pattern.fullmatch('', partial=True))
+  <regex.Match object; span=(0, 0), match='', partial=True>
+
+  >>> # An empty string is OK, but it's only a partial match.
+  >>> # The user enters a letter:
+  >>> print(pattern.fullmatch('a', partial=True))
+  None
+  >>> # It'll never match.
+
+  >>> # The user deletes that and enters a digit:
+  >>> print(pattern.fullmatch('1', partial=True))
+  <regex.Match object; span=(0, 1), match='1', partial=True>
+  >>> # It matches this far, but it's only a partial match.
+
+  >>> # The user enters 2 more digits:
+  >>> print(pattern.fullmatch('123', partial=True))
+  <regex.Match object; span=(0, 3), match='123', partial=True>
+  >>> # It matches this far, but it's only a partial match.
+
+  >>> # The user enters another digit:
+  >>> print(pattern.fullmatch('1234', partial=True))
+  <regex.Match object; span=(0, 4), match='1234'>
+  >>> # It's a complete match.
+
+  >>> # If the user enters another digit:
+  >>> print(pattern.fullmatch('12345', partial=True))
+  None
+  >>> # It's no longer a match.
+
+  >>> # This is a partial match:
+  >>> pattern.match('123', partial=True).partial
+  True
+
+  >>> # This is a complete match:
+  >>> pattern.match('1233', partial=True).partial
+  False
+
+``*`` operator not working correctly with sub() (`Hg issue 106 <https://github.com/mrabarnett/mrab-regex/issues/106>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Sometimes it's not clear how zero-width matches should be handled. For example, should ``.*`` match 0 characters directly after matching >0 characters?
+
+.. sourcecode:: python
+
+  >>> regex.sub('.*', 'x', 'test')
+  'xx'
+  >>> regex.sub('.*?', '|', 'test')
+  '|||||||||'
+
+Added ``capturesdict`` (`Hg issue 86 <https://github.com/mrabarnett/mrab-regex/issues/86>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``capturesdict`` is a combination of ``groupdict`` and ``captures``:
+
+``groupdict`` returns a dict of the named groups and the last capture of those groups.
+
+``captures`` returns a list of all the captures of a group
+
+``capturesdict`` returns a dict of the named groups and lists of all the captures of those groups.
+
+.. sourcecode:: python
+
+  >>> m = regex.match(r"(?:(?P<word>\w+) (?P<digits>\d+)\n)+", "one 1\ntwo 2\nthree 3\n")
+  >>> m.groupdict()
+  {'word': 'three', 'digits': '3'}
+  >>> m.captures("word")
+  ['one', 'two', 'three']
+  >>> m.captures("digits")
+  ['1', '2', '3']
+  >>> m.capturesdict()
+  {'word': ['one', 'two', 'three'], 'digits': ['1', '2', '3']}
+
+Added ``allcaptures`` and ``allspans`` (`Git issue 474 <https://github.com/mrabarnett/mrab-regex/issues/474>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``allcaptures`` returns a list of all the captures of all the groups.
+
+``allspans`` returns a list of all the spans of the all captures of all the groups.
+
+.. sourcecode:: python
+
+  >>> m = regex.match(r"(?:(?P<word>\w+) (?P<digits>\d+)\n)+", "one 1\ntwo 2\nthree 3\n")
+  >>> m.allcaptures()
+  (['one 1\ntwo 2\nthree 3\n'], ['one', 'two', 'three'], ['1', '2', '3'])
+  >>> m.allspans()
+  ([(0, 20)], [(0, 3), (6, 9), (12, 17)], [(4, 5), (10, 11), (18, 19)])
+
+Allow duplicate names of groups (`Hg issue 87 <https://github.com/mrabarnett/mrab-regex/issues/87>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Group names can be duplicated.
+
+.. sourcecode:: python
+
+  >>> # With optional groups:
+  >>>
+  >>> # Both groups capture, the second capture 'overwriting' the first.
+  >>> m = regex.match(r"(?P<item>\w+)? or (?P<item>\w+)?", "first or second")
+  >>> m.group("item")
+  'second'
+  >>> m.captures("item")
+  ['first', 'second']
+  >>> # Only the second group captures.
+  >>> m = regex.match(r"(?P<item>\w+)? or (?P<item>\w+)?", " or second")
+  >>> m.group("item")
+  'second'
+  >>> m.captures("item")
+  ['second']
+  >>> # Only the first group captures.
+  >>> m = regex.match(r"(?P<item>\w+)? or (?P<item>\w+)?", "first or ")
+  >>> m.group("item")
+  'first'
+  >>> m.captures("item")
+  ['first']
+  >>>
+  >>> # With mandatory groups:
+  >>>
+  >>> # Both groups capture, the second capture 'overwriting' the first.
+  >>> m = regex.match(r"(?P<item>\w*) or (?P<item>\w*)?", "first or second")
+  >>> m.group("item")
+  'second'
+  >>> m.captures("item")
+  ['first', 'second']
+  >>> # Again, both groups capture, the second capture 'overwriting' the first.
+  >>> m = regex.match(r"(?P<item>\w*) or (?P<item>\w*)", " or second")
+  >>> m.group("item")
+  'second'
+  >>> m.captures("item")
+  ['', 'second']
+  >>> # And yet again, both groups capture, the second capture 'overwriting' the first.
+  >>> m = regex.match(r"(?P<item>\w*) or (?P<item>\w*)", "first or ")
+  >>> m.group("item")
+  ''
+  >>> m.captures("item")
+  ['first', '']
+
+Added ``fullmatch`` (`issue #16203 <https://bugs.python.org/issue16203>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``fullmatch`` behaves like ``match``, except that it must match all of the string.
+
+.. sourcecode:: python
+
+  >>> print(regex.fullmatch(r"abc", "abc").span())
+  (0, 3)
+  >>> print(regex.fullmatch(r"abc", "abcx"))
+  None
+  >>> print(regex.fullmatch(r"abc", "abcx", endpos=3).span())
+  (0, 3)
+  >>> print(regex.fullmatch(r"abc", "xabcy", pos=1, endpos=4).span())
+  (1, 4)
+  >>>
+  >>> regex.match(r"a.*?", "abcd").group(0)
+  'a'
+  >>> regex.fullmatch(r"a.*?", "abcd").group(0)
+  'abcd'
+
+Added ``subf`` and ``subfn``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``subf`` and ``subfn`` are alternatives to ``sub`` and ``subn`` respectively. When passed a replacement string, they treat it as a format string.
+
+.. sourcecode:: python
+
+  >>> regex.subf(r"(\w+) (\w+)", "{0} => {2} {1}", "foo bar")
+  'foo bar => bar foo'
+  >>> regex.subf(r"(?P<word1>\w+) (?P<word2>\w+)", "{word2} {word1}", "foo bar")
+  'bar foo'
+
+Added ``expandf`` to match object
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``expandf`` is an alternative to ``expand``. When passed a replacement string, it treats it as a format string.
+
+.. sourcecode:: python
+
+  >>> m = regex.match(r"(\w+) (\w+)", "foo bar")
+  >>> m.expandf("{0} => {2} {1}")
+  'foo bar => bar foo'
+  >>>
+  >>> m = regex.match(r"(?P<word1>\w+) (?P<word2>\w+)", "foo bar")
+  >>> m.expandf("{word2} {word1}")
+  'bar foo'
+
+Detach searched string
+^^^^^^^^^^^^^^^^^^^^^^
+
+A match object contains a reference to the string that was searched, via its ``string`` attribute. The ``detach_string`` method will 'detach' that string, making it available for garbage collection, which might save valuable memory if that string is very large.
+
+.. sourcecode:: python
+
+  >>> m = regex.search(r"\w+", "Hello world")
+  >>> print(m.group())
+  Hello
+  >>> print(m.string)
+  Hello world
+  >>> m.detach_string()
+  >>> print(m.group())
+  Hello
+  >>> print(m.string)
+  None
+
+Recursive patterns (`Hg issue 27 <https://github.com/mrabarnett/mrab-regex/issues/27>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Recursive and repeated patterns are supported.
+
+``(?R)`` or ``(?0)`` tries to match the entire regex recursively. ``(?1)``, ``(?2)``, etc, try to match the relevant group.
+
+``(?&name)`` tries to match the named group.
+
+.. sourcecode:: python
+
+  >>> regex.match(r"(Tarzan|Jane) loves (?1)", "Tarzan loves Jane").groups()
+  ('Tarzan',)
+  >>> regex.match(r"(Tarzan|Jane) loves (?1)", "Jane loves Tarzan").groups()
+  ('Jane',)
+
+  >>> m = regex.search(r"(\w)(?:(?R)|(\w?))\1", "kayak")
+  >>> m.group(0, 1, 2)
+  ('kayak', 'k', None)
+
+The first two examples show how the subpattern within the group is reused, but is _not_ itself a group. In other words, ``"(Tarzan|Jane) loves (?1)"`` is equivalent to ``"(Tarzan|Jane) loves (?:Tarzan|Jane)"``.
+
+It's possible to backtrack into a recursed or repeated group.
+
+You can't call a group if there is more than one group with that group name or group number (``"ambiguous group reference"``).
+
+The alternative forms ``(?P>name)`` and ``(?P&name)`` are also supported.
+
+Full Unicode case-folding is supported
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In version 1 behaviour, the regex module uses full case-folding when performing case-insensitive matches in Unicode.
+
+.. sourcecode:: python
+
+  >>> regex.match(r"(?iV1)strasse", "stra\N{LATIN SMALL LETTER SHARP S}e").span()
+  (0, 6)
+  >>> regex.match(r"(?iV1)stra\N{LATIN SMALL LETTER SHARP S}e", "STRASSE").span()
+  (0, 7)
+
+In version 0 behaviour, it uses simple case-folding for backward compatibility with the re module.
+
+Approximate "fuzzy" matching (`Hg issue 12 <https://github.com/mrabarnett/mrab-regex/issues/12>`_, `Hg issue 41 <https://github.com/mrabarnett/mrab-regex/issues/41>`_, `Hg issue 109 <https://github.com/mrabarnett/mrab-regex/issues/109>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Regex usually attempts an exact match, but sometimes an approximate, or "fuzzy", match is needed, for those cases where the text being searched may contain errors in the form of inserted, deleted or substituted characters.
+
+A fuzzy regex specifies which types of errors are permitted, and, optionally, either the minimum and maximum or only the maximum permitted number of each type. (You cannot specify only a minimum.)
+
+The 3 types of error are:
+
+* Insertion, indicated by "i"
+
+* Deletion, indicated by "d"
+
+* Substitution, indicated by "s"
+
+In addition, "e" indicates any type of error.
+
+The fuzziness of a regex item is specified between "{" and "}" after the item.
+
+Examples:
+
+* ``foo`` match "foo" exactly
+
+* ``(?:foo){i}`` match "foo", permitting insertions
+
+* ``(?:foo){d}`` match "foo", permitting deletions
+
+* ``(?:foo){s}`` match "foo", permitting substitutions
+
+* ``(?:foo){i,s}`` match "foo", permitting insertions and substitutions
+
+* ``(?:foo){e}`` match "foo", permitting errors
+
+If a certain type of error is specified, then any type not specified will **not** be permitted.
+
+In the following examples I'll omit the item and write only the fuzziness:
+
+* ``{d<=3}`` permit at most 3 deletions, but no other types
+
+* ``{i<=1,s<=2}`` permit at most 1 insertion and at most 2 substitutions, but no deletions
+
+* ``{1<=e<=3}`` permit at least 1 and at most 3 errors
+
+* ``{i<=2,d<=2,e<=3}`` permit at most 2 insertions, at most 2 deletions, at most 3 errors in total, but no substitutions
+
+It's also possible to state the costs of each type of error and the maximum permitted total cost.
+
+Examples:
+
+* ``{2i+2d+1s<=4}`` each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4
+
+* ``{i<=1,d<=1,s<=1,2i+2d+1s<=4}`` at most 1 insertion, at most 1 deletion, at most 1 substitution; each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4
+
+You can also use "<" instead of "<=" if you want an exclusive minimum or maximum.
+
+You can add a test to perform on a character that's substituted or inserted.
+
+Examples:
+
+* ``{s<=2:[a-z]}`` at most 2 substitutions, which must be in the character set ``[a-z]``.
+
+* ``{s<=2,i<=3:\d}`` at most 2 substitutions, at most 3 insertions, which must be digits.
+
+By default, fuzzy matching searches for the first match that meets the given constraints. The ``ENHANCEMATCH`` flag will cause it to attempt to improve the fit (i.e. reduce the number of errors) of the match that it has found.
+
+The ``BESTMATCH`` flag will make it search for the best match instead.
+
+Further examples to note:
+
+* ``regex.search("(dog){e}", "cat and dog")[1]`` returns ``"cat"`` because that matches ``"dog"`` with 3 errors (an unlimited number of errors is permitted).
+
+* ``regex.search("(dog){e<=1}", "cat and dog")[1]`` returns ``" dog"`` (with a leading space) because that matches ``"dog"`` with 1 error, which is within the limit.
+
+* ``regex.search("(?e)(dog){e<=1}", "cat and dog")[1]`` returns ``"dog"`` (without a leading space) because the fuzzy search matches ``" dog"`` with 1 error, which is within the limit, and the ``(?e)`` then it attempts a better fit.
+
+In the first two examples there are perfect matches later in the string, but in neither case is it the first possible match.
+
+The match object has an attribute ``fuzzy_counts`` which gives the total number of substitutions, insertions and deletions.
+
+.. sourcecode:: python
+
+  >>> # A 'raw' fuzzy match:
+  >>> regex.fullmatch(r"(?:cats|cat){e<=1}", "cat").fuzzy_counts
+  (0, 0, 1)
+  >>> # 0 substitutions, 0 insertions, 1 deletion.
+
+  >>> # A better match might be possible if the ENHANCEMATCH flag used:
+  >>> regex.fullmatch(r"(?e)(?:cats|cat){e<=1}", "cat").fuzzy_counts
+  (0, 0, 0)
+  >>> # 0 substitutions, 0 insertions, 0 deletions.
+
+The match object also has an attribute ``fuzzy_changes`` which gives a tuple of the positions of the substitutions, insertions and deletions.
+
+.. sourcecode:: python
+
+  >>> m = regex.search('(fuu){i<=2,d<=2,e<=5}', 'anaconda foo bar')
+  >>> m
+  <regex.Match object; span=(7, 10), match='a f', fuzzy_counts=(0, 2, 2)>
+  >>> m.fuzzy_changes
+  ([], [7, 8], [10, 11])
+
+What this means is that if the matched part of the string had been:
+
+.. sourcecode:: python
+
+  'anacondfuuoo bar'
+
+it would've been an exact match.
+
+However, there were insertions at positions 7 and 8:
+
+.. sourcecode:: python
+
+  'anaconda fuuoo bar'
+          ^^
+
+and deletions at positions 10 and 11:
+
+.. sourcecode:: python
+
+  'anaconda f~~oo bar'
+             ^^
+
+So the actual string was:
+
+.. sourcecode:: python
+
+  'anaconda foo bar'
+
+Named lists ``\L<name>`` (`Hg issue 11 <https://github.com/mrabarnett/mrab-regex/issues/11>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+There are occasions where you may want to include a list (actually, a set) of options in a regex.
+
+One way is to build the pattern like this:
+
+.. sourcecode:: python
+
+  >>> p = regex.compile(r"first|second|third|fourth|fifth")
+
+but if the list is large, parsing the resulting regex can take considerable time, and care must also be taken that the strings are properly escaped and properly ordered, for example, "cats" before "cat".
+
+The new alternative is to use a named list:
+
+.. sourcecode:: python
+
+  >>> option_set = ["first", "second", "third", "fourth", "fifth"]
+  >>> p = regex.compile(r"\L<options>", options=option_set)
+
+The order of the items is irrelevant, they are treated as a set. The named lists are available as the ``.named_lists`` attribute of the pattern object :
+
+.. sourcecode:: python
+
+  >>> print(p.named_lists)
+  {'options': frozenset({'third', 'first', 'fifth', 'fourth', 'second'})}
+
+If there are any unused keyword arguments, ``ValueError`` will be raised unless you tell it otherwise:
+
+.. sourcecode:: python
+
+  >>> option_set = ["first", "second", "third", "fourth", "fifth"]
+  >>> p = regex.compile(r"\L<options>", options=option_set, other_options=[])
+  Traceback (most recent call last):
+    File "<stdin>", line 1, in <module>
+    File "C:\Python310\lib\site-packages\regex\regex.py", line 353, in compile
+      return _compile(pattern, flags, ignore_unused, kwargs, cache_pattern)
+    File "C:\Python310\lib\site-packages\regex\regex.py", line 500, in _compile
+      complain_unused_args()
+    File "C:\Python310\lib\site-packages\regex\regex.py", line 483, in complain_unused_args
+      raise ValueError('unused keyword argument {!a}'.format(any_one))
+  ValueError: unused keyword argument 'other_options'
+  >>> p = regex.compile(r"\L<options>", options=option_set, other_options=[], ignore_unused=True)
+  >>> p = regex.compile(r"\L<options>", options=option_set, other_options=[], ignore_unused=False)
+  Traceback (most recent call last):
+    File "<stdin>", line 1, in <module>
+    File "C:\Python310\lib\site-packages\regex\regex.py", line 353, in compile
+      return _compile(pattern, flags, ignore_unused, kwargs, cache_pattern)
+    File "C:\Python310\lib\site-packages\regex\regex.py", line 500, in _compile
+      complain_unused_args()
+    File "C:\Python310\lib\site-packages\regex\regex.py", line 483, in complain_unused_args
+      raise ValueError('unused keyword argument {!a}'.format(any_one))
+  ValueError: unused keyword argument 'other_options'
+  >>>
+
+Start and end of word
+^^^^^^^^^^^^^^^^^^^^^
+
+``\m`` matches at the start of a word.
+
+``\M`` matches at the end of a word.
+
+Compare with ``\b``, which matches at the start or end of a word.
+
+Unicode line separators
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Normally the only line separator is ``\n`` (``\x0A``), but if the ``WORD`` flag is turned on then the line separators are ``\x0D\x0A``, ``\x0A``, ``\x0B``, ``\x0C`` and ``\x0D``, plus ``\x85``, ``\u2028`` and ``\u2029`` when working with Unicode.
+
+This affects the regex dot ``"."``, which, with the ``DOTALL`` flag turned off, matches any character except a line separator. It also affects the line anchors ``^`` and ``$`` (in multiline mode).
+
+Set operators
+^^^^^^^^^^^^^
+
+**Version 1 behaviour only**
+
+Set operators have been added, and a set ``[...]`` can include nested sets.
+
+The operators, in order of increasing precedence, are:
+
+* ``||`` for union ("x||y" means "x or y")
+
+* ``~~`` (double tilde) for symmetric difference ("x~~y" means "x or y, but not both")
+
+* ``&&`` for intersection ("x&&y" means "x and y")
+
+* ``--`` (double dash) for difference ("x--y" means "x but not y")
+
+Implicit union, ie, simple juxtaposition like in ``[ab]``, has the highest precedence. Thus, ``[ab&&cd]`` is the same as ``[[a||b]&&[c||d]]``.
+
+Examples:
+
+* ``[ab]`` # Set containing 'a' and 'b'
+
+* ``[a-z]`` # Set containing 'a' .. 'z'
+
+* ``[[a-z]--[qw]]`` # Set containing 'a' .. 'z', but not 'q' or 'w'
+
+* ``[a-z--qw]`` # Same as above
+
+* ``[\p{L}--QW]`` # Set containing all letters except 'Q' and 'W'
+
+* ``[\p{N}--[0-9]]`` # Set containing all numbers except '0' .. '9'
+
+* ``[\p{ASCII}&&\p{Letter}]`` # Set containing all characters which are ASCII and letter
+
+regex.escape (`issue #2650 <https://bugs.python.org/issue2650>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+regex.escape has an additional keyword parameter ``special_only``. When True, only 'special' regex characters, such as '?', are escaped.
+
+.. sourcecode:: python
+
+  >>> regex.escape("foo!?", special_only=False)
+  'foo\\!\\?'
+  >>> regex.escape("foo!?", special_only=True)
+  'foo!\\?'
+
+regex.escape (`Hg issue 249 <https://github.com/mrabarnett/mrab-regex/issues/249>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+regex.escape has an additional keyword parameter ``literal_spaces``. When True, spaces are not escaped.
+
+.. sourcecode:: python
+
+  >>> regex.escape("foo bar!?", literal_spaces=False)
+  'foo\\ bar!\\?'
+  >>> regex.escape("foo bar!?", literal_spaces=True)
+  'foo bar!\\?'
+
+Repeated captures (`issue #7132 <https://bugs.python.org/issue7132>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A match object has additional methods which return information on all the successful matches of a repeated group. These methods are:
+
+* ``matchobject.captures([group1, ...])``
+
+  * Returns a list of the strings matched in a group or groups. Compare with ``matchobject.group([group1, ...])``.
+
+* ``matchobject.starts([group])``
+
+  * Returns a list of the start positions. Compare with ``matchobject.start([group])``.
+
+* ``matchobject.ends([group])``
+
+  * Returns a list of the end positions. Compare with ``matchobject.end([group])``.
+
+* ``matchobject.spans([group])``
+
+  * Returns a list of the spans. Compare with ``matchobject.span([group])``.
+
+.. sourcecode:: python
+
+  >>> m = regex.search(r"(\w{3})+", "123456789")
+  >>> m.group(1)
+  '789'
+  >>> m.captures(1)
+  ['123', '456', '789']
+  >>> m.start(1)
+  6
+  >>> m.starts(1)
+  [0, 3, 6]
+  >>> m.end(1)
+  9
+  >>> m.ends(1)
+  [3, 6, 9]
+  >>> m.span(1)
+  (6, 9)
+  >>> m.spans(1)
+  [(0, 3), (3, 6), (6, 9)]
+
+Atomic grouping ``(?>...)`` (`issue #433030 <https://bugs.python.org/issue433030>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+If the following pattern subsequently fails, then the subpattern as a whole will fail.
+
+Possessive quantifiers
+^^^^^^^^^^^^^^^^^^^^^^
+
+``(?:...)?+`` ; ``(?:...)*+`` ; ``(?:...)++`` ; ``(?:...){min,max}+``
+
+The subpattern is matched up to 'max' times. If the following pattern subsequently fails, then all the repeated subpatterns will fail as a whole. For example, ``(?:...)++`` is equivalent to ``(?>(?:...)+)``.
+
+Scoped flags (`issue #433028 <https://bugs.python.org/issue433028>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``(?flags-flags:...)``
+
+The flags will apply only to the subpattern. Flags can be turned on or off.
+
+Definition of 'word' character (`issue #1693050 <https://bugs.python.org/issue1693050>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The definition of a 'word' character has been expanded for Unicode. It conforms to the Unicode specification at ``http://www.unicode.org/reports/tr29/``.
+
+Variable-length lookbehind
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A lookbehind can match a variable-length string.
+
+Flags argument for regex.split, regex.sub and regex.subn (`issue #3482 <https://bugs.python.org/issue3482>`_)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``regex.split``, ``regex.sub`` and ``regex.subn`` support a 'flags' argument.
+
+Pos and endpos arguments for regex.sub and regex.subn
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``regex.sub`` and ``regex.subn`` support 'pos' and 'endpos' arguments.
+
+'Overlapped' argument for regex.findall and regex.finditer
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``regex.findall`` and ``regex.finditer`` support an 'overlapped' flag which permits overlapped matches.
+
+Splititer
+^^^^^^^^^
+
+``regex.splititer`` has been added. It's a generator equivalent of ``regex.split``.
+
+Subscripting match objects for groups
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A match object accepts access to the groups via subscripting and slicing:
+
+.. sourcecode:: python
+
+  >>> m = regex.search(r"(?P<before>.*?)(?P<num>\d+)(?P<after>.*)", "pqr123stu")
+  >>> print(m["before"])
+  pqr
+  >>> print(len(m))
+  4
+  >>> print(m[:])
+  ('pqr123stu', 'pqr', '123', 'stu')
+
+Named groups
+^^^^^^^^^^^^
+
+Groups can be named with ``(?<name>...)`` as well as the existing ``(?P<name>...)``.
+
+Group references
+^^^^^^^^^^^^^^^^
+
+Groups can be referenced within a pattern with ``\g<name>``. This also allows there to be more than 99 groups.
+
+Named characters ``\N{name}``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Named characters are supported. Note that only those known by Python's Unicode database will be recognised.
+
+Unicode codepoint properties, including scripts and blocks
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``\p{property=value}``; ``\P{property=value}``; ``\p{value}`` ; ``\P{value}``
+
+Many Unicode properties are supported, including blocks and scripts. ``\p{property=value}`` or ``\p{property:value}`` matches a character whose property ``property`` has value ``value``. The inverse of ``\p{property=value}`` is ``\P{property=value}`` or ``\p{^property=value}``.
+
+If the short form ``\p{value}`` is used, the properties are checked in the order: ``General_Category``, ``Script``, ``Block``, binary property:
+
+* ``Latin``, the 'Latin' script (``Script=Latin``).
+
+* ``BasicLatin``, the 'BasicLatin' block (``Block=BasicLatin``).
+
+* ``Alphabetic``, the 'Alphabetic' binary property (``Alphabetic=Yes``).
+
+A short form starting with ``Is`` indicates a script or binary property:
+
+* ``IsLatin``, the 'Latin' script (``Script=Latin``).
+
+* ``IsAlphabetic``, the 'Alphabetic' binary property (``Alphabetic=Yes``).
+
+A short form starting with ``In`` indicates a block property:
+
+* ``InBasicLatin``, the 'BasicLatin' block (``Block=BasicLatin``).
+
+POSIX character classes
+^^^^^^^^^^^^^^^^^^^^^^^
+
+``[[:alpha:]]``; ``[[:^alpha:]]``
+
+POSIX character classes are supported. These are normally treated as an alternative form of ``\p{...}``.
+
+The exceptions are ``alnum``, ``digit``, ``punct`` and ``xdigit``, whose definitions are different from those of Unicode.
+
+``[[:alnum:]]`` is equivalent to ``\p{posix_alnum}``.
+
+``[[:digit:]]`` is equivalent to ``\p{posix_digit}``.
+
+``[[:punct:]]`` is equivalent to ``\p{posix_punct}``.
+
+``[[:xdigit:]]`` is equivalent to ``\p{posix_xdigit}``.
+
+Search anchor ``\G``
+^^^^^^^^^^^^^^^^^^^^
+
+A search anchor has been added. It matches at the position where each search started/continued and can be used for contiguous matches or in negative variable-length lookbehinds to limit how far back the lookbehind goes:
+
+.. sourcecode:: python
+
+  >>> regex.findall(r"\w{2}", "abcd ef")
+  ['ab', 'cd', 'ef']
+  >>> regex.findall(r"\G\w{2}", "abcd ef")
+  ['ab', 'cd']
+
+* The search starts at position 0 and matches 'ab'.
+
+* The search continues at position 2 and matches 'cd'.
+
+* The search continues at position 4 and fails to match any letters.
+
+* The anchor stops the search start position from being advanced, so there are no more results.
+
+Reverse searching
+^^^^^^^^^^^^^^^^^
+
+Searches can also work backwards:
+
+.. sourcecode:: python
+
+  >>> regex.findall(r".", "abc")
+  ['a', 'b', 'c']
+  >>> regex.findall(r"(?r).", "abc")
+  ['c', 'b', 'a']
+
+Note that the result of a reverse search is not necessarily the reverse of a forward search:
+
+.. sourcecode:: python
+
+  >>> regex.findall(r"..", "abcde")
+  ['ab', 'cd']
+  >>> regex.findall(r"(?r)..", "abcde")
+  ['de', 'bc']
+
+Matching a single grapheme ``\X``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The grapheme matcher is supported. It conforms to the Unicode specification at ``http://www.unicode.org/reports/tr29/``.
+
+Branch reset ``(?|...|...)``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Group numbers will be reused across the alternatives, but groups with different names will have different group numbers.
+
+.. sourcecode:: python
+
+  >>> regex.match(r"(?|(first)|(second))", "first").groups()
+  ('first',)
+  >>> regex.match(r"(?|(first)|(second))", "second").groups()
+  ('second',)
+
+Note that there is only one group.
+
+Default Unicode word boundary
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``WORD`` flag changes the definition of a 'word boundary' to that of a default Unicode word boundary. This applies to ``\b`` and ``\B``.
+
+Timeout
+^^^^^^^
+
+The matching methods and functions support timeouts. The timeout (in seconds) applies to the entire operation:
+
+.. sourcecode:: python
+
+  >>> from time import sleep
+  >>>
+  >>> def fast_replace(m):
+  ...     return 'X'
+  ...
+  >>> def slow_replace(m):
+  ...     sleep(0.5)
+  ...     return 'X'
+  ...
+  >>> regex.sub(r'[a-z]', fast_replace, 'abcde', timeout=2)
+  'XXXXX'
+  >>> regex.sub(r'[a-z]', slow_replace, 'abcde', timeout=2)
+  Traceback (most recent call last):
+    File "<stdin>", line 1, in <module>
+    File "C:\Python310\lib\site-packages\regex\regex.py", line 278, in sub
+      return pat.sub(repl, string, count, pos, endpos, concurrent, timeout)
+  TimeoutError: regex timed out

.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/6/8/9/5/f689581dbe86ea3c1a14226c252116f97e87dde2c835d7d60fd42b59.body

@@ -0,0 +1,280 @@
+Metadata-Version: 2.1
+Name: dill
+Version: 0.3.8
+Summary: serialize all of Python
+Home-page: https://github.com/uqfoundation/dill
+Author: Mike McKerns
+Author-email: [email protected]
+Maintainer: Mike McKerns
+Maintainer-email: [email protected]
+License: BSD-3-Clause
+Download-URL: https://pypi.org/project/dill/#files
+Project-URL: Documentation, http://dill.rtfd.io
+Project-URL: Source Code, https://github.com/uqfoundation/dill
+Project-URL: Bug Tracker, https://github.com/uqfoundation/dill/issues
+Platform: Linux
+Platform: Windows
+Platform: Mac
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+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 :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+Provides-Extra: graph
+Requires-Dist: objgraph (>=1.7.2) ; extra == 'graph'
+Provides-Extra: profile
+Requires-Dist: gprof2dot (>=2022.7.29) ; extra == 'profile'
+Provides-Extra: readline
+
+-----------------------------
+dill: serialize all of Python
+-----------------------------
+
+About Dill
+==========
+
+``dill`` extends Python's ``pickle`` module for serializing and de-serializing
+Python objects to the majority of the built-in Python types. Serialization
+is the process of converting an object to a byte stream, and the inverse
+of which is converting a byte stream back to a Python object hierarchy.
+
+``dill`` provides the user the same interface as the ``pickle`` module, and
+also includes some additional features. In addition to pickling Python
+objects, ``dill`` provides the ability to save the state of an interpreter
+session in a single command.  Hence, it would be feasible to save an
+interpreter session, close the interpreter, ship the pickled file to
+another computer, open a new interpreter, unpickle the session and
+thus continue from the 'saved' state of the original interpreter
+session.
+
+``dill`` can be used to store Python objects to a file, but the primary
+usage is to send Python objects across the network as a byte stream.
+``dill`` is quite flexible, and allows arbitrary user defined classes
+and functions to be serialized.  Thus ``dill`` is not intended to be
+secure against erroneously or maliciously constructed data. It is
+left to the user to decide whether the data they unpickle is from
+a trustworthy source.
+
+``dill`` is part of ``pathos``, a Python framework for heterogeneous computing.
+``dill`` is in active development, so any user feedback, bug reports, comments,
+or suggestions are highly appreciated.  A list of issues is located at
+https://github.com/uqfoundation/dill/issues, with a legacy list maintained at
+https://uqfoundation.github.io/project/pathos/query.
+
+
+Major Features
+==============
+
+``dill`` can pickle the following standard types:
+
+    - none, type, bool, int, float, complex, bytes, str,
+    - tuple, list, dict, file, buffer, builtin,
+    - Python classes, namedtuples, dataclasses, metaclasses,
+    - instances of classes,
+    - set, frozenset, array, functions, exceptions
+
+``dill`` can also pickle more 'exotic' standard types:
+
+    - functions with yields, nested functions, lambdas,
+    - cell, method, unboundmethod, module, code, methodwrapper,
+    - methoddescriptor, getsetdescriptor, memberdescriptor, wrapperdescriptor,
+    - dictproxy, slice, notimplemented, ellipsis, quit
+
+``dill`` cannot yet pickle these standard types:
+
+    - frame, generator, traceback
+
+``dill`` also provides the capability to:
+
+    - save and load Python interpreter sessions
+    - save and extract the source code from functions and classes
+    - interactively diagnose pickling errors
+
+
+Current Release
+===============
+
+The latest released version of ``dill`` is available from:
+
+    https://pypi.org/project/dill
+
+``dill`` is distributed under a 3-clause BSD license.
+
+
+Development Version
+===================
+
+You can get the latest development version with all the shiny new features at:
+
+    https://github.com/uqfoundation
+
+If you have a new contribution, please submit a pull request.
+
+
+Installation
+============
+
+``dill`` can be installed with ``pip``::
+
+    $ pip install dill
+
+To optionally include the ``objgraph`` diagnostic tool in the install::
+
+    $ pip install dill[graph]
+
+To optionally include the ``gprof2dot`` diagnostic tool in the install::
+
+    $ pip install dill[profile]
+
+For windows users, to optionally install session history tools::
+
+    $ pip install dill[readline]
+
+
+Requirements
+============
+
+``dill`` requires:
+
+    - ``python`` (or ``pypy``), **>=3.8**
+    - ``setuptools``, **>=42**
+
+Optional requirements:
+
+    - ``objgraph``, **>=1.7.2**
+    - ``gprof2dot``, **>=2022.7.29**
+    - ``pyreadline``, **>=1.7.1** (on windows)
+
+
+Basic Usage
+===========
+
+``dill`` is a drop-in replacement for ``pickle``. Existing code can be
+updated to allow complete pickling using::
+
+    >>> import dill as pickle
+
+or::
+
+    >>> from dill import dumps, loads
+
+``dumps`` converts the object to a unique byte string, and ``loads`` performs
+the inverse operation::
+
+    >>> squared = lambda x: x**2
+    >>> loads(dumps(squared))(3)
+    9
+
+There are a number of options to control serialization which are provided
+as keyword arguments to several ``dill`` functions:
+
+* with *protocol*, the pickle protocol level can be set. This uses the
+  same value as the ``pickle`` module, *DEFAULT_PROTOCOL*.
+* with *byref=True*, ``dill`` to behave a lot more like pickle with
+  certain objects (like modules) pickled by reference as opposed to
+  attempting to pickle the object itself.
+* with *recurse=True*, objects referred to in the global dictionary are
+  recursively traced and pickled, instead of the default behavior of
+  attempting to store the entire global dictionary.
+* with *fmode*, the contents of the file can be pickled along with the file
+  handle, which is useful if the object is being sent over the wire to a
+  remote system which does not have the original file on disk. Options are
+  *HANDLE_FMODE* for just the handle, *CONTENTS_FMODE* for the file content
+  and *FILE_FMODE* for content and handle.
+* with *ignore=False*, objects reconstructed with types defined in the
+  top-level script environment use the existing type in the environment
+  rather than a possibly different reconstructed type.
+
+The default serialization can also be set globally in *dill.settings*.
+Thus, we can modify how ``dill`` handles references to the global dictionary
+locally or globally::
+
+    >>> import dill.settings
+    >>> dumps(absolute) == dumps(absolute, recurse=True)
+    False
+    >>> dill.settings['recurse'] = True
+    >>> dumps(absolute) == dumps(absolute, recurse=True)
+    True
+
+``dill`` also includes source code inspection, as an alternate to pickling::
+
+    >>> import dill.source
+    >>> print(dill.source.getsource(squared))
+    squared = lambda x:x**2
+
+To aid in debugging pickling issues, use *dill.detect* which provides
+tools like pickle tracing::
+
+    >>> import dill.detect
+    >>> with dill.detect.trace():
+    >>>     dumps(squared)
+    ┬ F1: <function <lambda> at 0x7fe074f8c280>
+    ├┬ F2: <function _create_function at 0x7fe074c49c10>
+    │└ # F2 [34 B]
+    ├┬ Co: <code object <lambda> at 0x7fe07501eb30, file "<stdin>", line 1>
+    │├┬ F2: <function _create_code at 0x7fe074c49ca0>
+    ││└ # F2 [19 B]
+    │└ # Co [87 B]
+    ├┬ D1: <dict object at 0x7fe0750d4680>
+    │└ # D1 [22 B]
+    ├┬ D2: <dict object at 0x7fe074c5a1c0>
+    │└ # D2 [2 B]
+    ├┬ D2: <dict object at 0x7fe074f903c0>
+    │├┬ D2: <dict object at 0x7fe074f8ebc0>
+    ││└ # D2 [2 B]
+    │└ # D2 [23 B]
+    └ # F1 [180 B]
+
+With trace, we see how ``dill`` stored the lambda (``F1``) by first storing
+``_create_function``, the underlying code object (``Co``) and ``_create_code``
+(which is used to handle code objects), then we handle the reference to
+the global dict (``D2``) plus other dictionaries (``D1`` and ``D2``) that
+save the lambda object's state. A ``#`` marks when the object is actually stored.
+
+
+More Information
+================
+
+Probably the best way to get started is to look at the documentation at
+http://dill.rtfd.io. Also see ``dill.tests`` for a set of scripts that
+demonstrate how ``dill`` can serialize different Python objects. You can
+run the test suite with ``python -m dill.tests``. The contents of any
+pickle file can be examined with ``undill``.  As ``dill`` conforms to
+the ``pickle`` interface, the examples and documentation found at
+http://docs.python.org/library/pickle.html also apply to ``dill``
+if one will ``import dill as pickle``. The source code is also generally
+well documented, so further questions may be resolved by inspecting the
+code itself. Please feel free to submit a ticket on github, or ask a
+question on stackoverflow (**@Mike McKerns**).
+If you would like to share how you use ``dill`` in your work, please send
+an email (to **mmckerns at uqfoundation dot org**).
+
+
+Citation
+========
+
+If you use ``dill`` to do research that leads to publication, we ask that you
+acknowledge use of ``dill`` by citing the following in your publication::
+
+    M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis,
+    "Building a framework for predictive science", Proceedings of
+    the 10th Python in Science Conference, 2011;
+    http://arxiv.org/pdf/1202.1056
+
+    Michael McKerns and Michael Aivazis,
+    "pathos: a framework for heterogeneous computing", 2010- ;
+    https://uqfoundation.github.io/project/pathos
+
+Please see https://uqfoundation.github.io/project/pathos or
+http://arxiv.org/pdf/1202.1056 for further information.
+

.cache/pip/http-v2/f/a/0/e/b/fa0eb94064e725636a09e766c68812661f1423e7568ddc8b81c74949.body

@@ -0,0 +1,1591 @@
+Metadata-Version: 2.1
+Name: tqdm
+Version: 4.66.5
+Summary: Fast, Extensible Progress Meter
+Maintainer-email: tqdm developers <[email protected]>
+License: MPL-2.0 AND MIT
+Project-URL: homepage, https://tqdm.github.io
+Project-URL: repository, https://github.com/tqdm/tqdm
+Project-URL: changelog, https://tqdm.github.io/releases
+Project-URL: wiki, https://github.com/tqdm/tqdm/wiki
+Keywords: progressbar,progressmeter,progress,bar,meter,rate,eta,console,terminal,time
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Environment :: MacOS X
+Classifier: Environment :: Other Environment
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: X11 Applications
+Classifier: Framework :: IPython
+Classifier: Framework :: Jupyter
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Other Audience
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft
+Classifier: Operating System :: Microsoft :: MS-DOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: BSD
+Classifier: Operating System :: POSIX :: BSD :: FreeBSD
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: POSIX :: SunOS/Solaris
+Classifier: Operating System :: Unix
+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
+Classifier: Programming Language :: Python :: Implementation
+Classifier: Programming Language :: Python :: Implementation :: IronPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Unix Shell
+Classifier: Topic :: Desktop Environment
+Classifier: Topic :: Education :: Computer Aided Instruction (CAI)
+Classifier: Topic :: Education :: Testing
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Other/Nonlisted Topic
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Pre-processors
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: System :: Installation/Setup
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENCE
+Requires-Dist: colorama ; platform_system == "Windows"
+Provides-Extra: dev
+Requires-Dist: pytest >=6 ; extra == 'dev'
+Requires-Dist: pytest-cov ; extra == 'dev'
+Requires-Dist: pytest-timeout ; extra == 'dev'
+Requires-Dist: pytest-xdist ; extra == 'dev'
+Provides-Extra: notebook
+Requires-Dist: ipywidgets >=6 ; extra == 'notebook'
+Provides-Extra: slack
+Requires-Dist: slack-sdk ; extra == 'slack'
+Provides-Extra: telegram
+Requires-Dist: requests ; extra == 'telegram'
+
+|Logo|
+
+tqdm
+====
+
+|Py-Versions| |Versions| |Conda-Forge-Status| |Docker| |Snapcraft|
+
+|Build-Status| |Coverage-Status| |Branch-Coverage-Status| |Codacy-Grade| |Libraries-Rank| |PyPI-Downloads|
+
+|LICENCE| |OpenHub-Status| |binder-demo| |awesome-python|
+
+``tqdm`` derives from the Arabic word *taqaddum* (تقدّم) which can mean "progress,"
+and is an abbreviation for "I love you so much" in Spanish (*te quiero demasiado*).
+
+Instantly make your loops show a smart progress meter - just wrap any
+iterable with ``tqdm(iterable)``, and you're done!
+
+.. code:: python
+
+    from tqdm import tqdm
+    for i in tqdm(range(10000)):
+        ...
+
+``76%|████████████████████████        | 7568/10000 [00:33<00:10, 229.00it/s]``
+
+``trange(N)`` can be also used as a convenient shortcut for
+``tqdm(range(N))``.
+
+|Screenshot|
+    |Video| |Slides| |Merch|
+
+It can also be executed as a module with pipes:
+
+.. code:: sh
+
+    $ seq 9999999 | tqdm --bytes | wc -l
+    75.2MB [00:00, 217MB/s]
+    9999999
+
+    $ tar -zcf - docs/ | tqdm --bytes --total `du -sb docs/ | cut -f1` \
+        > backup.tgz
+     32%|██████████▍                      | 8.89G/27.9G [00:42<01:31, 223MB/s]
+
+Overhead is low -- about 60ns per iteration (80ns with ``tqdm.gui``), and is
+unit tested against performance regression.
+By comparison, the well-established
+`ProgressBar <https://github.com/niltonvolpato/python-progressbar>`__ has
+an 800ns/iter overhead.
+
+In addition to its low overhead, ``tqdm`` uses smart algorithms to predict
+the remaining time and to skip unnecessary iteration displays, which allows
+for a negligible overhead in most cases.
+
+``tqdm`` works on any platform
+(Linux, Windows, Mac, FreeBSD, NetBSD, Solaris/SunOS),
+in any console or in a GUI, and is also friendly with IPython/Jupyter notebooks.
+
+``tqdm`` does not require any dependencies (not even ``curses``!), just
+Python and an environment supporting ``carriage return \r`` and
+``line feed \n`` control characters.
+
+------------------------------------------
+
+.. contents:: Table of contents
+   :backlinks: top
+   :local:
+
+
+Installation
+------------
+
+Latest PyPI stable release
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+|Versions| |PyPI-Downloads| |Libraries-Dependents|
+
+.. code:: sh
+
+    pip install tqdm
+
+Latest development release on GitHub
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+|GitHub-Status| |GitHub-Stars| |GitHub-Commits| |GitHub-Forks| |GitHub-Updated|
+
+Pull and install pre-release ``devel`` branch:
+
+.. code:: sh
+
+    pip install "git+https://github.com/tqdm/tqdm.git@devel#egg=tqdm"
+
+Latest Conda release
+~~~~~~~~~~~~~~~~~~~~
+
+|Conda-Forge-Status|
+
+.. code:: sh
+
+    conda install -c conda-forge tqdm
+
+Latest Snapcraft release
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+|Snapcraft|
+
+There are 3 channels to choose from:
+
+.. code:: sh
+
+    snap install tqdm  # implies --stable, i.e. latest tagged release
+    snap install tqdm  --candidate  # master branch
+    snap install tqdm  --edge  # devel branch
+
+Note that ``snap`` binaries are purely for CLI use (not ``import``-able), and
+automatically set up ``bash`` tab-completion.
+
+Latest Docker release
+~~~~~~~~~~~~~~~~~~~~~
+
+|Docker|
+
+.. code:: sh
+
+    docker pull tqdm/tqdm
+    docker run -i --rm tqdm/tqdm --help
+
+Other
+~~~~~
+
+There are other (unofficial) places where ``tqdm`` may be downloaded, particularly for CLI use:
+
+|Repology|
+
+.. |Repology| image:: https://repology.org/badge/tiny-repos/python:tqdm.svg
+   :target: https://repology.org/project/python:tqdm/versions
+
+Changelog
+---------
+
+The list of all changes is available either on GitHub's Releases:
+|GitHub-Status|, on the
+`wiki <https://github.com/tqdm/tqdm/wiki/Releases>`__, or on the
+`website <https://tqdm.github.io/releases>`__.
+
+
+Usage
+-----
+
+``tqdm`` is very versatile and can be used in a number of ways.
+The three main ones are given below.
+
+Iterable-based
+~~~~~~~~~~~~~~
+
+Wrap ``tqdm()`` around any iterable:
+
+.. code:: python
+
+    from tqdm import tqdm
+    from time import sleep
+
+    text = ""
+    for char in tqdm(["a", "b", "c", "d"]):
+        sleep(0.25)
+        text = text + char
+
+``trange(i)`` is a special optimised instance of ``tqdm(range(i))``:
+
+.. code:: python
+
+    from tqdm import trange
+
+    for i in trange(100):
+        sleep(0.01)
+
+Instantiation outside of the loop allows for manual control over ``tqdm()``:
+
+.. code:: python
+
+    pbar = tqdm(["a", "b", "c", "d"])
+    for char in pbar:
+        sleep(0.25)
+        pbar.set_description("Processing %s" % char)
+
+Manual
+~~~~~~
+
+Manual control of ``tqdm()`` updates using a ``with`` statement:
+
+.. code:: python
+
+    with tqdm(total=100) as pbar:
+        for i in range(10):
+            sleep(0.1)
+            pbar.update(10)
+
+If the optional variable ``total`` (or an iterable with ``len()``) is
+provided, predictive stats are displayed.
+
+``with`` is also optional (you can just assign ``tqdm()`` to a variable,
+but in this case don't forget to ``del`` or ``close()`` at the end:
+
+.. code:: python
+
+    pbar = tqdm(total=100)
+    for i in range(10):
+        sleep(0.1)
+        pbar.update(10)
+    pbar.close()
+
+Module
+~~~~~~
+
+Perhaps the most wonderful use of ``tqdm`` is in a script or on the command
+line. Simply inserting ``tqdm`` (or ``python -m tqdm``) between pipes will pass
+through all ``stdin`` to ``stdout`` while printing progress to ``stderr``.
+
+The example below demonstrate counting the number of lines in all Python files
+in the current directory, with timing information included.
+
+.. code:: sh
+
+    $ time find . -name '*.py' -type f -exec cat \{} \; | wc -l
+    857365
+
+    real    0m3.458s
+    user    0m0.274s
+    sys     0m3.325s
+
+    $ time find . -name '*.py' -type f -exec cat \{} \; | tqdm | wc -l
+    857366it [00:03, 246471.31it/s]
+    857365
+
+    real    0m3.585s
+    user    0m0.862s
+    sys     0m3.358s
+
+Note that the usual arguments for ``tqdm`` can also be specified.
+
+.. code:: sh
+
+    $ find . -name '*.py' -type f -exec cat \{} \; |
+        tqdm --unit loc --unit_scale --total 857366 >> /dev/null
+    100%|█████████████████████████████████| 857K/857K [00:04<00:00, 246Kloc/s]
+
+Backing up a large directory?
+
+.. code:: sh
+
+    $ tar -zcf - docs/ | tqdm --bytes --total `du -sb docs/ | cut -f1` \
+      > backup.tgz
+     44%|██████████████▊                   | 153M/352M [00:14<00:18, 11.0MB/s]
+
+This can be beautified further:
+
+.. code:: sh
+
+    $ BYTES=$(du -sb docs/ | cut -f1)
+    $ tar -cf - docs/ \
+      | tqdm --bytes --total "$BYTES" --desc Processing | gzip \
+      | tqdm --bytes --total "$BYTES" --desc Compressed --position 1 \
+      > ~/backup.tgz
+    Processing: 100%|██████████████████████| 352M/352M [00:14<00:00, 30.2MB/s]
+    Compressed:  42%|█████████▎            | 148M/352M [00:14<00:19, 10.9MB/s]
+
+Or done on a file level using 7-zip:
+
+.. code:: sh
+
+    $ 7z a -bd -r backup.7z docs/ | grep Compressing \
+      | tqdm --total $(find docs/ -type f | wc -l) --unit files \
+      | grep -v Compressing
+    100%|██████████████████████████▉| 15327/15327 [01:00<00:00, 712.96files/s]
+
+Pre-existing CLI programs already outputting basic progress information will
+benefit from ``tqdm``'s ``--update`` and ``--update_to`` flags:
+
+.. code:: sh
+
+    $ seq 3 0.1 5 | tqdm --total 5 --update_to --null
+    100%|████████████████████████████████████| 5.0/5 [00:00<00:00, 9673.21it/s]
+    $ seq 10 | tqdm --update --null  # 1 + 2 + ... + 10 = 55 iterations
+    55it [00:00, 90006.52it/s]
+
+FAQ and Known Issues
+--------------------
+
+|GitHub-Issues|
+
+The most common issues relate to excessive output on multiple lines, instead
+of a neat one-line progress bar.
+
+- Consoles in general: require support for carriage return (``CR``, ``\r``).
+
+  * Some cloud logging consoles which don't support ``\r`` properly
+    (`cloudwatch <https://github.com/tqdm/tqdm/issues/966>`__,
+    `K8s <https://github.com/tqdm/tqdm/issues/1319>`__) may benefit from
+    ``export TQDM_POSITION=-1``.
+
+- Nested progress bars:
+
+  * Consoles in general: require support for moving cursors up to the
+    previous line. For example,
+    `IDLE <https://github.com/tqdm/tqdm/issues/191#issuecomment-230168030>`__,
+    `ConEmu <https://github.com/tqdm/tqdm/issues/254>`__ and
+    `PyCharm <https://github.com/tqdm/tqdm/issues/203>`__ (also
+    `here <https://github.com/tqdm/tqdm/issues/208>`__,
+    `here <https://github.com/tqdm/tqdm/issues/307>`__, and
+    `here <https://github.com/tqdm/tqdm/issues/454#issuecomment-335416815>`__)
+    lack full support.
+  * Windows: additionally may require the Python module ``colorama``
+    to ensure nested bars stay within their respective lines.
+
+- Unicode:
+
+  * Environments which report that they support unicode will have solid smooth
+    progressbars. The fallback is an ``ascii``-only bar.
+  * Windows consoles often only partially support unicode and thus
+    `often require explicit ascii=True <https://github.com/tqdm/tqdm/issues/454#issuecomment-335416815>`__
+    (also `here <https://github.com/tqdm/tqdm/issues/499>`__). This is due to
+    either normal-width unicode characters being incorrectly displayed as
+    "wide", or some unicode characters not rendering.
+
+- Wrapping generators:
+
+  * Generator wrapper functions tend to hide the length of iterables.
+    ``tqdm`` does not.
+  * Replace ``tqdm(enumerate(...))`` with ``enumerate(tqdm(...))`` or
+    ``tqdm(enumerate(x), total=len(x), ...)``.
+    The same applies to ``numpy.ndenumerate``.
+  * Replace ``tqdm(zip(a, b))`` with ``zip(tqdm(a), b)`` or even
+    ``zip(tqdm(a), tqdm(b))``.
+  * The same applies to ``itertools``.
+  * Some useful convenience functions can be found under ``tqdm.contrib``.
+
+- `No intermediate output in docker-compose <https://github.com/tqdm/tqdm/issues/771>`__:
+  use ``docker-compose run`` instead of ``docker-compose up`` and ``tty: true``.
+
+- Overriding defaults via environment variables:
+  e.g. in CI/cloud jobs, ``export TQDM_MININTERVAL=5`` to avoid log spam.
+  This override logic is handled by the ``tqdm.utils.envwrap`` decorator
+  (useful independent of ``tqdm``).
+
+If you come across any other difficulties, browse and file |GitHub-Issues|.
+
+Documentation
+-------------
+
+|Py-Versions| |README-Hits| (Since 19 May 2016)
+
+.. code:: python
+
+    class tqdm():
+      """
+      Decorate an iterable object, returning an iterator which acts exactly
+      like the original iterable, but prints a dynamically updating
+      progressbar every time a value is requested.
+      """
+
+      @envwrap("TQDM_")  # override defaults via env vars
+      def __init__(self, iterable=None, desc=None, total=None, leave=True,
+                   file=None, ncols=None, mininterval=0.1,
+                   maxinterval=10.0, miniters=None, ascii=None, disable=False,
+                   unit='it', unit_scale=False, dynamic_ncols=False,
+                   smoothing=0.3, bar_format=None, initial=0, position=None,
+                   postfix=None, unit_divisor=1000, write_bytes=False,
+                   lock_args=None, nrows=None, colour=None, delay=0):
+
+Parameters
+~~~~~~~~~~
+
+* iterable  : iterable, optional  
+    Iterable to decorate with a progressbar.
+    Leave blank to manually manage the updates.
+* desc  : str, optional  
+    Prefix for the progressbar.
+* total  : int or float, optional  
+    The number of expected iterations. If unspecified,
+    len(iterable) is used if possible. If float("inf") or as a last
+    resort, only basic progress statistics are displayed
+    (no ETA, no progressbar).
+    If ``gui`` is True and this parameter needs subsequent updating,
+    specify an initial arbitrary large positive number,
+    e.g. 9e9.
+* leave  : bool, optional  
+    If [default: True], keeps all traces of the progressbar
+    upon termination of iteration.
+    If ``None``, will leave only if ``position`` is ``0``.
+* file  : ``io.TextIOWrapper`` or ``io.StringIO``, optional  
+    Specifies where to output the progress messages
+    (default: sys.stderr). Uses ``file.write(str)`` and ``file.flush()``
+    methods.  For encoding, see ``write_bytes``.
+* ncols  : int, optional  
+    The width of the entire output message. If specified,
+    dynamically resizes the progressbar to stay within this bound.
+    If unspecified, attempts to use environment width. The
+    fallback is a meter width of 10 and no limit for the counter and
+    statistics. If 0, will not print any meter (only stats).
+* mininterval  : float, optional  
+    Minimum progress display update interval [default: 0.1] seconds.
+* maxinterval  : float, optional  
+    Maximum progress display update interval [default: 10] seconds.
+    Automatically adjusts ``miniters`` to correspond to ``mininterval``
+    after long display update lag. Only works if ``dynamic_miniters``
+    or monitor thread is enabled.
+* miniters  : int or float, optional  
+    Minimum progress display update interval, in iterations.
+    If 0 and ``dynamic_miniters``, will automatically adjust to equal
+    ``mininterval`` (more CPU efficient, good for tight loops).
+    If > 0, will skip display of specified number of iterations.
+    Tweak this and ``mininterval`` to get very efficient loops.
+    If your progress is erratic with both fast and slow iterations
+    (network, skipping items, etc) you should set miniters=1.
+* ascii  : bool or str, optional  
+    If unspecified or False, use unicode (smooth blocks) to fill
+    the meter. The fallback is to use ASCII characters " 123456789#".
+* disable  : bool, optional  
+    Whether to disable the entire progressbar wrapper
+    [default: False]. If set to None, disable on non-TTY.
+* unit  : str, optional  
+    String that will be used to define the unit of each iteration
+    [default: it].
+* unit_scale  : bool or int or float, optional  
+    If 1 or True, the number of iterations will be reduced/scaled
+    automatically and a metric prefix following the
+    International System of Units standard will be added
+    (kilo, mega, etc.) [default: False]. If any other non-zero
+    number, will scale ``total`` and ``n``.
+* dynamic_ncols  : bool, optional  
+    If set, constantly alters ``ncols`` and ``nrows`` to the
+    environment (allowing for window resizes) [default: False].
+* smoothing  : float, optional  
+    Exponential moving average smoothing factor for speed estimates
+    (ignored in GUI mode). Ranges from 0 (average speed) to 1
+    (current/instantaneous speed) [default: 0.3].
+* bar_format  : str, optional  
+    Specify a custom bar string formatting. May impact performance.
+    [default: '{l_bar}{bar}{r_bar}'], where
+    l_bar='{desc}: {percentage:3.0f}%|' and
+    r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, '
+    '{rate_fmt}{postfix}]'
+    Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt,
+    percentage, elapsed, elapsed_s, ncols, nrows, desc, unit,
+    rate, rate_fmt, rate_noinv, rate_noinv_fmt,
+    rate_inv, rate_inv_fmt, postfix, unit_divisor,
+    remaining, remaining_s, eta.
+    Note that a trailing ": " is automatically removed after {desc}
+    if the latter is empty.
+* initial  : int or float, optional  
+    The initial counter value. Useful when restarting a progress
+    bar [default: 0]. If using float, consider specifying ``{n:.3f}``
+    or similar in ``bar_format``, or specifying ``unit_scale``.
+* position  : int, optional  
+    Specify the line offset to print this bar (starting from 0)
+    Automatic if unspecified.
+    Useful to manage multiple bars at once (eg, from threads).
+* postfix  : dict or ``*``, optional  
+    Specify additional stats to display at the end of the bar.
+    Calls ``set_postfix(**postfix)`` if possible (dict).
+* unit_divisor  : float, optional  
+    [default: 1000], ignored unless ``unit_scale`` is True.
+* write_bytes  : bool, optional  
+    Whether to write bytes. If (default: False) will write unicode.
+* lock_args  : tuple, optional  
+    Passed to ``refresh`` for intermediate output
+    (initialisation, iterating, and updating).
+* nrows  : int, optional  
+    The screen height. If specified, hides nested bars outside this
+    bound. If unspecified, attempts to use environment height.
+    The fallback is 20.
+* colour  : str, optional  
+    Bar colour (e.g. 'green', '#00ff00').
+* delay  : float, optional  
+    Don't display until [default: 0] seconds have elapsed.
+
+Extra CLI Options
+~~~~~~~~~~~~~~~~~
+
+* delim  : chr, optional  
+    Delimiting character [default: '\n']. Use '\0' for null.
+    N.B.: on Windows systems, Python converts '\n' to '\r\n'.
+* buf_size  : int, optional  
+    String buffer size in bytes [default: 256]
+    used when ``delim`` is specified.
+* bytes  : bool, optional  
+    If true, will count bytes, ignore ``delim``, and default
+    ``unit_scale`` to True, ``unit_divisor`` to 1024, and ``unit`` to 'B'.
+* tee  : bool, optional  
+    If true, passes ``stdin`` to both ``stderr`` and ``stdout``.
+* update  : bool, optional  
+    If true, will treat input as newly elapsed iterations,
+    i.e. numbers to pass to ``update()``. Note that this is slow
+    (~2e5 it/s) since every input must be decoded as a number.
+* update_to  : bool, optional  
+    If true, will treat input as total elapsed iterations,
+    i.e. numbers to assign to ``self.n``. Note that this is slow
+    (~2e5 it/s) since every input must be decoded as a number.
+* null  : bool, optional  
+    If true, will discard input (no stdout).
+* manpath  : str, optional  
+    Directory in which to install tqdm man pages.
+* comppath  : str, optional  
+    Directory in which to place tqdm completion.
+* log  : str, optional  
+    CRITICAL|FATAL|ERROR|WARN(ING)|[default: 'INFO']|DEBUG|NOTSET.
+
+Returns
+~~~~~~~
+
+* out  : decorated iterator.  
+
+.. code:: python
+
+    class tqdm():
+      def update(self, n=1):
+          """
+          Manually update the progress bar, useful for streams
+          such as reading files.
+          E.g.:
+          >>> t = tqdm(total=filesize) # Initialise
+          >>> for current_buffer in stream:
+          ...    ...
+          ...    t.update(len(current_buffer))
+          >>> t.close()
+          The last line is highly recommended, but possibly not necessary if
+          ``t.update()`` will be called in such a way that ``filesize`` will be
+          exactly reached and printed.
+
+          Parameters
+          ----------
+          n  : int or float, optional
+              Increment to add to the internal counter of iterations
+              [default: 1]. If using float, consider specifying ``{n:.3f}``
+              or similar in ``bar_format``, or specifying ``unit_scale``.
+
+          Returns
+          -------
+          out  : bool or None
+              True if a ``display()`` was triggered.
+          """
+
+      def close(self):
+          """Cleanup and (if leave=False) close the progressbar."""
+
+      def clear(self, nomove=False):
+          """Clear current bar display."""
+
+      def refresh(self):
+          """
+          Force refresh the display of this bar.
+
+          Parameters
+          ----------
+          nolock  : bool, optional
+              If ``True``, does not lock.
+              If [default: ``False``]: calls ``acquire()`` on internal lock.
+          lock_args  : tuple, optional
+              Passed to internal lock's ``acquire()``.
+              If specified, will only ``display()`` if ``acquire()`` returns ``True``.
+          """
+
+      def unpause(self):
+          """Restart tqdm timer from last print time."""
+
+      def reset(self, total=None):
+          """
+          Resets to 0 iterations for repeated use.
+
+          Consider combining with ``leave=True``.
+
+          Parameters
+          ----------
+          total  : int or float, optional. Total to use for the new bar.
+          """
+
+      def set_description(self, desc=None, refresh=True):
+          """
+          Set/modify description of the progress bar.
+
+          Parameters
+          ----------
+          desc  : str, optional
+          refresh  : bool, optional
+              Forces refresh [default: True].
+          """
+
+      def set_postfix(self, ordered_dict=None, refresh=True, **tqdm_kwargs):
+          """
+          Set/modify postfix (additional stats)
+          with automatic formatting based on datatype.
+
+          Parameters
+          ----------
+          ordered_dict  : dict or OrderedDict, optional
+          refresh  : bool, optional
+              Forces refresh [default: True].
+          kwargs  : dict, optional
+          """
+
+      @classmethod
+      def write(cls, s, file=sys.stdout, end="\n"):
+          """Print a message via tqdm (without overlap with bars)."""
+
+      @property
+      def format_dict(self):
+          """Public API for read-only member access."""
+
+      def display(self, msg=None, pos=None):
+          """
+          Use ``self.sp`` to display ``msg`` in the specified ``pos``.
+
+          Consider overloading this function when inheriting to use e.g.:
+          ``self.some_frontend(**self.format_dict)`` instead of ``self.sp``.
+
+          Parameters
+          ----------
+          msg  : str, optional. What to display (default: ``repr(self)``).
+          pos  : int, optional. Position to ``moveto``
+            (default: ``abs(self.pos)``).
+          """
+
+      @classmethod
+      @contextmanager
+      def wrapattr(cls, stream, method, total=None, bytes=True, **tqdm_kwargs):
+          """
+          stream  : file-like object.
+          method  : str, "read" or "write". The result of ``read()`` and
+              the first argument of ``write()`` should have a ``len()``.
+
+          >>> with tqdm.wrapattr(file_obj, "read", total=file_obj.size) as fobj:
+          ...     while True:
+          ...         chunk = fobj.read(chunk_size)
+          ...         if not chunk:
+          ...             break
+          """
+
+      @classmethod
+      def pandas(cls, *targs, **tqdm_kwargs):
+          """Registers the current `tqdm` class with `pandas`."""
+
+    def trange(*args, **tqdm_kwargs):
+        """Shortcut for `tqdm(range(*args), **tqdm_kwargs)`."""
+
+Convenience Functions
+~~~~~~~~~~~~~~~~~~~~~
+
+.. code:: python
+
+    def tqdm.contrib.tenumerate(iterable, start=0, total=None,
+                                tqdm_class=tqdm.auto.tqdm, **tqdm_kwargs):
+        """Equivalent of `numpy.ndenumerate` or builtin `enumerate`."""
+
+    def tqdm.contrib.tzip(iter1, *iter2plus, **tqdm_kwargs):
+        """Equivalent of builtin `zip`."""
+
+    def tqdm.contrib.tmap(function, *sequences, **tqdm_kwargs):
+        """Equivalent of builtin `map`."""
+
+Submodules
+~~~~~~~~~~
+
+.. code:: python
+
+    class tqdm.notebook.tqdm(tqdm.tqdm):
+        """IPython/Jupyter Notebook widget."""
+
+    class tqdm.auto.tqdm(tqdm.tqdm):
+        """Automatically chooses beween `tqdm.notebook` and `tqdm.tqdm`."""
+
+    class tqdm.asyncio.tqdm(tqdm.tqdm):
+      """Asynchronous version."""
+      @classmethod
+      def as_completed(cls, fs, *, loop=None, timeout=None, total=None,
+                       **tqdm_kwargs):
+          """Wrapper for `asyncio.as_completed`."""
+
+    class tqdm.gui.tqdm(tqdm.tqdm):
+        """Matplotlib GUI version."""
+
+    class tqdm.tk.tqdm(tqdm.tqdm):
+        """Tkinter GUI version."""
+
+    class tqdm.rich.tqdm(tqdm.tqdm):
+        """`rich.progress` version."""
+
+    class tqdm.keras.TqdmCallback(keras.callbacks.Callback):
+        """Keras callback for epoch and batch progress."""
+
+    class tqdm.dask.TqdmCallback(dask.callbacks.Callback):
+        """Dask callback for task progress."""
+
+
+``contrib``
++++++++++++
+
+The ``tqdm.contrib`` package also contains experimental modules:
+
+- ``tqdm.contrib.itertools``: Thin wrappers around ``itertools``
+- ``tqdm.contrib.concurrent``: Thin wrappers around ``concurrent.futures``
+- ``tqdm.contrib.slack``: Posts to `Slack <https://slack.com>`__ bots
+- ``tqdm.contrib.discord``: Posts to `Discord <https://discord.com>`__ bots
+- ``tqdm.contrib.telegram``: Posts to `Telegram <https://telegram.org>`__ bots
+- ``tqdm.contrib.bells``: Automagically enables all optional features
+
+  * ``auto``, ``pandas``, ``slack``, ``discord``, ``telegram``
+
+Examples and Advanced Usage
+---------------------------
+
+- See the `examples <https://github.com/tqdm/tqdm/tree/master/examples>`__
+  folder;
+- import the module and run ``help()``;
+- consult the `wiki <https://github.com/tqdm/tqdm/wiki>`__;
+
+  * this has an
+    `excellent article <https://github.com/tqdm/tqdm/wiki/How-to-make-a-great-Progress-Bar>`__
+    on how to make a **great** progressbar;
+
+- check out the `slides from PyData London <https://tqdm.github.io/PyData2019/slides.html>`__, or
+- run the |binder-demo|.
+
+Description and additional stats
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Custom information can be displayed and updated dynamically on ``tqdm`` bars
+with the ``desc`` and ``postfix`` arguments:
+
+.. code:: python
+
+    from tqdm import tqdm, trange
+    from random import random, randint
+    from time import sleep
+
+    with trange(10) as t:
+        for i in t:
+            # Description will be displayed on the left
+            t.set_description('GEN %i' % i)
+            # Postfix will be displayed on the right,
+            # formatted automatically based on argument's datatype
+            t.set_postfix(loss=random(), gen=randint(1,999), str='h',
+                          lst=[1, 2])
+            sleep(0.1)
+
+    with tqdm(total=10, bar_format="{postfix[0]} {postfix[1][value]:>8.2g}",
+              postfix=["Batch", {"value": 0}]) as t:
+        for i in range(10):
+            sleep(0.1)
+            t.postfix[1]["value"] = i / 2
+            t.update()
+
+Points to remember when using ``{postfix[...]}`` in the ``bar_format`` string:
+
+- ``postfix`` also needs to be passed as an initial argument in a compatible
+  format, and
+- ``postfix`` will be auto-converted to a string if it is a ``dict``-like
+  object. To prevent this behaviour, insert an extra item into the dictionary
+  where the key is not a string.
+
+Additional ``bar_format`` parameters may also be defined by overriding
+``format_dict``, and the bar itself may be modified using ``ascii``:
+
+.. code:: python
+
+    from tqdm import tqdm
+    class TqdmExtraFormat(tqdm):
+        """Provides a `total_time` format parameter"""
+        @property
+        def format_dict(self):
+            d = super().format_dict
+            total_time = d["elapsed"] * (d["total"] or 0) / max(d["n"], 1)
+            d.update(total_time=self.format_interval(total_time) + " in total")
+            return d
+
+    for i in TqdmExtraFormat(
+          range(9), ascii=" .oO0",
+          bar_format="{total_time}: {percentage:.0f}%|{bar}{r_bar}"):
+        if i == 4:
+            break
+
+.. code::
+
+    00:00 in total: 44%|0000.     | 4/9 [00:00<00:00, 962.93it/s]
+
+Note that ``{bar}`` also supports a format specifier ``[width][type]``.
+
+- ``width``
+
+  * unspecified (default): automatic to fill ``ncols``
+  * ``int >= 0``: fixed width overriding ``ncols`` logic
+  * ``int < 0``: subtract from the automatic default
+
+- ``type``
+
+  * ``a``: ascii (``ascii=True`` override)
+  * ``u``: unicode (``ascii=False`` override)
+  * ``b``: blank (``ascii="  "`` override)
+
+This means a fixed bar with right-justified text may be created by using:
+``bar_format="{l_bar}{bar:10}|{bar:-10b}right-justified"``
+
+Nested progress bars
+~~~~~~~~~~~~~~~~~~~~
+
+``tqdm`` supports nested progress bars. Here's an example:
+
+.. code:: python
+
+    from tqdm.auto import trange
+    from time import sleep
+
+    for i in trange(4, desc='1st loop'):
+        for j in trange(5, desc='2nd loop'):
+            for k in trange(50, desc='3rd loop', leave=False):
+                sleep(0.01)
+
+For manual control over positioning (e.g. for multi-processing use),
+you may specify ``position=n`` where ``n=0`` for the outermost bar,
+``n=1`` for the next, and so on.
+However, it's best to check if ``tqdm`` can work without manual ``position``
+first.
+
+.. code:: python
+
+    from time import sleep
+    from tqdm import trange, tqdm
+    from multiprocessing import Pool, RLock, freeze_support
+
+    L = list(range(9))
+
+    def progresser(n):
+        interval = 0.001 / (n + 2)
+        total = 5000
+        text = f"#{n}, est. {interval * total:<04.2}s"
+        for _ in trange(total, desc=text, position=n):
+            sleep(interval)
+
+    if __name__ == '__main__':
+        freeze_support()  # for Windows support
+        tqdm.set_lock(RLock())  # for managing output contention
+        p = Pool(initializer=tqdm.set_lock, initargs=(tqdm.get_lock(),))
+        p.map(progresser, L)
+
+Note that in Python 3, ``tqdm.write`` is thread-safe:
+
+.. code:: python
+
+    from time import sleep
+    from tqdm import tqdm, trange
+    from concurrent.futures import ThreadPoolExecutor
+
+    L = list(range(9))
+
+    def progresser(n):
+        interval = 0.001 / (n + 2)
+        total = 5000
+        text = f"#{n}, est. {interval * total:<04.2}s"
+        for _ in trange(total, desc=text):
+            sleep(interval)
+        if n == 6:
+            tqdm.write("n == 6 completed.")
+            tqdm.write("`tqdm.write()` is thread-safe in py3!")
+
+    if __name__ == '__main__':
+        with ThreadPoolExecutor() as p:
+            p.map(progresser, L)
+
+Hooks and callbacks
+~~~~~~~~~~~~~~~~~~~
+
+``tqdm`` can easily support callbacks/hooks and manual updates.
+Here's an example with ``urllib``:
+
+**``urllib.urlretrieve`` documentation**
+
+    | [...]
+    | If present, the hook function will be called once
+    | on establishment of the network connection and once after each block read
+    | thereafter. The hook will be passed three arguments; a count of blocks
+    | transferred so far, a block size in bytes, and the total size of the file.
+    | [...]
+
+.. code:: python
+
+    import urllib, os
+    from tqdm import tqdm
+    urllib = getattr(urllib, 'request', urllib)
+
+    class TqdmUpTo(tqdm):
+        """Provides `update_to(n)` which uses `tqdm.update(delta_n)`."""
+        def update_to(self, b=1, bsize=1, tsize=None):
+            """
+            b  : int, optional
+                Number of blocks transferred so far [default: 1].
+            bsize  : int, optional
+                Size of each block (in tqdm units) [default: 1].
+            tsize  : int, optional
+                Total size (in tqdm units). If [default: None] remains unchanged.
+            """
+            if tsize is not None:
+                self.total = tsize
+            return self.update(b * bsize - self.n)  # also sets self.n = b * bsize
+
+    eg_link = "https://caspersci.uk.to/matryoshka.zip"
+    with TqdmUpTo(unit='B', unit_scale=True, unit_divisor=1024, miniters=1,
+                  desc=eg_link.split('/')[-1]) as t:  # all optional kwargs
+        urllib.urlretrieve(eg_link, filename=os.devnull,
+                           reporthook=t.update_to, data=None)
+        t.total = t.n
+
+Inspired by `twine#242 <https://github.com/pypa/twine/pull/242>`__.
+Functional alternative in
+`examples/tqdm_wget.py <https://github.com/tqdm/tqdm/blob/master/examples/tqdm_wget.py>`__.
+
+It is recommend to use ``miniters=1`` whenever there is potentially
+large differences in iteration speed (e.g. downloading a file over
+a patchy connection).
+
+**Wrapping read/write methods**
+
+To measure throughput through a file-like object's ``read`` or ``write``
+methods, use ``CallbackIOWrapper``:
+
+.. code:: python
+
+    from tqdm.auto import tqdm
+    from tqdm.utils import CallbackIOWrapper
+
+    with tqdm(total=file_obj.size,
+              unit='B', unit_scale=True, unit_divisor=1024) as t:
+        fobj = CallbackIOWrapper(t.update, file_obj, "read")
+        while True:
+            chunk = fobj.read(chunk_size)
+            if not chunk:
+                break
+        t.reset()
+        # ... continue to use `t` for something else
+
+Alternatively, use the even simpler ``wrapattr`` convenience function,
+which would condense both the ``urllib`` and ``CallbackIOWrapper`` examples
+down to:
+
+.. code:: python
+
+    import urllib, os
+    from tqdm import tqdm
+
+    eg_link = "https://caspersci.uk.to/matryoshka.zip"
+    response = getattr(urllib, 'request', urllib).urlopen(eg_link)
+    with tqdm.wrapattr(open(os.devnull, "wb"), "write",
+                       miniters=1, desc=eg_link.split('/')[-1],
+                       total=getattr(response, 'length', None)) as fout:
+        for chunk in response:
+            fout.write(chunk)
+
+The ``requests`` equivalent is nearly identical:
+
+.. code:: python
+
+    import requests, os
+    from tqdm import tqdm
+
+    eg_link = "https://caspersci.uk.to/matryoshka.zip"
+    response = requests.get(eg_link, stream=True)
+    with tqdm.wrapattr(open(os.devnull, "wb"), "write",
+                       miniters=1, desc=eg_link.split('/')[-1],
+                       total=int(response.headers.get('content-length', 0))) as fout:
+        for chunk in response.iter_content(chunk_size=4096):
+            fout.write(chunk)
+
+**Custom callback**
+
+``tqdm`` is known for intelligently skipping unnecessary displays. To make a
+custom callback take advantage of this, simply use the return value of
+``update()``. This is set to ``True`` if a ``display()`` was triggered.
+
+.. code:: python
+
+    from tqdm.auto import tqdm as std_tqdm
+
+    def external_callback(*args, **kwargs):
+        ...
+
+    class TqdmExt(std_tqdm):
+        def update(self, n=1):
+            displayed = super().update(n)
+            if displayed:
+                external_callback(**self.format_dict)
+            return displayed
+
+``asyncio``
+~~~~~~~~~~~
+
+Note that ``break`` isn't currently caught by asynchronous iterators.
+This means that ``tqdm`` cannot clean up after itself in this case:
+
+.. code:: python
+
+    from tqdm.asyncio import tqdm
+
+    async for i in tqdm(range(9)):
+        if i == 2:
+            break
+
+Instead, either call ``pbar.close()`` manually or use the context manager syntax:
+
+.. code:: python
+
+    from tqdm.asyncio import tqdm
+
+    with tqdm(range(9)) as pbar:
+        async for i in pbar:
+            if i == 2:
+                break
+
+Pandas Integration
+~~~~~~~~~~~~~~~~~~
+
+Due to popular demand we've added support for ``pandas`` -- here's an example
+for ``DataFrame.progress_apply`` and ``DataFrameGroupBy.progress_apply``:
+
+.. code:: python
+
+    import pandas as pd
+    import numpy as np
+    from tqdm import tqdm
+
+    df = pd.DataFrame(np.random.randint(0, 100, (100000, 6)))
+
+    # Register `pandas.progress_apply` and `pandas.Series.map_apply` with `tqdm`
+    # (can use `tqdm.gui.tqdm`, `tqdm.notebook.tqdm`, optional kwargs, etc.)
+    tqdm.pandas(desc="my bar!")
+
+    # Now you can use `progress_apply` instead of `apply`
+    # and `progress_map` instead of `map`
+    df.progress_apply(lambda x: x**2)
+    # can also groupby:
+    # df.groupby(0).progress_apply(lambda x: x**2)
+
+In case you're interested in how this works (and how to modify it for your
+own callbacks), see the
+`examples <https://github.com/tqdm/tqdm/tree/master/examples>`__
+folder or import the module and run ``help()``.
+
+Keras Integration
+~~~~~~~~~~~~~~~~~
+
+A ``keras`` callback is also available:
+
+.. code:: python
+
+    from tqdm.keras import TqdmCallback
+
+    ...
+
+    model.fit(..., verbose=0, callbacks=[TqdmCallback()])
+
+Dask Integration
+~~~~~~~~~~~~~~~~
+
+A ``dask`` callback is also available:
+
+.. code:: python
+
+    from tqdm.dask import TqdmCallback
+
+    with TqdmCallback(desc="compute"):
+        ...
+        arr.compute()
+
+    # or use callback globally
+    cb = TqdmCallback(desc="global")
+    cb.register()
+    arr.compute()
+
+IPython/Jupyter Integration
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+IPython/Jupyter is supported via the ``tqdm.notebook`` submodule:
+
+.. code:: python
+
+    from tqdm.notebook import trange, tqdm
+    from time import sleep
+
+    for i in trange(3, desc='1st loop'):
+        for j in tqdm(range(100), desc='2nd loop'):
+            sleep(0.01)
+
+In addition to ``tqdm`` features, the submodule provides a native Jupyter
+widget (compatible with IPython v1-v4 and Jupyter), fully working nested bars
+and colour hints (blue: normal, green: completed, red: error/interrupt,
+light blue: no ETA); as demonstrated below.
+
+|Screenshot-Jupyter1|
+|Screenshot-Jupyter2|
+|Screenshot-Jupyter3|
+
+The ``notebook`` version supports percentage or pixels for overall width
+(e.g.: ``ncols='100%'`` or ``ncols='480px'``).
+
+It is also possible to let ``tqdm`` automatically choose between
+console or notebook versions by using the ``autonotebook`` submodule:
+
+.. code:: python
+
+    from tqdm.autonotebook import tqdm
+    tqdm.pandas()
+
+Note that this will issue a ``TqdmExperimentalWarning`` if run in a notebook
+since it is not meant to be possible to distinguish between ``jupyter notebook``
+and ``jupyter console``. Use ``auto`` instead of ``autonotebook`` to suppress
+this warning.
+
+Note that notebooks will display the bar in the cell where it was created.
+This may be a different cell from the one where it is used.
+If this is not desired, either
+
+- delay the creation of the bar to the cell where it must be displayed, or
+- create the bar with ``display=False``, and in a later cell call
+  ``display(bar.container)``:
+
+.. code:: python
+
+    from tqdm.notebook import tqdm
+    pbar = tqdm(..., display=False)
+
+.. code:: python
+
+    # different cell
+    display(pbar.container)
+
+The ``keras`` callback has a ``display()`` method which can be used likewise:
+
+.. code:: python
+
+    from tqdm.keras import TqdmCallback
+    cbk = TqdmCallback(display=False)
+
+.. code:: python
+
+    # different cell
+    cbk.display()
+    model.fit(..., verbose=0, callbacks=[cbk])
+
+Another possibility is to have a single bar (near the top of the notebook)
+which is constantly re-used (using ``reset()`` rather than ``close()``).
+For this reason, the notebook version (unlike the CLI version) does not
+automatically call ``close()`` upon ``Exception``.
+
+.. code:: python
+
+    from tqdm.notebook import tqdm
+    pbar = tqdm()
+
+.. code:: python
+
+    # different cell
+    iterable = range(100)
+    pbar.reset(total=len(iterable))  # initialise with new `total`
+    for i in iterable:
+        pbar.update()
+    pbar.refresh()  # force print final status but don't `close()`
+
+Custom Integration
+~~~~~~~~~~~~~~~~~~
+
+To change the default arguments (such as making ``dynamic_ncols=True``),
+simply use built-in Python magic:
+
+.. code:: python
+
+    from functools import partial
+    from tqdm import tqdm as std_tqdm
+    tqdm = partial(std_tqdm, dynamic_ncols=True)
+
+For further customisation,
+``tqdm`` may be inherited from to create custom callbacks (as with the
+``TqdmUpTo`` example `above <#hooks-and-callbacks>`__) or for custom frontends
+(e.g. GUIs such as notebook or plotting packages). In the latter case:
+
+1. ``def __init__()`` to call ``super().__init__(..., gui=True)`` to disable
+   terminal ``status_printer`` creation.
+2. Redefine: ``close()``, ``clear()``, ``display()``.
+
+Consider overloading ``display()`` to use e.g.
+``self.frontend(**self.format_dict)`` instead of ``self.sp(repr(self))``.
+
+Some submodule examples of inheritance:
+
+- `tqdm/notebook.py <https://github.com/tqdm/tqdm/blob/master/tqdm/notebook.py>`__
+- `tqdm/gui.py <https://github.com/tqdm/tqdm/blob/master/tqdm/gui.py>`__
+- `tqdm/tk.py <https://github.com/tqdm/tqdm/blob/master/tqdm/tk.py>`__
+- `tqdm/contrib/slack.py <https://github.com/tqdm/tqdm/blob/master/tqdm/contrib/slack.py>`__
+- `tqdm/contrib/discord.py <https://github.com/tqdm/tqdm/blob/master/tqdm/contrib/discord.py>`__
+- `tqdm/contrib/telegram.py <https://github.com/tqdm/tqdm/blob/master/tqdm/contrib/telegram.py>`__
+
+Dynamic Monitor/Meter
+~~~~~~~~~~~~~~~~~~~~~
+
+You can use a ``tqdm`` as a meter which is not monotonically increasing.
+This could be because ``n`` decreases (e.g. a CPU usage monitor) or ``total``
+changes.
+
+One example would be recursively searching for files. The ``total`` is the
+number of objects found so far, while ``n`` is the number of those objects which
+are files (rather than folders):
+
+.. code:: python
+
+    from tqdm import tqdm
+    import os.path
+
+    def find_files_recursively(path, show_progress=True):
+        files = []
+        # total=1 assumes `path` is a file
+        t = tqdm(total=1, unit="file", disable=not show_progress)
+        if not os.path.exists(path):
+            raise IOError("Cannot find:" + path)
+
+        def append_found_file(f):
+            files.append(f)
+            t.update()
+
+        def list_found_dir(path):
+            """returns os.listdir(path) assuming os.path.isdir(path)"""
+            listing = os.listdir(path)
+            # subtract 1 since a "file" we found was actually this directory
+            t.total += len(listing) - 1
+            # fancy way to give info without forcing a refresh
+            t.set_postfix(dir=path[-10:], refresh=False)
+            t.update(0)  # may trigger a refresh
+            return listing
+
+        def recursively_search(path):
+            if os.path.isdir(path):
+                for f in list_found_dir(path):
+                    recursively_search(os.path.join(path, f))
+            else:
+                append_found_file(path)
+
+        recursively_search(path)
+        t.set_postfix(dir=path)
+        t.close()
+        return files
+
+Using ``update(0)`` is a handy way to let ``tqdm`` decide when to trigger a
+display refresh to avoid console spamming.
+
+Writing messages
+~~~~~~~~~~~~~~~~
+
+This is a work in progress (see
+`#737 <https://github.com/tqdm/tqdm/issues/737>`__).
+
+Since ``tqdm`` uses a simple printing mechanism to display progress bars,
+you should not write any message in the terminal using ``print()`` while
+a progressbar is open.
+
+To write messages in the terminal without any collision with ``tqdm`` bar
+display, a ``.write()`` method is provided:
+
+.. code:: python
+
+    from tqdm.auto import tqdm, trange
+    from time import sleep
+
+    bar = trange(10)
+    for i in bar:
+        # Print using tqdm class method .write()
+        sleep(0.1)
+        if not (i % 3):
+            tqdm.write("Done task %i" % i)
+        # Can also use bar.write()
+
+By default, this will print to standard output ``sys.stdout``. but you can
+specify any file-like object using the ``file`` argument. For example, this
+can be used to redirect the messages writing to a log file or class.
+
+Redirecting writing
+~~~~~~~~~~~~~~~~~~~
+
+If using a library that can print messages to the console, editing the library
+by  replacing ``print()`` with ``tqdm.write()`` may not be desirable.
+In that case, redirecting ``sys.stdout`` to ``tqdm.write()`` is an option.
+
+To redirect ``sys.stdout``, create a file-like class that will write
+any input string to ``tqdm.write()``, and supply the arguments
+``file=sys.stdout, dynamic_ncols=True``.
+
+A reusable canonical example is given below:
+
+.. code:: python
+
+    from time import sleep
+    import contextlib
+    import sys
+    from tqdm import tqdm
+    from tqdm.contrib import DummyTqdmFile
+
+
+    @contextlib.contextmanager
+    def std_out_err_redirect_tqdm():
+        orig_out_err = sys.stdout, sys.stderr
+        try:
+            sys.stdout, sys.stderr = map(DummyTqdmFile, orig_out_err)
+            yield orig_out_err[0]
+        # Relay exceptions
+        except Exception as exc:
+            raise exc
+        # Always restore sys.stdout/err if necessary
+        finally:
+            sys.stdout, sys.stderr = orig_out_err
+
+    def some_fun(i):
+        print("Fee, fi, fo,".split()[i])
+
+    # Redirect stdout to tqdm.write() (don't forget the `as save_stdout`)
+    with std_out_err_redirect_tqdm() as orig_stdout:
+        # tqdm needs the original stdout
+        # and dynamic_ncols=True to autodetect console width
+        for i in tqdm(range(3), file=orig_stdout, dynamic_ncols=True):
+            sleep(.5)
+            some_fun(i)
+
+    # After the `with`, printing is restored
+    print("Done!")
+
+Redirecting ``logging``
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Similar to ``sys.stdout``/``sys.stderr`` as detailed above, console ``logging``
+may also be redirected to ``tqdm.write()``.
+
+Warning: if also redirecting ``sys.stdout``/``sys.stderr``, make sure to
+redirect ``logging`` first if needed.
+
+Helper methods are available in ``tqdm.contrib.logging``. For example:
+
+.. code:: python
+
+    import logging
+    from tqdm import trange
+    from tqdm.contrib.logging import logging_redirect_tqdm
+
+    LOG = logging.getLogger(__name__)
+
+    if __name__ == '__main__':
+        logging.basicConfig(level=logging.INFO)
+        with logging_redirect_tqdm():
+            for i in trange(9):
+                if i == 4:
+                    LOG.info("console logging redirected to `tqdm.write()`")
+        # logging restored
+
+Monitoring thread, intervals and miniters
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+``tqdm`` implements a few tricks to increase efficiency and reduce overhead.
+
+- Avoid unnecessary frequent bar refreshing: ``mininterval`` defines how long
+  to wait between each refresh. ``tqdm`` always gets updated in the background,
+  but it will display only every ``mininterval``.
+- Reduce number of calls to check system clock/time.
+- ``mininterval`` is more intuitive to configure than ``miniters``.
+  A clever adjustment system ``dynamic_miniters`` will automatically adjust
+  ``miniters`` to the amount of iterations that fit into time ``mininterval``.
+  Essentially, ``tqdm`` will check if it's time to print without actually
+  checking time. This behaviour can be still be bypassed by manually setting
+  ``miniters``.
+
+However, consider a case with a combination of fast and slow iterations.
+After a few fast iterations, ``dynamic_miniters`` will set ``miniters`` to a
+large number. When iteration rate subsequently slows, ``miniters`` will
+remain large and thus reduce display update frequency. To address this:
+
+- ``maxinterval`` defines the maximum time between display refreshes.
+  A concurrent monitoring thread checks for overdue updates and forces one
+  where necessary.
+
+The monitoring thread should not have a noticeable overhead, and guarantees
+updates at least every 10 seconds by default.
+This value can be directly changed by setting the ``monitor_interval`` of
+any ``tqdm`` instance (i.e. ``t = tqdm.tqdm(...); t.monitor_interval = 2``).
+The monitor thread may be disabled application-wide by setting
+``tqdm.tqdm.monitor_interval = 0`` before instantiation of any ``tqdm`` bar.
+
+
+Merch
+-----
+
+You can buy `tqdm branded merch <https://tqdm.github.io/merch>`__ now!
+
+Contributions
+-------------
+
+|GitHub-Commits| |GitHub-Issues| |GitHub-PRs| |OpenHub-Status| |GitHub-Contributions| |CII Best Practices|
+
+All source code is hosted on `GitHub <https://github.com/tqdm/tqdm>`__.
+Contributions are welcome.
+
+See the
+`CONTRIBUTING <https://github.com/tqdm/tqdm/blob/master/CONTRIBUTING.md>`__
+file for more information.
+
+Developers who have made significant contributions, ranked by *SLoC*
+(surviving lines of code,
+`git fame <https://github.com/casperdcl/git-fame>`__ ``-wMC --excl '\.(png|gif|jpg)$'``),
+are:
+
+==================== ======================================================== ==== ================================
+Name                 ID                                                       SLoC Notes
+==================== ======================================================== ==== ================================
+Casper da Costa-Luis `casperdcl <https://github.com/casperdcl>`__             ~80% primary maintainer |Gift-Casper|
+Stephen Larroque     `lrq3000 <https://github.com/lrq3000>`__                 ~9%  team member
+Martin Zugnoni       `martinzugnoni <https://github.com/martinzugnoni>`__     ~3%
+Daniel Ecer          `de-code <https://github.com/de-code>`__                 ~2%
+Richard Sheridan     `richardsheridan <https://github.com/richardsheridan>`__ ~1%
+Guangshuo Chen       `chengs <https://github.com/chengs>`__                   ~1%
+Helio Machado        `0x2b3bfa0 <https://github.com/0x2b3bfa0>`__             ~1%
+Kyle Altendorf       `altendky <https://github.com/altendky>`__               <1%
+Noam Yorav-Raphael   `noamraph <https://github.com/noamraph>`__               <1%  original author
+Matthew Stevens      `mjstevens777 <https://github.com/mjstevens777>`__       <1%
+Hadrien Mary         `hadim <https://github.com/hadim>`__                     <1%  team member
+Mikhail Korobov      `kmike <https://github.com/kmike>`__                     <1%  team member
+==================== ======================================================== ==== ================================
+
+Ports to Other Languages
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+A list is available on
+`this wiki page <https://github.com/tqdm/tqdm/wiki/tqdm-ports>`__.
+
+
+LICENCE
+-------
+
+Open Source (OSI approved): |LICENCE|
+
+Citation information: |DOI|
+
+|README-Hits| (Since 19 May 2016)
+
+.. |Logo| image:: https://tqdm.github.io/img/logo.gif
+.. |Screenshot| image:: https://tqdm.github.io/img/tqdm.gif
+.. |Video| image:: https://tqdm.github.io/img/video.jpg
+   :target: https://tqdm.github.io/video
+.. |Slides| image:: https://tqdm.github.io/img/slides.jpg
+   :target: https://tqdm.github.io/PyData2019/slides.html
+.. |Merch| image:: https://tqdm.github.io/img/merch.jpg
+   :target: https://tqdm.github.io/merch
+.. |Build-Status| image:: https://img.shields.io/github/actions/workflow/status/tqdm/tqdm/test.yml?branch=master&label=tqdm&logo=GitHub
+   :target: https://github.com/tqdm/tqdm/actions/workflows/test.yml
+.. |Coverage-Status| image:: https://img.shields.io/coveralls/github/tqdm/tqdm/master?logo=coveralls
+   :target: https://coveralls.io/github/tqdm/tqdm
+.. |Branch-Coverage-Status| image:: https://codecov.io/gh/tqdm/tqdm/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/tqdm/tqdm
+.. |Codacy-Grade| image:: https://app.codacy.com/project/badge/Grade/3f965571598f44549c7818f29cdcf177
+   :target: https://www.codacy.com/gh/tqdm/tqdm/dashboard
+.. |CII Best Practices| image:: https://bestpractices.coreinfrastructure.org/projects/3264/badge
+   :target: https://bestpractices.coreinfrastructure.org/projects/3264
+.. |GitHub-Status| image:: https://img.shields.io/github/tag/tqdm/tqdm.svg?maxAge=86400&logo=github&logoColor=white
+   :target: https://github.com/tqdm/tqdm/releases
+.. |GitHub-Forks| image:: https://img.shields.io/github/forks/tqdm/tqdm.svg?logo=github&logoColor=white
+   :target: https://github.com/tqdm/tqdm/network
+.. |GitHub-Stars| image:: https://img.shields.io/github/stars/tqdm/tqdm.svg?logo=github&logoColor=white
+   :target: https://github.com/tqdm/tqdm/stargazers
+.. |GitHub-Commits| image:: https://img.shields.io/github/commit-activity/y/tqdm/tqdm.svg?logo=git&logoColor=white
+   :target: https://github.com/tqdm/tqdm/graphs/commit-activity
+.. |GitHub-Issues| image:: https://img.shields.io/github/issues-closed/tqdm/tqdm.svg?logo=github&logoColor=white
+   :target: https://github.com/tqdm/tqdm/issues?q=
+.. |GitHub-PRs| image:: https://img.shields.io/github/issues-pr-closed/tqdm/tqdm.svg?logo=github&logoColor=white
+   :target: https://github.com/tqdm/tqdm/pulls
+.. |GitHub-Contributions| image:: https://img.shields.io/github/contributors/tqdm/tqdm.svg?logo=github&logoColor=white
+   :target: https://github.com/tqdm/tqdm/graphs/contributors
+.. |GitHub-Updated| image:: https://img.shields.io/github/last-commit/tqdm/tqdm/master.svg?logo=github&logoColor=white&label=pushed
+   :target: https://github.com/tqdm/tqdm/pulse
+.. |Gift-Casper| image:: https://img.shields.io/badge/dynamic/json.svg?color=ff69b4&label=gifts%20received&prefix=%C2%A3&query=%24..sum&url=https%3A%2F%2Fcaspersci.uk.to%2Fgifts.json
+   :target: https://cdcl.ml/sponsor
+.. |Versions| image:: https://img.shields.io/pypi/v/tqdm.svg
+   :target: https://tqdm.github.io/releases
+.. |PyPI-Downloads| image:: https://img.shields.io/pypi/dm/tqdm.svg?label=pypi%20downloads&logo=PyPI&logoColor=white
+   :target: https://pepy.tech/project/tqdm
+.. |Py-Versions| image:: https://img.shields.io/pypi/pyversions/tqdm.svg?logo=python&logoColor=white
+   :target: https://pypi.org/project/tqdm
+.. |Conda-Forge-Status| image:: https://img.shields.io/conda/v/conda-forge/tqdm.svg?label=conda-forge&logo=conda-forge
+   :target: https://anaconda.org/conda-forge/tqdm
+.. |Snapcraft| image:: https://img.shields.io/badge/snap-install-82BEA0.svg?logo=snapcraft
+   :target: https://snapcraft.io/tqdm
+.. |Docker| image:: https://img.shields.io/badge/docker-pull-blue.svg?logo=docker&logoColor=white
+   :target: https://hub.docker.com/r/tqdm/tqdm
+.. |Libraries-Rank| image:: https://img.shields.io/librariesio/sourcerank/pypi/tqdm.svg?logo=koding&logoColor=white
+   :target: https://libraries.io/pypi/tqdm
+.. |Libraries-Dependents| image:: https://img.shields.io/librariesio/dependent-repos/pypi/tqdm.svg?logo=koding&logoColor=white
+    :target: https://github.com/tqdm/tqdm/network/dependents
+.. |OpenHub-Status| image:: https://www.openhub.net/p/tqdm/widgets/project_thin_badge?format=gif
+   :target: https://www.openhub.net/p/tqdm?ref=Thin+badge
+.. |awesome-python| image:: https://awesome.re/mentioned-badge.svg
+   :target: https://github.com/vinta/awesome-python
+.. |LICENCE| image:: https://img.shields.io/pypi/l/tqdm.svg
+   :target: https://raw.githubusercontent.com/tqdm/tqdm/master/LICENCE
+.. |DOI| image:: https://img.shields.io/badge/DOI-10.5281/zenodo.595120-blue.svg
+   :target: https://doi.org/10.5281/zenodo.595120
+.. |binder-demo| image:: https://mybinder.org/badge_logo.svg
+   :target: https://mybinder.org/v2/gh/tqdm/tqdm/master?filepath=DEMO.ipynb
+.. |Screenshot-Jupyter1| image:: https://tqdm.github.io/img/jupyter-1.gif
+.. |Screenshot-Jupyter2| image:: https://tqdm.github.io/img/jupyter-2.gif
+.. |Screenshot-Jupyter3| image:: https://tqdm.github.io/img/jupyter-3.gif
+.. |README-Hits| image:: https://caspersci.uk.to/cgi-bin/hits.cgi?q=tqdm&style=social&r=https://github.com/tqdm/tqdm&l=https://tqdm.github.io/img/favicon.png&f=https://tqdm.github.io/img/logo.gif
+   :target: https://caspersci.uk.to/cgi-bin/hits.cgi?q=tqdm&a=plot&r=https://github.com/tqdm/tqdm&l=https://tqdm.github.io/img/favicon.png&f=https://tqdm.github.io/img/logo.gif&style=social

.cache/pip/http-v2/f/c/a/5/b/fca5b18fd877930924e4c3ed44a7de4862861d131c1248697b107213.body

@@ -0,0 +1,420 @@
+Metadata-Version: 2.1
+Name: frozenlist
+Version: 1.4.1
+Summary: A list-like structure which implements collections.abc.MutableSequence
+Home-page: https://github.com/aio-libs/frozenlist
+Maintainer: aiohttp team <[email protected]>
+Maintainer-email: [email protected]
+License: Apache 2
+Project-URL: Chat: Matrix, https://matrix.to/#/#aio-libs:matrix.org
+Project-URL: Chat: Matrix Space, https://matrix.to/#/#aio-libs-space:matrix.org
+Project-URL: CI: Github Actions, https://github.com/aio-libs/frozenlist/actions
+Project-URL: Code of Conduct, https://github.com/aio-libs/.github/blob/master/CODE_OF_CONDUCT.md
+Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/frozenlist
+Project-URL: Docs: Changelog, https://github.com/aio-libs/frozenlist/blob/master/CHANGES.rst#changelog
+Project-URL: Docs: RTD, https://frozenlist.aio-libs.org
+Project-URL: GitHub: issues, https://github.com/aio-libs/frozenlist/issues
+Project-URL: GitHub: repo, https://github.com/aio-libs/frozenlist
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+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 :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+frozenlist
+==========
+
+.. image:: https://github.com/aio-libs/frozenlist/workflows/CI/badge.svg
+   :target: https://github.com/aio-libs/frozenlist/actions
+   :alt: GitHub status for master branch
+
+.. image:: https://codecov.io/gh/aio-libs/frozenlist/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/aio-libs/frozenlist
+   :alt: codecov.io status for master branch
+
+.. image:: https://img.shields.io/pypi/v/frozenlist.svg?logo=Python&logoColor=white
+   :target: https://pypi.org/project/frozenlist
+   :alt: frozenlist @ PyPI
+
+.. image:: https://readthedocs.org/projects/frozenlist/badge/?version=latest
+   :target: https://frozenlist.aio-libs.org
+   :alt: Read The Docs build status badge
+
+.. image:: https://img.shields.io/matrix/aio-libs:matrix.org?label=Discuss%20on%20Matrix%20at%20%23aio-libs%3Amatrix.org&logo=matrix&server_fqdn=matrix.org&style=flat
+   :target: https://matrix.to/#/%23aio-libs:matrix.org
+   :alt: Matrix Room — #aio-libs:matrix.org
+
+.. image:: https://img.shields.io/matrix/aio-libs-space:matrix.org?label=Discuss%20on%20Matrix%20at%20%23aio-libs-space%3Amatrix.org&logo=matrix&server_fqdn=matrix.org&style=flat
+   :target: https://matrix.to/#/%23aio-libs-space:matrix.org
+   :alt: Matrix Space — #aio-libs-space:matrix.org
+
+Introduction
+------------
+
+``frozenlist.FrozenList`` is a list-like structure which implements
+``collections.abc.MutableSequence``. The list is *mutable* until ``FrozenList.freeze``
+is called, after which list modifications raise ``RuntimeError``:
+
+
+>>> from frozenlist import FrozenList
+>>> fl = FrozenList([17, 42])
+>>> fl.append('spam')
+>>> fl.append('Vikings')
+>>> fl
+<FrozenList(frozen=False, [17, 42, 'spam', 'Vikings'])>
+>>> fl.freeze()
+>>> fl
+<FrozenList(frozen=True, [17, 42, 'spam', 'Vikings'])>
+>>> fl.frozen
+True
+>>> fl.append("Monty")
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "frozenlist/_frozenlist.pyx", line 97, in frozenlist._frozenlist.FrozenList.append
+    self._check_frozen()
+  File "frozenlist/_frozenlist.pyx", line 19, in frozenlist._frozenlist.FrozenList._check_frozen
+    raise RuntimeError("Cannot modify frozen list.")
+RuntimeError: Cannot modify frozen list.
+
+
+FrozenList is also hashable, but only when frozen. Otherwise it also throws a RuntimeError:
+
+
+>>> fl = FrozenList([17, 42, 'spam'])
+>>> hash(fl)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "frozenlist/_frozenlist.pyx", line 111, in frozenlist._frozenlist.FrozenList.__hash__
+    raise RuntimeError("Cannot hash unfrozen list.")
+RuntimeError: Cannot hash unfrozen list.
+>>> fl.freeze()
+>>> hash(fl)
+3713081631934410656
+>>> dictionary = {fl: 'Vikings'} # frozen fl can be a dict key
+>>> dictionary
+{<FrozenList(frozen=True, [1, 2])>: 'Vikings'}
+
+
+Installation
+------------
+
+::
+
+   $ pip install frozenlist
+
+The library requires Python 3.8 or newer.
+
+
+Documentation
+-------------
+
+https://frozenlist.aio-libs.org
+
+Communication channels
+----------------------
+
+We have a *Matrix Space* `#aio-libs-space:matrix.org
+<https://matrix.to/#/%23aio-libs-space:matrix.org>`_ which is
+also accessible via Gitter.
+
+Requirements
+------------
+
+- Python >= 3.8
+
+License
+-------
+
+``frozenlist`` 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/frozenlist/issues>`_ if you have found a bug
+or have some suggestions to improve the library.
+
+.. _GitHub: https://github.com/aio-libs/frozenlist
+
+=========
+Changelog
+=========
+
+..
+    You should *NOT* be adding new change log entries to this file, this
+    file is managed by towncrier. You *may* edit previous change logs to
+    fix problems like typo corrections or such.
+    To add a new change log entry, please see
+    https://pip.pypa.io/en/latest/development/contributing/#news-entries
+    we named the news folder "changes".
+
+    WARNING: Don't drop the next directive!
+
+.. towncrier release notes start
+
+1.4.1 (2023-12-15)
+==================
+
+Packaging updates and notes for downstreams
+-------------------------------------------
+
+- Declared Python 3.12 and PyPy 3.8-3.10 supported officially
+  in the distribution package metadata.
+
+
+  *Related issues and pull requests on GitHub:*
+  `#553 <https://github.com/aio-libs/yarl/issues/553>`__.
+
+- Replaced the packaging is replaced from an old-fashioned ``setup.py`` to an
+  in-tree `PEP 517 <https://peps.python.org/pep-517>`__ build backend -- by `@webknjaz <https://github.com/sponsors/webknjaz>`__.
+
+  Whenever the end-users or downstream packagers need to build ``frozenlist``
+  from source (a Git checkout or an sdist), they may pass a ``config_settings``
+  flag ``pure-python``. If this flag is not set, a C-extension will be built
+  and included into the distribution.
+
+  Here is how this can be done with ``pip``:
+
+  .. code-block:: console
+
+      $ python3 -m pip install . --config-settings=pure-python=
+
+  This will also work with ``-e | --editable``.
+
+  The same can be achieved via ``pypa/build``:
+
+  .. code-block:: console
+
+      $ python3 -m build --config-setting=pure-python=
+
+  Adding ``-w | --wheel`` can force ``pypa/build`` produce a wheel from source
+  directly, as opposed to building an ``sdist`` and then building from it.
+
+
+  *Related issues and pull requests on GitHub:*
+  `#560 <https://github.com/aio-libs/yarl/issues/560>`__.
+
+
+Contributor-facing changes
+--------------------------
+
+- It is now possible to request line tracing in Cython builds using the
+  ``with-cython-tracing`` `PEP 517 <https://peps.python.org/pep-517>`__ config setting
+  -- `@webknjaz <https://github.com/sponsors/webknjaz>`__.
+
+  This can be used in CI and development environment to measure coverage
+  on Cython modules, but is not normally useful to the end-users or
+  downstream packagers.
+
+  Here's a usage example:
+
+  .. code-block:: console
+
+      $ python3 -Im pip install . --config-settings=with-cython-tracing=true
+
+  For editable installs, this setting is on by default. Otherwise, it's
+  off unless requested explicitly.
+
+  The following produces C-files required for the Cython coverage
+  plugin to map the measurements back to the PYX-files:
+
+  .. code-block:: console
+
+      $ python -Im pip install -e .
+
+  Alternatively, the ``FROZENLIST_CYTHON_TRACING=1`` environment variable
+  can be set to do the same as the `PEP 517 <https://peps.python.org/pep-517>`__ config setting.
+
+
+  *Related issues and pull requests on GitHub:*
+  `#560 <https://github.com/aio-libs/yarl/issues/560>`__.
+
+- Coverage collection has been implemented for the Cython modules
+  -- by `@webknjaz <https://github.com/sponsors/webknjaz>`__.
+
+  It will also be reported to Codecov from any non-release CI jobs.
+
+
+  *Related issues and pull requests on GitHub:*
+  `#561 <https://github.com/aio-libs/yarl/issues/561>`__.
+
+- A step-by-step ``Release Guide`` guide has
+  been added, describing how to release *frozenlist* -- by `@webknjaz <https://github.com/sponsors/webknjaz>`__.
+
+  This is primarily targeting the maintainers.
+
+
+  *Related issues and pull requests on GitHub:*
+  `#563 <https://github.com/aio-libs/yarl/issues/563>`__.
+
+- Detailed ``Contributing Guidelines`` on
+  authoring the changelog fragments have been published in the
+  documentation -- by `@webknjaz <https://github.com/sponsors/webknjaz>`__.
+
+
+  *Related issues and pull requests on GitHub:*
+  `#564 <https://github.com/aio-libs/yarl/issues/564>`__.
+
+
+----
+
+
+1.4.0 (2023-07-12)
+==================
+
+The published source distribution package became buildable
+under Python 3.12.
+
+
+----
+
+
+Bugfixes
+--------
+
+- Removed an unused ``typing.Tuple`` import
+  `#411 <https://github.com/aio-libs/frozenlist/issues/411>`_
+
+
+Deprecations and Removals
+-------------------------
+
+- Dropped Python 3.7 support.
+  `#413 <https://github.com/aio-libs/frozenlist/issues/413>`_
+
+
+Misc
+----
+
+- `#410 <https://github.com/aio-libs/frozenlist/issues/410>`_, `#433 <https://github.com/aio-libs/frozenlist/issues/433>`_
+
+
+----
+
+
+1.3.3 (2022-11-08)
+==================
+
+- Fixed CI runs when creating a new release, where new towncrier versions
+  fail when the current version section is already present.
+
+
+----
+
+
+1.3.2 (2022-11-08)
+==================
+
+Misc
+----
+
+- Updated the CI runs to better check for test results and to avoid deprecated syntax. `#327 <https://github.com/aio-libs/frozenlist/issues/327>`_
+
+
+----
+
+
+1.3.1 (2022-08-02)
+==================
+
+The published source distribution package became buildable
+under Python 3.11.
+
+
+----
+
+
+1.3.0 (2022-01-18)
+==================
+
+Bugfixes
+--------
+
+- Do not install C sources with binary distributions.
+  `#250 <https://github.com/aio-libs/frozenlist/issues/250>`_
+
+
+Deprecations and Removals
+-------------------------
+
+- Dropped Python 3.6 support
+  `#274 <https://github.com/aio-libs/frozenlist/issues/274>`_
+
+
+----
+
+
+1.2.0 (2021-10-16)
+==================
+
+Features
+--------
+
+- ``FrozenList`` now supports being used as a generic type as per PEP 585, e.g. ``frozen_int_list: FrozenList[int]`` (requires Python 3.9 or newer).
+  `#172 <https://github.com/aio-libs/frozenlist/issues/172>`_
+- Added support for Python 3.10.
+  `#227 <https://github.com/aio-libs/frozenlist/issues/227>`_
+- Started shipping platform-specific wheels with the ``musl`` tag targeting typical Alpine Linux runtimes.
+  `#227 <https://github.com/aio-libs/frozenlist/issues/227>`_
+- Started shipping platform-specific arm64 wheels for Apple Silicon.
+  `#227 <https://github.com/aio-libs/frozenlist/issues/227>`_
+
+
+----
+
+
+1.1.1 (2020-11-14)
+==================
+
+Bugfixes
+--------
+
+- Provide x86 Windows wheels.
+  `#169 <https://github.com/aio-libs/frozenlist/issues/169>`_
+
+
+----
+
+
+1.1.0 (2020-10-13)
+==================
+
+Features
+--------
+
+- Add support for hashing of a frozen list.
+  `#136 <https://github.com/aio-libs/frozenlist/issues/136>`_
+
+- Support Python 3.8 and 3.9.
+
+- Provide wheels for ``aarch64``, ``i686``, ``ppc64le``, ``s390x`` architectures on
+  Linux as well as ``x86_64``.
+
+
+----
+
+
+1.0.0 (2019-11-09)
+==================
+
+Deprecations and Removals
+-------------------------
+
+- Dropped support for Python 3.5; only 3.6, 3.7 and 3.8 are supported going forward.
+  `#24 <https://github.com/aio-libs/frozenlist/issues/24>`_

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

@@ -0,0 +1,14 @@
+{"time":"2024-09-26T05:52:22.315197362Z","level":"INFO","msg":"started logging, with flags","port-filename":"/tmp/tmp0irn9n95/port-986.txt","pid":986,"debug":false,"disable-analytics":false}
+{"time":"2024-09-26T05:52:22.315233622Z","level":"INFO","msg":"FeatureState","shutdownOnParentExitEnabled":false}
+{"time":"2024-09-26T05:52:22.316073319Z","level":"INFO","msg":"Will exit if parent process dies.","ppid":986}
+{"time":"2024-09-26T05:52:22.316064076Z","level":"INFO","msg":"server is running","addr":{"IP":"127.0.0.1","Port":41193,"Zone":""}}
+{"time":"2024-09-26T05:52:22.505125081Z","level":"INFO","msg":"created new connection","id":"127.0.0.1:42070"}
+{"time":"2024-09-26T05:52:22.951875072Z","level":"INFO","msg":"connection init received","streamId":"14kj2390","id":"127.0.0.1:42070"}
+{"time":"2024-09-26T05:52:22.952304043Z","level":"ERROR","msg":"error creating symlink","error":"symlink /root/.cache/wandb/logs/core-debug-20240926_055222.log /root/wandb/run-20240926_055222-14kj2390/logs/debug-core.log: file exists"}
+{"time":"2024-09-26T05:52:22.955991404Z","level":"INFO","msg":"connection init completed","streamId":"14kj2390","id":"127.0.0.1:42070"}
+{"time":"2024-09-26T12:39:40.244212691Z","level":"INFO","msg":"handle finish received","streamId":"14kj2390","id":"127.0.0.1:42070"}
+{"time":"2024-09-26T12:39:41.460220703Z","level":"INFO","msg":"connection: teardown","id":"127.0.0.1:42070"}
+{"time":"2024-09-26T12:39:41.460275234Z","level":"INFO","msg":"server is shutting down"}
+{"time":"2024-09-26T12:39:41.460350917Z","level":"INFO","msg":"closed connection","id":"127.0.0.1:42070"}
+{"time":"2024-09-26T12:39:41.460369816Z","level":"INFO","msg":"connection closed","id":"127.0.0.1:42070"}
+{"time":"2024-09-26T12:39:41.460376796Z","level":"INFO","msg":"server is closed"}

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

@@ -0,0 +1,12 @@
+{"time":"2024-09-26T19:28:31.323728841Z","level":"INFO","msg":"started logging, with flags","port-filename":"/tmp/tmp9l51n5u0/port-7447.txt","pid":7447,"debug":false,"disable-analytics":false}
+{"time":"2024-09-26T19:28:31.324125995Z","level":"INFO","msg":"FeatureState","shutdownOnParentExitEnabled":false}
+{"time":"2024-09-26T19:28:31.324781916Z","level":"INFO","msg":"Will exit if parent process dies.","ppid":7447}
+{"time":"2024-09-26T19:28:31.324772272Z","level":"INFO","msg":"server is running","addr":{"IP":"127.0.0.1","Port":44021,"Zone":""}}
+{"time":"2024-09-26T19:28:31.519883511Z","level":"INFO","msg":"created new connection","id":"127.0.0.1:49154"}
+{"time":"2024-09-26T19:28:31.945023432Z","level":"INFO","msg":"connection init received","streamId":"378lr5yg","id":"127.0.0.1:49154"}
+{"time":"2024-09-26T19:28:31.945242119Z","level":"ERROR","msg":"error creating symlink","error":"symlink /root/.cache/wandb/logs/core-debug-20240926_192831.log /root/wandb/run-20240926_192831-378lr5yg/logs/debug-core.log: file exists"}
+{"time":"2024-09-26T19:28:31.947286776Z","level":"INFO","msg":"connection init completed","streamId":"378lr5yg","id":"127.0.0.1:49154"}
+{"time":"2024-09-27T02:14:23.053318256Z","level":"INFO","msg":"handle finish received","streamId":"378lr5yg","id":"127.0.0.1:49154"}
+{"time":"2024-09-27T02:14:23.674128558Z","level":"INFO","msg":"connection init received","streamId":"clesd0p8","id":"127.0.0.1:49154"}
+{"time":"2024-09-27T02:14:23.674521506Z","level":"ERROR","msg":"error creating symlink","error":"symlink /root/.cache/wandb/logs/core-debug-20240926_192831.log /root/wandb/run-20240927_021423-clesd0p8/logs/debug-core.log: file exists"}
+{"time":"2024-09-27T02:14:23.677325569Z","level":"INFO","msg":"connection init completed","streamId":"clesd0p8","id":"127.0.0.1:49154"}

.jupyter/jupyter_nbconvert_config.json

@@ -0,0 +1,13 @@
+{
+  "version": 1,
+  "Exporter": {
+    "extra_template_paths": [
+      ".",
+      "/usr/local/lib/python3.10/dist-packages/jupyter_contrib_nbextensions/templates"
+    ],
+    "preprocessors": [
+      "jupyter_contrib_nbextensions.nbconvert_support.CodeFoldingPreprocessor",
+      "jupyter_contrib_nbextensions.nbconvert_support.PyMarkdownPreprocessor"
+    ]
+  }
+}

.jupyter/jupyter_notebook_config.json

@@ -0,0 +1,7 @@
+{
+  "NotebookApp": {
+    "nbserver_extensions": {
+      "jupyter_nbextensions_configurator": true
+    }
+  }
+}

.jupyter/lab/workspaces/default-37a8.jupyterlab-workspace

@@ -0,0 +1 @@
+{"data":{"layout-restorer:data":{"main":{"dock":{"type":"tab-area","currentIndex":0,"widgets":["terminal:1","editor:train.py","editor:model.py","terminal:3"]},"current":"terminal:1"},"down":{"size":0,"widgets":[]},"left":{"collapsed":false,"visible":true,"current":"filebrowser","widgets":["filebrowser","running-sessions","@jupyterlab/toc:plugin","extensionmanager.main-view"],"widgetStates":{"jp-running-sessions":{"sizes":[0.25,0.25,0.25,0.25],"expansionStates":[false,false,false,false]},"extensionmanager.main-view":{"sizes":[0.3333333333333333,0.3333333333333333,0.3333333333333333],"expansionStates":[false,false,false]}}},"right":{"collapsed":true,"visible":true,"widgets":["jp-property-inspector","debugger-sidebar"],"widgetStates":{"jp-debugger-sidebar":{"sizes":[0.2,0.2,0.2,0.2,0.2],"expansionStates":[false,false,false,false,false]}}},"relativeSizes":[0.2099370188943317,0.7900629811056683,0],"top":{"simpleVisibility":true}},"terminal:1":{"data":{"name":"1"}},"terminal:3":{"data":{"name":"3"}},"file-browser-filebrowser:cwd":{"path":""},"editor:train.py":{"data":{"path":"train.py","factory":"Editor"}},"editor:model.py":{"data":{"path":"model.py","factory":"Editor"}}},"metadata":{"id":"default"}}

.jupyter/migrated

@@ -0,0 +1 @@
+2024-09-26T05:25:08.359004+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/addbefore.yaml

@@ -0,0 +1,7 @@
+Type: IPython Notebook Extension
+Name: AddBefore
+Description: This extension enables the Add Cell before button (from iPython 1)
+Link: readme.md
+Icon: icon.png
+Main: main.js
+Compatibility: 4.x

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

@@ -0,0 +1,42 @@
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'base/js/events',
+    'base/js/utils',
+], function(Jupyter, $, requirejs, events, configmod, utils) {
+    "use strict";
+
+    var load_extension = function() {
+             Jupyter.toolbar.add_buttons_group([
+                 Jupyter.keyboard_manager.actions.register ({
+                      'help'   : 'Insert Cell Above',
+                      'icon'   : 'fa-arrow-circle-o-up',
+                      'handler': function () {
+                                                    Jupyter.notebook.insert_cell_above('code');
+                                                    Jupyter.notebook.select_prev();
+                                                    Jupyter.notebook.focus_cell();
+                      }
+                 }, 'insert-cell-above', 'addbefore'),
+                 Jupyter.keyboard_manager.actions.register ({
+                      'help'   : 'Insert Cell Below',
+                      'icon'   : 'fa-arrow-circle-o-down',
+                      'handler': function () {
+                                                    Jupyter.notebook.insert_cell_below('code');
+                                                    Jupyter.notebook.select_next();
+                                                    Jupyter.notebook.focus_cell();
+                      }
+                 }, 'insert-cell-below', 'addbefore'),
+                 ]);
+             $('#insert_above_below').remove()
+
+    };
+
+
+
+    var extension = {
+        load_jupyter_extension : load_extension,
+        load_ipython_extension : load_extension
+    };
+    return extension;
+});

.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/autoscroll/autoscroll.yaml

@@ -0,0 +1,26 @@
+Type: IPython Notebook Extension
+Compatibility: 3.x, 4.x
+Name: Autoscroll
+Main: main.js
+Icon: icon.png
+Link: README.md
+Description: Optionally set the output autoscroll threshold, and/or add a selector to the toolbar to set it, and/or add a toolbar button to enable/disable it
+Parameters:
+- name: autoscroll_set_on_load
+  description: Set an autoscroll threshold on notebook load. If false, the default is unchanged.
+  input_type: checkbox
+  default: false
+- name: autoscroll_starting_threshold
+  description: Autoscroll threshold which would be set on notebook load. -1 disables autoscrolling.
+  input_type: number
+  min: -1
+  step: 1
+  default: 100
+- name: autoscroll_show_selector
+  description: add a selector to the toolbar to change the autoscroll threshold
+  input_type: checkbox
+  default: true
+- name: autoscroll_show_button
+  description: add a button to the toolbar to disable/enable autoscrolling
+  input_type: checkbox
+  default: false

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

@@ -0,0 +1,130 @@
+define([
+    'jquery',
+    'base/js/namespace',
+    'base/js/events',
+    'notebook/js/outputarea',
+    'notebook/js/codecell'
+], function (
+    $,
+    IPython,
+    events,
+    oa,
+    codecell
+) {
+    "use strict";
+
+    var prev_threshold = 0;
+    var action_full_name; // will be set when registering the action
+
+    // define default values for config parameters
+    var params = {
+        autoscroll_set_on_load : false,
+        autoscroll_starting_threshold : 100,
+        autoscroll_show_selector : true,
+        autoscroll_show_button : false
+    };
+
+    // update params with any specified in the server's config file
+    var update_params = function() {
+        var config = IPython.notebook.config;
+        for (var key in params) {
+            if (config.data.hasOwnProperty(key))
+                params[key] = config.data[key];
+        }
+    };
+
+    var initAutoScroll = function() {
+        if (IPython.notebook === undefined) return;
+        var cells = IPython.notebook.get_cells();
+        var ncells = IPython.notebook.ncells();
+        for (var i=0; i<ncells; i++) {
+            var cell = cells[i];
+            if ((cell instanceof codecell.CodeCell)) {
+                cell.scroll_output()
+            }
+        }
+
+    };
+
+    var toggle_output_autoscroll = function() {
+        if (oa.OutputArea.auto_scroll_threshold > 0) {
+            prev_threshold = oa.OutputArea.auto_scroll_threshold;
+            oa.OutputArea.auto_scroll_threshold = -1;
+        }
+        else {
+            var new_thr = prev_threshold <= 0 ? 1 : prev_threshold;
+            prev_threshold = oa.OutputArea.auto_scroll_threshold;
+            oa.OutputArea.auto_scroll_threshold = new_thr;
+        }
+
+        $('#autoscroll_selector').val(oa.OutputArea.auto_scroll_threshold);
+
+        $('.btn[data-jupyter-action="' + action_full_name + '"]')
+            .toggleClass('active', oa.OutputArea.auto_scroll_threshold <= 0)
+            .blur();
+        initAutoScroll();
+    };
+
+    var initialize = function() {
+        update_params();
+
+        var thresholds = [-1, 1, 10, 20, 50, 100, 200, 500, 1000];
+
+        if (params.autoscroll_set_on_load) {
+            var st = params.autoscroll_starting_threshold;
+            oa.OutputArea.auto_scroll_threshold = st;
+            if (thresholds.includes(st) === false) thresholds.push(st);
+        }
+
+        thresholds.sort(function(a, b){ return a-b; });
+
+        if (params.autoscroll_show_selector) {
+            var select = $('<select id="autoscroll_selector"/>')
+                .addClass("form-control select-xs");
+            select.change(function() {
+                oa.OutputArea.auto_scroll_threshold = parseInt($(this).val(), 10);
+                $('.btn[data-jupyter-action="' + action_full_name + '"]')
+                    .toggleClass('active', oa.OutputArea.auto_scroll_threshold <= 0);
+                $(this).blur();
+            });
+            for (var i in thresholds) {
+                var thr = thresholds[i];
+                select.append($('<option/>').attr('value', thr).text(thr));
+            }
+            select.find('option[value="100"]').text('100 (default)');
+            select.find('option[value="-1"]').text('no-scroll');
+            IPython.toolbar.element.append(
+                $('<label class="navbar-text"/>').text('auto-scroll threshold:')
+            ).append(select);
+            select.val(oa.OutputArea.auto_scroll_threshold);
+        }
+
+        if (params.autoscroll_show_button) {
+            IPython.toolbar.add_buttons_group([action_full_name]);
+        }
+        initAutoScroll();
+    };
+
+    var load_ipython_extension = function () {
+        var prefix = 'auto';
+        var action_name = 'toggle-output-autoscroll';
+        var action = {
+            icon: 'fa-close',
+            help: 'Toggle output auto-scrolling',
+            help_index : 'zz',
+            handler : toggle_output_autoscroll
+        };
+
+        action_full_name = IPython.keyboard_manager.actions.register(action, action_name, prefix);
+
+        IPython.notebook.config.loaded.then(initialize);
+        events.on("notebook_loaded.Notebook", function(){
+            initAutoScroll();
+        });
+
+    };
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+});

.local/share/jupyter/nbextensions/cell_filter/cell_filter.js

@@ -0,0 +1,133 @@
+/**
+ * cell_filter.js
+ * An extension that allows you to filter cells by tags. Keywords entered into the search bar separated by spaces joins them with logical AND.
+ *
+ *
+ * @version 0.1.0
+ * @author  Benjamin Ellenberger, https://github.com/benelot
+ * @updated 2018-02-16
+ *
+ *
+ */
+define([
+    'require',
+    'jqueryui',
+    'base/js/namespace',
+    'base/js/utils',
+    'services/config'
+], function (
+    requirejs,
+    $,
+    Jupyter,
+    utils
+) {
+    'use strict';
+
+    function filterRows (filterText, caseSensitive, useRegex) {
+        var input = $('#filterkeyword');
+        var btnRegex = $('#filterisreg');
+
+        filterText = filterText !== undefined ? filterText : input.val();
+        useRegex = useRegex !== undefined ? useRegex : btnRegex.attr('aria-pressed') === 'true';
+        caseSensitive = caseSensitive !== undefined ? caseSensitive : $('#filtercase').attr('aria-pressed') === 'true';
+
+        if (!useRegex) {
+            // escape any regex special chars
+            filterText = filterText.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+            var keywords = filterText.split(' ');                                                                   // get all space separated keywords
+            filterText = '.*';                                                                                      // catch all stuff before the keywords
+            keywords.forEach(function(keyword){                                                                     // find all keywords we are looking for with regex (?=.*keyword)
+                filterText += '(?=.*' + keyword + ')';
+            });
+            filterText += '.*';                                                                                     // catch all stuff after the keywords
+        }
+        var matchExpr;
+        try {
+            matchExpr = new RegExp(filterText, caseSensitive ? '' : 'i');                                           // prepare regex
+        }
+        catch (err) {
+            // do nothing, error is handled based on undefined matchExpr
+        }
+
+        var invalidRegex = matchExpr === undefined;                                                                 // indicate invalid regex
+        btnRegex.toggleClass('btn-danger', invalidRegex);
+        btnRegex.toggleClass('btn-default', !invalidRegex);
+        btnRegex.closest('.form-group').toggleClass('has-error has-feedback', invalidRegex);
+
+        Jupyter.notebook.get_cells().forEach(function (cell, idx, cells) {                                          // toggle visibility of cells depending on their tags
+            var tags = cell.metadata.tags || [];
+            tags = tags.join(' ');
+            if(filterText === ".*(?=.*).*" || filterText === "" || tags.search(matchExpr) !== -1 && tags.length > 0){                    // empty filter or match expression on non-zero tags
+                cell.element.show(); // cell.element.style.display = '';
+                //cell.element.find("div.inner_cell").show();
+            }
+            else{
+                cell.element.hide(); // cell.element.style.display = 'none';
+                //cell.element.find("div.inner_cell").hide();
+            }
+        });
+    }
+
+    function filterRowsDefaultParams () {
+        return filterRows();
+    }
+
+    function load_ipython_extension () {
+
+        var form_tgrp = $('<div/>')
+            .addClass('btn-group')                                                                                 // insert a top form-group to make the form appear next to the buttons
+            .appendTo('#maintoolbar-container');
+
+        var frm_grp = $('<div/>')
+            .addClass('form-group')                                                                                 // insert a form-group
+            .css('margin-bottom', 0)
+            .appendTo(form_tgrp);
+
+        var grp = $('<div/>')
+            .addClass('input-group')                                                                                // insert an input-group
+            .appendTo(frm_grp);
+
+        $('<input/>')                                                                                               // insert search bar
+            .attr('type', 'text')
+            .addClass('form-control input-sm')
+            .attr('title', 'Keyword for filtering cells by tags')
+            .attr('id', 'filterkeyword')
+            .attr('placeholder', 'Cell Tag Filter')
+            .css('font-weight', 'bold')
+            .css('width', '70%')
+            .css('height', '24px')
+            .on('focus', function (evt) { Jupyter.notebook.keyboard_manager.disable();})
+            .on('blur', function (evt) { Jupyter.notebook.keyboard_manager.enable();})
+            .appendTo(grp);
+
+        $('<button/>')
+            .attr('type', 'button')                                                                                 // insert regex button
+            .attr('id', 'filterisreg')
+            .addClass('btn btn-default btn-sm')
+            .attr('data-toggle', 'button')
+            .css('font-weight', 'bold')
+            .attr('title', 'Use regex (JavaScript regex syntax)')
+            .text('.*')
+            .on('click', function (evt) { setTimeout(filterRowsDefaultParams); })
+            .appendTo(grp);
+
+        $('<button/>')                                                                                              // insert case sensitive button
+            .attr('type', 'button')
+            .attr('id', 'filtercase')
+            .addClass('btn btn-default btn-sm')
+            .attr('data-toggle', 'button')
+            .attr('tabindex', '0')
+            .attr('title', 'Match case')
+            .css('font-weight', 'bold')
+            .text('Aa')
+            .on('click', function (evt) { setTimeout(filterRowsDefaultParams); })
+            .appendTo(grp);
+
+        $('#filterkeyword').on('keyup', filterRowsDefaultParams);                                                   // trigger filtering right with typing
+    }
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+
+});

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

@@ -0,0 +1,4 @@
+Code Font Size
+==============
+
+Adds toolbar buttons to increase and decrease code's font size. This is useful, for example, when projecting the notebook.

.local/share/jupyter/nbextensions/code_font_size/code_font_size.js

@@ -0,0 +1,70 @@
+// Increase/decrease code font size
+
+
+define([
+    'base/js/namespace',
+    'base/js/events'
+    ], function(Jupyter, events) {
+            var code_change_fontsize =  function(doIncrease) {
+                var pre_css = null;
+                var pre_style = null;
+                for(i = 0; i < document.styleSheets.length; i++){
+                    //if style sheet is custom.css
+                    if(/.*\/custom\/custom\.css/.test(document.styleSheets[i].href)){ 
+                        //pre_css now contains the style sheet custom.css
+                        pre_css = document.styleSheets[i]; 
+                        break;
+                    }
+                }
+
+                for(i = 0; i < pre_css.cssRules.length; i++){
+                    if(/\.CodeMirror pre/.test(pre_css.cssRules[i].selectorText)){
+                        pre_style = pre_css.cssRules[i].style;
+                        break;
+                    }
+                }
+
+                if(pre_style == null){
+                    pre_css.insertRule(".CodeMirror pre { font-size: \"14px\"; padding-bottom: \"0px\"; }", 0);
+                    pre_style = pre_css.cssRules[0];
+                }
+
+                var font_size = pre_style.fontSize || "";
+                if(font_size == "")
+                    font_size = 14;
+                else
+                    font_size = +/\d+/.exec(font_size)[0];
+                font_size += (doIncrease ? +3 : -3);
+                font_size = (font_size < 8 ? 8 : font_size);
+                var padding_size = (font_size <= 14 ? 0 : (font_size - 14));
+
+                pre_style.paddingBottom = padding_size + "px";
+                pre_style.fontSize = font_size + "px";
+            };
+
+        var load_ipython_extension = function () {
+            Jupyter.toolbar.add_buttons_group([
+                /*
+                 * Buttons to increase/decrease code font size
+                 */
+                Jupyter.keyboard_manager.actions.register ({
+                     'help'   : 'Increase code font size',
+                     'icon'   : 'fa-search-plus',
+                     'handler': function () {
+                        $( document ).ready(code_change_fontsize(true));
+                     }
+                }, 'increase-code-font-size', 'code_font_size'),
+                Jupyter.keyboard_manager.actions.register ({
+                     'help'   : 'Decrease code font size',
+                     'icon'   : 'fa-search-minus',
+                     'handler': function () {
+                        $( document ).ready(code_change_fontsize(false));
+                     }
+                }, 'decrease-code-font-size', 'code_font_size'),
+                
+            ]);
+        };
+        return {
+            load_ipython_extension : load_ipython_extension
+        };
+});

.local/share/jupyter/nbextensions/code_font_size/code_font_size.yaml

@@ -0,0 +1,7 @@
+Type: IPython Notebook Extension
+Name: Code Font Size
+Link: README.md
+Description: Adds toolbar buttons to increase and decrease code's font size.
+             This is useful, for example, when projecting the notebook.
+Main: code_font_size.js
+Compatibility: 4.x, 5.x

.local/share/jupyter/nbextensions/code_prettify/2to3.yaml

@@ -0,0 +1,65 @@
+Type: Jupyter Notebook Extension
+Name: 2to3 Converter
+Description: Converts python2 code in a notebook's code cell to python3 code
+Link: README_2to3.md
+Main: 2to3.js
+Compatibility: Jupyter 4.x, 5.x
+Parameters:
+
+- name: 2to3.add_toolbar_button
+  description: Add a toolbar button to convert the selected cell(s)
+  input_type: checkbox
+  default: true
+
+- name: 2to3.button_icon
+  description: |
+    Toolbar button icon: a font-awesome class defining the icon used for the
+    toolbar button. See https://fontawesome.com/icons for available icons.
+  input_type: text
+  default: 'fa-space-shuttle'
+
+- name: 2to3.button_label
+  description: Toolbar button label text
+  input_type: text
+  default: 'Code converter'
+
+- name: 2to3.register_hotkey
+  description: Register a hotkey to convert the selected cell(s)
+  input_type: checkbox
+  default: true
+
+- name: 2to3.hotkeys.process_selected
+  description: Hotkey to convert the selected cell(s) from python2 to python3
+  input_type: hotkey
+  default: 'Ctrl-M'
+
+- name: 2to3.hotkeys.process_all
+  description: Hotkey to convert the whole notebook
+  input_type: hotkey
+  default: 'Ctrl-Shift-M'
+
+- name: 2to3.show_alerts_for_not_supported_kernel
+  description: Show alerts if the kernel is not supported
+  input_type: checkbox
+  default: false
+
+- name: 2to3.show_alerts_for_errors
+  description: Show alerts for errors in the kernel converting calls
+  input_type: checkbox
+  default: true
+
+- name: 2to3.kernel_config_map_json
+  description: |
+    kernel_config_map_json:
+    json defining library calls required to load the kernel-specific
+    converting modules, and the prefix & postfix for the json-format string
+    required to make the converting call.
+  input_type: textarea
+  default: |
+    {
+      "python": {
+        "library": "import lib2to3.refactor, json\n_2to3_refactoring_tool = lib2to3.refactor.RefactoringTool(\n    set(lib2to3.refactor.get_fixers_from_package('lib2to3.fixes')))\ndef _2to3_refactor_cell(src):\n    try:\n        tree = _2to3_refactoring_tool.refactor_string(src+'\\n', '<dummy_name>')\n    except (lib2to3.pgen2.parse.ParseError, lib2to3.pgen2.tokenize.TokenError):\n        return src \n    else:\n        return str(tree)[:-1]",
+        "prefix": "print(json.dumps(refactor_cell(u",
+        "postfix": ")))"
+      }
+    }

.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/code_prettify/README_autopep8.md

@@ -0,0 +1,136 @@
+jupyter-autopep8
+================
+
+This nbextension reformats/prettifies code in notebook python code cells.
+
+Under the hood, it uses a call to the current notebook kernel to reformat the
+code.
+The conversion run by the kernel uses the python [autopep8] package, and thus is compatible only with python kernels.
+
+The nbextension provides
+
+- a toolbar button (configurable to be added or not)
+
+- a keyboard shortcut for reformatting the current code-cell (default shortcut
+  is `Alt-A`, can also be configured not to add the keyboard shortcut).
+
+- a keyboard shortcut for reformatting the whole notebook (default shortcut
+  is `Alt-Shift-A`, can also be configured not to add the keyboard shortcut).
+
+Syntax needs to be correct, but the nbextension may be able to point out basic
+syntax errors.
+
+
+Prerequisites
+-------------
+
+Of course, you must have the necessary kernel-specific package installed for
+the prettifier call to work:
+
+    pip install autopep8
+
+
+Options
+-------
+
+All options are provided by the [KerneExecOnCells library] - see the
+[internals] section below for details.
+There are a few nbextension-wide options, configurable using the
+[jupyter_nbextensions_configurator] or by editing the `notebook` section config
+file directly.
+The options are as follows:
+
+- `autopep8.add_toolbar_button`:
+  Whether to add a toolbar button to transform the selected cell(s).
+  Defaults to `true`.
+
+- `autopep8.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-cog`.
+
+- `autopep8.button_label`:
+  Toolbar button label text. Also used in the actions' help text.
+  Defaults to `Prettify (using autopep8)`.
+
+- `autopep8.register_hotkey`:
+  Whether to register hotkeys to transform the selected cell(s)/whole notebook.
+  Defaults to `true`.
+
+- `autopep8.hotkeys.process_all`:
+  Hotkey to use to transform all the code cells in the notebook.
+  Defaults to `Alt-Shift-A`.
+
+- `autopep8.hotkeys.process_selected`:
+  Hotkey to use to transform the selected cell(s).
+  Defaults to `Alt-A`.
+
+- `autopep8.show_alerts_for_not_supported_kernel`:
+  Whether to show alerts if the kernel is not supported.
+  Defaults to `false`.
+
+- `autopep8.show_alerts_for_errors`:
+  Whether to show alerts for errors in the kernel calls.
+  Defaults to `true`.
+
+- `autopep8.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 `python `:
+
+  * `autopep8.kernel_config_map_json.python.library`:
+    String to execute in the kernel in order to load any necessary kernel
+    libraries.
+
+  * `autopep8.kernel_config_map_json.python.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.
+
+  * `autopep8.kernel_config_map_json.python.prefix` and
+    `autopep8.kernel_config_map_json.python.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.
+
+  * `autopep8.kernel_config_map_json.python.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
+---------
+
+Under the hood, this nbextension uses the [KerneExecOnCells library], a shared
+library for creating Jupyter nbextensions which transform code cell text using
+calls to the active kernel.
+
+See the [shared README] for the internal model used by the nbextension.
+
+
+History
+-------
+
+The project was forked by [@kenkoooo] from [@jfbercher]'s [code_prettify],
+retaining most of the code.
+
+It has since been altered to use the [KerneExecOnCells library], a shared
+library for creating Jupyter nbextensions which transform code cell text using
+calls to the active kernel.
+
+[@jfbercher]: https://github.com/jfbercher
+[@kenkoooo]: https://github.com/kenkoooo
+[autopep8]: https://github.com/hhatto/autopep8
+[code_prettify]: https://github.com/jfbercher/code_prettify
+[fontawesome]: https://fontawesome.com/icons
+[internals]: #Internals
+[jupyter_nbextensions_configurator]: https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator
+[KerneExecOnCells library]: README.md
+[shared README]: README.md

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

@@ -0,0 +1,44 @@
+# Sort imports using isort
+
+This nbextension sorts imports in notebook code cells.
+
+Under the hood, it uses a call to the current notebook kernel to reformat the code. The conversion run by the kernel uses Python's package [isort](https://github.com/timothycrosley/isort) by [Timothy Edmund Crosley](https://github.com/timothycrosley).
+
+The nbextension provides
+
+- a toolbar button (configurable to be added or not)
+
+**pre-requisites:** of course, you must have the corresponding package installed:
+
+```
+pip install isort [--user]
+```
+
+## Options
+
+All options are provided by the [KerneExecOnCells library](kernel_exec_on_cell.js). There are a few nbextension-wide options, configurable using the [jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator) or by editing the `notebook` section config file directly. The options are as follows:
+
+- `isort.add_toolbar_button`: Whether to add a toolbar button to transform the selected cell(s). Defaults to `true`.
+
+- `isort.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-sort`.
+
+- `isort.show_alerts_for_not_supported_kernel`:
+  Whether to show alerts if the kernel is not supported.
+  Defaults to `false`.
+
+- `isort.show_alerts_for_errors`: Whether to show alerts for errors in the kernel calls. Defaults to `false`.
+
+- `isort.button_label`: Toolbar button label text. Also used in the actions' help text. Defaults to `Sort imports with isort`.
+
+- `isort.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.
+
+## Internals
+
+Under the hood, this nbextension uses the [kerneexeconcells library](kernel_exec_on_cell.js), a shared library for creating Jupyter nbextensions which transform code cell text using calls to the active kernel.
+
+See the [shared README](README.md) and [kerneexeconcells library](kernel_exec_on_cell.js) for the internal model used by the nbextension.
+
+[fontawesome]: https://fontawesome.com/icons

.local/share/jupyter/nbextensions/code_prettify/autopep8.js

@@ -0,0 +1,36 @@
+// Copyright (c) Jupyter-Contrib Team.
+// Distributed under the terms of the Modified BSD License.
+// Authors: @kenkoooo, @jfbercher and @jcb91
+
+define(['./kernel_exec_on_cell'], function(kernel_exec_on_cell) {
+    'use strict';
+
+    var mod_name = 'autopep8';
+
+    // gives default settings
+    var cfg = {
+        add_toolbar_button: true,
+        hotkeys: {
+            process_selected: 'Alt-A',
+            process_all: 'Alt-Shift-A',
+        },
+        register_hotkey: true,
+        show_alerts_for_errors: true,
+        button_icon: 'fa-cog',
+        button_label: 'Prettify (using autopep8)',
+        kbd_shortcut_text: 'Prettify' // ' current cell(s)'
+    };
+
+    cfg.kernel_config_map = { // map of parameters for supported kernels
+        "python": {
+            "library": "import json\nimport autopep8",
+            "prefix": "print(json.dumps(autopep8.fix_code(u",
+            "postfix": ")))"
+        }
+    };
+
+    var prettifier = new kernel_exec_on_cell.define_plugin(mod_name, cfg);
+    prettifier.load_ipython_extension = prettifier.initialize_plugin;
+    return prettifier;
+
+    });

.local/share/jupyter/nbextensions/code_prettify/autopep8.yaml

@@ -0,0 +1,67 @@
+Type: Jupyter Notebook Extension
+Name: Autopep8
+Description: Use kernel-specific code to reformat/prettify the contents of code cells
+Link: README_autopep8.md
+Main: autopep8.js
+Compatibility: Jupyter 4.x, 5.x
+Parameters:
+
+- name: autopep8.add_toolbar_button
+  description: Add a toolbar button to prettify the selected cell(s)
+  input_type: checkbox
+  default: true
+
+- name: autopep8.button_icon
+  description: |
+    Toolbar button icon: a font-awesome class defining the icon used for the
+    toolbar button and actions.
+    See https://fontawesome.com/icons for available icons.
+  input_type: text
+  default: 'fa-cog'
+
+- name: autopep8.button_label
+  description: Toolbar button label text
+  input_type: text
+  default: 'Code prettify'
+
+- name: autopep8.register_hotkey
+  description: |
+    Register hotkeys to prettify the selected code cell(s), or all code cells
+    in the notebook
+  input_type: checkbox
+  default: true
+
+- name: autopep8.hotkeys.process_selected
+  description: Hotkey to use to prettify the selected cell(s)
+  input_type: hotkey
+  default: 'Alt-A'
+
+- name: autopep8.hotkeys.process_all
+  description: Hotkey to use to prettify the whole notebook
+  input_type: hotkey
+  default: 'Alt-Shift-A'
+
+- name: autopep8.show_alerts_for_not_supported_kernel
+  description: Show alerts if the kernel is not supported
+  input_type: checkbox
+  default: false
+
+- name: autopep8.show_alerts_for_errors
+  description: Show alerts for errors in the kernel prettifying calls
+  input_type: checkbox
+  default: true
+
+- name: autopep8.kernel_config_map_json
+  description: |
+    json defining library calls required to load the kernel-specific
+    prettifying modules, and the prefix & postfix for the json-format string
+    required to make the prettifying call.
+  input_type: textarea
+  default: |
+    {
+        "python": {
+            "library": "import json\nimport autopep8",
+            "prefix": "print(json.dumps(autopep8.fix_code(u",
+            "postfix": ")))"
+        }
+    }

.local/share/jupyter/nbextensions/code_prettify/code_prettify.js

@@ -0,0 +1,56 @@
+// Copyright (c) Jupyter-Contrib Team.
+// Distributed under the terms of the Modified BSD License.
+// Authors: @jfbercher and @jcb91
+
+define(['./kernel_exec_on_cell'], function(kernel_exec_on_cell) {
+    'use strict';
+
+    var mod_name = 'code_prettify';
+
+    // gives default settings
+    var cfg = {
+        add_toolbar_button: true,
+        hotkeys: {
+            process_selected: 'Ctrl-L',
+            process_all: 'Ctrl-Shift-L',
+        },
+        register_hotkey: true,
+        show_alerts_for_errors: true,
+        button_label: 'Code prettify',
+        button_icon: 'fa-legal',
+        kbd_shortcut_text: 'Code prettify',
+    };
+
+    cfg.kernel_config_map = { // map of parameters for supported kernels
+        "python": {
+            "library": ["import json",
+            "def yapf_reformat(cell_text):", 
+            "    import yapf.yapflib.yapf_api",
+            "    from yapf import file_resources",
+            "    import os",
+            "    import re",
+            "    style_config = file_resources.GetDefaultStyleForDir(os.getcwd())",
+            "    cell_text = re.sub('^%', '#%#', cell_text, flags=re.M)",
+            "    reformated_text = yapf.yapflib.yapf_api.FormatCode(cell_text, style_config=style_config)[0]",
+            "    return re.sub('^#%#', '%', reformated_text, flags=re.M)"].join("\n"),
+            "prefix": "print(json.dumps(yapf_reformat(u",
+            "postfix": ")))"
+        },
+        "r": {
+            "library": "library(formatR)\nlibrary(jsonlite)",
+            "prefix": "cat(toJSON(paste(tidy_source(text=",
+            "postfix": ", output=FALSE)[['text.tidy']], collapse='\n')))"
+        },
+        "javascript": {
+            "library": "jsbeautify = require(" + "'js-beautify')",
+            // we do this + trick to prevent require.js attempting to load js-beautify when processing the AMI-style load for this module
+            "prefix": "console.log(JSON.stringify(jsbeautify.js_beautify(",
+            "postfix": ")));"
+        }
+    };
+
+ 
+    var prettifier = new kernel_exec_on_cell.define_plugin(mod_name, cfg);
+    prettifier.load_ipython_extension = prettifier.initialize_plugin;
+    return prettifier;
+});

.local/share/jupyter/nbextensions/code_prettify/code_prettify.yaml

@@ -0,0 +1,77 @@
+Type: Jupyter Notebook Extension
+Name: Code prettify
+Description: Use kernel-specific code to reformat/prettify the contents of code cells
+Link: README_code_prettify.md
+Main: code_prettify.js
+Compatibility: Jupyter 4.x, 5.x
+Parameters:
+
+- name: code_prettify.add_toolbar_button
+  description: Add a toolbar button to prettify the selected cell(s)
+  input_type: checkbox
+  default: true
+
+- name: code_prettify.button_icon
+  description: |
+    Toolbar button icon: a font-awesome class defining the icon used for the
+    toolbar button and actions.
+    See https://fontawesome.com/icons for available icons.
+  input_type: text
+  default: 'fa-legal'
+
+- name: code_prettify.button_label
+  description: Toolbar button label text
+  input_type: text
+  default: 'Code prettify'
+
+- name: code_prettify.register_hotkey
+  description: |
+    Register hotkeys to prettify the selected code cell(s), or all code cells
+    in the notebook
+  input_type: checkbox
+  default: true
+
+- name: code_prettify.hotkeys.process_selected
+  description: Hotkey to use to prettify the selected cell(s)
+  input_type: hotkey
+  default: 'Ctrl-L'
+
+- name: code_prettify.hotkeys.process_all
+  description: Hotkey to use to prettify the whole notebook
+  input_type: hotkey
+  default: 'Ctrl-Shift-L'
+
+- name: code_prettify.show_alerts_for_not_supported_kernel
+  description: Show alerts if the kernel is not supported
+  input_type: checkbox
+  default: false
+
+- name: code_prettify.show_alerts_for_errors
+  description: Show alerts for errors in the kernel prettifying calls
+  input_type: checkbox
+  default: true
+
+- name: code_prettify.kernel_config_map_json
+  description: |
+    json defining library calls required to load the kernel-specific
+    prettifying modules, and the prefix & postfix for the json-format string
+    required to make the prettifying call.
+  input_type: textarea
+  default: |
+    {
+      "python": {
+        "library": "import json\ndef yapf_reformat(cell_text):\n    import yapf.yapflib.yapf_api\n    import re\n    cell_text = re.sub('^%', '#%#', cell_text, flags=re.M)\n    reformated_text = yapf.yapflib.yapf_api.FormatCode(cell_text)[0]\n    return re.sub('^#%#', '%', reformated_text, flags=re.M)",
+        "prefix": "print(json.dumps(yapf_reformat(u",
+        "postfix": ")))"
+      },
+      "r": {
+        "library": "library(formatR)\nlibrary(jsonlite)",
+        "prefix": "cat(toJSON(paste(tidy_source(text=",
+        "postfix": ", output=FALSE)[['text.tidy']], collapse='\n')))"
+      },
+      "javascript": {
+        "library": "jsbeautify = require('js-beautify')",
+        "prefix": "console.log(JSON.stringify(jsbeautify.js_beautify(",
+        "postfix": ")));"
+      }
+    }

.local/share/jupyter/nbextensions/code_prettify/isort.js

@@ -0,0 +1,43 @@
+// Copyright (c) Jupyter-Contrib Team.
+// Distributed under the terms of the Modified BSD License.
+// Authors: @benjaminabel
+// Based on: code_prettify extension
+
+define(['./kernel_exec_on_cell'], function(kernel_exec_on_cell) {
+    'use strict';
+
+    var mod_name = 'isort';
+
+    // gives default settings
+    var cfg = {
+        add_toolbar_button: true,
+        register_hotkey: false,
+        show_alerts_for_errors: false,
+        button_icon: 'fa-sort',
+        button_label: 'Sort imports with isort',
+        kbd_shortcut_text: 'Sort imports in' // ' current cell(s)'
+    };
+
+    cfg.kernel_config_map = { // map of parameters for supported kernels
+        "python": {
+            "library": [
+                "import isort",
+                "import json",
+                "def _isort_refactor_cell(src):",
+                "    try:",
+                "        tree = isort.SortImports(file_contents=src).output",
+                "    except Exception:",
+                "        return src ",
+                "    else:",
+                "        return str(tree)[:-1]",
+            ].join('\n'),
+            "prefix": "print(json.dumps(_isort_refactor_cell(u",
+            "postfix": ")))"
+        }
+    };
+
+    var converter = new kernel_exec_on_cell.define_plugin(mod_name, cfg);
+    converter.load_ipython_extension = converter.initialize_plugin;
+    return converter;
+
+    });

.local/share/jupyter/nbextensions/code_prettify/isort.yaml

@@ -0,0 +1,40 @@
+Type: Jupyter Notebook Extension
+Name: isort formatter
+Description: Sort imports in python files using isort
+Link: README_isort.md
+Main: isort.js
+Compatibility: Jupyter 4.x, 5.x
+Parameters:
+
+- name: isort.add_toolbar_button
+  description: Add a toolbar button to convert the selected cell(s)
+  input_type: checkbox
+  default: true
+
+- name: isort.button_icon
+  description: |
+    Toolbar button icon: a font-awesome class defining the icon used for the
+    toolbar button. See https://fontawesome.com/icons for available icons.
+  input_type: text
+  default: 'fa-sort'
+
+- name: isort.button_label
+  description: Toolbar button label text
+  input_type: text
+  default: 'Sort imports with isort'
+
+- name: isort.kernel_config_map_json
+  description: |
+    kernel_config_map_json:
+    json defining library calls required to load the kernel-specific
+    converting modules, and the prefix & postfix for the json-format string
+    required to make the converting call.
+  input_type: textarea
+  default: |
+    {
+      "python": {
+        "library": "import json, isort\ndef _isort_refactor_cell(src):\n    try:\n        tree = isort.SortImports(file_contents=src).output\n    except Exception:\n        return src \n    else:\n        return str(tree)[:-1]",
+        "prefix": "print(json.dumps(_isort_refactor_cell(u",
+        "postfix": ")))"
+      }
+    }

.local/share/jupyter/nbextensions/code_prettify/kernel_exec_on_cell.js

@@ -0,0 +1,356 @@
+// Copyright (c) Jupyter-Contrib Team.
+// Distributed under the terms of the Modified BSD License.
+
+define([
+    'jquery',
+    'base/js/namespace',
+    'base/js/events',
+    'notebook/js/codecell',
+], function(
+    $,
+    Jupyter,
+    events,
+    codecell
+) {
+    'use strict';
+
+    var CodeCell = codecell.CodeCell;
+
+    // this wrapper function allows config & hotkeys to be per-plugin
+    function KernelExecOnCells(mod_name, cfg) {
+
+        this.mod_name = mod_name;
+        this.mod_log_prefix = '[' + this.mod_name + ']';
+        this.mod_edit_shortcuts = {};
+        this.mod_cmd_shortcuts = {};
+        this.default_kernel_config = {
+            library: '',
+            prefix: '',
+            postfix: '',
+            replacements_json_to_kernel: [],
+            trim_formatted_text: true
+        };
+        // gives default settings
+        var default_cfg = {
+            add_toolbar_button: true,
+            hotkeys: {
+                process_selected: 'Ctrl-L',
+                process_all: 'Ctrl-Shift-L',
+            },
+            register_hotkey: true,
+            show_alerts_for_errors: true,
+            show_alerts_for_not_supported_kernel: false,
+            button_icon: 'fa-legal',
+            button_label: mod_name,
+            kbd_shortcut_text: mod_name,
+            kernel_config_map: {},
+            actions: null, // to be filled by register_actions
+        };
+        // extend a new object, to avoid interference with other nbextensions
+        // derived from the same base class
+        this.cfg = $.extend(true, {}, default_cfg, cfg);
+        // set default json string, will later be updated from config
+        // before it is parsed into an object
+        this.cfg.kernel_config_map_json = JSON.stringify(this.cfg.kernel_config_map);
+
+    } // end per-plugin wrapper define_plugin_functions
+
+    // Prototypes
+    // ----------
+
+    /**
+     * return a Promise which will resolve/reject based on the kernel message
+     * type.
+     * The returned promise will be
+     *   - resolved if the message was not an error
+     *   - rejected using the message's error text if msg.msg_type is "error"
+     */
+    KernelExecOnCells.prototype.convert_error_msg_to_broken_promise = function(msg) {
+        var that = this;
+        return new Promise(function(resolve, reject) {
+            if (msg.msg_type == 'error') {
+                return reject(that.mod_log_prefix + '\n Error: ' + msg.content.ename + '\n' + msg.content.evalue);
+            }
+            return resolve(msg);
+        });
+    };
+
+    KernelExecOnCells.prototype.convert_loading_library_error_msg_to_broken_promise = function(msg) {
+        var that = this;
+        return new Promise(function(resolve, reject) {
+            if (msg.msg_type == 'error') {
+                return reject(that.mod_log_prefix + '\n Error loading library for ' +
+                    Jupyter.notebook.metadata.kernelspec.language + ':\n' +
+                    msg.content.ename  + msg.content.evalue +
+                    '\n\nCheck that the appropriate library/module is correctly installed (read ' +
+                    that.mod_name + '\'s documentation for details)');
+            }
+            return resolve(msg);
+        });
+    };
+
+    KernelExecOnCells.prototype.get_kernel_config = function() {
+        var kernelLanguage = Jupyter.notebook.metadata.kernelspec.language.toLowerCase();
+        var kernel_config = this.cfg.kernel_config_map[kernelLanguage];
+        // true => deep
+        return $.extend(true, {}, this.default_kernel_config, kernel_config);
+    };
+
+    KernelExecOnCells.prototype.transform_json_string_to_kernel_string = function(str, kernel_config) {
+        for (var ii = 0; ii < kernel_config.replacements_json_to_kernel.length; ii++) {
+            var from = kernel_config.replacements_json_to_kernel[ii][0];
+            var to = kernel_config.replacements_json_to_kernel[ii][1];
+            str = str.replace(from, to);
+        }
+        return str;
+    };
+
+    /**
+     * construct functions as callbacks for the autoformat cell promise. This
+     * is necessary because javascript lacks loop scoping, so if we don't use
+     * this IIFE pattern, cell_index & cell are passed by reference, and every
+     * callback ends up using the same value
+     */
+    KernelExecOnCells.prototype.construct_cell_callbacks = function(cell_index, cell) {
+        var that = this;
+        var on_success = function(formatted_text) {
+            cell.set_text(formatted_text);
+        };
+        var on_failure = function(reason) {
+            console.warn(
+                that.mod_log_prefix,
+                'error processing cell', cell_index + ':\n',
+                reason
+            );
+            if (that.cfg.show_alerts_for_errors) {
+                alert(reason);
+            }
+        };
+        return [on_success, on_failure];
+    };
+
+    KernelExecOnCells.prototype.autoformat_cells = function(indices) {
+
+        if (indices === undefined) {
+            indices = Jupyter.notebook.get_selected_cells_indices();
+        }
+        var kernel_config = this.get_kernel_config();
+        for (var ii = 0; ii < indices.length; ii++) {
+            var cell_index = indices[ii];
+            var cell = Jupyter.notebook.get_cell(cell_index);
+            if (!(cell instanceof CodeCell)) {
+                continue;
+            }
+            // IIFE because otherwise cell_index & cell are passed by reference
+            var callbacks = this.construct_cell_callbacks(cell_index, cell);
+            this.autoformat_text(cell.get_text(), kernel_config).then(callbacks[0], callbacks[1]);
+        }
+    };
+
+    KernelExecOnCells.prototype.autoformat_text = function(text, kernel_config) {
+        var that = this;
+        return new Promise(function(resolve, reject) {
+            kernel_config = kernel_config || that.get_kernel_config();
+            var kernel_str = that.transform_json_string_to_kernel_string(
+                JSON.stringify(text), kernel_config);
+            Jupyter.notebook.kernel.execute(
+                kernel_config.prefix + kernel_str + kernel_config.postfix, {
+                    iopub: {
+                        output: function(msg) {
+                            return resolve(that.convert_error_msg_to_broken_promise(msg).then(
+                                function on_success(msg) {
+                                    // print goes to stream text => msg.content.text
+                                    // but for some kernels (eg nodejs) can be called as result of exec
+                                    if (msg.content.text !== undefined) {
+                                        var formatted_text;
+                                        try {
+                                            formatted_text = String(JSON.parse(msg.content.text));
+                                        }
+                                        catch (err) {
+                                            return Promise.reject(err);
+                                        }
+                                        if (kernel_config.trim_formatted_text) {
+                                            formatted_text = formatted_text.trim();
+                                        }
+                                        return formatted_text;
+                                    }
+                                }
+                            ));
+                        }
+                    }
+                }, { silent: false }
+            );
+        });
+    };
+
+
+    KernelExecOnCells.prototype.add_toolbar_button = function() {
+        if ($('#' + this.mod_name + '_button').length < 1) {
+            var button_group_id = this.mod_name + '_button';
+            var that = this;
+            Jupyter.toolbar.add_buttons_group([{
+                label: ' ', //space otherwise add_buttons fails -- This label is inserted as a button description AND bubble help
+                icon: this.cfg.button_icon,
+                callback: function(evt) {
+                    that.autoformat_cells(
+                        evt.shiftKey ? Jupyter.notebook.get_cells().map(function (cell, idx) { return idx; }) : undefined
+                    );
+                },
+            }], button_group_id);
+
+            // Correct add_buttons_group default
+            // Change title --> inserts bubble help
+            // redefine icon to remove spurious space 
+            var w = $('#'+ button_group_id +' > .btn')[0];
+            w.title = this.cfg.kbd_shortcut_text + ' selected cell(s) (add shift for all cells)'
+            w.innerHTML = '<i class="' + this.cfg.button_icon + ' fa"></i>'
+        }
+}
+
+
+
+    KernelExecOnCells.prototype.add_keyboard_shortcuts = function() {
+        var new_shortcuts = {};
+        new_shortcuts[this.cfg.hotkeys.process_selected] = this.cfg.actions.process_selected.name;
+        new_shortcuts[this.cfg.hotkeys.process_all] = this.cfg.actions.process_all.name;
+        Jupyter.keyboard_manager.edit_shortcuts.add_shortcuts(new_shortcuts);
+        Jupyter.keyboard_manager.command_shortcuts.add_shortcuts(new_shortcuts);
+    };
+
+    KernelExecOnCells.prototype.register_actions = function() {
+        /**
+         *  it's important that the actions created by registering keyboard
+         *  shortcuts get different names, as otherwise a default action is
+         *  created, whose name is a string representation of the handler
+         *  function.
+         *  Since this library uses the same handler function for all plugins,
+         *  just with different contexts (different values of cfg), their
+         *  string representations are the same, and the last one to be
+         *  registered overwrites all previous versions.
+         *  This is essentially an issue with notebook, but it encourages us to
+         *  use actions, which is where notebook is going anyway.
+         */
+        var actions = this.cfg.actions = {};
+        var that = this;
+        actions.process_selected = {
+            help: that.cfg.kbd_shortcut_text + ' selected cell(s)',
+            help_index: 'yf',
+            icon: that.cfg.button_icon,
+            handler: function(evt) { that.autoformat_cells(); },
+        };
+        actions.process_all = {
+            help: that.cfg.kbd_shortcut_text + " the whole notebook",
+            help_index: 'yf',
+            icon: that.cfg.button_icon,
+            handler: function(evt) {
+                that.autoformat_cells(Jupyter.notebook.get_cells().map(function (cell, idx) { return idx; }));
+            },
+        };
+
+        actions.process_selected.name = Jupyter.keyboard_manager.actions.register(
+            actions.process_selected, 'process_selected_cells', that.mod_name);
+        actions.process_all.name = Jupyter.keyboard_manager.actions.register(
+            actions.process_all, 'process_all_cells', that.mod_name);
+    };
+
+    KernelExecOnCells.prototype.setup_for_new_kernel = function() {
+        var that = this;
+        var kernelLanguage = Jupyter.notebook.metadata.kernelspec.language.toLowerCase();
+        var kernel_config = this.cfg.kernel_config_map[kernelLanguage];
+        if (kernel_config === undefined) {
+            $('#' + this.mod_name + '_button').remove();
+            var err = this.mod_log_prefix + " Sorry, can't use kernel language " + kernelLanguage + ".\n" +
+                "Configurations are currently only defined for the following languages:\n" +
+                Object.keys(this.cfg.kernel_config_map).join(', ') + "\n" +
+                "See readme for more details."
+            if (this.cfg.show_alerts_for_not_supported_kernel) {
+                        alert(err);
+                                                }
+            else {
+                        console.error(err);
+                 }            
+            // also remove keyboard shortcuts
+            if (this.cfg.register_hotkey) {
+                try {
+                    Jupyter.keyboard_manager.edit_shortcuts.remove_shortcut(this.cfg.hotkeys.process_selected);
+                    Jupyter.keyboard_manager.edit_shortcuts.remove_shortcut(this.cfg.hotkeys.process_all);
+                    Jupyter.keyboard_manager.command_shortcuts.remove_shortcut(this.cfg.hotkeys.process_all);
+                } catch (err) {}
+            }
+
+        } else { // kernel language is supported
+            if (this.cfg.add_toolbar_button) {
+                this.add_toolbar_button();
+            }
+            if (this.cfg.register_hotkey) {
+                this.add_keyboard_shortcuts();
+            }
+            Jupyter.notebook.kernel.execute(
+                kernel_config.library, {
+                    iopub: {
+                        output: function(msg) {
+                            return that.convert_loading_library_error_msg_to_broken_promise(msg)
+                                .catch(
+                                    function on_failure(err) {
+                                        if (that.cfg.show_alerts_for_errors) {
+                                            alert(err);
+                                        }
+                                        else {
+                                            console.error(err);
+                                        }
+                                    }
+
+                                );
+                        }
+                    }
+                }, { silent: false }
+            );
+
+        }
+    };
+
+    KernelExecOnCells.prototype.initialize_plugin = function() {
+        var that = this;
+        // first, load config
+        Jupyter.notebook.config.loaded
+            // now update default config with that loaded from server
+            .then(function on_success() {
+                $.extend(true, that.cfg, Jupyter.notebook.config.data[that.mod_name]);
+            }, function on_error(err) {
+                console.warn(that.mod_log_prefix, 'error loading config:', err);
+            })
+            // next parse json config values
+            .then(function on_success() {
+                var parsed_kernel_cfg = JSON.parse(that.cfg.kernel_config_map_json);
+                $.extend(that.cfg.kernel_config_map, parsed_kernel_cfg);
+            })
+            // if we failed to parse the json values in the config
+            // using catch pattern, we attempt to continue anyway using defaults
+            .catch(function on_error(err) {
+                console.warn(
+                    that.mod_log_prefix, 'error parsing config variable',
+                    that.mod_name + '.kernel_config_map_json to a json object:',
+                    err
+                );
+            })
+            // now do things which required the config to be loaded
+            .then(function on_success() {
+                that.register_actions(); // register actions
+                // kernel may already have been loaded before we get here, in which
+                // case we've missed the kernel_ready.Kernel event, so try ctx
+                if (typeof Jupyter.notebook.kernel !== "undefined" && Jupyter.notebook.kernel !== null) {
+                    that.setup_for_new_kernel();
+                }
+
+                // on kernel_ready.Kernel, a new kernel has been started
+                events.on("kernel_ready.Kernel", function(evt, data) {
+                    console.log(that.mod_log_prefix, 'restarting for new kernel_ready.Kernel event');
+                    that.setup_for_new_kernel();
+                });
+            }).catch(function on_error(err) {
+                console.error(that.mod_log_prefix, 'error loading:', err);
+            });
+    };
+
+    return {define_plugin: KernelExecOnCells};
+});