semvec/pypi-packages huggingface dataset:
sachin-super-test 0.1.0
A Python SDK for the Superleap API
Requires Python: >=3.7

# Superleap SDK

A Python SDK for interacting with the Superleap API.

## Installation

```bash
pip install superleap-sdk
```

## Usage

```python
from superleap import SuperleapClient

# Initialize the client
client = SuperleapClient("YOUR_TOKEN_HERE")

# Fetch user data
response = client.poll()

# Access the data
print(f"Success: {response.success}")
for user in response.data:
    print(f"User: {user.name} ({user.email})")
```
safe-migrations 0.2.0
A Django package to safely generate and apply migrations from historical commits.
Requires Python: >=3.7

# Safe Migrations

A Django package to safely generate and apply migrations from historical commits.

## Installation

Install the package via pip:

```bash
pip install safe-migrations
```

add `safe_migrations` to `INSTALLED_APPS` in settings.py of your django project.

## Usage

```bash
python manage.py safe_migrations --hash GIT_COMMIT_HASH --git GIT_DIRECTORY
```

## Features

Automatically identifies model changes across commits.
Generates and applies all missing migrations safely.
fild-compare 0.0.4
Compare objects with rules
Requires Python: >=3.9

# fild-compare v 0.0.4

![Downloads](https://img.shields.io/pypi/dm/fild-compare.svg?style=flat)
![Python Versions](https://img.shields.io/pypi/pyversions/fild-compare.svg?style=flat)
![License](https://img.shields.io/pypi/l/fild-compare.svg?version=latest)
[![Build Status](https://github.com/elenakulgavaya/fild-compare/workflows/Tests/badge.svg)](https://github.com/elenakulgavaya/fild-compare/actions)
pyemon 0.2.2
Python auxiliary tools
Requires Python: >=3.13

# pyemon
Python auxiliary tools

## Concept
Make your python work easier

## What is possible
1. Initialization work required to create your own package
2. Installing the package
3. Testing the package
4. Building the package
5. Uploading the package
6. Execute your own defined tasks

## Reason for development
- I want to easily create my own packages

## Versions

|Version|Summary|
|:--|:--|
|0.2.2|Update json|
|0.2.1|Update pyemon|
|0.1.7|Update Path|
|0.1.6|Refactoring|
|0.1.4|Refactoring|
|0.1.3|Release pyemon|

## Installation
### [pyemon](https://pypi.org/project/pyemon/)
`pip install pyemon`

## CLI
### package.init
Initialization work required to create your own package

```
package.init
  [With value]
    -u|--user-name    {USERNAME}    # User name
    -e|--email        {EMAIL}       # Email
    -d|--description  {DESCRIPTION} # Description
    -p|--project-name               # Project name
```
`pyemon package.init -u USERNAME -e EMAIL -d DESCRIPTION`

### package.install
Installing the package

```
package.install # <pip(pipenv) install args>
  [No value]
    -p|--pip   # PIP
    -d|--dev   # Development
    -t|--test  # TestPYPI
```
`pyemon package.install`

### package.test
Testing the package

```
package.test # <pytest args>
```
`pyemon package.test`

### package.build
Building the package

```
package.build # <build args>
```
`pyemon package.build`

### package.upload
Uploading the package

```
package.upload # <twine upload args>
  [No value]
    -p|--pypi  # PYPI
```
`pyemon package.upload`

### task.run
Executing a task

```
task.run # <task name> <task args>
```
`pyemon task.run`

#### 1. Prepare pyetask.py file
**[pyetask.py]**
```python
from pyemon.task import *

class CamelizeTask(Task):
  def run(self, argv):
    for arg in argv:
      print(inflection.camelize(arg))
Task.set(CamelizeTask("<words>"))

class UnderscoreTask(Task):
  def run(self, argv):
    for arg in argv:
      print(inflection.underscore(arg))
Task.set(UnderscoreTask("<words>"))

class SingularizeTask(Task):
  def run(self, argv):
    for arg in argv:
      print(inflection.singularize(arg))
Task.set(SingularizeTask("<words>"))

class PluralizeTask(Task):
  def run(self, argv):
    for arg in argv:
      print(inflection.pluralize(arg))
Task.set(PluralizeTask("<words>"))
```

#### 2. Execute tasks with CLI execution

```
camelize # <words>
```
`pyemon task.run camelize device_type`
```
DeviceType
```

```
underscore # <words>
```
`pyemon task.run underscore DeviceType`
```
device_type
```

```
singularize # <words>
```
`pyemon task.run singularize posts`
```
post
```

```
pluralize # <words>
```
`pyemon task.run pluralize post`
```
posts
```
py0ltv 0.1.6
A transpiler for .py0 files to Python
Requires Python: >=3.6

# Py0 Transpiler

Py0 is a transpiler that converts .py0 files to Python and executes them.

# compile
pip install setuptools wheel twine
python setup.py sdist bdist_wheel

## Installation

```
pip install py0
```

## Usage

```
py0 <filename.py0>
```

This command will transpile all .py0 files in the directory of `filename.py0` to .py files, and then execute `filename.py`.

## License

This project is licensed under the MIT License - see the LICENSE file for details.
polimer 0.0.2
Automated callstack synthesis framework (annotations-based)
Requires Python: >=3.8

# polimer

**polimer** is an automated callstack synthesis framework (based on annotations)

## Basic idea

- Define annotations based on payload id (not just type id)
    - e.g. `l: 'price_list'` insead of `l: list`
- Automatically invoke argument initializers based on payload id
    - e.g. call `def get_price_list() -> 'price_list'`
- Simplify end-user code

## Quick-demo

1. Install **polimer**
```bash
pip install polimer
```

2. Annotate your methods with payload ids:

<h5 a><strong><code>prices.py</code></strong></h5>

```python
import random

def get_prices(length=10) -> 'price_list':
    return [random.random() for _ in range(length)]

def calc_avg_price(p: 'price_list'):
    return sum(p) / len(p)
```

3. Import your entrypoints via **polimer**
<h5 a><strong><code>demo.py</code></strong></h5>

```python
from prices import *
from polimer import prices

print(prices.calc_avg_price())
```