semvec/pypi-packages huggingface dataset:
urca 1.0.0
Unified Resource for Cryptographic Arrays
Requires Python: >=3.12

# URCA

**U**nified **R**esource for **C**ryptographic **A**rrays

<img src="docs/source/_static/logo.svg" width="128" alt="Official logo">

The URCA project aims to give the vectorized implementations of many
cryptographic primitives in order to investigate the statistical properties.
Not only, since sometimes it could be useful to study a reduced version of the
primitives, the URCA project tries to give the generalised version of the
primitives. The project implements vectorised implementations both for CPUs and
GPUs, using respectvely [NumPy](https://numpy.org/) and
[CuPy](https://cupy.dev/).

## Pages

[Documentation](https://ale-depi.github.io/urca/)

[Guide for the user](https://ale-depi.github.io/urca/guide/user.html)

[Guide for the developer](https://ale-depi.github.io/urca/guide/developer.html)

## Examples

Multiple plaintext can be encrypted at once.

```python
>>> import numpy as np
>>> from urca.cpu.blocks.speck import Speck
>>> speck = Speck(32, 64)
>>> word_type = speck.word_type
>>> texts = np.array([[0x6574, 0x694C], [0x0000, 0x0000]], dtype=word_type)
>>> keys = np.array([[0x1918, 0x1110, 0x0908, 0x0100], [0x0000, 0x0000, 0x0000, 0x0000]], dtype=word_type)
>>> speck.encrypt(texts, keys, 0, 22)
>>> np.vectorize(hex)(texts)
array([['0xa868', '0x42f2'],
       ['0x2bb9', '0xc642']], dtype='<U6')
```

URCA is designed to be as general as possible. The following workflow,
encrypting a bunch of texts, can be applied to any primitive.

```python
>>> import random
>>> import numpy as np
>>> from urca.cpu.blocks.speck import Speck
>>> primitive = Speck(32, 64)
>>> word_size = primitive.word_size
>>> word_type = primitive.word_type
>>> n_text_words = primitive.n_text_words
>>> n_key_words = primitive.n_key_words
>>> n_instances = 4
>>> texts = [[random.getrandbits(word_size) for _ in range(n_text_words)] for _ in range(n_instances)]
>>> texts = np.array(texts, dtype=word_type)
>>> keys = [[random.getrandbits(word_size) for _ in range(n_key_words)] for _ in range(n_instances)]
>>> keys = np.array(keys, dtype=word_type)
>>> primitive.encrypt(texts, keys, 0, 22)
>>> np.vectorize(hex)(texts)
# array([['0x3068', '0xc0bf'],
#        ['0xb30b', '0xbed8'],
#        ['0xbb16', '0xece6'],
#        ['0x921a', '0x6f0a']], dtype='<U6')
# Example of output
```
krevoniz-unique-img-proc-pkg 0.1.0
Pacote de processamento de imagens usando Python
Requires Python: >=3.8

# Image Processing Package

## DescriÃ§Ã£o
O pacote `image_processing_pkg` Ã© uma biblioteca Python para processamento de imagens que oferece:
- Processamento bÃ¡sico: redimensionamento, rotaÃ§Ã£o, corte e conversÃ£o entre formatos
- AplicaÃ§Ã£o de filtros: blur, sharpen, grayscale, sepia, etc.
- Processamento avanÃ§ado: detecÃ§Ã£o de bordas, segmentaÃ§Ã£o, histograma
- UtilitÃ¡rios para manipulaÃ§Ã£o de metadados de imagens

## InstalaÃ§Ã£o

Use o gerenciador de pacotes [pip](https://pip.pypa.io/en/stable/) para instalar o pacote:

```bash
pip install image_processing_pkg
```

## Uso

### Processamento BÃ¡sico
```python
from image_processing_pkg.processing import basic

# Redimensionar uma imagem
basic.resize("input.jpg", "output.jpg", width=800, height=600)

# Converter para escala de cinza
basic.to_grayscale("input.jpg", "output_gray.jpg")

# Aplicar rotaÃ§Ã£o
basic.rotate("input.jpg", "output_rotated.jpg", angle=90)
```

### AplicaÃ§Ã£o de Filtros
```python
from image_processing_pkg.processing import filters

# Aplicar filtro de desfoque
filters.blur("input.jpg", "output_blur.jpg", radius=5)

# Aplicar filtro de nitidez
filters.sharpen("input.jpg", "output_sharp.jpg", amount=1.5)

# Aplicar filtro sÃ©pia
filters.sepia("input.jpg", "output_sepia.jpg")
```

### Processamento AvanÃ§ado
```python
from image_processing_pkg.processing import advanced

# Detectar bordas
advanced.detect_edges("input.jpg", "output_edges.jpg", method="canny")

# SegmentaÃ§Ã£o de imagem
advanced.segment("input.jpg", "output_segmented.jpg", clusters=5)

# Gerar histograma
histogram = advanced.histogram("input.jpg")
```

## Autor
Python Developer

## LicenÃ§a
[MIT](https://choosealicense.com/licenses/mit/)
goatlang 0.0.2
A language for goated people with no purpose.
Requires Python: >=3.8

# 🐐 GLC (GoatLang Compiler)

**GLC** is a toy programming language that transpiles to **C** and then compiles into native executables.
It’s designed for learning about compilers, transpilers, and language design while keeping things simple.

---

## ✨ Features

* Variables: `int`, `float`, `bool`, `string`
* Arithmetic: `+`, `-`, `*`, `/`
* Comparisons: `<`, `>`, `==`, `!=`
* Print statements: `print(expr)`
* Conditionals: `if` / `else`
* Loops: `while`
* Basic string concatenation (`msg + "something"`)

---

## 📦 Installation

Clone the repo and install it locally in **editable** mode:

```bash
pip install goatlang==0.0.1
```

This installs the `glc` command into your environment.

---

## ▶️ Usage

### Compile & Run a program

Create a file `hello.g`:

```goat
fn main() {
    string msg = "Hello, GoatLang!"
    print(msg)
}
```

Compile and run:

```bash
glc hello.g
```

Output:

```
Hello, GoatLang!
```

### Another Example (loop, conditionals, math)

```goat
fn main() {
    int x = 42
    float y = 3.14
    bool flag = true

    print(x)
    print(y)
    print(flag)

    int sum = x + 10
    float product = y * 2.0
    print(sum)
    print(product)

    if sum > 50 {
        print("Sum is large!")
    } else {
        print("Sum is small!")
    }

    int counter = 0
    while counter < 5 {
        print(counter)
        counter = counter + 1
    }
}
```

---

## 📂 Project Structure

```
glc/
├── glc/             # Source code
│   ├── lexer.py     # Tokenizer
│   ├── parser.py    # Parser → AST
│   ├── t2c.py       # AST → C transpiler
│   └── main.py      # CLI entry point
├── examples/        # Example GoatLang programs
├── pyproject.toml   # Build config
└── README.md
```

---

## ⚡ How It Works

1. **Lexing** – source code → tokens
2. **Parsing** – tokens → AST (abstract syntax tree)
3. **Transpiling** – AST → C code
4. **Compiling** – C → native executable (via GCC/clang)
5. **Running** – GLC runs the binary automatically

---

## 🛠 Requirements

* Python ≥ 3.8
* GCC or Clang (for compiling generated C code)

---

## 🚧 Limitations

* No user-defined functions yet (only `fn main`)
* String concatenation is still basic (uses buffers + `strcpy/strcat`)
* Error messages are primitive
* No standard library (beyond `print`)

---
Do you have some issues with the language put them here: https://github.com/Narendrakumar-Suresh/goat-lang/issues

## 📜 License

MIT License © 2025 Naren