semvec/pypi-packages huggingface dataset:
gravitum 0.2.1
Library for implementing decompiled code.
Requires Python: >=3.6

# Gravitum

[![build](https://github.com/Sh4ww/gravitum/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/Sh4ww/gravitum/actions/workflows/tests.yml)
![PyPI](https://img.shields.io/pypi/v/gravitum)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/gravitum)
[![GitHub license](https://img.shields.io/github/license/Sh4ww/gravitum)](https://github.com/Sh4ww/gravitum/blob/main/LICENSE)

Gravitum is a library for implementing decompiled code with Python.

## Requirements

- Python 3.6+

## Installation

```
$ pip install gravitum
```

## Usage

Gravitum defines some interger types with fixed size. You can use shorthand functions (`int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`) to create them.

```python
from gravitum import uint8

v = uint8(0x53)
```

Pointer operations are common in the decompiled code.

```c
unsigned __int8 data[8] = {71, 114, 97, 118, 105, 116, 117, 109};

unsigned __int8 *p = data;
unsigned __int8 v = p[4];

*((unsigned __int32 *)p + 1) = v;
```

So Gravitum provides `vptr`.

```python
from gravitum import vptr

data = bytearray([71, 114, 97, 118, 105, 116, 117, 109])

p = vptr(data, 'uint8')
v = p.add(4).read()

p.cast('uint32').add(1).write(v)
```

In some cases, decompilers may use their built-in functions in the output. Gravitum implements some of them. You can look up from `gravitum.decompiler_builtins`.

```python
from gravitum import uint32
from gravitum.decompiler_builtins.ida import ror4

v = uint32(0x53683477)
v = ror4(v, 2)
```
domaingen 0.0.10
Generate domain name variations based on keywords and synonyms.
Keywords: python,whois,domain,domain name,domain name registration,domain names,domains,dns


# domaingen

Under construction! Not ready for use yet! Currently experimenting and planning!

Developed by Jeffery Mandrake from GoInfosystems.com (c) 2023

## Examples of How To Use (Alpha Version)

Create a domaingen object and input keywords

```python

from domaingen.domains import DomainGenerator as dg

keywords = ["recipes","cooking","dinner","easy"] # List of keywords
tlds = ['com','net'] # List of top level domain extensions (optional, default is com)

domaingen = DomainGenerator(keywords,tlds)
domains = domaingen.get_domains()
for domain in domains:
    print(domain)


>>>
cookingdinnereasy.net
recipesdinnereasy.com
recipescooking.com
recipesdinner.com
cookingdinner.net
recipesdinner.net
recipescookingeasy.net
cookingeasy.net
cookingeasy.com
recipesdinnereasy.net
recipescookingdinner.com
recipescookingeasy.com
cookingdinner.com
recipescooking.net
recipescookingdinner.net
recipeseasy.net
dinnereasy.com
cookingdinnereasy.com
dinnereasy.net
recipeseasy.com

```

## Thesaurus (English)
This is a json dataset of synonyms for english words.
Source:
https://www.kaggle.com/datasets/behcetsenturk/englishengen-synonyms-json-thesaurus
on-done 0.1.1
IPython/Jupyter cell magic to execute code after a cell succeeds or fails
Requires Python: >=3.6

<p align="center">
  <img alt="on-done" src="https://raw.githubusercontent.com/parsiad/on-done/master/logo.png">
</p>

An IPython/Jupyter cell magic to execute code after a cell succeeds or fails so you can receive an alert when your code terminates.

![](https://github.com/parsiad/on-done/blob/main/tty.gif?raw=true)

## Installation

```console
$ pip install on-done
```

## Example

Start by launching an IPython session:

```console
$ ipython
```

Then, load the extension:

```python
In [1]: %load_ext on_done
```

Next, define a function to alert you that your code has terminated.

```python
In [2]: def alert():
   ...:     from datetime import datetime
   ...:     print(f"Cell terminated at {str(datetime.now())}\n")
```

**You can change this function to send yourself an email, Slack alert, etc.**

Putting `%%on_done alert()` at the top of a cell will cause it to alert:

```python
In [3]: %%on_done alert()
   ...: import numpy as np
   ...: x = np.random.randn(10**8)
   ...: print(f"mean={x.mean()}")
mean=0.00021783589122321365
Cell terminated at 2022-11-21 00:35:40.678180
```

In particular, the alert will also occur if the cell failed:

```python
In [4]: %%on_done alert()
   ...: import numpy as np
   ...: x = np.random.randn(10**8)
   ...: print(f"mean={x.mean(axis=1)}")
Cell terminated at 2022-11-21 00:35:50.654766

---------------------------------------------------------------------------
AxisError                                 Traceback (most recent call last)
...
```

## Credit

on-done is inspired by [this Stack Overflow answer](https://stackoverflow.com/a/57365710) by [Colin Carroll](https://colindcarroll.com)