semvec/pypi-packages huggingface dataset:
razer-chroma-keyboard 0.0.1.post2
Razer chroma compatible keyboard backlight driving library.
Requires Python: >=3.9

# What is this library ?

This library allows a python application or script to change the keys backlight colors of a razer chroma compatible keyboard.
A demo is also available.

# How to install ?

Install [https://www.razer.com/fr-fr/synapse-3](https://www.razer.com/fr-fr/synapse-3). <br/>
Create an environment and activate it if you want to (optionnal). <br/>
Execute ```pip install razer-chroma-keyboard```

# How to test ?

Execute ```python -m razer_chroma_keyboard```. You should see promptly (in less than 3 seconds) the result on your keyboard.

# How to use as a library ?

Import with ```import razer_chroma_keyboard```. For this example, also ```import time```.
Prepare your (R, G, B) color tuples matrix. So you know the dimensions, you can use this black matrix and modify it : ```m = [[(0, 0, 0) for _ in range(22)] for _ in range(6)]```.
Then you can use a with statement (to allow fine control of the connection) like this : <br/>
```
with razer_chroma_keyboard.razerServerChromaConnection() as connection :
    connection.apply_chroma_custom(m)
    while True: time.sleep(1)
```
The second line is because, when the with statement is left, the connection will be stopped, and the keyboard will back to it's previous state after a moment (if another software controls it).
Example of full code to turn the whole keyboard into a specific color :
```
import razer_chroma_keyboard
import time

def change_color(color: tuple[int, int, int] = (50, 50, 50)):
    m = [[color for _ in range(22)] for _ in range(6)]
    with razer_chroma_keyboard.razerServerChromaConnection() as connection :
        connection.apply_chroma_custom(m)
        while True: time.sleep(1)

change_color((255, 191, 0)) #  Amber yellow.
```
Reckitt-Python-Package 1.0.0
A simple Python package
Requires Python: >=3.6

# `basicpkg`

The `Python_Package_tutorial` is a simple testing example to understand the basics of developing your first Python package. 
MIT License

Copyright (c) 2023 Vikash Kumar Barnwal

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
StringType 0.0.1
A module for working with string types of vars
Requires Python: >=3.6

**So...**
```
	Just write to shell **PIP INSTALL StringType**))))
```

**Commands:**
```
	p(text)-return text with paragrath

	finder(text,list)-check, is text in list, and if it's true, return true, else return false

  times(time,text)-return text after a "time" time

  lock(key,value,file)-open and code file into key-value couple

  type(var)-check, if var is a string, return true, else return false

  check(text,checkvar)-the same as finder()

```
My discord: <a>MS.music9#1861</a>
PyMS9 0.0.1
A funny module for making programmist's live easy!
Requires Python: >=3.6

**So...**
```
	1. Download PyMS9.py file to your computer.
  2. Import it to your project.
	3. In __Main.py__ write 'import PyMS9 as m9'
```
__**or...**__
```
	or just write to shell **PIP INSTALL MS9**))))
```

**Commands:**
```
	lenprint(text)-just going on the lenght of the text to the lines

	_random(values)-gives to you one random value

  timer(int())-starts timer

  runner(int(),int())-just adds to the first value "1" while it smaller than second value

  chase(value2,value2,list/tuple)-returns value what is in list/tuple

  check(value,list/tuple)-returns true if value in list/tuple

	strvalue(int())-makes from integer value to string value as 5 = "5"

  ArithmeticNum(list)-makes from list of integer values one float number that is the average of all values in list

  isdivision(values)-checks, if 1st value % 2nd value == 0, it returns true

  Other commands is about turtle

  New commands is coming...

```
My discord: <a>MS.music9#1861</a>
villain-pagination 0.1.5
A small pagination package
Requires Python: >=3.7

# Welcome to villain-pagination

## Installation

First of all, you need to install villain-pagination on your local to start.

```
pip install villain-pagination
```

## Minimal Example

`Villain Paginator` uses SQLAlchemy ORM.

Let's start with a simple example below.
You need to import `page` and `paginator` function from `villain-pagination`.

- `page` : is a class which used as `response_model` in your route declaration.
- `paginator` : is main functions that will paginate your data.

To use paginate, 5 params required.

- `db` : is a SQLAlchemy session.
- `model` : is a object which you want to paginate.
- `order_by` : is a column of the model.
- `page` : is a number of a page requested to show.
- `size` : is a number of data which will shown in one page.

And Here is an example.

```python
from typing import Iterator, Any
from faker import Faker
from fastapi import Depends, FastAPI
from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import Session, sessionmaker

from villain import page, paginator

engine = create_engine("sqlite:///.db", connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=True, autoflush=True, bind=engine)

Base = declarative_base(bind=engine)

fake = Faker()

class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String, nullable=False)

Base.metadata.create_all()

app = FastAPI()

@app.on_event("startup")
def on_startup() -> None:
    session = SessionLocal()
    session.add_all([User(name=fake.name()) for _ in range(100)])
    session.flush()
    session.close()

def get_db() -> Iterator[Session]:
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get("/users/", response_model=page.Page)
def get_users(db: Session = Depends(get_db)) -> Any:
    return paginator.paginate(db = db, model = User, order_by= User.id, page = 0, size = 10 )

```
OBP-reliability-pillar-2 0.0.13
Provides AWS compliance details
Requires Python: >=3.7

# OBP_Reliability_Pillar

OBP_Reliability_Pillar package can be used to get the compliance details of Operational Best Practices for AWS Well Architected Reliability Pillar.

Release Notes:
# v0.0.8
1. Added following compliance checks:
   - DbInstanceBackupEnabled
   - S3BucketDefaultLockEnabled
   - LambdaInsideVpc
   - GuarddutyEnabledCentralized
   - DynamodbPitrEnabled
   - RedshiftClusterMaintenancesettingsCheck
2. Minor bug fixes

# v0.0.7
1. Added following compliance checks:
   - Elastic Search In VPC only
   - ELB deletion protection enabled
   - Instance in VPC
   - Lambda dlq check

# v0.0.4
1. Added Description column on Compliance Data set
2. Added method for S3 Bucket replication compliance
3. Fixes bugs
adjectiveanimalnumber 0.0.1
A simple package to generate random adjectives with an animal name and a random integer.
Requires Python: >=3

# AdjectiveAnimalNumber

This is a port in Python of the [adjectiveadjectiveanimal](https://github.com/nii236/adjectiveadjectiveanimal)

## Installation

```bash 
pip install adjectiveanimalnumber
```

## Usage

### CLI
    usage: adjectiveanimalnumber [-h] [-a ADJS] [-s SEP] [-n NUM] [-i INF] [-u SUP]                                                                                                                                                                                     
    
    Generate a random adjective with an animal name and a random integer.
    
    optional arguments:
      -h, --help            show this help message and exit
      -a ADJS, --adjs ADJS  Number of adjectives to generate
      -s SEP, --sep SEP     Separator between adjectives and animal name
      -n NUM, --num NUM     Add a random integer to the end of the string
      -i INF, --inf INF     Inferior limit for random integer
      -u SUP, --sup SUP     Superior limit for random integer

Examples:
    
```bash
adjectiveanimalnumber -a 2 -n 1 -i 0 -u 100
```

```bash
adjectiveanimalnumber -a 3 -s "_" -i 0 -u 1024
```

### Python

```python
from adjectiveanimalnumber import generate
generate()
```
jira-2-notion-db 1.1.2
Jira to Notion-database Migration Tool
Requires Python: >=3.7

# Jira 2 Notion DB

Jira issue to Notion database Migration Tool

## Installation

```shell
pip install jira-2-notion-db
```

## Configuration

* Jira login token
* Notion integration token


## CLI Usage

should be able to find Notion db using Jira project name.

```shell
jira-2-notion-db --url "https://your.atlassian.net" --username "your@mail.com" --password "yourAtlassianToken" --project "PJ" --notion "yourNotionIntegrationToken"
```

* arguments:
  * --url URL
    * Jira url ex) https://your.atlassian.net
  * --username
    * Jira username
  * --password
    * Jira api token (Not Password)
  * --project
    * Jira project name
  * --notion
    * Notion integration bot token
  * --delay
    * Notion update delay


## Python Usage

```python
# jira
from jira_2_notion_db.services.jira_service import JiraService
jira = JiraService(base_url="https://your.atlassian.net", username="username", password="password")
all_projects = jira.read_project()
jira.login()
jira_contents = jira.collect(project="PJ", only_my_issue=False)

# notion
from jira_2_notion_db.services.notion_service import NotionService
notion = NotionService(notion_key="notionToken")
notion.run(db_name="PJ", data=jira_contents, delay_time=1)
```

## Open source license
[LICENSE](LICENSE)

## Related projects

* https://github.com/minwook-shin/notion-database