semvec/pypi-packages huggingface dataset:
modulitiz 2.23.1
Raccolta dei miei moduli - versione completa
Requires Python: >=3.11

# modulitiz

It's a Python library that contains all the useful functions.  
This package requires all the others.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install:

```bash
pip install -U modulitiz
```
The other required dependencies will be installed automatically.

## Usage

```python
from modulitiz.multimedia.ModuloImmagini import ModuloImmagini

# returns True
ModuloImmagini.screenshot("abc.png")
```

## Contributing

If you find any bug you can write me at [sderfo1234@altervista.org](mailto:sderfo1234@altervista.org)

## License

[MIT](https://choosealicense.com/licenses/mit/)
deephaven-plugin-ui 0.32.2
deephaven.ui plugin
Keywords: deephaven, plugin, graph

# deephaven.ui Plugin

Plugin prototype for programmatic layouts and callbacks. Currently calling it `deephaven.ui` but that's not set in stone.

## Build

To create your build / development environment (skip the first two lines if you already have a venv):

```sh
python -m venv .venv
source .venv/bin/activate
pip install --upgrade pip setuptools
pip install build deephaven-plugin plotly
```

To build:

```sh
python -m build --wheel
```

The wheel is stored in `dist/`.

To test within [deephaven-core](https://github.com/deephaven/deephaven-core), note where this wheel is stored (using `pwd`, for example).
Then, follow the directions in the top-level README.md to install the wheel into your Deephaven environment.

To unit test, run the following command from the root of the repo:

```sh
tox -e py
```

## Usage

Once you have the JS and python plugins installed and the server started, you can use deephaven.ui. See [examples](docs/README.md) for examples.

## Logging

The Python library uses the [logging](https://docs.python.org/3/howto/logging.html) module to log messages. The default log level is `WARNING`. To change the log level for debugging, set the log level to `DEBUG`:

```python
import logging
import sys

# Have the root logger output to stdout instead of stderr
logging.basicConfig(stream=sys.stdout, level=logging.WARNING)

# Set the log level for the deephaven.ui logger to DEBUG
logging.getLogger("deephaven.ui").setLevel(level=logging.DEBUG)
```

You can also set the log level for specific modules if you want to see specific modules' debug messages or filter out other ones, e.g.

```python
# Only log warnings from deephaven.ui.hooks
logging.getLogger("deephaven.ui.hooks").setLevel(level=logging.WARNING)

# Log all debug messages from the render module specifically
logging.getLogger("deephaven.ui.render").setLevel(level=logging.DEBUG)
```

## Docs
Docs can be built locally

Install the necessary dependencies:
```shell
pip install -r ../../sphinx_ext/sphinx-requirements.txt
pip install dist/deephaven_plugin_ui-*.whl
```
then run the docs make script:
```shell
python make_docs.py
```

The files will be built into `docs/build/markdown`.
Note that these built files should not be committed to the repository.

## Update Icon Types
Available IconTypes can be generated automatically using icon TypeScript definitions in node_modules.

Writes to `icon_types.py`. 

```shell
npm install
cd plugins/ui
python make_icon_types.py
```
modulitiz-rpi 2.3.1
Raccolta dei miei moduli - funzioni specifiche per il RaspberryPi
Requires Python: >=3.11

# modulitiz-rpi

It's a Python library that contains specific functions for RaspberryPi.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install:

```bash
pip install -U modulitiz_rpi
```
The other required dependencies will be installed automatically.

## Usage

```python
from modulitiz_rpi.ModuloGPIOInput import ModuloGPIOInput

gpioInput=ModuloGPIOInput(0)
gpioInput.populate()

# return False or True
gpioInput.isActive()
```

## Contributing

If you find any bug you can write me at [sderfo1234@altervista.org](mailto:sderfo1234@altervista.org)

## License

[MIT](https://choosealicense.com/licenses/mit/)
modulitiz-binaries 2.6.1
Raccolta dei miei moduli - file binari
Requires Python: >=3.11

# modulitiz-binaries

It's a Python library that contains binary files and other libraries.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install:

```bash
pip install -U modulitiz_binaries
```
The other required dependencies will be installed automatically.

## Usage

```python
from modulitiz_binaries.Init import Init

# returns the folder which contains binary files
print(Init.getCartellaFileBinari())
```

## Contributing

If you find any bug you can write me at [sderfo1234@altervista.org](mailto:sderfo1234@altervista.org)

## License

[MIT](https://choosealicense.com/licenses/mit/)
orca-sdk 0.1.14
SDK for interacting with Orca Services
Requires Python: <3.15,>=3.11

<!--
IMPORTANT NOTE:
- This file will get rendered in the public facing PyPi page here: https://pypi.org/project/orca_sdk/
- Only content suitable for public consumption should be placed in this file everything else should go into CONTRIBUTING.md
-->

# OrcaSDK

OrcaSDK is a Python library for building and using retrieval-augmented models with [OrcaCloud](https://orcadb.ai). It enables you to create, deploy, and maintain models that can adapt to changing circumstances without retraining by accessing external data called "memories."

## Documentation

You can find the documentation for all things Orca at [docs.orcadb.ai](https://docs.orcadb.ai). This includes tutorials, how-to guides, and the full interface reference for OrcaSDK.

## Features

- **Labeled Memorysets**: Store and manage labeled examples that your models can use to guide predictions
- **Classification Models**: Build retrieval-augmented classification models that adapt to new data without retraining
- **Embedding Models**: Use pre-trained or fine-tuned embedding models to represent your data
- **Telemetry**: Collect feedback and monitor memory usage to optimize model performance
- **Datasources**: Easily ingest data from various sources into your memorysets

## Installation

OrcaSDK is compatible with Python 3.10 or higher and is available on [PyPI](https://pypi.org/project/orca_sdk/). You can install it with your favorite python package manager:

- Pip: `pip install orca_sdk`
- Conda: `conda install orca_sdk`
- Poetry: `poetry add orca_sdk`

## Quick Start

```python
from dotenv import load_dotenv
from orca_sdk import OrcaCredentials, LabeledMemoryset, ClassificationModel

# Load your API key from environment variables
load_dotenv()
assert OrcaCredentials.is_authenticated()

# Create a labeled memoryset
memoryset = LabeledMemoryset.from_disk("my_memoryset", "./data.jsonl")

# Create a classification model using the memoryset
model = ClassificationModel("my_model", memoryset)

# Make predictions
prediction = model.predict("my input")

# Get Action Recommendation
action, rationale = prediction.recommend_action()
print(f"Recommended action: {action}")
print(f"Rationale: {rationale}")

# Generate and add synthetic memory suggestions
if action == "add_memories":
    suggestions = prediction.generate_memory_suggestions(num_memories=3)

    # Review suggestions
    for suggestion in suggestions:
        print(f"Suggested: '{suggestion['value']}' -> {suggestion['label']}")

    # Add suggestions to memoryset
    model.memoryset.insert(suggestions)
    print(f"Added {len(suggestions)} new memories to improve model performance!")
```

For a more detailed walkthrough, check out our [Quick Start Guide](https://docs.orcadb.ai/quickstart-sdk/).

## Support

If you have any questions, please reach out to us at support@orcadb.ai.