semvec/pypi-packages huggingface dataset:
coverage-sbfl 0.0.1
Collect coverage from python projects compatible with Spectrum-Based Fault Localization (SBFL)!
Requires Python: >=3.6

# Coverage-sbfl
Coverage collection in SBFL format using [coverage.py](https://coverage.readthedocs.io/).

This is a plugin for the [coverage.py](https://coverage.readthedocs.io/) tool.
The plugin provides an alternative coverage report in
[TCM](https://www.fernuni-hagen.de/ps/prjs/PD/) format compatible with Spectrum-Based
Fault Localization (SBFL) techniques such as [FLITSR](https://github.com/DCallaz/flitsr).

The plugin requires only the coverage.py coverage output (either the binary
.coverage file or the json coverage report), as well as the output of the
testing framework used (e.g. [pytest](https://pytest.org)), which is
usually included in the output of coverage.py itself.

## Installation

To install the `coverage-sbfl` plugin, simply use:
```
pip install coverage-sbfl
```

## Usage

The `coverage-sbfl` plugin is a report generation plugin for the coverage.py
tool. So it replaces the normal call to any of coverage.py's report formatters.

An example usage of the plugin using coverage.py is as follows:
```
coverage -m pytest > coverage_output.txt
coverage-sbfl -e coverage_output.txt
```
which will create the `coverage.tcm` file compatible with SBFL tools.

NOTE: We **strongly** suggest you use the settings provided in the
`template_coveragerc.txt` file when using this plugin. In particular, this
plugin relies on coverage.py's dynamic contexts in order to collect per-test
case coverage, so the setting:
```
dynamic_context = test_function
```
is necessary in order to use this plugin.
ftprci 0.3.0
Cross platform fast time python robot interface controller
Requires Python: >=3.7

# FTPRCI

Fast Time Python Robot Controller Interface

## Description

This library is a collection of classes and functions to help with the development
of robot controllers in Python. It is designed to be fast and easy to use, with a
focus on real-time control.
Works on CPython and MicroPython.
But the support for MicroPython is currently broken, because of the numpy dependancy.

## Installation

To install the library, simply run:

    ```sh
    pip install ftprci
    ```

## Usage

The library is divided into several modules, each with a specific purpose:

- `interface`: Contains the `Interface` class, which is an abstract base class for
  all interfaces.
- `actuators`: Contains the `Actuator` class, which is an abstract base class for
  all actuators.
- `estimator`: Contains the `Estimator` class, which is an abstract base class for
  all estimators.
- `controller`: Contains the `Controller` class, which is an abstract base class
  for all controllers.
- `sensor`: Contains the `Sensor` class, which is an abstract base class for all
  sensors.
- `logger`: Contains the `Logger` class, which is used for logging.
- `main`: Contains the `RunnerThread` class, which is used to run the controller
  with precise timings.

Here is an example of how to use the library:

    ```python
    import ftprci as fci

    th = fci.RunnerThread()

    sensor = fci.LSM6()
    estimator = fci.KalmanFilter()
    controller = fci.PIDController(1, 10, 0.1)
    actuator = fci.DCMotor()

    th.callback | sensor.read | estimator.estimate | controller.steer | actuator.command
    th.run()
    ```

## Contributing

Do not hesitate to contribute to the project if you create a new sensor, estimator, or anything!
You can open a pull request or an issue on the GitHub repository.
feedbackintelligence 1.0.3
An SDK for Feedback Intelligence data insertion
Requires Python: >=3.6

# Feedback Intelligence SDK

The `feedbackintelligenceSDK` is a Python package designed to interact with the Feedback Intelligence API. It allows you
to add context, chat, and feedback data to the database, both synchronously and asynchronously.

## Installation

You can install the package via pip:

```bash
pip install feedbackintelligence
```

Usage
Initialization
To use the SDK, first initialize it with your API key:

```python
from feedbackintelligence.fi import FeedbackIntelligenceSDK

sdk = FeedbackIntelligenceSDK(api_key="your_api_key_here")
```

## Methods

- ***add_context***

#### Add context to the database (synchronous)

```python
response = sdk.add_context( project_id=1, context="Sample context", context_id=123)
# Or you can skip the context_id
#response = sdk.add_context( project_id=1, context="Sample context")

```

- ***add_context_async***

#### Add context to the database (asynchronous)

```python
response = await sdk.add_context_async( project_id=1, context="Sample context", context_id=123)
```

- ***add_chat***

#### Add chat data to the database (synchronous).

```python
from feedbackIntelligence.schemas import Message, Context, Feedback
# Make sure to use the exact date format that is used in the example

messages = [
    Message(role='human', text='Hello', prompt='test', 
            date='2020-01-20T13:00:00',
            context=Context(text='new_context')), 
    Message(role='ai', text='Hi there', 
            date='2020-01-20T13:01:00',
            feedback=Feedback(thumbs_up=1, message='Feedback message(optional)'))]
response = sdk.add_chat( project_id=1, chat_id="chat-1", messages=messages)
```

- ***add_chat_async***

#### Add chat data to the database (asynchronous).

```python

response = await sdk.add_chat_async( project_id=1, chat_id="chat-1", messages=messages)
```

- ***add_feedback***

#### Add feedback data to the database (synchronous).

```python
response = sdk.add_feedback( project_id=1, message="Great service", source="email")
```

- ***add_feedback_async***

#### Add feedback data to the database (asynchronous).

```python
response = await sdk.add_feedback_async( project_id=1, message="Great service", source="survey")
```

visit this links to see examples
* [SKD](https://colab.research.google.com/drive/1p6ZkAj0zQoKtlv4FETE5Mrb4PXn-IhuA?usp=drive_link)
* [API](https://drive.google.com/file/d/1cwjbqVIAFidlbhYv8YA36P6PDhpufT9c/view?usp=drive_link)