semvec/pypi-packages huggingface dataset:
antibodyomics 0.0.1.1
An antibodyomics library
Requires Python: >=3.7

## About

---

**Source Code**: <a href="https://https://github.com/drewschaub/antibodyomics" target="_blank">https://https://github.com/drewschaub/antibodyomics</a>

---

Antibodyomics is a python library for performing structural and genetic  bioinformatic analysis in python. 

## Installation

---

Installation is handled using the python package installer `pip`

```console
$ pip install antibodyomics
```

## License

[![License](https://img.shields.io/github/license/drewschaub/antibodyomics)](https://opensource.org/licenses/MIT)

- Copyright © Andrew J. Schaub
antibodyomics-test 0.0.1
An antibodyomics library
Requires Python: >=3.7

# antibodyomics

## Backend

I'm using setuptools, but other options were Hatchling, Flit and PDM

https://packaging.python.org/en/latest/tutorials/packaging-projects/


## Action Items

1. I need to add the required packages to `pyproject.toml`
rvid.tex-runner 0.2.0
Utility functions for rendering XeLaTeX documents from Python
Requires Python: >=3.11

# rvid.tex-runner

A small utility to ease programmatic usage of LaTeX from Python.

## Calling XeLaTeX on output

If you just run the `xelatex` command, you'll get a bunch of temp files output
to your current working directory. You also get a few screenfulls of debug out that
you only really want to see if something goes wrong. No big deal, but a bit of faff.

The function `rvid.tex_runner.make_pdf_at_path()` finds the xelatex-command, creates a
temp-directory, runs the command, moves the PDF-file into the location you
specified and then cleans up all the temp files.

```
def make_pdf_at_path(
    tex_content=a_string_that_holds_tex_source,
    target_path="/home/apa/bepa.pdf"
) 
```

If you want the resulting PDF returned as a bytestream instead written to disk, just
use `rvid.tex_runner.make_pdf_as_bytestream()` instead.

## When there is an error

XeLaTeX is run in nonstop mode and will not drop to an interactive prompt if there is a
problem. If a non-zero exit code is returned, the XeLaTeX output will be dumped to
stdout, even in silent mode.

## Handling paths to external resources

To handle external resources that are needed to build your PDF files, tex-runner has a
concept of `ExternalResource`. This is a Python object that contains a sequence of
absolute file paths and a relative target path (`basedir`) where your .tex files expect
to be able to include them from. For example:

```
ExternalResource(
    basedir="images",
    files=[
        "/Users/sean.banan/tex/img1.png",
        "/Users/sean.banan/tex/img2.png",
    ]
)
```

This concept also comes in handy if you have differing paths in different deployment
environments, since it allows you to abstract that away programmatically.

### Auto-generating ExternalResource-libraries

There is a utility function for auto-generating ExternalResource-objects from filesystem
paths:

```
>>> make_external_resource_library(source_directory="c:/pix", relative_target_directory="img")
ExternalResource(basedir="img", files=["c:/pix/q1.jpg"])
```

## Debugging

Change `rvid.tex_runner.latex:make_pdf_in_tempdir()` so that it doesn't delete
the tempdir after finishing the run.
aioauthx 0.1.1
HTTPX-style authorization schemes for aiohttp.
Requires Python: >=3.7

# aioauthx

`aioauthx` adds [HTTPX](https://github.com/encode/httpx/blob/master/httpx/_auth.py)-style authentication strategies to [aiohttp](https://github.com/aio-libs/aiohttp) allowing `ClientSession`'s to support digest, negotiate, oauth2, etc.

## Installation

You can install `aioauthx` with `pip`

`pip install aioauthx`

See below for a list of optional dependencies

## Usage

`aioauthx` works by providing a framework to support different authentication schemes and wrapping that scheme in `ClientRequest` and `ClientResponse` types that can be passed directly to `ClientSession`. For example...

**Note: The `NegotiateAuth` flow requires `pywin32`. You can use the optional dependency.**

`pip install "aioauthx[win]"`

```python
from aioauthx import create_auth_handlers
from aioauthx.flows.negotiate import NegotiateAuth
from aiohttp import ClientSession


async def make_request(session: ClientSession) -> ...:
    resp = await session.get(...)
    ...
    
async def main() -> None:
    flow = NegotiateAuth(...)
    request_class, response_class = create_auth_handlers(flow)
    async with ClientSession(
        request_class=request_class, response_class=response_class
   	) as session:
        await make_request(session)
```

## Creating Flows

All flows inherit from `Auth`. The flow itself is an async generator that manipulates the request object being sent. To dispatch a request `yield`. Unlike HTTPX, you do not yield a request to the client, you manipulate a request in place. Yielding just lets the client know it can send the request as constructed. Upon executing the request, the client will `send()` the response back to the flow generator. We will illustrate this by building a basic auth flow (aiohttp supports basic auth out of the box, this is just for demonstration purposes)...

```python
from collections.abc import AsyncGenerator

from aioauthx import Auth
from aiohttp import ClientRequest, ClientResponse, hdrs
from aiohttp.connector import Connection


class BasicAuth(Auth):
    def __init__(self, username: str, password: str) -> None:
        self.username, self.password = username, password
        
    async def flow(
        self,
        request: ClientRequest,
        connection: Connection
   	) -> AsyncGenerator[None, ClientResponse]:
        userpass = b":".join((to_bytes(self.username), to_bytes(self.password)))
        token = b64encode(userpass).decode()
        auth_header = f"Basic {token}"
        request.headers[hdrs.AUTHORIZATION] = auth_header
        
        # In terms of the auth scheme we are done so we could just yield here
        # and that would be it. Like so...
        # yield
        # return
        
        # However, if we want to see how to use the response we can yield and
        # expect the response...
        response = yield
        print(response.status)
        
```

## Optional Dependencies

- aioauthx[win] -> pywin32
printf-log-formatter 0.3.0
Convert logger f-strings and str.format syntax to printf-style strings
Requires Python: >=3.7
Keywords: linter,formatter,logging,sentry

<a href="https://github.com/sondrelg/printf-log-formatter"><img src="https://raw.githubusercontent.com/sondrelg/printf-log-formatter/main/logo.svg?token=GHSAT0AAAAAACAOR4AAQVLI3YMI4IZKDAYCZBS5KOA&sanitize=true" alt="logo" width="110" align="right"></a>

# printf-log-formatter

Automatically convert f-strings and `str.format()` syntax to printf-style strings.

In other words, this syntax

```python
logger.error(f"{1}")
logger.error("{}".format(1))
logger.error("{foo}".format(foo=1))
```

is changed to

```python
logger.error("%s", 1)
logger.error("%s", 1)
logger.error("%s", 1)
```


## Motivation

Why would we want to do this? [This article](https://blog.pilosus.org/posts/2020/01/24/python-f-strings-in-logging/) explains it pretty well.

Mainly it's useful for Python projects using [Sentry](https://sentry.io)'s log integration.

## Installation

You have two options for running this pre-commit hook:


### Python hook

If you would like to install this using Python, run:

```shell
pip install printf-log-formatter
```

then set the pre-commit hook up using:

```yaml
- repo: local
  hooks:
  - id: printf-log-formatter
    name: printf-log-formatter
    entry: printf-log-formatter
    language: system
    types: [ python ]
    args:
      - --log-level=error
```


### Rust hook

If you're happy to compile the Rust version, you can use:

```yaml
- repo: https://github.com/sondrelg/printf-log-formatter
  rev: ''
  hooks:
    - id: printf-log-formatter
      args:
        - --log-level=error
```

## I just want to downgrade loggers once

The Rust binary or Python package can also be run directly, like this:

```shell
printf-log-formatter $(find . -name "*.py") --log-level error
```
cs-nds 0.3.1
Often used things for Computer Science classes


# Computer Science Niedersachsen

This Library contains often used methods and classes
for Computer Science classes in Niedersachsen (Lower Saxony), Germany.

The initial and main reason for creation of this library
is an implementation of the `Stack` and `Queue` classes,
which differ from the Python implementation.

**Disclaimer:**
Although I try to give my best to provide a useful tool,
I cannot guarantee it always working correctly and being
up-to-date with the latest specifications.

If you encounter a problem, please open an [issue](https://github.com/alexcoder04/cs_nds/issues).

## Installation

This package is available over `pip`:

```sh
pip install cs-nds
```

To use it in your code, just import it:

```python
import cs_nds

my_queue = cs_nds.Queue()
my_queue.enqueue(3)

# ...
```

## Data Structures

 - `Stack` ("Stapel" / stack)
 - `Queue` ("(Warte-)Schlange" / queue)
 - `DynArray` ("Dynamische Reihung" / dynamic array)
 - `BinTree` ("Binärbaum" / binary tree)
swagroutes 1.0.2
Command-line tool that extracts and lists API routes from Swagger files in YAML or JSON format.
Requires Python: >=3.6

# swagroutes

swagroutes is a command-line tool that extracts and lists API routes from Swagger files in YAML or JSON format. It simplifies the process of fetching the routes provided by an API and supports processing multiple files or directories at once.

![](https://user-images.githubusercontent.com/3582096/233068257-29adfadd-8cd3-45fd-9d1d-f22a9772d139.png)

## Install

```bash
pip install swagroutes
```

## Upgrade
```bash
pip install -U swagroutes
```

## Help
```
usage: swagroutes [-h] [-o OUTPUT] [-p] input [input ...]

Extract routes from Swagger files.

positional arguments:
  input                 Input file(s) or directory containing Swagger files.

options:
  -h, --help            show this help message and exit
  -o OUTPUT, --output OUTPUT
                        Output file to store the results.
  -p, --include-params  Include query parameters in the extracted routes.
```

## Usage
To use swagroutes, simply provide input files or directories containing Swagger files as arguments. The tool will process the files and print the extracted routes.

#### Single YAML or JSON file
```bash
swagroutes file.yaml
```

```bash
swagroutes file.json
```

#### Multiple YAML and/or JSON files

```bash
swagroutes file1.yaml file2.json
```

#### Directory containing Swagger files
```bash
swagroutes directory/
```

#### Mix of files and directories
```bash
swagroutes file1.yaml directory1/ file2.json directory2/
```

#### Extract parameters
```bash
swagroutes file1.yaml --include-params
```

#### Output to a file
Save the extracted routes to an output file using the `-o` or `--output` option:

```bash
swagroutes file.yaml -o output.txt 
```


## Examples

**Input:**
```yaml
basePath: /api
paths:
  /users:
    get: {}
    post: {}
  /profile/{profile_id}:
    put: {}
```

**Output:**

```
GET /api/users
POST /api/users
PUT /api/profile/{profile_id}
```

---

**Input:**
```yaml
basePath: /api/v1
paths:
  /users:
    get:
      parameters:
        - name: limit
          in: query
        - name: offset
          in: query

  /users/{userId}:
    get:
      parameters:
        - name: userId
          in: path
          required: true
          type: string
```

**Output:**
```
GET /api/v1/users/{userId}
GET /api/v1/users?limit&offset
```
nlpie 0.3.2
A lightweight clinical entity linking tool using distilled clinical language models from Huggingface and spaCy/ScispaCy

# NLPIE: A Lightweight Entity Linker

A lightweight entity linking tool using distilled clinical language models from Huggingface and spaCy/ScispaCy intended to connect clinical notes to UMLS codes. Additional mapping is available for ICD-10 and SNOMED CT entries. 

## Repository Structure

```
.
├── README.md
├── entity_linker.py
├── entity_linker_hf.py
├── mappings-from-UMLS
│ ├── cui_to_icd10_EXACT.json
│ ├── cui_to_icd10_RO.json
│ ├── cui_to_snomed_EXACT.json
│ └── cui_to_snomed_RO.json
├── preprocessor.py
├── query_filter.py
└── requirements.txt
```

## Installation

Install the required packages by running:

 
```bash
pip install nlpie
```

## Usage
### Preprocessor

Use the `InputPreprocessor` class in `preprocessor.py` to preprocess an input CSV file:


```python
from preprocessor import InputPreprocessor

input_path = 'input.csv'
output_path = 'preprocessed.csv'

preprocessor = InputPreprocessor(input_path)
preprocessed_data = preprocessor.preprocess_input_file(output_path)
```

## Query Filter

Use the `QueryFilter` class in `query_filter.py` to filter a preprocessed CSV file based on a text query:

```python
from query_filter import QueryFilter

query = "pneumonia"
input_csv_path = "preprocessed.csv"

query_filter = QueryFilter()
query_umls_codes = query_filter.process_query(query)
filtered_data, negated_rows = query_filter.filter_rows(query_umls_codes, input_csv_path)
query_filter.save_filtered_data_to_csv(filtered_data, negated_rows, query, input_csv_path)
```
circleci-stubs 0.1.3
Typing stubs for CircleCI

# CircleCI-Stubs

This repository contains type stubs for the [CircleCI](https://circleci.com/) library. The purpose of this package is to provide type hinting and improved type checking for users of the CircleCI library until the primary library includes the `py.typed` file.

## Installation

To install the CircleCI stubs, simply use `pip`:

```bash
pip install circleci-stubs
```

## Usage
After successfully installing the circleci-stubs package, type hinting and type checking for the CircleCI library should start working automatically with mypy or other compatible tools.

## Status
This package is meant to be a temporary solution, and we will gladly remove it once the main CircleCI library updated to include the required py.typed file.
We do not claim any warranties, and we are not affiliated with the original library maintainers.

## Contributing
If you find any issues or improvements in the stubs provided here, please feel free to open a Pull Request or an Issue on the project's GitHub repository.

## License
This package is released under the [MIT License](LICENSE).

## Acknowledgments
The circleci-stubs package is not officially affiliated with CircleCI or the original library. It is an independent effort by the community, intended to benefit users by providing type checking until the original library is updated.