semvec/pypi-packages huggingface dataset:
pypxl 0.2.4
Asynchronous API wrapper for the pxlapi https://pxlapi.dev
License: MIT

# pypxl
An asynchronous wrapper for [pxlapi](https://pxlapi.dev)

# Install it
Just use `pip3 install pypxl` to install it

# How to use it
```py
from pypxl import PxlClient
#Define yout details here
pxl = PxlClient(token="Your pxlapi token", stop_on_error=False)
```

Now you can use a all pxlapi features with just one line of code!
```py
glitch = await pxl.glitch(images=["https://cdn.discordapp.com/avatars/606162661184372736/a_62245605493deac02c291fe8fa517bee.gif?size=512"])
```

# Docs
There is no website offering documentation, however if you hover over a function in your IDE it will give you some info about what it does, you can also just read the source code. For an example in a discord bot, please click [here](https://github.com/Kile/pypxl/blob/main/examples/glitch_discord.markdown)

I have implemented most functions this library offers in commands in my bot. You can find those commands [here](https://github.com/Kile/Killua/blob/main/killua/cogs/image_manipulation.py)

For questions and suggestions, join my discord server or dm me (`Kile#0606`)

 <a> [![Discord Server](https://img.shields.io/discord/691713541262147687.svg?label=Discord&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2&style=flat)](https://discord.gg/zXqDHkm)
</a>
jamcalci 0.0.2
A basic calculator
License: MIT
Requires Python: >=3.6
Keywords: calculator

Description
The Jamcalci library is a powerful Python toolkit offering over 100 custom mathematical operations 
tailored for a wide range of computational and analytical needs. This comprehensive library is designed
to simplify complex mathematical tasks and provide seamless functionality for developers, researchers, and data scientists.

Key Features
Basic Arithmetic Operations
Perform fundamental calculations effortlessly, including addition, subtraction, multiplication, division, modulus, exponentiation, and more.

Geometric Calculations
Compute areas, perimeters, and volumes for various geometric shapes, enabling quick solutions to spatial problems.

Logical and Bitwise Operations
Execute logical operations like AND, OR, XOR, and bitwise shift operations for efficient low-level computations.

Statistical Functions
Access essential statistical tools, such as mean, median, mode, standard deviation, and other summary statistics, to analyze data effectively.

Number Property Functions
Determine prime numbers, check even/odd properties, count digits, and explore other number properties effortlessly.

Custom Implementations
Perform operations like square roots, cube roots, and factorials using efficient, built-in algorithms without relying on external libraries.

Whatâ€™s New in Version 2.0
Enhanced performance and optimizations for key operations.
New statistical functions for advanced data analysis.
Additional geometric and logical utilities for diverse applications.
Bug fixes and improved user experience.

setup(
    name='jamcalci',
    version='0.0.2',  # Increment this version
    ...
)
wikiluv 0.2.0
Wikipedia at your fingertips
License: MIT
Requires Python: <4.0,>=3.10

# Wikiluv

Wikipedia at your fingertips.

## Installation
```bash
pip install wikiluv
```
## Usage
```bash
wikiluv rose
```

# Demo
![demo](https://github.com/walidsa3d/wikiluv/blob/master/wikiluv.gif)
regionmask 0.13.0
create masks of geospatial regions for arbitrary grids
License: MIT
Requires Python: >=3.10

![regionmask logo](docs/source/logo/logo.png)

# create *masks* of geospatial *regions* for arbitrary grids

[![CI Status](https://github.com/regionmask/regionmask/workflows/CI/badge.svg?branch=main)](https://github.com/regionmask/regionmask/actions?query=workflow%3ACI)
[![Code Coverage Badge](https://codecov.io/gh/regionmask/regionmask/branch/main/graph/badge.svg)](https://codecov.io/gh/regionmask/regionmask)
[![Documentation Status](https://readthedocs.org/projects/regionmask/badge/?version=stable)](https://regionmask.readthedocs.io/en/stable/?badge=stable)
[![PyPi Badge](https://img.shields.io/pypi/v/regionmask.svg)](https://pypi.python.org/pypi/regionmask/)
[![Anaconda-Server Badge](https://anaconda.org/conda-forge/regionmask/badges/version.svg)](https://anaconda.org/conda-forge/regionmask)
[![zenodo DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10849860.svg)](https://doi.org/10.5281/zenodo.10849860)


When working with gridded data such as climate model output or reanalysis data it is
often important to create regional averages, e.g., over countries, continents or
regions defined in the literature. To do so we need to know for each grid point to which
region it belongs to.

**regionmask** is a python package that:

- can be used to create *masks* of (geo)spatial *regions* for arbitrary (longitude and latitude) grids. These masks indicate which region a gridpoint belongs to and can then be used to aggregate gridded data over the regions. The masks come in three variants:
  - 2D integer masks
  - 3D boolean masks
  - 3D approximate fractional masks
- takes great care to create consistent masks for
  - region edges and interiors
  - overlapping regions
- contains a number of defined regions, including:
  - countries
  - landmasks
  - regions used in the scientific literature
- can plot figures of these regions
- supports using arbitrary existing or user-defined region definitions:
  - regions defined as shapefiles can be accessed via geopandas
  - user-defined regions can be created via numpy or shapely

## Documentation

Learn more about regionmask in its official documentation at https://regionmask.readthedocs.io

## Get in touch

Dont hesitate to ask usage questions, report bugs, suggest features or view the source
code on GitHub under [regionmask/regionmask](https://github.com/regionmask/regionmask).

## License

regionmask is published under a MIT license.
tool-use-ai 1.1.11
Tools to simplify life with AI
License: MIT
Requires Python: <4.0,>=3.11

# tool-use

Tools to simplify life with AI. Brought to you by [Tool Use](https://www.youtube.com/@ToolUseAI).
You can install the package via [PyPI](https://pypi.org/project/tool-use-ai/).

## Installation

```bash
pip install tool-use-ai
```

## Command Structure

This toolkit provides two main command interfaces:

- `ai`: General-purpose AI tools for everyday tasks
- `tooluse`: Specific tools for podcast and community interaction

## AI Tools (`ai` command)

### 1. Command Generation (`ai do`)

Generate and execute terminal commands from natural language.

```bash
ai do <your optional command description>
```

### 2. Calendar Manager (`ai cal`)

Manage Google Calendar events.

```bash
ai cal
```

### 3. File Converter (`ai convert`)

Convert between file formats using Open Interpreter.

```bash
ai convert "/path/to/file.txt to pdf"
```

### 4. Obsidian Plugin Generator (`ai make-obsidian-plugin`)

Create custom Obsidian plugins with AI assistance.

```bash
ai make-obsidian-plugin "Plugin Name"
```

### 5. Activity Tracker (`ai log`)

Track and analyze daily activities.

```bash
ai log <activity>          # Start tracking an activity
ai log                     # Stop current activity or start new one
ai log tell <query>       # Query your activity history
ai log category <command> # Manage activity categories
```

Examples:

```bash
ai log working on python project
ai log tell me how long I coded today
ai log tell me what I did yesterday
ai log category list
```

### 6. Task Prioritizer (`ai prioritize`)

Voice-based task organization tool that:

- Organizes tasks by priority level
- Provides empathetic analysis
- Suggests concrete next steps

**Note:** You input your tasks using voice commands for a hands-free experience after running the script

```bash
ai prioritize
```

### 7. Marketing Plan Generator (`ai marketing-plan`)

Use a swarm of AI agents to generate a marketing plan for your business.

```bash
ai marketing-plan
```

### 8. Posture Coach (`ai posture`)

Use the webcam and a tiny vision model to analyze your posture and focus.

```bash
ai posture
```

### 9. Promptathon (`ai promptathon`)

Create a virtual prompt hackathon with AI judges and mentors.

```bash
ai promptathon
```

## Tool Use Tools (`tooluse` command)

### 1. Podcast RSS Reader (`tooluse`)

Fetch and interact with podcast episodes from RSS feeds.

```bash
tooluse
```

### 2. Contact Form (`tooluse contact`)

Submit feedback, requests, or general messages.

```bash
tooluse contact
```
poetry-aws-sam 1.4.3
Poetry plugin to work with AWS's SAM serverless tool
License: MIT
Requires Python: <4.0,>=3.10

# Description

CLI tool to run the `sam build` on a poetry-based project.

AWS's SAM made use of a `requirements.txt` file for third party
dependency management.  This method is limiting in comparison
to other tools such as Poetry that manage sub-dependencies'
versions through a lock file.  This poetry plugin deploys
a serverless app through SAM with dependencies being managed
through Poetry.

Created by Pinnacle Solutions Group, `www.pinnsg.com`.

## Set up

This plugin is dependent on having `aws-sam-cli` locally.
AWS has a doc page an `aws-sam-cli` with the installation
instructions at this url:
[aws-sam-cli installation](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html#install-sam-cli-instructions)

To install in the same environment as the poetry on your system:

```bash
pip install poetry
poetry self add poetry-aws-sam
```

This will add sam as a command in poetry. If you run `poetry list`, you will
see `sam` as an option amongst the commands.  You can then call
`poetry sam --help` for options in running `sam` in your poetry project.

The plugin replaces the `sam build` command.

Sam deployment steps

```bash
sam build
sam package
sam deploy
```

Deployment steps using poetry-aws-sam:

```bash
poetry sam --without-hashes
sam package
sam deploy
```

## History

The plugin was created while Pinnacle Solutions Group was working
with one of its clients on a projects built on aws serverless resources.
The client used SAM for its serverless management.
The company ended a vendor's contract,
which led to the team not having a repository for its package whl's.
The team shifted to using poetry and installing its packages from
a github url.  With the change to poetry, the team needed to update
how it interacted with SAM.  This plugin was created by Pinnacle Solutions
Group to meet that need.

## Working on poetry-aws-sam

Common Actions - justfile

There is a justfile for `just` commands.  It is like `make` with improvements.
You can read about installation and usage here: [just - github](https://github.com/casey/just#just)

- show all the commands by running only just: `just`
- set up git hooks through the pre-commit project: `just pre-commit-setup`
- run the unit tests: `just tests`

### Install locally to test iteratively

```bash
python -m venv .venv
source .venv/bin/activate
pip install -e .
just sam # same as: .venv/bin/poetry sam
```

This will set up a virtual env and have the sam ready as a plugin

## pypi deployment

The `master.yml` workflow will deploy to pypi.  This means that
the project version in `pyproject.toml` will need to be increased
when merging into the `master` branch.

A good dev flow:
- create new branch
- update version number of project
    - can use `poetry version minor` to increase the minor version
- with code update, create pull request to merge into `master`
- approve pull request and then merge into `master`
- the workflow will then deploy to pypi