semvec/pypi-packages huggingface dataset:
pyvoynich 0.1.0
A Python package for bi-directional translation and substitution
Requires Python: >=3.6

![pyvoynich logo](https://github.com/wjbmattingly/pyvoynich/blob/main/assets/pyvoynich-logo.png?raw=true)

A Python package for bi-directional translation and substitution, particularly useful for working with Voynich manuscript transcriptions.

## Overview

PyVoynich is a Python implementation of the `bitrans.c` tool, which performs bi-directional translation/substitution based on a set of rules. The package is designed to be easy to use and integrate into Python applications. All the original C code and .bit files were written by René Zandbergen. For access to the original data and codebase, please visit [René Zandbergen's site](https://www.voynich.nu/software/000_README.txt).

Key features:
- Bi-directional translation (forward and reverse)
- Support for complex rule sets with multiple characters
- Loading rules from files
- Saving rules to files
- Processing text files

## Installation

```bash
# Clone the repository
git clone https://github.com/wjbmattingly/pyvoynich.git
cd pyvoynich

# Install the package
pip install -e .
```

## Usage

### Basic Usage

```python
from pyvoynich.bitrans import Bitrans
from pyvoynich.data import STA_Eva_def, STA_Eva_Bint, Eva_Cuva, Curr_Eva_def

input_text = "tchor. ckhoiin. daiin. cphchar-"

bitrans1 = Bitrans(STA_Eva_def, direction=2)
output1 = bitrans1.translate(input_text)
print(f"Output: {output1}")


input_text_sta = "Q2K1A1C1.U1A3G1.B1A3G1.T1K1A3C1"
bitrans2 = Bitrans(STA_Eva_def, direction=1)
output2 = bitrans2.translate(input_text_sta)
print(f"Output: {output2}")
```

## Available Rule Sets

The package includes several predefined rule sets:

- `STA_Eva_def`: Standard EVA transliteration
- `STA_Eva_Bint`: EVA to Beinecke transliteration
- `Eva_Cuva`: EVA to Currier transliteration
- `STA_FSG_def`: FSG transliteration
- `STA_Curr_def`: Currier transliteration

## Acknowledgements

This package is a Python implementation of the `bitrans.c` tool, originally developed for transliteration of the Voynich manuscript.
appBanco 0.1.1
Simulador simples de banco em Python

﻿# appBanco

### Simulador simples de banco em python  (•◡•) /

este projeto é um sistema bancário básico com funcionalidades para criar usuários, abrir contas, realizar depósitos, saques e visualizar extratos.

★ foi feito para fins didáticos e prática de pacotes python. ★

## Instalação

```bash
pip install appBanco
```
➳ após instalar, rode 'appBanco' no terminal. 

## Author
K-Campassi

## License
[MIT](https://choosealicense.com/licenses/mit/)
computation-toolkit 1
Theory of Computation
Requires Python: >=3.6

# Computation Toolkit - practical assignment

## P1. NFA to DFA Converter

A Python implementation of the subset construction algorithm to convert a Non-Deterministic Finite Automaton (NFA) with Îµ-transitions to an equivalent Deterministic Finite Automaton (DFA).

### Algorithm
- Computes Îµ-closures for NFA states.
- Generates DFA states, transitions, and accept states.
- Handles Îµ-transitions during DFA state construction.


### Usage
#### Input Format
Define your NFA as follows:
- `nfa_states`: Set of NFA states (e.g., `{'q0', 'q1', 'q2'}`).
- `nfa_alphabet`: List of symbols including `'Îµ'` (e.g., `['a', 'b', 'Îµ']`).
- `nfa_transitions`: Dictionary where keys are tuples `(state, symbol)`, and values are sets of next states. (e.g., `{
        ('q0', 'Îµ'): {'q1'},
        ('q1', 'a'): {'q1', 'q2'},
        ('q1', 'b'): {'q1'},
        ('q2', 'a'): {'q2'},
    }`).
- `nfa_start`: The start state (e.g., `'q0'`).
- `nfa_accept`: Set of accept states (e.g., `{'q2'}`).

#### Function Call
```python
from computation_toolkit import nfa_to_dfa

dfa_states, dfa_alphabet, dfa_transitions, dfa_start, dfa_accept = nfa_to_dfa(
    nfa_states, nfa_alphabet, nfa_transitions, nfa_start, nfa_accept
)
```

## P2. Check CFG Ambiguity given a string
A program to determine if a given string has **more than one parse tree** under a provided context-free grammar (CFG), indicating ambiguity for that string. Uses an **shift-reduce bottom up parser** to handle common sources of ambiguity.


### Algorithm
- Detects ambiguity by checking for multiple valid parse trees.
- Uses **BFS-based shift-reduce parsing** to build the parse trees.


### Usage

Specify your CFG as a dictionary where:
- **Keys** are non-terminals (e.g., `"E"`).
- **Values** are lists of productions (e.g., `[["E", "+", "E"], ["a"]]`).

Example (ambiguous arithmetic grammar):
```python
from computation_toolkit import has_multiple_parses

grammar = {
    "E": [["E", "+", "E"], ["E", "*", "E"], ["a"]]
}
start_symbol = "E"
input_string = "a+a*a"
print(has_multiple_parses(grammar, start_symbol, input_string))
```

## P3. Turing Machine to add two uniary numbers

A Python implementation of a Turing Machine that computes the sum of two unary numbers separated by a `+` symbol.

### Algotithm
- Implements a 3-state Turing Machine (Start, MoveToEnd, EraseLast)
- Handles edge cases (empty numbers, missing separator)
- Includes error checking for invalid inputs
- Unit test coverage for all major cases

### Usage

```python
from computation_toolkit import tm_add

input_str = "111+11"
print(tm_add(input_str))
```

# Running the Tests
To run the tests, use the following command:
```bash
python -m unittest discover tests -v
```


## Author
- Ammar Khaled [GitHub](https://github.com/Ammar-Khaled) - [LinkedIn](https://www.linkedin.com/in/ammar-noor/)
cordhook 1.0
A simple Discord webhook wrapper for Python
Requires Python: >=3.7

# Cordhook

Cordhook is a clean, lightweight Python wrapper around the Discord Webhook API.  
It provides a developer-friendly way to send rich messages, embeds, and file attachments with built-in validation, retry logic, and error handling.

---

[PyPi Project Page](https://pypi.org/project/cordhook/)

## Features

- Simple interface for sending messages and embeds  
- Full support for Discord embed customization  
- File attachment support  
- Auto retry logic with exponential backoff  
- Custom exception handling for common issues  
- Utility functions for formatting, truncating, and validating payloads  

---

## Quick Start
```bash
pip install cordhook
```
```py
from cordhook import Webhook

wh = Webhook("https://discord.com/api/webhooks/...")
wh.set_content("Hello, world!")\\
  .add_embed("Embed Title", "This is a test")\\
  .send()
```
---

## Embed Creation

You can use the create_embed() helper for more control:
```py
from cordhook import create_embed

embed = create_embed(
    title="Sample Embed",
    description="Generated with Cordhook",
    footer_text="Sent via Python",
    timestamp=True
)
```
---

## Utilities

- retry_request(func, retries=3) – retries any function with optional backoff  
- validate_url(url) – checks if a webhook URL is valid  
- json_pretty_print(obj) – nicely formats any JSON or dict  
- truncate_text(text, limit=1024) – prevents hitting Discord text limits  

---

## Exceptions

Cordhook raises specific exceptions so you can catch and handle errors cleanly:

- WebhookException  
- InvalidPayloadException  
- RateLimitException  
- FileAttachmentException  

---

## Example with File
```py
Webhook("url")  
    .set_content("With a file!")  
    .attach_file("cat.png")  
    .send()
```
---

## License

MIT License — free to use, modify, and distribute  

---

## Feedback or Contributions

Open an issue or PR to suggest improvements or fix bugs.