semvec/pypi-packages huggingface dataset:
ner-reformat 1.0.0
A Python package for converting various Named Entity Recognition (NER) formats to BRAT and BIO formats.
Requires Python: >=3.7
Keywords: NLP Named Entity Recognition annotation NER BRAT BIO

# NER Reformat

NER Reformat is a Python package that transforms Named Entity Recognition (NER) annotations into the BRAT and BIO formats. It also supports Named Entity Linking annotations transformation to BRAT format for some corpora. You can see the list of formats at section [Supported formats](#supported-formats)


## Installation

You can install NER Formatter using pip:
```
pip3 install ner-reformat
```

## Usage

Here's a basic example of how to use NER Formatter:
```
from ner-reformat import ncbi_to_brat

path_to = "your path/NCBI diseases"
path_from = "your path/NCBI diseases"
ncbi_to_brat(path_from=path_from, path_to=path_to)
```

## Supported Corpora

- IOB formatted, including:
   - CoNLL
   - OntoNotes
   - MultiNERD
   - WikiNeural
   - WNUT
   - MIT Movies
   - MIT Restaurants
- BRAT formatted, including:
  - CADEC
- NCBI
- IEER
- BioCreative
- Groningen Meaning Bank
- GeoVirus
- MalwareTextDB

### Annotation Schemes of BRAT and IOB

[BRAT](https://brat.nlplab.org/) (Brat Rapid Annotation Tool) format is a standoff annotation format used for text annotation tasks. In BRAT format, each entity is represented on a separate line with annotations including an ID, entity type, start and end offsets, and the annotated text. Example:
```
example.txt

The following month, he signed a contract to play for the Newark Bears in the International League.
```
```
example.ann

T1    ORG 58 70    Newark Bears
T2    ORG 78 98    International League
```

IOB (Beginning, Inside, Outside) format, also known as BIO, is a tagging scheme used for token-level annotation in NLP tasks like Named Entity Recognition. The `B-` prefix indicates the beginning of an entity, `I-` prefix indicates a token inside an entity, and `O` tag represents tokens outside any entity.

```
0    The    O
1    following    O
2    month    O
3    ,    O
4    he    O
5    signed    O
6    a    O
7    contract    O
8    to    O
9    play    O
10    for    O
11    the    O
12    Newark    B-ORG
13    Bears    I-ORG
14    in    O
15    the    O
16    International    B-ORG
17    League    I-ORG
18    .    O
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
pyGSTi 0.9.13
A python implementation of Gate Set Tomography
Requires Python: >=3.8
Keywords: pygsti, tomography, gate set, pigsty, pig, quantum, qubit

Gate set tomography (GST) is a quantum tomography protocol that provides full characterization of a quantum logic device
(e.g. a qubit).  GST estimates a set of quantum logic gates and (simultaneously) the associated state preparation and
measurement (SPAM) operations.  GST is self-calibrating.  This eliminates a key limitation of traditional quantum state
and process tomography, which characterize either states (assuming perfect processes) or processes (assuming perfect
state preparation and measurement), but not both together.  Compared with benchmarking protocols such as randomized
benchmarking, GST provides much more detailed and accurate information about the gates, but demands more data.  The
primary downside of GST has been its complexity.  Whereas benchmarking and state/process tomography data can be analyzed
with relatively simple algorithms, GST requires more complex algorithms and more fine-tuning (linear GST is an exception
that can be implemented easily).  pyGSTi addresses and eliminates this obstacle by providing a fully-featured, publicly
available implementation of GST in the Python programming language.

The primary goals of the pyGSTi project are to:

- provide efficient and robust implementations of Gate Set Tomography algorithms;
- allow straightforward interoperability with other software;
- provide a powerful high-level interface suited to inexperienced programmers, so that
  common GST tasks can be performed using just one or two lines of code;
- use modular design to make it easy for users to modify, customize, and extend GST functionality.
uwu-python 0.1.3
The fastest text uwuifier ever made, made in rust and bound using maturin for use in python projects

Requires-Python: >=3.8
Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM

# Information
installation does required rust and cargo to be installed inorder to use this package

# Usage
```python
from uwu_python import uwu
text = "whats up baby"
return uwu(text)
```