dj-plotly-dash
dj-plotly-dash copied to clipboard
Published
20 hours ago •
pikhovkin
pikhovkin
Pin fire to latest version 0.5.0
This PR pins fire to the latest release 0.5.0.
Changelog
0.5.0
Changelist
* Support for custom serializers with fire.Fire(serializer=your_serializer) 345
* Auto-generated help text now shows short arguments (e.g. -a) when appropriate 318
* Documentation improvements (334, 399, 372, 383, 387)
* Default values are now shown in help for kwonly arguments 414
* Completion script fix where previously completions might not show at all 336
Highlighted change: `fire.Fire(serialize=custom_serialize_fn)` 345
You can now pass a custom serialization function to fire to control how the output is serialized.
Your serialize function should accept an object as input, and may return a string as output. If it returns a string, Fire will display that string. If it returns None, Fire will display nothing. If it returns something else, Fire will use the default serialization method to convert it to text.
The default serialization remains unchanged from previous versions. Primitives and collections of primitives are serialized one item per line. Objects that define a custom `__str__` function are serialized using that. Complex objects that don't define `__str__` trigger their help screen rather than being serialized and displayed.
0.4.0
Changelist
- Support for Python 3.8 and Python 3.9
- Argument types and defaults appear in help text
- Support for asyncio coroutines
- Support for modules and Python files with `python -m fire`
- Keyword argument info from rst docstrings appears in help text
- Bug fix for missing parts of multiline argument descriptions from Google and Numpy style docstrings.
- Packaging of enum34
- Support functions even when they override getattr in non-standard ways. (e.g. supports BeautifulSoup)
Highlighted change: `python -m fire`
You can use Python Fire without ever modifying your code. To use it, first install Python Fire with `pip install fire`. Then simply run `python -m fire path/to/yourfile.py` or `python -m fire path.to.yourmodule`.
This is both a fast way to use Python Fire to create a CLI from your code, and a way to apply Python Fire quickly to a codebase you don't have access to.
0.3.1
Removes preexec_fn from pager subprocess call. Resolves 236.
0.3.0
Assorted Improvements in Python Fire v0.3.0
- Use Fire on third-party code without making any code changes: `python -m fire <module>`
- Docstring parsing fix for all lines are blank f01aad347632791e3438c1a753e42a514520d690
- Improved parsing of numpy-style docstrings
- 187 Expose built-in functions from the standard library (e.g. sin, cos)
- 149 Support objects implementing \_\_getattr\_\_
- 205 Fix ctrl-C handling in help screens
- Support functools.wraps and lru_cache decorated functions
- Better support for objects with properties
- Objects with custom \_\_str\_\_ are now treated as Values. E.g. If such an object appears in a dict, the dict will still print in line-by-line mode rather than showing a help screen by default.
- Formatting on Windows works properly now
0.2.1
Bug fixes
- Improves robustness of docstring parser in the face of unexpected format docstrings. 183
0.2.0
- Help and usage screens
Help screens now have a man-page appearance and are shown with less-style pagination. Usage screens are shown when a user-error is encountered. The help and usage screens are considerably cleaner than the default output in previous versions of Fire.
- Custom serialization
If you define a custom `__str__` method on an object, that will be used to serialize the object when it is the final result of a Fire command. This means better support for numpy arrays, and better support for custom types.
- Docstring parsing
Notably, docstrings are parsed in order to determine the descriptions to use for arguments in the help screens. We largely support (but not fully) Google, numpy, and RST style docstrings. These are the three most common styles of docstring used in Python code.
- Access --help naturally
You no longer need to separate --help from your command with an extra --. Simply running `command -h` or `command --help` will give help, provided there isn't an argument named `help` in your component.
- NamedTuples can be indexed both by their field names and by their indexes.
- Callable objects can both be called, and their members can be accessed.
You must use flag syntax to call a callable object; you cannot pass their arguments positionally.
- Single-hyphen flags are supported
You can now specify `-flag` instead of `--flag` if preferred. Both work.
- Short-flags are permitted when their use is unambiguous
E.g. if your function has argument `alpha`, then you can specify its value with `-a`.
- Fish completion support
0.1.3
This release has a few small improvements:
- Do not treat arguments that start with '--' as strings [99]
- Fix for BinOps in args [96]
- six.u for Python 3 compatability in fuzz tests [111]
And a small packaging improvement:
- Files in PyPi archive are world readable. [107]
0.1.2
Improvements
- IPython is fully optional! [7]
Now Fire's only dependency is six (the Python 2, 3 compatibility module) which is fairly light weight.
If you use Fire without IPython, we call it "Fire Lite." Pun intended.
- The command argument accepts lists [53]
fire.Fire's optional `command` argument now accepts either a sequence of arguments or a single string.
Previously the `command` argument only accepted a string.
- New mkdocs documentation
We've started using mkdocs for documentation. The documentation is available at https://google.github.io/python-fire.
- Packaging improvements: the license file is now included in the release.
- Output is no longer force converted to ASCII.
0.1.1
New Features
- [The Python Fire Guide](https://github.com/google/python-fire/blob/master/doc/guide.md) is available
- Support for annotations in functions
- Support for keyword-only arguments in functions
- Faster loading via lazy imports
Bug Fixes
- Serialize empty dictionaries
- Serialize dictionaries with circular dependencies
- Support non-comparable objects, numpy arrays, etc
- Help for objects without source files
- Completion scripts for top-level functions
Links
- PyPI: https://pypi.org/project/fire
- Changelog: https://pyup.io/changelogs/fire/
- Repo: https://github.com/google/python-fire
