semvec/pypi-packages huggingface dataset:
EscribaLogger 2.0.2
A fast 'read to use' Logging system which provides stdout/file/custom stream with easy syntax and operation. It's a very simple approach of Laravel drivers sorts, by the way, handlers ands drivers are both the same
License: MIT
Requires Python: >=3.10
Keywords: logging, logger, log, logs, drivers

[![codecov](https://codecov.io/gh/Strovsk/EscribaLogger/graph/badge.svg?token=FJFYOM8X4U)](https://codecov.io/gh/Strovsk/EscribaLogger)

<p align="center">
   <img src="https://raw.githubusercontent.com/Strovsk/EscribaLogger/refs/heads/main/docs/assets/escriba%20logger%20background.png" alt="Escriba Logger Logo" width="300">
</p>

# Get Started

## install

`python -m pip install EscribaLogger`

## Usage

Just import, add drivers and use:

> You can output your logs using a pre-configured builtin [rich](https://rich.readthedocs.io/en/stable/introduction.html) stdout handler

```python
from EscribaLogger import Log

# Initilize
Log()
Log.set_logger_name('CustomName')

# Add drivers (stdout, file, graylog, flutend etc)
Log.add_driver('stdout')

Log.info('My info message', {'context_var': 'value'})
# > [01/12/25 20:30:20] INFO     CustomName - My info message                                                                <stdin>:1
```

## Log file driver

```python
# You can add another driver. In this case, we will add the file driver
Log.add_driver('file')


Log.info('Some message', extra={"context_var": "value"})
# > The message will be stored in "logs/2023-07-16.log"
# > [2023-07-16 16:13:55,100] EscribaLogger.INFO - Some message - {"context_var": "value"}
```

> In the default logging system, handle context variables is a exhausting task. EscribaLogger added the "extra_context" log variable to solve this. You add the context info for any custom driver.

### Change default log files storage

```python
# You can change default path to store log files in:
Log.add_driver('file', driver_option={'file_location': 'another/path'})


Log.info('Some message', extra={"context_var": "value"})
# > The message will be stored in "another/path/2023-07-16.log"
# > [2023-07-16 16:13:55,100] EscribaLogger.INFO - Some message - {"context_var": "value"}
```

# Contributing

## Setup env

1. install pdm

```console
python -m pip install pdm
```

2. install dependencies

```console
pdm install
```

## Tests

We are using [pytest](https://docs.pytest.org/en/7.4.x/) and [coverage.py](https://coverage.readthedocs.io/en/7.2.7/) to maintain this project.
You can run the tests by using:

```console
pdm run test:unit
```

the command above will generate the `.coverage` file in root path. Now you can generate the coverage report

### Coverage

```console
coverage report -m
```

Or you can create a entire webpage to see the results:

```console
pdm run coverage html
```
tomlenv 0.2.3
Environment Wrapped TOML
License: MIT
Requires Python: <4.0,>=3.11
Keywords: TOML, environment, variables, config

# TOMLenv
![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/joaonsantos/tomlenv/python-publish.yml)
![PyPI - Version](https://img.shields.io/pypi/v/tomlenv)
![Pypi - Python Version](https://img.shields.io/badge/python-3.11%2B-blue)
![PyPI - Downloads](https://img.shields.io/pypi/dm/tomlenv)
![License](https://img.shields.io/github/license/joaonsantos/tomlenv)

Environment wrapped TOML. 

Package available in [PyPI](https://pypi.org/project/tomlenv/).

## Getting Started

### Install the library

Using pip:
```sh
$ pip install tomlenv
```

Using pipenv:
```sh
$ pipenv install tomlenv
```

Using poetry:
```sh
$ poetry add tomlenv
```

### Basic Usage

Tomlenv takes advantage of modern Python features such as `dataclasses` and
`tomllib` to create a simple yet powerful configuration library.

By default, tomlenv looks for a `config.toml` file in your project root:
```toml
token = "dev"
debug = false
```

Assuming this environment variable is set:
```sh
TOMLENV_DEBUG=true
```

Create your configuration dataclass and parse config and env into it:
```python
import tomlenv
from dataclasses import dataclass

@dataclass
class Config:
    token: str = ''
    debug: bool = False

config = Config()
parser = tomlenv.Parser()

parser.load(config)

# You can now access the fields of your fully typed config Class
# that contains values from a TOML config file and the environment.

# For example:

token = config.token
debug = config.debug
print(token) # prints "dev"
print(debug) # prints True
```

## Configuration

To configure the location of your toml file, set `TOMLENV_CONF_FILEPATH`.

For example if your config file is in `configs/config.toml` relative to the project root, then set `TOMLENV_CONF_FILEPATH=configs/config.toml`

## Tests

This project uses [Poetry](https://python-poetry.org/) and [GNU Make](https://www.gnu.org/software/make/).

Run tests from the project root with:
```sh
$ make test
```

To get a coverage report:
```sh
$ make cov
```

## Issues

Feel free to send issues or suggestions to https://github.com/joaonsantos/tomlenv/issues.
tackleberry 0.1.2
Tackleberry (or TB) is helping you tackle the access to AI
License: MIT
Requires Python: >=3.10

[![Tackleberry](https://raw.githubusercontent.com/Getty/tackleberry/main/tackleberry.jpg)](https://github.com/Getty/tackleberry)

# Tackleberry

API may change slightly, still work in progress.

## Synopsis

```python
from tackleberry import TB

openai_chat = TB.chat('gpt-4o-mini')
openai_reply = openai_chat.query("Say test")

claude_chat = TB.chat('claude-3-5-sonnet-20241022')
claude_reply = claude_chat.query("Say test")

groq_chat = TB.chat('gemma2-9b-it')
groq_reply = groq_chat.query("Say test")

# OLLAMA_PROXY_URL set for URL, can handle Basic Auth in URL
ollama_chat = TB.chat('ollama/gemma2:2b')
ollama_reply = ollama_chat.query("Say test")

from pydantic import BaseModel

class UserInfo(BaseModel):
    name: str
    age: int

# Using Structured Output Feature of Ollama - no instructor
ollama_user_info = ollama_chat.query("Extract the name and the age: 'John is 20 years old'", UserInfo)

# Using instructor[anthropic]
claude_user_info = claude_chat.query("Extract the name and the age: 'John is 20 years old'", UserInfo)

# Using instructor[groq]
groq_user_info = groq_chat.query("Extract the name and the age: 'John is 20 years old'", UserInfo)

```

# Install

## Using PIP

### Stable Version with PIP

Install from `PyPi`

```console
❯ pip install --upgrade tackleberry
```
langchain-turbopuffer 0.1.2
an unofficial langchain binding for turbopuffer
License: MIT
Requires Python: <3.13,>=3.10
Keywords: langchain, turbopuffer, vector-store

# langchain-turbopuffer

Use Turbopuffer as a vector store for LangChain.

## Usage

```bash
poetry add git+https://github.com/skyzh/langchain-turbopuffer
# see example.py for usage
```

```python
from langchain_turbopuffer import TurbopufferVectorStore

vectorstore = TurbopufferVectorStore(
    embedding=OllamaEmbeddings(model="mxbai-embed-large"),
    namespace="langchain-turbopuffer-test",
    api_key=os.getenv("TURBOPUFFER_API_KEY"),
)
```

## Local Development

```bash
git clone https://github.com/skyzh/langchain-turbopuffer
cd langchain-turbopuffer
poetry env use 3.12
poetry install

ollama pull mxbai-embed-large llama3.2
ollama run llama3.2
export TURBOPUFFER_API_KEY=your_api_key
poetry run python example.py
poetry run python example.py --skip-load
```

In the example, you can ask questions like "What is prompt engineering?"

## License

MIT

Note that the `example.py` is from [langchain-risinglight](https://github.com/skyzh/langchain-risinglight) based on several online tutorials (see the file header for more details).
langchain-risinglight 0.1.0
Langchain binding for RisingLight
License: MIT
Requires Python: <3.13,>=3.10

# langchain-risinglight

Use RisingLight as a vector store for LangChain.

## Usage

```python
# Activate your virtual environment, i.e., using poetry
poetry new risinglight-test-environment
cd risinglight-test-environment
poetry add --dev maturin
poetry add git+https://github.com/skyzh/langchain-risinglight
# Install risinglight in the virtual env
poetry shell
git clone https://github.com/risinglightdb/risinglight
cd risinglight
maturin build -F python
pip install ./target/wheels/risinglight-*.whl --force-reinstall
```

## Local Development

```python
git clone https://github.com/skyzh/langchain-risinglight
cd langchain-risinglight
poetry env use 3.12
poetry install
poetry shell
git clone https://github.com/risinglightdb/risinglight ../risinglight
cd ../risinglight
maturin build -F python
pip install ./target/wheels/risinglight-*.whl --force-reinstall
cd ../langchain-risinglight
poetry run python example.py
```
fileflows 0.2.8
A single high-level file operations API for both object stores and local file system.
License: MIT

Core functions are accessed through the `Files` class. This is a high-level interface for file operations on your local file system and/or s3 protocol object stores. Internally, appropriate functions will by called based on the type of arguments passed. i.e. `s3://` path or `/local/path`.

```py
from fileflows import Files
```
Core functions include `create, transfer, copy, move, delete, exists, file_size, list_files, parquet_column_names, df_from_csv, df_from_parquet`.
See [core](/fileflows/core.py) for more details.   

Additional functionality specific to s3 protocol object stores can be accessed through the `S3` class. See [s3](/fileflows/s3.py) for more details.
```py
from fileflows import S3
```

Both `Files` and `S3` take an optional `S3Cfg` object as argument (`from fileflows import S3Cfg`). `S3Cfg` contains parameters for the s3 protocol object store you are working with. If no argument is provided, `S3Cfg` will default to environment variables: `s3_endpoint_url` (http://localhost:9000 by default), `aws_access_key_id`, `aws_secret_access_key`.