semvec/pypi-packages huggingface dataset:
resource-reporter 0.1.3
A comprehensive monitoring library for real-time resource tracking and remote management of containerized applications with support for metrics reporting, asynchronous event notifications, and command listening via Google PubSub
Requires Python: >=3.6
Keywords: monitoring, resource, metrics, pubsub, containers, kubernetes, docker, reporting, distributed, cloud

# Resource Reporter

A Python library for monitoring and reporting resource usage in containerized applications, with support for asynchronous event reporting and command listening.

## Features

- Regular resource usage reporting (CPU, memory, network, GPU)
- Asynchronous event reporting
- Command listening via Google PubSub for remote control of containers
- Support for graceful shutdown and restart

## Installation

### Basic Installation

```bash
pip install resource-reporter
```

### With GPU Support
```bash
pip install resource-reporter[gpu]
```

### Quick Start
```Python
from resource_reporter import ResourceReporter

# Initialize the reporter
reporter = ResourceReporter(
    metrics_endpoint_url="http://monitoring-service/api/metrics",
    events_endpoint_url="http://monitoring-service/api/events",
    interval=30,
    consumer_id="consumer-1",
    group_consumer="production"
)

# Start reporting
reporter.start()

# Report an event
reporter.async_report_event({
    "status": 200,
    "error_code": 0,
    "error_message": "",
    "result": {"processed": True},
    "stats_data": {"duration_ms": 120},
    "task_id": "task-123"
})

# Update job stats
reporter.update_job_stats({
    "processed": 1000,
    "errors": 5
})

# Stop the reporter when done
reporter.stop()
```
### Documentation
## Environment Variables

The Resource Reporter library uses several environment variables for configuration. While most parameters can be passed directly to the constructor, environment variables provide a convenient way to configure the reporter, especially in containerized environments.

### Required Environment Variables

None of the environment variables are strictly required, as all configuration can be passed directly to the constructor. However, the following are commonly used:

### Optional Environment Variables

| Variable | Description | Default |
|----------|-------------|---------|
| `GROUP_CONSUMER` | Group identifier for the consumer | `"default"` |
| `API_KEY` | API key for authentication with metrics and events endpoints | None |
| `GOOGLE_APPLICATION_CREDENTIALS` | Path to Google Cloud credentials JSON file | None |

### Google Cloud Authentication

For PubSub command listening functionality, the reporter requires Google Cloud authentication. There are several ways to provide this:

1. **Service Account JSON** (recommended for non-GCP environments):
   ```bash
   export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-key.json
License
MIT
curriculum-analysis 0.2.12
A simple tool for analysing DMU module and programme specifications with respect to provided keywords.
Requires Python: >=3.10

# Curriculum analysis

A simple tool for analysing DMU module and programme specifications with respect to provided keywords.

## Installation

Installation is via pip.

```
pip install curriculum_analysis
```

## Usage

Basic usage is via the command line script `curriculum-analysis`.

```
curriculum-analysis <filename> [-c <optional configuration file>]
```

The tool will process the provided file according to the configuration given.
If no configuration is given, then the default configuration will be used.

The default configuration file (`config.cfg`) is placed in the users home directory under a hidden folder `~/.curriculumAnalysis`.

```
[curriculumAnalysis]
keywords_path = ~/.curriculumAnalysis/keywords.txt
outpath = ~/.curriculumAnalysis/output
format = js
```

Changing these values will influence the default settings.

## Example usage

```
curriculum-analysis modules.txt
```
job-scraper-lib 0.2.1
A Python library for scraping job listings from company career pages
Requires Python: >=3.6

# Job Scraper Library

## Overview
This Python library allows users to **automatically extract job listings** from a company's career page. The library scrapes job postings and updates the data **automatically** to ensure real-time job availability.

## Features
- Extracts job listings from any career page URL
- Automatically updates job data
- Easy to integrate into job board websites
- Uses **Selenium** and **WebDriver-Manager** for automation

## Installation
Before using the library, install the required dependencies:

```bash
pip install selenium webdriver-manager
```

## Usage
Here is how to use the library to scrape job postings:

```python
from job_scraper import JobScraper

# Initialize scraper with career page URL
scraper = JobScraper("https://www.google.com/about/careers/applications/jobs/results?has_remote=true")

# Get job listings
jobs = scraper.fetch_jobs()

# Print job details
for job in jobs:
    print(job)
```

## Requirements
- Python 3.7+
- Google Chrome (Latest Version)
- ChromeDriver (Managed automatically by `webdriver-manager`)

## Troubleshooting
### "ImportError: No module named 'selenium'"
Run:
```bash
pip install selenium webdriver-manager
```

### "ChromeDriver Version Error"
If ChromeDriver version is outdated, update it:
```bash
pip install --upgrade webdriver-manager
```

## Contributing
Feel free to submit **pull requests** for improvements or bug fixes.

## License
This project is **open-source** under the MIT License.
warc-s3 1.0.1
Scalable and easy WARC records storage on S3.
Requires Python: >=3.8

[![PyPi](https://img.shields.io/pypi/v/warc-s3?style=flat-square)](https://pypi.org/project/warc-s3/)
[![CI](https://img.shields.io/github/actions/workflow/status/janheinrichmerker/warc-s3/ci.yml?branch=main&style=flat-square)](https://github.com/janheinrichmerker/warc-s3/actions/workflows/ci.yml)
[![Code coverage](https://img.shields.io/codecov/c/github/janheinrichmerker/warc-s3?style=flat-square)](https://codecov.io/github/janheinrichmerker/warc-s3/)
[![Python](https://img.shields.io/pypi/pyversions/warc-s3?style=flat-square)](https://pypi.org/project/warc-s3/)
[![Issues](https://img.shields.io/github/issues/janheinrichmerker/warc-s3?style=flat-square)](https://github.com/janheinrichmerker/warc-s3/issues)
[![Commit activity](https://img.shields.io/github/commit-activity/m/janheinrichmerker/warc-s3?style=flat-square)](https://github.com/janheinrichmerker/warc-s3/commits)
[![Downloads](https://img.shields.io/pypi/dm/warc-s3?style=flat-square)](https://pypi.org/project/warc-s3/)
[![License](https://img.shields.io/github/license/janheinrichmerker/warc-s3?style=flat-square)](LICENSE)

# 💾 warc-s3

Scalable and easy WARC records storage on S3.

## Installation

Install the package from PyPI:

```shell
pip install warc-s3
```

## Usage

TODO

## Development

To build this package and contribute to its development you need to install the `build`, and `setuptools` and `wheel` packages:

```shell
pip install build setuptools wheel
```

(On most systems, these packages are already pre-installed.)

Then, install the package and test dependencies:

```shell
pip install -e .[tests]
```

You can now verify your changes against the test suite.

```shell
ruff check .                   # Code format and LINT
mypy .                         # Static typing
bandit -c pyproject.toml -r .  # Security
pytest .                       # Unit tests
```

Please also add tests for your newly developed code.

### Build wheels

Wheels for this package can be built with:

```shell
python -m build
```

## Support

If you hit any problems using this package, please file an [issue](https://github.com/janheinrichmerker/warc-s3/issues/new).
We're happy to help!

## License

This repository is released under the [MIT license](LICENSE).
ansys-codefest 0.2.0
Ansys Codefest Companion Library
Requires Python: <4,>=3.11

# Ansys CodeFest Companion Library

This package is a companion library to Ansys CodeFests. The challenges have varying storylines and contexts, 
however, they all have the same common framework. For example, to access the PyMAPDL structures challenges, 
execute the following code.

```python
import ansys.codefest.mapdl as acf

# Challenge ids are *always* strings because some contain letters as well as numbers.
challenge = acf.Start.builtin_challenge('1a')
challenge.display_problem()
```

Then, once the specific challenge has been detailed, you can submit solution attempts using the following commands.

```python
import ansys.codefest.mapdl as acf

# Challenge ids are *always* strings because some contain letters as well as numbers.
challenge = acf.Start.builtin_challenge('1a')
design = challenge.suggest_a_design()
bridge = challenge.build_bridge(design)
success, feedback, beams = bridge.assess_for_breaks()
print(f'Bridge costs ${challenge.calculate_design_cost(design)} dollarydoos')
bridge.plot()
```

The program will then test your attempt and provide feedback about what you did wrong (if anything).
Finally, it will give a breakdown of all the elements you used and how close to the yield strength they came as 
percentages.