semvec/pypi-packages huggingface dataset:
setlogging 0.4.3
A flexible logging utility with JSON support and timezone awareness
License: MIT
Requires Python: >=3.9
Keywords: json, logging, timezone

# Setlogging

[![Python](https://img.shields.io/badge/Python-3.7+-blue.svg)](https://www.python.org/downloads/)
[![PyPI version](https://badge.fury.io/py/setlogging.svg)](https://badge.fury.io/py/setlogging)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A flexible Python logging utility with JSON support and timezone awareness.

## Author

- **Name:** Jie Yan
- **Contact:** <kiki3890528@gmail.com>

## Features

- JSON and plain text log formats
- Log file rotation with size limits
- Console and logfile output options
- Timezone-aware logging
- Customizable formatting
- Type-safe configuration

## Installation

```bash
pip install setlogging
```

## Usage

```python
from setlogging import get_logger

# Basic logging
logger = get_logger()
logger.info("Basic log message")

# JSON logging with indentation
logger = get_logger(json_format=True, indent=2)
logger.info("Structured logging")

# Custom file and rotation
logger = get_logger(
    log_file="/tmp/app.log",
    max_size_mb=10,  # 10MB
    backup_count=5
)

# Disable console output with log file
logger = get_logger(console_output=False, logfile="./logs/app.log")
logger.info("This will not be printed to the console")
```

## Project Structure

```
setlogging/
├── src/
│   └── setlogging/
│       ├── __init__.py
│       └── logger.py
├── tests/
│   ├── __init__.py
│   └── test_logger.py
├── README.md
└── LICENSE
```

## Configuration Options

| Option          | Type    | Default                        | Description                             |
|-----------------|---------|--------------------------------|-----------------------------------------|
| `log_level`     | int     | `DEBUG`                        | Logging level                           |
| `log_file`      | str     | `False`                        | Log file path                           |
| `max_size_mb`   | int     | `25`                           | Max file size in MB before rotation     |
| `backup_count`  | int     | `7`                            | Number of backup files                  |
| `console_output`| bool    | `True`                         | Enable console logging                  |
| `log_format`    | str     | `None`                         | Custom log format string                |
| `date_format`   | str     | `None`                         | Custom date format string               |
| `json_format`   | bool    | `False`                        | Enable JSON formatting                  |
| `indent`        | int     | `None`                         | JSON indentation level                  |
aerospace-chatbot 0.0.10.1
Aerospace engineering chatbot and AI tools.
License: MIT
Requires Python: <3.12.0,>=3.11.0

# Aerospace Chatbot
Aerospace discipline-specific chatbots and AI tools.
Help docs here: https://aerospace-chatbot.readthedocs.io/en/latest/

## Deployments
See https://danmueller.pro/ai-aerospace-tools/ for details.
pytorchltr2 0.2.3
Learning to Rank with PyTorch (Fork of pytorchltr)
License: MIT
Requires Python: >=3.10

# PyTorch Learning to Rank (LTR)

This is a library for Learning to Rank (LTR) with PyTorch.
The goal of this library is to support the infrastructure necessary for performing LTR experiments in PyTorch.

This is a fork of the original [pytorchltr](https://github.com/rjagerman/pytorchltr). It add fix and updates to allow it to work with Python >=3.10.


## Installation

In your virtualenv simply run:

    pip install pytorchltr2

Note that this library requires Python 3.10 or higher.

## Documentation

Original documentation is available [here](https://pytorchltr.readthedocs.io/).

## Example

See `examples/01-basic-usage.py` for a more complete example including evaluation

```python
import torch
from pytorchltr.datasets import Example3
from pytorchltr.loss import PairwiseHingeLoss

# Load dataset
train = Example3(split="train")
collate_fn = train.collate_fn()

# Setup model, optimizer and loss
model = torch.nn.Linear(train[0].features.shape[1], 1)
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
loss = PairwiseHingeLoss()

# Train for 3 epochs
for epoch in range(3):
    loader = torch.utils.data.DataLoader(train, batch_size=2, collate_fn=collate_fn)
    for batch in loader:
        xs, ys, n = batch.features, batch.relevance, batch.n
        l = loss(model(xs), ys, n).mean()
        optimizer.zero_grad()
        l.backward()
        optimizer.step()
```

## Dataset Disclaimer
This library provides utilities to automatically download and prepare several public LTR datasets.
We cannot vouch for the quality, correctness or usefulness of these datasets.
We do not host or distribute these datasets and it is ultimately **your responsibility** to determine whether you have permission to use each dataset under its respective license.

## Citing
If you find this software useful for your research, please cite the publication for the original pytorchltr.

    @inproceedings{jagerman2020accelerated,
        author = {Jagerman, Rolf and de Rijke, Maarten},
        title = {Accelerated Convergence for Counterfactual Learning to Rank},
        year = {2020},
        publisher = {Association for Computing Machinery},
        address = {New York, NY, USA},
        booktitle = {Proceedings of the 43rd International ACM SIGIR Conference on Research and Development in Information Retrieval},
        doi = {10.1145/3397271.3401069},
        series = {SIGIR’20}
    }