semvec/pypi-packages huggingface dataset:
code-with-finn 1.0.2
Helps feed the soul while coding
Requires Python: >=3.7

# code_with_finn

[![PyPI version](https://badge.fury.io/py/code-with-finn.svg)](https://pypi.org/project/code-with-finn/)

A small module that brings the good dog Finn into your Jupyter notebooks.

![demo image](https://github.com/svank/code_with_finn/raw/main/images/error.png)

While Finn can warn you after errors, he can also celebrate successes!

![demo image](https://github.com/svank/code_with_finn/raw/main/images/celebrate.png)

He can also help you prepare yourself before a long stack trace.

![demo image](https://github.com/svank/code_with_finn/raw/main/images/looks_bad.png)

You can send him away if you need to:

![demo image](https://github.com/svank/code_with_finn/raw/main/images/without.png)

Or keep him away with
```python
code_with_finn.announce_errors(False)
code_with_finn.celebrate_success(False)
```

# Installation

Install with
```
pip install code_with_finn
```
pynamodb-attributes 0.5.0
Common attributes for PynamoDB
Requires Python: >=3

This Python 3 library contains compound and high-level PynamoDB attributes:

- `FloatAttribute` – same as `NumberAttribute` but whose value is typed as `float`
- `IntegerAttribute` – same as `NumberAttribute` but whose value is typed as `int` (rather than `float`)
- `IntegerSetAttribute` – same as `NumberSetAttribute` but whose value is typed as `int` (rather than `float`)
- `UnicodeDelimitedTupleAttribute` - a delimiter-separated value, useful for storing composite keys
- `UnicodeEnumAttribute` - serializes a string-valued `Enum` into a Unicode (`S`-typed) attribute
- `UnicodeProtobufEnumAttribute` - serializes a Protobuf enum into a Unicode (`S`-typed) attribute
- `IntegerEnumAttribute` - serializes a int-valued `Enum` into a number (`N`-typed) attribute
- `TimedeltaAttribute`, `TimedeltaMsAttribute`, `TimedeltaUsAttribute` – serializes `timedelta`s as integer seconds, milliseconds (ms) or microseconds (µs)
- `TimestampAttribute`, `TimestampMsAttribute`, `TimestampUsAttribute` – serializes `datetime`s as Unix epoch seconds, milliseconds (ms) or microseconds (µs)
- `IntegerDateAttribute` - serializes `date` as an integer representing the Gregorian date (_e.g._ `20181231`)
- `UUIDAttribute` - serializes a `UUID` Python object as a `S` type attribute (_e.g._ `'a8098c1a-f86e-11da-bd1a-00112444be1e'`)
- `UnicodeDatetimeAttribute` - ISO8601 datetime strings with offset information

## Testing

The tests in this repository use an in-memory implementation of [`dynamodb`](https://aws.amazon.com/dynamodb). To run the tests locally, make sure [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) is running. It is available as a standalone binary, through package managers (e.g. [Homebrew](https://formulae.brew.sh/cask/dynamodb-local)) or as a Docker container:
```shell
docker run -d -p 8000:8000 amazon/dynamodb-local
```

Afterwards, run tests as usual:
```shell
pytest tests
```
ru-mvd-search-wanted 0.0.4
Parser of information from the website of the Ministry of Internal Affairs Search
Requires Python: >3.7


# API MVD Search Wanted Client

> Поиск указанного человека в базе данных [Розыск МВД](https://xn--b1aew.xn--p1ai/wanted)

Requirements:

-   Python 3.7+
-   [httpx](https://pypi.org/project/httpx/)
-   [beautifulsoup4](https://pypi.org/project/beautifulsoup4/)
-   [fake-useragent](https://pypi.org/project/fake-useragent/)

## Installation

```sh
pip install ru_mvd_search_wanted
```


## Usage

Import client:

```python
from ru_mvd_search_wanted.sync import MVDParser
```

Set proxy:

```python
proxy = "user:pass@host:port"
```

Use `with MVDParser()` if you want a context-managed client:

```python


with MVDParser(
    "Фамилия", "Имя", "Отчество", "YYYY", "MM", "DD", "123455@gmail.com", proxy
) as mvd:
    captcha_base64 = mvd.initialize()

    # solve captcha
    # captcha_word = solve(captcha_base64)
    result = mvd.get_result(captcha_word)

    print(result)

```

## Usage  (async)

Import client:

```python
from ru_mvd_search_wanted.asynchr import MVDParserAsync
```

Set proxy:

```python
proxy = "user:pass@host:port"
```

Use `async with MVDParserAsync()` Example:

```python

import asyncio

proxy = "user:pass@host:port"

async def main():
    async with MVDParserAsync(
        "Фамилия",
        "Имя",
        "Отчество",
        "YYYY",
        "MM",
        "DD",
        "123456@gmail.com",
        proxy
    ) as mvd:
        captcha_base64 = await mvd.initialize()

        # solve captcha
        # captcha_word = await solve(captcha_base64)
        result = await mvd.get_result(captcha_word)

        print(result)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())
```
socket-log-receiver 24.3.0b0
A light-weight socket log receiver
Requires Python: >=3.8

[![License](https://img.shields.io/pypi/l/socket-log-receiver.svg)](https://pypi.org/project/socket-log-receiver/)
[![PyPI Version](https://badge.fury.io/py/socket-log-receiver.svg)](https://pypi.org/project/socket-log-receiver/)
[![Package Status](https://img.shields.io/pypi/status/socket-log-receiver.svg)](https://pypi.org/project/resconfig/)
[![pyversion Status](https://img.shields.io/pypi/pyversions/socket-log-receiver.svg)](https://img.shields.io/pypi/pyversions/socket-log-receiver.svg)
[![CircleCI](https://circleci.com/gh/okomestudio/socket-log-receiver.svg?style=shield)](https://circleci.com/gh/okomestudio/socket-log-receiver)
[![Coverage Status](https://coveralls.io/repos/github/okomestudio/socket-log-receiver/badge.svg?branch=development)](https://coveralls.io/github/okomestudio/socket-log-receiver?branch=development&kill_cache=1)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)


# Socket Log Receiver

`socket_log_receiver` is a light-weight socket log receiving server.
The server aggregates messages from multi-process applications via a
socket and logs them to a single file. The service is used with
Python's stdlib `logging` package, which by default does not support
multi-process writes to a single file.


## Installation

``` shell
$ pip install socket-log-receiver
```


## Basic Usage

The receiver service should be run as a service:

``` shell
$ python -m socket_log_receiver  # as a module
$ log_receiver                   # as a command-line program
```

These are equivalent.

By default, the receiver service starts listening on `localhost:9020`.
These can be changed through CLI options; see the Help section below.

In the application, use `SocketHandler` to send logs to the receiver
service.

``` python
from logging.handlers import SocketHandler

handler = SocketHandler('localhost', 9020)  # handler to send logs to localhost:9020
logging.root.addHandler(handler)            # add the socket handler to the root logger
```

This way, the root logger sends logging messages to the receiver service.

### Help

``` shell
$ python -m socket_log_receiver -h
$ log_receiver -h
```

### Undefined Signal

The receiver service's configuration is managed by
[resconfig](https://github.com/okomestudio/resconfig). By default, the
dynamic configuration update is trigged by `SIGHUP`. Some systems
might not make this signal available, in which case you could use a
different signal for the trigger using the command-line option, e.g.

``` shell
$ log_receiver --reloader-signal SIGUSR2
```


## Development

``` shell
$ pip install -e .[dev]
$ pre-commit install
```


### Running Tests

``` shell
$ pip install -e .[test]
$ pytest
```
omitron.owleye 0.0.0.3
Modules to support CADMUS Owl Eye operations.
Requires Python: >=3.11.1

This Readme file will have info and examples for installing, setting up, and using CADMUS/OWLEYE client.

Example:
from owleye_client import owleye_client as owleye

owleye.hello_world()
owleye.hello_world('This is an overload test')
LicenseVendor 1.0.1
Library for managing software licenses

# LicenseVendor

LicenseVendor is a powerful Python library designed for managing software licenses, including license generation and time management. It provides developers with efficient tools to verify license validity, activate new licenses, and ensure secure communication with a dedicated web page for license management.

## Operational System Compatibility
This version of LicenseVendor is optimized for desktop software development specifically for the Windows operating system.

## Usability
LicenseVendor provides a user-friendly interface and seamless integration for managing software licenses on Windows-based applications. With its intuitive design and robust functionality, developers can easily integrate LicenseVendor into their software projects, ensuring efficient license management and activation processes.

Whether you're developing commercial software or distributing proprietary applications, LicenseVendor streamlines the licensing workflow, making it easy to generate, verify, and activate licenses directly within your Windows-based applications.

By leveraging LicenseVendor, developers can focus on creating innovative software solutions while ensuring compliance with licensing agreements and protecting intellectual property rights.

## Installation

You can install LicenseVendor via pip:
pip install LicenseVendor

## Good to Know
This version includes a hyperlink to the dedicated web page Tekinova Cloud LicenseVendor - tekinova.cloud/licensevendor.

## Info
For more information and access to additional services, visit Tekinova Cloud LicenseVendor.
oncall 2.1.7
Oncall is a calendar tool designed for scheduling and managing on-call shifts

Oncall [![Gitter chat](https://badges.gitter.im/irisoncall/Lobby.png)](https://gitter.im/irisoncall/Lobby) [![Build Status](https://circleci.com/gh/linkedin/oncall.svg?style=shield)](https://circleci.com/gh/linkedin/oncall)
======

<p align="center"><img src="https://github.com/linkedin/oncall/raw/master/docs/source/_static/demo.png" width="600"></p>

See [admin docs](http://oncall.tools/docs/admin_guide.html) for information on
how to run and manage Oncall.

Development setup
-----------------

### Local machine

<details> 
  <summary>See instructions for setting up Oncall on your local machine</summary>

### Prerequisites

  * Debian/Ubuntu - `sudo apt-get install libsasl2-dev python3-dev libldap2-dev libssl-dev python-pip python-setuptools mysql-server mysql-client`

### Install

```bash
python setup.py develop
pip install -e '.[dev]'
```

Setup mysql schema:

```bash
mysql -u root -p < ./db/schema.v0.sql
```

Setup app config by editing configs/config.yaml.

Optionally, you can import dummy data for testing:

```bash
mysql -u root -p -o oncall < ./db/dummy_data.sql
```

### Run

One of the following commands:

* `goreman start`
* `procman start`
* `make serve`
* `oncall-dev ./configs/config.yaml`


### Test

```bash
make test
```
</details>

### Docker compose

<details> 
  <summary>See instructions for using <code>docker compose</code></summary>

### Running

```bash
make compose
```

or running `docker compose` directly:

```bash
docker compose up --build
```

### Limitations

* Doesn't currently provide a mechanism for running tests
* Requires rebuilding to apply code changes
* Doesn't tail Python logs to stdout

</details>

## Contributing

Check out https://github.com/linkedin/oncall/issues for a list of outstanding
issues, and tackle any one that catches your interest. Contributions are
expected to be tested thoroughly and submitted with unit/end-to-end tests; look
in the e2e directory for our suite of end-to-end tests.
rosbag-tools 0.0.10
A ROS-agnostic toolbox for common rosbag operations
Requires Python: >=3.8

# rosbag-tools

> A ROS-agnostic toolbox for common rosbag operations

This package bundles different tools that can be applied on ROS 1 or ROS 2 rosbags with no dependency on the ROS software stack.

## Installation

`rosbag-tools` can be installed from PyPi :

```sh
pip install rosbag-tools
```

Some tools, like [`topic-compare`](src/rosbag_tools/topic_compare), have a graphing feature that requires `matplotlib`. Install `rosbag-tools[plot]` to install graph dependencies.

```sh
pip install rosbag-tools[plot]
```

`rosbag-tools` being a CLI application, it can be quickly installed with [pipx](https://github.com/pypa/pipx):

```sh
pipx install rosbag-tools
pipx install rosbag-tools[plot] # with plot
```

## Tools

* [`clip`](src/rosbag_tools/clip)
* [`split`](src/rosbag_tools/split)
* [`compute-duration`](src/rosbag_tools/compute_duration)
* [`export-odometry`](src/rosbag_tools/export_odometry)
* [`topic-compare`](src/rosbag_tools/topic_compare)
* [`topic-remove`](src/rosbag_tools/topic_remove)

## Usage

Each tool in `rosbag-tools` can be used both as a command line application and in Python code.

### Command line

A basic use of `rosbag-tools` is to simply call it from the command line.

```console
rosbag-tools `command` <options>
```

## Contributing

Pull requests and issues are welcome ! Don't hesitate to contribute !

(Recommended) [flit](https://flit.pypa.io) is used to package this module. Development packages can be installed using `flit` :

```console
python -m venv venv
source venv/bin/activate
pip install flit
flit install
```

(Alternative) Development requirements can be installed using pip :

```console
python -m venv venv
source venv/bin/activate
pip install -r requirements/requirements-dev.txt
```

## Acknowledgements

This package relies strongly on [`rosbags`](https://ternaris.gitlab.io/rosbags) for working with rosbags. Hats off to the team at [Ternaris](https://ternaris.com) for developing and maintaining it.

## License

This project is licensed under a [GNU GPLv3](LICENSE) license.