semvec/pypi-packages huggingface dataset:
RaDin-tdb 0.0.2
It's a School's Database Trial Manipulator, That is written by Abuzar Alvi.
Keywords: school,database,school database,arithmetic,mathematics,python,RaDin,RaDin database,database modifier

It's a School's Database Trial Manipulator, That is written by Abuzar Alvi. They can perform many tasks like insert, check, update, delete, add, sub or many more things.
cisort 1.1.15
cpp include sort
Requires Python: >=3.6,<4.0

<img src="https://i.imgur.com/LsH6pj8.gif" alt="example" width="500"/>

# C/С++ Includes Sort

This is a tool that allows you to quickly and
conveniently sort all libraries included in the project in
alphabetical order.

## Examples
<img src="https://i.imgur.com/GLgtBDH.gif" alt="example" width="500"/>

### Text before:
```c++
#include <iostream>
#include <vector>
#include <stdio.h>
#include <algorithm>

#include "mylib.h"
#include "b_lib.h"
#include "a_first_lib.h"

#include <external/lib/main.hpp>
#include <external/lib/abuse.hpp>
#include <external/lib/func.hpp>

int main(){
	std::cout << "Hello, World!" << std::endl;
}
```
### Text after:
```c++
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>

#include "a_first_lib.h"
#include "b_lib.h"
#include "mylib.h"

#include <external/lib/abuse.hpp>
#include <external/lib/func.hpp>
#include <external/lib/main.hpp>

int main(){
	std::cout << "Hello, World!" << std::endl;
}
```

## Installation:

```python
pip install cisort
```

## Usage:
```cisort [flags] [path]```

Flags:\
        `-r` `--recursive` - recursive searching C/C++ files\
        `-ls` - show info about sorted files\
        `-h` `--help` - to get help\
        `-c` `--comments` - add comments to sorted blocks\n'



#### Contacts

[VK][1], [Telegram][2], [Discord][3]

[1]: https://vk.com/pavel.cmake
[2]: https://t.me/pavel_cpp
[3]: https://discordapp.com/users/427479608321900545/
DBDictionary 0.1.1
A dictionary-like interface for using databases

# DB Dictionary

## Description :
This is a module which has been designed to make it easier to work with databases 
in python using a dictionary like interface.

## Installation :
`pip install DBDictionary`

## Usage MongoDB :

```python
from DBDictionary import MongoDB_Dict

my_db_dict = MongoDB_Dict("my_db_name", "my_collection_name", "my_key_field", "my_connection_string")
# The connection string is optional and will default to 
# "mongodb://localhost:27017/"  if not provided here and not in the ENV var also
my_db_dict["my_key"] = {"my_key_field": "my_key",
                        "other data": "my_value"}  # This will insert a new document into the collection
your_value = my_db_dict["my_key"]  # This will return "my_value", the value in the database
print(your_value)  # This will print {"my_key_field": "my_key", "other data": "my_value"}
del my_db_dict["my_key"]  # This will delete the document from the collection
# now trying to retrive the value will raise a KeyError ,
# but you can use the "get" method like you do in a dictionary as usual
your_value = my_db_dict.get("my_key", "default_value")  # This will return "default_value"
print(your_value)  # This will print "default_value"
your_value = my_db_dict["my_key"]  # This will raise a KeyError

# editing and updating a document :
your_value["other data"] = "my_new_value"  # This will edit the value in the memory
my_db_dict.update(your_value)  # This will update the document in the database

# When you edit a dictionary like this :
my_db_dict["my_key"][
    "other data"] = "my_new_value"  # This will have no effect on the database and any changes will be lost
```
jwtsign 1.0.8
JWT encoding and decoding limited to RS256
Requires Python: >=3.10

# JWTSign

Rust jwt signing bindings for python

Usage:

```py
import time
import json

from jwtsign import PyJwtEncoder, PyJwtDecoder

def read_bin(path: str) -> bytes:
    with open(path, "rb") as file:
        return file.read()

claims = {
    "id": "example",
    "exp": int(time.time() + 60),
}

private_key = read_bin("res/private_key.pem")
public_key = read_bin("res/public_key.pem")
encoder = PyJwtEncoder(private_key)
decoder = PyJwtDecoder(public_key, leeway=60)

# Using object encoding
token_claims_obj = encoder.encode_claims_json_obj(claims)
decoded_claims_obj = decoder.decode(token_claims_obj)

# Using serialized object encoding
token_claims_str = encoder.encode_claims_json_str(json.dumps(claims))
decoded_claims_str = decoder.decode(token_claims_str)
```

Decoder validates expiration time based on UTC with a leeway defined in the `PyJwtDecoder::__init__`.

> [!NOTE]
> If at any point you have your claim as serialized JSON keep in mind that this performs slightly faster than the object as encoding parameter, as the rust code uses python bindings to call `json.dumps` on the object.