semvec/pypi-packages huggingface dataset:
divio-docs-parser 0.1.2
Collect and parse all your divio-style documentation with just one line of code!
Requires Python: >=3.6

# Divio Docs Parser

Collect and parse all your [divio-style documentation](https://documentation.divio.com/) with just one line of code! This script will scan any files/directories/strings you pass. For example:
- If you have a how-to section in your README, that'll get extracted and put in the right spot
- Or, if you have an how-to.md file, it'll get added in its entirety!

## How-To
### Install from pip
```bash
python3 -m pip install divio_docs_parser
```

### Clone & run scripts locally
```bash
git clone https://github.com/Denperidge-Redpencil/divio-docs-parser.git
cd divio-docs-gen/
python3 -m src.divio_docs_parser
```

### Run tests
```bash
git clone https://github.com/Denperidge-Redpencil/divio-docs-parser.git
cd divio-docs-gen/
python3 -m unittest
```

### Build & install package locally
```bash
git clone https://github.com/Denperidge-Redpencil/divio-docs-parser.git
cd divio-docs-gen/
python3 -m pip install --upgrade build setuptools  # If no setuptools dist can be found, try using a higher python version
python3 -m build && python3 -m pip install --force-reinstall ./dist/*.whl
```
*Note: other Python versions can be used!*


## Explanation
The Divio structure is built upon splitting your documentation into 4 types of documentations. ![The overview of the divio documentation on their website](https://documentation.divio.com/_images/overview.png). In this repository they're referred to as sections.


If you want to know more about the design principles of this project, feel free to check out my writeup [here](https://github.com/Denperidge-Redpencil/Learning.md/blob/main/Notes/docs.md#design-principles)!


## Reference
### Synonyms
For ease of use and freedom of implementation, every section has synonyms.

| Section       | Synonyms                        |
| ------------- | ------------------------------- |
| Tutorials     | Getting started                 |
| How-to Guides | How-To, Guide, Usage            |
| Explanation   | Discussion, background material | 
| Reference     | Technical                       |
rabbitmq-toolkit 0.1.7
A streamlined toolkit for efficient RabbitMQ operations.
Requires Python: >=3.6
Keywords: rabbitmq,messaging,queue,producer,consumer

# RabbitMQ Toolkit

RabbitMQ Toolkit is a comprehensive package designed to simplify RabbitMQ operations. It encapsulates the core functionalities into three intuitive classes: `QueueManager`, `Producer`, and `Consumer`, streamlining the process of message queueing, producing, and consuming.

## Installation

Install the package via pip:

```bash
pip install rabbitmq_toolkit
```


## Features

- **QueueManager**: Effortlessly manage your RabbitMQ queues.
- **Producer**: Produce messages with ease, ensuring they're properly queued.
- **Consumer**: Robustly consume messages, with built-in mechanisms to handle common scenarios.

## Usage Example

### Producer

In `producer.py`:

```python
from rabbitmq_toolkit import QueueManager, Producer

# Initialize the Queue Manager and declare a queue
queue_mgr = QueueManager()
queue_name = "sample_queue"
queue_mgr.declare_queue(queue_name)

# Produce a message
producer = Producer(queue_mgr)
producer.send_message(queue_name, "Hello from RabbitMQ Toolkit!")
```

Run `producer.py` in terminal:
```bash
python producer.py
```

### Consumer

In `consumer.py`:

```python
from rabbitmq_toolkit import QueueManager, Consumer

# Initialize the Queue Manager
queue_mgr = QueueManager()
queue_name = "sample_queue"
# We use declare_queue for both can operate independently and can be started in any order.
queue_mgr.declare_queue(queue_name)

# Consume the message
def callback(message):
    print(f"Received: {message}")

consumer = Consumer(queue_mgr)
consumer.start_consuming(queue_name, callback)
```

Run `consumer.py` in other tab terminal:
```bash
python consumer.py
```

**Note:** This provides a clear distinction between the Producer and Consumer, showcasing how they can be used in separate files.
GraphifyPy 0.0.7
A library for different graph functionalities and operations.
Requires Python: >=3.7

# GraphifyPy

#### Note: This is a library still in the works and is not fully functional.
---
### Installation

#### `pip install GraphifyPy`

### Getting Started

GraphifyPy is a library meant for constructing graphs made using user-defined nodes/vertices and edges connecting these nodes/vertices, using Python. Alternatively, this library currently has the functionality to generate 3 special types of graphs based on user-defined sizes- Complete, Bipartite and Cycle graphs. 

The UndirectedGraph() class is to be called for the purposes of a user-defined graph.
pycefr 1.0.1
A tool to measure code competency levels based on CEFR model

# **pycefrl**
## *Identifying Python3 Code Level Using the CERFL Framework as Inspiration*

### What is this project about?
The goal of pycefrl is to create a tool capable of obtaining an evaluation inspired by the [''Common European Framework of Reference for Languages''](https://en.wikipedia.org/wiki/Common_European_Framework_of_Reference_for_Languages) for code written in the Python programming language, version 3.

With this tool it is possible to analyze the level of GitHub repositories (and their developers) or code snippets in Python3.

### ABSTRACT
Python is known to be a versatile language, well suited both for beginners and advanced users. Some elements of the language are easier to understand than others: some are found in any kind of code, while some others are used only by experienced programmers. The use of these elements lead to different ways to code, depending on the experience with the language and the knowledge of its elements, the general programming competence and programming skills, etc. In this paper, we present pycefr, a tool that detects the use of the different elements of the Python language, effectively measuring the level of Python proficiency required to comprehend and deal with a fragment of Python code. Following the well-known Common European Framework of Reference for Languages (CEFR), widely used for natural languages, pycefr categorizes Python code in six levels, depending on the proficiency required to create and understand it. We also discuss different use cases for pycefr: identifying code snippets that can be understood by developers with a certain proficiency, labeling code examples in online resources such as Stackoverflow and GitHub to suit them to a certain level of competency, helping in the onboarding process of new developers in Open Source Software projects, etc

### Usage
1. Prepare the files as follows
```text
Root folder of your project
└───projects
|   ├───sample directory
|
└───jupyter notebook
└───results
```

Current API 
```python
from pycefr import pycerfl

pycerfl.read_Directory('projects/sample directory', 'sample directory')
```
It should create a results folder with two files
- d.csv
- d.json

## Citation
If you use pycefr in your research or wish to refer to the examples in this repo, please cite with:

```bibtex
@inproceedings{RoblesICPC22,
author = {Robles, Gregorio and Kula, Raula Gaikovina and Ragkhitwetsagul, Chaiyong and Sakulniwat, Tattiya and Matsumoto, Kenichi and Gonzalez-Barahona, Jesus M.},
title = {Pycefr: Python Competency Level through Code Analysis},
year = {2022},
isbn = {9781450392983},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3524610.3527878},
doi = {10.1145/3524610.3527878},
booktitle = {Proceedings of the 30th IEEE/ACM International Conference on Program Comprehension},
pages = {173–177},
numpages = {5},
location = {Virtual Event},
series = {ICPC '22}
}