semvec/pypi-packages huggingface dataset:
ips.py 0.1.2
A Python library for handling IPS patches
Requires Python: >=3.6

# ips.py

A Python library for handling IPS patches.

I wanted to create this as there was no suitable library for how I wanted to manipulate IPS patches, which at the time was just changing the offsets in the records. Since then I have wanted to extend it for my own needs, and for the potential needs of others.

The logic for creating patches from two file objects is taken from [flips](https://github.com/Alcaro/Flips/), which creates very good, small patches.

### How to use

To import the library, do

```py
import ips
```

To get a `Patch` object from an IPS file, do

```py
with open("path/to/patch.ips", "rb") as f:
    p = ips.Patch.load(f)
```

If you already have the bytes of the IPS file, you can do

```py
with open("path/to/patch.ips", "rb") as f:
    cont = f.read()

...

p = ips.Patch.load(cont)
```

To apply a `Patch` object, do

```py
with open("path/to/original/file.bin", "rb") as old, open("path/to/new/file.bin", "wb") as new:
    p.apply(old, new)
```

If you don't want to necessarily write it to a new file, you can do

```py
import io

new = io.BytesIO()
with open("path/to/original/file.bin", "rb") as old:
    p.apply(old, new)
```

To create a `Patch` object from two file objects, do

```py
with open("path/to/original/file.bin", "rb") as old, open("path/to/new/file.bin", "rb") as new:
    p = ips.Patch.create(old, new)
```

To pack a `Patch` object into a `bytes` object, do

```py
bytes(p)
```

To add a record to a `Patch` object, use the `add_record` method.

To get a list of records in a `Patch` object, use the `records` attribute.

To get whether a `Patch` object is using the IPS32 format, which allows for offsets up to 4 GiB, check the `ips32` attribute.
dj-short 0.1.1
Simple CLI for shortcutting Django command
Requires Python: >=3.5

## Django CLI

Simple python CLI program for shortcutting Django command

## Usage

You can install this CLI with :
```sh
pip install dj-short
```

And after that, on your root Django project you can use this CLI by executing `dj` and add following commands like :

- `csu` for create a new superuser (based on `python manage.py createsuperuser`)
- `rsv` for run the django server (based on `python manage.py runserver`)
- `mm` for make a migrations for database (based on `python manage.py makemigrations`)
- `m` for migrate the database (based on `python manage.py migrate`)

## Why this package (even) exist?

Cause i'm lazy and little bit tired for too much typing in Django command. To be honest, i also don't really understand why django command management can't be shortened like in Ruby on Rails (the only way is to use a shortened django command is make a custom bash script or configuration in existing files such as `.ini` or `.toml`)

## Shortcomings

This CLI is temporarily unable to dynamically add new arguments to each existing command. Example: all arguments or option is limited and it's based on default parameter that provided by Django, just like when we're going to running django server specifically on a particular port, we cannot change the port number / addresses.
chanalyze 0.3.9
A simple WhatsApp Chat Analyzer ( for both Private & Group chats ), made with <3
Requires Python: >=3.7

# chanalyze

![banner](plots/wordCloudOfMessagesByAnjan.png)

A simple WhatsApp Chat Analyzer ( for both Private &amp; Group chats ), made with :heart:

**Now with concurrency support !!!**

## nomenclature

**Chat** _+_ **Analyze** _=_ **chanalyze**

## motivation

- I was interested in learning how much time I'm spending on WhatsApp _or_ in which conversation I'm more or less involved/ attached _or_ at which part of day I'm more involved in Chatting etc.
- So I'm writing these scripts for analyzing **WhatsApp** Chat _( both Private & Group )_, which can easily be exported into a _*.txt_ file from WhatsApp Mobile Application.
- That _*.txt_ is parsed, cleaned & objectified, so that it can be analyzed with ease.
- Using this tool, now I can understand each minute I spent on a certain Chat _( or may be how someone else spent )_ or how many times someone started a conversation _( which might be a good indicator of interest of participant(s) towards Chat )_
- For sake of **Privacy** test data file(s), which were used for plotting following chart(s), are kept private. Also Contact Name(s)/ Number(s) are partially grayed.

## usage

- Install `chanalyze` from PyPI

```bash
$ python3 -m pip install --user chanalyze
```
- Make sure you've added `$HOME/.local/bin` to your `$PATH` environment variable
- Export target Whatsapp chat into `*.txt` file, while omitting media.
- Now analyze your exported WhatsApp chat(s), using **chanalyze**

## chanalysis _( Chat Analysis )_

- [x] [Total Contribution of Chat Participants](docs/totalContribution.md)
- [x] [Hourly Contribution of Chat Participants](docs/hourlyContribution.md)
- [x] [Activity of Chat Participants on every Minute of Day](docs/contributionByMinute.md)
- [x] [Activeness of Chat](docs/chatActiveness.md)
- [x] [Conversation Initializing Chat Participant Identification _( using Mean & Median Delay )_ - Reflecting Participant's interest towards Chat](docs/conversationStartingPerson.md)
- [x] [Top Emojis used in Chat](docs/emojiStat.md)
- [x] [Chat Activity HeatMap](docs/heatmap.md)
- [x] [Word Cloud from Messages](docs/wordCloud.md)