Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/scalabli/neuraldig
Scalable and powerful Machine Learning tool for NeuroImaging in python
https://github.com/scalabli/neuraldig
data-science machine-learning neural-network neuroimaging
Last synced: about 1 month ago
JSON representation
Scalable and powerful Machine Learning tool for NeuroImaging in python
- Host: GitHub
- URL: https://github.com/scalabli/neuraldig
- Owner: scalabli
- License: mit
- Created: 2022-03-12T08:07:17.000Z (almost 3 years ago)
- Default Branch: main
- Last Pushed: 2022-09-30T19:51:43.000Z (over 2 years ago)
- Last Synced: 2023-03-06T23:46:57.182Z (almost 2 years ago)
- Topics: data-science, machine-learning, neural-network, neuroimaging
- Language: Python
- Homepage:
- Size: 11.7 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
[](https://pepy.tech/project/neuraldig)
[](https://badge.fury.io/py/neuraldig)
[](https://pypi.com/project/neuraldig)
[](https://ci.appveyor.com/project/gerrishons/neuraldig)
[](https://pypi.com/project/neuraldig)
[](https://neuraldig.readthedocs.io)
[](https://doi.org/10.5281/zenodo.5848515)
[](https://opensource.org/licenses/MIT)
[](https://twitter.com/gerrishon_s)
[](https://github.com/secretum-inc/quo)
`Forever Scalable`
**Neuraldig** is a Python based toolkit for writing Command-Line Interface(CLI) applications.
Quo is making headway towards composing speedy and orderly CLI applications while forestalling any disappointments brought about by the failure to execute a CLI API.
Simple to code, easy to learn, and does not come with needless baggage.
## Compatibility
Neuraldig works flawlessly with Linux, OSX, and Windows.
Neuraldig requires Python `3.8` or later.
## Features
- [x] Support for Ansi, RGB and Hex color models
- [x] Support for tabular presentation of data
- [x] Intuitive progressbars
- [x] Code completions
- [x] Nesting of commands
- [x] Customizable Text User Interface _(TUI)_ dialogs.
- [x] Automatic help page generation
- [x] Syntax highlighting
- [x] Autosuggestions
- [x] Key Binders
## Getting Started
### Installation
You can install quo via the Python Package Index (PyPI)
```
pip install -U quo
```
Run the following to test Quo output on your terminal:
```
python -m quo
```
## Quo echo
To output formatted text to your terminal you can import the [echo](https://quo.readthedocs.io/en/latest/introduction.html#quick-start) method.
Try this:
**Example 1**
```python
from quo import echo
echo(f"Hello, World!", fg="red", italic=True, bold=True))
```
**Example 2**
```python
from quo import echo
echo(f"Quo is ", nl=False)
echo(f"scalable", bg="red", fg="black")
```
Alternatively, you can import [print](https://quo.readthedocs.io/en/latest/printing_text.html#print)
```python
from quo import print
from quo.text import Text
print(Text('This is bold'))
print(Text('This is italic'))
print(Text('This is underlined'))
# Colors from the ANSI palette.
print(Text('This is red'))
print(Text('Green on red background</stlye>'))
```
## Quo prompt
- Using ``quo.prompt`` method.
```python
from quo import prompt
prompt("What is your name?")
```
- Using ``quo.prompt.Prompt`` object
```python
from quo.prompt import Prompt
session = Prompt()
session.prompt("Type something:")
```
Read more on [Prompt](https://quo.readthedocs.io/latest/prompt.html)
# Quo Library
Quo contains a number of builtin features you can use to create elegant output in your CLI.
Click the following headings for details:»
<details>
<summary>Console</summary>
For more control over quo terminal content, import and construct a `Console` object.
```python
from quo import Console
console = Console()
```
## ``Launching Applications``
Quo supports launching applications through `Console.launch`. This can be used to open the default application associated with a URL or filetype.
```python
from quo import Console
console = Console()
console.launch("https://quo.rtfd.io/")
```
Read more on [Console](https://quo.readthedocs.io/en/latest/console.html)
</details>
<details>
<summary>Completion</summary>
## ``Autocompletion``
Press [Tab] to autocomplete
```python
from quo.prompt import Prompt
from quo.completion import WordCompleter
example = WordCompleter(['USA', 'UK', 'Canada', 'Kenya'])
session = Prompt(completer=example)
session.prompt('Which country are you from?: ')
```
## ``Autosuggestion``
Auto suggestion is a way to propose some input completions to the user. Usually, the input is compared to the history and when there is another entry starting with the given text, the completion will be shown as gray text behind the current input. Pressing the right arrow → or ctrl-e will insert this suggestion, alt-f willinsert the first word of the suggestion.
```python
from quo.prompt import Prompt
from quo.completion import AutoSuggestFromHistory
from quo.history import InMemoryHistory
history = InMemoryHistory(
history.append("import os")
history.append('print("hello")')
history.append('print("world")')
history.append("import path"
session = Prompt(auto_suggest=AutoSuggestFromHistory(), history=history)
while True:
session.prompt('> ')
```
Read more on [Completions](https://quo.readthedocs.io/en/latest/prompt.html#completion)
</details>
<details>
<summary>Documenting Scripts</summary>
Quo automatically generates help pages for your command-line tools.
```python
from quo import print
from quo.console import command
from quo.console import app
@command()
@app('--count', default=1, help='number of greetings')
@app('--name', prompt="What is your name?", help="The person to greet")
def hello(count: int, name: str):
"""This script prints hello NAME COUNT times."""
for x in range(count):
print(f"Hello {name}!")
if __name__ == "__main__:
hello()
```
And what it looks like:
</details>
<details>
<summary>Progress</summary>
Creating a new progress bar can be done by calling the class **ProgressBar**
The progress can be displayed for any iterable. This works by wrapping the iterable (like ``range``) with the class **ProgressBar**
```python
import time
from quo.progress import ProgressBar
with ProgressBar() as pb:
for i in pb(range(800)):
time.sleep(.01)
```
Read more on [Progress](https://quo.readthedocs.io/en/latest/progress.html)
</details>
<details>
<summary>Key Binding</summary>
A key binding is an association between a physical key on a keyboard and a parameter.
```python
from quo import echo
from quo.prompt import Prompt
from quo.keys import Bind
bind = Bind()
# Print "Hello world" when ctrl-h is pressed
@bind.add("ctrl-h")
def _(event):
echo("Hello, World!")
session.prompt(">>", bind=bind)
```
Read more on [Key bindings](https://quo.readthedocs.io/en/latest/kb.html)
</details>
<details>
<summary>Dialog</summary>
High level API for displaying dialog boxes to the user for informational purposes, or get input fromthe user.
1) Example of a message box dialog.
```python
from quo.dialog import MessageBox
MessageBox(
title="Message pop up window",
text="Do you want to continue?\nPress ENTER to quit.").run()
```
The above produces the following output
2) Example of a prompt box dialog
```python
from quo.dialog import PromptBox
PromptBox(
title="PromptBox shenanigans",
text="What Country are you from?:").run()
```
Read more on [Dialogs](https://quo.readthedocs.io/en/latest/dialogs.html)
</details>
<details>
<summary>Table</summary>
Function [Table](https://quo.readthedocs.io/en/latest/table.html) offers a number of configuration options to set the look and feel of the table, including how borders are rendered and the style and alignment of the columns.
Example
```python
from quo import echo
from quo.table import Table
data = [
["Name", "Gender", "Age"],
["Alice", "F", 24],
["Bob", "M", 19],
["Dave", "M", 24]
]
echo(Table(data))
```
</details>
<details>
<summary>Widgets</summary>
A collection of reusable components for building full screen applications.
## ``Label``
Widget that displays the given text. It is not editable or focusable.
```python
from quo.console import Console
from quo.keys import Bind
from quo.layout import Layout
from quo.widget import Label
root = Label("Hello, World", style="fg:black bg:red")
layout = Layout(root)
# Ctrl-c to exit
bind = Bind()
@bind.add("ctrl-c")
def _(event):
event.app.exit()
Console(
layout=layout,
bind=bind,
full_screen=True).run()
```
Read more on [Widgets](https://quo.readthedocs.io/en/latest/widgets.html)
</details>
For more intricate examples, have a look in the [examples](https://github.com/secretum-inc/quo/tree/master/examples) directory and the documentation.
## Donate🎁
In order to for us to maintain this project and grow our community of contributors.
[Donate](https://www.paypal.com/donate?hosted_button_id=KP893BC2EKK54)
## Quo is...
**Simple**
If you know Python you can easily use quo and it can integrate with just about anything.
## Getting Help
### Community
For discussions about the usage, development, and the future of quo, please join our Google community
* [Community👨👩👦👦](https://groups.google.com/forum/#!forum/secretum)
## Resources
### Bug tracker
If you have any suggestions, bug reports, or annoyances please report them
to our issue tracker at
[Bug tracker](https://github.com/secretum-inc/quo/issues/) or send an email to:
## License📑
[](https://opensource.org/licenses/MIT)
This software is licensed under the `MIT License`. See the [License](https://github.com/scalabli/quo/blob/master/LICENSE) file in the top distribution directory for the full license text.
## Code of Conduct
Code of Conduct is adapted from the Contributor Covenant,
version 1.2.0 available at
[Code of Conduct](http://contributor-covenant.org/version/1/2/0/)