semvec/pypi-packages huggingface dataset:
repo-reader 0.0.1
A package for reading GitHub repos and converting them for LLM processing
Requires Python: >=3.6

# Repo Reader

Repo Reader is a Python package that allows you to read GitHub repositories and convert them into a format that can be easily processed by a long context Language Model (LLM). It provides functionality to count files, map directory structures, join files, and count tokens.

## Installation

You can install Repo Reader using pip:

pip install repo_reader

## Usage

Here's an example of how to use Repo Reader:

```python
from repo_reader.file_counter import count_files
from repo_reader.directory_mapper import map_directory_structure
from repo_reader.file_joiner import join_files, join_text_files
from repo_reader.token_counter import count_tokens

# Count files in a directory
folder_path = '/path/to/github/repo/folder'
count_files(folder_path)

# Map directory structure
directory_path = '/path/to/directory'
output_file = 'repo_directory_structure.txt'
map_directory_structure(directory_path, file_handler=open(output_file, 'w'))

# Join files in a directory
directory_path = '/path/to/directory'
output_file = 'joined_files.txt'
excluded_extensions = ['.png', '.jpg', '.git']
ignored_folders = ['/path/to/ignored/folder']
encoding_name = 'cl100k_base'
join_files(directory_path, output_file, excluded_extensions, ignored_folders, encoding_name)

# Count tokens in a file
file_path = 'path/to/your/file.txt'
encoding_name = 'cl100k_base'
total_tokens = count_tokens(file_path, encoding_name)

# Join text files
input_files = ['file1.txt', 'file2.txt']
output_file = 'joined_files.txt'
join_text_files(input_files, output_file)
```

Functions
count_files(folder_path)
Counts the number of files and file types in a given folder.

map_directory_structure(directory, level=0, include_hidden=False, include_git=False, file_handler=None)
Maps out the structure of folders and files in a directory. Optionally includes hidden files and the .git folder.

join_files(directory, output_file, excluded_extensions, ignored_folders, encoding_name)
Joins the files in a directory into a single file, excluding specified file extensions and folders. Counts the number of tokens in each file.

count_tokens(file_path, encoding_name)
Counts the number of tokens in a text file using the specified encoding.

join_text_files(input_files, output_file)
Joins multiple text files into a single file.

Contributing
Contributions are welcome! If you find any issues or have suggestions for improvement, please open an issue or submit a pull request on the GitHub repository.

License
This project is licensed under the MIT License.
machine-code-python-sdk 1.13.0
MachineCode SDK for Vention hardware
Requires Python: >=3.6

# machine-code-python-sdk

Provides a programmatic interface in Python to talk to Vention hardware, as well as a generic state machine for coordinating your programs.

## Table of Contents

1. [Requirements](#requirements)
1. [Development](#development)
1. [Documentation](#documentation)
1. [Resources](#resources)

## Requirements

Python 3.9.2  
Higher versions of python work, but 3.9.2 is shipped on the MachineMotion.

### Installing Python

You can install python 3.9 on Ubuntu via `sudo apt install python3.9`  
Check your python version via `python3 --version`  
If you already had a python version installed, you'll need to map `python3` to the 3.9 version that you installed.

```sh
cd /usr/bin
sudo link python3
sudo ln -s /usr/bin/python3.9 python3
```

Then you'll need these in order to set up a venv

```sh
sudo apt-get install python3-apt python3-virtualenv python3.9-venv
```

## Development

Always work inside a python `venv` so that your dependencies do not get interfered with:

```sh
python3 -m venv venv
source venv/bin/activate
```

You will need to upgrade pip before continuing

```sh
pip install --upgrade pip
```

Then install package:

```sh
pip install machine-code-python-sdk
```

## Documentation
- [Documentation](https://vention.io/resources/guides/machinelogic-python-programming-514)

## Resources
- [Miros](https://aleph2c.github.io/miros/html/#) is the framework upon which our architecture is based
autoDATA-prep 1.5.0
Data pre-processing library

autoDATA-prep automates the data pre-processing step, this accelerates the first stage of any Data Analysis/ Data Science/ML pipeline.


- Removing Missing Values.
- Converting Categorical Variables to Quantitative Variables.
- Normalizing Data as an Option.
- Applying Standardization Techniques to Image Data for Computer Vision.
- Applications ; General Data Science Projects, ML, Computer Vision, Natural Language Understanding ;  Processing and Generation (NLP & NLG), Signal Processing
islabtech-upw-sensor-v1 0.1.5
Python client for the ISLabTech UPW sensor
Requires Python: >=3.7

# Python Remote for ISLabTech UPW Sensor

Python client library to communicate with the [ISLabTech UPW Sensor](https://gitlab.com/islabtech/upw-sensor)

## Setup

1. install the Python package:

```sh
pip install islabtech-upw-sensor-v1
```

2. connect the sensor and your computer to the same network, e.g. via WiFi or Ethernet
3. read the IP address from the display of the sensor
4. run this example snippet:

```python
import islabtech_upw_sensor_v1 as upw
from time import sleep

sensor = upw.Device.connect_via_network("192.168.x.x") # insert sensor IP address
while True:
    print(sensor.latest_measurement())
    sleep(1)
```

## Examples

Examples are in the [examples](https://gitlab.com/islabtech/upw-sensor/remote-python/-/tree/main/islabtech_upw_sensor_v1/examples) directory. Try out the [Getting Started](https://gitlab.com/islabtech/upw-sensor/remote-python/-/blob/main/islabtech_upw_sensor_v1/examples/0100%20getting%20started.ipynb) example.

## License

This project is licensed under the [Apache 2 license](https://www.apache.org/licenses/LICENSE-2.0).
md-lab-tools 2024.5.0
Basic molecular dynamics tools
Requires Python: >=3.8

# lab-tools

This is a collection of tools for daily work in the lab. The main goal is to automate some boring tasks and make the work
with molecular dynamics simulations more efficient.

# Install

Just run

```shell
pip3 install git+https://github.com/jkrajniak/lab-tools.git
```

The main entry to the tools is `md_tools`, just type

```shell
md_tools --help
```

Content
==========

 - `scripts` - some more or less usefull scripts for daily work with HPC cluster, VOTCA or LaTeX ;-)
 - `examples` - some examples of input files
django-discord-integration 1.2.8
Discord integration for Django, supporting error reporting via webhooks.

# Django Discord Integration

Discord integration for Django, supporting error reporting via webhooks.

This app comes with two message handlers: `DiscordMessageHandler` and `SimpleDiscordMessageHandler`. `DiscordMessageHandler` sends all the information related to the message, such as a traceback if there is one, while the `SimpleDiscordMessageHandler` only sends the title.

## Installation
```bash
$ pip install django-discord-integration
```

In your `settings.py`, add the following:
```python
INSTALLED_APPS = (
    'discord_integration',
    ...
)
```

Next, migrate the database:
```
$ python manage.py migrate
```

Finally, create a Discord integration object in the Django admin site. Set the Discord webhook URL as well as the bot username and avatar URL if necessary. You can create multiple objects to direct different logs to different channels. The default object should the name `default`.


## Sample Logging Configuration

```python
LOGGING = {
    'handlers': {
        'discord_integration': {
            'level': 'ERROR',
            'class': 'discord_integration.log.DiscordMessageHandler',
            'model_name': 'default',  # OPTIONAL: specify a name to use a different integration configuration.
        },
    },
    'loggers': {
        'handlers': ['discord_integration'],
    },
}
```