semvec/pypi-packages huggingface dataset:
notion2jekyll 0.1.6
Export notion page to jekyll post
License: MIT

# Notion2Jekyll
[![PyPI version](https://badge.fury.io/py/notion2jekyll.svg)](https://badge.fury.io/py/notion2jekyll)

Jekyll Exporter makes your notion page to [Jekyll Post Markdown](https://jekyllrb-ko.github.io/docs/posts/) file. This is using [notion-py](https://github.com/jamalex/notion-py) to export notion page to markdown.  

Notion2Jekyll provides these features.  

1. Exports your notion page to the markdown file named as the jekyll-post title:
    `yyyy-m-dd-<your page's title>`

2. Puts [front matter](https://jekyllrb.com/docs/step-by-step/03-front-matter/)s to the markdown file.

  - `tags`

  - `layout: post`

3. Download images in your notion page, and automatically set the image path in the md file 

    `You need to rename the path when you upload in your blog`

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install notion2jekyll.  

```Bash
$pip install notion2jekyll
```

## Usage_Command Line

```Bash
$python -m notion2jekyll
#Markdown file name: <output file name(without .md)>
#Token_v2: <your token_v2 on notion.so>
#Notion Page Url: <your notion page to export>
```

## Usage in Python

> I changed the way to use the jekyll exporter. Please follow these examples.

### With nothing
```Python
from notion2jekyll import *

export_cli()
```

### With token_v2 & url
```Python
from notion2jekyll import *
token_v2 = #<your notion token_v2>
url = #<your notion page url>

export_out(url,token_v2)
```

### With token_v2 & url & Notion-py Block
```Python
from notion2jekyll import *

token_v2 = #<your notion token_v2>
url = #<your notion page url>

client = NotionClient(token_v2=token_v2)
block = client.get_block(url)

export_in(block,client)
```


## Aditional Info

- Exporter will make the md file and images in the folder named `posts` and `posts/<your block title>`

- The url should be the page that you want to export.

- The front matter in the markdown will be different based on your jekyll blog variables. So, change the front matters when you finish the export, or change the code in this project.

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.  

Please make sure to update tests as appropriate.  

## License

[MIT](https://choosealicense.com/licenses/mit/)
vertibird 0.1.7
A really, really simple Python virtualization module which interfaces directly with QEMU.
License: MIT
Requires Python: >=3.6

Vertibird is a dead-simple virtualization library based around direct access to
QEMU. Because I couldn't be bothered to figure out how the hell the crappy
libvirt C bindings work. I also couldn't be bothered to write a million lines
of XML. Screw that.

Currently only tested on x86_64, and probably only works on x86_64. Usage is
also only possible on Linux, this library is NOT cross-platform. It would've
taken an infinitely longer amount of time to write this for Windows, since it
makes use of features such as named pipes.

PyPi: https://pypi.org/project/vertibird/

GitHub & Further Information: https://github.com/naphthasl/vertibird

License: MIT (see LICENSE for details)
lstm-conv 1.0.0
Graph convolutional operator that uses a LSTM as a filter
License: MIT
Requires Python: >=3
Keywords: gnn,graph-neural-network,convolution,pytorch,graph,lstm,rnn,recurrent

# lstm-conv

`lstm-conv` is a PyTorch implementation of a graph convolutional operator that uses long short-term memory (LSTM) network as a filter -- that is, LSTM is used to update node embeddings. This is useful for graph datasets where each node represents a time series or sequence of vectors.

<p align="center">
    <img src="assets/equation.png" width="47%" />
</p>

Where _&phi;<sub>r</sub>_ and _&phi;<sub>m</sub>_ are LSTMs (`torch.nn.LSTM()`), and _h<sub>Θ</sub>_ is a neural network. The outputs of each LSTM are the last hidden state, _h<sub>n</sub>_, rather than all the output features.

## Installation

This module can be installed with `pip`:

```bash
$ pip install lstm-conv
```

## Usage

`LSTMConv` is built on PyTorch Geometric and derives from the `MessagePassing` module. It expects an input graph where each node's has a sequence of vectors associated with it. `LSTMConv`, similarly to `NNConv`, also incorporates any available edge features when collecting messages from a node's neighbors.

**Parameters:**

- **in_channels** (_int_): Number of channels in the input node sequence (e.g. if each node has a sequence of vectors of size n associated with it, then in_channels = n)
- **out_channels** (_int_): Number of channels in the output node embedding
- **edge_nn** (_torch.nn.Module_): A neural network _h<sub>Θ</sub>_ that maps edge features, `edge_attr`, of shape `[-1, num_edge_features]` to shape `[-1, out_channels]`
- **aggr** (_string_, _optional_): The message aggregation scheme to use ("add", "mean", "max")
- **root_lstm** (_bool_, _optional_): If set to `False`, the layer will not add the LSTM-transformed root node features to the output
- **bias** (_bool_, _optional_): If set to `False`, the layer will not learn an additive bias
- **\*\*kwargs** (_optional_): Additional arguments for `torch.nn.LSTM`

**Example Usage:**

```python
import torch
from lstm_gnn import LSTMConv

# Convolutional layer
conv_layer = LSTMConv(
    in_channels=1,
    out_channels=5,
    edge_nn=torch.nn.Linear(2, 5)
)

# Your input graph (see: https://pytorch-geometric.readthedocs.io/en/latest/notes/introduction.html#data-handling-of-graphs)
x = torch.randn((3, 12, 1), dtype=torch.float) # Shape is [num_nodes, seq_len, in_channels]
edge_index = torch.tensor([
    [0, 1, 1, 2],
    [1, 0, 2, 1]
], dtype=torch.long)
edge_attr = torch.randn((4, 2), dtype=torch.long)

# Your output graph
x = conv_layer(x, edge_index, edge_attr) # Shape is now [3, 5]
```

To-Do: Allow stacking of `LSTMConv` layers.