semvec/pypi-packages huggingface dataset:
skim-unicode-table 0.1.21
Interactive fuzzy-searchable unicode table using lotabout/skim
Keywords: unicode,table,interactive,character,fuzzy

# skim-unicode-table

Interactive fuzzy-searchable Unicode table using [lotabout's skim][1].

Can be used to quickly search for a character and copy it to the clipboard.


## Demo video

https://user-images.githubusercontent.com/3827982/127855578-b052bf0b-f4e5-4686-b171-5e5fea784326.mov


## Installation

Install via pip:

(**NOTE:** If prebuilt wheels are not available for your operating system,
installation will take a long time and use a lot of space because it has to
compile a fork of skim from scratch.)

```bash
pip install skim-unicode-table
```

This will put two scripts into pip's preferred binary directory:
`skim-unicode-table` and `skim-unicode-table-xsel`. The former just displays
the table and prints the selected character and its various names separated by
two spaces when the user presses `Enter`, then exits. The latter also copies
the selected character into the clipboard using `xsel` (check if this is
installed!), which might not work on all platforms. If it doesn't work, you can
try to build your own script for copying the character into the clipboard using
`skim-unicode-table`.

### Optional dependencies

- [atanunq's viu][2]: Required for enlarged character previews like in the demo
  video above to work. Make sure it can be found from `PATH`.

### Launching in new terminal window

The most common setup will probably be to bind `skim-unicode-table-xsel` to
a hotkey that launches it in a new terminal window. How to do this depends on
the specific terminal emulator used (there is no unified CLI, unfortunately).

In `gnome-terminal`'s case, it would be (absolute path in case pip's preferred
binary installation folder isn't in `PATH` for the application that handles
hotkeys, commonly the window manager):

```bash
gnome-terminal -- /path/to/skim-unicode-table-xsel
```


## Development notes

### Why use a forked skim?

`fuzzy-matcher` (used internally by skim) had default scoring that didn't seem
very suitable for this use case, as it kept returning something unexpected as
the best match, so I had to [tweak it a bit][3] and fork skim so that it uses
this modified version.


[1]: https://github.com/lotabout/skim "lotabout/skim on GitHub"
[2]: https://github.com/atanunq/viu "atanunq/viu on GitHub"
[3]: https://github.com/smheidrich/fuzzy-matcher/compare/master...smheidrich:for_skim_unicode#diff-2099478acb23e56398caeea19c6a315098d4d7ae4d6d642b8cbacb647ce3f2e8
ripio-client 0.0.3
Ripio Client for Python
Requires Python: >=3.7

# Ripio Client for Python
###  ALPHA SOFTWARE


This is a lightweight library that works as a client to [Ripio](https://www.ripio.com) Services

## Installation
```bash
pip install ripio-client
```

## Usage example
```python
from ripio.trade.client import Client

# API key is required for user data endpoints
client = Client(api_key='<api_key>')

# Get balance information
print(client.balance())

# Create a market order
params = {
	'pair': 'BTC_USDC',
	'side': 'buy',
	'amount': 0.01,
	'type': 'market'
}
response = client.create_order(**params)
print(response)

# Create a limit buy order
params = {
	'pair': 'BTC_USDC',
	'side': 'buy',
	'amount': 0.0002,
	'type': 'limit',
	'price': 27471.65
}
response = client.create_order(**params)
print(response)

# Create a limit sell order
params = {
	'pair': 'BTC_USDC',
	'side': 'sell',
	'amount': 0.0002,
	'type': 'limit',
	'price': 27470
}
response = client.create_order(**params)
print(response)

```
ascii-yt 2.1.1
play any youtube video ▶ with ASCII in the terminal.
Keywords: ascii,art,video,youtube,linux,shell,python,terminal

<div align=center>

# ascii-yt

play any youtube video ▶ with ASCII in the terminal.

[![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/malkiii/ascii-yt?color=red)](./ascii_video_player)
[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/malkiii/ascii-yt/publish.yml?color=2fbe50&logo=github)](https://github.com/malkiii/ascii-yt/actions)
[![PyPI](https://img.shields.io/pypi/v/ascii-yt?label=pypi%20version&logo=pypi)](https://pypi.org/project/ascii-yt/)
[![Twitter URL](https://img.shields.io/twitter/url?label=@malkiAbdoo&url=https%3A%2F%2Ftwitter.com%2FmalkiAbdoo)](https://twitter.com/malkiAbdoo)

![Screenshot](./images/example.gif)

</div>

## Requirements

- python 3.3 or above
- Linux or MacOS

## Installation

install it with `pip` command

```bash
$ pip install ascii-yt
```

or use `pip3` in Linux or MacOS

```bash
$ pip3 install ascii-yt
```

## Usage

you can use URL as well between double quotes

```bash
$ ascii-yt "https://www.youtube.com/watch?v=dQw4w9WgXcQ&"
```

### Options

**`--colors`**
Allow to use colors in the ascii video

```bash
$ ascii-yt "URL.." --colors
```

**`-s --size`** Set a custom size and it must be `WIDTHxHEIGHT`

```bash
$ ascii-yt "URL.." -s 110x40
```

**`-c --chars`**
Allow using your own characters depending on the grayscale value from black to white. the default value: " .'~;icok0XN"

```bash
$ ascii-yt "URL.." -c " .:!lM" --colors
```

## How it works

ascii-yt is a python program that renders [ASCII](https://en.wikipedia.org/wiki/ASCII) videos based on 5 steps:

1. Using **OpenCV** module to read each frame in the video
2. Resize it to the terminal size (if there's not a custom size in the options)
3. Convert the frame to a grayscale image (black & white)
4. Mapping each pixel to a given character depending on the grayscale value from black to the white. the default value: `" .'~;icok0XN"`

5. finaly display the frame.

<details>

<summary>Overview</summary><br>
<img src="https://raw.githubusercontent.com/malkiii/ascii-yt/main/images/explain.jpg" alt="overview" />

</details>

## License

Distributed under the [MIT](https://github.com/malkiii/ascii-yt/blob/main/LICENSE) license.
wordpress-scanner 1.2
A theme, username, plugin name browser for Flask in Python

Here is an example of its usage:

```
from wordpress_scanner import WordpressScanner


scanner = WordpressScanner(domain)

users = scanner.get_users() 
theme_name = scanner.get_theme_name() 
plugins_name = scanner.get_plugins_name()

print(users)
print(theme_name)
print(plugins_name)

```

This library is a useful tool that can extract the theme name, plugin names, and user name of a WordPress site. It is designed to work with Flask and offers a simple and fast interface for WordPress sites. With the theme name and user name information of a site, you can easily find out which theme and plugins are being used by the site owner. This information can be particularly helpful when analyzing or examining a site.

Using the library is quite easy. After importing the library, all you need to do is enter the WordPress site URL.

The library has been designed to make WordPress site management easier and more efficient for users. I hope this library will help users improve their WordPress site management tasks.


### Changelog


__v1.1[2023-04-13]__
* It worked.

__v0.9[2023-04-12]__
* Pull and fix all plugin names
json-stream-to-standard-types 0.1.4
Convert json-stream objects to standard Python dicts and lists
Requires Python: >=3.7,<4.0

⚠ **NOTE:** Starting at json-stream 2.2.0,[`to_standard_types` is part of
json-stream itself](https://github.com/daggaz/json-stream/pull/33), so there
is no longer a need for this packgage.

# json-stream-to-standard-types

Utility function to convert `json-stream` objects to normal Python dicts/lists.

Parallel PR: https://github.com/daggaz/json-stream/pull/17

## Installation

```bash
pip install json-stream-to-standard-types
```

## Usage

To convert a json-stream `dict`-like or `list`-like object and all its
descendants to a standard `list` and `dict`, simply apply the library's
`to_standard_types` function:

```python
import json_stream
from json_stream_to_standard_types import to_standard_types

# JSON: {"round": 1, "results": [1, 2, 3]}
data = json_stream.load(f)
results = data["results"]
print(results)  # prints <TransientStreamingJSONList: TRANSIENT, STREAMING>
converted = to_standard_types(results)
print(converted)  # prints [1, 2, 3]
```

## License

Do whatever you want with it license or whatever it was called