semvec/pypi-packages huggingface dataset:
raw-wrapper 1.0.0
Wrap raw binary to class
Requires Python: <3.12,>=3.8

# raw-wrapper

A library for simple wrapping raw bytes to a class ✌️

## Install

```bash
pip install raw-wrapper
```

## Use
```python
from dataclasses import dataclass
from raw_wrapper import RawWrapper


@dataclass
class SampleClass(RawWrapper):
    """Sample class"""
    sample_4b_int: int = 0
    sample_string: str = b''.ljust(12)

    @staticmethod
    def get_format():
        return '>i12s'

    @staticmethod
    def expected_size():
        return 16


data = b'\x00\x00\x00\x01Hello world!'

sample_class = SampleClass.wrap(data)

assert sample_class.sample_4b_int == 1
assert sample_class.sample_string == b'Hello world!'
```

## Dev

More about format see https://docs.python.org/3/library/struct.html#format-characters
git-squared 0.1a1
Add your description here
Requires Python: >=3.9

# git-squared (`gg`)

A CLI for stacked git workflows

The program is called `gg` and has the following commands:

```
% gg 
usage: gg [-h] command ...

positional arguments:
  command
    ls        List all branches and current status
    rm        Remove (delete) this branch or a named branch
    go        Go to a branch if it exists. Otherwise, create a new branch tracking the current branch.
    co        Alias for `go` (`co` is short for `checkout`)
    restack   Restack this branch and all children onto its tracking branch
    r         Alias for `restack`
    status    Show git status (alias for `git status`)
    add       Add files to the staging area (alias for `git add`)
    commit    Commit the staged changes (using amend, ie one commit per branch)
    c         Alias for `commit`
    down      Move down the tree from the current branch; ie, move to the parent branch
    up        Move up the tree from the current branch; ie, move to the child branch
    s         Submit this branch to the remote (`s` stands for `submit`)
    ss        Submit this branch and its children to the remote (`ss`stands for `submit stack`!)


optional arguments:
  -h, --help  show this help message and exit
```

## commands

### `gg ls` shows the stack

```
% gg ls

◯ c
◯ b
│ ◯ d
◯─┘ a
│ ◯ aaaa
│ ◯ aaa
│ ◯ aa
│ │ ◯ t1
│ │ │ ◯ t2
│ │ │ │ ◯ t3
│ │ ◯─┴─┘ test
└─┴─┴─● main

```

### `gg go` moves around the stack (or creates new branches in the stack)

```
% gg go aa

🏁 Checked out aa
...
│ ◯ d
◯─┘ a
│ ◯ aaaa
│ ◯ aaa
│ ● aa
...
└─┴─┴─◯ main


```

### `gg up`/`gg down` move up and down the stack

```
% gg up

🏁 Checked out aaa
...
│ ◯ d
◯─┘ a
│ ◯ aaaa
│ ● aaa
│ ◯ aa
...
└─┴─┴─◯ main

```
```
% gg down

🏁 Checked out aa
...
│ ◯ d
◯─┘ a
│ ◯ aaaa
│ ◯ aaa
│ ● aa
...
└─┴─┴─◯ main

```
VortexWEB 0.1.1
A simple HTTP API framework for building RESTful APIs
Requires Python: >=3.7

Vortex

Р­С‚Рѕ РїСЂРѕСЃС‚РѕР№ С„СЂРµР№РјРІРѕСЂРє РЅР° Python РґР»СЏ СЃРѕР·РґР°РЅРёСЏ HTTP-СЃРµСЂРІРµСЂРѕРІ Рё RESTful API. РћРЅ РїРѕРґРґРµСЂР¶РёРІР°РµС‚ РѕСЃРЅРѕРІРЅС‹Рµ HTTP РјРµС‚РѕРґС‹ (GET, POST, PUT, DELETE, PATCH), РѕР±СЂР°Р±РѕС‚РєСѓ РѕС€РёР±РѕРє, СЂРµРЅРґРµСЂРёРЅРі С€Р°Р±Р»РѕРЅРѕРІ, Р° С‚Р°РєР¶Рµ РїРѕРґРґРµСЂР¶РєСѓ CORS-Р·Р°РіРѕР»РѕРІРєРѕРІ. РћСЃРѕР±РµРЅРЅРѕСЃС‚Рё

РџРѕРґРґРµСЂР¶РєР° HTTP РјРµС‚РѕРґРѕРІ: GET, POST, PUT, DELETE, PATCH.
РћР±СЂР°Р±РѕС‚РєР° РѕС€РёР±РѕРє СЃ РЅР°СЃС‚СЂР°РёРІР°РµРјС‹РјРё СЃРѕРѕР±С‰РµРЅРёСЏРјРё (400, 404, 422, 500).
РџРѕРґРґРµСЂР¶РєР° CORS РґР»СЏ РєСЂРѕСЃСЃ-РґРѕРјРµРЅРЅС‹С… Р·Р°РїСЂРѕСЃРѕРІ.
Р РµРЅРґРµСЂРёРЅРі С€Р°Р±Р»РѕРЅРѕРІ СЃ РїРѕРґРґРµСЂР¶РєРѕР№ Jinja-РїРѕРґРѕР±РЅС‹С… С€Р°Р±Р»РѕРЅРѕРІ.
Р”РёРЅР°РјРёС‡РµСЃРєР°СЏ СЂРµРіРёСЃС‚СЂР°С†РёСЏ СЌРЅРґРїРѕРёРЅС‚РѕРІ.
РћС‚РІРµС‚С‹ РІ С„РѕСЂРјР°С‚Рµ JSON РґР»СЏ СѓРґРѕР±РЅРѕР№ РёРЅС‚РµРіСЂР°С†РёРё СЃ API.
vatsal 1.2.0
Custom utility functions to reuse efficiently.
Requires Python: >=3.10

# Utility Functions Repository

## Overview

* A collection of optimized reusable utility functions for various tasks.
* View author details [at the bottom.](#authors)


## Installation

To install the utility functions, run:

```bash
pip install git+https://github.com/vatsal1306/vatsal.git
```

or, you can directly install from pip.

```bash
pip install vatsal
```

## Usage

### Path operations
Import `utils.Path` class and use its methods for file operations.

```python
from vatsal.utils import Path

# Validates path. If valid path, returns path in string, else returns FileNotFoundError.
obj = Path('/valid/path')
print(obj)

# Read file content. Optional mode and encoding params.
content = Path.read('/valid/path')

# Write to file. Optional mode and encoding params.
Path.write('/valid/path', "Hello world!")

# Append to file
Path.append('/valid/path', "Append text.")

# Get a list of all custom methods for Path .
obj.__dir__()
```

### Wrappers
Use `Wrappers` class for using decorators.
```python
from vatsal.utils import Wrappers


# Make any class method as a private method. Use private_method this as decorator, then that method can only be called internally by class. It cannot be used outside the class or by class object.
class DemoClass:
	@Wrappers.private_method
	def func(self):
		print("This is a private method.")
		

# Make any class as a singleton class. Singleton class is only initialized once. Wrapping @singleton on a class will make sure the class __init__ is only called once. On initialzing the class again, it will return the previously initialized object.
@Wrappers.singleton
class DemoClass:
	def __init__(self):
		print("Inside init method.")

obj1 = DemoClass()  # This will print 'Inside init method.'
obj2 = DemoClass()  # This will not print anything because DemoClass is already initialized once.
```

### Config
Use `Config` class to read .ini file. It will read all the sections and return a variable with .ini data in key-value pairs (dictionary).
```python
from vatsal.utils import Config

config = Config('/path/to/config.ini')
print(config['key'])	# prints value for key.
```

### Progress tracking

Use the `ProgressPercentage` class for real time file upload data in bytes.

```python
from vatsal.utils import ProgressPercentage
import boto3

# Initialize a ProgressPercentage object
progress = ProgressPercentage('file.txt')

# Upload file to S3 with progress tracking
s3 = boto3.client('s3')
s3.upload_file('file.txt', 'bucket-name', 'object-name', Callback=progress)
```

## Contributing

Contributions are welcome. To contribute:
1. Fork the repository.
2. Create a new branch.
3. Make changes and commit.
4. Submit a pull request.

## Authors

*   [Vatsal Vadodaria](https://pypi.org/user/vatsal1399/)
	+ [Github](https://github.com/vatsal1306)
	+ [LinkedIn](https://www.linkedin.com/in/vatsalvadodaria/)
mykad-generator 0.1.3
Random Mykads for testing purposes. Returns list of mykad
Requires Python: >=3.8

# MyKad Generator

A Python package to generate random Malaysian identity numbers (MyKad).

## Installation

You can install the package using Poetry:

```bash
pip install mykad_generator
```

## Usage
```bash

from mykad_generator import generate_mykad

mykad_numbers = generate_mykad(num_records=5)

print(mykad_numbers)


```
fasthog 0.1.7
Reasonably fast implementation of HOG descriptor calculation

# FastHOG
Reasonably fast implementation of Histogram of Oriented Gradients. Designed to be roughly equivalent to
`skimage.feature.hog`. While slightly less flexible (it only supports `float64` single-channel images),
it is _significantly_ faster, so ideal in workloads where `HOG` calculation is a bottleneck, as was in
the https://github.com/flatironinstitute/ManifoldEM project that inspired this repository.


## Installation

```bash
pip install fasthog
```

## Usage
Example taken from https://scikit-image.org/docs/stable/auto_examples/features_detection/plot_hog.html

```python3
from fasthog import hog
from skimage import data
from skimage.color import rgb2gray

image = rgb2gray(data.astronaut())

fd, hog_image = hog(
    image,
    n_bins=8,
    pixels_per_cell=(16, 16),
    cells_per_block=(1, 1),
)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4), sharex=True, sharey=True)

ax1.axis('off')
ax1.imshow(image, cmap=plt.cm.gray)
ax1.set_title('Input image')

# Rescale histogram for better display
hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 10))

ax2.axis('off')
ax2.imshow(hog_image_rescaled, cmap=plt.cm.gray)
ax2.set_title('Histogram of Oriented Gradients')
plt.show()


```