semvec/pypi-packages huggingface dataset:
frf2seq2 0.1.1
frame2seq test
Requires Python: >=3.10

# Frame2seq
Official repository for Frame2seq, a structured-conditioned masked language model for protein sequence design, as described in our preprint [Structure-conditioned masked language models for protein sequence design generalize beyond the native sequence space](https://doi.org/10.1101/2023.12.15.571823).

## Colab notebook
Colab notebook for generating sequences with Frame2seq: [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/dakpinaroglu/Frame2seq/blob/main/notebooks/Frame2seq.ipynb)

## Setup
To use Frame2seq, install via pip:
```bash
pip install frame2seq
```

Alternatively, you can clone this repository and install the package locally:
```bash
$ git clone git@github.com:dakpinaroglu/Frame2seq.git
$ pip install Frame2seq
```

## Usage

### Sequence design

To use Frame2seq to generate sequences, you can use the `design` function.

```python
from frame2seq import Frame2seqRunner

Frame2seq = Frame2seqRunner()
Frame2seq.design(pdb_file, chain_id, temperature, num_samples)
```


#### Arguments

- `pdb_file`: Path to PDB file.
- `chain_id`: Chain ID of protein.
- `temperature`: Sampling temperature.
- `num_samples`: Number of sequences to sample.


## Citing this work

```bibtex
@article{akpinaroglu2023structure,
  title={Structure-conditioned masked language models for protein sequence design generalize beyond the native sequence space},
  author={Akpinaroglu, Deniz and Seki, Kosuke and Guo, Amy and Zhu, Eleanor and Kelly, Mark JS and Kortemme, Tanja},
  journal={bioRxiv},
  pages={2023--12},
  year={2023},
  publisher={Cold Spring Harbor Laboratory}
}
```
grid-sdk 1.0.1
A small example package
Requires Python: >=3.7

# GRID Python SDK
Python SDK to simplify integration with GRID services: https://gridgs.com

**It's in beta state now. Please expect changes (we'll try to keep them backward-compatible).**

# Main parts
GridAuthClient - Used to authorize on GRID SSO server.

GridApiClient - Client for GRID RespAPI that can work with main Grid entities (right now with sessions only).

GridEventSubscriber - subscriber to receive real-time events about changes in sessions (creation, deletion, starting and so on).

GridMQTTClient - Client for GRID MQTT API. It useful for realtime connection (receive downlink frames and send uplink frames).

# Examples how to use
## GridAuthClient
```
logger = logging.getLogger()
```

```
keycloak_openid = KeycloakOpenID(server_url="https://login.gridgs.com", client_id="grid-api", realm_name="grid")
grid_auth_client = GridAuthClient(open_id_client=keycloak_openid, username="user@gridgs.com", password="userpass", company_id=1, logger=logger)
```

## GridApiClient

```
grid_api_client = GridApiClient(base_url="https://api.gridgs.com" auth_client=grid_auth_client, logger=logger)
```

### Get predicted sessions
```
sessions = grid_api_client.get_predicted_sessions() 
```

### Create a session

```
session = Session() # A session from get_predicted_sessions
session = grid_api_client.create_session(session)
```

## GridEventSubscriber

Receive statuses of sessions

```
grid_event_subscriber = GridEventSubscriber(host="api.gridgs.com", port=1883, auth_client=grid_auth_client, logger=logger)

grid_event_subscriber.on_event(on_event)
grid_event_subscriber.run()

def on_event(self, event: SessionEvent):
    session = event.session
```

## GridMQTTClient

```
grid_mqtt_client = GridMQTTClient(host="api.gridgs.com", port=1883, auth_client=grid_auth_client, logger=logger)

grid_mqtt_client.subscribe(session, on_downlink_frame)
grid_mqtt_client.connect()

def on_downlink_frame(frame: Frame):
```

### Sending a frame

```
grid_mqtt_client.send(session, b'Uplink frame data')
```
ecs-girvel 3.0.1
Annotation-based asynchronous ECS library
Requires Python: >=3.7

[//]: # (TODO mention minimalistic & does not presume anything, maximal compatibility)

# ECS micro-engine

Library for python containing an interpretation of ECS design pattern. 

## Features

1. Adding/removing entity's attributes causes dynamic addition/removal of the entity from the corresponding systems
2. Systems with annotation-based syntax
3. Asynchronous systems (yield skips a frame)
4. Systems accept multiple arguments, preventing global mutable state issues
5. Full compatibility with type hints

## Interpretation

1. Entity is a python object
2. Component is entity's attribute
3. System is an entity describing an interaction between cartesian product of entities
4. Metasystem is a system that launches other systems
5. MetasystemFacade encapsulates all general logic (add, remove, update)

## Installation

```bash
pip install ecs-girvel
```

## Usage

You can also see [girvel/fallen](https://github.com/girvel/fallen), ecs is written for it.

```py
from ecs import MetasystemFacade, System, Entity  # TODO NEXT fix demo
import time


# 1. You create a metasystem
ms = MetasystemFacade()

dt = 0.04

# 2. You create systems and add them to metasystem
class VerticalSpeed:
    vy: float

class GravityConstants:
    g: float

@ms.add
@System
def gravity(target: VerticalSpeed, constants: GravityConstants):
    target.vy += constants.g * dt

class Inert:
    x: float
    y: float
    vx: float
    vy: float

@ms.add
@System
def inertia(target: Inert):
    target.x += target.vx * dt
    target.y += target.vy * dt

class Displayable:
    x: float
    y: float
    name: str

@ms.add
@System
def output(target: Displayable):
    yield from range(int(1 / dt) - 1)  # skips 24 out of 25 frames
    print(f'{target.name}: {target.x:.2f}, {target.y:.2f}')


# 3. You create objects
class DynamicEntity(Entity):
    def __init__(self, **attributes):
        for key, value in attributes.items():
            setattr(self, key, value)

ms.add(DynamicEntity(name='falling_guy1', x=0, y=0, vx=0, vy=0))
ms.add(DynamicEntity(name='falling_guy2', x=100, y=0, vx=0, vy=0))
ms.add(DynamicEntity(g=10))


# 4. Game loop
if __name__ == "__main__":
    while True:
        ms.update()
        time.sleep(dt)
```
nicepdf 0.1.0
nicegui based PDF manipulation tool - e.g. booklet conversion
Requires Python: >=3.8
Keywords: nicegui,pdf

# nicepdf
online PDF display and manipulation tool

[![Join the discussion at https://github.com/WolfgangFahl/nicepdf/discussions](https://img.shields.io/github/discussions/WolfgangFahl/nicepdf)](https://github.com/WolfgangFahl/nicepdf/discussions)
[![pypi](https://img.shields.io/pypi/pyversions/nicepdf)](https://pypi.org/project/nicepdf/)
[![Github Actions Build](https://github.com/WolfgangFahl/nicepdf/workflows/Build/badge.svg?branch=main)](https://github.com/WolfgangFahl/nicepdf/actions?query=workflow%3ABuild+branch%3Amain)
[![PyPI Status](https://img.shields.io/pypi/v/nicepdf.svg)](https://pypi.python.org/pypi/nicepdf/)
[![GitHub issues](https://img.shields.io/github/issues/WolfgangFahl/nicepdf.svg)](https://github.com/WolfgangFahl/nicepdf/issues)
[![GitHub closed issues](https://img.shields.io/github/issues-closed/WolfgangFahl/nicepdf.svg)](https://github.com/WolfgangFahl/nicepdf/issues/?q=is%3Aissue+is%3Aclosed)
[![License](https://img.shields.io/github/license/WolfgangFahl/nicepdf.svg)](https://www.apache.org/licenses/LICENSE-2.0)

## Docs and Tutorials
[Wiki](https://wiki.bitplan.com/index.php/nicepdf)

## Demo
[nicepdf demo](http://nicepdf.bitplan.com)
data-magic 0.1
A python library to help you import and export data from various formats easily

# Data Magic

A Python library to help you import and export data from various formats easily

## Installation

Install the package using pip:

```bash
pip install data-magic
```

## Features

- Fetches JSON data from a provided URL.
- Supports handling authentication tokens for secured endpoints.
- Converts JSON data to CSV or JSON file formats.
- Connects to an SQL database and fetches data based on provided connection parameters.
- Converts SQL query results to CSV or JSON file formats.


## Usage 

- convert json data
```python
from datamagic import JsonCsvConverter

# Create a new JsonCsvConverter instance
converter = JsonCsvConverter(url='https://jsonplaceholder.typicode.com/todos/1',
                              auth_token='your_auth_token')

# Convert the JSON data to a CSV file and save it
converter.convert_to_file('output.csv', output_format='csv')

# Convert the JSON data to a JSON file and save it
converter.convert_to_file('output.json', output_format='json')

```

- convert sql data
```python
from database_converter import DatabaseToCSVConverter

# Replace these with your actual database connection parameters
connection_params = {
    'host': 'your_host',
    'user': 'your_username',
    'password': 'your_password',
    'database': 'your_database'
}

converter = DatabaseToCSVConverter(connection_params)

# Define your SQL query to retrieve data from the database
sql_query = "SELECT * FROM your_table"

# Convert fetched data to CSV format
converter.convert_to_file(sql_query, 'output.csv', output_format='csv')

# Convert fetched data to JSON format
converter.convert_to_file(sql_query, 'output.json', output_format='json')
```
gridgs 1.0.5
A small example package
Requires Python: >=3.7

# GRID Python SDK
Python SDK to simplify integration with GRID services: https://gridgs.com

**It's in beta state now. Please expect changes (we'll try to keep them backward-compatible).**

# Main parts
GridAuthClient - Used to authorize on GRID SSO server.

GridApiClient - Client for GRID RespAPI that can work with main Grid entities (right now with sessions only).

GridEventSubscriber - subscriber to receive real-time events about changes in sessions (creation, deletion, starting and so on).

GridMQTTClient - Client for GRID MQTT API. It useful for realtime connection (receive downlink frames and send uplink frames).

# Examples how to use
## GridAuthClient
```
logger = logging.getLogger()
```

```
keycloak_openid = KeycloakOpenID(server_url="https://login.gridgs.com", client_id="grid-api", realm_name="grid")
grid_auth_client = GridAuthClient(open_id_client=keycloak_openid, username="user@gridgs.com", password="userpass", company_id=1, logger=logger)
```

## GridApiClient

```
grid_api_client = GridApiClient(base_url="https://api.gridgs.com" auth_client=grid_auth_client, logger=logger)
```

### Get predicted sessions
```
sessions = grid_api_client.get_predicted_sessions() 
```

### Create a session

```
session = Session() # A session from get_predicted_sessions
session = grid_api_client.create_session(session)
```

## GridEventSubscriber

Receive statuses of sessions

```
grid_event_subscriber = GridEventSubscriber(host="api.gridgs.com", port=1883, auth_client=grid_auth_client, logger=logger)

grid_event_subscriber.on_event(on_event)
grid_event_subscriber.run()

def on_event(self, event: SessionEvent):
    session = event.session
```

## GridMQTTClient

```
grid_mqtt_client = GridMQTTClient(host="api.gridgs.com", port=1883, auth_client=grid_auth_client, logger=logger)

grid_mqtt_client.subscribe(session, on_downlink_frame)
grid_mqtt_client.connect()

def on_downlink_frame(frame: Frame):
```

### Sending a frame

```
grid_mqtt_client.send(session, b'Uplink frame data')
```
akl-cameras 0.1.0
Tool that allow to operate cameras owned by AKL
Requires Python: >=3.9,<4.0

# AKL Cameras

Tool that allow to operate cameras owned by AKL.

## Instalation

### Install required package

*Manjaro:*

```bash
$ sudo pamac install gphoto2
```

*Fedora:*

```bash
$ sudo dnf install gphoto2
```

*RaspberyPi:*

```bash
$ sudo apt install gphoto2
```

### Setup repository

```bash
$ git clone git@gitlab.com:academic-aviation-club/droniada-2024/akl-cameras.git
$ cd akl-cameras
$ poetry install --no-root
$ poetry shell
```

### Setup repository on RaspberyPi:

```bash
$ git clone git@gitlab.com:academic-aviation-club/droniada-2024/akl-cameras.git
$ cd akl-cameras
```

### Hardware preparation

1. Connect camera to the on-board computer,
biofkit-Chou-Uken 0.0.1
With biofkit, sequence can be easily extract from pdb. And more functions will be added.
Requires Python: >=3.9

# biofkit
Biofkit is now containing only one module with one package which can transfer pdb into fasta (or a sequence dictionary) very easily. 

## How to Install
### Conda
```console
conda install -c chou_uken biofkit
```
### Mamba
``` 
mamba install -c chou_uken biofkit
```

## How to Use
### ProteinKit
```python
from proteinKit import pdbKit

# if argument fasta is True, a fasta file will be created in the same path as the pdb file.
pdbKit.pdb2Seq(pdbFilePath: str, fasta: bool = False) -> dict[str, str]
```