semvec/pypi-packages huggingface dataset:
scrapli-scp 0.1.0
scrapli_scp
Requires Python: >=3.6

===========
Scrapli SCP
===========
Welcome to Scrapli SCP project!

This project is about to add smart SCP capability to Scrapli based connections.
By smart, I mean various checks before and after the file copy to ensure the file copy is possible
and successful.

These are the checks done by default:

#. checksum
#. existence of file at destination (also with hash)
#. available space at destination
#. scp enablement on device (and tries to turn it on if needed)
#. restore configuration after transfer if it was changed
#. check MD5 after transfer

Requirements
------------
``scrapli``, ``scrapli-community``, ``asyncssh``, ``aiofiles``

Installation
------------
.. code-block:: console

    $ pip install scrapli-scp


Simple example
--------------
You can find it in ``test`` folder but the main part:

.. code-block:: python

    async with AsyncScrapli(**device) as conn:
        scp = AsyncSrapliSCP(conn)
        result = await scp.file_transfer("put", src=filename, dst=".", force_scp_config=True)
    print(result)

Progress bar example
--------------------

.. code-block:: python

    from rich.progress import Progress

    with Progress(refresh_per_second=100) as progress:
        task = progress.add_task("Getting config...")

        def progress_handler(srcpath: bytes, dstpath: bytes, copied: int, total: int):  # arg signature is important!
            progress.update(task, completed=copied, total=total, description=dstpath.decode())

        async with AsyncScrapli(**device) as conn:
            scp: AsyncSCPFortiOS = AsyncSrapliSCP(conn)
            result = await scp.get_config(
                filename=filename,
                overwrite=True,
                force_scp_config=True,
                progress_handler=progress_handler
            )
    print(result)
dephealth 0.5.0
SDK for monitoring microservice dependencies via Prometheus metrics
Requires Python: >=3.11
Keywords: dependency, health-check, microservices, monitoring, prometheus

# dephealth

SDK for monitoring microservice dependencies via Prometheus metrics.

## Features

- Automatic health checking for dependencies (PostgreSQL, MySQL, Redis, RabbitMQ, Kafka, HTTP, gRPC, TCP)
- Prometheus metrics export: `app_dependency_health` (Gauge 0/1), `app_dependency_latency_seconds` (Histogram), `app_dependency_status` (enum), `app_dependency_status_detail` (info)
- Async architecture built on `asyncio`
- FastAPI integration (middleware, lifespan, endpoints)
- Connection pool support (preferred) and standalone checks

## Installation

```bash
# Basic installation
pip install dephealth

# With specific checkers
pip install dephealth[postgres,redis]

# All checkers + FastAPI
pip install dephealth[all]
```

## Quick Start

### Standalone

```python
from dephealth import DepHealth

dh = DepHealth()
dh.add("postgres", url="postgresql://user:pass@localhost:5432/mydb")
dh.add("redis", url="redis://localhost:6379")

await dh.start()
# Metrics are available via prometheus_client
await dh.stop()
```

### FastAPI

```python
from fastapi import FastAPI
from dephealth_fastapi import DepHealthFastAPI

app = FastAPI()
dh = DepHealthFastAPI(app)
dh.add("postgres", url="postgresql://user:pass@localhost:5432/mydb")
```

## Health Details

```python
details = dh.health_details()
for key, ep in details.items():
    print(f"{key}: healthy={ep.healthy} status={ep.status} "
          f"latency={ep.latency_millis():.1f}ms")
```

## Configuration

| Parameter | Default | Description |
| --- | --- | --- |
| `interval` | `15` | Check interval (seconds) |
| `timeout` | `5` | Check timeout (seconds) |

## Supported Dependencies

| Type | Extra | URL Format |
| --- | --- | --- |
| PostgreSQL | `postgres` | `postgresql://user:pass@host:5432/db` |
| MySQL | `mysql` | `mysql://user:pass@host:3306/db` |
| Redis | `redis` | `redis://host:6379` |
| RabbitMQ | `amqp` | `amqp://user:pass@host:5672/vhost` |
| Kafka | `kafka` | `kafka://host1:9092,host2:9092` |
| HTTP | — | `http://host:8080/health` |
| gRPC | `grpc` | `host:50051` (via `FromParams`) |
| TCP | — | `tcp://host:port` |

## Authentication

HTTP and gRPC checkers support Bearer token, Basic Auth, and custom headers/metadata:

```python
http_check("secure-api",
    url="http://api.svc:8080",
    critical=True,
    bearer_token="eyJhbG...",
)

grpc_check("grpc-backend",
    host="backend.svc",
    port=9090,
    critical=True,
    bearer_token="eyJhbG...",
)
```

See [quickstart guide](../docs/quickstart/python.md#authentication) for all options.

## License

Apache License 2.0 — see [LICENSE](https://github.com/BigKAA/topologymetrics/blob/master/LICENSE).
labmaster 0.3.0a1
A client-server system for linux school labs
Requires Python: >=3.13

# Lab Master

An asyncronous server/client arch  written in python.


## Install

```
sudo apt install pkg-config libsystemd-dev
```

## Configuration

You must provide a configuration file in /opt/labs_manager named config.1 with the following fields:

```
[database]

db_type = mariadb|sqlite
db_user = dbuser
db_path = dbpath (for sqlite)
db_pwd  = db user password
db_host = 192.168.0.1
db_port = 3306
db_name = dbname


[log]
no_session_log= list of users that must not be tracked
watch_groups= list of regexp matching groups to be watched
default_grade=0T,0A
log_dir=/tmp
global_level=debug
console_level=debug
file_level=debug

[server]
key = server aes shared key
address= 127.0.0.1
port= 6666

```
isahitlab 0.14.1
Python client for isahit lab
Requires Python: >=3.8

# isahitlab

[![PyPI - Version](https://img.shields.io/pypi/v/isahitlab.svg)](https://pypi.org/project/isahitlab)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/isahitlab.svg)](https://pypi.org/project/isahitlab)

-----

## Table of Contents

- [Installation](#installation)
- [Documentation](https://sdk-docs.lab.isahit.com/latest)
- [License](#license)

## Installation

```console
pip install isahitlab
```


## License

`isahitlab` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
pyqt-code-editor 0.0.57
Fully featured code-editor widgets for PyQt
Requires Python: >=3.10
Keywords: code editor, pyqt, ide

# Sigmund Analyst (PyQt Code Editor)

Copyright 2025-2026 Sebastiaan Mathôt

- [About](#about)
- [AI integration](#ai-integration)
- [Installation](#installation)
- [License](#license)


## About

Sigmund Analyst is a powerful code editor (also: Integrated Development Environment or IDE) focused on AI-assisted data analysis with Python. It is composed of a set of powerful PyQt/ PySide widgets that can also be used in other applications.

Features:
    
- AI integration [SigmundAI](https://sigmundai.eu) and [Mistral Codestral](https://docs.mistral.ai/capabilities/code_generation/)
- Syntax highlighting
- Code completion
- Code checking
- Project explorer
- Jupyter (IPython) console
- Workspace explorer
- Editor panel with splittable tabs
- Settings panel

![](screenshot.png)


## AI integration

### SigmundAI for collaborative code editing

You can work together with SigmundAI on the currently active document or selected text. To activate SigmundAI integration, simply log into <https://sigmundai.eu> (subscription required). Sigmund Analyst will then automatically connect to SigmundAI when you enable the Sigmund panel in the toolbar.


### Mistral Codestral for as-you-type suggestions

As-you-type code suggestions are provided by Mistral Codestral. To activate Mistral integration, you need to create an account with Mistral AI. Currently, a free Codestral API key is then provided through the Mistral console. Copy-paste this API key to Codestral API Key field in the settings panel of Sigmund Analyst.


## Installation


### Windows

The easiest way to install Sigmund Analys on Windows is to install OpenSesame, which include Sigmund Analyst:

- <https://osdoc.cogsci.nl/download/>


### Linux/ Ubuntu

The easiest way to install Sigmund Analyst on Linux is to download and run the installer script. This will create a Virtual Environment, pip install Sigmund Analyst and all dependencies into this environment, and add a Desktop file to your system to easily start Sigmund Analyst. To upgrade, simply run the script again.

```
bash <(curl -L https://raw.githubusercontent.com/open-cogsci/pyqt_code_editor/refs/heads/master/install_sigmund_analyst.sh)
```


### Other systems

Install with:

```
pip install pyqt_code_editor
```

Start Sigmund Analyst with:

```
sigmund-analyst
```


## License

`PyQt Code Editor` is licensed under the [GNU General Public License
v3](http://www.gnu.org/licenses/gpl-3.0.en.html).
acquire 3.22.dev7
A tool to quickly gather forensic artifacts from disk images or a live system into a lightweight container
Requires Python: >=3.10

# Acquire

`acquire` is a tool to quickly gather forensic artifacts from disk images or a live system into a lightweight container.
This makes `acquire` an excellent tool to, among others, speedup the process of digital forensic triage.
It uses `dissect` to gather that information from the raw disk, if possible.

`acquire` gathers artifacts based on modules. These modules are paths or globs on a filesystem which acquire attempts to gather.
Multiple modules can be executed at once, which have been collected together inside a profile.
These profiles (used with `--profile`) are  `full`, `default`, `minimal` and `none`.
Depending on what operating system gets detected, different artifacts are collected.

The most basic usage of `acquire` is as follows:

```bash
user@dissect~$ sudo acquire
```

The tool requires administrative access to read raw disk data instead of using the operating system for file access.
However, there are some options available to use the operating system as a fallback option. (e.g `--fallback` or `--force-fallback`)

For more information, please see [the documentation](https://docs.dissect.tools/en/latest/projects/acquire/index.html).

## Requirements

This project is part of the Dissect framework and requires Python.

Information on the supported Python versions can be found in the Getting Started section of [the documentation](https://docs.dissect.tools/en/latest/index.html#getting-started).

## Installation

`acquire` is available on [PyPI](https://pypi.org/project/acquire/).

```bash
pip install acquire
```

## Build and test instructions

This project uses `tox` to build source and wheel distributions. Run the following command from the root folder to build
these:

```bash
tox -e build
```

The build artifacts can be found in the `dist/` directory.

`tox` is also used to run linting and unit tests in a self-contained environment. To run both linting and unit tests
using the default installed Python version, run:

```bash
tox
```

For a more elaborate explanation on how to build and test the project, please see [the
documentation](https://docs.dissect.tools/en/latest/contributing/tooling.html).

## Contributing

The Dissect project encourages any contribution to the codebase. To make your contribution fit into the project, please
refer to [the development guide](https://docs.dissect.tools/en/latest/contributing/developing.html).

## Copyright and license

Dissect is released as open source by Fox-IT (<https://www.fox-it.com>) part of NCC Group Plc
(<https://www.nccgroup.com>).

Developed by the Dissect Team (<dissect@fox-it.com>) and made available at <https://github.com/fox-it/acquire>.

License terms: AGPL3 (<https://www.gnu.org/licenses/agpl-3.0.html>). For more information, see the LICENSE file.