semvec/pypi-packages huggingface dataset:
inceptalytics 0.1.1
INCEpTALYTICS is a package for analysing INCEpTION annotation projects.

# INCEpTALYTICS

[![DOI](https://zenodo.org/badge/379546031.svg)](https://zenodo.org/badge/latestdoi/379546031)

An easy-to-use API for analyzing [INCEpTION](https://inception-project.github.io) annotation projects.
* We parse an XMI export of an Inception annotation project and provide easy access to (most) of the underlying data including annotators, source files, etc.
* We provide *recipes* for computing project statistics, confusion matrices, inter-annotator-agreement, or plotting progress reports.

## Installation

INCEpTALYTICS is on [PyPi](https://pypi.org/). To install it run:

```bash
pip install inceptalytics
```

## Basic Usage

```python
from inceptalytics import Project

file = "data/Example_Project_POS.zip"

# load project
project = Project.from_zipped_xmi(file)

# print all annotator names
for annotator in project.annotators:
    print(annotator)

# create a view 
pos_type = "de.tudarmstadt.ukp.dkpro.core.api.lexmorph.type.pos.POS"

view = project.select(
        annotation=project.feature_path(pos_type, "coarseValue"), 
        annotators=project.annotators, 
        source_files=project.source_file_names
)

print('# pos annotations in view:', len(view.annotations))

print('IAA Krippendorff: ', view.iaa())
```

## Dashboard
We also provide a basic [Streamlit](http://streamlit.io) web application as a starting point for a dashboard that fits your needs.

To run the dashboard, you will have to install some additional dependencies.

```bash
pip install -r examples/streamlit_requirements.txt
```

Afterwards, you can run the dashboard.

```bash
streamlit run examples/dashboard.py
```

The application should be available in your browser under `http://localhost:8501`. The URL is also printed on the shell.

![Screenshot of dashboard](https://raw.githubusercontent.com/ltl-ude/inception-analytics/main/img/dashboard.png "Dashboard")

## Changelog

### Version 0.1.0

* Project is now on [PyPi](https://pypi.org/project/inceptalytics/).
* Projects can now be loaded using the [INCEpTION's Remote API](https://inception-project.github.io//releases/0.11.2/docs/admin-guide.html#sect_remote_api) using `Project.from_remote`.
* Removed plotting functionality from INCEpTALYTICS and moved it to the dashboard under example. 

### Version 0.1.1

* Added sanity checks and input normalisation to `Project.from_remote`.
* Updated `Project.from_remote` to be compatible with the latest version of [pycaprio](https://pypi.org/project/pycaprio/).
oauth-userdb 1.0.4
OAuth User DB

# oauth_userdb
OAuth User Database


## Versions

### 1.0.4

- include client_id/client_secret in refresh request

### 1.0.3

- avoid writing null refresh_token if server does not include refresh_token in refresh request

### 1.0.2

- fix refresh token flow

### 1.0.1

- make scope an optional return type, make redirect_url an optional param (kwarg)
pdc-event-autodoc 1.0.1
Autodoc for socket
Requires Python: >=3.9,<4.0

# Autodoc for Socketio and Fastapi

Create autodoc for socketio and access using API Router.

Use decorator and method for describe the event running, Use sub for 'subscribe' and use pub for 'publish'.
This code also integrated with pydantic, so it will be detect data model in your params if using pydantic. 
Beside that other type data like array or general type like str, int, etc can be solved. 
Other type from python typing like Optional and Union especially Union with none type can be solved.


## Example Using

To use this import the class SokcetDocumentations, and assign the class to var.
Use decorator (@) to create documentation. There is two option to create documentation.
First is class method sub to define the event under decorator is subscribe, The second is pub to define the event or method under decorator is to publish. In this bellow is example how to use the code:

```
from pdc_event_autodoc import SocketDocumentation 

doc = SocketDocumentation()
```

First time is set your application info like bellow:
```
doc.set_info_app(title= 'Example App', version= '1.0.0', description= 'This is example documentation of Example App version 1.0.0')
```



You can decla your params using pydantic model:
```
class PydanticModel(BaseModel):
    id: int
    name: str
    address: str

# Example using pydantic model
@doc.sub(event_name= 'message', 
        tags= ['SubcribeMessage'], 
        schema= PydanticModel, 
        summary= 'ReceiveMessage', 
        description= 'This is event when we receive a message.')
@sm.on('message')
def receive_message(sid, data: PydanticModel):
    return data.dict()
```

Or using general type like 
```
@doc.pub(event_name= 'message', 
        tags= ['PublishMessage'],
        summary= 'To Send a Message', 
        description= 'This is event when we want to send a message.')
def sending_message(sid, data: str):
    return sm.emit('message', data)
```

To preview the documentation, you can using FastAPI or APIRouter.
This is an example using APIRouter:

```
from fastapi import APIRouter
from fastapi.encoders import jsonable_encoder
from pydantic import AnyHttpUrl

from pdc_event_autodoc import SocketDocumentation, get_asyncapi_html

doc = SocketDocumentation()

router = APIRouter(tags= ['Socket Documentations])

@router.get('/socket.json')
def get_socket_json():
    return jsonable_encoder(doc.main_data)

@router.get('/socket_doc')
def get_socket_documentation():
    async_url= AnyHttpUrl('/socket.json', scheme= 'http')
    return get_asyncapi_html(asyncapi_url= async_url, title= 'Notification Service')
```
In AnyHttpUrl if you using prefix, don't forget to include your prefix.!

The documentattion can be access in path '/socket_doc'.

## Notice
### Dont't forget to declare your type params (it can be Pydantic model, array, str, int, Optional or Union, etc).
### If not be declare it will be detect that your function using Any params.