semvec/pypi-packages huggingface dataset:
pystardict 0.9
Library for manipulating StarDict dictionaries from within Python

pystardict [![Build Status](https://travis-ci.org/lig/pystardict.svg?branch=master)](https://travis-ci.org/lig/pystardict)
==========

Home page
---------

<https://github.com/lig/pystardict>

Authors
-------

Serge Matveenko <s@matveenko.ru> and contributors: <https://github.com/lig/pystardict/graphs/contributors>.

Installation
------------

```shell
pip install pystardict
```

How to use
----------

For working example look into `examples` directory at the `demo.py` file.
Examples are installed in the `/local/prefix/share/pystardict` directory, where
`/local/prefix` is your installation prefix.

How to contribute
-----------------

Fill free to report any bugs or send pull requests on Github: <https://github.com/lig/pystardict>.

Respect PEP8.
gitrole 0.1.0
Switch between Git configurations based on role.
Requires Python: <3.15,>=3.11
Keywords: git

# GitRole

[![Build](https://github.com/qqfunc/gitrole/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/qqfunc/gitrole/actions/workflows/build.yml)

Switch between Git configurations based on role.
md2Slack 0.1.3.2
Convert Markdown to Slack-friendly format.
Requires Python: >=3.6

# MD2Slack - Markdown to Slack Converter

![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)  
![Build Status](https://github.com/MayzTex/MD2Slack/actions/workflows/ci.yml/badge.svg)
![PyPI version](https://img.shields.io/pypi/v/md2slack)  
![Python](https://img.shields.io/badge/python-3.6%2B-blue)  

MD2Slack is a Python package that converts **Markdown** into **Slack-compatible formatting**.  
Easily transform Markdown syntax into a format that works seamlessly in Slack messages, preserving formatting like **bold, italics, headers, lists, tables, and code blocks**.  

---

## Features
- Converts standard **Markdown** syntax to **Slack-formatted** text  
- Supports **headers, lists, blockquotes, code blocks, and tables**  
- Handles **inline styles** (bold, italics, strikethrough, and links)  
- Preserves **Slack-specific mentions** (`@user`, `#channel`)  
- Lightweight and efficient  

---

## Installation

You can install MD2Slack via pip:

```bash
pip install md2slack
```

---

## Usage

### Basic Example
Convert Markdown text into Slack-formatted output:

```python
from md2slack import SlackMarkdown

parser = SlackMarkdown()
slack_text = parser("## Hello *world*")
print(slack_text)  # Outputs: *Hello _world_*
```
---

## Development & Contribution

I welcome contributions! Follow these steps to contribute:

1. **Fork** the repository  
2. **Clone** your fork locally  
   ```bash
   git clone https://github.com/MayzTex/md2slack.git
   cd md2slack
   ```
3. **Create a new branch**  
   ```bash
   git checkout -b feature-branch
   ```
4. **Make changes & commit**  
   ```bash
   git add .
   git commit -m "Added new feature"
   ```
5. **Push & open a Pull Request**  
   ```bash
   git push origin feature-branch
   ```

---

## Running Tests

To run tests locally:

```bash
pytest
```

---

## License

MD2Slack is licensed under the **MIT License**. See the [LICENSE](LICENSE) file for details.

---

## Support & Feedback

If you find this project useful, consider starring it on GitHub.  
For issues or feature requests, please open an [issue](https://github.com/MayzTex/md2slack/issues).
hdf5maker 2025.10.29
Eiger raw file to hdf5 converter
Requires Python: >=3.9

# hdfmaker

Python package to convert PSI Eiger raw files to hdf5 with Bitshuffle+LZ4. 


## Command line tool

```bash
#Usage
raw2hdf5 /path/to/run_master_0.raw /output/path/

raw2hdf5 -h #show usage

```

## Python API

*WIP*

## Data processing


## Limitations 

The software assumes that files are written with padding in the receiver such that each frame is header+data and no size variation due to packet loss. 

### Image size

The tool reads raw files from disk and uses row, col information in the frame header in combination with the master fileto figure out the image size.  

### Gap pixels

* Inter module gaps are by default set to 0, and marked as true in the pixel mask. 

* Large pixels on the chip borders are split in two (or four) with the counts split between pixels. In the case of an odd number of counts the extra count is randomly assigned to on of the pixels. 

### File format

* Nexus like hdf5 with Bitshuffle + LZ4
* Readable with Albula 4.x

**Master file**

The master holds in addition to the pixel mask only links to the data files 

```
HDF5 "test1_0000.h5" {
FILE_CONTENTS {
 group      /
 group      /entry
 group      /entry/data
 ext link   /entry/data/data_000001 -> test/test1_0000_000000.h5 entry/data/data
 group      /entry/instrument
 group      /entry/instrument/data
 group      /entry/instrument/detector
 group      /entry/instrument/detector/detectorSpecific
 dataset    /entry/instrument/detector/detectorSpecific/pixel_mask
 }
}
```

**Data file**

```
HDF5 "test1_0000_000000.h5" {
FILE_CONTENTS {
 group      /
 group      /entry
 group      /entry/data
 dataset    /entry/data/data
 }
}

```

## Dependencies

## Compatibility

We aim to follow NEP 29 regarding supported Python and Numpy versions https://numpy.org/neps/nep-0029-deprecation_policy.html#nep29

At the moment this means:
* Python 3.9-3.11
* Numpy 1.22-1.24
ptyx-mcq 31.0.0
pTyX-MCQ is a generator/scanner of MCQ, based on pTyX.
Requires Python: >=3.10
Keywords: exam, latex, mcq, pdf, python, student, tikz

pTyX MCQ Extension
==================

MCQ generation (PDF files) and automatic marking of scanned students answers.

Overview
--------
pTyX is a LaTeX precompiler, written in Python.
pTyX enables to generate LaTeX documents, using custom commands or plain python code.
One single pTyX file may generate many latex documents, with different values.
I developed and used pTyX to make several versions of a same test in exams,
for my student, to discourage cheating.
Since it uses sympy library, pTyX has symbolic calculus abilities too.

The `pTyX MCQ extension` makes it easy to use pTyX to generate Multiple Choice Questions 
in the form of pdf documents.
The students MCQ can then be scanned and automatically corrected and marked.

Installation
------------

Obviously, pTyX needs a working Python installation.
Python version 3.8 (at least) is required for pTyX MCQ to run.

Currently, pTyX is only supported on GNU/Linux.

The easiest way to install it is to use pip.

    $ pip install --user ptyx_mcq

Usage
-----

To generate a template, run:

    $ mcq new new_folder

This will generate a `new_folder` folder with a `new.ptyx` file inside,
which is the main configuration file.

This will also create a `new_folder/questions/` folder, where you should put all the exercises, 
as `.txt` files. 

A few text files are already included as examples.

See the next section (*MCQ file format*) for more information about those files format.

To compile the template, run:

    $ mcq make

For more options:

    $ mcq make --help

To automatically corrected the scanned students MCQs, but them as a pdf inside `new_folder/scan`.

Then run:
    
    $ mcq scan


MCQ file format
---------------

When running `mcq new`, a template folder will be generated, including a `new.ptyx` file.

(More to come...)
noos-pyk 0.1.0
A simple, yet useful Python toolkit
Requires Python: <3.13,>=3.12.0

[![CircleCI](https://circleci.com/gh/noosenergy/noos-requests.svg?style=svg&circle-token=c08ede3341e1b8a80f87df87959f849fe40d148f)](https://circleci.com/gh/noosenergy/noos-requests)

# Noos Energy Request Toolkit

This is a simple, yet useful toolkit that supports you in writing Python clients to microservices-style apps.

## Installation

Package available from the [PyPi repository](https://pypi.org/project/noos-pyk/):

```sh
pip install noos-pyk
```

## Usage as a library

The project currently houses a boilerplate to build Python HTTP and WebSocket clients to web services.

As an example, to implement a Python client wrapping up HashiCorp's Terraform Cloud API,

```python
# Import the namespace within your project
from noos_pyk.clients import auth, json


# Define a bearer token authentication class
class TerraformAuth(auth.HTTPTokenAuth):
    default_header = "Authorization"
    default_value = "Bearer"


# Wireup all components for a JSON REST client
class TerraformClient(json.JSONClient, auth.AuthClient):
    default_base_url = "https://app.terraform.io/api/"
    default_content_type = "application/vnd.api+json"

    default_auth_class = TerraformAuth
```

## Development

Make sure [uv](https://docs.astral.sh/uv/) has been installed and pre-configured,
then run the following command to install the project dependencies:

```shell
~$ uv sync --dev
```

This project is shipped with a Makefile, which is ready to do basic common tasks.

```shell
~$ make
help                           Display this auto-generated help message
update                         Lock and install build dependencies
clean                          Clean project from temp files / dirs
format                         Run auto-formatting linters
install                        Install build dependencies from lock file
lint                           Run python linters
test                           Run pytest with all tests
package                        Build project wheel distribution
release                        Publish wheel distribution to PyPi
```
dynamic-doc-sh 1.0.1
Library to dynamically document sh scripts
Requires Python: >=3.12

# Dynamic Doc SH

A dynamic documentation generator to be invoked, using inline tags inspired by Swagger's approach to API documentation.

## Overview

When writing shell scripts, documenting them properly can be tedious and often gets overlooked. Dynamic Doc SH solves this problem by allowing you to embed documentation tags directly in your shell scripts, then automatically generating clean, readable Markdown documentation.

Similar to how Swagger generates API documentation from code annotations, this tool parses special tags in your shell scripts and creates comprehensive documentation that stays in sync with your code.

## Features

 - Tag-based Documentation: Use simple tags to mark functions, variables, and script sections
 - Automatic Markdown Generation: Generates clean .md files from your tagged shell scripts
 - Dynamic Updates: Documentation stays current with your code changes
 - Multiple Tag Types: Support for different documentation elements
 - Template Generation: Creates consistent documentation structure

## How It Works

 - Add tags, place documentation tags directly above the code elements you want to document
 - Run generator, execute the script to parse your shell files
 - Get documentation, lean Markdown documentation is generated/updated automatically

### Example

The following example shows all available tags.

```
#!/bin/bash

set -e

# @doc: Developer settings are used in development mode, don't use it if you deploy in production
# @default: yes
read -e -i yes -p "Use Developer Settings [YES/no]" developer_settings
echo "Developer Settings: $developer_settings"
```

`@doc` tag is mandatory if it's not present then the process will be aborted, same for the `read` directive.

`@default` is an additional tag that is not mandatory and can be used if needed.

## How to run it

```bash
dynamicdoc --script_path /tmp/testing_dynamic_doc/default.sh --previous_hash_path /tmp/testing_dynamic_doc
/default_previous_hash_path.txt --output_path /tmp/testing_dynamic_doc/output
```

 - `--script_path`, where the script to document is located
 - `--previous_hash_path`, where the hash history file is located
 - `--script_language`, specifies which language has been used by the script for the library to be able to use the correct jinja template, `bash` is the default choice
 - `--output_path`, where to put the newly created documentation