semvec/pypi-packages huggingface dataset:
pydataharvest 1.0.0
A Python application that provides web scraping capabilities, including fetching Google and Yelp reviews.

### pydataharvest

pydataharvest is a Python application that provides web scraping capabilities, including fetching Google and Yelp reviews. The application has a user-friendly graphical user interface (GUI) for easy interaction.

### Features

- **Web Scraping:** Extract information from web pages based on user-provided URLs.
- **Google Reviews:** Fetch reviews for a given business or location using Google Maps API.
- **Yelp Reviews:** Retrieve reviews for a business using the Yelp API.
- **OpenStreetMap Data:** Extract latitude, longitude, and additional information from OpenStreetMap.

#### Requirements

- Python 3.x
- Required Python packages (install using `pip install -r requirements.txt`):
  - `requests`
  - `beautifulsoup4`
  - `pandas`
  - `openpyxl`
  - `nltk` (for text processing)
  - `tkinter` (GUI toolkit)

#### Usage

1. Clone the repository:

   ```bash
   git clone https://github.com/arjunlimat/pydataharvest.git

2. Navigate to the project directory:

cd pydataharvest

3. Install the required packages:

pip install -r requirements.txt

4. Run the application:
python main.py

The GUI will appear, allowing you to choose different services and perform web scraping tasks.

Services
Web Scraping

Enter a URL and click "Search" to explore available data types.

Choose the desired data type, enter a file name, and click "Download" to save the data.

Google Reviews
Select "Google reviews" from the services dropdown.

Enter the business or location name and address.
Provide a file name and click "Download" to fetch and save Google reviews.

Yelp Reviews
Select "Yelp reviews" from the services dropdown.
Enter the business name and address.
Provide a file name and click "Download" to fetch and save Yelp reviews.

OpenStreetMap
Select "Open Street Map" from the services dropdown.
Enter the map URL, provide a file name, and click "Download" to extract map data.

Contributing
Contributions are welcome! If you encounter issues or have ideas for improvement, please open an issue or submit a pull request.

#### License:
This project is licensed under the MIT License - see the LICENSE file for details.
econometrics01 1.0.1
This is the simplest modufwle for work with files. v2
Keywords: files speedfiles

# Speed File Library #

## What is this? ##
The module allows you to work with files in just one line of code, without the need to manually open and close the file each time

## Quick Guide ##
The module is based on the following structure:

    
    f = open('data.txt')
    data = f.readlines()
    f.close()
    
Which Python provides by standard.
black-pixel-convertor 0.0.2
This library change black pixels to invisible.

# Black Pixel Convertor

This library change black pixels to invisible.  
For example, you can use it to convert satellite images.  

It will act by following sequence.

1. Load image by `pillow` 
2. Convert it to `numpy` array.
3. `patch` images
4. Traverse patches and check should change.
5. Convert alpha value in pixel. - RGB*A* 
6. `Unpatch` and change array to image. 
7. Compress and save.

## Install
```
pip install black-pixel-convertor
```
### requirements
- numpy == 1.26.4
- patchify == 0.2.3
- pillow == 10.2.0

## How to use
```markdown
from bpc import Config, Convertor

config = Config()

convertor = Convertor(path="file_located_path", out_path="image_will_save_in_this_path")

convertor.multiple_convert()
convertor.single_convert(name="original_name.png", out_name="output_name.png")
```

### Parameters
#### - config
```python
"""
Config.__init__

cpu_amount
- type: int
- default: 2 / 3 of your cpu core amount
- notice: Do not set upper than core amount.

max_range
- type: int
- default: 10
- describe: max of black pixel amount you can permit in patch.

common_param
- type: int
- default: 100
- describe: height, width, step of each patch
- notice: 
    - if `common_param` is too small, time to spend will be increase
    - furthermore `common_param`is too big, image can't convert black pixels.
    - You have to find compromise point well.
    
compress_level
- type: int
- default: 4
- describe: 
    - compress level for saving image after convert.
    - you can get more details in pillow document. 
    - https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html
- notice:
    - It is same kind of common_param. 
    - Get compromise point of you image size.
    - else is same as pillow.
    

black_pixel_level
- type: int
- default: 0
- describe: 
    - standard of black pixel.
    - pixel where each R, G, B value is smaller than black_pixel_level separate as black.

max_image_pixels
- type: int
- default: 933120000
- describe: max pixel amount of your images to convert.
- notice: Be careful about Image ddos attack.

"""
```
#### - convertor
```python
""" 
Convertor.__init__

~ `path` and `out_path` can be same

path
- type: str
- notice

out_path
- type: str
- notice


Convertor.single_convert

name
- type: str
- describe: name of the file to convert. 
- notice:
    - It can't be None!
    - You have to write extension(.png, .jpg) together!
    
out_name
- type: str
- default: `name` + `_Pad_out.png`
- describe:
    - File name of output after convert.
    - if `out_name` is None, `_Pad_out.png` will appended to name.


Convertor.multiple_convert

~ Convert all images(png, jpg) in `path` and return to `out_path`.
~ Name of output will be `filename` + `_Pad_out.png`  

"""

```
df-squeezer 0.0.12
A small package to optimize memory usage of Pandas DataFrames
Requires Python: >=3.9

# DF_Squeezer

DF_Squeezer is a Python package designed to help reduce the memory usage of pandas DataFrames. By analyzing the data
types of DataFrame columns, DF-Squeezer suggests and can automatically apply data type conversions that are more
memory-efficient without losing information.

## Features

- **Analysis of DataFrame Columns**: Identifies columns that can be converted to more memory-efficient data types.
- **Memory Usage Reporting**: Calculates and reports the potential memory savings from suggested conversions.
- **Automatic Conversion Application**: Optionally applies suggested conversions directly to the DataFrame.

## Installation

To install DF-Squeezer, run the following command in your terminal:

```sh
pip install df_squeezer
```

Ensure you have pandas installed in your environment as it is a required dependency.

## Usage

```
from df_squeezer import df_squeezer
import pandas as pd

# Sample DataFrame
df = pd.DataFrame(
    {
        "a": range(1000),
        "b": [float(i) for i in range(1000)],
        "c": ["category" + str(i % 3) for i in range(1000)],
    }
)

# Use df_squeeze to analyze and report potential dtype conversions
optimized_df = df_squeezer(df, report=True, edit=False)

# To directly apply the suggested conversions
optimized_df = df_squeezer(df, report=True, edit=True)

```

## Parameters

df (pd.DataFrame): The input DataFrame to analyze and optimize.
report (bool, optional): If True (default), prints suggested changes for data type conversions along with potential
memory savings.
edit (bool, optional): If False (default), the function only reports potential optimizations without applying them. If
True, the function applies the suggested data type conversions directly to the DataFrame.
Returns
pd.DataFrame: The original DataFrame with applied changes if edit=True. Otherwise, returns the original DataFrame
unmodified.
Contributing
Contributions to DF-Squeezer are welcome! Please refer to the contribution guidelines for more information.

License
This project is licensed under the MIT License - see the LICENSE file for details.