semvec/pypi-packages huggingface dataset:
passmanage 1.0.0
A simple CLI password manager with AES encryption
Requires Python: >=3.12


🔐 Passman — Simple CLI Password Manager

Passman is a lightweight, command-line based password manager built in Python.
It securely stores your passwords in an encrypted SQLite database — only accessible with your master password.

🚀 Features:

  🔒 Secure AES-based encryption using a master password

  🧠 Master password verified before any access

  🗄️ Passwords stored locally in an encrypted SQLite database

  📜 List, add, delete, or retrieve services easily

  🎨 Colored output for better readability

  ⚙️ Cross-platform (Linux, macOS, Windows)

📦 Installation:
  🧩 Option 1: Local Installation (Developer Mode)

  Clone the repository and install it locally in editable mode:
  ```bash:

  git clone https://github.com/<your-username>/passman.git
  cd passman
  pip install -e .

💡 The -e flag means “editable mode”, so any changes to the code will reflect instantly.

  Now, you can use the command:
  pass
  
🔑 First-Time Setup:

  When you run any command (like add, list, get, etc.) for the first time,
  passman will automatically ask you to create a master password:

    ```bash
    No Master Password Set. Let's Create One Now.
    Create Master Password: ********
    Confirm Master Password: ********
    Master password saved. Keep it safe!

  This password will be used to encrypt and decrypt all your stored credentials.
  You’ll need to enter it every time you open a new terminal session.

⚙️ Usage:

  📥 Add a new service
    Add a password for a service (e.g., Gmail, GitHub, Discord):

  ```bash
    pass add <service_name> -u <username> <password>

  🔍 Get a service password

  Retrieve a stored password for a service:
    pass get <service_name>

  📋 List all saved services
  1️⃣  Without showing passwords:
    pass list

  2️⃣ Show list with decrypted passwords: 
    pass list --show

  ❌ Delete a service
    Remove a saved password entry by service name:

    pass del <service_name>

💻 Development Commands 

   - Install locally (editable):
      pip install -e .
   - Uninstall:
      pip uninstall passman -y


🧠 Future Enhancements

  🔐 Multi-user support

  ☁️ Optional cloud sync

  🧩 Auto password generation

  🧰 Backup and restore feature
hack4u-course 0.34.1
Una biblioteca para listar los 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]


## Instalación
Instala el paquete utilizando 'pip3':

```python3
pip3 install hack4u
```

## Uso básico

### Listar todos los cursos

```python
from hack4u import list_courses

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

### Calcular duración total de los cursos

```python3
from hack4u.utils import total_duration

print(f"Duración total: {total_duration()} horas")
```
OHFFDRL 0.0.2
Optimized Hierarchical Fused Fuzzy Deep Reinforcement Learning
Requires Python: >=3.11

# OHFFDRL

Optimized Hierarchical Fused Fuzzy Deep Reinforcement Learning.

## Example
```python
import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

import OHFFDRL as oh

# === Step 1: Load and preprocess data ===
df = pd.read_csv("MAINDiagnostics.csv")
df = df.drop(columns=["IDFILENAME", "FileName", "Beat"])
df["Gender"] = df["Gender"].map({"MALE": 1, "FEMALE": 0})

normal_group = ["SR", "SB", "ST", "SI", "SAAWR"]
arrhythmia_group = ["AFIB", "AF", "SVT", "AT", "AVNRT", "AVRT"]
df["Rhythm_Binary"] = df["Rhythm"].apply(lambda x: 0 if x in normal_group else (1 if x in arrhythmia_group else np.nan))
df = df.dropna(subset=["Rhythm_Binary"])

X = df.drop(columns=["Rhythm", "Rhythm_Binary"], errors='ignore').values
y = df["Rhythm_Binary"].astype(int).values

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# === SSO-inspired oversampling for class 1 ===
X_min = X_scaled[y == 1]
X_maj = X_scaled[y == 0]
n_to_generate = len(X_maj) - len(X_min)

def sso_augment(X, n_samples):
    n_features = X.shape[1]
    augmented = []
    for _ in range(n_samples):
        i, j = np.random.choice(len(X), 2, replace=False)
        alpha = np.random.uniform(-1, 1, n_features)
        sample = X[i] + alpha * (X[j] - X[i])
        augmented.append(sample)
    return np.array(augmented)

X_syn = sso_augment(X_min, n_to_generate)
y_syn = np.ones(n_to_generate, dtype=int)

X_bal = np.vstack([X_scaled, X_syn])
y_bal = np.concatenate([y, y_syn])

# === Train/test split ===
X_train, X_val, y_train, y_val = train_test_split(X_bal, y_bal, test_size=0.2, random_state=42, stratify=y_bal)
input_dim = X_train.shape[1]

ohf = oh.OHFFDRL(input_dim, X_train, X_val, y_train, y_val)

dim = 2 * 3 * input_dim
opt_vector = ohf.whho_optimize(dim)
mu_opt = opt_vector[:len(opt_vector)//2].reshape(3, input_dim)
sigma_opt = np.abs(opt_vector[len(opt_vector)//2:].reshape(3, input_dim)) + 1e-2

# === Step 5: Train final model ===
final_model = ohf.build_model(mu_opt, sigma_opt)
final_model.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=30, batch_size=32, verbose=1)

# === Step 6: Evaluate ===
y_pred_final = np.argmax(final_model.predict(X_val), axis=1)
print(classification_report(y_val, y_pred_final, target_names=["Normal", "Arrhythmia"]))
```
You can find the "MAINDiagnostics.csv" [here](https://github.com/arman-daliri/OHFFDRL/blob/main/OHFFDRL/MAINDiagnostics.csv).

## Authors
- Arman Daliri