semvec/pypi-packages huggingface dataset:
activeft 0.1.1
Efficiently fine-tune large neural networks by intelligent active data selection
License: MIT
Requires Python: >=3.10

# Active Fine-Tuning

A library for automatic data selection in active fine-tuning of large neural networks.

**[Website](https://jonhue.github.io/activeft)** | **[Documentation](https://jonhue.github.io/activeft/docs)**

Please cite our work if you use this library in your research ([bibtex below](#citation)):

- [Efficiently Learning at Test-Time: Active Fine-Tuning of LLMs]()
- [Transductive Active Learning: Theory and Applications](https://arxiv.org/abs/2402.15898) (Section 4)

## Installation

```
pip install activeft
```

## Usage Example

```python
from activeft.sift import Retriever

# Load embeddings
embeddings = np.random.rand(1000, 512)
query_embeddings = np.random.rand(1, 512)

index = faiss.IndexFlatIP(d)
index.add(embeddings)
retriever = Retriever(index)
indices = retriever.search(query_embeddings, N=10)
```

## Development

### CI checks

* The code is auto-formatted using `black .`.
* Static type checks can be run using `pyright`.
* Tests can be run using `pytest test`.

### Documentation

To start a local server hosting the documentation run ```pdoc ./activeft --math```.

### Publishing

1. update version number in `pyproject.toml` and `activeft/__init__.py`
2. build: `poetry build`
3. publish: `poetry publish`
4. push version update to GitHub
5. create new release on GitHub

## Citation

```bibtex
@article{hubotter2024efficiently,
	title        = {Efficiently Learning at Test-Time: Active Fine-Tuning of LLMs},
	author       = {H{\"u}botter, Jonas and Bongni, Sascha and Hakimi, Ido and Krause, Andreas},
	year         = 2024,
	journal      = {arXiv Preprint}
}

@inproceedings{hubotter2024transductive,
	title        = {Transductive Active Learning: Theory and Applications},
	author       = {H{\"u}botter, Jonas and Sukhija, Bhavya and Treven, Lenart and As, Yarden and Krause, Andreas},
	year         = 2024,
	booktitle    = {Advances in Neural Information Processing Systems}
}
```
pgman 0.0.6
Python操作PostgreSQL
License: MIT
Keywords: Python, DB, PostgreSQL

# 更新日志

- 第一版
- 添加数据时，表名称加入双引号，避免跟关键字冲突
- `getfv`方法中也补充双引号，避免冲突
- 修复BUG，fetchone返回None时不应该进行`dict转换`
- 工资的随机数进行向上取证，比如9800=10000、8278=8500
- 工资的随机数最低为3000

# 连接PostgreSQL

```python
from pgman import PostgreSQL

pg = PostgreSQL(db="test", user="wauo", password="123456")

name = "people"
pg.make_table(name)

res = pg.exe_sql("select * from people limit 10", query_all=True)
print(res)
```
juliustools 0.1.1
An API wrapper for the Julius Tools API
License: MIT
Requires Python: >=3.9
Keywords: julius, tools, api, wrapper

# Julius Tools API Wrapper

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

This Python API Wrapper provides a simple and intuitive interface for interacting with the Julius Tools API. It offers easy access to various endpoints, allowing you to leverage the power of Julius Tools in your Python projects.

## Features

- Simple and intuitive API
- Supports core Julius Tools API endpoints
- Automatic handling of authentication
- Enhanced error handling with detailed error information
- Comprehensive documentation (Soon)

## Installation

Install the Julius Tools API Client using pip:

```bash
pip install juliustools
```

## Quick Start

Here's a quick example to get you started with the Julius Tools API Wrapper:

```python
from juliustools import JuliusToolsAPI

# Initialize the client with your API key
api = JuliusToolsAPI(api_key="your_api_key_here")

# Get API status
status = api.get_status()
print(f"API Status: {status}")

# Perform a crypto operation
result = api.crypto_operation(text="Hello, World!", operation="encrypt")
print(f"Encrypted text: {result['result']}")
print(f"Encryption key: {result['key']}")

# Get a random quote
quote = api.get_random_quote()
print(f"Random quote: {quote['quote']}")

# Get a random joke
joke = api.get_random_joke()
print(f"Random joke: {joke['joke']}")
```

## Documentation

For detailed documentation on all available methods and their usage, please refer to our [official documentation](https://docs.tools.juliusbot.eu/).

## Available Methods

- `get_status()`: Get the API status
- `crypto_operation(text, operation, key=None)`: Perform encryption or decryption
- `get_random_quote()`: Get a random quote
- `get_random_joke()`: Get a random joke
- `add_content(content, content_type)`: Submit new content for approval

## Error Handling

The client provides informative error messages through a custom `APIError` exception. Here's an example of how to handle errors:

```python
from juliustools import JuliusToolsAPI, APIError

try:
    api = JuliusToolsAPI(api_key="invalid_key")
    api.get_status()
except APIError as e:
    print(f"An error occurred: {e}")
    if e.status_code:
        print(f"Status code: {e.status_code}")
    if e.response:
        print(f"Response content: {e.response.content}")
```

The `APIError` exception includes the following attributes:
- `message`: A descriptive error message
- `status_code`: The HTTP status code (if applicable)
- `response`: The full response object (if available)

This allows you to handle different types of errors (e.g., network errors, API errors, invalid API key) in a unified way while still having access to detailed error information when needed.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.