semvec/pypi-packages huggingface dataset:
pyconverters-mistralocr 0.5.102
Convert PDF to structured text using MistralOCR
Requires Python: >=3.8

# pyconverters_mistralocr

[![license](https://img.shields.io/github/license/oterrier/pyconverters_mistralocr)](https://github.com/oterrier/pyconverters_mistralocr/blob/master/LICENSE)
[![tests](https://github.com/oterrier/pyconverters_mistralocr/workflows/tests/badge.svg)](https://github.com/oterrier/pyconverters_mistralocr/actions?query=workflow%3Atests)
[![codecov](https://img.shields.io/codecov/c/github/oterrier/pyconverters_mistralocr)](https://codecov.io/gh/oterrier/pyconverters_mistralocr)
[![docs](https://img.shields.io/readthedocs/pyconverters_mistralocr)](https://pyconverters_mistralocr.readthedocs.io)
[![version](https://img.shields.io/pypi/v/pyconverters_mistralocr)](https://pypi.org/project/pyconverters_mistralocr/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyconverters_mistralocr)](https://pypi.org/project/pyconverters_mistralocr/)

Convert PDF to structured text using [MistralOCR](https://github.com/kermitt2/mistralocr)

## Installation

You can simply `pip install pyconverters_mistralocr`.

## Developing

### Pre-requesites

You will need to install `flit` (for building the package) and `tox` (for orchestrating testing and documentation building):

```
python3 -m pip install flit tox
```

Clone the repository:

```
git clone https://github.com/oterrier/pyconverters_mistralocr
```

### Running the test suite

You can run the full test suite against all supported versions of Python (3.8) with:

```
tox
```

### Building the documentation

You can build the HTML documentation with:

```
tox -e docs
```

The built documentation is available at `docs/_build/index.html.
stackit-runcommand 1.1.1
STACKIT Run Commands Service API
Requires Python: <4.0,>=3.9

# stackit.runcommand
API endpoints for the STACKIT Run Commands Service API


This package is part of the STACKIT Python SDK. For additional information, please visit the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.


## Installation & Usage
### pip install

```sh
pip install stackit-runcommand
```

Then import the package:
```python
import stackit.runcommand
```

## Getting Started

[Examples](https://github.com/stackitcloud/stackit-sdk-python/tree/main/examples) for the usage of the package can be found in the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.
stackit-logs 0.2.0
STACKIT Logs API
Requires Python: <4.0,>=3.9

# stackit.logs
This API provides endpoints for managing STACKIT Logs.



This package is part of the STACKIT Python SDK. For additional information, please visit the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.


## Installation & Usage
### pip install

```sh
pip install stackit-logs
```

Then import the package:
```python
import stackit.logs
```

## Getting Started

[Examples](https://github.com/stackitcloud/stackit-sdk-python/tree/main/examples) for the usage of the package can be found in the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.
stackit-kms 0.7.0
STACKIT Key Management Service API
Requires Python: <4.0,>=3.9

# stackit.kms
This API provides endpoints for managing keys and key rings.



This package is part of the STACKIT Python SDK. For additional information, please visit the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.


## Installation & Usage
### pip install

```sh
pip install stackit-kms
```

Then import the package:
```python
import stackit.kms
```

## Getting Started

[Examples](https://github.com/stackitcloud/stackit-sdk-python/tree/main/examples) for the usage of the package can be found in the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.
dissect.util 3.24.dev4
A Dissect module implementing various utility functions for the other Dissect modules
Requires Python: >=3.10.0

# dissect.util

A Dissect module implementing various utility functions for the other Dissect modules. For more information, please see
[the documentation](https://docs.dissect.tools/en/latest/projects/dissect.util/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

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

```bash
pip install dissect.util
```

`dissect.util` includes both a pure Python implementation as well as a faster native Rust implementation of the LZ4 and LZO decompression algorithms.
Pre-build wheels are available for most common platforms and the native implementation will automatically be used.
In the rare case that a pre-build wheel is not available, the pure Python implementation will automatically be used instead.
If you wish to build your own wheel in the case a pre-build one is not available for your platform, you can do so by running the following command:

```bash
tox -e build-native
```

Note that you'll need to bring your own Rust toolchain for the target platform you wish to build a wheel for. For example, using [rustup](https://rustup.rs).

## 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/dissect>.

License terms: Apache License 2.0 (<https://www.apache.org/licenses/LICENSE-2.0>). For more information, see the LICENSE file.
reqstool-python-hatch-plugin 0.1.5
Hatch plugin to process reqstool-python-decorators when building with Hatch
Requires Python: >=3.10


[![Commit Activity](https://img.shields.io/github/commit-activity/m/Luftfartsverket/reqstool-python-hatch-plugin?label=commits&style=for-the-badge)](https://github.com/Luftfartsverket/reqstool-python-hatch-plugin/pulse)
[![GitHub Issues](https://img.shields.io/github/issues/Luftfartsverket/reqstool-python-hatch-plugin?style=for-the-badge&logo=github)](https://github.com/Luftfartsverket/reqstool-python-hatch-plugin/issues)
[![License](https://img.shields.io/github/license/Luftfartsverket/reqstool-python-hatch-plugin?style=for-the-badge&logo=opensourceinitiative)](https://opensource.org/license/mit/)
[![Build](https://img.shields.io/github/actions/workflow/status/Luftfartsverket/reqstool-python-hatch-plugin/build.yml?style=for-the-badge&logo=github)](https://github.com/Luftfartsverket/reqstool-python-hatch-plugin/actions/workflows/build.yml)
[![Static Badge](https://img.shields.io/badge/Documentation-blue?style=for-the-badge&link=docs)](https://luftfartsverket.github.io/reqstool-python-hatch-plugin/reqstool-python-hatch-plugin/0.0.2/index.html)



## Description

This documentation provides information on how to use the Reqstool Hatch Plugin. The plugin is designed to be used with the Hatch build tool and facilitates the integration of the Reqstool Decorators in your project.

## Installation

To use the Reqstool Hatch Plugin, follow these steps:

- Update your project dependencies in the `pyproject.toml` file and 
ensure that the Reqstool Decorators' dependency is listed as follows;
``` 
dependencies = ["reqstool-python-decorators == <version>"]
```

When you declare this in the pyproject.toml file, you are specifying the required versions for the dependency of the Reqstool Decorators. This ensures that the correct version of the dependencies are used when installing and running your project.



## Usage

### Configuration

The plugin can be configured through the `pyproject.toml` file. Configure plugin in `pyproject.toml`as follows;

```toml
[tool.hatch.build.hooks.reqstool]
dependencies = ["reqstool-python-hatch-plugin == <version>"]
sources = ["src", "tests"]
dataset_directory = "docs/reqstool"
output_directory = "build/reqstool"
test_results = ["build/**/junit.xml"]
```

It specifies that the reqstool-python-hatch-plugin is a dependency for the build process, and it should be of a specific version. 

Further it defines the paths where the plugin should be applied. In this case, it specifies that the plugin should be applied to files in the src and tests directories.
gitfucktime 1.0.1
A CLI tool to rewrite git timestamps to standard work hours.
Requires Python: >=3.7

# Git Fuck Time

<p align="center">
  <img src="https://github.com/G0razd/gitfucktime/raw/master/logo.png" alt="Git Fuck Time Logo" width="300">
</p>

<p align="center">
  <a href="https://pypi.org/project/gitfucktime/">
    <img src="https://img.shields.io/pypi/v/gitfucktime.svg" alt="PyPI version">
  </a>
</p>

**Because nobody needs to know you were debugging CSS at 3 AM on a Saturday.**

`gitfucktime` is a CLI utility that scrubs your git commit timestamps and spreads them out over a healthy, respectable 9-5, Monday-to-Friday schedule. 

Gaslight your boss, your colleagues, and even your future self into believing you have a perfect work-life balance.

## Features

-   **9-to-5 Only**: Automatically shifts commits to "standard" business hours (09:00 - 17:00).
-   **No Weekends**: Skips Saturdays and Sundays, because you definitely have a life outside of work.
-   **Smart Detection**: Automatically picks up where you left off. It looks at your last pushed commit and starts falsifying... er, *correcting*... timestamps from the very next workday.
-   **Interactive Dashboard**: Run it without arguments to see a pretty summary of your shame (unpushed commits) and fix them with one click.

## Prerequisites

-   **Git**: You need to have `git` installed (duh).
-   **Python 3.7+**: Because we have standards.

## Installation

```bash
pip install gitfucktime
```

Congratulations, you are now a "morning person".

## Usage

### 1. The "I Just Woke Up and Fixed This" Mode (Recommended)
Automatically detects your unpushed commits and spreads them out starting from the next logical work day after your last push.

```bash
# Run the interactive dashboard
gitfucktime

# Or do it silently
gitfucktime -u
```

### 2. The "Crunch Time" Cover-Up
Rewrites your last 10 commits to look like a productive week rather than a panic-fueled all-nighter.

```bash
gitfucktime --last 10
```

### 3. The micromanager
Manually specify the exact dates you want your work to appear in. We won't judge.

```bash
gitfucktime --start 2025-01-01 --end 2025-01-10
```

## CLI Reference

| Flag | Short | What it does |
| :--- | :--- | :--- |
| `--start` | `-s` | Start date (YYYY-MM-DD). The day you *allegedly* started working. |
| `--end` | `-e` | End date (YYYY-MM-DD). The day you *allegedly* finished. |
| `--unpushed`| `-u` | Only fixes commits you haven't exposed to the public yet. |
| `--last N` | `-l` | Fixes the last N commits. |
| `--first N` | `-f` | Fixes the first N commits (for fresh repos). |
| `--version` | `-v` | Version info. |
| `--help` | `-h` | Shows the help menu. |

## ⚠️ warning ⚠️

**This tool rewrites git history.**

This changes commit hashes. If you use this on a shared branch that others have already pulled, **they will hate you**. 

Only use this on:
1.  Your own local feature branches before you push.
2.  Personal projects where you are the benevolent dictator.

**ALWAYS MAKE A BACKUP BEFORE RUNNING.**

```bash
cp -r my-project my-project-backup
```
psengine 2.4.2
psengine is a simple, yet elegant, library for rapid development of integrations with Recorded Future.
Requires Python: <3.14,>=3.9
Keywords: API, Recorded Future, Cyber Security Engineering, Threat Intelligence

**Documentation**: <https://recordedfuture-professionalservices.github.io/psengine/>

**Github**: <https://github.com/RecordedFuture-ProfessionalServices/psengine>

**PyPi**: <https://pypi.org/project/psengine/>

---

PSEngine is a simple, yet elegant, library for rapid development of integrations with Recorded Future.

PSEngine allows you to interact with the Recorded Future API extremely easily. There’s no need to manually build the URLs and query parameters, just use the modules dedicated to individual API endpoints.

PSEngine is a Python package solely built and maintained by the Cyber Security Engineering team powering a number of high profile integrations, such as: Elasticsearch, QRadar, Anomali, Jira, TheHive, etc.

## Installation

PSEngine is a Python package that can be installed using `pip`. To install PSengine, run the following command:

```bash
pip install psengine
```

PSEngine officially supports Python >= 3.9, < 3.14.


## Supported Features & Best Practices

PSEngine is ready for the demands of building robust and reliable integrations.

It can easily interact with the following Recorded Future datasets:

- Analyst Notes
- Collective Insights
- Classic & Playbook Alerts
- Detection Rules
- Fusion File management
- Identity Exposures management
- List management
- Malware Sandbox reports download
- On demand IOC enrichment
- Risklists
- Risk History
- STIX conversion


And facilitate the development with features like:

- Built-in logging
- Easy configuration management
- Markdown creation from certain data types
- Proxy support
dgm-dayabay-dev 0.7.1
Implementation of the Daya Bay model for dag-modelling framework. Development version.
Requires Python: >=3.11

# dgm-dayabay-dev

[![python](https://img.shields.io/badge/python-3.11-purple.svg)](https://www.python.org/)
[![pipeline](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/badges/main/pipeline.svg)](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/commits/main)
[![coverage report](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/badges/main/coverage.svg)](https://git.jinr.ru/dagflow-team/dgm-dayabay-dev/-/commits/main)

<!--- Uncomment here after adding docs!
[![pages](https://img.shields.io/badge/pages-link-white.svg)](http://dagflow-team.pages.jinr.ru/dgm-dayabay-dev)
-->

Implementation of the Daya Bay model for `dag-modelling` framework. Development version.

## Repositories

- Main repo:
  - Development/CI: https://git.jinr.ru/dagflow-team/dgm-dayabay-dev
  - Contact/pypi/mirror: https://github.com/dagflow-team/dgm-dayabay-dev
  - PYPI: https://pypi.org/project/dgm-dayabay-dev
openazharmony 0.0.0
OpenAI and Azure compatibility helpers with response format contracts.
Requires Python: >=3.10

# openazharmony

A small compatibility wrapper around the OpenAI Python client, with pydantic
contracts for response formatting and Azure/OpenAI configuration. It provides
chat and responses helpers with unified response_format handling.

- Unified chat/responses helpers
- Pydantic contracts for response_format
- Azure endpoint inference from base_url

## Install

```bash
pip install openazharmony
```

## Quickstart

```python
from openazharmony import HarmonyClient, ResponseFormat

client = HarmonyClient(
    api_key="...",
    model="gpt-4o-mini",
)

response = client.chat(
    question="Say hello",
    response_format=ResponseFormat(type="json_object"),
)
print(response)
```

## Azure quickstart

```python
from openazharmony import HarmonyClient

client = HarmonyClient(
    api_key="...",
    model="gpt-4o-mini",
    azure_endpoint="https://your-resource.openai.azure.com",
    api_version="2024-02-15-preview",
    use_azure_v1_base_url=False,
)
response = client.responses(question="Say hello")
print(response)
```

## Documentation (bundled)

The package ships with offline documentation that is accessible after install:

```bash
python -m openazharmony.docs --list
python -m openazharmony.docs --show PYTHON
python -m openazharmony.docs --show RESPONSE_FORMATS
python -m openazharmony.docs --show AZURE
python -m openazharmony.docs --show EXAMPLES
python -m openazharmony.docs --show LIMITATIONS
python -m openazharmony.docs --show SECURITY
python -m openazharmony.docs --show TROUBLESHOOTING
python -m openazharmony.docs --show FAQ
python -m openazharmony.docs --show CHANGELOG
python -m openazharmony.docs --write-dir .\openazharmony-docs
```

## Python API (core objects)

### `HarmonyClient`

```python
HarmonyClient(
    config: ClientConfig | None = None,
    api_key: str | None = None,
    model: str | None = None,
    base_url: str | None = None,
    azure_endpoint: str | None = None,
    api_version: str | None = None,
    use_azure_v1_base_url: bool = True,
    client: object | None = None,
)
```

### Response format models

```python
ResponseFormat(type="json_object")

ResponseFormat(
    type="json_schema",
    json_schema=JsonSchemaSpec(
        name="summary",
        schema={"type": "object", "properties": {"summary": {"type": "string"}}},
        strict=True,
    ),
)
```