semvec/pypi-packages huggingface dataset:
socorepo 1.2.1
A webapp that fetches software version listings and presents them as download sites.
License: MIT
Requires Python: >=3.7

Socorepo, the SOftware COmponent REPOsitory exPOser, is a lightweight Python webapp that pulls
software component listings from a variety of different sources and presents them as intuitive download sites
to end users.

A production instance of the webapp is permanently embedded in https://loadingbyte.com, for example, at https://loadingbyte.com/socorepo/dl/. Try it out!

## Features

* Pulls software components from Nexus 3, GitHub, or PyPI repositories.
* "Just works": Listings are sorted and classified by sensible and generic (yet configurable) standards.
* Extremely lightweight: No external services like databases required.
* Configured fully by simple config files.
* Features a REST API.
* 100% JavaScript-free. Doesn't employ any JavaScript in the browser.

## Install

Socorepo can be installed from PyPI:

    $ pip install socorepo

You can then quickly deploy Socorepo, e.g., using [Gunicorn](https://gunicorn.org/):

    $ pip install gunicorn
    $ gunicorn -b 127.0.0.1:4000 socorepo:app

## Configure

When you just fire up Socorepo, it uses the default configuration files that it ships with.
You probably want to edit these files.
To do that, first extract the default configuration files using:

    $ socorepo-default-config

This will copy the default configuration files into a new `config/` folder in your shell's current directory.
Now put that folder wherever you want.
When you start Socorepo in the future, simply supply the path to your new config directory
in the environment variable `SOCOREPO_CONFIG_DIR`:

    $ SOCOREPO_CONFIG_DIR=/path/to/config/ gunicorn -b 127.0.0.1:4000 socorepo:app

All configuration files use the [TOML](https://github.com/toml-lang/toml) configuration format.

The `settings.toml` file contains straightforward general settings which are explained in detail by the comments in that file.
Meanwhile, the `projects.toml` file defines the software projects for which Socorepo presents download pages.
When configuring Socorepo for the first time, start with these two files and use the extensive comments as a guide.
The remaining `.toml` files you probably won't need to touch for starters.
gitlab-release-notes-generator 1.3.0
Utility for use in gitlab ci to generate changelogs.
License: MIT


# gitlab-release-note-generator
===============

Special thanks to [gitlab-release](https://gitlab.com/alelec/gitlab-release). Most of the code used in this project is based on gitlab-release.

This Python utility is used to generate a markdown changelog in the form:

```
### Release note (2021-02-09 12:19:16)

#### [](#closed-issues)Closed issues

-   Adds initial gitlab yaml [(#1)]

#### [](#merged-merge-requests)Merged merge requests

-   Resolve "Adds initial gitlab yaml" [(#1)]
```



It can be used in a ``.gitlab-ci.yml`` stage like:

::

    release:
      stage: release
      image: python3
      script:
        - pip3 install gitlab-release gitlab-release-notes-generator
        - Output=$(gitlab-release-notes-generator --private-token $GITLAB_ACCESS_TOKEN)
        - gitlab-release --description "${Output}" --zip "release-${CI_COMMIT_TAG}.zip" *
      only:
        - tags


Setting up the required private token
---------------------------------------

This tool requires you to put a copy of a ``PRIVATE_TOKEN`` in a
secret CI variable for the project to give it access to post the files
back to the project.

For this create a new `Personal Access Token` at
https://gitlab.com/profile/personal_access_tokens and use that. (You
could also use your personal token from
https://gitlab.com/profile/account, but this is `not recommended`.)

Make sure you enable `Access your API` when creating the token. The
`name` of the token is just for you to remeber what it's for, it wont
affeect operation.

Add it to a secret variable called ``PRIVATE_TOKEN`` for the project you’re
building at ``https://gitlab.com/<user>/<project>/settings/ci_cd>``.


Usage
-----
::

    usage: gitlab-release-note-generator [-h] [--server SERVER] [--project-id PROJECT_ID]
                                              [--private-token PRIVATE_TOKEN] [-f FILE]

============================= =====
optional arguments
============================= =====
| Argument | Description |
  |--|--|
  |``--server SERVER``       | Url of gitlab server <br/>(default: http://gitlab.com/) |
  |``--project-id``          |  Unique id of project, available in Project. Settings/General <br/>(default:  $CI_PROJECT_ID) |
 |``--private-token``       | Login token with permissions to commit to repo                                      <br/>(default:  $PRIVATE_TOKEN)|
 | ``-f, --file``  |The changelog file, which shall be written. <br/>(default: stdout) |
|  ``-h``, ``--help``                 |Show this help message and exit   |
============================= =====
editquality 0.5.1
A library for performing automatic detection of the quality of Wikipedia edits.
License: MIT

# Edit quality

This library provides a set of utilities for building and maintaining
edit quality prediction models for Wikipedia and other Wikimedia projects.

* **Repository:** https://github.com/wikimedia/editquality
* **Documentation:** https://editquality.readthedocs.io
* **License:** MIT

## Installation

First, follow the [installation instructions for revscoring](https://github.com/wikimedia/revscoring).

At the command line:
```
pip install editquality
```

This should will install the library and CLI tool in your PATH. To check it out
try invoking the CLI:
```
editquality -h
```

## Local Development
First, make sure you have `python3`, `virtualenv`, and `git-lfs` installed and configured on your system.  Note that `git-lfs` will need you to run `git lfs install` once before it works. 

You can clone the project repo and work from the
root directory as follows:
```
git clone  https://github.com/wikimedia/editquality.git
cd editquality
virtualenv -p python3 venv
source venv/bin/activate
python setup.py install
```

Now you can invoke the utility cli:
```
./utility -h
```

## Author
* Aaron Halfaker -- https://github.com/halfak
* Amir Sarabadani -- https://github.com/Ladsgroup
articlequality 0.4.4
A library for performing automatic detection of assessment classes of Wikipedia articles.
License: MIT

# Wikipedia article quality classification

This library provides a set of utilities for performing automatic detection of
assessment classes of Wikipedia articles.  For more information, see the full
documentation at https://articlequality.readthedocs.io .

**Compatible with Python 3.x only.**  Sorry.

* **Install:** ``pip install articlequality``
* **Models:** https://github.com/wikimedia/articlequality/tree/master/models
* **Documentation:** https://articlequality.readthedocs.io

## Basic usage

    >>> import articlequality
    >>> from revscoring import Model
    >>>
    >>> scorer_model = Model.load(open("models/enwiki.nettrom_wp10.gradient_boosting.model", "rb"))
    >>>
    >>> text = "I am the text of a page.  I have a <ref>word</ref>"
    >>> articlequality.score(scorer_model, text)
    {'prediction': 'stub',
     'probability': {'stub': 0.27156163795807853,
                     'b': 0.14707452309674252,
                     'fa': 0.16844898943510833,
                     'c': 0.057668704007171959,
                     'ga': 0.21617801281707663,
                     'start': 0.13906813268582238}}

## Install

### Requirements

* Python 3.5, 3.6 or 3.7
* All the system requirements of [revscoring](https://github.com/wikimedia/revscoring)

### Installation steps

1. clone this repository
2. install the package itself and its dependencies `python setup.py install`
3. You can verify that your installation worked by running `make enwiki_models` to build the English Wikipedia article quality model or `make wikidatawiki_models` to build the item quality model for Wikidata

### Retraining the models

To retrain a model, run `make -B MODEL` e.g. `make -B wikidatawiki_models`. This will redownload the labels, re-extract the features from the revisions, and then retrain and rescore the model.

To skip re-downloading the training labels and re-extracting the features, it is enough `touch` the files in the `datasets/` directory and run the `make` command without the `-B` flag.

### Running tests

Example:

```
pytest -vv tests/feature_lists/test_wikidatawiki.py
```

## Authors
* Aaron Halfaker -- https://github.com/halfak
* Morten Warncke-Wang -- https://github.com/nettrom
draftquality 0.0.4
A library for performing automatic detection of the quality of Wikipedia article creations.
License: MIT

# draftquality

This library provides a set of utilities for building and maintaining
draft (new article creation) quality prediction models for Wikipedia.

* **Installation:** ``pip install draftquality``
* **Repository:** https://github.com/wikimedia/draftquality
* **License:** MIT

## Requirements

Optionally requires the following based on usage:

* NLTK SentiWordnet - ``python -m nltk.downloader sentiwordnet``
* NLTK Wordnet - ``python -m nltk.downloader wordnet``

## Author
* Aaron Halfaker -- https://github.com/halfak
bsimport 0.1.1
A tool for importing Markdown files to a Bookstack instance.
License: MIT
Requires Python: >=3.6
Keywords: bookstack,import,markdown

# bsimport

A Python tool for importing Markdown files to a
[Bookstack](https://www.bookstackapp.com) instance.

## Important notice

This project is no longer maintained. I don't use Bookstack anymore so I'm not
sure if it still works: if you have any feedback, please share it by opening an
issue.

## Motivation

I currently use [Obsidian](https://obsidian.md/) for all my note-taking needs.
I wanted to test Bookstack with my existing notes, and since it has an API, I
created this tool to import them.

I used [Typer](https://typer.tiangolo.com/) to create the CLI, and implemented
my own incomplete wrapper of the API.

## Features

- Import a single file or an entire directory:
    - A single file is imported as a page, so it will ask for the ID of the book
      you want to add the page to. You can list your accessible books with
      `python -m bsimport list-books`.
    - A directory is imported as a book: any Markdown files found directly
      inside will be imported as pages of this book.
        - If a subdirectory is found, it will be imported as a chapter, and any
          Markdown files inside it will be imported as pages of that chapter.
        - If a subdirectory of a subdirectory is found, it will be completely
          ignored, even if it contains Markdown files.

- Support for tags: Obsidian uses a [YAML front
  matter](https://help.obsidian.md/Advanced+topics/YAML+front+matter) to add
  tags and other information at the top of the page. Currently, only tags
  created with the format `tags: [tag1, tag2, tag3]` are supported.  This means
  the following YAML list format **is not** supported:
  ```YAML
  tags:
  - tag1
  - tag2
  - tag3
  ```
    - Additionally, any other front matter key such as `aliases` will be ignored.

- The API token and Bookstack URL are saved in a configuration file. You can get
  the path to the file with `python -m bsimport where`.

## Usage

- Get the API token:
  - Login to your Bookstack instance.
  - Edit your profile.
  - At the bottom of the page, create a new token.
    Save both the ID and the secret.

- Install the package with:
  ```bash
  python3 -m pip install bsimport
  ```

- Run the `init` command:
  ```bash
  python -m bsimport init
  ```
  It will ask you for the token ID and secret, as well as the URL to your
  Bookstack.

- Then import your files with:
  ```bash
  python -m bsimport import /path/to/file
  ```

## To modify the code

- Download or clone the code.

- (Optional but recommended) Create a virtual environment: see
  https://docs.python.org/3/library/venv.html.
  Example:
    ```bash
    python3 -m venv .venv
    ```

- Install the dependencies:
  ```bash
  python -m pip install -r requirements.txt -r dev-requirements.txt
  ```
drafttopic 0.4.1
A library for automatic detection of topics of new drafts on Wikipedia based on WikiProjects.
License: MIT

# Draft topic

Predicting topics to new drafts based on Wikiprojects on English Wikipedia.

## Setting up

Make sure to have a working python3 environment.
Install requirements using:

```
pip install -r requirements
```

Install the library using:

```
python setup.py install
```

## Generating machine-readable WikiProjects data

Use the following utility from root directory to generate machine-readable WikiProjects data:

```
./utility fetch_wikiprojects --output <output_file_name.json>
```

## Generating mid-level category to WikiProjects mapping

Use the following utility from root directory to generate a mapping of high-level topic categories to list of WikiProjects contained in them:

```
./utility trim_wikiprojects --wikiprojects wp --output outmid
```

## Labeling a list of page-ids with the wikiprojects and mid-level categories each page belongs to

Use the following utility from root directory to label a list of page-ids with the wikiprojects and the mid-level categories the page belongs to.

```
./utility fetch_page_wikiprojects --api-host=https://en.wikipedia.org/ --input=wikiproject_page_ids.json --output=enwiki.labeled_wikiprojects.json --mid_level_wp=outmid.json --verbose
```

In above, the input to the script should be a json containing a list of
observations, each observation having a **page\_id: \<page-id\>** mapping.
Additionally also pass the mid-level wikiprojects json for the script to
generate wikiprojects to mid-level categories mapping. The script augments the
given list with the mentioned fields, writing them to a new file specified by
**"output"**

## Generating predictions for a set of page-ids on Wikipedia

For generating topic predictions for a set of revision-ids, download the relevant model and use revscoring's [score](https://github.com/wikimedia/revscoring/blob/master/revscoring/utilities/score.py) API
to generate predictions. Note that the revision-ids need to be in a file with a format specified by the API. Use the revision ID of the most recent revision for a page to get a good prediction.
easy-inference 0.1.1
Got a working detection model file? Want to quickly setup inference pipelines? You are in the right place!
License: MIT
Requires Python: >=3.8

# Easy Inference

Welcome to the easy inference repository! The main goal of this repository is to provide a clean, simple and short way of setting up inference pipelines for 2D (and 3D) visual detection.
The interfaces to camera drivers are abstracted away as python `generators`. A simple inference pipeline for a webcam based inference pipeline looks as follows:

```Python3
from easy_inference.providers.webcam import Webcam

provider = Webcam(source=0)

for frame in provider:

  # run my detection 
```

See the examples directory for some `yolov7` pipelines.


### Sidenote

Many examples is this repository include `yolov7` pipelines using the onnx-runtime. To generate onnx model files follow the steps on the yolov7 repository [readme](https://github.com/WongKinYiu/yolov7/blob/8c0bf3f78947a2e81a1d552903b4934777acfa5f/README.md?plain=1#L156).

To export a model for yolov7 including pose detection, checkout the following branch of [yolov7](https://github.com/WongKinYiu/yolov7/tree/pose) and download the pytorch model [yolov7-w6-pose.pt](https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6-pose.pt). Then run the following to export an onnx model with your desired configuration:

```bash
cd yolov7
python models/export.py --weights yolov7-w6-pose.pt --grid --simplify --export-nms --batch-size 2 --img-size 512 640
```