semvec/pypi-packages huggingface dataset:
pege 1.2.1
Protein embeddings to describe local electrostic enviroments
License: MIT
Requires Python: >=3.6.2,<4.0

# Protein Environment Graph Embeddings (PEGE)

Protein embeddings to describe local electrostic environments

# Installation & Basic Usage

PEGE is installable from the Pypi repo:
```bash
python3 -m pip install pege
```

[Pytorch Geometry](https://pytorch-geometric.readthedocs.io/en/latest/notes/installation.html) also needs to be installed

In order for the structure preprocessing to work python2 and gawk need to installed.
```bash
apt install python2 gawk
```

Pege can be used to obtain protein embeddings as well as descriptors for specific `atom_numbers` from a `pdb` file:
```python
from pege import Pege

protein = Pege(<pdb>)
protein_emb = protein.get_protein()
all_res_embs = protein.get_all_res_embs(chain="A")
```

# Documentation
TBA

# License
This source code is licensed under the MIT license found in the LICENSE file in the root directory of this source tree.

# Contacts
Please submit a github issue to report bugs and to request new features. Alternatively, you may email the developer [directly](mailto:pedro.reis@bayer.com).
pytactoe 0.15.0
Python library for k-in-a-row family of games, including    (m,n,k)-game, Connect6, Pente, Ultimate tic-tac-toe and others
License: MIT
Keywords: tictactoe tic-tac-toe gomoku connect6 pente

# PyTacToe: library for k-in-a-row games
## Introduction
PyTacToe is a Python library for k-in-a-row family of games, including:
- (m,n,k)-game
- Pente
- Connect6
- Ultimate tic-tac-toe
- Some tic-tac-toe variants (Order and chaos, Misere, Impartial, Wild)

## Features
- Most of the games support N players, n-by-m board including ∞-by-∞ with k-in-a-row to win.
- Legal move generation, checking wins and draws
- Tracking board history and reverting moves
- Creating and parsing FEN
- Engine evaluation

## Installing
Install the latest release using pip:
```
pip install pytactoe
```

## Usage

Initializing games
```python
>>> from pytactoe import *

>>> ttt = TicTacToe(m=3, n=3, k=3, infinite=False, players=2)

>>> mis = MisereTicTacToe(m=3, n=3, k=3, infinite=False, players=2)

>>> imp = ImpartialTicTacToe(m=3, n=3, k=3, infinite=False, players=2)

>>> pente = Pente(m=19, n=19, k=5, infinite=False, players=2)

>>> connect6 = Connect6(m=19, n=19, k=6, p=2, q=1, infinite=False)

>>> ult = UltimateTicTacToe(m=3, n=3, k=3, which_local_board=(0,0), players=2)

>>> wild = WildTicTacToe(m=3, n=3, k=3, infinite=False, players=2)

>>> oac = OrderAndChaos(m=4, n=4, k=3, infinite=False)
```

Making moves
```python
>>> ttt.move(0,1)
>>> ttt.move(1,1)
>>> ttt.move(0,2)
>>> ttt.move(2,2)
>>> ttt.move(0,0)
```

Some games have their own format of moves
```python
>>> connect6.move_sequence([(0,1)])
>>> connect6.move_sequence([(2,2), (3,2)])
>>> wild.wild_move(1, 1, Piece.X)
>>> oac.wild_move(2, 3, Piece.X)
```

Checking wins and draws
```python
>>> ttt.result()
<Result.WIN: 1>

>>> tt.get_winner()
<Piece.X: 1>
```

Getting board history and reverting moves
```python
>>> ttt.pop()
>>> ttt.move_history
[(0, 1), (1, 1), (0, 2), (2, 2)]
```

Creating and parsing FEN
```python
>>> ttt.fen
'1XX/1O1/2O X 3'
```

```python
>>> print(Pente.from_fen('XX1/O1O/3 X 3'))
XX.
O.O
...
```

Showing a simple ASCII board
```python
>>> print(ttt)
.XX
.O.
..O
```

Getting legal moves
```python
>>> print(list(ttt.legal_moves()))
[(0, 0), (1, 0), (1, 2), (2, 0), (2, 1)]
```

Showing a fancy Unicode board
```python
>>> print(ttt.unicode())
🟩⬜⬜
🟩⬛🟩
🟩🟩⬛
```

Resetting board
```python
>>> tt.reset()
>>> tt
TicTacToe.from_fen('3/3/3 X 1')
```

## License

PyTacToe is available under the MIT license. For the full text, check out `LICENSE`.