semvec/pypi-packages huggingface dataset:
howler-client-internal 1.6.0.dev15942
Howler Client - CCCS Internal Build
License: MIT
Keywords: development howler client gc canada cse-cst cse cst

**Le version français suit**

# Howler Client Library

The Howler client library facilitates issuing requests to Howler.

## Running the Tests

1. Prepare the howler-api:
    1. Start dependencies
    1. `howler-api > python howler/app.py`
    1. `howler-api > python howler/odm/random_data.py`
2. Run Java integration tests:
    1. `howler-client > mvn verify`
3. Run python integration tests:
    1. `howler-client/python > python -m venv env`
    1. `howler-client/python > . env/bin/activate`
    1. `howler-client/python > pip install -r requirements.txt`
    1. `howler-client/python > pip install -r test/requirements.txt`
    1. `howler-client/python > pip install -e .`
    1. `howler-client/python > pytest -s -v test`


===

# Français

# Bibliothèque client de Howler

La bibliothèque client Howler facilite l'émission de requêtes à Howler.

## Exécution des tests

1. Préparez l'interface howler-api :
    1. Démarrer les dépendances
    1. `howler-api > python howler/app.py`
    1. `howler-api > python howler/odm/random_data.py`
2. Exécutez les tests d'intégration Java :
    1. `howler-client > mvn verify`
3. Exécuter les tests d'intégration python :
    1. `howler-client/python > python -m venv env`
    1. `howler-client/python > . env/bin/activate`
    1. `howler-client/python > pip install -r requirements.txt`
    1. `howler-client/python > pip install -r test/requirements.txt`
    1. `howler-client/python > pip install -e .`
    1. `howler-client/python > pytest -s -v test`
pytorch-partial-tagger 0.1.18
Sequence Tagger for Partially Annotated Dataset in PyTorch
License: MIT
Requires Python: <3.12,>=3.8

# pytorch-partial-tagger

[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/17GcpKmYn49bMM-mCZhiuRu8dkPZ0WXuD?usp=sharing)

`pytorch-partial-tagger` is a Python library for building a sequence tagger, specifically for the common NLP task Named Entity Recognition, with a partially annotated dataset in PyTorch.
You can build your own tagger using a distantly-supervised dataset obtained from unlabled text data and a dictionary that maps surface names to their entity type.
The algorithm of this library is based on Effland and Collins. (2021).


## Usage

Import all dependencies first:

```py
import torch
from sequence_label import SequenceLabel

from partial_tagger.metric import Metric
from partial_tagger.utils import create_trainer
```

Prepare your own datasets. Each item of dataset must have a pair of a string and a sequence label.
A string represents text that you want to assign a label, which is defined as `text` below.
A sequence label represent a set of a character-based tag, which has a start, a length, and a label, which are defined as `label` below.
A start represents a position in the text where a tag starts.
A length represents a distance in the text between the beginning of a tag and the end of a tag.
A label represents what you want to assign to a span of the text defined by a start and a length.

```py
text = "Tokyo is the capital of Japan."
label = SequenceLabel.from_dict(
    tags=[
        {"start": 0,  "end": 5, "label": "LOC"},  # Tag for Tokyo
        {"start": 24,  "end": 29, "label": "LOC"},  # Tag for Japan
    ],
    size=len(text),
)

train_dataset = [(text, label), ...]
validation_dataset = [...]
test_dataset = [...]
```

Here, you will train your tagger and evaluate its performance.
You will train it through an instance of `Trainer`, which you get by calling `create_trainer`.
After a training, you will get an instance of `Recognizer` which predicts character-based tags from given texts.
You will evaluate the performance of your tagger using an instance of `Metric` as follows.


```py

device = torch.device("cuda")

trainer = create_trainer()
recognizer = trainer(train_dataset, validation_dataset, device)

texts, ground_truths = zip(*test_dataset)

batch_size = 15
predictions = recognizer(texts, batch_size, device)

metric = Metric()
metric(predictions, ground_truths)

print(metric.get_scores())  # Display F1-score, Precision, Recall
```

## Installation

```bash
pip install pytorch-partial-tagger
```

## Documentation

For details about the `pytorch-partial-tagger` API,  see the [documentation](https://pytorch-partial-tagger.readthedocs.io/en/latest/).

## References

- Thomas Effland and Michael Collins. 2021. [Partially Supervised Named Entity Recognition via the Expected Entity Ratio Loss](https://aclanthology.org/2021.tacl-1.78/). _Transactions of the Association for Computational Linguistics_, 9:1320–1335.
isostream 1.1.0
Python Client for the IsoStream API
License: MIT

# isostream
IsoStream Python Client

A simple wrapper around the ISOStream API that produces JSON or well formated pandas DataFrames from query results.
The the API client, methods, inputs and responses and all dynamically created from the OpenAPI specification of the IsoStream REST API.


## Installation

You can install the library with:
```
pip install isostream
```

## Quickstart
The ISOStream client is dynamically generated from the OpenAPI specification from the ISOStream API.
See the [ISOStream API Documentation](https://app.isostream.io/docs) for more details.
All of the REST API endpoints available on client as methods.

```
from isostream import IsoStream

client = IsoStream("<your_api_key>")

df = client.dalmp_node(node="WESTERN HUB", start="2021-01-01", end="2021-02-01", iso="PJM")
```

All string timestamps can also be provided as datetime objects.

To see a list of available API methods:
```
client.api_methods()

# or filter by a specific keyword to see only relevant methods:
client.api_methods(filter="dalmp")
```

By default, the client returns all queries in appropriated typed and logically pivoted pandas DataFrames.
You can alter this behavior with the 'as_df' and 'pivot' flags:
```
raw = client.meta_nodes(iso="PJM", as_df=False)
```