semvec/pypi-packages huggingface dataset:
pyweb-moderator-api 1.0.0
Library for using the API for PyWeb AI Moderator.
Requires Python: >=3.6
Keywords: antispam moderator ai api pyweb pywebsol

### PyWebSolutions API Python Library

This is a Python library for interacting with the PyWeb Moderator API. The library provides both synchronous and asynchronous methods for making requests to the PyWeb Moderator API, allowing you to easily integrate PyWebSolutions functionality into your Python applications.

## Usage
Synchronous API:

```python
import pyweb_moderator_api

text = "Example text"

with pyweb_moderator_api.SyncAPI(token="your_api_token") as client:
    result = client.getClass(text)

text_class = result.text_class
time_taken = result.time_taken
confidence = result.confidence
unique_id = result.unique_id
balance = result.balance
label = result.label

print(f"Text class: {text_class}\nLabel: {label}\nTime taken: {time_taken}\nConfidence: {confidence}\nId: {unique_id}\nRemaining balance: {balance}")
```

Asynchronous API:

```python
import pyweb_moderator_api
import asyncio

async def main():
    text = "Example text"

    async with pyweb_moderator_api.AsyncAPI(token="your_api_token") as client:
        result = await client.getClass(text)

    text_class = result.text_class
    time_taken = result.time_taken
    confidence = result.confidence
    unique_id = result.unique_id
    balance = result.balance
    label = result.label

    print(f"Text class: {text_class}\nLabel: {label}\nTime taken: {time_taken}\nConfidence: {confidence}\nId: {unique_id}\nRemaining balance: {balance}")

asyncio.run(main())
```

Replace "your_api_token" with your actual API key from telegram bot https://t.me/RuModeratorAI_API_Bot.

API endpoint URL: http://pywebsolutions.ru:30
API documentation: http://pywebsolutions.ru:30/docs
functionCacher 1.0.5.2
Cache function results to disk

# Function Cacher

[![Documentation Status](https://readthedocs.org/projects/function-cacher/badge/?version=latest)](https://function-cacher.readthedocs.io/en/latest/?badge=latest) 
[![Test Status](https://gitlab.com/philipp.friese/function-cacher/badges/main/pipeline.svg)](https://gitlab.com/philipp.friese/function-cacher/badges/main/pipeline.svg)

## Overview

The Function Cacher project provides a way to cache the result of a (e.g. computation or IO-heavy) function to a location on the filesystem, ideally a [tmpfs](https://www.kernel.org/doc/html/latest/filesystems/tmpfs.html).

In comparison to Python’s integrated `functools.cache`, this approach provides caching outside of a programs lifetime. The (originally) intended use-case is caching results of long-running database queries during rapid-prototyping (& rapidly crashing) data analysis scripts.

Please refer to https://function-cacher.readthedocs.io for documentation, more examples, and further details.

Tested on Python 3.10 and upwards.

## Installation

Use `pip` to install this package:

`pip install functionCacher`

The package is located here: https://pypi.org/project/functionCacher/

## Basic Usage

```python
from functionCacher.Cacher import Cacher
cacher_instance = Cacher()

@cacher_instance.cache
def myfunc(*args):
	print(f"myfunc is getting called with {args}")
	return args

print(myfunc(1,2,3)) # cache miss; prints "myfunc is getting..."
print(myfunc(1,2,3)) # cache hit ; prints nothing
print(myfunc(2,3,4)) # cache miss; prints "myfunc is getting..."

print(f"Cache path is: {cacher_instance.cachePath}")
```

Output:

```commandline
% python3 basic_example.py
myfunc is getting called with (1, 2, 3)
(1, 2, 3)
(1, 2, 3)
myfunc is getting called with (2, 3, 4)
(2, 3, 4)
Cache path is: /path/to/cachedir
```

## Features

- cache function results to disk
- `pickle`s objects for storage
- cache compression (LZMA, ZSTD)
- HMAC-verification of cache file (do not forget to set a proper `hmac_key` during Cacher initialisation!)
- cache decorator
- automatic cache ID generation, based on
	- function parameter
	- function name
	- function source code

## Notes & Caveats

1) Caches are on the filesystem. For maximum performance, you might want to consider a RAM-backed FS like a ramdisk or [tmpfs](https://www.kernel.org/doc/html/latest/filesystems/tmpfs.html).

2) FunctionCacher assumes pure functions without side-effects. It can only discern two cache-entries via the function parameters!

3) Python `pickle` might mess with your cached function results. Works well in most cases, though.

## Related Projects

While this project has been developed largely in a vacuum (sorry! Didn't know better), several related projects approach result caching in Python in similar or identical ways:

- `cache_to_disk` by sarenehan (https://github.com/sarenehan/cache_to_disk)
- Shelved Cache by mhelf (https://pypi.org/project/shelved-cache)
- `asynccache` by hexhep (https://github.com/hephex/asyncache)

# Licence

MIT Licence
latent-experiments 0.0.7
A package for running and plotting latent experiments.
Requires Python: >=3.6

# latent_experiments

Python package for running experiments on latent spaces of neural networks

## Installation

```bash
pip install latent-experiments
```

## Usage

```python
import latent_experiments as le


# Run experiments on a simple dataset
outcome_diff_df = run_latent_experiments(
    data,
    columns_to_match=columns_to_match,
    outcome_var=outcome_var,
    match_threshold=0.8,
)
```
pytabs 0.2.1
A python wrapper for the CSi ETABS .NET API
Requires Python: >=3.10

<!-- PROJECT LOGO -->
<br />
<div align="center">
  <a href="https://github.com/mitchell-tesch/pytabs">
    <img src="docs/_static/logo.png" alt="PyTABS logo" width="80" height="80">
  </a>

  <h3 align="center">PyTABS</h3>

  <p align="center">
    A python wrapper for CSi ETABS .NET API
    <br />
    <a href="https://mitchell-tesch.github.io/pytabs/pytabs.html"><strong>Explore the docs »</strong></a>
    <br />
    <br />
    <a href="https://github.com/mitchell-tesch/pytabs/issues">Report Bug</a>
    ·
    <a href="https://github.com/mitchell-tesch/pytabs/issues">Request Feature</a>
  </p>
</div>


## Description
A Python wrapper for CSi ETABS .NET API - a simple yet robust Python interface to the ETABS .NET API. Not affiliated with Computer and Structures Inc.


## Installation
*PyTABS* can be installed through the Python package manager:
```
$ pip install pytabs
```


## Requirements
 - Python 3.10+
 - pythonnet


## Usage
🗒️Documentation can be found at https://mitchell-tesch.github.io/pytabs/pytabs.html

_For examples, please refer to the [examples](./examples/)._


## Licence
Distributed under the MIT License. See [LICENSE](LICENSE) for more information.


## Contibutors
Contributors welcome.

IntelliSense of the ETABSv1 namespace (ETABSv1.dll) can be achieved via the included stub file. This stub file has been generated using [IronPython Stubs](https://github.com/gtalarico/ironpython-stubs) by [gtalarico](https://github.com/gtalarico).

To make use of this stub file in VS Code add the following to your settings.json:
```json
    "python.autoComplete.extraPaths": ["<path_to_stub_directory>"],
    "python.analysis.extraPaths": ["<path_to_stub_directory>"]
```
tubelearns 2.1.0
Python script for extracting, cleaning, and tokenizing YouTube video transcripts for Pre-Processing in machine learning.
Keywords: python,video,transcript,raw data,cleaning,machine learning,pre-processing



## TubeLearns: YouTube Video Transcript Extractor

TubeLearns is a Python script designed for extracting and cleaning YouTube video transcripts for preprocessing in machine learning. This versatile tool streamlines the process of acquiring high-quality text data from YouTube videos, making it ideal for various natural language processing tasks, sentiment analysis, speech recognition, and more.

## Features

- Extracts video transcripts from YouTube videos.
- Saves cleaned transcripts into separate text files.
- Supports individual video URLs, batch processing from a list of URLs, and entire playlists.
- Streamlines the dataset collection process for machine learning applications.
- New Feature: Tokenization and Punctuation Removal for text preprocessing and cleaning.

## Installation

You can install TubeLearns using pip:

```bash
pip install tubelearns
```

## Usage

### Playlist Grabbing

```python
from tubelearns import Acquisition

# Initialize the Acquisition class
model = Acquisition()

# Grab transcripts from a YouTube playlist
playlist_url = 'https://www.youtube.com/your_playlist_url'
model.PlaylistGrab(playlist_url, name="raw_data")
```

### Extract Video Links from Playlist

```python
# Extract video links from a YouTube playlist
playlist_url = 'https://www.youtube.com/your_playlist_url'
model.Play2Text(playlist_url)
```

### Tokenization and Cleaning

```python
from tubelearns.tokenizers import Tokenization, Cleaning

# Initialize the Tokenization class
tokenizer = Tokenization()
cleaner = Cleaning()

# Tokenize text data
text_data = "Your input text here."
tokenized_data = tokenizer.TokenizeRaw(text_data)
cleaned_data = tokenizer.PunctList(tokenized_data)
```

Refer to the [TubeLearns documentation](https://github.com/KabilPreethamK/tubelearns/blob/main/Documentation.md) for detailed usage instructions and examples.

## Contributing

If you'd like to contribute to TubeLearns or report issues, please check out the [GitHub repository](https://github.com/KabilPreethamK/tubelearns).

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.

## Acknowledgments

- [YouTube Transcript API](https://github.com/jdepoix/youtube-transcript-api)
- [PyTube](https://github.com/pytube/pytube)
- [spaCy](https://spacy.io/)
- [num2words](https://github.com/savoirfairelinux/num2words)

---


Enjoy using TubeLearns! If you have any questions or encounter issues, please don't hesitate to [get in touch](mailto:tubelearnsofficial@gmail.com).
simple-weather-api-by-ys 0.1.2
This is a simple Flask API that provides real-time weather information for a specified city. The API is integrated with the Weatherstack service to fetch accurate and up-to-date weather data.
Requires Python: >=3.8

```markdown
# Weather Information API

This is a simple Flask API that provides real-time weather information for a specified city. The API is integrated with the Weatherstack service to fetch accurate and up-to-date weather data.

## Getting Started

These instructions will help you set up and run the Weather Information API on your local machine.

### Prerequisites

- Python (version 3.6 or higher)
- Flask
- Requests library

Install the required dependencies using the following command:

```bash
pip install Flask requests
```

### API Key

To use this API, you need to obtain an API key from Weatherstack. Visit [Weatherstack](https://weatherstack.com/) to sign up and get your API key.

### Configuration

Open the `app.py` file and replace `'YOUR_API_KEY'` with your actual Weatherstack API key.

```python
# Weatherstack API key (replace 'YOUR_API_KEY' with your actual API key)
API_KEY = 'YOUR_API_KEY'
```

### Running the API

Run the Flask application using the following command:

```bash
python main.py
```

The API will be accessible at `http://127.0.0.1:5000/weather`.

## API Endpoints

### Get Weather Information

- **Endpoint:** `/weather`
- **Method:** `GET`
- **Parameters:**
    - `city` (required): The name of the city for which you want to get weather information.

Example Request:

```bash
curl http://127.0.0.1:5000/weather?city=London
```

Example Response:

```json
{
  "city": "London",
  "temperature": 15,
  "conditions": "Partly cloudy"
}
```

## Error Handling

- If the city parameter is not provided, the API will return a `400 Bad Request` error.

```json
{
  "error": "City parameter is required"
}
```

- If the specified city is not found, the API will return a `404 Not Found` error.

```json
{
  "error": "City not found"
}
```

## Acknowledgments

- Flask: [Flask Documentation](https://flask.palletsprojects.com/)
- Weatherstack: [Weatherstack API Documentation](https://weatherstack.com/documentation)

Feel free to customize this README based on your specific project structure and additional features.