fastcore 2.2.32__tar.gz → 2.2.34__tar.gz

{fastcore-2.2.32/fastcore.egg-info → fastcore-2.2.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastcore
-Version: 2.2.32
+Version: 2.2.34
 Summary: Python supercharged for fastai development
 Author-email: Jeremy Howard and Sylvain Gugger <infos@fast.ai>
 License-Expression: Apache-2.0
@@ -44,19 +44,19 @@ Python is a powerful, dynamic language. Rather than bake everything into the lan
 
 Here are some tips on using fastcore:
 
-- **Liberal imports**: Use `from fastcore.module import *` freely. The library is designed for safe wildcard imports.
-- **Enhanced list operations**: Substitute `list` with [`L`](https://fastcore.fast.ai/foundation.html#l). This provides advanced indexing, method chaining, and additional functionality while maintaining list-like behavior.
-- **Extend existing classes**: Apply the `@patch` decorator to add methods to classes, including built-ins, without subclassing.
-- **Streamline class initialization**: In `__init__` methods, use [`store_attr()`](https://fastcore.fast.ai/basics.html#store_attr) to efficiently set multiple attributes, reducing repetitive assignment code.
-- **Explicit keyword arguments**: Apply the [`delegates`](https://fastcore.fast.ai/meta.html#delegates) decorator to functions to replace `**kwargs` with specific parameters, enhancing IDE support and documentation.
-- **Optimize parallel execution**: Use fastcore’s enhanced [`ThreadPoolExecutor`](https://fastcore.fast.ai/parallel.html#threadpoolexecutor) and [`ProcessPoolExecutor`](https://fastcore.fast.ai/parallel.html#processpoolexecutor) for simplified concurrent processing.
-- **Expressive testing**: Prefer fastcore’s testing functions like [`test_eq`](https://fastcore.fast.ai/test.html#test_eq), [`test_ne`](https://fastcore.fast.ai/test.html#test_ne), [`test_close`](https://fastcore.fast.ai/test.html#test_close) for more readable and informative test assertions.
-- **Advanced file operations**: Use the extended `Path` class, which adds methods like `ls()`, `read_json()`, and others to [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html#pathlib.Path).
-- **Flexible data structures**: Convert between dictionaries and attribute-access objects using [`dict2obj`](https://fastcore.fast.ai/xtras.html#dict2obj) and [`obj2dict`](https://fastcore.fast.ai/xtras.html#obj2dict) for more intuitive data handling.
-- **Functional programming paradigms**: Use tools like [`compose`](https://fastcore.fast.ai/basics.html#compose), [`maps`](https://fastcore.fast.ai/basics.html#maps), and [`filter_ex`](https://fastcore.fast.ai/basics.html#filter_ex) to write more functional-style Python code.
-- **Documentation**: Document parameters and return values with [`docments`](https://fastcore.fast.ai/docments.html#docments), using source comments or `Annotated` metadata for generated APIs. [`MarkdownRenderer`](https://fastcore.fast.ai/docments.html#markdownrenderer) shows the effective signature and retains usage sections such as Notes, Raises, and Examples.
-- **Time-aware caching**: Apply the [`timed_cache`](https://fastcore.fast.ai/xtras.html#timed_cache) decorator to add time-based expiration to the standard `lru_cache` functionality.
-- **Simplified CLI creation**: Use `fastcore.script` to easily transform Python functions into command-line interfaces.
+- Use `from fastcore.module import *` freely. fastcore’s modules are built to be safe for wildcard imports.
+- Use [`L`](https://fastcore.fast.ai/foundation.html#l) in place of `list`. [`L`](https://fastcore.fast.ai/foundation.html#l) behaves like a list, with extra indexing options, method chaining and more methods.
+- Add methods to existing classes, including built-ins, with the `@patch` decorator instead of subclassing.
+- In `__init__` methods, call [`store_attr()`](https://fastcore.fast.ai/basics.html#store_attr) to set multiple attributes at once instead of assigning each one.
+- Apply the [`delegates`](https://fastcore.fast.ai/meta.html#delegates) decorator to show a function’s real parameters in place of `**kwargs`, for IDEs and generated documentation.
+- Use fastcore’s versions of [`ThreadPoolExecutor`](https://fastcore.fast.ai/parallel.html#threadpoolexecutor) and [`ProcessPoolExecutor`](https://fastcore.fast.ai/parallel.html#processpoolexecutor) for simpler concurrent processing.
+- Prefer fastcore’s test functions, such as [`test_eq`](https://fastcore.fast.ai/test.html#test_eq), [`test_ne`](https://fastcore.fast.ai/test.html#test_ne) and [`test_close`](https://fastcore.fast.ai/test.html#test_close), for assertions that read clearly and give informative failures.
+- fastcore extends [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html#pathlib.Path) with methods such as `ls()` and `read_json()`.
+- Convert between dictionaries and objects with attribute access using [`dict2obj`](https://fastcore.fast.ai/xtras.html#dict2obj) and [`obj2dict`](https://fastcore.fast.ai/xtras.html#obj2dict).
+- Write in a functional style with tools such as [`compose`](https://fastcore.fast.ai/basics.html#compose), [`maps`](https://fastcore.fast.ai/basics.html#maps) and [`filter_ex`](https://fastcore.fast.ai/basics.html#filter_ex).
+- Document parameters and return values with [`docments`](https://fastcore.fast.ai/docments.html#docments), using source comments or `Annotated` metadata for generated APIs. [`MarkdownRenderer`](https://fastcore.fast.ai/docments.html#markdownrenderer) shows the effective signature and keeps usage sections such as Notes, Raises and Examples.
+- Apply the [`timed_cache`](https://fastcore.fast.ai/xtras.html#timed_cache) decorator to add time-based expiry to the standard `lru_cache`.
+- Turn Python functions into command-line interfaces with `fastcore.script`.
 
 For example, [`L`](https://fastcore.fast.ai/foundation.html#l) is a drop-in replacement for `list` with extra superpowers:
 
@@ -88,8 +88,6 @@ To install fastcore run: `conda install fastcore -c fastai` (if you use Anaconda
 
 To get started, we recommend you read through [the fastcore tour](https://fastcore.fast.ai/tour.html).
 
-[`globtastic`](https://fastcore.fast.ai/xtras.html#globtastic) supports filename filters (`file_glob`, `file_re`) and full-path filters (`path_glob`, `path_re`). Glob filters use `fnmatch`: `*` matches directory separators and `**` has no special meaning.
-
 ## Contributing
 
 After you clone this repository, please run `nbdev_install_hooks` in your terminal. This sets up git hooks, which clean up the notebooks to remove the extraneous stuff stored in the notebooks (e.g. which cells you ran) which causes unnecessary merge conflicts.

{fastcore-2.2.32 → fastcore-2.2.34}/README.md

@@ -13,19 +13,19 @@ Python is a powerful, dynamic language. Rather than bake everything into the lan
 
 Here are some tips on using fastcore:
 
-- **Liberal imports**: Use `from fastcore.module import *` freely. The library is designed for safe wildcard imports.
-- **Enhanced list operations**: Substitute `list` with [`L`](https://fastcore.fast.ai/foundation.html#l). This provides advanced indexing, method chaining, and additional functionality while maintaining list-like behavior.
-- **Extend existing classes**: Apply the `@patch` decorator to add methods to classes, including built-ins, without subclassing.
-- **Streamline class initialization**: In `__init__` methods, use [`store_attr()`](https://fastcore.fast.ai/basics.html#store_attr) to efficiently set multiple attributes, reducing repetitive assignment code.
-- **Explicit keyword arguments**: Apply the [`delegates`](https://fastcore.fast.ai/meta.html#delegates) decorator to functions to replace `**kwargs` with specific parameters, enhancing IDE support and documentation.
-- **Optimize parallel execution**: Use fastcore’s enhanced [`ThreadPoolExecutor`](https://fastcore.fast.ai/parallel.html#threadpoolexecutor) and [`ProcessPoolExecutor`](https://fastcore.fast.ai/parallel.html#processpoolexecutor) for simplified concurrent processing.
-- **Expressive testing**: Prefer fastcore’s testing functions like [`test_eq`](https://fastcore.fast.ai/test.html#test_eq), [`test_ne`](https://fastcore.fast.ai/test.html#test_ne), [`test_close`](https://fastcore.fast.ai/test.html#test_close) for more readable and informative test assertions.
-- **Advanced file operations**: Use the extended `Path` class, which adds methods like `ls()`, `read_json()`, and others to [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html#pathlib.Path).
-- **Flexible data structures**: Convert between dictionaries and attribute-access objects using [`dict2obj`](https://fastcore.fast.ai/xtras.html#dict2obj) and [`obj2dict`](https://fastcore.fast.ai/xtras.html#obj2dict) for more intuitive data handling.
-- **Functional programming paradigms**: Use tools like [`compose`](https://fastcore.fast.ai/basics.html#compose), [`maps`](https://fastcore.fast.ai/basics.html#maps), and [`filter_ex`](https://fastcore.fast.ai/basics.html#filter_ex) to write more functional-style Python code.
-- **Documentation**: Document parameters and return values with [`docments`](https://fastcore.fast.ai/docments.html#docments), using source comments or `Annotated` metadata for generated APIs. [`MarkdownRenderer`](https://fastcore.fast.ai/docments.html#markdownrenderer) shows the effective signature and retains usage sections such as Notes, Raises, and Examples.
-- **Time-aware caching**: Apply the [`timed_cache`](https://fastcore.fast.ai/xtras.html#timed_cache) decorator to add time-based expiration to the standard `lru_cache` functionality.
-- **Simplified CLI creation**: Use `fastcore.script` to easily transform Python functions into command-line interfaces.
+- Use `from fastcore.module import *` freely. fastcore’s modules are built to be safe for wildcard imports.
+- Use [`L`](https://fastcore.fast.ai/foundation.html#l) in place of `list`. [`L`](https://fastcore.fast.ai/foundation.html#l) behaves like a list, with extra indexing options, method chaining and more methods.
+- Add methods to existing classes, including built-ins, with the `@patch` decorator instead of subclassing.
+- In `__init__` methods, call [`store_attr()`](https://fastcore.fast.ai/basics.html#store_attr) to set multiple attributes at once instead of assigning each one.
+- Apply the [`delegates`](https://fastcore.fast.ai/meta.html#delegates) decorator to show a function’s real parameters in place of `**kwargs`, for IDEs and generated documentation.
+- Use fastcore’s versions of [`ThreadPoolExecutor`](https://fastcore.fast.ai/parallel.html#threadpoolexecutor) and [`ProcessPoolExecutor`](https://fastcore.fast.ai/parallel.html#processpoolexecutor) for simpler concurrent processing.
+- Prefer fastcore’s test functions, such as [`test_eq`](https://fastcore.fast.ai/test.html#test_eq), [`test_ne`](https://fastcore.fast.ai/test.html#test_ne) and [`test_close`](https://fastcore.fast.ai/test.html#test_close), for assertions that read clearly and give informative failures.
+- fastcore extends [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html#pathlib.Path) with methods such as `ls()` and `read_json()`.
+- Convert between dictionaries and objects with attribute access using [`dict2obj`](https://fastcore.fast.ai/xtras.html#dict2obj) and [`obj2dict`](https://fastcore.fast.ai/xtras.html#obj2dict).
+- Write in a functional style with tools such as [`compose`](https://fastcore.fast.ai/basics.html#compose), [`maps`](https://fastcore.fast.ai/basics.html#maps) and [`filter_ex`](https://fastcore.fast.ai/basics.html#filter_ex).
+- Document parameters and return values with [`docments`](https://fastcore.fast.ai/docments.html#docments), using source comments or `Annotated` metadata for generated APIs. [`MarkdownRenderer`](https://fastcore.fast.ai/docments.html#markdownrenderer) shows the effective signature and keeps usage sections such as Notes, Raises and Examples.
+- Apply the [`timed_cache`](https://fastcore.fast.ai/xtras.html#timed_cache) decorator to add time-based expiry to the standard `lru_cache`.
+- Turn Python functions into command-line interfaces with `fastcore.script`.
 
 For example, [`L`](https://fastcore.fast.ai/foundation.html#l) is a drop-in replacement for `list` with extra superpowers:
 
@@ -57,8 +57,6 @@ To install fastcore run: `conda install fastcore -c fastai` (if you use Anaconda
 
 To get started, we recommend you read through [the fastcore tour](https://fastcore.fast.ai/tour.html).
 
-[`globtastic`](https://fastcore.fast.ai/xtras.html#globtastic) supports filename filters (`file_glob`, `file_re`) and full-path filters (`path_glob`, `path_re`). Glob filters use `fnmatch`: `*` matches directory separators and `**` has no special meaning.
-
 ## Contributing
 
 After you clone this repository, please run `nbdev_install_hooks` in your terminal. This sets up git hooks, which clean up the notebooks to remove the extraneous stuff stored in the notebooks (e.g. which cells you ran) which causes unnecessary merge conflicts.

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/__init__.py

@@ -4,19 +4,19 @@ Python is a powerful, dynamic language. Rather than bake everything into the lan
 
 Here are some tips on using fastcore:
 
-- **Liberal imports**: Use `from fastcore.module import *` freely. The library is designed for safe wildcard imports.
-- **Enhanced list operations**: Substitute `list` with `L`. This provides advanced indexing, method chaining, and additional functionality while maintaining list-like behavior.
-- **Extend existing classes**: Apply the `@patch` decorator to add methods to classes, including built-ins, without subclassing.
-- **Streamline class initialization**: In `__init__` methods, use `store_attr()` to efficiently set multiple attributes, reducing repetitive assignment code.
-- **Explicit keyword arguments**: Apply the `delegates` decorator to functions to replace `**kwargs` with specific parameters, enhancing IDE support and documentation.
-- **Optimize parallel execution**: Use fastcore's enhanced `ThreadPoolExecutor` and `ProcessPoolExecutor` for simplified concurrent processing.
-- **Expressive testing**: Prefer fastcore's testing functions like `test_eq`, `test_ne`, `test_close` for more readable and informative test assertions.
-- **Advanced file operations**: Use the extended `Path` class, which adds methods like `ls()`, `read_json()`, and others to `pathlib.Path`.
-- **Flexible data structures**: Convert between dictionaries and attribute-access objects using `dict2obj` and `obj2dict` for more intuitive data handling.
-- **Functional programming paradigms**: Use tools like `compose`, `maps`, and `filter_ex` to write more functional-style Python code.
-- **Documentation**: Document parameters and return values with `docments`, using source comments or `Annotated` metadata for generated APIs. `MarkdownRenderer` shows the effective signature and retains usage sections such as Notes, Raises, and Examples.
-- **Time-aware caching**: Apply the `timed_cache` decorator to add time-based expiration to the standard `lru_cache` functionality.
-- **Simplified CLI creation**: Use `fastcore.script` to easily transform Python functions into command-line interfaces.
+- Use `from fastcore.module import *` freely. fastcore's modules are built to be safe for wildcard imports.
+- Use `L` in place of `list`. `L` behaves like a list, with extra indexing options, method chaining and more methods.
+- Add methods to existing classes, including built-ins, with the `@patch` decorator instead of subclassing.
+- In `__init__` methods, call `store_attr()` to set multiple attributes at once instead of assigning each one.
+- Apply the `delegates` decorator to show a function's real parameters in place of `**kwargs`, for IDEs and generated documentation.
+- Use fastcore's versions of `ThreadPoolExecutor` and `ProcessPoolExecutor` for simpler concurrent processing.
+- Prefer fastcore's test functions, such as `test_eq`, `test_ne` and `test_close`, for assertions that read clearly and give informative failures.
+- fastcore extends `pathlib.Path` with methods such as `ls()` and `read_json()`.
+- Convert between dictionaries and objects with attribute access using `dict2obj` and `obj2dict`.
+- Write in a functional style with tools such as `compose`, `maps` and `filter_ex`.
+- Document parameters and return values with `docments`, using source comments or `Annotated` metadata for generated APIs. `MarkdownRenderer` shows the effective signature and keeps usage sections such as Notes, Raises and Examples.
+- Apply the `timed_cache` decorator to add time-based expiry to the standard `lru_cache`.
+- Turn Python functions into command-line interfaces with `fastcore.script`.
 
 For example, `L` is a drop-in replacement for `list` with extra superpowers:
 
@@ -55,4 +55,4 @@ Modules:
 - `fastcore.xml`: Concise HTML generation and namespace-aware XML construction.
 - `fastcore.xtras`: Utility functions used in the fastai library"""
 
-__version__ = "2.2.32"
+__version__ = "2.2.34"

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/_modidx.py

@@ -656,6 +656,7 @@ d = { 'settings': { 'branch': 'main',
                               'fastcore.net._SafeRedirectHandler': ('net.html#_saferedirecthandler', 'fastcore/net.py'),
                               'fastcore.net._SafeRedirectHandler.redirect_request': ( 'net.html#_saferedirecthandler.redirect_request',
                                                                                       'fastcore/net.py'),
+                              'fastcore.net._http_exc': ('net.html#_http_exc', 'fastcore/net.py'),
                               'fastcore.net._socket_det': ('net.html#_socket_det', 'fastcore/net.py'),
                               'fastcore.net._waitfor': ('net.html#_waitfor', 'fastcore/net.py'),
                               'fastcore.net.free_port': ('net.html#free_port', 'fastcore/net.py'),

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/ansi.py

@@ -9,20 +9,21 @@ from html import escape
 __all__ = ["strip_ansi", "ansi2html", "ansi2latex"]
 
 _ANSI_RE = re.compile("\x1b\\[(.*?)([@-~])")
+_OSC_RE = re.compile(r'\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)')
 _ANSI_COLORS = ( "ansi-black", "ansi-red", "ansi-green", "ansi-yellow", "ansi-blue", "ansi-magenta", "ansi-cyan", "ansi-white", "ansi-black-intense",
     "ansi-red-intense", "ansi-green-intense", "ansi-yellow-intense", "ansi-blue-intense", "ansi-magenta-intense", "ansi-cyan-intense", "ansi-white-intense")
 
 def strip_terminal_queries(text):
-    # Remove OSC sequences (like background color queries)
-    text = re.sub('\x1b\\][^\x07]*\x07', '', text)
+    # Remove OSC sequences, such as hyperlinks and background color queries
+    text = _OSC_RE.sub('', text)
     # Remove DSR sequences (device status reports)
     return re.sub(r'\x1b\[[0-9]*n', '', text)
 
 
 def strip_ansi(source, term_queries:bool=False):
-    "Remove ANSI escape codes from text."
+    "Remove ANSI escape codes, including OSC sequences such as hyperlinks, from text."
     if term_queries: source = strip_terminal_queries(source)
-    return _ANSI_RE.sub("", source)
+    return _ANSI_RE.sub("", _OSC_RE.sub("", source))
 
 
 def _htmlconverter(fg, bg, bold, underline, inverse):

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/basics.py

@@ -1,10 +1,10 @@
 """Basic functionality used in the fastai library
 
-The staples used throughout fastai code, each replacing a common multi-line pattern with a one-liner: `ifnone(a,b)` is `b if a is None else a` (though both args are always evaluated); `listify` and `tuplify` convert anything to a list or tuple the way you'd mean it (`None` becomes `[]`, a `str` or `dict` stays a single item, a generator is consumed); and `basic_repr('a,b')` gives a class a deterministic `key=value` repr with no memory address, so notebook and git diffs stay clean.
+The staples used throughout fastai code, each replacing a common multi-line pattern with a one-liner.
 
 Curried versions of the comparison and arithmetic functions in Python's `operator` module: `lt gt le ge eq ne add sub mul truediv is_ is_not in_ mod`. With two args they work like `operator`'s versions; with one arg they return a partial that binds it as the *second* argument, so `lt(3)` means "is less than 3" and `in_(vals)` means "is contained in `vals`". They read especially well as `cmp` arguments to `fastcore.test.test`, e.g. `test(x, valid, in_)`.
 
-`AttrDict` is a `dict` whose keys are also attributes, so `d.foo` reads and writes `d['foo']` (to convert a whole nested structure at once, see `dict2obj` in `fastcore.xtras`); `NS` is the same idea built on `SimpleNamespace`, adding indexing and iteration. `store_attr()`, called inside `__init__`, stores the function's arguments as attributes of `self` in one line:
+`store_attr()`, called inside `__init__`, stores the function's arguments as attributes of `self` in one line:
 
 ```python
 class Point:
@@ -13,7 +13,7 @@ p = Point(1, 2)
 test_eq((p.x, p.y, p.scale), (1, 2, 1))
 ```
 
-Tools for making and transforming functions: `compose(f,g,...)` chains functions left to right; `bind` is `partial` extended with `arg0`,`arg1`,... placeholders for reordering positional arguments; and `fail_clean` re-raises exceptions with the library's own traceback frames stripped, for errors that are part of a function's contract rather than bugs.
+Utilities for functional programming or for defining, modifying, or debugging functions.
 
 `~Self` is a concise alternative to `lambda` for a function that operates on a single object (note the capitalization!). Write the chain of attribute accesses, method calls, and indexing just as you would after a variable name, with `~Self` in its place, and the result is a plain function that runs the chain on its argument:
 
@@ -25,7 +25,7 @@ Tools for making and transforming functions: `compose(f,g,...)` chains functions
 
 Since `.`, `()`, and `[]` bind tighter than `~`, the whole chain builds first and `~` then converts it to a function, so the chain never needs its own parentheses: `map(~Self.imag, nums)` works as written.
 
-`@patch` adds a function to an existing class as a method, using the function's `self:` type annotation to pick the class (a union annotation patches several classes at once); `@patch_to(Cls)` is the same with the class passed explicitly. Both take `as_prop`, `set_prop`, and `cls_method`. fastai code uses this to build classes incrementally across a notebook, so expect to find a class's methods defined far from the class itself:
+fastai code builds classes incrementally across a notebook. A class's methods often appear far from the class itself. `@patch` adds a function to an existing class as a method, and picks the class from the function's `self:` annotation:
 
 ```python
 @patch
@@ -1314,6 +1314,7 @@ class NotStr(GetAttr):
 class PrettyString(str):
     "Little hack to get strings to show properly in Jupyter."
     def __repr__(self): return self
+    full = True # Tools that truncate long strings show this whole
 
 # %% ../nbs/01_basics.ipynb #a5138103
 def even_mults(start, stop, n):

fastcore-2.2.34/fastcore/editskill.py

@@ -0,0 +1,62 @@
+"""Text, file, cell, and notebook editing from `fastcore.tools` and `fastcore.nbio`, plus the conventions the whole fastai editing toolkit follows. Read this before working with the editing tools in any package that shares them.
+
+`from fastcore.editskill import *` loads `fastcore.tools` and `fastcore.nbio`.
+
+## Targets and tools
+
+Targets: in-memory strings, file paths, notebook cell sources (`path, cell_id`), and held `Notebook`/`NbCell` objects.
+
+- `fastcore.tools`: text primitives, file tools, and `line_hash`/`lnhash`/`lnhash_at` address creation without exhash installed.
+- `fastcore.nbio`: notebook read/write/validate/repair, cell construction/editing, and `Notebook`/`NbCell` session objects with snapshot queries (`find_cells`, `summary_nb`).
+- `exhash.skill`: preferred hash-verified file/cell editing where installed; covers address forms and the verified edit loop.
+- `rgapi.skill`: preferred search where installed: `rg`/`fd`/`ls`/`nbrg` with lnhash output, `rgstr` for text already held.
+- `remold`: structural Python search/rewrite with declarative ast-grep rules, LibCST matcher transforms and symbol queries; the engine behind `ast_replace`.
+- `aidialog.dlgskill`, `dialoghelper`: preferred dialog layer where installed, including its own theory of dialogs and projections. A Solveit dialog is an `.ipynb` with notes, runnable code and prompt/reply pairs. Cell tools handle notebook structure regardless of origin; this layer reads/edits dialog messages.
+
+Open/save: `Notebook.open(path)`, `nb.save()`. Index by position or cell id (exact/unique prefix): `nb[k]` returns a cell, `nb[k] = src` sets its source, `del nb[k]` removes it. `nb.add(src, cell_type)`/`nb.md(src)` insert at `idx`, `after` or `before` a cell id; `nb.move(ids, after=, before=)` reorders cells.
+
+## Naming
+
+- File/notebook/cell/message operations: `verb_target` (`view_file`, `create_file`, `read_nb`, `write_nb`, `view_cell`, `validate_nb`, `view_msg`, `view_dlg`, `lnhashview_cell`). `find_msgs`, `add_msg`, `del_msgs`, `find_cells` need no extra dialog/notebook prefix. `msg` = dialog message; `cell` = notebook cell; `summary_nb` returns notebook-cell rows.
+- Text primitives (`insert_line`, `del_lines`, `replace_lines`, `str_replace`) gain `file_`/`cell_`/`msg_` prefixes (`file_del_lines`, `cell_del_lines`, `msg_del_lines`); address arguments precede the primitive's arguments. `str_replace` retains Anthropic's text editor name/argument order. `ast_replace` (AST patterns) and `exhash` (hash-verified line addresses) use these prefixes too: `file_ast_replace`, `msg_ast_replace`, `file_exhash`, `cell_exhash`.
+- Converters: `x2y` (`nb2dict`, `cell2xml`); methods: `to_y` (`nb.to_dict()`).
+- Plurals accept several items: `view_cell` one cell, `lnhashview_cells` several, `del_msgs` many.
+
+## Parameters: shared vocabulary
+
+- Order: address (`text`; `path`; `path, cell_id`; message `id`), new text, then keyword-only ambient context (message tools' dialog).
+- `start_line`/`end_line`: 1-based, inclusive; `None` = first/last line; negative `end_line` counts from the end. `del_lines` has no defaults: state the range.
+- `re_filter`/`invert_filter`: lines (not) matching a regex, like ex `g//`/`g!//`; combines with the range.
+- Search patterns default to regex; editors default to literal unless `use_regex=True`.
+- Views: `nums` line numbers; `lnhashs` `lineno|hash|` addresses; `maxlen` caps summary lines; `trunc_out`/`trunc_in` truncate dialog outputs/sources.
+- `fd`/`ls`/`rg`/`nbrg` share one include/exclude/ext/hidden/ignore block. `fd`/`rg`/`nbrg`: `pattern` first, `root='.'` second. `ls` is `fd` with listing defaults, but `root` first, like shell `ls DIR`.
+- Filters narrow with `only_*` (`only_err`, `only_exp`, `only_errors`), widen with `incl_*` (`incl_out`).
+- `context=` units: file lines (blocks in summary mode), notebook cells, dialog messages.
+- Editors return a diff: read it as verification rather than re-viewing. No change: fastcore editors and exhash return `none: No changes.`
+
+## Functions and methods
+
+Functions take a path, save and return a diff; methods change held objects, saved explicitly. Methods drop address arguments and the object's part of the name: `cell_str_replace(path, cell_id, ...)` -> `c.str_replace(...)` on `NbCell`; `find_cells(path, pat)` -> `nb.find_cells(pat)` on `Notebook`. Read functions return snapshot rows (addresses, source, metadata); read methods return objects. One style per file: save before switching to functions; reopen before returning to methods.
+
+## Navigation and addresses
+
+When unsure where to edit, start with summaries: rgapi's `rg(summary=True)`/`nbrg`, aidialog's `summary_dlg`, exhash's `open_doc` outlines. They give one addressed row per block/cell/message/section. `open_doc` outlines Markdown, code and notebooks; `doc(open_doc)` covers inputs, navigation and llms.txt. A section is a span of lines or a run of cells, edited through file/cell tools. Token `1.6.|12|Py|,45|HD|` combines section number and first/last-line lnhash range; the range is an exhash address.
+
+Edits take plain line numbers or lnhash addresses obtained while reading: `nums=True`/`lnhashs=True` views, `rg(lnhashs=True)`. Prefer lnhash addresses where exhash is installed; stale ones are rejected. Plain numbers are unverified and shift: re-view after each such edit; apply several bottom-to-top.
+
+Docs: https://fastcore.fast.ai/tools.html.md and https://fastcore.fast.ai/nbio.html.md
+"""
+
+from fastcore.tools import (insert_line, str_replace, strs_replace, replace_lines, del_lines, ast_replace,
+    file_insert_line, file_str_replace, file_strs_replace, file_replace_lines, file_del_lines, file_ast_replace,
+    view_file, create_file, line_hash, lnhash, lnhash_at)
+from fastcore.nbio import (read_nb, write_nb, new_nb, mk_cell, validate_nb, validate_cell, repair_nb, repair_cell,
+    view_cell, cell_insert_line, cell_str_replace, cell_strs_replace, cell_replace_lines, cell_del_lines, cell_ast_replace, Notebook, NbCell, find_cells, summary_nb)
+
+__all__ = ['insert_line', 'str_replace', 'strs_replace', 'replace_lines', 'del_lines', 'ast_replace',
+    'file_insert_line', 'file_str_replace', 'file_strs_replace', 'file_replace_lines', 'file_del_lines', 'file_ast_replace',
+    'view_file', 'create_file', 'line_hash', 'lnhash', 'lnhash_at',
+    'read_nb', 'write_nb', 'new_nb', 'mk_cell', 'validate_nb', 'validate_cell', 'repair_nb', 'repair_cell',
+    'view_cell', 'cell_insert_line', 'cell_str_replace', 'cell_strs_replace', 'cell_replace_lines', 'cell_del_lines', 'cell_ast_replace', 'Notebook', 'NbCell', 'find_cells', 'summary_nb']
+
+__pyskill_params__ = {'replace_params': ('start_line', 'end_line', 'n_matches', 're_filter', 'invert_filter', 'use_regex')}

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/funccall.py

@@ -219,10 +219,9 @@ def _nm_map(nms):
     return py2orig
 
 # %% ../nbs/14_funccall.ipynb #47b49644
-def call_func(fc_name, fc_inputs, ns, raise_on_err=True):
-    "Call the function `fc_name` with the given `fc_inputs` using namespace `ns`."
-    if not isinstance(ns, abc.Mapping): ns = mk_ns(ns)
-    func = resolve_nm(fc_name, ns)
+def call_func(fc_name, fc_inputs, ns=None, raise_on_err=True):
+    "Call `fc_name`, a function or its name in namespace `ns`, with the given `fc_inputs`."
+    func = resolve_nm(fc_name, mk_ns(ns)) if isinstance(fc_name, str) else fc_name
     inps = {_norm_nm(k):v for k,v in fc_inputs.items()}
     inps = coerce_inputs(func, inps)
     try: return func(**inps)
@@ -231,17 +230,12 @@ def call_func(fc_name, fc_inputs, ns, raise_on_err=True):
         else: return traceback.format_exc()
 
 # %% ../nbs/14_funccall.ipynb #73bca085
-async def call_func_async(fc_name, fc_inputs, ns, raise_on_err=True):
-    "Awaits the function `fc_name` with the given `fc_inputs` using namespace `ns`."
-    if not isinstance(ns, abc.Mapping): ns = mk_ns(ns)
-    func = resolve_nm(fc_name, ns)
-    try:
-        res = call_func(fc_name, fc_inputs, ns, raise_on_err=raise_on_err)
-        res = await maybe_await(res)
+async def call_func_async(fc_name, fc_inputs, ns=None, raise_on_err=True):
+    "Awaits `fc_name`, a function or its name in namespace `ns`, with the given `fc_inputs`."
+    try: return await maybe_await(call_func(fc_name, fc_inputs, ns, raise_on_err=raise_on_err))
     except Exception as e:
         if raise_on_err: raise e from None
         else: return traceback.format_exc()
-    return res
 
 # %% ../nbs/14_funccall.ipynb #5a2588d5
 type_map = dict(string=str, boolean=bool, integer=int, number=float, array=list, object=dict)

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/nbio.py

@@ -1,10 +1,10 @@
 """Reading, writing, and running Jupyter notebooks
 
-Cell tools apply `fastcore.tools`' string editing primitives to one notebook cell's source, addressed by path and cell id, mirroring that module's file tools: the same operations and parameters, with `path, cell_id` in place of `path`. Each editor (including the structural `cell_ast_replace`) returns a diff of the change, and `view_cell` shows a cell's source with optional line numbers or exhash addresses.
+The cell tools apply `fastcore.tools`' string editing primitives to one notebook cell's source. They match that module's file tools, with the same operations and parameters, but take `path, cell_id` where the file tools take `path`. Every editor, including the structural `cell_ast_replace`, returns a diff of its change. `view_cell` shows a cell's source with optional line numbers or exhash addresses.
 
-Naming and parameter conventions shared across the editing toolkit are documented in `fastcore.editskill`, which also re-exports this module's editing tools.
+`fastcore.editskill` documents the naming and parameter conventions shared across the editing toolkit, and re-exports this module's editing tools.
 
-`diff_cells` compares two versions of a cell sequence -- an open notebook against its file on disk, a dialog against an edited copy -- and yields the edits that turn one into the other. Items are aligned by `id` (any objects with `.id` work, not just cells), and each edit is a *block*: a contiguous run of deletions, insertions, or in-place changes, so an applier can handle a whole run at once and inserted items keep their order. Identity questions ride the ids; whether an aligned pair *changed* is a content question, answered by comparing `key(item)` on each side.
+`diff_cells` compares two versions of a cell sequence, such as an open notebook and its file on disk, or a dialog and an edited copy. It yields the edits that turn one into the other. It aligns items by `id`, and works with any objects that have an `.id`, not just cells. Each edit is a *block* covering a contiguous run of deletions, insertions or in-place changes. An applier can handle each block in one step, keeping inserted items in order. An aligned pair counts as changed when `key(item)` differs between the two sides.
 
 Docs: https://fastcore.fast.ai/nbio.html.md"""
 
@@ -799,9 +799,10 @@ def to_dict(self:Notebook):
 class Found:
     "Mixin for find-result containers: `matched` ids, id-only indexing, and match/context kinds"
     _unit = 'item'
-    def __init__(self, items=None, matched=None):
+    def __init__(self, items=None, matched=None, maxlen=MAXLEN):
         super().__init__(items if items is not None else [])
         self.matched = set(matched) if matched is not None else {o.id for o in self}
+        self.maxlen = maxlen
     def kind(self, o): return 'match' if o.id in self.matched else 'context'
     def __getitem__(self, k):
         if not isinstance(k, str): raise TypeError(
@@ -814,7 +815,7 @@ class FoundCells(Found, list):
     "Find results: cells indexed by id (exact or unique prefix), shown as `CellRow` lines with context rows marked"
     _unit = 'cell'
     def __repr__(self):
-        rows = [c if isinstance(c, CellRow) else CellRow(c) for c in self]
+        rows = [c if isinstance(c, CellRow) else CellRow(c, self.maxlen) for c in self]
         for r in rows: r.kind = self.kind(r)
         return '\n'.join(repr(r) for r in rows)
 
@@ -825,6 +826,7 @@ def find_cells(self:Notebook,
     cell_type:str=None, # Optional limit by type ('code', 'markdown', or 'raw')
     ids='', # Optional limit by cell ids (comma-separated str, or list); exact or unique prefixes
     context:int=None, # Cells of context around matches (default 1)
+    maxlen:int=MAXLEN, # Maximum source characters per displayed cell
 ):
     "Find live cells matching all the given criteria, plus `context` neighbouring cells"
     if context is None: context = 1
@@ -832,7 +834,7 @@ def find_cells(self:Notebook,
     cs = self.cells
     idxs = [i for i,c in enumerate(cs) if (not pat or re.search(pat, c.source)) and (not cell_type or c.cell_type==cell_type) and (not ids or c.id in ids)]
     keep = sorted({j for i in idxs for j in range(max(0,i-context), min(len(cs),i+context+1))})
-    return FoundCells([cs[j] for j in keep], matched={cs[i].id for i in idxs})
+    return FoundCells([cs[j] for j in keep], matched={cs[i].id for i in idxs}, maxlen=maxlen)
 
 # %% ../nbs/13_nbio.ipynb #cb639e77
 def find_cells(
@@ -841,10 +843,11 @@ def find_cells(
     cell_type:str=None, # Optional limit by type ('code', 'markdown', or 'raw')
     ids='', # Optional limit by cell ids (comma-separated str, or list); exact or unique prefixes
     context:int=None, # Cells of context around matches (default 1)
+    maxlen:int=MAXLEN, # Maximum source characters per displayed cell
 ):
     "Snapshot `FoundCells` for matching cells in the notebook at `path`"
     fc = Notebook.open(path).find_cells(pat, cell_type, ids=ids, context=context)
-    return FoundCells([CellRow(c) for c in fc], matched=fc.matched)
+    return FoundCells([CellRow(c, maxlen) for c in fc], matched=fc.matched)
 
 # %% ../nbs/13_nbio.ipynb #202a29f1
 def deep_merge(

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/net.py

@@ -1,6 +1,6 @@
 """Network, HTTP, and URL functions
 
-`urlread`/`urljson` retrieve a URL (POSTing when `data` or kwargs are given), `urlsave` downloads to a file named from the URL, and `urlopen` wraps `urllib` with quoting, header, and data handling; on HTTP failure they raise a status-specific exception (`HTTP404NotFoundError`, ...), each a subclass of `HTTP4xxClientError` or `HTTP5xxServerError`, with the response body included in the message. `start_server`/`start_client` make TCP — or, passing a string `port`, Unix-socket — connections; `waitfor` polls a callable until truthy with a timeout; and `is_port_free`/`wait_port_free` help coordinate with servers.
+Every URL function here goes through `urlopen`. It quotes the URL, sends `url_default_headers`, and encodes `data`. On an HTTP error it raises the status-specific exception for the code, such as `HTTP404NotFoundError` or `HTTP503ServiceUnavailableError`. Each is a subclass of `HTTP4xxClientError` or `HTTP5xxServerError`. Its message includes the response body. The module also has TCP and Unix-socket clients and servers, and helpers that wait for a condition or a free port.
 
 Docs: https://fastcore.fast.ai/net.html.md"""
 
@@ -19,7 +19,11 @@ __all__ = ['url_default_headers', 'ExceptionsHTTP', 'urlquote', 'urlwrap', 'HTTP
            'HTTP418AmAteapotError', 'HTTP421MisdirectedRequestError', 'HTTP422UnprocessableEntityError',
            'HTTP423LockedError', 'HTTP424FailedDependencyError', 'HTTP425TooEarlyError', 'HTTP426UpgradeRequiredError',
            'HTTP428PreconditionRequiredError', 'HTTP429TooManyRequestsError', 'HTTP431HeaderFieldsTooLargeError',
-           'HTTP451LegalReasonsError']
+           'HTTP451LegalReasonsError', 'HTTP500InternalServerError', 'HTTP501NotImplementedError',
+           'HTTP502BadGatewayError', 'HTTP503ServiceUnavailableError', 'HTTP504GatewayTimeoutError',
+           'HTTP505HTTPVersionNotSupportedError', 'HTTP506VariantAlsoNegotiatesError',
+           'HTTP507InsufficientStorageError', 'HTTP508LoopDetectedError', 'HTTP510NotExtendedError',
+           'HTTP511NetworkAuthenticationRequiredError']
 
 # %% ../nbs/03b_net.ipynb #05c808e7
 from .utils import *
@@ -99,18 +103,28 @@ _httperrors = ((400,'Bad Request'),(401,'Unauthorized'),(402,'Payment Required')
     (414,'URI Too Long'),(415,'Unsupported Media Type'),(416,'Range Not Satisfiable'),(417,'Expectation Failed'),
     (418,'Am A teapot'),(421,'Misdirected Request'),(422,'Unprocessable Entity'),(423,'Locked'),(424,'Failed Dependency'),
     (425,'Too Early'),(426,'Upgrade Required'),(428,'Precondition Required'),(429,'Too Many Requests'),
-    (431,'Header Fields Too Large'),(451,'Legal Reasons'))
+    (431,'Header Fields Too Large'),(451,'Legal Reasons'),(500,'Internal Server Error'),(501,'Not Implemented'),
+    (502,'Bad Gateway'),(503,'Service Unavailable'),(504,'Gateway Timeout'),(505,'HTTP Version Not Supported'),
+    (506,'Variant Also Negotiates'),(507,'Insufficient Storage'),(508,'Loop Detected'),(510,'Not Extended'),
+    (511,'Network Authentication Required'))
 
 for code,msg in _httperrors:
-    nm = f'HTTP{code}{msg.replace(" ","")}Error'
-    def _init(self, url, hdrs, fp, msg=msg, code=code): HTTP4xxClientError.__init__(self, url, code, msg, hdrs, fp)
-    cls = type(nm, (HTTP4xxClientError,), {'__init__':_init})
+    base = HTTP4xxClientError if code<500 else HTTP5xxServerError
+    nm = f'HTTP{code}{msg.replace(" ","").removesuffix("Error")}Error'
+    def _init(self, url, hdrs, fp, msg=msg, code=code, base=base): base.__init__(self, url, code, msg, hdrs, fp)
+    cls = type(nm, (base,), {'__init__':_init})
     globals()[nm] = ExceptionsHTTP[code] = cls
 
 # %% ../nbs/03b_net.ipynb #21fa32a4
-_all_ = ['HTTP400BadRequestError', 'HTTP401UnauthorizedError', 'HTTP402PaymentRequiredError', 'HTTP403ForbiddenError', 'HTTP404NotFoundError', 'HTTP405MethodNotAllowedError', 'HTTP406NotAcceptableError', 'HTTP407ProxyAuthRequiredError', 'HTTP408RequestTimeoutError', 'HTTP409ConflictError', 'HTTP410GoneError', 'HTTP411LengthRequiredError', 'HTTP412PreconditionFailedError', 'HTTP413PayloadTooLargeError', 'HTTP414URITooLongError', 'HTTP415UnsupportedMediaTypeError', 'HTTP416RangeNotSatisfiableError', 'HTTP417ExpectationFailedError', 'HTTP418AmAteapotError', 'HTTP421MisdirectedRequestError', 'HTTP422UnprocessableEntityError', 'HTTP423LockedError', 'HTTP424FailedDependencyError', 'HTTP425TooEarlyError', 'HTTP426UpgradeRequiredError', 'HTTP428PreconditionRequiredError', 'HTTP429TooManyRequestsError', 'HTTP431HeaderFieldsTooLargeError', 'HTTP451LegalReasonsError']
+_all_ = ['HTTP400BadRequestError', 'HTTP401UnauthorizedError', 'HTTP402PaymentRequiredError', 'HTTP403ForbiddenError', 'HTTP404NotFoundError', 'HTTP405MethodNotAllowedError', 'HTTP406NotAcceptableError', 'HTTP407ProxyAuthRequiredError', 'HTTP408RequestTimeoutError', 'HTTP409ConflictError', 'HTTP410GoneError', 'HTTP411LengthRequiredError', 'HTTP412PreconditionFailedError', 'HTTP413PayloadTooLargeError', 'HTTP414URITooLongError', 'HTTP415UnsupportedMediaTypeError', 'HTTP416RangeNotSatisfiableError', 'HTTP417ExpectationFailedError', 'HTTP418AmAteapotError', 'HTTP421MisdirectedRequestError', 'HTTP422UnprocessableEntityError', 'HTTP423LockedError', 'HTTP424FailedDependencyError', 'HTTP425TooEarlyError', 'HTTP426UpgradeRequiredError', 'HTTP428PreconditionRequiredError', 'HTTP429TooManyRequestsError', 'HTTP431HeaderFieldsTooLargeError', 'HTTP451LegalReasonsError', 'HTTP500InternalServerError', 'HTTP501NotImplementedError', 'HTTP502BadGatewayError', 'HTTP503ServiceUnavailableError', 'HTTP504GatewayTimeoutError', 'HTTP505HTTPVersionNotSupportedError', 'HTTP506VariantAlsoNegotiatesError', 'HTTP507InsufficientStorageError', 'HTTP508LoopDetectedError', 'HTTP510NotExtendedError', 'HTTP511NetworkAuthenticationRequiredError']
 
 # %% ../nbs/03b_net.ipynb #0d72881c
+def _http_exc(e):
+    "The status-specific exception for `HTTPError` `e`, or `e` itself outside 4xx and 5xx"
+    if e.code in ExceptionsHTTP: return ExceptionsHTTP[e.code](e.url, e.hdrs, e.fp, msg=e.msg)
+    if 400 <= e.code < 600: return (HTTP4xxClientError if e.code<500 else HTTP5xxServerError)(e.url, e.code, e.msg, e.hdrs, e.fp)
+    return e
+
 def urlopen(url, data=None, headers=None, timeout=None, **kwargs):
     "Like `urllib.request.urlopen`, but first `urlwrap` the `url`, and encode `data`"
     if kwargs and not data: data=kwargs
@@ -118,18 +132,14 @@ def urlopen(url, data=None, headers=None, timeout=None, **kwargs):
         if not isinstance(data, strtyps): data = urlencode(data)
         if not isinstance(data, bytes): data = data.encode('ascii')
     try: return urlopener().open(urlwrap(url, data=data, headers=headers), timeout=timeout)
-    except HTTPError as e: 
+    except HTTPError as e:
         e.msg += f"\n====Error Body====\n{e.read().decode(errors='ignore')}"
-        raise
+        raise _http_exc(e) from None
 
 # %% ../nbs/03b_net.ipynb #fa6a4dfe
 def urlread(url, data=None, headers=None, decode=True, return_json=False, return_headers=False, timeout=None, **kwargs):
     "Retrieve `url`, using `data` dict or `kwargs` to `POST` if present"
-    try:
-        with urlopen(url, data=data, headers=headers, timeout=timeout, **kwargs) as u: res,hdrs = u.read(),u.headers
-    except HTTPError as e:
-        if 400 <= e.code < 500: raise ExceptionsHTTP[e.code](e.url, e.hdrs, e.fp, msg=e.msg) from None
-        else: raise
+    with urlopen(url, data=data, headers=headers, timeout=timeout, **kwargs) as u: res,hdrs = u.read(),u.headers
 
     if decode: res = res.decode()
     if return_json: res = loads(res)

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/style.py

@@ -1,6 +1,6 @@
 """Fast styling for friendly CLIs.
 
-Build ANSI terminal styles by chaining attributes on the exported `S` object, then apply by calling with a string: `S.blue.bold('hi')` returns the escaped string, nesting correctly inside other styles. Chains are plain objects, so a style can be defined once and reused; tab completion on `S.` lists the available colors and effects.
+Build an ANSI terminal style by chaining attributes on the exported `S` object, then apply it by calling it with a string. `S.blue.bold('hi')` returns the escaped string, which nests correctly inside other styles. A chain is a plain object that can be defined once and reused. Tab completion on `S.` lists the available colors and effects.
 
 Docs: https://fastcore.fast.ai/style.html.md"""
 

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/test.py

@@ -1,6 +1,6 @@
 """Helper functions to quickly write tests in notebooks
 
-All the helpers here wrap `test(a,b,cmp)`: an `assert cmp(a,b)` that shows both values when the comparison fails, rather than a bare `AssertionError`. The named comparisons are `test_eq`, `test_ne`, `test_eq_type` (equal and same type), `test_close` (within `eps`, default 1e-5), `test_is`, `test_shuffled` (equal ignoring order), `test_stdout` (what `f` prints), and `test_warns`.
+All the helpers here wrap `test(a,b,cmp)`, an `assert cmp(a,b)` that shows both values when the comparison fails, rather than a bare `AssertionError`.
 
 To check that code fails as expected, use `test_fail(f, contains=..., exc=...)` for a callable, or `expect_fail` as a context manager, which also accepts `regex`:
 

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/xdg.py

@@ -1,6 +1,6 @@
 """XDG Base Directory Specification helpers.
 
-`xdg_cache_home`, `xdg_config_home`, `xdg_data_home`, `xdg_state_home`, and `xdg_runtime_dir` each return the `Path` given by their `XDG_*` environment variable, falling back to the [spec](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html)'s default (`~/.cache`, `~/.config`, `~/.local/share`, `~/.local/state`; `None` for the runtime dir) when it's unset, empty, or relative. `xdg_config_dirs` and `xdg_data_dirs` likewise return the colon-split search-path lists.
+Each helper reads one `XDG_*` environment variable and falls back to the [spec](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html)'s default when the variable is unset or empty. The single-path helpers also fall back when the variable holds a relative path. The `*_DIRS` helpers split the variable on colons and drop relative entries. `xdg_runtime_dir` has no default and returns `None`.
 
 Docs: https://fastcore.fast.ai/xdg.html.md"""
 

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/xml.py

@@ -158,6 +158,7 @@ def Html(*c, doctype=True, **kwargs)->FT:
 # %% ../nbs/09_xml.ipynb #116c886e
 class Safe(str):
     def __html__(self): return self
+    full = True # Tools that truncate long strings show this whole
 
 # %% ../nbs/09_xml.ipynb #254c8ff3
 def _escape(s):

{fastcore-2.2.32 → fastcore-2.2.34}/fastcore/xtras.py

@@ -258,7 +258,7 @@ def detect_mime(data):
     import mimetypes
     from fastcore import imghdr
     for (sig,pos),mime in _sigs.items():
-        if data[pos:pos+len(sig)]==sig: return mime(data) if callable(mime) else mime
+        if data[pos:pos+len(sig)]==sig and (res := mime(data) if callable(mime) else mime): return res
     return mimetypes.types_map.get(f'.{imghdr.what(None, h=data)}')
 
 # %% ../nbs/03_xtras.ipynb #f856746a

{fastcore-2.2.32 → fastcore-2.2.34/fastcore.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastcore
-Version: 2.2.32
+Version: 2.2.34
 Summary: Python supercharged for fastai development
 Author-email: Jeremy Howard and Sylvain Gugger <infos@fast.ai>
 License-Expression: Apache-2.0
@@ -44,19 +44,19 @@ Python is a powerful, dynamic language. Rather than bake everything into the lan
 
 Here are some tips on using fastcore:
 
-- **Liberal imports**: Use `from fastcore.module import *` freely. The library is designed for safe wildcard imports.
-- **Enhanced list operations**: Substitute `list` with [`L`](https://fastcore.fast.ai/foundation.html#l). This provides advanced indexing, method chaining, and additional functionality while maintaining list-like behavior.
-- **Extend existing classes**: Apply the `@patch` decorator to add methods to classes, including built-ins, without subclassing.
-- **Streamline class initialization**: In `__init__` methods, use [`store_attr()`](https://fastcore.fast.ai/basics.html#store_attr) to efficiently set multiple attributes, reducing repetitive assignment code.
-- **Explicit keyword arguments**: Apply the [`delegates`](https://fastcore.fast.ai/meta.html#delegates) decorator to functions to replace `**kwargs` with specific parameters, enhancing IDE support and documentation.
-- **Optimize parallel execution**: Use fastcore’s enhanced [`ThreadPoolExecutor`](https://fastcore.fast.ai/parallel.html#threadpoolexecutor) and [`ProcessPoolExecutor`](https://fastcore.fast.ai/parallel.html#processpoolexecutor) for simplified concurrent processing.
-- **Expressive testing**: Prefer fastcore’s testing functions like [`test_eq`](https://fastcore.fast.ai/test.html#test_eq), [`test_ne`](https://fastcore.fast.ai/test.html#test_ne), [`test_close`](https://fastcore.fast.ai/test.html#test_close) for more readable and informative test assertions.
-- **Advanced file operations**: Use the extended `Path` class, which adds methods like `ls()`, `read_json()`, and others to [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html#pathlib.Path).
-- **Flexible data structures**: Convert between dictionaries and attribute-access objects using [`dict2obj`](https://fastcore.fast.ai/xtras.html#dict2obj) and [`obj2dict`](https://fastcore.fast.ai/xtras.html#obj2dict) for more intuitive data handling.
-- **Functional programming paradigms**: Use tools like [`compose`](https://fastcore.fast.ai/basics.html#compose), [`maps`](https://fastcore.fast.ai/basics.html#maps), and [`filter_ex`](https://fastcore.fast.ai/basics.html#filter_ex) to write more functional-style Python code.
-- **Documentation**: Document parameters and return values with [`docments`](https://fastcore.fast.ai/docments.html#docments), using source comments or `Annotated` metadata for generated APIs. [`MarkdownRenderer`](https://fastcore.fast.ai/docments.html#markdownrenderer) shows the effective signature and retains usage sections such as Notes, Raises, and Examples.
-- **Time-aware caching**: Apply the [`timed_cache`](https://fastcore.fast.ai/xtras.html#timed_cache) decorator to add time-based expiration to the standard `lru_cache` functionality.
-- **Simplified CLI creation**: Use `fastcore.script` to easily transform Python functions into command-line interfaces.
+- Use `from fastcore.module import *` freely. fastcore’s modules are built to be safe for wildcard imports.
+- Use [`L`](https://fastcore.fast.ai/foundation.html#l) in place of `list`. [`L`](https://fastcore.fast.ai/foundation.html#l) behaves like a list, with extra indexing options, method chaining and more methods.
+- Add methods to existing classes, including built-ins, with the `@patch` decorator instead of subclassing.
+- In `__init__` methods, call [`store_attr()`](https://fastcore.fast.ai/basics.html#store_attr) to set multiple attributes at once instead of assigning each one.
+- Apply the [`delegates`](https://fastcore.fast.ai/meta.html#delegates) decorator to show a function’s real parameters in place of `**kwargs`, for IDEs and generated documentation.
+- Use fastcore’s versions of [`ThreadPoolExecutor`](https://fastcore.fast.ai/parallel.html#threadpoolexecutor) and [`ProcessPoolExecutor`](https://fastcore.fast.ai/parallel.html#processpoolexecutor) for simpler concurrent processing.
+- Prefer fastcore’s test functions, such as [`test_eq`](https://fastcore.fast.ai/test.html#test_eq), [`test_ne`](https://fastcore.fast.ai/test.html#test_ne) and [`test_close`](https://fastcore.fast.ai/test.html#test_close), for assertions that read clearly and give informative failures.
+- fastcore extends [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html#pathlib.Path) with methods such as `ls()` and `read_json()`.
+- Convert between dictionaries and objects with attribute access using [`dict2obj`](https://fastcore.fast.ai/xtras.html#dict2obj) and [`obj2dict`](https://fastcore.fast.ai/xtras.html#obj2dict).
+- Write in a functional style with tools such as [`compose`](https://fastcore.fast.ai/basics.html#compose), [`maps`](https://fastcore.fast.ai/basics.html#maps) and [`filter_ex`](https://fastcore.fast.ai/basics.html#filter_ex).
+- Document parameters and return values with [`docments`](https://fastcore.fast.ai/docments.html#docments), using source comments or `Annotated` metadata for generated APIs. [`MarkdownRenderer`](https://fastcore.fast.ai/docments.html#markdownrenderer) shows the effective signature and keeps usage sections such as Notes, Raises and Examples.
+- Apply the [`timed_cache`](https://fastcore.fast.ai/xtras.html#timed_cache) decorator to add time-based expiry to the standard `lru_cache`.
+- Turn Python functions into command-line interfaces with `fastcore.script`.
 
 For example, [`L`](https://fastcore.fast.ai/foundation.html#l) is a drop-in replacement for `list` with extra superpowers:
 
@@ -88,8 +88,6 @@ To install fastcore run: `conda install fastcore -c fastai` (if you use Anaconda
 
 To get started, we recommend you read through [the fastcore tour](https://fastcore.fast.ai/tour.html).
 
-[`globtastic`](https://fastcore.fast.ai/xtras.html#globtastic) supports filename filters (`file_glob`, `file_re`) and full-path filters (`path_glob`, `path_re`). Glob filters use `fnmatch`: `*` matches directory separators and `**` has no special meaning.
-
 ## Contributing
 
 After you clone this repository, please run `nbdev_install_hooks` in your terminal. This sets up git hooks, which clean up the notebooks to remove the extraneous stuff stored in the notebooks (e.g. which cells you ran) which causes unnecessary merge conflicts.

fastcore-2.2.32/fastcore/editskill.py

@@ -1,64 +0,0 @@
-"""Text, file, cell, and notebook editing from `fastcore.tools` and `fastcore.nbio`, plus the conventions the whole fastai editing toolkit follows. Read this before working with the editing tools in any package that shares them.
-
-`from fastcore.editskill import *` loads `fastcore.tools` (text primitives, file tools) and `fastcore.nbio` (notebook I/O, cell editors). Where installed, prefer `exhash` for hash-verified editing, `rgapi` for search, and `aidialog`/`dialoghelper` for dialogs.
-
-## Places
-
-Targets: strings in memory, files (a path), notebook cells (`path, cell_id`; edits that cell's source), and in-memory `Notebook`/`NbCell`. A Solveit dialog is an `.ipynb` whose cells are notes, runnable code, and prompt/reply pairs; cell tools work with notebook structure whatever produced the file, while `aidialog.dlgskill`/`dialoghelper` read and edit dialog messages. exhash's `open_doc` outlines Markdown, code, and notebooks (`doc(open_doc)`: inputs, navigation, llms.txt workflow); a section is a span of lines or a run of cells, changed with the file and cell tools.
-
-Open a `Notebook` with `Notebook.open(path)` and save it with `nb.save()`. Index it by position or cell id (exact or unique prefix): `nb[k]` returns a cell, `nb[k] = src` sets its source, and `del nb[k]` removes it. `nb.add(src, cell_type)` and `nb.md(src)` insert a cell at `idx`, or `after` or `before` a cell id. `nb.move(ids, after=, before=)` reorders cells.
-
-## Naming
-
-- Operations on files, notebooks, cells, and messages: `verb_target` (`view_file`, `create_file`, `read_nb`, `write_nb`, `view_cell`, `validate_nb`, `view_msg`, `view_dlg`, `lnhashview_cell`). `find_msgs`, `add_msg`, `del_msgs`, `find_cells` need no extra dialog/notebook prefix. `msg` = dialog message; `cell` = notebook cell. `summary_nb` returns rows for notebook cells.
-- Text primitives (`insert_line`, `del_lines`, `replace_lines`, `str_replace`) get `file_`/`cell_`/`msg_` versions (`file_del_lines`, `cell_del_lines`, `msg_del_lines`) that take the primitive's arguments after their address arguments. `str_replace` keeps the name and argument order of Anthropic's text editor tool. `ast_replace` (AST patterns) and `exhash` (hash-verified line addresses) use the same prefixes: `file_ast_replace`, `msg_ast_replace`, `file_exhash`, `cell_exhash`.
-- Converters: `x2y` (`nb2dict`, `cell2xml`, aidialog's `dlg2md`); converter methods: `to_y` (`nb.to_dict()`).
-- Plural names take several items: `view_cell` one cell, `lnhashview_cells` several, `del_msgs` many.
-
-## Parameters (one vocabulary wherever it appears)
-
-- Order: the place's address (`text`; `path`; `path, cell_id`; a message `id`), then the new text, then ambient context as keyword-only (how message tools name their dialog).
-- `start_line`/`end_line`: 1-based, inclusive, `None` = first/last line; a negative `end_line` counts from the end. `del_lines` has no defaults: state the range.
-- `re_filter`/`invert_filter`: restrict an edit to lines (not) matching a regex, like ex `g//`/`g!//`; combines with the range.
-- Searches read patterns as regex by default; editors read them as literal text unless `use_regex=True`.
-- Views: `nums` (line numbers), `lnhashs` (`lineno|hash|` addresses); `maxlen` caps summary lines; `trunc_out`/`trunc_in` truncate outputs/sources in dialog views.
-- Search tools (`fd`, `ls`, `rg`, `nbrg`): `pattern` first, `root='.'`, one include/exclude/ext/hidden/ignore block; variants differ by defaults, not API (`ls` is `fd` with listing defaults).
-- Boolean filters narrow as `only_*` (`only_err`, `only_exp`, `only_errors`) and widen as `incl_*` (`incl_out`).
-- `context=` counts the place's units: lines (blocks in summary mode) for files, cells for notebooks, messages for dialogs.
-- Editors return a diff, which is the verification: read it rather than re-viewing. No change: fastcore editors and exhash return `none: No changes.`
-
-## Functions and methods
-
-Functions take a path, save, and return a diff; methods change an object in memory, saved explicitly. Methods drop the address arguments and the object's part of the name: `cell_str_replace(path, cell_id, ...)` -> `c.str_replace(...)` on an `NbCell`; `find_cells(path, pat)` -> `nb.find_cells(pat)` on a `Notebook`. Read functions return snapshot rows (addresses, source, metadata); read methods return the objects. One style per file at a time: save before switching to functions, reopen before returning to methods.
-
-## Addresses
-
-Edits take plain line numbers or lnhash addresses, got while reading: `nums=True`/`lnhashs=True` views, `rg(lnhashs=True)`. Prefer lnhash addresses where exhash is installed; stale ones are rejected. Plain line numbers are unverified and shift, so re-view after each such edit and apply several bottom-to-top. `exhash.skill` covers address forms and the verified edit loop.
-
-Not sure where to edit? Start with a summary: rgapi's `rg(summary=True)` and `nbrg`, aidialog's `summary_dlg`, and exhash's `open_doc` outlines give one addressed row per block, cell, message, or section. A section token such as `1.6.|12|Py|,45|HD|` is the section number plus the lnhash range of the section's first and last lines; that range works as an exhash address.
-
-## What's where
-
-- `fastcore.tools`: text primitives, file tools, and `line_hash`/`lnhash`/`lnhash_at` for creating addresses without exhash installed.
-- `fastcore.nbio`: notebook read/write/validate/repair, cell construction, cell editors, and the `Notebook`/`NbCell` session objects with their snapshot queries (`find_cells`, `summary_nb`).
-- `exhash.skill`: hash-verified editing for files and cells, plus `open_doc` section outlines for Markdown, code, and notebooks; prefer it for edits where installed.
-- `rgapi.skill`: `rg`/`fd`/`ls`/`nbrg` search with lnhash output, and `rgstr` to search text already in hand.
-- `remold`: structural search and rewrite for Python source (declarative ast-grep rules, LibCST matcher transforms, symbol queries); the engine behind `ast_replace`.
-- `aidialog.dlgskill`, `dialoghelper`: the dialog layer, including its own theory of dialogs and projections.
-
-Docs: https://fastcore.fast.ai/tools.html.md and https://fastcore.fast.ai/nbio.html.md
-"""
-
-from fastcore.tools import (insert_line, str_replace, strs_replace, replace_lines, del_lines, ast_replace,
-    file_insert_line, file_str_replace, file_strs_replace, file_replace_lines, file_del_lines, file_ast_replace,
-    view_file, create_file, line_hash, lnhash, lnhash_at)
-from fastcore.nbio import (read_nb, write_nb, new_nb, mk_cell, validate_nb, validate_cell, repair_nb, repair_cell,
-    view_cell, cell_insert_line, cell_str_replace, cell_strs_replace, cell_replace_lines, cell_del_lines, cell_ast_replace, Notebook, NbCell, find_cells, summary_nb)
-
-__all__ = ['insert_line', 'str_replace', 'strs_replace', 'replace_lines', 'del_lines', 'ast_replace',
-    'file_insert_line', 'file_str_replace', 'file_strs_replace', 'file_replace_lines', 'file_del_lines', 'file_ast_replace',
-    'view_file', 'create_file', 'line_hash', 'lnhash', 'lnhash_at',
-    'read_nb', 'write_nb', 'new_nb', 'mk_cell', 'validate_nb', 'validate_cell', 'repair_nb', 'repair_cell',
-    'view_cell', 'cell_insert_line', 'cell_str_replace', 'cell_strs_replace', 'cell_replace_lines', 'cell_del_lines', 'cell_ast_replace', 'Notebook', 'NbCell', 'find_cells', 'summary_nb']
-
-__pyskill_params__ = {'replace_params': ('start_line', 'end_line', 'n_matches', 're_filter', 'invert_filter', 'use_regex')}