semvec/pypi-packages huggingface dataset:
arrayqueues 1.4.1
Multiprocessing queues for numpy arrays using shared memory
License: MIT
Keywords: multiprocessing queues arrays

# ArrayQueues

[![Python Version](https://img.shields.io/pypi/pyversions/arrayqueues.svg)](https://pypi.org/project/arrayqueues)
[![Tests](https://img.shields.io/github/workflow/status/portugueslab/arrayqueues/tests)](
    https://github.com/portugueslab/arrayqueues/actions)
[![Coverage Status](https://coveralls.io/repos/github/portugueslab/arrayqueues/badge.svg?branch=master)](https://coveralls.io/github/portugueslab/arrayqueues?branch=master)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![PyPI version](https://badge.fury.io/py/arrayqueues.svg)](https://badge.fury.io/py/arrayqueues)

This package provides a drop-in replacement for the Python multiprocessing Queue class which handles transport of large numpy arrays.
It avoids pickling and uses the multiprocessing Array class in the background.
The major difference between this implementation and the normal queue is that the maximal amount of memory that the queue can have must be specified beforehand.

Attempting to send an array of a different shape or datatype of the previously inserted one resets the queue.
Only passing of numpy arrays is supported, optionally annotated with timestamps if using the TimestampedArrayQueue class,
but other object types can be supported by extending the class.

The package has been tested on Python 3.6/3/7 on Windows and MacOS and Linux with Travis. Python 2.7 is not supported.

# Usage example
```python
from arrayqueues.shared_arrays import ArrayQueue
from multiprocessing import Process
import numpy as np

class ReadProcess(Process):
    def __init__(self, source_queue):
        super().__init__()
        self.source_queue = source_queue
      
    def run(self):
        print(self.source_queue.get())

if __name__ == "__main__":
    q = ArrayQueue(1) # intitialises an ArrayQueue which can hold 1MB of data
    n = np.full((5,5), 5)
    q.put(n)
    r = ReadProcess(q)
    r.start()
    r.join()
    
```

Further examples can be found in tests.
arivo-schedule 1.2.2
Job scheduling for humans.
License: MIT
Requires Python: >=3.7
Keywords: schedule,periodic,jobs,scheduling,clockwork,cron,scheduler,job scheduling

`schedule <https://schedule.readthedocs.io/>`__
===============================================


.. image:: https://github.com/dbader/schedule/workflows/Tests/badge.svg
        :target: https://github.com/dbader/schedule/actions?query=workflow%3ATests+branch%3Amaster

.. image:: https://coveralls.io/repos/dbader/schedule/badge.svg?branch=master
        :target: https://coveralls.io/r/dbader/schedule

.. image:: https://img.shields.io/pypi/v/schedule.svg
        :target: https://pypi.python.org/pypi/schedule

Python job scheduling for humans. Run Python functions (or any other callable) periodically using a friendly syntax.

- A simple to use API for scheduling jobs, made for humans.
- In-process scheduler for periodic jobs. No extra processes needed!
- Very lightweight and no external dependencies.
- Excellent test coverage.
- Tested on Python and 3.7, 3.8, 3.9, 3.10, 3.11

Usage
-----

.. code-block:: bash

    $ pip install schedule

.. code-block:: python

    import schedule
    import time

    def job():
        print("I'm working...")

    schedule.every(10).seconds.do(job)
    schedule.every(10).minutes.do(job)
    schedule.every().hour.do(job)
    schedule.every().day.at("10:30").do(job)
    schedule.every(5).to(10).minutes.do(job)
    schedule.every().monday.do(job)
    schedule.every().wednesday.at("13:15").do(job)
    schedule.every().day.at("12:42", "Europe/Amsterdam").do(job)
    schedule.every().minute.at(":17").do(job)

    def job_with_argument(name):
        print(f"I am {name}")

    schedule.every(10).seconds.do(job_with_argument, name="Peter")

    while True:
        schedule.run_pending()
        time.sleep(1)

Documentation
-------------

Schedule's documentation lives at `schedule.readthedocs.io <https://schedule.readthedocs.io/>`_.


Meta
----

Daniel Bader - `@dbader_org <https://twitter.com/dbader_org>`_ - mail@dbader.org

Inspired by `Adam Wiggins' <https://github.com/adamwiggins>`_ article `"Rethinking Cron" <https://adam.herokuapp.com/past/2010/4/13/rethinking_cron/>`_ and the `clockwork <https://github.com/Rykian/clockwork>`_ Ruby module.

Distributed under the MIT license. See `LICENSE.txt <https://github.com/dbader/schedule/blob/master/LICENSE.txt>`_ for more information.

https://github.com/dbader/schedule
avirtech-spraying-jiyi-wp-lib 0.0.4
Avirtech Python Library to Generate JIYI Drone Spraying Track Using Waypoint Data From Avirplaner
License: MIT

Script ini untuk membuat jalurterbang Spraying untuk drone spraying FC JIYI, "memanfaatkan hasil waypoint dari avirplaner".
Data yang dihasilkan adalah berupa garis(.shp).

Data yang dibutuhkan adalah (.waypoint) hasil dari avirplaner. 
Bila menggunakan data DSM(.tif) boleh menggunakan koordinat WGS_1984, maupun koordinat UTM.

Data tersebut dilanjutkan di software Qgis, untuk diconvert menjadi (.kml), lalu di "dissolve".
Data hasil dissolve dapat digunakan dalam aplikasi "AgriAsistant"

Install
pip install avirtech_spraying_jiyi_wp_lib

Usage
from avirtech_spraying_jiyi_wp_lib.avirtech_spraying_jiyi_wp import autocorrect
avirtech-spraying-jiyi-waypoint-lib 0.0.2
Avirtech Python Library to Generate JIYI Drone Spraying Track Using Waypoint Data From Avirplaner
License: MIT

Script ini untuk membuat jalurterbang Spraying untuk drone spraying FC JIYI, "memanfaatkan hasil waypoint dari avirplaner".
Data yang dihasilkan adalah berupa garis(.shp).

Data yang dibutuhkan adalah (.waypoint) hasil dari avirplaner. 
Bila menggunakan data DSM(.tif) boleh menggunakan koordinat WGS_1984, maupun koordinat UTM.

Data tersebut dilanjutkan di software Qgis, untuk diconvert menjadi (.kml), lalu di "dissolve".
Data hasil dissolve dapat digunakan dalam aplikasi "AgriAsistant"

Install
pip install avirtech_spraying_jiyi_waypoint_lib

Usage
from avirtech_spraying_jiyi_wp_lib.avirtech_spraying_jiyi_wp import autocorrect
rxn-metrics 1.1.0
Metrics for RXN models
License: MIT
Requires Python: >=3.6

# RXN package for the calculation of metrics for OpenNMT-based models

[![Actions tests](https://github.com/rxn4chemistry/rxn-metrics/actions/workflows/tests.yaml/badge.svg)](https://github.com/rxn4chemistry/rxn-metrics/actions)

This repository contains a Python package and associated scripts for training reaction models based on the OpenNMT library.
This repository is closely related to [`rxn-onmt-models`](https://github.com/rxn4chemistry/rxn-onmt-models), which handles the training pipelines for these models.
The repository also relies on other RXN packages; see [`rxn-utilities`](https://github.com/rxn4chemistry/rxn-utilities), [`rxn-chemutils`](https://github.com/rxn4chemistry/rxn-chemutils), and [`rxn-onmt-utils`](https://github.com/rxn4chemistry/rxn-onmt-utils).

Links:
* [GitHub repository](https://github.com/rxn4chemistry/rxn-metrics)
* [Documentation](https://rxn4chemistry.github.io/rxn-metrics/)
* [PyPI package](https://pypi.org/project/rxn-metrics/)

This repository was produced through a collaborative project involving IBM Research Europe and Syngenta.

## System Requirements

This package is supported on all operating systems.
It has been tested on the following systems:
+ macOS: Big Sur (11.1)
+ Linux: Ubuntu 18.04.4

A Python version of 3.6, 3.7, or 3.8 is recommended.
Python versions 3.9 and above are not expe`cted to work due to compatibility with the selected version of OpenNMT.

## Installation guide

The package can be installed from Pypi:
```bash
pip install rxn-metrics[rdkit,rxnmapper]
```
You can leave out the extra dependency `rdkit` if RDKit is already available in your environment.
Also, you can leave out the extra dependency `rxnmapper` if you don't plan on calculating the "true reactant" accuracy.

For local development, the package can be installed with:
```bash
pip install -e ".[dev,rdkit,rxnmapper]"
```

## Calculation of metrics

The metrics are best calculated by launching one of the following scripts:
* `rxn-prepare-context-metrics`
* `rxn-prepare-forward-metrics`
* `rxn-prepare-retro-metrics`
Note that these scripts will run the models directly to limit the likelihood of making errors.

If the prediction files are available already, the script `rxn-evaluate-metrics` will compute the metrics only.

To aggregate all the metrics for different models (typically: after tuning the hyperparameters), you can run the script `rxn-parse-metrics-into-csv`.