semvec/pypi-packages huggingface dataset:
purehtml-purescraps 0.1.4
HTML data extraction library
Requires Python: >=3.8

# PureHTML

PureHTML is a parsing specification for extracting JSON from HTML.

- [Documentation](https://purescraps.github.io/purehtml/)

**Installation**:

To install **PureHTML**, you can use `pip` with following command:

```bash
  pip install purehtml-purescraps
```

## Usage

```python
from purehtml import ConfigFactory, extract

yaml_string = """
selector: span
type: array
items: {}
"""
html_string = """
<div>
  <span>a</span>
  <span>b</span>
  <span>c</span>
</div>
"""
expected_output = "['a', 'b', 'c']"

config = ConfigFactory.from_yaml(yaml_string)

print(f"Extracted output : {extract(config, html_string, 'http://example.com')}")
print(f"Expected  output : {expected_output}")

```

## Development

For testing, we use test specifications defined in `<purehtml root>/specs`.
You may run `python3 run_tests.py` to check if the python implementation
is working correctly or has some incompatibilities.

#### Building

1. Install `build` pip with this command: `python3 -m pip install --upgrade build`
2. Execute `make clean build` to create a clean build output. The output will be placed in `dist/`

#### Publishing to Python Package Index

1. Install the `twine` package: `python3 -m pip install --upgrade twine`
2. Publish to pypi: `python3 -m twine upload dist/*` or with `make publish`

## License

[MIT](https://choosealicense.com/licenses/mit/)
NotipyDesktop 10.0.0
A simple Python notification library using libnotify.
Requires Python: >=3.6

# NotipyDesktop

NotipyDesktop is a simple Python library for sending desktop notifications using [libnotify](https://developer.gnome.org/libnotify/).

## Features

- Send desktop notifications with a title and message.
- Easy-to-use API with just one function.
- Uses [PyGObject](https://pygobject.readthedocs.io/en/latest/) to interact with GNOME notifications.

---

## Installation

Install the library via `pip`:

```bash
pip install NotipyDesktop
```

---

## Usage

Here's an example of how to use `notifier`:

```python
from NotipyDesktop import notify

# Send a notification
notify("MyApp", "Test Notification", "This is a test message.")
```

### CLI Usage

#### local path

You can also use the library as a command-line tool. Run the following command to send a notification:

```bash
python3 NotipyDesktop.py MyApp "Test Notification" "This is a test message."
```

---

#### sytem wide

You can make the program system wide executable with:

```bash
chmod +x /path/to/NotipyDesktop/NotipyDesktop.py
```

After that you have to add the path to `$PATH`:

```bash
export PATH=$PATH:/path/to/NotipyDesktop
```

Then you can run:

```bash
NotipyDesktop MyApp "Test Notification" "This is a test message."
```

## Requirements

- Python 3.6 or higher
- GNOME Desktop Environment (or a compatible Linux desktop environment)
- `libnotify` installed on your system

Install the required Python dependencies:

```bash
pip install PyGObject
```

For most Linux distributions, you can install `libnotify` with your package manager. Example for Ubuntu/Debian:

```bash
sudo apt install libnotify-bin
```

---

## Development

To set up the project locally for development:

1. Clone the repository:

   ```bash
   git clone https://github.com/Michdo93/NotipyDesktop.git
   cd NotipyDesktop
   ```

2. Install dependencies:

   ```bash
   pip install -r requirements.txt
   ```

3. Run the tests or use the CLI to validate functionality.

---

## Contributing

Contributions are welcome! If you find a bug or have a feature request, feel free to open an issue or submit a pull request.

---

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

---

## Acknowledgments

- [PyGObject Documentation](https://pygobject.readthedocs.io/en/latest/)
- [GNOME libnotify](https://developer.gnome.org/libnotify/)
```
ckey 1.0.0a1
OpenFEC API client for researching the political spending of executives
Requires Python: >=3.6

# ckey
### OpenFEC API client for researching the political ideology of executives

Copyright (c) 2024 Justin G. Davis.

## Overview
Ckey is a data collection and analysis tool that uses executive information from ExecuComp to capture political contribution data from openFEC, the Federal Election Commission (FEC) API. It allows researchers to construct measures of executive political ideology based on the executives' political contributions.

> **Disclaimer** - Ckey is not affiliated with, endorsed by, or vetted by ExecuComp.

## Features
- **User-Friendly** - Designed for researchers with minimal Python experience
- **Data Processing** - Automated cleaning and formatting of ExecuComp data
- **API Integration** - Efficient data collection from openFEC API with built-in rate limiting
- **Compliance** - Integrated adherence to openFEC API usage policies
- **Political Analysis** - Construction of all commonly used political ideology measures
- **Accurate Matching** - Robust executive-to-contribution matching using name, employer, and occupation verification

## Installation
```bash
pip install ckey
```

## Prerequisites & Dependencies

### Prerequisites
- Python 3.6 or higher
- Access to ExecuComp data
- FEC API key (obtain from [FEC.gov](https://api.open.fec.gov/developers))

### Python Dependencies
- pandas >= 2.0.0
- requests >= 2.31.0
- ThreadPoolExecutorPlus >= 0.2.2

Note: Python dependencies are automatically installed during the pip installation

## Usage Guide

### Basic Usage
```python
import ckey

ckey.run(
    data_path='your ExecuComp data.csv',
    id_column='exec id column in the data',
    name_column='name column in the data',
    company_column='company column in the data',
    year_column='year column in the data',
    key='YOUR_API_KEY'
)
```
For detailed usage instructions and methodology, please see:

[Citation information to be added]

## Citation
If you use this tool in your research, please cite:

[Citation information to be added]

## License
This project is licensed under the MIT License - see the LICENSE file for details.

## Acknowledgments
Thank you to:
- The FEC for providing and maintaining the openFEC API.
- The openFEC support staff for their assistance throughout the development process.

## Author
Justin G. Davis
lazyplot 0.1.7
plot matplotlib graph easily
Requires Python: >=3.8

# lazyplot

Module for using matplotlib easily.

## install
```
pip install lazyplot
```

## usage
### lazy_plot
Draw graphs by entering only np.ndarray data.
```
from lazyplot import lazy_plot
x = np.random.rand(3, 30)
lazy_plot(x)

# Simple customization
lazy_plot(x, figure_config={"figsize"=(8,20), "colmuns"=2, "plot_type_2d"="plot"})
```

### custom plot
Draw more detailed graph by using user-specified LazyAxes
```
from lazyplot import LazyAxes, custom_plot
draw_info = LazyAxes(y=np.random.rand(2,30), title="random value", plot_type="scatter", color="blue")
custom_plot(draw_info)
```

### FigureConfig
FigreConfig can be overridden by giving a dictionary-type configuration item to the figure_config of lazy_plot and custom_plot.

- figsize (tuple[int, int])figsize of matplotlib.Figure (default= (5, 4))
- layout ("tight" | "constrained") : layout of matplotlib.Figure (default= "constrained")
- linewidth (float) : linewidth of graph (default= 2.0)
- columns (int) : number of columns in graph display.  (default= 1)
    
- plot_type_1d ("plot" | "hist" | "bar"): default plot type of 1 demensional array. (default= "plot")
- plot_type_1d ("plot" | "scatter" | "imshow" | "boxplot"): default plot type of 2 demensional array. (default= "imshow")
- plot_type_3d ("scatter"): default plot type of 3 demensional array. (default= "scatter")
    
- dpi (float) : dpi of matplotlib.Figure (default= 100)



### LazyAxes

- y (np.ndarray) \*REQUIRED
- plot_type ("plot" | "hist" | "bar" | "scatter" | "imshow" | "boxplot") \*REQUIRED

- title (str)
- t (np.ndarray)
- labels (list[str])
- x_label (str)
- y_label (str)
- x_lim (tuple[float|None, float|None])
- y_lim (tuple[float|None, float|None])
- color (list[str | tuple[int, int, int]])
- alpha (float)
- line_style (list[str])
- marker_style (list[str])
- linewidth (float)
- aspect (float | Literal["auto"])
- invert_xaxis (bool)
- invert_yaxis (bool)
telethon-client 0.1.9
Custom Telethon Client for My Usage
Requires Python: >=3.7

# Telethon Custom Client

This is a custom Telethon client package that I have created for my own usage. It is open source and available on GitHub. Feel free to explore the repository and use it if it fits your needs.

## Installation

You can install this package from PyPI using pip:

```shell
pip install telethon-client
```

## Usage

To use this custom Telethon client, you need to import it in your Python code:

```python
from TeleClient import MyClient

# Create an instance of the custom client
bot = MyClient(api_id, api_hash, token) # if u wanna use user client use StringSession from telethon.sessions just like telethon

# Use the client to interact with the Telegram API
# ...
```

Make sure to replace `api_id` and `api_hash` with your own Telegram API credentials.


## License

This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).