fastcore 2.2.31__tar.gz → 2.2.33__tar.gz

{fastcore-2.2.31/fastcore.egg-info → fastcore-2.2.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastcore
-Version: 2.2.31
+Version: 2.2.33
 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.31 → fastcore-2.2.33}/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.31 → fastcore-2.2.33}/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.31"
+__version__ = "2.2.33"

{fastcore-2.2.31 → fastcore-2.2.33}/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.31 → fastcore-2.2.33}/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

{fastcore-2.2.31 → fastcore-2.2.33}/fastcore/docments.py

@@ -44,7 +44,7 @@ def docstring(sym):
     if isinstance(sym, partial): return docstring(sym.func)
     if _callable_instance(sym):
         own = inspect.getattr_static(sym, '__doc__', None)
-        if own is not getattr(type(sym), '__doc__', None): return getdoc(sym) or ''
+        if isinstance(own, property) or own is not getattr(type(sym), '__doc__', None): return getdoc(sym) or ''
         return getdoc(sym.__call__) or getdoc(sym) or ''
     res = getdoc(sym)
     if not getattr(sym, '__doc__', None) and res == object.__init__.__doc__: res = None
@@ -183,7 +183,7 @@ def docments(s, full=False, eval_str=False, returns=True, args_kwargs=False):
     except (ValueError, TypeError): return AttrDict()
     nps = parse_docstring(s)
     docs = {}
-    while s:
+    while s is not None:
         p = _param_locs(s, returns=returns, args_kwargs=args_kwargs) or {}
         c = {o.start[0]:_clean_comment(o.string) for o in _tokens(s) if o.type==COMMENT}
         for k,v in p.items():

{fastcore-2.2.31 → fastcore-2.2.33}/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"""
 

{fastcore-2.2.31 → fastcore-2.2.33}/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.31 → fastcore-2.2.33}/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.31 → fastcore-2.2.33}/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.31 → fastcore-2.2.33}/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.31 → fastcore-2.2.33/fastcore.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastcore
-Version: 2.2.31
+Version: 2.2.33
 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.