semvec/pypi-packages huggingface dataset:
ideograph 1.1.0
Tool for finding ideographic (e.g. Han) characters from their components

# ideograph

A tool to look up ideographs by their components. At the moment, it only contains Han characters, but it could be expanded to include other ideographic scripts such as Tangut or Sumero-Akkadian Cuneiform.

## Installation

```bash
$ pip install ideograph
```

## Usage

*ideograph* consists of a two functions, `find()` and `components()`:

`find()` takes a string of ideograph components and returns a set of ideographs that include all of those components.

Characters in the component string that are not ideographic components are ignored.

Note that the current implementation is quite strict and relies on visual distinction for components rather than etymological connection: e.g. "人" ≠ "亻".

It can be called from the command line:

```bash
$ ideograph 木日勿
䵘楊鸉����������������
```

or imported as a Python package:

```python3
>>> import ideograph
>>> ideograph.find("木日勿")
{'��', '��', '��', '��', '��', '��', '��', '��', '楊', '��', '��', '��', '��', '鸉', '䵘', '��'}
```

`components()` takes a string consisting of a single ideograph and returns a set of components. Note that the set contains components and the components of those components, and so on, down to the most basic of components contained in the cjkvi-ids data set.

```python3
>>> import ideograph
>>> ideograph.components("楊")
{'日', '木', '昜', '一', '勿', '旦', '勹', '丿', '\uf3e4'}
```

## Data

Character components are derived from the [cjkvi-ids database](https://github.com/cjkvi/cjkvi-ids) (included in this Git repository as a submodule), specifically the `ids-cdp.txt` data file. As some components do not currently have a Unicode code point assigned to them, they are given code points in the Private Use Area of Unicode. Note that because of this, some of these characters may be returned by the `find()` and `components()` functions.

Data is stored in a sqlite3 database, which can be regenerated from cjkvi-ids data by running the `generate_data.py` script.
s3edit 0.0.1
Edit files from S3 directly with your default editor.

# S3edit

s3edit allows you to edit files from AWS S3 directly from your terminal.

## Installation

```bash
pip install s3edit
```

## Usage

Assuming your file is at `s3://my-bucket/path/to/file.json`:

```bash
s3edit my-bucket/path/to/file.json
```

## Editor
s3edit uses your `EDITOR` environmental variable to choose an editor. If not
set, `vi` is used by default.

## AWS
Your AWS profile, credentials, and region needs to be set up for s3edit to
work. This can be done through enviromental variables or configuration files.
For more information, see
https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html.
shoedog 0.0.1
A search tool built on SQLAlchemy

# shoedog (WIP)
A flexible, efficient plug-and-play query engine built on top of SQLAlchemy, inspired by GraphQL
This library is a work in progress!

# Setting up
```
from shoedog import shoedoggify
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db'
db = SQLAlchemy(app)

shoedoggify(app, db)
```

The above code will set up a `/shoedog` endpoint on your application that takes a `POST` request. The payload on the `POST` request is a shoedog payload, with the following syntax:

```
query Company {
    name
    year_founded [(* > 1994 and * < 2017) or * == 2019]
    investors {
        name [any in ['gv', a16z']]
        amount_invested [all > 2000000]
    }
    contact_details (SingaporeContact) {
        address
        singapore_contact_number
    }
}
```

The above query will return a json response containing all instances of Company where:
1. The year founded is between 1994 and 2017, or is exactly 2019
2. The investors have all invested over 2,000,000 dollars
3. The investors include at least one investor with a name that is either 'gv' or 'a16z'

Furthermore, the json response has a predictable structure, returning only the fields that were requested.

```
{'companies': [{
    'name': 'XYZ Company',
    'year_founded': 1995,
    'investors': [{
        'name': 'gv',
        'amount_invested': 2000001 
    }],
    'contact_details': {
        'address': '123 Foobar Road',
        'singapore_contact_number': '+65 9635 9999'
    }
}, ...]}
```

Notice that
1. The `contact_details` was returned as a dictionary, since it is a different model.
2. The `contact_details` field was cast as a `SingaporeContact`, which allows us to query for the `singapore_contact_number` field which is only on that particular subclass. This query would have failed without the cast!
qfracture 0.9.2
qFracture is a lightweight UI atop of fracture
Keywords: fracture data composite qfracture

# Overview

qfracture is a Qt based front end exposing a fracture project. The interface
allows for data browsing and searching as well as data interaction.

For full details on fracture please see: 

https://github.com/mikemalinowski/fracture


# Browsing

qFracture displays a browsing panel which allows you to navigate data in a 
natural way - which is particularly useful if your data is file based. 

![alt text](https://github.com/mikemalinowski/qfracture/blob/master/docs/qfracture_browse.png?raw=true)

Right clicking a _Data Asset_ exposes the functionality bound to that data. 


# Searching

Within qFracture you can perform searches against your dataset. Fracture is 
 very quick at resolving searches - so this can be a preferable mechanism
 when interacting with data if you have a reasonable idea of what you're looking
 for. 
 
When no search entries are present this view will show any _Data Elements_ which
you have marked as being favourites - allowing them to be accessed very quickly
with no overhead. 


# Setting up a Project


The qFracture UI offers a wizard to make it easy to setup a new fracture 
project. This guides you through the process of defining the data structure 
location, the plugin locations and where you want to save your project file.

![alt text](https://github.com/mikemalinowski/qfracture/blob/master/docs/qfracture_wizard.png?raw=true)

It will also initiate a short scan of your data location. Depending on how
big your data set this can take a little time. 

Upon completion your data set is entirely searchable.


## System Tray


The qFracture Ui only performs a deep scan during the first time setup. Beyond
that, each location is re-scanned as you traverse those locations through the
browser panel.

If you want time based scans to occur you can trigger the __System Tray__ 
application (which is launchable from the _Settings_ tab). The system tray
allows you to specify an interval time (in seconds), and enable or disable
timed scans. 

This approach allows the scanning to occur in a completely different process
to any qFracture instances which can aid performance, especially if you're 
running qFracture from within environments such as Maya or Max etc. 


# Collaboration

I am always open to collaboration, so if you spot bugs lets me know, or if
you would like to contribute or get involved just shout!


# Compatibility

Launchpad has been tested under Python 2.7 and Python 3.7 on Windows and Ubuntu.