semvec/pypi-packages huggingface dataset:
hll-rcon-connection-test 0.1.1
A CLI tool to test RCON connections to Hell Let Loose Servers
Requires Python: >=3.8

# hll-rcon-connection-test

A very simple CLI tool to test RCON connections to Hell Let Loose Servers

# Installation

Create and activate a [Virtual Environment](https://docs.python.org/3/library/venv.html) so you don't install this package globally.

```
pip install hll_rcon_connection_test
```

# Usage

```
python -m hll_rcon_connection_test IP:port password
```

For example:

```
❯ python -m hll_rcon_connection_test.main  127.0.0.1:26000 sOmEpassWorD
Connection/login successful
Server name: The Draft [HAUS] |US EAST-FL|
```

# Troubleshooting

If you get any sort of error messages, you are either not connected to the Internet, your game server is offline or having other network problems, or **most likely** you didn't provide the IP:port and password in the correct format, or you passed invalid credentials.
zensols.dbpg 1.4.0
PostgreSQL Implementation of the dbutil library.
Keywords: tooling

# A PostgreSQL implementation of the dbutil library

[![PyPI][pypi-badge]][pypi-link]
[![Python 3.11][python311-badge]][python311-link]

A [PostgreSQL] implementation of the [dbutil] library.


## Documentation

See the [full documentation](https://plandes.github.io/dbutilpg/index.html).
The [API reference](https://plandes.github.io/dbutilpg/api.html) is also
available.


## Obtaining

The easist way to install the command line program is via the `pip` installer:
```bash
pip3 install zensols.dbutilpg
```

Binaries are also available on [pypi].

On macOS, use `make macosdep`.


## Changelog

An extensive changelog is available [here](CHANGELOG.md).


## Community

Please star this repository and let me know how and where you use this API.
Contributions as pull requests, feedback and any input is welcome.


## License

[MIT License](LICENSE.md)

Copyright (c) 2020 - 2025 Paul Landes


<!-- links -->
[pypi]: https://pypi.org/project/zensols.dbutilpg/
[pypi-link]: https://pypi.python.org/pypi/zensols.dbpg
[pypi-badge]: https://img.shields.io/pypi/v/zensols.dbpg.svg
[python311-badge]: https://img.shields.io/badge/python-3.11-blue.svg
[python311-link]: https://www.python.org/downloads/release/python-3110

[PostgreSQL]: https://www.postgresql.org
[dbutil]: https://github.com/plandes/dbutil
utils-tesis 0.1.4
Auxiliar functions for my thesis
Requires Python: >=3.7

# utils-tesis

![GitHub Actions](https://github.com/alvarohc777/Tesis/actions/workflows/release_to_pypi.yml/badge.svg)
[![PyPI version](https://badge.fury.io/py/utils-tesis.svg)](https://badge.fury.io/py/utils-tesis)
[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)

`utils-tesis` is a Python package that provides a collection of auxiliary functions for various tasks commonly encountered in thesis and research projects. These functions are designed to streamline and simplify common operations, leveraging the power of the NumPy Stack, including NumPy, SciPy, Matplotlib, and Pandas.

## Features

- **NumPy Stack Integration**: Utilize the capabilities of NumPy, SciPy, Matplotlib, and Pandas seamlessly for efficient data manipulation, analysis, and visualization.

- **Convenience Functions**: A set of convenience functions to perform common tasks encountered in thesis and research projects, including:
  - **Loading Signals as Pandas DataFrames**: Easily load and handle signals as Pandas DataFrames for efficient data manipulation.
  - **Fault Detection using Harmonic Distortion**: Detect and analyze faults in signals by examining harmonic distortion.
  - **Signal Windowing**: Apply windowing techniques to signals for better analysis and feature extraction.
  - **Plotting**: Streamlined functions for visualizing signals and analysis results using Matplotlib.
  - **Fourier Transforms**: Perform Fourier transforms on signals to analyze frequency components.
  - **Superimposed Components Analysis**: Identify and analyze superimposed components in signals.

- **Modular Design**: Well-organized modules make it easy to find and use specific functionalities without unnecessary complexity.

## Installation

Install the package using pip:

```bash
pip install utils-tesis
```
## Usage Example

``` python
# test.py

# Import necessary modules from utils_tesis
import utils_tesis.integration as itg
from utils_tesis.signalload import CSV_pandas

# Create a dictionary to store signal information
signal_info = {}
signal_info["window_length"] = 64
signal_info["step"] = 4

# Instantiate a CSV_pandas object to load signals
signals = CSV_pandas()

# Retrieve the list of available signals
signals.relay_list()

# Assign signals to the signal_info dictionary
signal_info["signals"] = signals

# Specify the signal name for analysis
signal_info["signal_name"] = "I: X0023A-R1A"

# Perform integration using img_trip function from the itg module
t, trip = itg.img_trip(signal_info)

# Visualize the results using Matplotlib
import matplotlib.pyplot as plt

# Plot the integrated signal using stem plot
plt.stem(t, trip)
plt.title("Integrated Signal: " + signal_info["signal_name"])
plt.xlabel("Time")
plt.ylabel("Integrated Value")
plt.show()
```
Pycodz 3.6
- Simple Library with Python 3
Requires Python: >=3.6

<div align="center"> <img src="https://www2.0zz0.com/2024/12/04/20/801153888.png" alt="Pycodz" width="128"> <h1>Pycodz</h1> <b>A library for Python developers.</b> <b> <a href="https://z44o.github.io"> <br> <li> MY </li> </br> </a> </div>

<br>

<div align="center"> <a href="https://pypi.org/project/Pycodz/"> <img src="https://img.shields.io/pypi/v/tgram.svg?logo=python&logoColor=%23959DA5&label=pypi&labelColor=%23282f37" alt="PyPI"> </a> <a href="https://t.me/Pycodz"> <img src="https://img.shields.io/badge/Telegram-Channel-blue.svg?logo=telegram" alt="Telegram Channel"> </a> <a href="https://t.me/PyChTz"> <img src="https://img.shields.io/badge/Telegram-Group-blue.svg?logo=telegram" alt="Telegram Group"> </a> <a href="https://t.me/DevZ44d"> <img src="https://img.shields.io/badge/Telegram-Owner-red.svg?logo=telegram" alt="Telegram Owner"> </a> </div>


##  Installation 🚀

### Via PyPI (Recommended)
```sh
pip install Pycodz -U
```

## 🚀 Quick Start

```python
import Pycodz.ai as z44o
bot = z44o.PHIND()
request = input(" - Type Your request : ")
response = bot.chat(
    prompt = request
)
print(response)
```

- [x] [Python 3.10](https://python.org)

## 💬 Help & Support
- For general questions and help, join our **[Telegram chat](https://t.me/PyChTz)**.
- Follow updates via the **[Telegram Channel](https://t.me/PyCodz)**.
ViTables 3.1.0
A viewer for HDF5 files.
Requires Python: >=3.10
Keywords: HDF5, PyTables

<div align=center>

![](https://raw.githubusercontent.com/uvemas/ViTables/074a2597866c8f73e78c73ab5606b215ddf7951e/doc/images/title_page_plain.svg)


![Platform](https://anaconda.org/conda-forge/vitables/badges/platforms.svg) ![License](https://anaconda.org/conda-forge/vitables/badges/license.svg)

![Conda](https://anaconda.org/conda-forge/vitables/badges/version.svg) ![Conda_downloads](https://anaconda.org/conda-forge/vitables/badges/downloads.svg) ![PyPI](https://img.shields.io/pypi/v/vitables) ![PyPI_Downloads](https://static.pepy.tech/badge/vitables/month)

</div>

# ViTables

ViTables is a component of the PyTables family. It is a GUI for browsing and editing files in both PyTables and HDF5 formats. It is developed using Python and PyQt (the Python bindings to Qt), so it can run on any platform that supports these components.

ViTables capabilities include easy navigation through the data hierarchy, displaying of real data and its associated metadata, a simple, yet powerful, browsing of multidimensional data and much more.

<div align=center>

![](https://github.com/uvemas/ViTables/blob/master/doc/images/mainWindow.png?raw=true)

</div>

As a viewer, one of the greatest strengths of ViTables is its ability to display very large datasets. Tables with one thousand millions of rows (and beyond) are navigated stunningly fast and with very low memory requirements. So, if you ever need to browse huge tables, don't hesitate, ViTables is your choice.

If you need a customized browser for managing your HDF5 data, ViTables is an excellent starting point.

Here are some [screenshots](https://github.com/uvemas/ViTables/tree/master/doc/images).

## QuickStart

### System requirements

ViTables 3.1.0 has been tested against the latest versions of Python 3,
PyTables and PyQt. You can try other versions at your own risk :).

### Install through pip (may need further manually debug)

```sh
$ pip install ViTables
```

If you don't have PyQt installed you can install it as an extra as follows:

```sh
$ pip install 'ViTables[PyQt6]'
```

### Install on a conda environment

Using conda you should be able to run vitables on any system, let it
be linux, mac or windows. The following are instructions for linux-like
systems.

Simply run

```sh
$ conda install -c conda-forge vitables
```

For more details, see [INSTALL.txt](https://github.com/uvemas/ViTables/blob/master/INSTALL.txt).

### Launch

```sh
$ vitables [/path/to/hdf5/file]
```

If `/path/to/hdf5/file` is given, vitables will load that file, otherwise, you need to select a file to open later.
rq-mr 0.2.0
MapReduce technique over RQ
Requires Python: >=3.11

Implementation of map-reduce over RQ (Redis Queue)

The following environment variables can be set:
* `MAX_QUEUED_JOBS` (default=10) : Maximum number of jobs that can be queued at a time
* `WAIT_TIME` (default=1): Time in seconds between polling for status of jobs
BasicAlgorithmsPyLib 0.0.1
The "BasicAlgorithmsPyLib" library this is a cozy place for the most common algorithms.
Requires Python: >=3.6
Keywords: python algorithms algorithms-library first-library sorting searching data-structures

# Library of Basic Algorithms <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="MIT-License image"></a>

This repository contains a small library called `BasicAlgorithms`, a collection of basic algorithms implemented in Python. The 'BasicAlgorithms` library this is a cozy place for the most common algorithms.

## Enabled Algorithms

Currently, the library includes implementations of the following algorithms:

- Sorting:
- Bubble Sort
- Insertion Sort
    - Selection Sort
- Merge Sort
- Quick Sort
- Search:
- Linear Search
- Binary Search
- Mathematical algorithms:
    - Factorial
    - The Fibonacci number of the index
- Other algorithms:
    - Search for min and max 

## Usage

To use algorithms in your Python projects, you can:

1. Clone the repository.


## Contribution

Any contributions are welcome! If you have an implementation of another algorithm or would like to improve the existing ones, please follow these steps.:

1. Make a fork of the repository.
2. Create a new branch for your feature or bug fix.
3. Implement your changes.
4. Make sure that your code is well documented and includes tests.
5. Send a pull request.

## License

This project is licensed under the [MIT LICENSE].

## Author

MindlessMuse666 (https://github.com/MindlessMuse666)
convert-to-confluence 1.0.1
A Python package to convert Markdown to Confluence format.
Requires Python: >=3.6

# Convert to Confluence Wiki Formate

## Overview

The `convert_to_confluence_wiki` package is a utility for converting Markdown text into a format compatible with Atlassian Confluence. It handles the transformation of various Markdown elements into their Confluence equivalents, making it easier to migrate or integrate content into Confluence pages.

## Features

- Converts headers (`#`, `##`, etc.) into Confluence headers and panels.
- Transforms code blocks and inline code into Confluence code macros.
- Processes nested and numbered lists for proper indentation and syntax.
- Converts bold, italic, and strikethrough text.
- Replaces Markdown-style links and images with Confluence-compatible formats.
- Handles tables, blockquotes, and horizontal rules.
- Provides support for Confluence-specific macros like notes and warnings.
- Ensures clean and well-structured formatting by removing unnecessary empty lines.

## Requirements

- Python 3.6+

## Usage

1. Place the `convert_to_confluence.py` script in your project directory.
2. Import the `markdown_to_confluence` function into your Python script:

```python
from .convert_to_confluence import MarkdownToConfluenceConverter
```

3. Pass your Markdown text to the function:

```python
markdown_text = """
# Sample Header

This is a **bold text** and this is _italic text_.

- Item 1
  - Sub-item 1.1

```python
print("Hello, World!")
# add stoping statement also(i.e. ```)

"""

converter = MarkdownToConfluenceConverter(markdown_text)
confluence_text = converter.convert()
print(confluence_text)
```

4. The output will be formatted for Confluence.

## Example Output

Input Markdown:

```markdown
# Header 1

This is **bold** and _italic_ text.

- Item 1
  - Sub-item 1.1

#Added as comment for readme ```
python
print("Hello, World!")
#Added as comment for readme ```

![Alt Text](image.png)
```

Converted Confluence Markup:

```
h1. Header 1

This is *bold* and _italic_ text.

* Item 1
** Sub-item 1.1

{code:language=python|theme=Midnight}
print("Hello, World!")
{code}

!image.png|alt=Alt Text!
```


## Limitations

- Custom Markdown extensions or non-standard syntax may not be fully supported.
- The script assumes well-formed Markdown input; malformed Markdown may lead to unexpected results.

## License

This script is open-source and can be modified as needed for personal or commercial use.

## Contributing

Contributions are welcome! Feel free to submit pull requests or open issues for bugs or feature requests.

## Contact
Email: aryamangurjar6@gmail.com

Github: https://github.com/AryamanGurjar

Linkedin: https://www.linkedin.com/in/aryaman-gurjar-251ab2201/