semvec/pypi-packages huggingface dataset:
mathcalcusuit 0.1.0
A simple package for basic math operations including prime checking, Fibonacci, GCD, LCM, and factorials

# MathCalcUSuit

**MathCalcUSuit** is a Python package that provides a suite of basic math operations. It includes functions for:

- Checking if a number is prime
- Generating Fibonacci numbers
- Calculating factorials
- Finding the Greatest Common Divisor (GCD) of two numbers
- Finding the Least Common Multiple (LCM) of two numbers
- Checking if a number is a perfect number

## Installation

To install **MathCalcUSuit**, use `pip`:

```bash
pip install mathcalcusuit
```
## Usage

### Prime Checker
```bash
from mathcalcusuit import prime_check

prime_check(7)
```

### Fibonacci Generator
```bash
from mathcalcusuit import generate_fibonacci

generate_fibonacci(10)
```

### Factorial Calculator
```bash
from mathcalcusuit import factorial_calcu

factorial_calcu(5)
```

### GCD Calculator
```bash
from mathcalcusuit import gcd_calcu

gcd_calcu(48, 180)
```

### LCM Calculator
```bash
from mathcalcusuit import lcm_calcu

lcm_calcu(4, 5)
```
metatomic 0.1.0
Atomistic machine learning models you can use everywhere for everything
Keywords: machine learning, molecular modeling

<h1>
<p align="center">
    <img src="https://raw.githubusercontent.com/metatensor/metatomic/refs/heads/main/docs/static/images/metatomic-horizontal-dark.png" alt="Metatomic logo" width="600"/>
</p>
</h1>

<h4 align="center">

[![tests status](https://img.shields.io/github/checks-status/metatensor/metatomic/main)](https://github.com/metatensor/metatomic/actions?query=branch%3Amain)
[![documentation](https://img.shields.io/badge/documentation-latest-sucess)](https://docs.metatensor.org/metatomic/)
[![coverage](https://codecov.io/gh/metatensor/metatomic/branch/main/graph/badge.svg)](https://codecov.io/gh/metatensor/metatomic)
</h4>


``metatomic`` is a library that defines a common interface between atomistic
machine learning models, and atomistic simulation engines. Our main goal is to
define and train models once, and then be able to re-use them across many
different simulation engines (such as LAMMPS, GROMACS, *etc.*). We strive to
achieve this goal without imposing any structure on the model itself, and to
allow any model architecture to be used.


## Documentation

For details, tutorials, and examples, please have a look at our
[documentation](https://docs.metatensor.org/metatomic/).


## Contributors

Thanks goes to all people that make metatensor possible:

[![contributors list](https://contrib.rocks/image?repo=metatensor/metatomic)](https://github.com/metatensor/metatomic/graphs/contributors)

We always welcome new contributors. If you want to help us take a look at our
[contribution guidelines](CONTRIBUTING.rst) and afterwards you may start with an
open issue marked as [good first
issue](https://github.com/metatensor/metatomic/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).
pork 0.1.0
Add your description here
Requires Python: >=3.12

# Pack of random korrelations (pork)
Sample your own correlation matrices.

Randomly sampling correlation matrices is useful in various statistical applications, such as Monte Carlo simulations, where you need to generate random data that adheres to a specific correlation structure. However, there is still new research being done in this area, and the methods for generating these matrices can vary in complexity and computational efficiency. This reposity aims to provide methods for sampling correlation matrices that have varying sturctures and properties one might want.

## Installation

TODO

## Usage

TODO

# Available methods
1. TODO
2. TODO
cleanshot 1.2.0
A tool to automatically rename screenshots using OpenAI's OCR
Requires Python: >=3.8

# cleanshot 📸

[![PyPI version](https://badge.fury.io/py/cleanshot.svg)](https://badge.fury.io/py/cleanshot)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Cleanshot monitors your macOS Screenshots folder and automatically renames screenshots using OpenAI.

![Description](./.github/demo.gif)

## 🔧 Installation

```bash
pip install cleanshot
```

## 🎮 Usage

#### Start cleanshot

```bash
cleanshot
```

#### Stop cleanshot

```bash
cleanshot stop
```

#### View help docs

```bash
cleanshot --help
```

## ⚙️ Settings

### **Supported LLM Providers:**

- OpenAI

You can update your API keys and provider settings by running:

```bash
cleanshot --setup
```

### OpenAI

To use OpenAI, you need an OpenAI account and a subscription. You can create an API key on [this page](https://platform.openai.com/settings/organization/api-keys).

## 🤝 Contributing

Contributions are welcome! Feel free to open issues or submit pull requests.

## 📄 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
wkt 0.1.4
WKT generator
Requires Python: >=3.11

# wkt

wkt makes it easy to grab Well-Known Text strings for countries, states, and cities around the world.

Here's how you can grab the polygon for New York State for example:

```python
import wkt

wkt.us.states.new_york() # => "POLYGON((-79.7624 42.5142,-79.0672 42.7783..."
```

`wkt` is interoperable with many Pythonic geospatial tools like Shapely, GeoPandas, Sedona, and Dask!

You can also fetch WKTs from the Overture Maps Foundation tables as follows:

```python
table_name = "wherobots_open_data.overture_maps_foundation.divisions_division_area"
wkt.omf(sedona, table_name).state("US", "US-AZ") # => "POLYGON((..."
```

## Installation

Just run `pip install wkt`.

This library doesn't have any dependencies, so it's easy to install anywhere.

## Shapely + wkt

Let's create a Shapely polygon with `wkt`:

```python
import wkt
from shapely import from_wkt

alaska = from_wkt(wkt.us.states.alaska())
```

Check to make sure that a Shapely Polygon is created:

```python
type(alaska) # => shapely.geometry.polygon.Polygon
```

Compute the area of the polygon:

```python
alaska.area # => 353.4887780300002
```

## GeoPandas + wkt

Create a GeoPandas DataFrame with `wkt`:

```python
import geopandas as gpd
import pandas as pd

data = {
    "state": ["colorado", "new_mexico"],
    "geometry": [from_wkt(wkt.us.states.colorado()), from_wkt(wkt.us.states.new_mexico())]
}
df = pd.DataFrame(data)
gdf = gpd.GeoDataFrame(df, geometry="geometry")
```

Add a column with centroids:

```python
gdf['centroid'] = gdf.geometry.centroid
```

Look at the results:

```python
        state                     geometry                     centroid
0    colorado  POLYGON ((-109.0448 37.0004,  POINT (-105.54643 38.99855)
1  new_mexico  POLYGON ((-109.0448 36.9971,  POINT (-106.10366 34.42267)
```

## Sedona + wkt

Read the Overture Maps Foundation places dataset:

```python
places = sedona.table("wherobots_open_data.overture_maps_foundation.places_place")
places.createOrReplaceTempView("places")
```

Find all the barbecue restaurants in the state of Florida:

```python
query = f"""
select * from places
where
    categories.primary = 'barbecue_restaurant' and
    ST_Contains(ST_GeomFromWKT('{wkt.us.states.florida()}'), geometry)
"""
res = sedona.sql(query)
res.count() # => 1386
```

## WKTs from Overture data

It's easy to get the WKT for countries, states, and cities from the Overture data:

TODO

## Contributing

Feel free to submit a pull request with additional WKTs!

You can also create an issue to discuss ideas before writing any code.

You can also check issues with the "help wanted" tag for contribution ideas.

## Developing

You can run the test suite with `uv run pytest tests`.
cfsign 0.0.3
A simple library for creating CloudFront signatures
Requires Python: <4.0,>=3.8

# CFSign

A Python library for generating AWS CloudFront signed URLs and cookies. This library provides a simple interface for creating signed URLs and cookies for CloudFront private content.

## Installation

Using pip:

```bash
pip install cfsign
```

Using Poetry:

```bash
poetry add cfsign
```

## Usage

### Basic Configuration

```python
import cfsign

# Configure with your CloudFront key pair
cfsign.configure(
    key_pair_id="YOUR_KEY_PAIR_ID",
    private_key="YOUR_PRIVATE_KEY"
)
```

### Creating Signed URLs/Cookies

```python
from cfsign.signature.cloudfront_signature import CloudfrontSignature

# Create a signature for a specific resource
signature = CloudfrontSignature("https://example.cloudfront.net/private/content.mp4")

# Get signed cookies
cookies = signature.cookie_dict
print(cookies)
"""
Gets you something like:
{
    "CloudFront-Policy": {...},
    "CloudFront-Signature": {...},
    "CloudFront-Key-Pair-Id": {...},
}
"""


# Get query string parameters for signed URLs
query_string = signature.query_string
print(query_string)
# prints - Policy&={...}&Signature={...}&Key-Pair-Id={...}
```

### Example: Using with Requests

```python
import requests

# Using signed cookies
response = requests.get(url, cookies=signature.cookie_dict)

# Using signed URL
signed_url = f"{url}?{signature.query_string}"

# You could also use the built-in signed url if you're not using a wildcard for the resource:
signed_url = signature.signed_url

response = requests.get(signed_url)
```

## Features

- Generate CloudFront signed URLs
- Generate CloudFront signed cookies
- Support for custom policies
- RSA signing with PKCS1v15 padding and SHA1 hashing (AWS CloudFront standard)
- Base64 policy encoding/decoding

## Development

### Setting up Development Environment

1. Clone the repository
2. Install development dependencies:

```bash
uv sync
```

### Running Tests

```bash
# Set PYTHONPATH to project root
pytest
```

### VSCode Configuration

To run tests in VSCode, create a `.env` file in your project root:

```txt
PYTHONPATH=.
```
ProteinPlot 2.0.1
Library for managing .pdb extension, plotting
Requires Python: >=3.6

Welcome to ProteinPlot's documentation!
============================================

Welcome to the documentation for **ProteinPlot**, a University package for analysing PDB entries in python

Introduction
------------

ProteinPlot helps in the analysis of PDB entries. The given files from the databank of rcsb.org is loaded into pandas dataframes and in this way manipulations have become easier

Features
--------

- PDB entry reading into pandas df
- Structure alignment
- Structure comparison
- Ramachadran plots
- 2D and 3D figures

Installation
------------

Install via pip: pip install ProteinPlot

Quick Start
-----------

Here's a basic example:

  The package automatically installs an IDE, that can be opened with the following bash command:
  
  jupyter-lab
  
  Load in the package and your first **PDB** file
   
   from ProteinPlot import protplot
   example = protplot.read_pdb('6vxx')
   
You are ready to go. For further examples please visit the documentation!
ableton-set-builder 0.1.0
A package to build Ableton Live sets programmatically.
Requires Python: >=3.6

# AbletonSetBuilder - Build Ableton sets using Python
This package helps building Ableton Live sets.

To start with this package, initialize the class with an existing Ableton Live set, to be used as a template:
```python
from ableton_set_builder import AbletonSetBuilder, ColorsDir

builder = AbletonSetBuilder('path/to/template.als') # parses both compressed and uncompressed .als sets
```

The following functions are available:
```python
builder.create_audio_track("Track Name", "salmon")
builder.add_scene("101", "scene 101")

xml = builder.to_xml() # compile set to XML
builder.build_als('path/to/output') # compile set to compressed ALS
```
llm-hacker-news 0.1.1
LLM plugin for pulling content from Hacker News
Requires Python: >=3.9

# llm-hacker-news

[![PyPI](https://img.shields.io/pypi/v/llm-hacker-news.svg)](https://pypi.org/project/llm-hacker-news/)
[![Changelog](https://img.shields.io/github/v/release/simonw/llm-hacker-news?include_prereleases&label=changelog)](https://github.com/simonw/llm-hacker-news/releases)
[![Tests](https://github.com/simonw/llm-hacker-news/actions/workflows/test.yml/badge.svg)](https://github.com/simonw/llm-hacker-news/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/simonw/llm-hacker-news/blob/main/LICENSE)

LLM plugin for pulling content from Hacker News

For background on how this works:

- [Long context support in LLM 0.24 using fragments and template plugins](https://simonwillison.net/2025/Apr/7/long-context-llm/)
- [Blog post announcing llm-hacker-news](https://simonwillison.net/2025/Apr/8/llm-hacker-news/)

## Installation

Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
```bash
llm install llm-hacker-news
```
## Usage

You can feed a full conversation thread from [Hacker News](https://news.ycombinator.com/) into LLM using the `hn:` [fragment](https://llm.datasette.io/en/stable/fragments.html) with the ID of the conversation. For example:

```bash
llm -f hn:43615912 'summary with illustrative direct quotes'
```
Item IDs can be found in the URL of the conversation thread.

## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:
```bash
cd llm-hacker-news
python -m venv venv
source venv/bin/activate
```
Now install the dependencies and test dependencies:
```bash
pip install -e '.[test]'
```
To run the tests:
```bash
python -m pytest
```