semvec/pypi-packages huggingface dataset:
toobj 0.0.1
Python package that transforms flat or nested dictionaries into objects.

# toobj: Transform a dictionary into an object
Python package that transforms flat or nested dictionaries into objects.

## Installation
```commandline
pip install toobj
```

## ToObj
Transforms flat or nested dictionaries into objects.

### Args
| Parameter | Type   | Description                             |
|-----------|--------|-----------------------------------------|
| `d`       | `dict` | Dictionary to convert in Python object. |

```python
from toobj import ToObj

d = dict(...)
obj = ToObj(d)
```

## Usage

```python
from toobj import ToObj

# Sample data
data = {
    'name': 'Alice',
    'age': 30,
    'address': {
        'city': 'Wonderland',
        'zipcode': 12345,
        'coordinates': {
            'lat': 52.5200,
            'long': 13.4050,
            'meta': {
                'continent': 'Europe',
                'population': 3000000
            }
        }
    },
    'contacts': {
        'email': 'alice@example.com',
        'phones': [
            {'type': 'home', 'number': '123-456'},
            {'type': 'work', 'number': '789-101'}
        ]
    },
    'hobbies': ['reading', 'traveling', {'name': 'coding', 'level': 'advanced'}]
}

# Dictionary to object
data_obj = ToObj(data)
```

```
>>> data_obj.name
'Alice'
>>> data_obj.address.zipcode
12345
>>> data_obj.address.coordinates.meta.continent
'Europe'
>>> data_obj.contacts.phones[0].number
'123-456'
>>> data_obj.hobbies[2].name
'coding'
```
autosuggest 1.1.1
A cross-platform auto-suggest input package with enhanced features
Requires Python: >=3.6

# AutoSuggest - Terminal Auto-Suggestion Tool

**AutoSuggest** is a Python terminal application that provides auto-suggestions based on user input. It is designed to enhance the user experience by offering real-time suggestions, making it easier to select names or other items.

## Features

- Real-time auto-suggestions as you type.
- Supports both colored and plain text output.
- Works on Windows and Unix-based systems (Linux, macOS).
- Clear terminal interface.



## Installation

To install AutoSuggest, simply use pip:

```bash
pip install autosuggest
```

## Usage

You can run the AutoSuggest tool directly in your terminal. Here's an example of how to use it:

```python
from autosuggest import AutoSuggest

# List of suggestions
names = ["Alice", "Bob", "Charlie", "David", "Edward", "Fiona", "George", "Hannah", "Ian", "Julia"]

# Customize your input message and whether to use colors
input_message = "Please type a name (Press Backspace to delete, ESC to exit): "
use_colors = True  # Set to False to disable colors

# Create an instance of AutoSuggest
suggestion_tool = AutoSuggest(names, input_message, use_colors)

# Run the auto-suggest feature
selected_name = suggestion_tool.run()
print(f"You selected: {selected_name}")
```

### Running the Tool

To execute the script, save it in a `.py` file and run it from the command line:

```bash
python your_script_name.py
```

Replace `your_script_name.py` with the name of your script.

## Customization

- **Input Message**: Change the `input_message` variable to customize the prompt shown to the user.
- **Color Usage**: Set the `use_colors` variable to `True` to enable colored output or `False` to disable it.

## Contributing

Contributions are welcome! If you'd like to improve this project, please submit a pull request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Contact

For any inquiries or support, please contact us at Ishan.kodithuwakku.official@gmail.com

**Repository Views** ![Views](https://profile-counter.glitch.me/autosuggest/count.svg)
pydalio 0.1.0
A package to help with testing of principles in decision making
Requires Python: <4.0,>=3.11

# PYDALIO

This package is inspired by the book of Ray Dalio, Principles.
The idea is to pose a number of principle questions to make more informed, rational decisions. These can be saved and the endgoal is to be able to abstract a personal working algorithm from it.

How to get started using the package:
0. Create a virtual environment: https://realpython.com/python-virtual-environments-a-primer/#create-it
1. pip install pydalio
2. Define your principles:
    a. create a .yaml file
    b. define principle questions as shown in example_principles.yaml
    c. define possible options as shown in example_principles.yaml
    d. Set yaml path to .env file as shown in example_config.env
3. Set database path in .env file as shown in example_config.env. Please note the name of the db (sqlite) is currently fixed at dalio.db
4. Optional: if sqlite is not installed, please install it. For more information: https://www.gurusoftware.com/the-complete-guide-to-downloading-installing-sqlite/
5. Setup environment by running the following python script:
    from pydalio.db import create_db
    from pydalio.db import initiliaze_tables

    create_db()
    initiliaze_tables()
6. Activate your virtual environment: https://realpython.com/python-virtual-environments-a-primer/#activate-it
7. Run the command "pydalio --help" to see all commands you can run.
8. Enjoy your journey of improved decision making!

Development track:
    [x] create cli application basis
    [ ] create orchestrating logic to run continuously
    [x] create sqllite db interface
    [x] create generalised principle questions interface
    [ ] create simple algorithm interface based on database.First guesstimate is decision tree algorithm or logistic regression.
    [ ] make a bash script to install/run globally?

If you would like to contribute, fork the package: https://github.com/tlaumen/pydalio and make a PR.
For further questions, e-mail to tom_laumen@hotmail.com