semvec/pypi-packages huggingface dataset:
ZenAuth-server 0.1.2
A user authentication and management library.
Requires Python: >=3.10

# ZenAuth-server

Server-side components for the ZenAuth monorepo.

日本語: see `README_ja.md`.

For how to run the server (Uvicorn) and environment variables, see the repository root README.

- Repository: https://github.com/MeiRakuPapa/ZenAuth

## Bulk import (CSV)

You can bulk create/update users/apps/roles/scopes from CSV.

Script:

- `server/src/scripts/import_csv.py`

### Usage

```bash
python server/src/scripts/import_csv.py \
	--dsn "sqlite+pysqlite:////absolute/path/to/zenauth.sqlite3" \
	--roles roles.csv \
	--scopes scopes.csv \
	--apps apps.csv \
	--users users.csv
```

- `--mode create` fails if a record already exists.
- `--mode upsert` (default) creates or updates.

### CSV formats

#### roles.csv

Headers:

- `role_name` (required)
- `display_name` (optional, defaults to `role_name`)
- `description` (optional)
- `scopes` (optional, comma-separated scope names; binds scopes to the role)

#### scopes.csv

Headers:

- `scope_name` (required)
- `display_name` (optional, defaults to `scope_name`)
- `description` (optional)
- `roles` (optional, comma-separated role names; binds roles to the scope)

#### apps.csv

Headers:

- `app_id` (required)
- `display_name` (optional)
- `description` (optional)
- `return_to` (required; absolute http(s) URL or absolute path starting with `/`)

#### users.csv

Headers:

- `user_name` (required)
- `password` (required for new users)
- `roles` (optional, comma-separated role names)
- `real_name` (optional)
- `division` (optional)
- `description` (optional)
- `policy_epoch` (optional; used for new users; default=1)

If passwords are already hashed (bcrypt), pass `--password-already-hashed`.
msql-driver 0.8.0
Mireo SpaceTime MSQL connector
Requires Python: >=3.10
Keywords: mireo, spacetime, msql, connector, sql, query, spatiotemporal, database

# Mireo SpaceTime MSQL connector

**msql-driver** is a Python module for querying [Mireo SpaceTime database](https://www.mireo.com/spacetime) using [MSQL query language](https://spacetime.mireo.com/msql/).

## Features

- Both **blocking** and **asynchronous** modes of operation are available.
- Query results are convertible to **Python lists**, **NumPy arrays** and **Pandas dataframes**.
- Requires **CPython 3.10+**.
- Available for **Linux** (**glibc** 2.17+ and **musl** 1.2+; x86-64 and arm64), **Windows** (x86-64 and arm64) and **MacOS** (10.12+ x86-64 and 11.0+ arm64).

## Installation

```
pip install -U msql-driver
```

Conversions to NumPy and Pandas data types require those packages that can be installed as optional dependencies:
```
pip install -U msql-driver[numpy]
pip install -U msql-driver[pandas]
pip install -U msql-driver[all]
```

## Example

```
import msql_driver

# Connect
session = msql_driver.SessionConfig().host(<address>).user(<org>, <user>, <password>).build()
print(session.status())  # SessionStatus.Connected

# Run query
res, = session.run_query("select * from st.segment limit 10")

# Print column names and their MSQL data types
print(res.row_type.columns)

# Iterating over rows converts each lazily to a Python list of appropriate Python data types
for row in res:
	print(row)

# Query result can be converted to:
rows = res.to_list()  # Python list of appropriate Python data types
arr = res.to_numpy()  # NumPy array of appropriate NumPy data types (requires numpy)
df = res.to_pandas()  # Pandas dataframe of appropriate NumPy/Pandas data types (requires pandas)

# Disconnect
session.stop()
print(session.status())  # SessionStatus.Stopped
```

## License
Licensed under [BSD 3-Clause “New” or “Revised” License](https://choosealicense.com/licenses/bsd-3-clause/).

## Credits
Authored and maintained by [Mireo](https://www.mireo.com).
gens-input-data-tools 2.0.0
Tools to generate Gens input data
Requires Python: >=3.12

# Generate Gens data

Collection of tools to generate input data to Gens (https://github.com/SMD-Bioinformatics-Lund/gens).

Usage:

```
>>> from gens_input_data_tools import generate_cov_and_baf
```
pyldapsearch 0.1.9
Tool for issuing manual LDAP queries which offers bofhound compatible output
Requires Python: <4.0,>=3.9

# pyldapsearch

This is designed to be a python "port" of the ldapsearch BOF by TrustedSec, which is a part of this [repo](https://github.com/trustedsec/CS-Situational-Awareness-BOF).

pyldapsearch allows you to execute LDAP queries from Linux in a fashion similar to that of the aforementioned BOF. Its output format closely mimics that of the BOF and all query output will automatically be logged to the user's home directory in `.pyldapsearch/logs`, which can ingested by [bofhound](https://github.com/coffeegist/bofhound).

## Why would I ever use this?
Great question. pyldapsearch was built for a scenario where the operator is utilizing Linux and is attempting to issue LDAP queries while flying under the radar (BloodHound will be too loud, expensive LDAP queries are alerted on, etc). When pyldapsearch is combined with bofhound, you can still obtain BloodHound compatible data that allows for AD visualization and identification of ACL-based attack paths, which are otherwise difficult to identify through manually querying LDAP.

Outside of usage during detection-conscious and bofhound-related situations, pyldapsearch can be useful for issuing targeted, one-off LDAP queries during generic engagements.

## Installation
Use `pip3` or `pipx`
```
pip3 install pyldapsearch
```

## Usage
![](.github/help.png)

## Examples
Query all the data - if you intend to do this, just run BloodHound :)
```
pyldapsearch ez.lab/administrator:pass '(objectClass=*)'
```

Query only the name, memberOf and ObjectSID of the user matt
```
pyldapsearch ez.lab/administrator:pass '(sAMAccountName=matt)' -attributes name,memberof,objectsid
```

Query all attributes for all user objects, but only return 3 results
```
pyldapsearch ez.lab/administrator:pass '(objectClass=user)' -limit 3
```

Query all attributes of the user matt, specifying the IP of the DC to query
```
pyldapsearch ez.lab/administrator:pass '(&(objectClass=user)(name=matt))' -dc-ip 10.4.2.20
```

Query all objects, specifying the search base to use
```
pyldapsearch ez.lab/administrator:pass '(objectClass=*)' -base-dn 'CN=Users,DC=EZ,DC=LAB'
```

Execute a query without displaying query results to the console (results will still be logged)
```
pyldapsearch ez.lab/administrator:pass '(objectClass=*)' -silent
```

Perform a query using an anonymous bind
```
pyldapsearch 'ez.lab'/'':'' '(objectClass=*)'
```

Perform a query across a domain trust
```
pyldapsearch ez.lab/administrator:pass '(objectClass=*)' -base-dn 'DC=otherdomain,DC=local' -dc-ip 10.1.4.20
```

## Development
pyldapsearch uses Poetry to manage dependencies. Install from source and setup for development with:
```shell
git clone https://github.com/fortalice/pyldapsearch
cd pyldapsearch
poetry install
poetry run pyldapsearch
```

## References
- ldapsearch ([CS-Situational-Awareness-BOF](https://github.com/trustedsec/cs-situational-awareness-bof))
- [ldapconsole](https://github.com/p0dalirius/ldapconsole)
zhinst-utils 0.7.1
Zurich Instruments utils for device control
Requires Python: >=3.7

[![PyPI version](https://badge.fury.io/py/zhinst-utils.svg)](https://badge.fury.io/py/zhinst-utils)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
[![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/fold_left.svg?style=social&label=Follow%20%40zhinst)](https://twitter.com/zhinst)

# Utils for Zurich Instruments LabOne API

zhinst-utils provides a set of helper functions for the native LabOne Python API
called [zhinst.core](https://pypi.org/project/zhinst-core).

It offers higher level functions to ease the communication with
[Zurich Instruments](https://zhinst.com) devices. It is not intended to be a
separate layer above ``zhinst.core`` but rather as an addition.

Apart for a set of not device specific functions the utility also provide
specific functionality for some devices. Currently including:
* SHFQA
* SHFSG
* SHFQC

To see the device utils in action check out the
[LabOne API examples](https://github.com/zhinst/labone-api-examples).

## Installation
Python 3.7+ is required.
```
pip install zhinst-utils
```

## Usage
```
import zhinst.utils.shfqa
import zhinst.utils.shfsg
import zhinst.utils.shfqc

help(zhinst.utils.shfqa)
help(zhinst.utils.shfsg)
help(zhinst.utils.shfqc)
```

## About

More information about programming with Zurich Instruments devices is available in the
[LabOne API Documentation](https://docs.zhinst.com/labone_api_user_manual/).
pyannoteai-sdk 0.4.0
Official pyannoteAI Python SDK
Requires Python: >=3.10

<p align="center">
  <a href="https://pyannote.ai/" target="blank"><img src="https://avatars.githubusercontent.com/u/162698670" width="64" /></a>
</p>

<div align="center">
    <h1>Official pyannoteAI Python SDK </h1>
</div>

## Installation

```bash
$ pip install pyannoteai-sdk
```

Then head over to [`dashboard.pyannote.ai`](https://dashboard.pyannote.ai) and create an API key.

## Speaker diarization

```python
# instantiate client
from pyannoteai.sdk import Client
client = Client("your-api-key")

# upload conversation file
media_url = client.upload('/path/to/conversation.wav')

# submit a diarization job
job_id = client.diarize(media_url)

# retrieve diarization
diarization = client.retrieve(job_id)
# diarization['output']['diarization'] contains diarization output
```

Use `help(client.diarize)` to learn about options.

## STT orchestration

```python
# submit a diarization job with STT orchestration
job_id = client.diarize(
  media_url, 
  transcription=True,
  transcription_config={"model": "parakeet-tdt-0.6b-v3"})

# retrieve speaker-attributed transcription
orchestration = client.retrieve(job_id)
# orchestration['output']['turnLevelTranscription'] 
# orchestration['output']['wordLevelTranscription']
```

## Speaker identification

```python
# create a voiceprint from a sample of Lex's voice
lex_url = client.upload('/path/to/lex.wav')
job_id = client.voiceprint(lex_url)
lex = client.retrieve(job_id)
# lex['output']['voiceprint'] contains Lex's voiceprint

# create a voiceprint from a sample of Mark's voice
mark_url = client.upload('/path/to/mark.wav')
job_id = client.voiceprint(mark_url)
mark = client.retrieve(job_id)
# mark['output']['voiceprint'] contains Mark's voiceprint

# use those voiceprints to track Lex and Mark in the conversation
voiceprints = {'lex': lex['output']['voiceprint'], 'mark': mark['output']['voiceprint']}
job_id = client.identify('/path/to/conversation.wav', voiceprints)
identification = client.retrieve(job_id)
# identification['output']['identification'] contains identification output
```

Use `help(client.identify)` to learn about options.