semvec/pypi-packages huggingface dataset:
dynamo-cmdline 0.0.1
Python command line interface for copying/querying/restoring DynamoDB tables and items.

# Dynamo CLI
>  Python Command-line interface to copy Dynamodb data in parallel batch processing + query natural & Global Secondary Indexes (GSIs).
#### Author: Simon Ryu

### Pre-requisite

- Profiles in `.aws/credentials` are configured for AWS environments (accounts).
- Install `dynamo-cmdline` package: ```pip install dynamo-cmdline```

## Running the CLI

#### Help message
> Displays a help message for using the CLI.


`$ dynamo -h`
```
Command line interface to copy, query and restore DynamoDB tables and items

positional arguments:
  {copy,restore,query}
    copy                Copy table or items from source to target envrionment
    query               Query items in specified environment's table

optional arguments:
  -h, --help            show this help message and exit
```

#### Copy table
> Creates an on-demand target table backup, truncates all items in the target table and copies all source table items in its place.


```$ dynamo copy --table foo --source production --target development```


Copy `foo` table from `production` to `development` environment.


#### Copy items
> Copies queried items from source table to target table. Queries items in source and target table, deletes them from the target table, then copies queried source items to the target table.
> For querying with sort keys, the comparision condition is begins_with.


```
$ dynamo copy --table foo --pk pkexample#id --sk skexample#id --source development --target test
```

Copy queried items in its natural table from development to test environment.


```$ dynamo copy --table foo --pk pkexample#id --index example-index --source prod --target stage```


Copy queried items in the table's secondary index from production to staging environment.

#### Query
> Query items in specified environment's table.

```$ dynamo query --table foo pkexample#id --env dev --head```

Prints the number of items queried as well as the first item returned from the query.

```$ dynamo query --table foo pkexample#id --env dev --unique entity-type```

Prints the number of items queried as well as the unique attribute values of the specified field. Atrribute value must be str.
vltava 0.1.3
Opinionated Czech Language Processing
Requires Python: >=3.7

# Vltava

[1]: https://nlp.fi.muni.cz/czech-morphology-analyser/
[2]: https://ufal.mff.cuni.cz/morphodita
[3]: https://github.com/petrpulc/python-majka
[4]: https://pypi.org/project/ufal.morphodita/

![PyPI](https://badge.fury.io/py/vltava.svg)
![Test](https://github.com/jancervenka/vltava/actions/workflows/test.yml/badge.svg)
![Publish](https://github.com/jancervenka/vltava/actions/workflows/publish.yml/badge.svg)


Opinionated Czech language processing.

The processor takes in raw documents and applies basic preprocessing
(such as tags and accent striping) and lemmatization using either [Majka][1]
or [MorphoDiTa][2].

```python
from vltava import DocumentProcessor

doc = "v televizi říkali, že zítra pršet nebude"
document_processor = DocumentProcessor()
result = document_processor.process(doc)
# result is ['televize', 'rikat', 'zitra', 'prset', 'byt']
```

`DocumentProcessor` supports multiprocessing when dealing with
large collections of documents.

```python
from vltava import DocumentProcessor

docs = ["Ahoj, jak se máš?"] * 100

result = DocumentProcessor().process_from_iterable(docs, n_jobs=2)
```

## Installation

```bash
pip install vltava
```

## Backend

The package is using two different backends for finding Czech lemmas:
[Majka][1], [MorphoDiTa][2]. Check out the links for more information.
The required binary files are contained directly in the package.

- [Majka Python API][3]
- [MorphoDiTa Python API][4]

## Public API

### `vltava.DocumentProcessor`

```python
vltava.DocumentProcessor(backend: str = "majka")
```

Initializes `DocumentProcessor` with the selected `backend`.

__Methods:__

```python
DocumentProcessor.process(
    self, doc: str, tokenize: bool = True
) -> Union[str, List[str]]
```

Processes the input `doc` and returns it as a processed
string or a list of processed tokens, if `tokenize` is `True`.

```python
DocumentProcessor.process_from_iterable(
    self, docs: Iterable[str], tokenize: bool = True, n_jobs: int = 1
) -> Union[Iterable[str], Iterable[List[str]]]:
```

Processes the input `docs` collection of documents. Result is either
an iterable of processed strings or an iterable of lists of processed
tokens (if `tokenize` is `True`).

If `n_jobs` is greater than one, multiple worker are launched to
process the documents.