semvec/pypi-packages huggingface dataset:
pyepics-asyncio 0.3.0
Async/await wrapper for PyEpics
License: MIT
Requires Python: >=3.9,<4.0
Keywords: pyepics,epics,asyncio,async,await

# pyepics-asyncio

Simple `async`/`await` wrapper for [PyEpics](https://github.com/pyepics/pyepics).

## Overview

There are two main types:
+ `PvMonitor` - subscribed to PV updates, `get` returns last received value.
+ `Pv` - connected but not subscribed, each `get` requests PV value over network.

## Usage

### Connect to PV

```python
from pyepics_asyncio import Pv

pv = await Pv.connect("pvname")
```

### Write value to PV

```python
await pv.put(3.1415)
```

### Read value from PV

```python
print(await pv.get())
```

### Monitor PV value updates

```python
with pv.monitor() as mon:
    async for value in mon:
        print(value)
```

## Testing

To run tests you need to have dummy IOC running (located in `ioc` dir):

+ Set appropriate `EPICS_BASE` path in `configure/RELEASE`.
+ Build with `make`.
+ Go to `iocBoot/iocTest/` and run script `st.cmd` and don't stop it.

In separate shell run `poetry run pytest --verbose`.
beam-postgres-connector 0.1.3
An io connector for PostgreSQL read/write in Apache Beam pipelines.
License: MIT
Requires Python: >=3.8.1,<4.0.0
Keywords: apache beam,beam,postgres,postgresql

# Beam - Postgres connector

[![PyPI](https://img.shields.io/pypi/v/beam-postgres-connector.svg)][pypi-project]
[![Supported Versions](https://img.shields.io/pypi/pyversions/beam-postgres-connector.svg)][pypi-project]
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Beam - Postgres Connector provides an io connector for PostgreSQL read/write in [Apache Beam](https://beam.apache.org/) pipelines.

## Installation

```bash
pip install beam-postgres-connector
```

## Usage

- Read From PostgreSQL

```Python
import apache_beam as beam
from beam_postgres import splitters
from beam_postgres.io import ReadFromPostgres

with beam.Pipeline(options=options) as p:
    read_from_postgres = ReadFromPostgres(
            query="SELECT * FROM test_db.test.test;",
            host="localhost",
            database="test_db",
            user="test",
            password="test",
            port=5432,
            splitter=splitters.NoSplitter()  # you can select how to split query for performance
    )


    (
        p
        | "ReadFromPostgres" >> read_from_postgres
        | "WriteToStdout" >> beam.Map(print)
    )
```

- Write To Postgres

```Python
import apache_beam as beam
from beam_postgres.io import WriteToPostgres


with beam.Pipeline(options=options) as p:
    write_to_postgres = WriteToPostgres(
            host="localhost",
            database="test_db",
            table="test.test",
            user="test",
            password="test",
            port=5432,
            batch_size=1000,
    )

    (
        p
        | "ReadFromInMemory"
        >> beam.Create(
            [
                {
                    "name": "test data",
                }
            ]
        )
        | "WriteToPostgres" >> write_to_postgres
    )
```

See [here][examples] for more examples.

## splitters

- NoSplitter

  Do not split the query

- QuerySplitter

  Split the query by a specified separator string and distribute it for parallel processing across multiple nodes. Specify non-overlapping ranges for each query in the WHERE clause. The processing results will be combined using UNION ALL.

## License

MIT License.

[pypi-project]: https://pypi.org/project/beam-postgres-connector
[examples]: https://github.com/satokiyo/beam-postgres-connector/tree/main/examples
supGecko 0.1.0a5
A helper library to write Gecko code
License: MIT
Requires Python: >=3.8

# supGecko
A helper library to write Gecko code

## Installation
```
pip install supGecko
```

## Usage
```python
from supGecko import Gecko

g = Gecko()
# TODO: usage of the Gecko class
print(g.dump_txt())
```
loggerr 1.1.0
Zero configuration JSON logger(r)
License: MIT
Requires Python: >=3

# loggerr [![](https://img.shields.io/pypi/v/loggerr?style=flat-square)](https://pypi.org/project/loggerr/) [![](https://img.shields.io/static/v1?label=github&message=python-loggerr&labelColor=black&color=3572a5&style=flat-square&logo=github)](https://github.com/fiverr/python-loggerr) [![](https://circleci.com/gh/fiverr/python-loggerr.svg?style=svg)](https://circleci.com/gh/fiverr/python-loggerr)

## Zero configuration JSON logger(r)


```py
from loggerr import Loggerr

logger = Loggerr("warn")

logger.info("Something going as expected", { "host": socket.gethostname() }) # ignored
logger.warn("Something must have gone terribly wrong") # sent

except Exception as e:
    logger.error(e, { request: "this was the request" })
```

### Log level
Create logger instance with a minimal log level

Log levels are (respectively):
- debug
- verbose
- info
- warn
- error
- critical

For example, a logger with log level "warn" will only print logs with level "warn", "error", or "critical".

### Synonyms
A couple of function synonyms have been placed to your convenience:

| function | will log with level
| - | -
| `logger.log(...)` | "info"
| `logger.warning(...)` | "warn"
| `logger.fatal(...)` | "critical"
| `logger.panic(...)` | "critical"

### Arguments
**Create**: Loggerr class accepts one or two arguments:

1. {string} Case insensitive name of **minimal** log level. defaults to 'info'
2. {dictionary} {'Key':'Value'} pairs, optional. Persistent enrichment fields for all log records

```py
logger = Loggerr(os.environ["LOG_LEVEL"], { "host": socket.gethostname() })
```

**Send**:Logger functions accept one or two arguments:

1. {any} Record's "message" field. Traditionally this would be a string or an exception.
2. {dictionary} {'Key':'Value'} pairs, optional. Values should be JSON serializable

```py
logger.info("something, something", { dark: "side" })
```
days360 1.0.2
Excel's DAYS360() formula for python.
License: MIT
Requires Python: >=3.8,<4.0
Keywords: excel,formula,finance,days360

# days360

[![Tests](https://github.com/tfeldmann/days360/actions/workflows/tests.yml/badge.svg)](https://github.com/tfeldmann/days360/actions/workflows/tests.yml)
<a href="https://pypi.org/project/days360/">
  <img src="https://img.shields.io/pypi/v/days360" title="PyPI Version">
</a>

Calculates the days between two dates based on the 360-day year.

- Implementation of Excel's (or Number's) `DAYS360` / `TAGE360` formula in python.
- Both EU and US methods of calculation are supported, with optional Excel bug compatibility.

## Installation

```
pip install days360
```

## Usage

```python
from datetime import date
from days360 import days360

date_a = date(2022, 10, 2)
date_b = date(2023, 11, 30)

# supported methods: "US" (default), "US_NASD", "EU"
days = days360(date_a, date_b, method="US")
print(days)  # prints 418
```

## Planned

- ISDA, PSA and SIA methods
  - https://www.isda.org/2008/12/22/30-360-day-count-conventions/)
  - https://web.archive.org/web/20160425044113/http://www.nyift.com/lesson/day-count-convention-bonds/
  - https://github.com/miradulo/isda_daycounters

## Notes and credits

- Implementations are based on https://en.wikipedia.org/wiki/360-day_calendar.
- This library started as a port of this ruby gem: https://github.com/tamaloa/days360/tree/master
FITSImageQA 0.0.3
Perform quality checks on FITS images
License: MIT
Requires Python: >=3.7

# FITSImageQA
Perform quality checks on FITS images

# Install package in editable mode
pip install -e .

# REORGANIZE ALL OF FOLLOWING INTO SENSIBLE TEXT - just dumping info for now

- use python=3.10 (maybe doesn't matter, or specified in requirements, or elsewhere?)

# Example images can be downloaded from the following url:
https://yale.box.com/s/gjz3310ft56iaepjrkcfyd4z0bxqph5t