semvec/pypi-packages huggingface dataset:
scaife-viewer-atlas 0.3rc1
Aligned Text and Linguistic Annotation Server (ATLAS)
License: MIT

# Aligned Text and Linguistic Annotation Server (ATLAS)

## Settings

Settings can be overridden at a project level using via the `SV_ATLAS_<name>`
naming convention.

### Data model

**DATA_DIR**

Default: `None`

The path to the directory containing ATLAS data

**INGESTION_CONCURRENCY**

Default: `None`

Sets the number of processes available to ProcessPoolExecutors during ingestion.

When `None`, defaults to number of processors as reported by multiprocessing.cpu_count()

**TREE_PATH_ALPHABET**

Default: `"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"`

Used by `django-treebeard` to calculate the maximum path steps.

See the [django-treebeard docs](https://django-treebeard.readthedocs.io/en/latest/mp_tree.html#treebeard.mp_tree.MP_Node.alphabet) for more information.


**INGESTION_PIPELINE**

Default:
```python
[
    "scaife_viewer.atlas.importers.versions.import_versions",
]
```

A list of callables that are ran by the `prepare_atlas_db` management
command to ingest data into ATLAS.


### Database

**DB_LABEL**

Default: `"atlas"`

The label to use for the ATLAS-specific database (required when using the `ATLASRouter` database router)

**DB_PATH**

Default: `None`

The path to the SQLite database referenced by `DB_LABEL`.

### Search
**SEARCH_TEMPLATE_FIXTURE_PATH**

Default: `scaife_viewer/atlas/backports/scaife_viewer/search/fixtures/base_template.json`

The path to the JSON fixture used to create ElasticSearch index mappings for ATLAS.

### Annotations

**EXPAND_IMAGE_ANNOTATION_REFS**

Default: `True`

Sets the text part relation to _all_ text parts within a passage reference (descendants within the passage reference).

_Example_:
- Reference is `1-2`
- Text parts `1.1, 1.2, ... 2.999` are linked to the annotation within ATLAS

When `False`, applies annotations _only_ to the text parts
specified in the passage reference.

_Example_:
- Reference is `1-2`
- Text parts `1, 2` are linked to the annotation within ATLAS, but _not_ any children / descendants

### GraphQL

**IN_MEMORY_PASSAGE_CHUNK_MAX**

Default: `2500`

Sets the upper limit on the number of text parts used for in-memory passage chunking.

When the number of text parts exceeds this limit, ATLAS will fall back to a database-backed
chunking alogrithm.

For most smaller passages, the in-memory chunking is faster than using the database.


### Other

**HOOKSET**

Default: `"scaife_viewer.atlas.hooks.DefaultHookSet"`

The path to a hookset that can be used to customize ATLAS functionality.

## GraphQL Endpoint

URL Name: `sv_atlas:graphql_endpoint`

Primary GraphQL endpoint for `scaife-viewer-atlas` projects.

When accessed [via a browser](https://github.com/graphql-python/graphene-django/blob/2e806384f60505a29745752bf9c477c71668f0fa/graphene_django/views.py#L154), delivers a [GraphiQL Playground](https://github.com/graphql/graphiql#graphiql) that can be used
to explore ATLAS GraphQL fields.
duptextfinder 0.3.0
Detect duplicated zones in (clinical) text
License: MIT
Keywords: TEXT,DUPLICATION,DUPLICATE,CLINICAL

# Duplicate Text Finder

`duptextfinder` is a python library to detect duplicated zones in text. Primarily meant to detect
copy/paste across medical documents. Should be faster than python's built-in
`difflib` algorithm and more robust to whitespace, newlines and other irrelevant
characters.

## Installation

`duptextfinder` can be installed through pip:

```
pip install duptextfinder
```

## Usage

```python3

from pathlib import Path
from duptextfinder import CharFingerprintBuilder, DuplicateFinder

# load some text files
texts = [p.read_text() for p in Path("some/dir").glob("*.txt")]

# init fingerprint and duplicate finder
fingerprintBuilder = CharFingerprintBuilder(fingerprintLength=15)
duplicateFinder = DuplicateFinder(fingerprintBuilder, minDuplicateLength=15)

# call findDuplicates() on each file
for i, text in enumerate(texts):
    id = f"D{i}"
    duplicates = duplicateFinder.findDuplicates(id, text)
    for duplicate in duplicates:
        print(
            f"sourceDoc={duplicate.sourceDocId}, "
            f"sourceStart={duplicate.sourceSpan.start}, "
            f"sourceEnd={duplicate.sourceSpan.end}, "
            f"targetStart={duplicate.targetSpan.start}, "
            f"targetEnd={duplicate.targetSpan.end}"
        )
        duplicated_text = text[duplicate.targetSpan.start : duplicate.targetSpan.end]
        print(duplicated_text)
```

`WordFingerprintBuilder` can be used instead of `CharFingerprintBuilder`. For
more details, refer to the docstrings of `DuplicateFinder`,
`CharFingerprintBuilder` and `WordFingerprintBuilder`.

## How to run tests

1. Install package in editable mode with test and extra dependencies by running `pip install -e ".[tests, ncls, intervaltree]"` in the repo directory
2. Launch `pytest tests/`

## About ncls and intervaltree

This tool can be used without any additional dependencies, but performance can
be improved when using interval trees. To benefit from this you well need to
install either the [ncls](https://github.com/biocore-ntnu/ncls) package or the
[intervaltree](https://github.com/chaimleib/intervaltree) package.


## References
- Evaluating the Impact of Text Duplications on a Corpus of More than 600,000 Clinical Narratives in a French Hospital. https://www.hal.inserm.fr/hal-02265124/
SuitecrmPythonClient 0.0.8
Python package which provides Suitecrm Client
License: MIT

 # SuiteCRMPythonClient

[![PyPI version](https://badge.fury.io/py/SuitecrmPythonClient.svg)](https://badge.fury.io/py/SuitecrmPythonClient)

Python Client Library for interfacing with SuiteCrm.

 ## Aims
 ## Usage examples
 ## Background
kait 0.2.1
Kait - Kubernetes AI Tool
License: MIT
Requires Python: >=3.8, <3.12

![Python Version](https://img.shields.io/badge/3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-blue)

# Kait (Kubernetes AI Tool)

`kait` is an AI assisted kubernetes debugging tool which automatically troubleshoots, diagnoses, and fixes issues related to kubernetes.

`kait` uses autonomous AI agents built using Microsoft's [AutoGen](https://microsoft.github.io/autogen/)

## Installation and setup

You can install `kait` directly using pip:

```bash
pip install kait
```

`kait` requires an OpenAI API key which is read via the environment variable KAIT_OPENAI_KEY. You can provide a list of models to use and `kait` will use the available model. It is recommended to use models with the capabilities of gpt-4. Larger contexts work better too e.g. 'gpt-4-1106-preview'. Your environment variable needs to point to a list of models in the following format:

```
[
    {
        "model": "gpt-4",
        "api_key": "YOUR_OPENAI_API_KEY"
    }
]
```

## Usage

`kait` requires kubectl to be installed and authenticated against the cluster you want to use.

To run `kait` simply run:

```bash
kait debug <DESCRIPTION OF THE ISSUE TO DEBUG>
```

For a full list of options, run:

```bash
kait debug --help
```

## Examples

A number of [examples/](examples/README.md) are provided so you can see how `kait` performs.