semvec/pypi-packages huggingface dataset:
locksmithy 0.1.0
A simple password generator
Requires Python: >=3.6

Sure, here is a basic README file template for the Locksmith password generator project:

# Locksmith Password Generator

Locksmith is a simple password generator tool that generates strong, random passwords with various options for customization.

## Installation

To install Locksmith, you can use `pip`:

```
pip install locksmithy
```

Alternatively, you can clone the repository and install it manually:

```
git clone https://github.com/yourusername/locksmith.git
cd locksmith
pip install .
```

## Usage

To generate a password with the default options (10 characters, lowercase letters only), simply run:

```
locksmith
```

To specify the length of the password, use the `-l` or `--length` flag followed by the desired length:

```
locksmith -l 16
```

To include numbers in the password, use the `-n` or `--numbers` flag:

```
locksmith --numbers
```

To include special characters in the password, use the `-s` or `--special` flag:

```
locksmith --special
```

To include uppercase letters in the password, use the `-u` or `--uppercase` flag:

```
locksmith --uppercase
```

You can combine these options to create passwords with your desired characteristics:

```
locksmith -l 20 -nus
```

## License

Locksmith is licensed under the [MIT License](https://github.com/yourusername/locksmith/blob/master/LICENSE).

## Contributing

If you would like to contribute to Locksmith, please feel free to submit a pull request or open an issue on the [GitHub repository](https://github.com/yourusername/locksmith).
MSO-WT 0.0.1
Official python implementation of the Maximal Spectral Overlap Wavelet Transform (MSO-WT)
Requires Python: >=3.6

## **Maximal Spectral Overlap Wavelet Transform**

***
![](resources/mso_wt.png)
Official python implementation of the _Maximal Spectral Overlap Wavelet Transform (MSO-WT)_ 
as described in [(Evangelidis and Kugiumtzis, 2023)](https://ieeexplore.ieee.org/document/10109867). 
The algorithm decomposes a signal into orthogonal _Intrinsic Mode Functions (IMFs)_ each oscillating 
around a different central frequency. 

### Installation

***
1. Install from source <br> <pre><code>$ git clone https://github.com/apostolosev/MSO_WT & cd MSO_WT
$ pip install .</pre></code>


### Minimal Example 

***
```python
import numpy as np
import matplotlib.pyplot as plt
from mso_wt import MSOWT

# Define the example multi-component input sign
t = np.linspace(0.0, 1.0, 1024)
gt_imf1 = 1 / (1.2 + np.cos(2 * np.pi * t))
gt_imf2 = np.cos(32 * np.pi * t + 0.2 * np.cos(64 * np.pi * t)) / (1.5 + np.sin(2 * np.pi * t))
sig = gt_imf1 + gt_imf2

# Decompose the signal using the MSO-WT
msowt = MSOWT(nIMFs=2)
imfs = msowt.decompose(sig)

# Display the decomposition results
# Original signal
plt.figure(figsize=(6, 4))
plt.plot(t, sig, "-k", linewidth=1.5, label="GT-IMF_1 + GT-IMF_2")
plt.title("Multi-component signal")
plt.legend(loc="upper left")
plt.xlabel("Time (s)")

# IMF 1
fig, axs = plt.subplots(1, 2, figsize=(12, 4))
axs[0].plot(t, gt_imf1, "-k", linewidth=1.5, label="GT-IMF_1")
axs[0].plot(t, imfs[0, :], "-c", linewidth=1.5, label="IMF_1")
axs[0].legend(loc="upper left")
axs[0].set_xlabel("Time (s)")

# IMF 2
axs[1].plot(t, gt_imf2, "-k", linewidth=1.5, label="GT-IMF_2")
axs[1].plot(t, imfs[1, :], "-c", linewidth=1.5, label="IMF_2")
axs[1].legend(loc="upper left")
axs[1].set_xlabel("Time (s)")
plt.show()
```

### Citation

***
If you use this package, please cite it as below.
```
@article{evangelidis2023adaptive,
  title={Adaptive Decomposition of Multicomponent Signals and Estimation of Phase Synchronization},
  author={Evangelidis, Apostolos and Kugiumtzis, Dimitris},
  journal={IEEE Transactions on Signal Processing},
  year={2023},
  publisher={IEEE}
}
```

### License

*** 
The software is released under the [MIT](https://github.com/apostolosev/MSO_WT/blob/main/license.txt) license.