semvec/pypi-packages huggingface dataset:
validador-datos 0.1.0
Paquete para validar emails y passwords
Requires Python: >=3.10

# validador_datos

Paquete de Python para **validar emails y passwords** de manera sencilla y profesional.  
Incluye funciones con **reglas de validación** y **excepciones personalizadas** para manejar errores de forma clara.

---

## 🔹 Instalación

Instala el paquete desde PyPI:

```bash
pip install validador_datos
```

## 🔹 Instalación

Instala el paquete desde PyPI:

```bash
pip install validador_datos
````

> Si estás usando el código localmente para pruebas, puedes instalar desde tu proyecto así:

```bash
pip install .
```

---

## 🔹 Uso básico

### Validar un email

```python
from validador_datos.email import validar_email
from validador_datos.exceptions import EmailInvalidoError

try:
    validar_email("usuario@ejemplo.com")
    print("Email válido ✅")
except EmailInvalidoError as e:
    print(f"Error: {e}")
```

### Validar un password

```python
from validador_datos.password import validar_password
from validador_datos.exceptions import PasswordInvalidoError

try:
    validar_password("MiPass123$")
    print("Password válido ✅")
except PasswordInvalidoError as e:
    print(f"Error: {e}")
```

---

## 🔹 Excepciones personalizadas

* `ValidacionError` → clase base para todos los errores de validación
* `EmailInvalidoError` → se lanza cuando un email no cumple el formato
* `PasswordInvalidoError` → se lanza cuando un password no cumple las reglas

Esto permite **capturar errores específicos o generales**:

```python
from validador_datos.exceptions import ValidacionError

try:
    validar_email("malo")
    validar_password("123")
except ValidacionError as e:
    print(f"Error de validación: {e}")
```

---

## 🔹 Reglas de validación de password

1. Mínimo 8 caracteres
2. Al menos una letra mayúscula
3. Al menos un número
4. Al menos un símbolo (no letra ni número ni espacio)

---

## 🔹 Licencia

MIT License. Puedes usar, modificar y distribuir libremente este paquete.
panzi_inotify 1.0.2
Simple Linux inotify bindings for Python, including OSErrors.
Requires Python: >=3.10
Keywords: inotify, linux

panzi-inotify
=============

[![Test Status](https://img.shields.io/github/actions/workflow/status/panzi/panzi-inotify/tests.yml)](https://github.com/panzi/panzi-inotify/actions/workflows/tests.yml)
[![Release](https://img.shields.io/github/v/tag/panzi/panzi-inotify)](https://pypi.org/project/panzi_inotify/)
[![Mozilla Public License Version 2.0](https://img.shields.io/github/license/panzi/panzi-inotify)](https://github.com/panzi/panzi-inotify/blob/main/LICENSE.txt)

[API Documentation](https://panzi.github.io/panzi-inotify)

Simple inotify bindings for Python.

I didn't like all the other available inotify bindings for one reason or anther.
This one is different in these ways:

* You can import the module even if your libc doesn't support inotify. It then
  will have `HAS_INOTIFY` `False` and only if you try to create an instance of
  `Inotify` you will get an exception (`OSError(ENOSYS)`).
* It correctly handles paths that are invalid UTF-8 by using `os.fsencode()`/`os.fsdecode()`
  which use the `'surrogateescape'` Unicode error handling option. This makes
  the file paths rountrip safe.
* `wait()` and `read_events()` is separate. You can do your own wait/poll logic
  if you want.
* You can use non-blocking mode and then `read_events()` only reads the available
  events. If there are none at the moment it returns an empty array.
* You can pass a `stopfd` to `PollInotify()`. This file descriptor will be added to
  the `epoll_wait()` call in `PollInotify.wait()`. If `POLLIN` signals for that
  then `wait()` will return `False`. This is meant for implementing a way to stop
  a thread that waits for events without a timeout.
* Translates errors to the appropriate Python exceptions from the given `errno`
  (`FileNotFoundError`, `PermissionError` etc. and `OSError` as fallback).
* Uses Mozilla Public License Version 2.0, so you can use it from proprietary
  code, yet it isn't as permissive as MIT or BSD.

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

Via pip:

```bash
$ pip install panzi-inotify
```

Form source:

```bash
$ git clone git@github.com:panzi/panzi-inotify.git
$ pip install ./panzi-inotify
```

Example
-------

```Python
from panzi_inotify import Inotify, get_inotify_event_names

import sys

with Inotify() as inotify:
    for filename in sys.argv[1:]:
        inotify.add_watch(filename)

    for event in inotify:
        print(f'{event.full_path()}: {", ".join(get_inotify_event_names(event.mask))}')
```

See [examples](https://github.com/panzi/panzi-inotify/tree/main/examples) for more.

You can also run a basic command line too to listen for events on a set of paths
like this:

```bash
python -m panzi_inotify [--mask=MASK] <path>...
```

For more on this see:

```bash
python -m panzi_inotify --help
```

See Also
--------

[inotify(7)](https://linux.die.net/man/7/inotify)
dbs-todo 0.6.2
Dain-Bread Simple TODO list
Requires Python: >=3.7

dbs == dain-bread simple
========================
TODO list for minimalists

# SPDX-License-Identifier: GPL-2.0-only
# Copyright (c) 2022, Al Stone <ahs3@ahs3.net>

A "task" consists of a file that looks something like this:

    Task: get something done
    State: open
    Project: stuff
    Priority: h
    Note: this is a note
    Note: this is another note

(sans indenting, of course).  Each key:value is exactly one line (everything
up until the newline).  There are a few limits:

   -- State is one of 'open', 'active', 'done' or 'deleted' [0]
   -- Priority is one of 'h', 'm', 'l'

It's all pretty self-explanatory.  I've tried to keep this as simple as
possible, but Python wants things packaged properly, and I wanted to have
both a CLI version (dbs) and an ncurses version (dbsui) using the same code
for managing tasks.  So, yeah, needed to create a module to package and
distribute with.

Installation is simple: clone the source tree, cd to the clone, then:

   $ make install

Or:

   $ pip install dbs-todo

That's it.  Python3 is the only requirement.  Most distros will have the
right Python modules by default.  I use this on Fedora and Debian, so
your mileage may vary.

To add a task like the one above:

   $ dbs add 0001 stuff h "get something done"

That's it.  It's automatically created as an open task.  You can find all
open tasks with:

   $ dbs lo

('lo' == 'list open' -- extra credit if you can figure out the command for
'list active' and 'list done').

If you do this:

   $ dbs

You'll get a list of all current commands and any parameters they might need.

There is a config file: it is always $HOME/.config/dbs/config. The only thing
you can specify is this:

    repo: <some directory path>

If it does not exist, it will be created.  If the repo path does not exist,
it will be created, also.  In the repo, there is a directory for each task
state containing one file for each task in that state.  Task names must be
unique across all states since we move the files around in the various repo
directories [1].

With 0.6.0, I've added an ncurses-based UI.  It's crude, probably buggy
even.  It can be invoked with:

   $ dbsui

There is a 'help' command ('?').  The left panel lists the projects that
have open tasks, and the right panel lists the tasks for the current
project.  This is still experimental code so caveat emptor.


Notes:
[0] Nothing ever gets actually deleted unless you remove the files.
[1] In order to sync across machines, I create ~/Dropbox/dbs and use
    Dropbox to sync that directory across machines.