semvec/pypi-packages huggingface dataset:
DataDock 2020.8.24.5
Data Dock package

# Data Dock Package

#### Introduction
This framework is mainly used for data pair amount in big data.

#### Installation
```ini
pip install DataDock -i https://pypi.python.org/simple -U
```

#### Uage
1.DataLoadStatic
- This is used to load static data variables, data variables cannot be modified
```python
from DataDock import DataLoadStatic
class DataLoad(DataLoadStatic):
    temp = 20
    press = 30
    
dl = DataLoad()
# dl.temp.value --> 20
# dl.all_fields --> {'temp': 20, 'press': 30}
```

2.DataParse
- Data analysis process, follow common framework usage锛歴et_up() ->  process() -> teardown()
    - set_up: Data preprocessing
    - process: data processing
    - teardown: Data finishing process
```python
from DataDock import DataParse
class TempDataParse(DataParse):
    def setup(self):
        pass

    def process(self):
        pass

    def teardown(self):
        pass
```

3.DataSave
- Data storage, incoming ```sql_url_con```, such as ```postgresql+psycopg2://root:123@127.0.0.1:5432/demo```
```python
from DataDock import DataSave
class TempDataSave(DataSave):
    pass

if __name__ == '__main__':
    sql_url_con = 'postgresql+psycopg2://root:123@127.0.0.1:5432/demo'
    tds = TempDataSave()
    db = tds.db(sql_url_con)
    db.query('your sql')
    tds.save('your save sql')
    
    sql_url_cons = [sql_url_con for _ in range(3)]
    dbs = tds.dbs(sql_url_cons) 
    index_db = dbs[0]
    index_db.query('your sql')
    index_db.save('your save sql')
    
```

#### Connection
- author github: https://github.com/AlitaIcon/DataDock

- more information: 1906321518@qq.com
semantic-ink 0.0.2
INK: Instance Neighbouring by using Knowledge
Keywords: Knowledge graph representation,Semantic Rule Mining

# INK: Instance Neighbouring using Knowledge

INK is a binary data structure for representing a knowledge graph (KG), taking into account nodes and their neighbourhoods till a certain, specified depth.

This repository contains:
* The code to transform a KG into the binary INK matrix representation
* The code INK Miner code: Semantic rule mining on the INK representation for both task-specific and task-agnostic use cases.

## Installation
* `pip install semantic-ink`
* or clone this repository
## Usage
See the [example notebook](https://github.com/IBCNServices/INK/blob/master/example.ipynb) for more information on how to use INK and the INK miner.
## Publications
Coming soon.
## Contributing
Pull requests are welcome. <br>
For major changes, please open an issue first to discuss what you would like to change.

## License
[IMEC](https://github.com/IBCNServices/INK/blob/master/LICENSE)
polyfamily-tree 0.1.0
Python package for structuredly managing directional relationship between objects.
Requires Python: >=3
Keywords: DAG,directed,acyclic,graph

# polyfamily_tree
Python package for structuredly managing directional relationship between objects.  
  
Though it uses allegory of 'family tree', it doesn't implement 'tree data structure'.  
Alternatively, relationship in default is drawn by organizing Directed Acyclic Graph(DAG).  
This means that there is a loop-less hierarchy in between members.  
Not like tree, member of this data structure can have multiple parents  
thus the package is named 'poly'family  
  
Graph organizing members is not a concrete object.  
All participants store its vicinity relationship in itself.
By default relationship is build bidirectional - parent knows about children while  
children knows about parent. But this can be manually tweaked using  
lower level methods like `fm_append` `fm_remove`.  
  
Methods use prefix 'fm_' to be distinguished.  
  
## Installation
Use `pip` to install the package.  
`pip install polyfamily_tree`

## Usage
```python
from polyfamily_tree import *    
   
   
class MyMember(FamilyMember): # inherit `FamilyMember`  
    def __init__(self):
        super().__init__()    # vital for initiating required attributes  
        # your __init__ code below
        ...
        
a, b = MyMember(), MyMember()  
a.fm_append_member(parent=a, child=b) # build relationship
print(b.fm_get_parents())
```    

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.    
<https://github.com/grasshopperTrainer/polyfamily_tree>    

## Alternative contect
For any questions :    
<grasshoppertrainer@gmail.com>    
    
## Licence
MIT
nannernest 0.1.4
Optimal peanut butter and banana sandwiches
Requires Python: >=3.7,<4.0
Keywords: deep learning,machine learning,peanut butter,banana,sandwich

# nannernest

![Python package](https://github.com/EthanRosenthal/nannernest/workflows/Python%20package/badge.svg?branch=master)

A small package for optimizing banana coverage on peanut butter and banana sandwiches. See [blog post](https://www.ethanrosenthal.com/2020/08/25/optimal-peanut-butter-and-banana-sandwiches/) for more info.


![assets/perfect_sandwich.jpg](assets/perfect_sandwich.jpg)


## Installation

`nannernest` is generally pip installable. Due to some C dependencies with the nesting library that I use [nest2D](https://github.com/markfink/nest2D), along with an outstanding [PR](https://github.com/markfink/nest2D/pull/2), I would recommend the following way to install everything:

 First, make sure you have [boost](https://www.boost.org/) and [cmake](https://cmake.org/) installed. If you are on Linux, then you may have `cmake` installed, and you can install `boost` with 
 
 ```commandline
sudo apt-get install libboost-all-dev 
```
 
 I'm on a Mac, and I installed `cmake` with conda and `boost` with brew:
 
 ```commandline
conda install cmake
brew install boost
```

Next, pip install my fork of `nest2D`:

```commandline
pip install git+https://github.com/EthanRosenthal/nest2D.git@download-dependencies
```

Finally, pip install `nannernest`

```commandline
pip install nannernest
```

## Usage

Take a top-down picture that contains your banana and at least one slice of bread. Pass the image in via command line:

```commandline
$ nannernest my_image.jpg
```

### CLI Details

```commandline
$ nannernest --help
Usage: nannernest [OPTIONS] IMAGE_PATH

Arguments:
  IMAGE_PATH  Image file which contains bread and banana  [required]

Options:
  --num-slices INTEGER            Total number of slices to cut the banana
                                  into. This number defines the slice
                                  thickness.  [default: 22]

  --mask-threshold FLOAT          Threshold of segmentation mask.  [default:
                                  0.6]

  --peel-scaler FLOAT             Fraction of slice that is assumed to belong
                                  to banana insides versus the peel.
                                  [default: 0.8]

  --ellipse-ratio FLOAT           Assumed ratio of minor axis to major axis of
                                  banana slice ellipses  [default: 0.85]

  --plot-segmentation / --no-plot-segmentation
                                  Whether or not to plot the segmentation
                                  masks  [default: False]

  --plot-slicing / --no-plot-slicing
                                  Whether or not to plot the slicing circle
                                  and skeleton  [default: False]

  --output TEXT                   Name of file to output  [default:
                                  perfect_sandwich.jpg]
```