semvec/pypi-packages huggingface dataset:
async-couch 0.2.0
Asynchronous client for CouchDB.
License: MIT
Requires Python: <4.0,>=3.11

# Async-Couch

![Logo](docs/source/_static/logo.jpg)
![Documentation Status](https://readthedocs.org/projects/async-couch/badge/?version=latest)
![Python package](https://github.com/symstu/async-couch/workflows/testing/badge.svg?branch=master)
![PyPI version](https://badge.fury.io/py/async-couch.svg)

## Resources
   * [Documentation](https://async-couch.readthedocs.io/en/latest/)

> This is simple asynchronous python CouchDB client that works with
> aiohttp, httpx and able to be adopted easily to any other http client.

### Requirements:
   * >= Python 3.11

### Allowed http client
   * [aiohttp](https://docs.aiohttp.org/en/stable/>)
   * [httpx](https://www.python-httpx.org/>)

### How to install
```bash
pip install async-couch
```

### Get Started
```python
   import asyncio

   from async_couch import get_couch_client
   from async_couch.http_clients import HttpxCouchClient


   async def example(client, doc_id: str):
      await client.db_create('test_index')
      await client.doc_create_or_update('test_index', doc_id, dict(val=1))

      response = await client.doc_get('test_index', response.model._id)
      assert response.model._id == doc_id

      await client.attachment_upload(
         'test_index', response.model._id, 'attachment_name', 'text/plain', b'\0')

   if __name__ == '__main__':
      loop = asyncio.get_event_loop()
      client = get_couch_client(request_adapter=HttpxCouchClient)

      loop.run_until_complete(example(client, 'document_name'))
```

### ToDo
* Rest endpoints
* Aiohttp adapter
datadog-log 1.5.1
JSON formatted logging for Datadog
License: MIT
Requires Python: <4.0,>=3.8

# Datadog-log

Write out JSON formatted logs in the format and with
the [attributes](https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#default-standard-attribute-list)
that Datadog expects

## Installation

`pip install datadog-log`

## Setup

The simplest way is to use `init_logging()` which will log to stdout.

If you want finner control then you can use `DatadogFormatter` directly. See `init_logging` for example usage.

## Logging

Use logging as normal:

```python
import logging
import datadoglog

datadoglog.init_logging()
log = logging.getLogger("example")
log.setLevel(logging.INFO)
log.info("Some info", extra={"extra": ["json"]})
```

The above would output json like below (but as a single line, shown 'pretty' here for readability):

```json
{
  "message": "Some info",
  "extra": ["json"],
  "timestamp": "2021-09-18T21:14:07.707371+00:00",
  "status": "info",
  "logger": {
    "name": "example",
    "method_name": "<stdin>.<module>",
    "thread_name": "MainThread"
  }
}
```
poetry-dev 0.2.3
A collection of scripts replace local packages with versions and vice versa
License: MIT
Requires Python: <4.0,>=3.6

# poetry-dev

This package is not maintained anymore

![Build](https://github.com/mrijken/poetry-dev/workflows/CI/badge.svg)

When developing multiple Python packages concurrently with Poetry manageed environments you
can install the local package as path requirements. Ie when you develop `bar`
which have `foo` as dependency, which you also want to edit, you can
do `poetry add ../foo` from `bar` package. But when you want to publish
`bar`, you have to change the path requirement back to a version requirement.

After publishing `bar` you have to switch back to `foo` as a path requirement
in order to continue develop both concurrently.

This package will help you to improve that task. With one command all version
requirements will be changed to path requirements (when the package is
checkout in a sibling directory with the same as the package name).

`poetry_dev path`

This results in a changed `pyproject.toml` file. `poetry update` is called
to make sure the package on the path is installed as editable package.

Before publishing, the path requirements can be switched back to version
requirements with the following command.

`poetry_dev version`

The version of the dependency on the local path will be
used as minimal caret version in the changed `pyproject.toml` and
`poetry update` is called to make sure the corresponding version
from the repository will be installed.