semvec/pypi-packages huggingface dataset:
logsteplib 0.0.22
A library providing a standardised format for logging.
Requires Python: >=3.10
Keywords: Logging, Log, Python, Configuration, Lakehouse, DataBricks

# logsteplib

- [Description](#package-description)
- [Usage](#usage)
- [Installation](#installation)
- [Docstring](#docstring)
- [License](#license)

## Package Description

A library providing a standardised format for the logging module.

## Usage

### Stream Console Logs

From a script:

```python
# Initialise a logger for the process and log an informational message
from logsteplib.streamer import StreamLogger

logger = StreamLogger(name="my_process").logger

logger.info(msg="Something to log!")
# 2025-11-02 00:00:01 - my_process           - INFO     - Something to log!
```

## Installation

Install python and pip if you have not already.

Then run:

```bash
pip install pip --upgrade
```

For production:

```bash
pip install logsteplib
```

This will install the package and all of it's python dependencies.

If you want to install the project for development:

```bash
git clone https://github.com/aghuttun/logsteplib.git
cd logsteplib
pip install -e ".[dev]"
```

## Docstring

The script's docstrings follow the numpydoc style.

## License

BSD License (see license file)

[top](#logsteplib)
kuaijs-ios-ext 0.2.40
快点JS代码提示与类型检查。
Requires Python: >=3.8
Keywords: kuaijs, types, stubs, ios, automation

# kuaijs-ios

`快点JS` Python 包的类型桩，仅用于「快点 JS」代码提示与类型检查。

## 安装

```bash
pip install kuaijs-ios-ext
```

## 说明

- 用于编辑器智能提示与类型检查。
run 0.3
Python process run control
Requires Python: >=3.0

============
 python-run
============

This module provides convenient ways to guarantee a certain script
state. 

``run.alone``
=============

Make sure only one instance of the program is running,
this is done by acquiring an fcntl file lock on the
current script:

    >>> import run.alone

Caveats
-------

There are a few things to keep in mind:

1. import run.alone once, it will exit your program if it gets
   imported twice

2. symlinked scripts will be resolved to the inode it has been
   linked to, this is a limitiation of using fcltn file locks

``run.until``
=============

Run until a specified timespec, if the process runs
longer, it will be killed:

    >>> import run
    >>> run.until('23m42s')
    >>> ...

You can also choose to limit on the amount of CPU-time
being consumed (default is wall clock time):

    >>> run.until('42s', 'cpu')
    >>> ...

Acknowledgements
================

This module is dirived from the `Sys::RunAlone`_ and 
`Sys::RunUntil`_ perl modules written by `Elizabeth Mattijsen`_.

.. _Sys::RunAlone: http://search.cpan.org/~elizabeth/Sys-RunAlone/
.. _Sys::RunUntil: http://search.cpan.org/~elizabeth/Sys-RunUntil/
.. _Elizabeth Mattijsen: http://search.cpan.org/~elizabeth/
langchain-iris 0.2.3b1
The InterSystems IRIS adoption for Langchain
Requires Python: >3.8
Keywords: "InterSystems IRIS"

# Langchain with InterSystems IRIS

[Langchain](https://github.com/langchain-ai/langchain) with support for InterSystems IRIS


## Install

```shell
pip install langchain-iris
```

## Example

```python
import os
from dotenv import load_dotenv

from langchain.docstore.document import Document
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.embeddings.fastembed import FastEmbedEmbeddings

from langchain_iris import IRISVector

loader = TextLoader("state_of_the_union.txt")
documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
docs = text_splitter.split_documents(documents)

CONNECTION_STRING = 'iris://_SYSTEM:SYS@localhost:1972/USER'

load_dotenv(override=True)

embeddings = OpenAIEmbeddings()

COLLECTION_NAME = "state_of_the_union_test"

db = IRISVector.from_documents(
    embedding=embeddings,
    documents=docs,
    collection_name=COLLECTION_NAME,
    connection_string=CONNECTION_STRING,
)

query = "What did the president say about Ketanji Brown Jackson"
docs_with_score = db.similarity_search_with_score(query)

for doc, score in docs_with_score:
    print("-" * 80)
    print("Score: ", score)
    print(doc.page_content)
    print("-" * 80)
```
loro 1.10.3
Python bindings for [Loro](https://loro.dev)
Requires Python: >=3.8
Keywords: local-first, CRDT, loro

[![PyPI version](https://badge.fury.io/py/loro.svg)](https://badge.fury.io/py/loro)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

<h1 align="center">loro-py</h1>

<p align="center">
  <a aria-label="X" href="https://x.com/loro_dev" target="_blank">
    <img alt="" src="https://img.shields.io/badge/Twitter-black?style=for-the-badge&logo=Twitter">
  </a>
  <a aria-label="Discord-Link" href="https://discord.gg/tUsBSVfqzf" target="_blank">
    <img alt="" src="https://img.shields.io/badge/Discord-black?style=for-the-badge&logo=discord">
  </a>
</p>

Python bindings for [Loro CRDT](https://github.com/loro-dev/loro). If you have
any issues or suggestions, please feel free to create an issue or join our
[Discord](https://discord.gg/tUsBSVfqzf) community.

## Features

- High-performance CRDT operations with Rust implementation
- Rich data types support: Text, List, Map, Tree, Movable List, Counter
- Python-friendly API design

## Installation

```shell
pip install loro
```

## Quick Start

```python
from loro import LoroDoc

# Create a new document
doc = LoroDoc()
# Get a text container
text = doc.get_text("text")
# Insert text
text.insert(0, "Hello, Loro!")
# store the `subscription` reference to prevent garbage collection
sub = doc.subscribe_root(lambda e: print(e))
doc.commit()
```

## Development

### Prerequisites

- Python 3.8+
- Rust toolchain
- [maturin](https://github.com/PyO3/maturin)

### Setup Development Environment

1. Clone the repository

```shell
git clone https://github.com/loro-dev/loro-py
cd loro-py
```

2. Install development dependencies and run

```shell
# choose your python venv
pip install maturin
maturin develop
```
raga-testing-platform 1.1.79
Short description or overview of the raga package.
Requires Python: >=3.9
Keywords: testing-platform, raga-testing-platform, model-testing, AB_testing


# Raga Testing Platform

The `raga-testing-platform` package provides a Python client for interacting with the Raga Testing Platform. It allows you to easily create and manage test sessions, datasets, and perform various testing operations.


## Installation
You can install `raga-testing-platform` using pip:

`pip install raga-testing-platform`

## Usage
To use the package, import the necessary classes and modules:

```
from raga import Dataset, TestSession, Auth
import pandas as pd
from typing import Optional, List, Dict
```
### Creating a test DataFrame

```
test_df = pd.DataFrame({
    'column1': [1, 2, 3],
    'column2': ['a', 'b', 'c']
})
```
### Defining the Schema class

```
class Schema:
    def __init__(
        self,
        prediction_id: Optional[str] = None,
        timestamp_column_name: Optional[str] = None,
        feature_column_names: Optional[List[str]] = None,
        metadata_column_names: Optional[List[str]] = None,
        label_column_names: Optional[Dict[str, str]] = None,
        embedding_column_names: Optional[Dict[str, str]] = None,
    ):
        self.prediction_id = prediction_id
        self.timestamp_column_name = timestamp_column_name
        self.feature_column_names = feature_column_names
        self.metadata_column_names = metadata_column_names
        self.label_column_names = label_column_names
        self.embedding_column_names = embedding_column_names
```

### Creating an instance of the Schema class
```
schema = Schema()
```

### Creating an instance of the Auth class
It will create auth token for further usages.
```
auth = Auth()
```

This variable stores auth token. You can use it untill expire token.
```
auth.token
```

### Creating an instance of the TestSession class
In this instance `experiment` will create and return `experiment_id`
```
experiment_id = TestSession(token, 1, "my_experiment")
```
This variable stores `experiment_id`. You can use it in further experiment.
```
experiment_id.experiment_id
```
### Creating an instance of the Dataset class

```
test_ds = Dataset(token, experiment_id, test_df, schema, "DatasetName")
```

### Loading labels from a file

```
test_ds.load_labels_from_file(
    "/path/to/labels.json",
    "dataset_name",
    "id_column_name",
    "label_column_name",
    "metadata_column_name",
    "category_column_name",
    "category_id_column_name"
)
```

### To Debug
```
export DEBUG=1
```
inspect-k8s-sandbox 0.3.0
A Kubernetes Sandbox Environment for Inspect
Requires Python: >=3.10

[<img width="295" src="docs/docs/assets/aisi-logo.svg" />](https://aisi.gov.uk/)

Welcome to the `k8s_sandbox` plugin for [Inspect](https://inspect.aisi.org.uk/). It
provides a Kubernetes (K8s) sandbox environment in which agentic evaluations can
securely be run at scale.

We are releasing this publicly because it is a useful example of a complex Sandbox
Environment provider. While this work was designed within the context of UK AISI's
infrastructure, we do expect it to be useful to other organisations if they adopt some
of our conventions. If you have an existing Kubernetes cluster this provider may work
for you, or may require further tailoring and adaptation. To ask questions or discuss
adopting this plugin, come join us in the [Inspect
Slack](https://join.slack.com/t/inspectcommunity/shared_invite/zt-2w9eaeusj-4Hu~IBHx2aORsKz~njuz4g)!

You can find documentation at
[https://k8s-sandbox.aisi.org.uk/](https://k8s-sandbox.aisi.org.uk/).

If you’d like to contribute to the development of the plugin, please review our
[contributing guidelines](CONTRIBUTING.md) before raising a pull request.

Created by the [UK AI Security Institute](https://aisi.gov.uk/).