semvec/pypi-packages huggingface dataset:
hillcipher 0.0.4
Hill Cipher (Encryption and Decryption)
Keywords: python,cryptography,hill,hillcipher,encryption,decryption,symmetric encryption

# Hill Cipher

The project is about **Hill Cipher Encryption and Decryption**

It allows to encrypt the text using the Hill Cipher technique, and decryption can be done as well. Checkout the snippets below.

**Note** : Provide the input in the capital letters.

```python
import hillcipher as hc

key = [[17,17,5],[21,18,21],[2,2,19]]
text = "PAY MORE MONEY"

enc = hc.encrypt(text, key)
dec = hc.decrypt(enc, key)

print(enc, dec)
```

The $2^{nd}$ parameter (i.e., **key**) is optional and can be excluded, but ensure that the count of alphabets in the input string are the multiples of 3.

```python
import hillcipher as hc

text = "PAY MORE MONEY"

enc = hc.encrypt(text)
dec = hc.decrypt(enc)

print(enc, dec)
```

The complete code can be found @ www.github.com/Kirandeep2806/Hill-Cipher
dagwood 2.0.0
Swiss-army knife for Python scripts. Includes logging, HTTP status codes, and more.

# Dagwood 

[![PyPI version](https://badge.fury.io/py/dagwood.svg)](https://badge.fury.io/py/dagwood)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

<img src="dagwood.png" alt="Dagwood Bumstead" width="200"/>

<br/>

Dagwood is a Swiss Army knife for Python, a collection of small utilities that I find myself using over and over again. It's named after [Dagwood Bumstead](https://en.wikipedia.org/wiki/Dagwood_Bumstead), the sandwich-loving husband of [Blondie](https://en.wikipedia.org/wiki/Blondie_(comic_strip)) in the eponymous comic strip.

Why "Dagwood"? Because a.) I like sandwiches, and b.) the name was available on PyPI.

To install Dagwood, run:

```
pip install dagwood
```

## Available Utilities

### Logging

To quickly set up a logger:

```python
import dagwood
logger = dagwood.assemble()
```

This will create a logger with default settings: log level set to `INFO` and log messages formatted as `'%(asctime)s - %(levelname)s - %(message)s'`. Logs will be written to a folder named `logs`.

You can customize the log folder, log file name, log level, and log format by passing optional parameters to `assemble`.

- `folder_name`: The name of the folder to store log files (default: `'logs'`)
- `file_name`: The name of the log file (default: `None`, which generates a log file with a timestamp)
- `level`: The log level (default: `logging.INFO`)
- `format`: The log format (default: `'%(asctime)s - %(levelname)s - %(message)s'`)

```python
logger = dagwood.assemble(folder_name='my_logs', file_name='app.log', level=logging.DEBUG, format='%(levelname)s - %(message)s')
```

### HTTP Codes

An easy way to check the meaning of an HTTP status code:

```python
from dagwood import http_codes

# Example of interpreting an HTTP code
CODE = 500
response = http_codes.interpret(CODE)

print(response.message)  # 'Internal Server Error'
print(response.explanation)  # 'The server has encountered a situation it does not know how to handle.'

# Checking the type of the response
types = http_codes.get_enums()
if response.type == types.SERVER_ERROR:
    # Handle server error
    pass
```

You can also retrieve the different types of HTTP responses:
```python
types = http_codes.get_enums()
print(types)  # ['Informational', 'Success', 'Redirection', 'Client Error', 'Server Error']
```

## Contributing

Feel free to open an issue or submit a pull request.

To publish a new version to PyPI:
```bash
pip install twine # if you don't have it already
python setup.py sdist bdist_wheel # build the package
twine upload dist/* # upload to PyPI
```

## Development

### Running Tests

The test suite can be run using Python's built-in `unittest` framework.

Navigate to the `tests` directory and run:

```
python -m unittest test_dagwood.py
```

Or, if you're in the root directory:

```
python -m unittest tests/test_dagwood.py
```
rsrch 0.2.5
Manage your ever-growing list of research papers
Requires Python: >=3.7

# rsrch
Manage your research papers from Python. This project lets you update a Notion database with arXiv links and download PDFs of papers to your local machine.

<p align="center">
    <img width="1095" alt="image" src="https://user-images.githubusercontent.com/47067154/219932040-ab4962f8-b01e-4d94-9eba-77a155b0e933.png">
</p>

## Installation
1. Create an [internal integration](https://www.notion.so/help/create-integrations-with-the-notion-api) in Notion.

2. [Add the integration](https://www.notion.so/help/add-and-manage-connections-with-the-api#add-connections-to-pages) to the database you want to download from.

3. Store your `NOTION_TOKEN` and `NOTION_DATABASE_ID` somewhere safe. Your `NOTION_TOKEN` can be found in your [integrations page](https://www.notion.so/my-integrations) and is called the **Internal Integration Token**. The `NOTION_DATABASE_ID` can be found in the [URL of your database](https://www.notion.so/my-integrations) (`https://www.notion.so/{workspace_name}/{database_id}?v={view_id}`).

4. Install local dependencies:

    ```bash
    pip install rsrch
    ```

5. **Important**: Your Notion database must have the following columns with the corresponding types:
    - **Title**: `Title`
    - **URL**: `URL`
    - **Date**: `Date`
    - **Authors**: `Text`

    You can add more columns, but these are the ones that are required.

## Usage
### Setup
```python
from rsrch import RsrchClient

client = RsrchClient(
    token=NOTION_TOKEN,
    database_id=NOTION_DATABASE_ID,
)
```

### Download
This will download all the papers from your Notion database to the `papers/` directory.

```python
client.download()
```

<p>
    <img width="1097" alt="image" src="https://user-images.githubusercontent.com/47067154/232264456-4bdef487-36e8-4627-95c3-82f5c3876082.png">
</p>

### Upload
You can upload arXiv abstract links, PDF links, or IDs to your Notion database and have it autofill all of the relevant fields.

```python
client.upload(
    arxiv_urls=[
        "https://arxiv.org/abs/1706.03762",
        "https://arxiv.org/pdf/1706.03762.pdf",
        "1706.03762",
    ]
)
```

<p>
    <img width="1095" alt="image" src="https://user-images.githubusercontent.com/47067154/232264615-82b42d8c-ca1c-4f21-899f-439a6c8a7879.png">
</p>

Alternatively, you can add non-arXiv links manually to Notion.

## Notes
- Uploading papers to Notion is currently only supported for arXiv links. Papers with titles that already exist in the database will not be uploaded.
- I plan on adding support for other databases in the future, but for now it only works with Notion databases.
- To build and release this:
  - Make new code accessible in `src/__init__.py`
  - Update the version in `src/__about__.py`
  - Run `python3 -m build`
  - Run `python3 -m twine upload dist/*`

### Resources
- [Notion API](https://developers.notion.com/)
cashappchecker 0.0.1
A package that aims to help people handle CashApp web receipts
Requires Python: >=3.11

# CashappChecker - DOCUMENTATION


## How to use

### GETTING STARTED

Import the module

```
import cashapp_checker as check
```
Get the ID of your cashapp invoice URL

```
check.id("https://cash.app/payments/4xxx8z1q1cisxxxxxxxxxx/receipt?utm_source=activity-item")
```
*example response: 4xxx8z1q1cisxxxxxxxxxx*

Get the amount sent

```
amt = check.amount("YOUR_ID")
```
*example value of variable **amt**: $5.50*

Get the note for the transaction

```
note = check.note("YOUR_ID")
```
*example value of variable **note**: For babysitting ❤*

Get the receiver of the transaction

```
cashtag = check.cashtag("YOUR_ID")
```
*example value of variable **cashtag**: $wahrs (my cashtag, feel free to donate if the module helped you 😊)*

Get the sender of the transaction

```
coming in v2
```