semvec/pypi-packages huggingface dataset:
cv2obs 0.10
OpenCV Images (NumPy Arrays) to OBS Virtual Cam
License: MIT
Keywords: cv2,imshow,obs,stream,virtual,cam

# OpenCV Images (NumPy Arrays) to OBS Virtual Cam

### Tested against Windows 10 / Python 3.10 / Anaconda

### pip install cv2obs

## Example 

```python
from adbblitz import AdbShotTCP
from kthread_sleep import sleep
import numpy as np
from cv2obs.cv2obscam import start_cv2obs, get_index_of_working_cameras
	
	

cameras = get_index_of_working_cameras()
px = start_cv2obs(
    height=540,
    width=960,
    fps=29.97,
    camera=cameras[-1],
    killkeys="ctrl+alt+l",
)

with AdbShotTCP(
    device_serial="localhost:5555",
    adb_path=r"C:\ProgramData\chocolatey\lib\scrcpy\tools\scrcpy-win64-v2.0\adb.exe",
    ip="127.0.0.1",
    port=5555,
    max_frame_rate=60,
    max_video_width=960,
    scrcpy_server_version="2.0",
    forward_port=None,
    frame_buffer=24,
    byte_package_size=131072,
    sleep_after_exception=0.01,
    log_level="info",
    lock_video_orientation=0,
) as shosho:
    for bi in shosho:
        if bi.dtype == np.uint16:
            continue
        px.write_image(
            bi
        )  # Writes images to the camera, image will be resized automatically
        # (according to width/height in start_cv2obs)
        sleep(0.001)





get_index_of_working_cameras():
    """
    Get the indices of the working cameras.

    Returns:
        List[int]: A list containing the indices of the cameras that are working.

    Note:
        - This function internally calls the `list_ports` function to test the camera ports.
        - The `list_ports` function returns a tuple with available ports, working ports, and non-working ports.
        - Only the working ports are extracted and returned by this function.
    """
	
	
start_cv2obs(
    height: int = 540,
    width: int = 960,
    fps: int | float = 29.97,
    camera: int = 2,
    killkeys: str = "ctrl+alt+l",
):
    """
    Start the cv2obs subprocess for capturing and processing camera images.

    Args:
        height (int): The desired height of the captured images. Defaults to 540.
        width (int): The desired width of the captured images. Defaults to 960.
        fps (int|float): The frames per second for capturing images. Defaults to 29.97.
        camera (int): The index of the camera to use. Defaults to 2.
        killkeys (str): The key combination to stop the cv2obs subprocess. Defaults to "ctrl+alt+l".


    Note:
        - The function internally creates a numpy array of shape (height, width, 3) with white pixels (255, 255, 255).
        - The numpy array is then encoded using `encode_var` function from the `varpickler` module.
        - The encoded array size is used for configuring the `bytesize` parameter of the `start_subprocess` function.
        - The cv2obs subprocess is started using the `start_subprocess` function with appropriate parameters.
        - The `px.write_image` attribute of the subprocess is set to a partial function `_write_image` for writing images.
    """	
	
```
atcom 0.4.3
A tool which makes AT communication easier.
License: MIT
Requires Python: >=3.6.0

# ATCom
​
AT commands are the instructions used to control and communicate with the cellular modems. In order to, send AT commands to a cellular device, one needs to check several parameters and might need a serial monitor tool. 
ATCom is a command-line interface tool that makes AT command operations easier.
​
## Installation
​
[pip3](https://pip.pypa.io/en/stable/) is required to install the **atcom**. pip3 can be intalled by 
​
```bash
sudo apt install python3-pip
```
​
Use the package manager [pip3](https://pip.pypa.io/en/stable/) to install **atcom**.
​
```bash
pip3 install atcom
```
​
## Usage
​
```bash
$ atcom [OPTIONS] AT_COMMAND
```

> ### Warning: 
> If you need to send `"` or `'` character, you should use escape character `\` before it.
> ### Example: 
> ```atcom AT+CGDCONT=1,\"IP\",\"internet\"```
​
### Examples
​
Running **atcom** without *--port* parameter, scans for available ports, and selects a valid modem port if available.
​
```bash
$ atcom AT
```
​
or
​
```bash
$ atcom --port /dev/ttyUSB2 AT
```
​
## Configuration File
​
Configuration file(configs.yaml) can be created for persist args. 
ATCom first checks the current working directory for the configs.yml to read the arguments from. The path of the configuration file can also be specified using the **--config** parameter. 
​
The configuration file must be in *yaml* format, for example: 
​
```yaml
port: /dev/ttyUSB2
baudrate: 115200
timeout: 10
```
​
The keys, config file can contain:
* port (str)
* baudrate (int)
* timeout (int)
* rts_cts (boolean)
* dsr_dtr (boolean)
* verbose (boolean)
​
### Parameters
​
|                 |     default    |            description           |
|-----------------|:--------------:|:--------------------------------:|
| -p / --port     |        -       | PORT of modem                    |
| -b / --baudrate |     115200     | Baudrate for serial communication|
| -t / --timeout  |        10      | Communication timeout            |
| -c / --config   | ./configs.yaml | Configurations file Path         |
| -v / --verbose  |        -       | Enable full log output           |
| --rts-cts       |        -       | Enable RTS-CTS mode              |
| --dsr-dtr       |        -       | Enable DSR-DTR mode              |
discord-status-updater 0.2.0
updates Discord status depending on various conditions
License: MIT
Requires Python: >=3.8
Keywords: Discord

Discord Status Updater
======================

This simple daemon/application updates your status in Discord depending on various conditions (behavior is customizable through the plugins). Right now only 2 plugins are implemented and enabled out-of-the-box:

* MPRIS listener - sets now playing item info as custom status
* screen lock listener - sets status to "idle" when screen is locked

Anything else can be implemented as additional plugin (even not in this package!), but there is no stable API for this yet. Some other default plugins may appear in the future.

Why?
----

Discord may set status depending on which application user runs (for example "Playing Minecraft" or "Listening to Spotify"), at least with some applications on Windows. But what about Linux? and/or whatever application? or if you want to show everyone the specific title of the item you are watching/listening to right now? This piece of software solves these questions (at least some of them).

Environment
-----------

This software is **Linux-only**, maybe even KDE-specific (not tested with other environments). It was developed in KDE environment and may rely on some KDE-specific DBus interfaces (at least I didn't find any documentation/specification for DBus signal I used to detect screen locking events).

It requires Python 3.8 or higher, developed with Python 3.11, lower versions are not tested but should work. The only "version-specific" code is a part of plugin system implementation, it uses some feature appeared in 3.8 (according to documentation).

Usage
-----

First of all, just install it as any other Python package, it has only few lightweight and pretty common dependencies. Then do the first run by typing `discord-status-updater` in terminal. It will generate default configuration file at `~/.config/discord-status-updater.json` and exit. You **must edit** this configuration file at least to set your Discord credentials.

No running Discord application is required to use this software. So, it is possible to start it with user session automatically (in any convenient way, e.g. placing .desktop file into `~/.config/autostart` or using "systemd" user service unit).

How it works
------------

This application is barely *another Discord client* (or "just bot" for simplicity) which listens to whatever system events and updates status according to them. It uses Discord API to update the status, so it needs to login as *you*, so that's why no running Discord app are required and credentials in the configuration file must exist.

Default plugins shipped with this package use DBus to track events they are interested in (aka "now playing" information or screen locking events), that's why it is Linux-specific.
BigKindsParser 0.1.5
Journalism, preprocessing-data.
License: MIT
Requires Python: >=3.7
Keywords: Journalism,preprocessing-data,BigKinds

# BigKindsParser

> BigKindsParser는 한국 언론의 빅데이터 저장소인 BigKinds에서 추출한 데이터를 low-Code로 분석할 수 있게 만든 툴입니다.

## Requirements

- Python >= 3.8

## Installation

- macOS

  ```bash
  python3 -m pip install BigKindsParser
  ```

- Windows

  ```bash
  python -m pip install BigKindsParser
  ```


## Authors

- [sorrychoe](https://www.github.com/sorrychoe)


## License

- [MIT](https://choosealicense.com/licenses/mit/)