semvec/pypi-packages huggingface dataset:
superpof 0.0.1
Una librería super beta inspirada en NumPy y Torch pero simplificada
Requires Python: >=3.8

# Super B

**Super B** es una biblioteca Python ultraligera que combina funciones simples inspiradas en NumPy y PyTorch, con estabilidad y características experimentales.

## Características
- Operaciones matemáticas básicas
- Funciones de estabilidad (`super_x`)
- Funciones experimentales (`super_vv`)
- Compatible con Python 3.12
- Soporte para compilación en C

## Instalación
```bash
pip install super-b

Uso rápido

import super_b

print(super_b.sumar(2, 3))

licencia 

mit
django-bsv-integration 0.1.0
Django integration for BSV blockchain using py-bsv SDK
Requires Python: >=3.8

# Django BSV Integration

A Django package for Bitcoin SV (BSV) blockchain integration using the py-bsv SDK.

## Features

- BSV wallet management with Django models
- Transaction creation and broadcasting
- 1sat ordinal support
- Image processing for blockchain storage
- UTXO management
- Integration with WhatsOnChain and GorillaPool APIs

## Installation

```bash
pip install django-bsv-integration
```

## Quick Start

1. Add "bsv_integration" to your INSTALLED_APPS:

```python
INSTALLED_APPS = [
    ...
    'bsv_integration',
]
```

2. Run migrations:

```bash
python manage.py migrate bsv_integration
```

3. Create a BSV wallet:

```python
from bsv_integration.models import BSVWallet

# Create wallet
wallet = BSVWallet.objects.create(
    user=request.user,
    name="My BSV Wallet",
    # ... other fields
)

# Send transaction
result = await wallet.send_transaction(
    recipient_address="1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2",
    amount=1000,  # satoshis
    op_return_message="Hello BSV!"
)
```

## Requirements

- Django 3.2+
- Python 3.8+
- py-bsv SDK
- aiohttp for async operations

## License

MIT License
utme 1.0.1
Universal Turing Machine Emulator.
Requires Python: >=3.12
Keywords: turing, machine, emulator

Universal Turing Machine Emulator
=================================

**utme** is a library that provides [*Turing machine*][tm] emulation in pure
Python.

With **utme**, you can define a *Turing machine*, run it with an input and
inspect its output.

> Note: I wrote this library to help myself understand Turing machines.
> **utme** is not suitable for efficient/performant Turing machine emulation.

[tm]: https://en.wikipedia.org/wiki/Turing_machine

### Why is it called *universal*?

As the library allows you to define any valid *Turing machine* (universal or
not) and run it, the library itself is equivalent to a *universal Turing
machine* (a Turing machine that accepts another Turing machine and an input for
it, and yields its output).

While **utme** does not emulate a universal Turing machine by itself, I found
the name cool (It was originally `utm`, but then I found out it was already
taken by another project on [PyPI][pypi]).

That said, there is an [example script](./examples/universal.py) that
composes `universal_machine`; a universal Turing machine using **utme**.
The script also provides `encode`/`decode` functions that converts **utme**
objects from and into valid tapes for `universal_machine` (so you can even pass
`universal_machine` (with an input) to itself!).

[pypi]: https://pypi.org/


Installation
------------

**utme** is available in the [Python Package Index][pypi-utme]:

```sh
pip install utme
```

The library has zero dependencies and should work on any Python (3.12+)
implementation on any platform.

[pypi-utme]: https://pypi.org/project/utme/


Documentation
-------------

**utme**'s API is documented at the definition level (via *docstrings* where
possible, and comments otherwise).

The library code is around 250 logical line of codes, so you can easily read
the source code to understand implementation details.

Exported objects are categorized and enumerated briefly in the package's
*docstring*:

```sh
python -m pydoc utme
```

### Examples

Examples of Turing machines implemented using **utme** are included in the
[examples](./examples) directory.


Development
-----------

You only need [`uv`][uv] and [`just`][just] on your POSIX system to get
started.

Run `just` (without arguments) to see available tasks.

[uv]: https://github.com/astral-sh/uv
[just]: https://github.com/casey/just

### Contribution

Before you submit a patch, please run `just precommit` and make sure the task
runs successfully.  Patches that don't pass `just precommit` will not be
merged.


License
-------

**utme** is licensed under the [MIT (Expat) license](./LICENSE).

> Copyright (C) 2025 Karam Assany (karam.assany@disroot.org)
hack4u-niggi 7.1.0
Una biblioteca para consultar cursos de hack4u

# Hack4U Academy Courses Library

Una biblioteca Python para consultar cursos de la academia Hack4U

## Cursos disponibles:

- Introducción a Linux [15 horas] 
- Personalización de Linux [3 horas] 
- Introducción al Hacking [53 horas]
- Python Ofensivo [35 horas]
- Hacking Web [51 horas]

## Instalación

Instala el paquete usando `pip3`:

```python3
pip install hack4u
```

## Uso básico

### Listar todos los cursos

```python
from hack4u import list_courses


for course in list_courses():
    print(course)
```

### Obtener un curso por nombre

```python
from hack4u import get_course_by_name

course = get_course_by_name("Introduccion a Linux")
print(course)
```

### Calcular duración total de los cursos

```python3
from hack4u.utils import total_duration

print(f"Duración total: {total_duration()} horas)
```
PyfodMC 1.1.5
Python Fermi-orbital descriptor Monte-Carlo (PyfodMC)
Requires Python: >=3.6
Keywords: Python, FLO-SIC, FODs

# PyfodMC - Python Fermi-orbital descriptor Monte-Carlo 
[![license](https://img.shields.io/badge/license-APACHE2-green)](https://www.apache.org/licenses/LICENSE-2.0)
[![language](https://img.shields.io/badge/language-Python3-blue)](https://www.python.org/)
[![version](https://img.shields.io/badge/version-1.1.3-lightgrey)](https://gitlab.com/opensic/PyfodMC/-/blob/main/README.md)

The Python Fermi-orbital descriptor Monte-Carlo (PyfodMC) is a Python code for      
the determination of Fermi-orbital descriptors (FODs) for atomic, molecular,     
and periodic systems. It follows a simple input structure, where users primarily    
define the bond patterns between the atoms in the structure. Everything else     
is handled internally through PyfodMC. Additional options for greater flexibility     
have also been added, like the explicit definition of lone FODs. Further options     
include the definiton of charge, whether to exchange the up and the dn channel,    
the definition of alternate electronic configurations, and the removal of core FODs    
for each atom.    


PyfodMC is the successor of the Fermi-orbital descriptor Monte-Carlo (fodMC) code.      
PyfodMC is based on fodMC, version 1.2.2, but has been written exclusively in Python.      
Furthermore, several improvements over the original fodMC code have been added for       
increased robustness and reproducibility.     
As such, the support for the original fodMC code will stop, and support for the PyfodMC    
code will start.    



## Installation
Using pip
```bash 
$ pip3 install PyfodMC
```
or install locally
```bash 
$ git clone https://gitlab.com/opensic/PyfodMC.git
$ cd PyfodMC
$ pip3 install -e .
```

Examples can be found in the examples folder.


## Citation
For publications, please consider citing the following articles        

- **Interpretation and automatic generation of Fermi-orbital descriptors**         
    [S. Schwalbe et al., J. Comput. Chem. 40, 2843-2857, 2019](https://onlinelibrary.wiley.com/doi/full/10.1002/jcc.26062)


# ATTENTION
While the PyfodMC can create FODs for      
any system, we do not recommend using       
guesses for systems containing transition metals.