semvec/pypi-packages huggingface dataset:
PersistentRequests 0.1.3
A Python library that provides a simple and effective caching layer for web requests.

# CacheRequests

CacheRequests is a Python library that provides a simple and effective caching layer for your web requests. It's built on top of the popular `requests` library and is designed to be a drop-in replacement for `requests.Session`.

## Features

*   **Persistent Caching:** Save responses to disk to speed up repeated requests.
*   **Automatic Cache Invalidation:** Set a time-to-live (TTL) for your cached responses.
*   **Customizable:** Configure cache directories, refresh policies, and more.
*   **Easy to Use:** A simple, intuitive API that gets out of your way.

## Installation

Install CacheFlow using pip:

```bash
pip install PersistentRequests
```

## Quick Start

Here's a simple example of how to use CacheRequests:

```python
from CacheRequests import CacheSession
from datetime import timedelta

# Create a new session with a cache directory
requests = CacheSession(cache_dir='.cache', refresh_after=timedelta(hours=1)) # or use `from CacheRequests import requests`

# Make a request
response = requests.get('https://api.github.com')

# The response is now cached. Subsequent requests to the same URL will be served from the cache.
cached_response = requests.get('https://api.github.com')

print(response.json())
```

## Advanced Usage

### Configuration

You can configure the behavior of CacheRequests by passing arguments to the `CacheSession` constructor:

*   `cache_dir`: The directory where cached responses will be stored.
*   `force_refresh`: If `True`, the cache will be ignored and all requests will be made to the network.
*   `refresh_after`: A `timedelta` object that specifies how long a cached response is valid.
*   `refresh_on_error`: If `True`, the cache will be refreshed if a cached response resulted in an error.

### Context Manager

You can also use a context manager to temporarily change the configuration:

```python
with requests.configure(force_refresh=True):
    # This request will bypass the cache
    response = requests.get('https://api.github.com')
```

## Deleting Cache Entries

CacheFlow provides multiple ways to manage your cache.

### Deleting by URL

You can delete cache entries based on a URL pattern:

```python
from CacheRequests import delete_cache_by_function
def should_delete(url: str):
    return 'github.com' in url

delete_cache_by_function(requests, should_delete)
```
### Deleting by Expiration

You can delete cache entries that are older than a specified timedelta:

```python
from CacheRequests import delete_cache_by_expiration
from datetime import timedelta
# Delete all cache entries older than 7 days
delete_cache_by_expiration(requests, timedelta(days=7))
```


## Contributing

Contributions are welcome! If you have a feature request, bug report, or pull request, please open an issue on GitHub.

## License

CacheRequests is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
CancerstFormer 0.1.0a0
A flexible framework for transformer-based analysis of spatial transcriptomics data.
Requires Python: >=3.8

# stFormer

A flexible framework for transformer-based analysis of spatial transcriptomics data. stFormer provides tools for data tokenization, pretraining, embedding extraction, in silico perturbation, and downstream classification.

- Keep up to date on [Github](https://github.com/istrope/stFormer)
- Browse model files on [Hugging-Face](https://huggingface.co/Istrope/stFormer)

# Install
```bash
pip install --upgrade stformer
```
> **Prerequisites:** Python3.8+, OpenMPI (for deepspeed only)

# Features
- Data Tokenization
- Pretraining
- Token/Sequence Classification
- In Silico Perturbation
- Network Dynamic Predictions

## Contributing

Contributions are welcome! Please open issues at our [Github](https://github.com/istrope/stFormer) or submit pull requests for bug fixes and new features.

## Models
Pretrained models and datasets are available through our [hugging-face](https://huggingface.co/Istrope/stFormer) model card 

## License

This project is licensed under the MIT License. See [LICENSE](https://github.com/istrope/stFormer/blob/main/LICENSE) for details.
weskit-client 1.0.1
Client for WESkit deployment and workflow execution.
Requires Python: >=3.12.0
Keywords: WESkit, client, workflow, execution, data, management, GA4GH-WES, WES

# WESkit Client

The WESkit client is a command-line tool for interacting with a WESkit instance.
It provides a simple interface for managing workflows, executing runs, and monitoring their status.

- For a detailed installation and usage instructions see the [WESkit client documentation](https://gitlab.com/one-touch-pipeline/weskit/documentation/-/blob/master/user/client.md)
kauldron 1.3.0
Kauldron is a ML research library optimized for quick iteration and modularity.
Requires Python: >=3.11

# kauldron

[![Unittests](https://github.com/google-research/kauldron/actions/workflows/pytest_and_autopublish.yml/badge.svg)](https://github.com/google-research/kauldron/actions/workflows/pytest_and_autopublish.yml)
[![PyPI version](https://badge.fury.io/py/kauldron.svg)](https://badge.fury.io/py/kauldron)
[![Documentation Status](https://readthedocs.org/projects/kauldron/badge/?version=latest)](https://kauldron.readthedocs.io/en/latest/?badge=latest)

Kauldron is a library for training machine learning models, optimized for
**research velocity** and **modularity**.

**Modularity**:

*   All parts of Kauldron are self-contained, so can be used independently
    outside Kauldron.
*   Use any dataset (TFDS, Grain, SeqIO, your custom pipeline),
    any (flax) model, any optimizer,... Kauldron provides the
    glue that link everything together.
*   Everything can be customized and overwritten (e.g. sweep over models
    architecture, overwrite any inner layer parameter,...)

**Research velocity**:

*   Everything should work out-of the box. The
    [example configs](https://github.com/google-research/kauldron/tree/main/examples/mnist_autoencoder.py)
    can be used and customized as a starting point.
*   Colab-first workflow for easy prototyping and fast iteration
*   Polished user experience (integrated XM plots, profiler,
    post-mortem debugging on borg, runtime shape checking, and many others...).
[Open an issue](https://github.com/google-research/kauldron/issues)..

*This is not an officially supported Google product.*
dspacelogs 0.1.6
A simple analyzer for DSpace log files
Requires Python: >=3.8

# dspacelogs: DSpace Log Analyzer

A simple library to analyze and visualize DSpace access logs.

---

## Installation

Install or upgrade to the latest version using pip:
```bash
pip install --upgrade dspacelogs
```
Quick Start Guide
This guide shows the simplest way to get your first results.

1. Create a Python Script
Create a new file, for example analyze.py.

2. Add Code and Edit Path
Copy the code below into your file. Remember to change the log_file_path to the actual path of your log file.

This example is a simplified version of the logic found in DSpace_run.py and uses the methods from the loganalyzer class.
```
from dspacelogs import loganalyzer

# Define the path to your log file
log_file_path = "C:/path/to/your/access.log"

# Create an analyzer instance
analyzer = loganalyzer(log_file_path=log_file_path)

# Load data and get a result
if analyzer.load_data():
    # Get and print the top 5 most frequent requests
    top_5_pages = analyzer.get_top_requests(n=5)
    print("Top 5 Pages:")
    print(top_5_pages)

    # You can also create a plot by uncommenting the next line
    # analyzer.plot_activity_by_minute()
```
3. Run Your Script
Open your terminal, navigate to your file's directory, and run it:

```bash
python analyze.py
```
You will see a table with the top 5 pages printed in your terminal.
report-of-monaco-2018-racing 0.1.1
Генератор звіту про гонку F1 Monaco 2018 з CLI інтерфейсом
Requires Python: >=3.12

# F1 Monaco 2018 Race Report Generator

A command‑line tool for parsing lap‑time logs and generating a formatted report of the F1 Monaco 2018 Grand Prix.

## Table of Contents

* [Overview](#overview)
* [Features](#features)
* [Prerequisites](#prerequisites)
* [Installation](#installation)
* [Usage](#usage)

  * [Required Arguments](#required-arguments)
  * [Optional Flags](#optional-flags)
  * [Examples](#examples)
* [Project Structure](#project-structure)
* [License](#license)

## Overview

This Python utility reads three files—`start.log`, `end.log`, and `abbreviations.txt`—to compute each driver’s total lap time for the 2018 Monaco Grand Prix, then prints a sorted leaderboard. You can choose ascending or descending order, and filter by a single driver’s name.

## Features

* Parses timestamped log files and driver abbreviations.
* Calculates total race time for each competitor.
* Supports sorting results in ascending (fastest first) or descending (slowest first) order.
* Optional filtering to display a specific driver’s result.
* Clearly formatted console output with ranking, driver name, team, and time.

## Prerequisites

* Python 3.12 or higher
* Standard library only; no external dependencies

## Installation

1. Clone the repository:

   ```bash
   git clone git@git.foxminded.ua:foxstudent108448/report-of-monaco-2018-racing.git```
   ```
2. Ensure the three input files are placed in a single folder:

   * `start.log`
   * `end.log`
   * `abbreviations.txt`

## Usage

Run the script `main.py` (or whatever you rename `main.py`) with the required `--files` argument pointing to your folder.

```bash
python main.py --files /path/to/logs [--asc] [--desc] [--driver DRIVER_NAME]
```

### Required Arguments

* `--files`
  Path to the directory containing `start.log`, `end.log`, and `abbreviations.txt`.

### Optional Flags

* `--asc`
  Sort the report in ascending order (fastest times first). This is the default if neither `--asc` nor `--desc` is specified.
* `--desc`
  Sort the report in descending order (slowest times first).
* `--driver DRIVER_NAME`
  Only display the result for the driver whose full name matches `DRIVER_NAME` (case‑insensitive).

### Examples

* Generate an ascending leaderboard (default):

  ```bash
  python main.py --files ./data
  ```
* Generate a descending leaderboard:

  ```bash
  python main.py --files ./data --desc
  ```
* Show only Lewis Hamilton’s result:

  ```bash
  python main.py --files ./data --driver "Lewis Hamilton"
  ```

## Project Structure

```
f1‑monaco‑2018‑report/
├── main.py                       # Entry‑point script with argparse
├── report/
│   └── report_maker.py           # Logic to parse logs and build the report
├── data/                         # Example folder containing:
│   ├── start.log
│   ├── end.log
│   └── abbreviations.txt
└── README.md                     # This file
```

## License

This project is licensed under the MIT License. Feel free to use, modify, and distribute.
corpstatsII 1.1.9
Extended Corpstats module for AllianceAuth
Requires Python: >=3.10
Keywords: allianceauth, corpstats

# CorpStats 2.0

## CorpStatsII fork
[This is a fork from the orginal CorpStat 2.0](https://github.com/Solar-Helix-Independent-Transport/allianceauth-corpstats-two)

To migrate from CorpStats to this fork, run the following

* source in your env.

```bash
pip uninstall aa-corpstats-two
pip install corpstatsII
```

* run migrations and static data

```bash
python /home/allianceserver/myauth/manage.py migrate
python /home/allianceserver/myauth/manage.py collectstatic --noinput
```

* restart auth


### Electric Boogaloo!

Extended Corpstats module for [AllianceAuth](https://gitlab.com/allianceauth/allianceauth) with some extra features around corp member tracking, and auth utilization.

Includes:
 * Corp level views
 * Corp Overview views
 * Member Service activation stats
 * Member Tracking
   * Last Login and Duration
   * Last known ship
 
Based on the hard work of:
 * [Ariel Rin](https://gitlab.com/soratidus999/allianceauth/tree/new-corpstats)
 * [Adarnof](https://github.com/Adarnof/allianceauth/tree/new_corpstats)

Previous Dev (all credits to him, for this app!):
* [AaronKable](https://github.com/pvyParts)

Active Devs:
* [Dejar Winter](https://github.com/DejarW/)
 
## Installation
 1. Install the Repo `pip install corpstatsII`
 2. Add `'corpstats',` to your `INSTALLED_APPS` in your projects `local.py`
 3. run migrations and restart auth
 3. setup your perms as documented below

## Permissions
If you are coming fromn the inbuilt module simply replace your perms from `corputils` with the matching `corpstats` perm

Perm | Admin Site | Auth Site 
 --- | --- | --- 
corpstats view_corp_corpstats | None | Can view corp stats of their corporation.
corpstats view_alliance_corpstats | None | Can view corp stats of members of their alliance.
corpstats view_state_corpstats | None | Can view corp stats of members of their auth state.
corpstats view_all_corpstats | None | Can view all corp stats.
corpstats add_corpstat | Can create model | Can add new corpstats using an SSO token.
corpstats change_corpstat |Can edit model | None.
corpstats remove_corpstat | Can delete model | None.

## Usage
Is very well documented [here](https://allianceauth.readthedocs.io/en/latest/features/apps/corpstats.html?highlight=corpstats#creating-a-corp-stats)

## Contributing
Make sure you have signed the [License Agreement](https://developers.eveonline.com/resource/license-agreement) by logging in at https://developers.eveonline.com before submitting any pull requests. All bug fixes or features must not include extra superfluous formatting changes.

## Changes
1.1.9
* Support Alliance Auth => 4.0

1.1.0
 * Added service activation information
 * Modified alliance view to show all corpstats visible to a user
 * updated to django-esi >= 2.0.0
 * FA 5 update

1.0.4 
 * perms fixes
telelogs 1.4.15
Telelogs — a lightweight Python library for sending logs and alerts directly to Telegram.

# TeleLogs - Telegram Logging Utility

A lightweight Python library for sending logs, status updates, and files to Telegram administrators.

## Installation

```bash
pip install telelogs
```

## Basic Usage

### Initialization

First, import and initialize the logger with your Telegram bot token and admin chat IDs:

```python
import telelogs

logger = telelogs.TeleLogs(
    bot_token="YOUR_TELEGRAM_BOT_TOKEN",
    log_file_path="application.log",  # Path to your log file
    admin_chat_ids=[ADMIN_CHAT_ID_1, ADMIN_CHAT_ID_2]  # List of admin chat IDs
)
```

### Core Features

#### 1. Sending Messages

Send a notification to all registered administrators:

```python
logger.send_message_to_all("Server started successfully!")
```

#### 2. Shutdown Reports

Send a shutdown report with custom message:

```python
logger.send_shutdown_report("Application terminated gracefully")
```

#### 3. Log File Delivery

Send the current log file to administrators:

```python
logger.send_log_file()
```

## Advanced Configuration

### Error Handling

The library will raise `ValueError` if:
- Bot token is invalid
- No admin chat IDs are provided
- Log file path doesn't exist

### Recommended Setup

For production environments:

```python
logger = telelogs.TeleLogs(
    bot_token=os.getenv("TELEGRAM_BOT_TOKEN"),
    log_file_path="/var/log/myapp.log",
    admin_chat_ids=list(map(int, os.getenv("ADMIN_CHAT_IDS").split(',')))
)
```

## Security Notes

1. **Never hardcode credentials** - Use environment variables or secret management
2. **Rotate log files** - Ensure log files don't grow indefinitely
3. **Limit admin access** - Only trusted users should receive logs

## Example Use Cases

- Server monitoring notifications
- Automated deployment alerts
- Critical error reporting
- Daily status reports

## License

MIT License - Free for commercial and personal use.
create-agentic-app 1.0.3
An AI agent centric micro-service project scaffolding CLI
Requires Python: >=3.8

# create-agentic-app

A simple CLI tool to scaffold a new agentic application project using a Cookiecutter template.

## Features

- Quickly generate a new agentic app project structure.
- Uses [Cookiecutter](https://cookiecutter.readthedocs.io/) for flexible templating.
- Minimal dependencies and easy to use.

## Installation

You can install the required dependencies using pip:
pip install -r requirements.txt
mhdtools 1.0.1
Tools to manipulate MHD/RAW files
Requires Python: >=3.8

# A tools collection for MHD/RAW files

## Installation

A python virtual environment is advised:
```sh
# move somewhere you want your environment to be
python -m venv mhdtools
source mhdtools/bin/activate
pip install -U pip
pip install mhdtools
```

## Available tools

### `mhdview`

An MHD/RAW file 2D viewer.
See `--help` for features and options.