semvec/pypi-packages huggingface dataset:
sharehousepy 0.1.4
A python library to create and execute sharehouse queries
Requires Python: >=3.6

# sharehousepy

#### A python library to create and execute sharehouse queries

## Installation

```bash
pip install sharehousepy
```

## Usage

```python
from sharehousepy import Query, SnowflakeConnection

# Initialize a connection
sf_conn = SnowflakeConnection()

# Create a query
query = Query(query="SELECT * FROM zod_maid_default2 LIMIT 10")

# Run the query
sf_conn.run(query)

# Print the results
print(f"Results: {query.results[:10]}")
```
fsvm 0.2.0
A scikit-learn compatible Fuzzy Support Vector Machine implementation.
Requires Python: >=3.9

fsvm - A Fuzzy Support Vector Machine implementation for Python
============================================================

![tests](https://github.com/balins/fsvm/actions/workflows/python-app.yml/badge.svg)
[![codecov](https://codecov.io/gh/balins/fsvm/graph/badge.svg?token=L0XPWwoPLw)](https://codecov.io/gh/balins/fsvm)
![doc](https://github.com/balins/fsvm/actions/workflows/deploy-gh-pages.yml/badge.svg)

`fsvm.FuzzySVC` is a Python module implementing fuzzy support vector machine classifier.
Its API is fully compatible with scikit-learn.
datanorm 0.0.2a0
Handling DATANORM 4 files with Python
Requires Python: >=3.10

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![PyPI](https://img.shields.io/pypi/v/datanorm)](https://pypi.org/project/datanorm/)
![Build Status](https://github.com/FahrJo/datanorm-python/actions/workflows/ci.yml/badge.svg)
[![Coverage Status](https://coveralls.io/repos/github/FahrJo/datanorm-python/badge.svg?branch=main)](https://coveralls.io/github/FahrJo/datanorm-python?branch=main)

## Handling DATANORM 4 files with Python

This library contains a collection of classes to parse DATANORM files in Python. The library follows
[this informal specification](https://docplayer.org/115761786-Technische-spezifikationen-der-datanorm-dateien-in-haufe-lexware.html)
and is compatible with DATANORM 4 files.

## State of the library

This library is still under development and the API might still change a little bit. At the moment
it supports parsing of the following files:

- **DATANORM 4 Artikelstammdatendatei** (without `Dimensionssatz` and `Langtextsatz`)
- **DATANORM 4 Preisdatendatei**
- **DATANORM 4 Warengruppendatei**

Support for writing/updating Datanorm files is possible, but not yet implemented.

## Installation

The InvenTree python library can be easily installed using PIP:

```bash
pip install datanorm
```
gpit 0.0.4
GPT-Powered Commit Assistance

# GPiT
> Effortless Git Integration with GPT-Powered Commit Assistance

## Overview
This tool is designed to automate several common Git operations, enhancing the standard Git workflow with additional features. It helps in managing unpushed commits, checking for local changes, generating commit messages using OpenAI's GPT-4 API, editing commit messages, and handling the push operation to a remote repository.

https://github.com/ofirsteinherz/gpit/assets/29001725/e699afd0-f219-48b5-b1e9-563d5f31845a

## Features
- 🔍 **Check for Unpushed Commits**: Quickly identify any commits that haven't been pushed to the remote repository.
- 📝 **Detect Local Changes**: View a summary of local changes that are not yet committed.
- 💬 **Generate Commit Messages**: Utilizes GPT-4 to suggest commit messages based on the detected changes.
- ✏️ **Edit Commit Messages**: Offers an interactive editor for customizing commit messages.
- 🚀 **Stage, Commit, and Push**: Automates the process of staging changes, committing them with a chosen message, and pushing to the remote repository.

## Installation
GPIT can be installed directly from PyPI:

```bash
pip install gpit
```

This tool requires Python 3.x. Make sure you have Python installed on your system.

## Setting Up OpenAI API Key
Before using the tool, make sure to set your OpenAI API key as an environment variable:
```bash
export OPENAI_API_KEY='your_openai_api_key'
```
Alternatively, you can set it in a `.env` file in the same directory as the script.
The most recommended way to save the key is through "Shell Profile Files":
Open or create the .bashrc file:
```bash
nano ~/.bashrc
```
Add your export statement:
```bash
export OPENAI_API_KEY="your_openai_api_key_here"
```
Save and exit. Apply the changes:
```bash
source ~/.bashrc
```
Verifying the Variable:
```bash
echo $OPENAI_API_KEY
```

## Usage
Once installed, you can run GPIT from any Git repository on your system. Simply use the following command:

```bash
gpit
```

Follow the on-screen prompts to manage your Git operations.

## Dependencies
- Git
- Python 3.x
- Requests library for Python
- python-dotenv (for managing environment variables)

Install Python dependencies using:
```bash
pip install requests python-dotenv
```

## Contributing
Contributions to this project are welcome! Please fork the repository and submit a pull request with your proposed changes.
partitioneer 0.2.13
A library for reading and writing partitioned data
Requires Python: >=3.6

# Partitioneer

Partitioneer is a Python library that provides utilities for managing data files in a date-partitioned format. It offers functions for writing data to partitions, reading data from partitions with filtering capabilities, and retrieving partition date information.

## Installation

You can install Partitioneer using pip:

```sh
pip install partitioneer
```

## Usage

### Writing Data to Partitions

To write data to partitioned Parquet files:

```python
from partitioneer import write_data_to_partitions
import pandas as pd

df = pd.DataFrame(...)  # Your data
write_data_to_partitions(
    df,
    base_path="/path/to/data",
    date_col="date_column",
    override_existing=False
)
```

### Reading Data from Partitions

To read data from partitioned Parquet files:

```python
from partitioneer import read_data_from_partitions, PartitionFilter

df = read_data_from_partitions(
    base_path="/path/to/data",
    filters=[
        PartitionFilter("category", "in", ["A", "B"]),
        PartitionFilter("value", "greater_than", 100)
    ],
    add_partition_date=True,
    start_date="2024-01-01",
    end_date="2024-12-31"
)
```

### Getting Partition Date Information

To get the latest or first partition date:

```python
from partitioneer import get_latest_partition_date, get_first_partition_date

latest_date = get_latest_partition_date("/path/to/data")
first_date = get_first_partition_date("/path/to/data")
```

## Build Instructions

To build the package:

```sh
python setup.py sdist bdist_wheel
```

To upload to PyPI:

```sh
pip install twine
twine upload dist/*
```

Automated build and publish script:

```shell
python setup.py sdist bdist_wheel
pip install twine
twine upload dist/* --password <add_pypi_token_here>
rm -r ./build
rm -r ./dist
rm -r ./partitioneer.egg-info
```

## License

[MIT License](LICENSE)
counting-package 0.0.2
A small package that counts unique symbols you entered
Requires Python: >=3.12

# This is a program that counts the number of unique characters.

## My program accepts a string and returns a dictionary whose keys are the designations of the 
## appropriate character category, and whose values are the number of characters in the string that occur only once.

# Requirements:
* build==1.2.2
* certifi==2024.8.30
* charset-normalizer==3.3.2
* click==8.1.7
* colorama==0.4.6
* docutils==0.21.2
* hatchling==1.25.0
* idna==3.8
* importlib_metadata==8.4.0
* iniconfig==2.0.0
* jaraco.classes==3.4.0
* jaraco.context==6.0.1
* jaraco.functools==4.0.2
* keyring==25.3.0
* markdown-it-py==3.0.0
* mccabe==0.7.0
* mdurl==0.1.2
* more-itertools==10.5.0
* mypy-extensions==1.0.0
* nh3==0.2.18
* packaging==24.1
* pathspec==0.12.1
* pkginfo==1.11.1
* platformdirs==4.3.2
* pluggy==1.5.0
* pycodestyle==2.12.1
* pyflakes==3.2.0
* Pygments==2.18.0
* pyproject_hooks==1.1.0
* pytest==8.3.2
* pywin32-ctypes==0.2.3
* readme_renderer==44.0
* requests==2.32.3
* requests-toolbelt==1.0.0
* rfc3986==2.0.0
* rich==13.8.0
* trove-classifiers==2024.7.2
* twine==5.1.1
* urllib3==2.2.2
* zipp==3.20.1

# How to use it?

* print in terminal "pip install counting-package"
* if you want to use function "counting_symbols", print in terminal: python -m counting_package.counting -s "some_text"
* if you want to read file and use text in this file in function "counting_symbols", print in terminal: python -m 
* counting_package.counting  -f file_location\file_name.txt
agentweb 0.1.0
A package for developing Open Agents
Requires Python: >=3.8

# Mask-Predict


### Download model 
Description | Dataset | Model
---|---|---
MASK-PREDICT | [WMT14 English-German] | [download (.tar.bz2)](http://dl.fbaipublicfiles.com/fairseq/models/maskPredict_en_de.tar.gz)
MASK-PREDICT | [WMT14 German-English] | [download (.tar.bz2)](http://dl.fbaipublicfiles.com/fairseq/models/maskPredict_de_en.tar.gz)
MASK-PREDICT | [WMT16 English-Romanian] | [download (.tar.bz2)](http://dl.fbaipublicfiles.com/fairseq/models/maskPredict_en_ro.tar.gz)
MASK-PREDICT | [WMT16 Romanian-English] | [download (.tar.bz2)](http://dl.fbaipublicfiles.com/fairseq/models/maskPredict_ro_en.tar.gz)
MASK-PREDICT | [WMT17 English-Chinese] | [download (.tar.bz2)](http://dl.fbaipublicfiles.com/fairseq/models/maskPredict_en_zh.tar.gz)
MASK-PREDICT | [WMT17 Chinese-English] | [download (.tar.bz2)](http://dl.fbaipublicfiles.com/fairseq/models/maskPredict_zh_en.tar.gz)

### Preprocess

text=PATH_YOUR_DATA

output_dir=PATH_YOUR_OUTPUT

src=source_language

tgt=target_language

model_path=PATH_TO_MASKPREDICT_MODEL_DIR

python preprocess.py --source-lang ${src} --target-lang ${tgt} --trainpref $text/train --validpref $text/valid --testpref $text/test  --destdir ${output_dir}/data-bin  --workers 60  --srcdict ${model_path}/maskPredict_${src}_${tgt}/dict.${src}.txt --tgtdict ${model_path}/maskPredict_${src}_${tgt}/dict.${tgt}.txt

### Train


model_dir=PLACE_TO_SAVE_YOUR_MODEL

python train.py ${output_dir}/data-bin --arch bert_transformer_seq2seq --share-all-embeddings --criterion label_smoothed_length_cross_entropy --label-smoothing 0.1 --lr 5e-4 --warmup-init-lr 1e-7 --min-lr 1e-9 --lr-scheduler inverse_sqrt --warmup-updates 10000 --optimizer adam --adam-betas '(0.9, 0.999)' --adam-eps 1e-6 --task translation_self --max-tokens 8192 --weight-decay 0.01 --dropout 0.3 --encoder-layers 6 --encoder-embed-dim 512 --decoder-layers 6 --decoder-embed-dim 512  --fp16 --max-source-positions 10000 --max-target-positions 10000 --max-update 300000 --seed 0 --save-dir ${model_dir}

### Evaluation


python generate_cmlm.py ${output_dir}/data-bin  --path ${model_dir}/checkpoint_best_average.pt  --task translation_self --remove-bpe --max-sentences 20 --decoding-iterations 10  --decoding-strategy mask_predict

# License
MASK-PREDICT is CC-BY-NC 4.0.
The license applies to the pre-trained models as well.

# Citation

Please cite as:

```bibtex
@inproceedings{ghazvininejad2019MaskPredict,
  title = {Mask-Predict: Parallel Decoding of Conditional Masked Language Models},
  author = {Marjan Ghazvininejad, Omer Levy, Yinhan Liu, Luke Zettlemoyer},
  booktitle = {Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing},
  year = {2019},
}
```
ArpMitmProject 0.1
A Python library for ARP spoofing and MITM attacks.
Requires Python: >=3.6

# ArpMitmProject
created by Matan Nafgi

`ArpMitmProject` is a Python library for performing ARP spoofing and man-in-the-middle (MITM) attacks.

## Installation

You can download ArpspoofMITM by cloning the Git Repo and simply installing its requirements
```
~ ❯❯❯ sudo apt-get update && sudo apt-get install scapy

~ ❯❯❯ gh repo clone https://github.com/Nathanafgi/ArpMitmProject.git
```
## bash
```
~ ❯❯❯ pip install Arp-Mitm
```

## Usage
```
make sure that IP forwarding is enabled on your attacker machine so that packets from the victim can reach the intended destination (the target).


sudo python3 arpmitm.py <victim_ip> <target_ip> <iface>
```
#default interface will be chosen if not specified

# Disclaimer

ArpMitmProject is provided as is under the MIT Licence (as stated below). 
It is built for educational purposes *only*. If you choose to use it otherwise, the developers will not be held responsible. Please, do not use it with evil intent.
escape-abm 0.0.3
Epidemic Simulator Compiler and Programming Environment
Requires Python: >=3.11

# ESCAPE: Epidemic Simulator Compiler and Programming Environment

![A man running away from a virus](docs/escape-banner.webp "A man running away from a virus")

The *Epidemic Simulator Compiler and Programming Environment* or ESCAPE
is a framework for efficiently developing
high-performance agent based epidemic simulators.

ESCAPE uses a domain specific language
called the *Epidemic Simulator Language* or ESL,
which users have to use to define the epidemic simulations.
The ESL language provides domain specific constructs
to define compartmental disease models
and the structure of the contact networks
on top of which the disease propagate.
Additionally, ESL also includes general purpose programming constructs
&mdash; conditionals, loops, functions, variables, etc. &mdash;
and parallel constructs
&mdash; select, sample, apply, and reduce &mdash;
for describing interventions.

ESCAPE provides a compiler that converts
the epidemic simulators written in ESL into C++ or CUDA programs.
Simulators created with ESCAPE are high performance
parallel programs that run on multi-core CPU systems
or GPU based systems.
The ESCAPE compiler itself is written in Python.