semvec/pypi-packages huggingface dataset:
haxagongrades 1.0.0a1
Haxagon Grades CLI is a command-line tool designed to manage and generate reports for Haxagon classes. The tool allows you to fetch and export class reports in different formats.
Requires Python: <4.0,>=3.11

# Hexagon Grades



Haxagon Grades CLI is a command-line tool designed to manage and generate reports for Haxagon classes. The tool allows you to fetch and export class reports in different formats.

## Features

- Generate class reports in CSV or JSON format.
- Specify output directory for the generated reports.
- Supports headless mode for automated environments.

## Installation

Install the CLI using `pipx` to keep it isolated from your system Python packages:

```bash
pipx install haxagongrades
```

Make sure you have `pipx` installed. If not, you can install it via pip:

```bash
pip install pipx
pipx ensurepath
```

## Usage

After installing, you can use the `haxagongrades` command to interact with the CLI.

### Commands

#### `report`

Generate a report for a specific class.

```bash
haxagongrades report <class_name> [OPTIONS]
```

##### Options

- `-f, --format [csv|json]` (Required): Choose the output format.
- `-o, --output PATH`: The path to the output folder (default is `/tmp`).
- `-l, --login TEXT`: The username to login with.
- `-p, --password TEXT`: The password to login with.
- `--headless`: Run in headless mode (default is `False`).

### Examples

Generate a report in CSV format for class `3.A` and save it to the `/reports` directory:

```bash
haxagongrades report "3.A" --format csv --output /reports
```

Generate a JSON report for class `3.A` using headless mode:

```bash
haxagongrades report "3.A" --format json --headless
```

## Development

To contribute to this project, clone the repository and install the dependencies:

```bash
git clone https://github.com/yourusername/haxagon-grades-cli.git
cd haxagon-grades-cli
pip install -e .
```

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
cocorf 0.1
Comment-based codebase refining framework

# Code for "Unsupervised and Supervised Co-learning for Codebase Mining and its Application in Code Search"
This repo contains the source code introduced in our paper. 

# Comment-based Codebase Refining (COCORF)

``COCORF`` is a Python3 library for filtering query-appropriate text to build high-quality code search datasets.
It consists of two filters: a rule-based filer and a model-based filter (Pytorch required).
Currently, ``COCORF`` should be used with GPU-enabled Pytorch.

## Installation
We have uploaded ``COCORF`` to Python Package Index (PyPi) and you can install it by the following command:
```
pip install cocorf
```

You can also clone this repo and install directly with the following command:

```
pip install -r requirements.txt
python setup.py install
```

Besides, ``COCORF`` should be used with GPU-enabled Pytorch. You can refer to https://pytorch.org/get-started/locally/ to install Pytorch. Pytorch 1.3 is required (Pytorch 1.3 does not support Python 3.8+).
ibis-python-package 0.0.1
A small example package for the python codeartifact
Requires Python: >=3.8

# Example Package

This is a simple example package. You can use
[GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
to write your content.

aws codeartifact login --tool pip --repository ibis-python-library --domain nus-cee --domain-owner 057053473890 --region ap-southeast-1
search-engines-kit 1.0
Search Engines Scraper
Keywords: search, browsers

\n# search_engines  
A Python library that queries Google, Bing, Yahoo and other search engines and collects the results from multiple search engine results pages.  
Please note that web-scraping may be against the TOS of some search engines, and may result in a temporary ban.

## Supported search engines  

_[Google](https://www.google.com)_  
_[Bing](https://www.bing.com)_  
_[Yahoo](https://search.yahoo.com)_  
_[Duckduckgo](https://duckduckgo.com)_  
_[Startpage](https://www.startpage.com)_  
_[Aol](https://search.aol.com)_  
_[Dogpile](https://www.dogpile.com)_  
_[Ask](https://uk.ask.com)_  
_[Mojeek](https://www.mojeek.com)_  
_[Brave](https://search.brave.com/)_  
_[Torch](http://xmh57jrzrnw6insl.onion/4a1f6b371c/search.cgi)_  

## Features  

 - Creates output files (html, csv, json).  
 - Supports search filters (url, title, text).  
 - HTTP and SOCKS proxy support.  
 - Collects dark web links with Torch.  
 - Easy to add new search engines. You can add a new engine by creating a new class in `search_engines/engines/` and add it to the  `search_engines_dict` dictionary in `search_engines/engines/__init__.py`. The new class should subclass `SearchEngine`, and override the following methods: `_selectors`, `_first_page`, `_next_page`. 
 - Python2 - Python3 compatible.  

## Requirements  

_Python 2.7 - 3.x_ with  
_[Requests](http://docs.python-requests.org/en/master/)_ and  
_[BeautifulSoup](https://www.crummy.com/software/BeautifulSoup/bs4/doc/)_  

## Installation  

Run the setup file: `$ python setup.py install`.  
Done!  

## Usage  

As a library:  

```
from search_engines import Google

engine = Google()
results = engine.search("my query")
links = results.links()

print(links)
```

As a CLI script:  

```  
$ python search_engines_cli.py -e google,bing -q "my query" -o json,print
```

## Other versions  

 - [async-search-scraper](https://github.com/soxoj/async-search-scraper) A really cool asynchronous implementation, written by @soxoj
gautomator 0.1.0
Automation framework developed by Dale
Requires Python: >=3.10

# [QA-QC] Gautomator Guideline
########################

## Unittest
```shell
behave
```

### Definition
```python
api_obj = APIFactory.generate_data(api_name='Service_Liveness').generate
```

The `api_obj` will have the content of 
```python
{
    'endpoint': str ,
    'content_type': str,
    'method': str,
    'request': RequestObj(),
    'response': ResponseObj()
}
```

### Usage

```python
from gautomator.cores.utils.common import ObjectSetupUtil
from gautomator.cores.factory.swagger_factory import APIFactory, APIConfiguration

class TestAPI(APIConfiguration):
    operation_id = 'Test_API' # the operation_id of the api , this info is listed in the swagger.json file

    def __init__(self, token=None):
        super().__init__()
        self.api_obj = self.factory_api.generate_data(api_name=self.operation_id).generate

    def test(self, **kwargs):
        body = ObjectSetupUtil.setup_object(self.api_obj.request, **kwargs)
        params = RequestFactory.create_request(request_type=self.api_obj.method, body=body, token=self._token)
        return RequestUtil.request(url=, data=params)
        
```
PyMeow 1.0.1
A simple python wrapper for using API of https://thecatapi.com/
Requires Python: >=3.7

# PyMeow
The simple way to get cats 🐱
## About

This is a simple python wrapper for using API of https://thecatapi.com/.
By this module you can get images of cats🐱 or information of their breeds.
You can see examples in the [examples folder](https://github.com/funnyruler/pymeow/tree/main/examples).
All entities are represented as dataclasses.
API have more than 60k images, breeds and facts about cats.
I recommend to [sign up](https://thecatapi.com/#pricing) and get API key, its free and this removes most of the restrictions and limits.



## Development
`pymeow` is being actively developed, and new API changes should arrive on `pymeow` very quickly. `pymeow` uses `requests` and `dataclasses` as models for its methods.
In the future, I will add `async` version of this wrapper.


## Installation
[PyPi page](https://pypi.org/project/PyMeow/)
`pymeow` requires python 3.7 or higher. This module can be installed by pip:
```
pip install pymeow
```

## Usage
```python
from pymeow import Client


client = Client(api_key='your_api_key')
random_cat = client.get_cat(has_breeds=True)  # get random cat with breads(requires api key)

print(random_cat)
# >>> Cat(image_info=CatPic(id='fsEMVl7f5', url='https://cdn2.thecatapi.com/images/fsEMVl7f5.jpg', width=1080, height=1080), breed_info=Breed(weight={'imperial': '8 - 20', 'metric': '4 - 9'}, id='raga', name='Ragamuffin', cfa_url='http://cfa.org/Breeds/BreedsKthruR/Ragamuffin.aspx', vetstreet_url='http://www.vetstreet.com/cats/ragamuffin', vcahospitals_url='https://vcahospitals.com/know-your-pet/cat-breeds/ragamuffin', temperament='Affectionate, Friendly, Gentle, Calm', origin='United States', country_codes='US', country_code='US', description='The Ragamuffin is calm, even tempered and gets along well with all family members. Changes in routine generally do not upset her. She is an ideal companion for those in apartments, and with children due to her patient nature.', life_span='12 - 16', indoor=0, lap=1, alt_names='', adaptability=5, affection_level=5, child_friendly=4, dog_friendly=5, energy_level=3, grooming=3, health_issues=3, intelligence=5, shedding_level=3, social_needs=3, stranger_friendly=5, vocalisation=1, experimental=0, hairless=0, natural=0, rare=0, rex=0, suppressed_tail=0, short_legs=0, wikipedia_url='https://en.wikipedia.org/wiki/Ragamuffin_cat', hypoallergenic=0, reference_image_id='SMuZx-bFM'))
```
historical-binance 0.1.7.8
A very fast downloader for Binance historical data
Requires Python: >=3.6

# A very simple fast fetcher for Binance historical market data.

#### By using a combination of historical CSV files and API calls this tiny library can avoid rate limits and fetch data significantly faster than alternatives that fetch just from the API.

here is a benchmark for you :)

| Downloaded tickers                                                                       | Time range        | **HistoricalBinance** | **Freqtrade** |
|------------------------------------------------------------------------------------------|-------------------|-----------------------|---------------|
| BTC/USDT:USDT, ETH/USDT:USDT                                                             | 20230201-20240315 | 5.139s                | 5min 11.78s   |
| BTC/USDT:USDT, ETH/USDT:USDT, OP/USDT:USDT, FET/USDT:USDT, SOL/USDT:USDT, RUNE/USDT:USDT | 20230201-20240315 | 9.68s                 | 14min 28.22s  |

### Usage
##### The library includes two classes - BinanceDataDownloader and BinanceDataDownloader

BinanceDataDownloader is a very simple class that just fetches the available tickers to download and upon requesting the `download_one_ticker(ticker, start_date, end_date, timeframe)` function will return a **polars** dataframe requested. If necessary it can be easily converted to pandas.

```
 downloader = BinanceDataDownloader()
 data = await downloader.download_one_ticker("BTCUSDT", datetime(2020, 1, 1), datetime(2024, 3, 10), "1d")
```

BinanceDataProvider is served as an example of how to effectively use the library - caching and asynchronously fetching multiple tickers.

Here is an example of how to use BinanceDataProvider:

```
from binance_data import BinanceDataProvider 
 
async def binance_data_provider_example(self):
    provider = BinanceDataProvider(["ETH/USDT:USDT", "BTC/USDT:USDT", "FET/USDT:USDT", "RUNE/USDT:USDT", "SOL/USDT:USDT", "OP/USDT:USDT"], ["1m"])
    await provider.update_tickers_async(["ETH/USDT:USDT", "BTC/USDT:USDT", "FET/USDT:USDT", "RUNE/USDT:USDT", "SOL/USDT:USDT", "OP/USDT:USDT"], ["1m"], datetime(2023, 2, 1))
    print(provider.cached_dataframes["1m"]["ETHUSDT"])
```
This will print out a **polars** dataframe with columns 
`'date', 'open', 'high', 'low', 'close', 'volume',
                           'count', 'taker_buy_volume'`, however if you wish you can modify the code to keep the 'ignore', 'taker_buy_quote_volume' and 'quote_volume' fetched from Binance.
gpuled 1.0.0
use led to show GPU temp
Requires Python: >=3.6

# gpuled
gpu And led

# use 
ライブラリ pynvml と pyfirmata を利用する
GPU の情報を即時的に取得する
温度が高すぎるとき警告を出す
GPU の温度に応じて LED の点滅頻度を調整する
eget-py 1.3.4
zyedidia/eget wrapper for python
Requires Python: >=3.8
Keywords: eget, github

# eget-py

A library that wraps the go package [eget](https://github.com/zyedidia/eget) in python.

See the original repository for usage: <https://github.com/zyedidia/eget>


## Install

```sh
pip install eget-py
```
balsamic 0.2.94
Send malicious pickles via requests or sockets
Keywords: python, hack, pickle, serialization, security, sockets, web


# Balsamic  
balsamic is a library for sending malicious pickles to a vunlerable application, via web requests, or a malicious server or client(currently ipv4 only).  
we will add more payloads but for now we just execute shell commands. via the oscmd payload.  
![image](https://github.com/malectricasoftware/balsamic/assets/107813117/c9e8138c-9f8f-4d68-b71c-331cf7a42343)

## useage (standalone)  
web request mode  
```
usage: balsamic.py webreq [-h] [-m METHOD] -u URL [-p PARAMETER] [-co COOKIE] -P PAYLOAD
                          [-c COMMAND] [-H HEADERS]

options:
  -h, --help            show this help message and exit
  -m METHOD, --method METHOD
  -u URL, --url URL
  -p PARAMETER, --parameter PARAMETER
  -co COOKIE, --cookie COOKIE
  -P PAYLOAD, --payload PAYLOAD
  -c COMMAND, --command COMMAND
  -H HEADERS, --headers HEADERS

```
socksend mode  
```
usage: balsamic.py socksend [-h] -rh RHOST -rp RPORT -P PAYLOAD [-c COMMAND] [-s STEPS] [-e]
                            [--ipv6]

options:
  -h, --help            show this help message and exit
  -rh RHOST, --rhost RHOST
  -rp RPORT, --rport RPORT
  -P PAYLOAD, --payload PAYLOAD
  -c COMMAND, --command COMMAND
  -s STEPS, --steps STEPS
  -e, --encode
  --ipv6                Use IPv6
```
socklisten mode
```
usage: balsamic.py socklisten [-h] -lp LPORT -P PAYLOAD [-c COMMAND] [-s STEPS] [-e] [--ipv6]

options:
  -h, --help            show this help message and exit
  -lp LPORT, --lport LPORT
  -P PAYLOAD, --payload PAYLOAD
  -c COMMAND, --command COMMAND
  -s STEPS, --steps STEPS
  -e, --encode
  --ipv6                Use IPv6
```

## useage (library)
```
from balsamic import balsamic
balsamic.utility.command="command"
balsamic.webreq("method", "url", "payload", "param", "cookie", custom_headers)
balsamic.socksend("rhost", rport, "payload", enc, steps, use_ipv6)
balsamic.socklisten(lport, "payload", enc, steps, use_ipv6)
```
massiprecon 0.0.14
Generate csv or jsons with ip info
Keywords: python, hack, osint, recon, data, api, ip


# massiprecon    
Given a list of ips massiprecon will find location and provider info etc and write them to a csv or json


## useage (standalone)  
```
usage: py -m massiprecon -i INFILE -o OUTFILE

massiprecon args

options:
  -h, --help            show this help message and exit
  -i INFILE, --infile INFILE
                        list of ips
  -o OUTFILE, --outfile OUTFILE
                        json or csv file to write to
```


## useage (library)
```
from massiprecon import massiprecon
f=massiprecon.FileMaker(args.infile,args.outfile)
print(f.generate())
```
flask-gun 1.0.0
Flask Gun is a web framework for building APIs with Flask and Python 3.10+ type hints.
Requires Python: <4.0,>=3.10

# Flask Gun

![build](https://github.com/kiwicom/flask-ninja/workflows/Build%20jobs/badge.svg)
![python](https://img.shields.io/badge/Python-3.9%20|%203.10-blue)

**Flask Gun** is a web framework for building APIs with Flask and Python 3.9+ type hints.

**Derived from Flask ninja 1.3.0 fork**

Key features:

- Easy: Designed to be easy to use and intuitive.
- Fast to code: Type hints and automatic docs lets you focus only on business logic.
- Standards-based: Based on the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema.
- Models based: Pydantic models support and automatic (de)serialization of requests/responses.
- Secure: Natively supports various authentication methods for the requests.

For mode details, see the [Documentation](https://flask-ninja.readthedocs.io/en/latest/)

## Installation

```
pip install flask-gun
```

## Usage

In your flask project where you create flask app:

```Python
from flask import Flask
from flask_gun import GunAPI
from pydantic import BaseModel

app = Flask(__name__)
api = GunAPI(app)

class Response(BaseModel):
    """Response model containing results of various number operations."""
    sum: int
    difference: int
    product: int
    power: int

@api.get("/compute")
def compute(a: int, b: int) -> Response:
    """Computes results of various number operations.

    This endpoint returns a result of the following operations:
    - sum
    - difference
    - product
    - power

    :param int a: First number
    :param int b: Second number number
    """
    return Response(
        sum=a + b,
        difference=a - b,
        product=a * b,
        power=a ** b
    )

if __name__ == "__main__":
    app.run()
```

**That's it !**

Now you've just created an API that:

- receives an HTTP GET request at `/compute`
- takes, validates and type-casts GET parameters `a` and `b`
- validates the returned Response object and serializes it into JSON
- generates an OpenAPI schema for defined operation

### Interactive API docs

Now go to <a href="http://127.0.0.1:8000/docs" target="_blank">http://127.0.0.1:5000/docs</a>

You will see the automatic interactive API documentation (provided by <a href="https://github.com/swagger-api/swagger-ui" target="_blank">Swagger UI</a>):