semvec/pypi-packages huggingface dataset:
metta-motto 0.0.12
Integration of MeTTa and LLMs for prompt templates, guidance, and chaining as well as composition with other agents.
Requires Python: >=3.8

# Metta Motto

This package provides integration of MeTTa and LLMs for prompt tamplates, guidance, and chaining as well as composition with other agents.

## Installation

The main requirement is [MeTTa](https://github.com/trueagi-io/hyperon-experimental/).

The project itself can be installed via
```bash
git clone git@github.com:zarqa-ai/metta-motto.git
cd metta-motto
```

### Using-pip

Run the following command to install the project using pip:
```bash
pip install metta-motto
```

## Usage

The package can be used both as a Python package
```python
import motto
```

and MeTTa extention
```
!(import! &self motto)
```

Please, refer to the [tutorial](tutorial) and [examples](examples). [Tests](tests) can also be considered in addition.

## Tests

The unit tests can be executed via

```bash
cd tests
pytest
```
clickhouse-arrow 0.5.0
A minimal client that uses the ClickHouse HTTP API and Apache Arrow.
Requires Python: >=3.10

# Clickhouse Arrow 🏠 🏹

A minimal [ClickHouse](https://clickhouse.com) client that uses the HTTP API and Apache Arrow.

You should probably use [Clickhouse Connect](https://github.com/ClickHouse/clickhouse-connect) instead.

### Installation

```bash
pip install clickhouse_arrow
```

### Examples

```python
import clickhouse_arrow as ch
import pyarrow as pa

# Initialise a client
client = ch.Client("http://localhost:8123", password="password")

# Create a table
client.execute(
    """
    CREATE TABLE test (
        col1 Int64,
        col2 String
    )
    ENGINE = Memory
    """,
)

# Import a table
table = pa.Table.from_pydict(
    {
        "col1": [1, 2, 3],
        "col2": ["a", "b", "d"],
    },
)
client.insert("test", table)

# Read into a table
table = client.read_table("SELECT * FROM test")
print(table)

# Read iterator of batches
batches = client.read_batches("SELECT * FROM test")
for batch in batches:
    print(batch)

# Use query parameters
table = client.read_table(
    """
    SELECT * FROM test
    WHERE col1 = {value:Int64}
    """,
    params={"value": 2},
)
print(table)

# Use query settings
table = client.read_table(
    "SELECT col2 FROM test",
    settings={"output_format_arrow_string_as_string": 1},
)
print(table["col2"])

# Use table schema
table = client.read_table(
    "SELECT * FROM test",
    schema = pa.schema(
        [
            ("col1", pa.int64()),
            ("col2", pa.binary()),
        ]
    ),
)
```
binary-fun 0.0.0
A Python module that converts and decodes binary.
Requires Python: >=3.6

This is a Python module that decodes and converts binary

FUNCTIONS:

_convert() (pretty useless because it is just a support for Convert())
Convert() (converts a number to binary)
Decode() (decodes binary)

USAGE:

Example:

***
import binary_fun

binary_fun.Convert(15) #Converts 15 to a binary then prints it
print()
binary_fun.Decode(10100) #Decodes 10100 then prints it
***

IMPORTANT WARNING:

DO NOT USE IN FUNCTIONS (like print()) OR VARIABLES! IT WILL RETURN NONE! WAIT FOR FUTURE UPDATES.
filmsdk 0.0.2
SDK Python pour accéder à l’API MovieLens (Data Analysts/Data Scientists friendly)
Requires Python: >=3.12

# MovieLens SDK - `filmsdk`

Un SDK Python simple pour interagir avec l’API REST MovieLens. Il est conçu pour les **Data Analysts** et **Data Scientists**, avec une prise en charge native de **Pydantic**, **dictionnaires** et **DataFrames Pandas**.

[![PyPI version](https://badge.fury.io/py/moviesdk.svg)](https://badge.fury.io/py/moviesdk)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

---

## Installation

```bash
pip install filmsdk
```

---

## Configuration

```python
from filmsdk import MovieClient, MovieConfig

# Configuration avec l’URL de votre API (Render ou locale)
config = MovieConfig(movie_base_url="https://movie-backend-xelv.onrender.com")
client = MovieClient(config=config)
```

---

## Tester le SDK

### 1. Health check

```python
client.health_check()
# Retourne : {"status": "ok"}
```

### 2. Récupérer un film

```python
movie = client.get_movie(1)
print(movie.title)
```

### 3. Liste de films au format DataFrame

```python
df = client.list_movies(limit=5, output_format="pandas")
print(df.head())
```

---

## Modes de sortie disponibles

Toutes les méthodes de liste (`list_movies`, `list_ratings`, etc.) peuvent retourner :

- des objets **Pydantic** (défaut)
- des **dictionnaires**
- des **DataFrames Pandas**

Exemple :

```python
client.list_movies(limit=10, output_format="dict")
client.list_ratings(limit=10, output_format="pandas")
```

---

## Tester en local

Vous pouvez aussi utiliser une API locale :

```python
config = MovieConfig(movie_base_url="http://localhost:8000")
client = MovieClient(config=config)
```

---

## Public cible

- Data Analysts
- Data Scientists
- Étudiants et curieux en Data
- Développeurs Python

---

## Licence

MIT License

---

## Liens utiles

- API Render : [https://movie-backend-xelv.onrender.com](https://movie-backend-xelv.onrender.com)
- PyPI : [https://pypi.org/project/filmsdk](https://pypi.org/project/filmsdk)
dynaccount 0.1.0
An easier way to programmatically leverage Account Management in Dynatrace. Please review the README. Project URLs are currently broken but will work once project is uploaded to public GitHub repo.
Requires Python: >=3.8

# Dynaccount

**Dynaccount** is a Python client for the [Dynatrace Account Management API].
It focuses on providing Dynatrace administrators an easier way to understand their environments, groups, policies, and subscription usage.

[Dynatrace Account Management API]: https://docs.dynatrace.com/docs/discover-dynatrace/references/dynatrace-api/account-management-api

## Requirements

1. Python 3.8 or higher
2. OAuth Client Credentials with scopes: account-env-read account-idm-read iam-policies-management

## Install

```bash
$ pip install dt
```

## Example Use Case

```python
import dynaccount

# Initialize client class
account_client = dynaccount.DynatraceClient("client_id_goes_here", "client_secret_goes_here", "account_urn_goes_here")

# Get policies matching your keyword search (regex is supported)
all_account_policies_detailed = dynaccount.get_policies_detailed(account_client, "search_policies_here", regex=False)

# Initialize exporter class
exporter = dynaccount.Exporter()

# Export to JSON
exporter.policies_to_json(all_account_policies_detailed)
```

## To-Do

- Create tests
- Dynamic scope options
- Add write functionality
- Introduce all API endpoints