semvec/pypi-packages huggingface dataset:
professordriver 0.1.0
A utility package to set up Selenium WebDriver with custom configurations.
Requires Python: >=3.6

# ProfessorDriver

This package provides a pre-configured Selenium WebDriver with a custom extension and proxy settings.

## Installation

Install from PyPI:

```bash
pip install professordriver
```

## Usage

```python
from professordriver import create_custom_driver

driver = create_custom_driver('185.177.107.30:9871')
```
FJsim 1.1
A module capable of simulating the spreading of an opinon in a given network using the Friedkin-Johnsen model.
Requires Python: >=3.9.10

# Friedkin-Johnsen-model-simulator


A module capable of simulating the spreading of an opinon in a given network using the Friedkin-Johnsen model.

## Table of contents

* [Requirements](#Requirements)
* [Installation](#Installation)
* [Usage](#Usage)
* [Example](#Example)


## Requirements

* Python 3.9.10 or higher
* Numpy 1.25.0 or higher

## Installation
Clone the repository:

```sh
git clone https://github.com/Giorgio-ctrl/Friedkin-Johnsen-model-simulator.git
```

or install via pip:

```sh
python -m pip install FJsim
```

## Usage

```sh
model = Friedkin_Johnsen(weight, influence)
```

* weight is the stochastic weighed adjacency matrix of the network (each element a<sub>ij</sub> is the influence of node j on node i)
* influence is the matrix where each diagonal element is how much a node is influenced by others and all the other entries are 0

```sh
model.simulate(initial)
```
* initial is the nx1 vector of the original opions of each node

This code altogether returns the opinions that the system converges to or -1 if they don't converge.


## Example


```sh
weight = numpy.array([
              [0.220, 0.120, 0.360, 0.300],
              [0.147, 0.215, 0.344, 0.294],
              [0.000, 0.000, 1.000, 0.000],
              [0.090, 0.178, 0.446, 0.286]
              ])
influence = numpy.diag([0.780, 0.785, 0, 0.714])
initial = numpy.transpose([25, 25, 75, 85])

model = Friedkin_Johnsen(weight, influence)
print(model.simulate(initial)
```
This code will print:
```sh
[60.02084883 59.98396594 75.         74.98620494]
```
Which is exactly the vector of the opinions once they converge.
roxCrypter 1.0.1
A custom encryption package for blank text & passwords
Requires Python: >=3.6


# roxCrypter: Simple ROT-Based Encryption Module

This Python module, roxCrypter, implements a basic encryption algorithm inspired by the ROT (Rotate) cipher family. It encrypts lowercase Turkish characters using a mathematical transformation.



#

## Installation

__Direct Import:__
```py
import roxCrypter

crypter = roxCrypter.roxCrypter()
encrypted_text = crypter.encrypt_text("Your message here")
```

## Functionality

The roxCrypter class provides two main methods:

encrypt_letter(self, letter): Encrypts a single lowercase Turkish letter using a mathematical formula involving squaring, cubing, taking the remainder, and adding offsets.
encrypt_text(self, text): Encrypts an entire string of text, handling both lowercase Turkish characters and other characters (which are left unchanged). The encrypted text is then base64 encoded for improved readability and storage.
Verification

The check_encrypted_text(self, original_text, encrypted_text) method allows you to verify if the encryption process was successful. It re-encrypts the original text and compares it to the provided encrypted text.

```py
import roxCrypter

crypter = roxCrypter.roxCrypter()
original_text = "Merhaba, dünya!"  # Turkish for "Hello, world!"
encrypted_text = crypter.encrypt_text(original_text)

print("Original Text:", original_text)
print("Encrypted Text:", encrypted_text)

is_valid = crypter.check_encrypted_text(original_text, encrypted_text)
print("Encryption Valid:", is_valid)
```
This code will output:
```
Original Text: Merhaba, dünya!
Encrypted Text: xZ91xLHEn2TDp2QsIHbFn3J5ZCE=
Encryption Valid: True
```

## Security Considerations

It's important to note that roxCrypter is a very simple encryption algorithm and should not be used for sensitive information. It's susceptible to brute-force attacks, statistical analysis, and other cryptanalysis techniques. Consider using more robust encryption methods for real-world applications.

## Future Enhancements

* Implement support for uppercase letters and other character sets.
* Explore more secure encryption algorithms like AES or RSA.
* Add functionality for decryption.
yazdl 0.1.0
Download zoom recordings.
Requires Python: >=3.9
Keywords: zoom, recording, downloader

# yazdl
> Yet Another zoomdl

Download zoom recordings

# Installation
This program can be installed manually, with the source code, using `pip` (in this case we'll be using `pipx` for separated virtual environments) or, in case you are on Windows, use the latest compiled release.

## Using pip
Simply type the following line into a terminal
```sh
pipx install yazdl
```

## Manually
In case you want to install it directly from the source, simply clone this repository and `cd` into it.

Then, run the following command:
```sh
pipx install .
```


# Usage
## Basic usage
```sh
yazdl recording-url.zoom.us/id1 recording-url.zoom.us/id2 ...
```

This will download all the recordings contained in the given URLs, whose content will be shared screen and speaker cam, if applicable.


## General usage
```sh
yazdl urls [options]
```

### Options
```sh
  -h, --help           show a help message and exit.
  --no-speaker, -k     Don't download the speaker screen.
  --no-screen, -c      Don't download the screen share.
  --subtitles, -s      Downloads the default subtitle for the meeting as srt.
  --transcription, -t  Downloads the meeting transcription as srt.
```

# Addendum
Just a few things I'd like to add, at least for now.

## DI
When I started writing this script, I decided to use DI in order to make something reusable, which, after a while I realized how much of a overkill this was for such a simple script. At the end, I didn't use [ABCs](https://docs.python.org/3/library/abc.html) and didn't write any tests, so it was a huge waste of time.

I'll eventually fix this mess and add a few tests, but for now, this project is not my top priority.

## YoutubeDL
After I was done with the downloader, I realized that the famous [youtubedl](https://github.com/ytdl-org/youtube-dl) already had a module that downloads zoom recordings, which consists in a very simple and straightforward code, with just a little over 60 lines and also contains proper testing as well, sooo...

But anyway, their script couldn't properly download th recordings that I had, so maybe thua is not that much useless after all?

The thing is, I will improve this script, eventually.

## Naming
At first, I picked the name **zoomdl** for this project, but, when uploading it to pypi test, I found out that, for no one's surprise, that there [already is a project named zoomdl](https://github.com/Battleman/zoomdl/), and it even turns out to be an archived project, seemingly because of the advent of the aforementioned `youtube-dl` project. So, my go to was to use the classic "_yet another_" naming convention.

Welp... My objective here is not to compete against them in anyway, after all, it's all open software. I don't want this project to be born archived, so I'll be improving it bit by bit, at least for a while.

# TODO
Replace `setup.py` and use [build](https://build.pypa.io/en/stable/) to build the package.

Password streams

Use ABC

Write tests lol
lucide_icons 0.1.0
Django Lucide Icons

# Django Lucide Icons

This is a Django template tag that allows you to use [Lucide Icons](https://lucide.dev/) in your Django templates.

## Installation

To install the package, simply run:

```bash
pip install django-lucide-icons
```

## Usage

To use the template tag, add the following line to your Django project's settings.py file:

```python
LUCIDE_ICONS_DIR = "/path/to/your/icons/directory"
```

The LUCIDE_ICONS_DIR variable should be set to the directory where you want to store the Lucide icons.

Then, you can use the `lucide` template tag in your Django templates to display Lucide icons. For example, to display the "home" icon, you can use the following code:

```html
{% load lucide_tags %} {% lucide "home" %}
```

The `lucide` template tag takes a single argument, which is the name of the Lucide icon you want to display.
It returns the SVG code of the icon as a string.

Since the plain SVG is rendered, it might make sense to wrap it in a "span" or "div" element to
size it properly.
Alternative approaches are welcome. Just submit an issue or a pull request.