semvec/pypi-packages huggingface dataset:
Cryptonour 1.0.0
A library for various cryptography algorithms (Caesar, Hill Cipher.)
Requires Python: >=3.6

# Cryptography Library
![Python](https://img.shields.io/badge/Python-3.6%2B-blue)
![License](https://img.shields.io/badge/License-MIT-green)
![Version](https://img.shields.io/badge/Version-1.0.0-orange)

A Python library for implementing and working with various classical encryption algorithms. This library provides a collection of ciphers that you can use to encrypt and decrypt data in educational or practical cryptography-related projects.

---

## Features
This library includes the following classical ciphers:
- **Caesar Cipher**: A substitution cipher that shifts letters by a fixed number.
- **Monoalphabetic Cipher**: A substitution cipher where each character is replaced by another character using a key.
- **Vigenere Cipher**: A polyalphabetic substitution cipher that uses a keyword to encrypt data.
- **Vernam Cipher**: A stream cipher that uses a key of the same length as the plaintext for encryption.
- **Playfair Cipher**: A digraph substitution cipher that encrypts pairs of letters.
- **Hill Cipher**: A cipher based on linear algebra that uses matrix multiplication for encryption.

---

## Installation
You can install this library using `pip`:

```bash
pip install CryptoClasec
```
## Usage
Here’s how to use the library in your Python project:

### Import the Cipher Classes
```bash
from CryptoClasec import Caesar, Monoalphabetic, Vigenere, Vernam, Playfair, HillCipher
```
### Example: Caesar Cipher
```python
# Initialize the Caesar cipher with a shift value of 3
caesar = Caesar(3)

# Encrypt a plaintext
encrypted = caesar.encrypt("HELLO")
print("Encrypted text:", encrypted)

# Decrypt the ciphertext
decrypted = caesar.decrypt(encrypted)
print("Decrypted text:", decrypted)
```
### Example: Vigenere Cipher
```python
# Initialize the Vigenere cipher with a keyword
vigenere = Vigenere("KEY")

# Encrypt a plaintext
encrypted = vigenere.encrypt("HELLO")
print("Encrypted text:", encrypted)

# Decrypt the ciphertext
decrypted = vigenere.decrypt(encrypted)
print("Decrypted text:", decrypted)
```
## Available Classes
1- Caesar:
```python
caesar = Caesar(3)
caesar.encrypt(plaintext)
caesar.decrypt(ciphertext)
```
2- Monoalphabetic:
```python
mono = Monoalphabetic("QWERTYUIOPLKJHGFDSAZXCVBNM")
mono.encrypt(plaintext)
mono.decrypt(ciphertext)

```
2- Vigenere:
```python
vigenere = Vigenere("KEY")
vigenere.encrypt(plaintext)
vigenere.decrypt(ciphertext)
```
4- Vernam:
```python
vernam = Vernam("RANDOMKEY")
vernam.encrypt(plaintext)
vernam.decrypt(ciphertext)
```
5- Playfair:
```python
playfair = Playfair("KEYWORD")
playfair.encrypt(plaintext)
playfair.decrypt(ciphertext)
```
6- HillCipher:
```python
hill = HillCipher([[2, 3], [1, 4]])
hill.encrypt(plaintext)
hill.decrypt(ciphertext)
```
## License
This library is licensed under the MIT License. See the [LICENSE](LICENSE) file for more information.
## Contributing
Contributions are welcome! Feel free to submit issues or pull requests to improve the library.
## Author
Created by Ibrahem abo kila. For any inquiries, please contact me at ibrahemabokila@gmail.com.
DifferentialAlgebra 5.3
The Differential Algebra package
Requires Python: >=3.8

# DifferentialAlgebra Package

The DifferentialAlgebra package implements symbolic computation methods
related to Ritt and Kolchin Differential Algebra.

- Joseph Fels Ritt, Differential Algebra, volume 33 of AMS Colloquium 
    Publications, New York, 1950

- Ellis Robert Kolchin, Differential Algebra and Algebraic Groups, 
    Academic Press, 1973

It mostly provides an implementation of a differential elimination algorithm
which is a general simplification method for systems of polynomial differential
equations (ordinary or with partial derivatives).

# Notes

The actual source code is hosted at 

    https://codeberg.org/francois.boulier/DifferentialAlgebra

The source distribution contains the C code of the BLAD and BMI libraries
as well as the file DifferentialAlgebra.c generated by Cython over 

    bmi/sympy/DifferentialAlgebra.pyx

# Dependencies

The package involves an embedded version of mini-gmp.
It depends on the Python sympy package.
realstarexx 1.0.2
Coding and programming isn't same
Requires Python: >=3.6

# Starexx
It provides a structured way to build Python programs through object composition rather than writing code directly.

## Installation
**Step 1**: `pip install starexx`<br>
**Step 2**: Implement in your code
```python
from starexx import *
```

## Basic Usage
**Simple Calculator Example**
```python
from starexx import *

program = src(
    var("a", 10),
    var("b", 5),
    
    p("a =", get("a")),
    p("b =", get("b")),
    p("a + b =", add(get("a"), get("b"))),
    p("a - b =", subtract(get("a"), get("b"))),
    p("a * b =", multiply(get("a"), get("b"))),
    p("a / b =", divide(get("a"), get("b")))
)

program.run()
```

**Output**:
```sh
a = 10
b = 5
a + b = 15
a - b = 5
a * b = 50
a / b = 2.0
```


**Variables and Conditions**
```python
from starexx import *

program = src(
    var("name", "Alice"),
    var("age", 25),
    
    p("Name:", get("name")),
    p("Age:", get("age")),
    
    if_(
        gt(get("age"), 18),
        p(get("name"), "is an adult"),
        else_=p(get("name"), "is a minor")
    )
)

program.run()
```

**Output:**
```sh
Name: Alice
Age: 25
Alice is an adult
```

## Core Components

**Basic Structure**:<br>
· `src(*nodes)` - Main program container<br>
· `var(name, value)` - Variable declaration<br>
· `p(*values)` - Print statement<br>
· `get(name)` - Variable reference<br>

**Control Flow**:<br>
· `if_(condition, then_branch, else_branch)` - If statement<br>
· `for_(item, iterable, body)` - For loop<br>
· `while_(condition, body)` - While loop<br>

**Functions**:<br>
· `function(name, params, *body)` - Function definition<br>
· `call(name, args)` - Function call<br>
· `return_(value)` - Return statement<br>

**Data Structures**:<br>
· `list_(*items)` - List literal<br>
· `dict_(**items)` - Dictionary literal<br>

**Operations**:<br>
· `add(a, b)`, `subtract(a, b)`, `multiply(a, b)`, `divide(a, b)`<br>
· `eq(a, b)`, `neq(a, b)`, `gt(a, b)`, `lt(a, b)`<br>
· `and_(a, b)`, `or_(a, b)`, `not_(a)`<br>

## Advanced Examples

**Function with Loop**
```python
from starexx import *

program = src(
    function(
        "calculate_sum",
        ["numbers"],
        var("total", 0),
        for_("num", get("numbers"), src(
            set_("total", add(get("total"), get("num")))
        )),
        return_(get("total"))
    ),
    
    var("scores", list_(85, 92, 78, 96)),
    var("total_score", call("calculate_sum", [get("scores")])),
    p("Scores:", get("scores")),
    p("Total:", get("total_score"))
)

program.run()
```

**List Operations**
```python
from starexx import *

program = src(
    var("fruits", list_("apple", "banana", "orange")),
    p("Fruits:", get("fruits")),
    p("First fruit:", call("fruits.__getitem__", [0])),
    
    # Add a new fruit
    call("fruits.append", ["grape"]),
    p("Updated fruits:", get("fruits")),
    
    # List length
    p("Number of fruits:", len_(get("fruits")))
)

program.run()
```