semvec/pypi-packages huggingface dataset:
cvss-converter 0.1.4
A package to convert CVSSv2 to CVSSv3
Requires Python: >=3.6

# cvss-converter

A python program to convert older cvss versions to more modern ones.

## Change Logs

## v0.1.4:

- Cleaned up README.md by removing irrelevant reference

### v0.1.3:

- `cvss2_to_3()` now better handles variants of prefixes on CVSSv2 vectors (e.g. CVSS2#/AV:L..., CVSS2.0:AV:L/...)

## Limitations

- Currently cvss-converter only provides cvssv2 to cvssv3 conversion, with strict mode by default.
- Only base vector is supported as it is meant to help convert older CVEs with CVSSv2 base vectors (on NVD)

## Strict Mode

As there are a several fields which are either ambiguous or doesn't exist at all (e.g. Scope or User Interaction). During conversion, the logic will always choose the values of a vector that yields a higher CVSS score. We prefer to err on the side of caution than to assume that the vulnerability is not affected by the ambiguity.
The conversion mapping chart in strict mode for ambiguous or missing vectors is as follows:

| CVSSv2 Vector                    | CVSSv3.1 Vector               |
| -------------------------------- | ----------------------------- |
| Attack Complexity (AC): "Medium" | Attack Complexity (AC): "Low" |
| Does not exist                   | Scope (S): "C"                |
| Does not exist                   | User Interaction (UI): "N"    |

Please also note that for Attack Vector (AV), since there is no `Physical` value in CVSSv2, there is no conversion requirements to ever map a value to CVSSv3 `AV:P`.

# How to use?

## Install with Pip or Pipenv

Pip:

```
pip install cvss-converter
```

Pipenv:

```
pipenv install cvss-converter
```

## Usage: Example

```python
from cvss_converter.converter import cvss2_to_cvss3

cvssv2 = "AV:N/AC:H/Au:S/C:P/I:P/A:C"
cvssv3, score = cvss2_to_cvss3(cvssv2)
print(f"CVSSv3 Vector: {cvssv3}, Base Score: {score}")
```

Expected output:

```bash
CVSSv3 Vector: CVSS:3.0/AV:N/AC:H/PR:L/UI:R/S:C/C:L/I:L/A:H, Base Score: 7.1
```

# Future

- Add vector override
- Add option for standard mode (non-strict)
webraft 0.6
WebRaft is a Python library for creating and reading JSON Web Tokens, extracting user agent information, retrieving IP data, and creating and reading API keys.
Keywords: webraft, WebRaftpython, django, jwt, jwt for django, create api key, read api key, create token, read token, user agent django, ip info python, user agent python, jwt flask, jwt bottle, jwt fastapi


    # WebRaft

    creating and reading JSON Web Tokens, extracting user agent
    information, retrieving IP data, and creating and reading API keys

    # How to install webraft

    ```python
    pip install webraft
    ```
    # Documentation
    open Github repository for the WebRaft Python library. The link is included in the package's documentation to provide
    users with access to the source code and additional information about the library.
    <br>
    https://github.com/MominIqbal-1234/webraft



    Check Our Site : https://mefiz.com/about </br>
    Developed by : Momin Iqbal
paqueteoptimizacion-isabellajb-1-2 0.0.1
Paquete de Optimizacion de Python
Keywords: python, optimizacion, multivariables, variable

Paquete de Optimizacion de Python que contiene métodos de funciones multivariables; directos y de gradiente, y funciones de una sola variable; eliminación de regiones y basados en la derivada
django-keycloak-lma 1.3.6
Modified version of the package django_keycloak (0.1.1)


INFO:


settings.KEYCLOAK_OIDC_PROFILE_MODEL = OpenIdConnectProfile

Available features:
- basic auth with token request (KeycloakPasswordAuthentication)
- bearer token auth (KeycloakTokenAuthentication)
- refresh token method (services/oidc_profile)
- exchange remote token (services/remote_client)
- logout (services/oidc_profile)
- permission check (auth/permissions)


Examples of using features: tests/lma
quantile-tree 0.1.2
Monotone quantile regressor
Requires Python: >=3.6

# quantile-tree

Non-crossing quantile estimation with:
- LightGBM
- XGBoost

# Installation
Install using pip:
```bash
pip install quantile-tree
```

# Usage
## Features
- **QuantileRegressorLgb**: quantile regressor based on LightGBM
- **QuantileRegressorXgb**: quantile regressor based on XGBoost

## Parameters
```python
x         # Explanatory data (e.g. pd.DataFrame)
          # Column name '_tau' must be not included
y         # Response data (e.g. np.ndarray)
alphas    # Target quantiles
objective # [Optional] objective to minimize, "check"(default) or "huber"
delta     # [Optional] parameter in "huber" objective, used when objective == "huber"
          # delta must be smaller than 0.1
```
## Methods
```python
train     # train quantile model
          # Any params related to model can be used except "objective"
predict   # predict with input data
```

## Example
```python
import numpy as np
from quantile_tree import QuantileRegressorLgb, QuantileRegressorXgb

## Generate sample
sample_size = 500
x = np.linspace(-10, 10, sample_size)
y = np.sin(x) + np.random.uniform(-0.4, 0.4, sample_size)
x_test = np.linspace(-10, 10, sample_size)
y_test = np.sin(x_test) + np.random.uniform(-0.4, 0.4, sample_size)

## target quantiles
alphas = [0.3, 0.4, 0.5, 0.6, 0.7]

## QuantileRegressorLgb
monotonic_quantile_lgb = QuantileRegressorLgb(
    x=x,
    y=y_test,
    alphas=alphas,
    objective="huber",
    delta=0.05,
)
lgb_params = {
    "max_depth": 4,
    "num_leaves": 15,
    "learning_rate": 0.1,
    "boosting_type": "gbdt",
}
monotonic_quantile_lgb.train(params=lgb_params)
preds_lgb = monotonic_quantile_lgb.predict(x=x_test, alphas=alphas)


## QuantileRegressorXgb
monotonic_quantile_xgb = QuantileRegressorXgb(
    x=x,
    y=y_test,
    alphas=alphas
)
xgb_params = {
    "learning_rate": 0.65,
    "max_depth": 10,
}
monotonic_quantile_xgb.train(params=xgb_params)
preds_xgb = monotonic_quantile_xgb.predict(x=x_test, alphas=alphas)
```
my-rabbitmq-package 0.1.4
A Python package for RabbitMQ interactions
Requires Python: >=3.6

```markdown
# my_rabbitmq_package

A Python package for RabbitMQ interactions.

## Installation

You can install the package using pip:

```bash
pip install my-rabbitmq-package==0.1.4
```

## Publisher Usage

```python
from my_rabbitmq_package.publisher import RabbitMQPublisher

# Initialize the publisher
rabbitmq_publisher = RabbitMQPublisher(host='localhost', port=5672, username='guest', password='guest')

# Declare the queue
rabbitmq_publisher.declare_queue('hello')

# Publish a message
message = "Hello, RabbitMQ!"
rabbitmq_publisher.publish_message(message, 'hello')

# Close the connection
rabbitmq_publisher.close_connection()
```

## Consumer Usage

```python
from my_rabbitmq_package.consumer import RabbitMQConsumer
import threading

# Initialize the consumer
rabbitmq_consumer = RabbitMQConsumer(host='localhost', port=5672, username='guest', password='guest')

# Declare the queue
rabbitmq_consumer.declare_queue('hello')

# Define event handler functions
@rabbitmq_consumer.event_manager.on(event="message_received")
def handle_message_received(data: bytes):
    print(" [*] Event handler 'handle_message_received' triggered")
    print(f"Processing message: {data.decode()}")

@rabbitmq_consumer.event_manager.on(event="stop_consumer")
def handle_stop_consumer():
    print(" [*] Event handler 'handle_stop_consumer' triggered")
    rabbitmq_consumer.stop()

# Start consuming messages in a separate thread
consume_thread = threading.Thread(target=rabbitmq_consumer.consume_messages, args=('hello',))
consume_thread.start()
consume_thread.join()

# Close the connection
rabbitmq_consumer.close_connection()
```

## Running Tests

You can run the tests using `pytest`. First, make sure you have `pytest` installed:

```bash
pip install pytest
```

Then, run the tests:

```bash
pytest tests/
```