https://github.com/weaming/objectify-json

Make accessing JSON data more convenient.
https://github.com/weaming/objectify-json

cli dict lambda

Last synced: about 2 months ago
JSON representation

Make accessing JSON data more convenient.

• Host: GitHub
• URL: https://github.com/weaming/objectify-json
• Owner: weaming
• Created: 2018-10-19T09:07:52.000Z (about 6 years ago)
• Default Branch: master
• Last Pushed: 2019-06-17T06:36:17.000Z (over 5 years ago)
• Last Synced: 2024-11-06T10:52:32.814Z (about 2 months ago)
• Topics: cli, dict, lambda
• Language: Python
• Homepage:
• Size: 29.3 KB
• Stars: 2
• Watchers: 2
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# Objectify JSON

Make accessing JSON like data more convenient.

## Features

* Access dict value via dot `.` (`data.a.b.c`).

* Always return `ObjectifyJSON` type, which holds the data with type of dict, list or any other primitive types.

* Use `x._data` to get the real data.

* Always return `ObjectifyJSON(None)` if doesn't exist.

* An CLI tool named `object` to process JSON data.

## Install

```

pip3 install objectify-json

```

## Example

See `test.py`

## Functions to process data in batch

* The return value is always `ObjectifyJOSN` too!

* The return value of lambda funtions will always be unwrapped to primitive types.

* Most of the `fn_*` functions accept optional `unwrap` parameter to enable passing the underlying value as primitive types to lambda. Default is False.

* When used in CLI tool, if it failed getting the property by property name, e.g. `map`, it will retry to get function with prefix `fn_` added to the name. This will simplify writting the CLI command.

### Common

Following methods of `ObjectifyJOSN` accept optional `unwrap` to unwrap `ObjectifyJOSN` data to the underlying built-in data, the default value is `False`.

* `fn_map(fn, unwrap=False)`: `map` on the iterator

* `fn_reduce(fn, initializer=None, unwrap=False)`: `reduce` on the iterator, lambda as the first positional parameter, optional `initializer` parameter will be passed to built-in `reduce`.

* `fn_lambda(fn, unwrap=False)`: value in-and-out

* `fn_filter(fn, unwrap=False)`: `filter` on the iterator

### Dict

* `fn_keys()`: Return keys as list.

* `fn_values()`: Return values as list.

* `fn_items()`: Return items as list. Element has the type `tuple`, e.g. `("key", "value")`.

* `fn_include_keys(keys)`: Filter dict. Keep the `keys` you give.

* `fn_exclude_keys(keys)`: Filter dict. Remove the `keys` you give.

* `fn_filter_by_value(fn)`: Filter dict. Filter by the lambda you give, which accept the value of dict item.

* `fn_filter_by_kv(fn)`: Filter dict. Filter by the lambda you give, which accept `key` and `value` two variables.

* `fn_update(key, fn, unwrap=False)`: Update dict value. The lambda you give accept the origin value and return a new value.

* `fn_items_update(fn, unwrap=False)`: Update dict value. The lambda you give accept `key` and `value` two variables and return a new value.

* `fn_rename(mapping)`: Update dict key. The `mapping` is a list of two-elements list.

### List

* `fn_sort(fn)`: Sort the list in place. The lambda you give will be passed as `key` argument to the `sort` method of list.

* `fn_dedup(fn=None, all=True)`: Dedup the elements in list. If `all` if `False`, the duplication will checked by comparing current value between last value, else will compare to all appeared before.