semvec/pypi-packages huggingface dataset:
imani 0.1.2
Advanced molecular analysis tools for molecular dynamics simulations.
Requires Python: >=3.9

# IMANI

## Overview

**IMANI** (Interaction Atoms Molecular Nanosecond Insights) is a Python package designed for analyzing molecular interactions from nanosecond-scale molecular dynamics (MD) simulations. Built on top of MDAnalysis, imani provides robust tools for molecular dynamics analysis, helping researchers quickly extract meaningful insights from complex molecular simulations. It enables users to study flip-flop movements, hydration profiles, and molecular orientations within complex systems such as membranes and micelles.

IMANI is built on top of MDAnalysis, NumPy, SciPy, and other powerful Python libraries, ensuring high performance and flexibility.

## Features

- **Flip-flop analysis:** Track molecule movement across membrane leaflets.
- **Hydration analysis:** Calculate water density profiles around specified molecules.
- **Orientation analysis:** Measure tilt angles and orientations of molecules relative to the membrane normal.

## Installation

You can install the IMANI package using pip:

```bash
pip install imani
manim-chessrender 0.1.2
A Manim plugin that allows you to generate scenes with chessboards with minimal setup.
Requires Python: <4.0,>=3.10

# Manim Chessboard

A Manim plugin that allows you to generate scenes with chessboards with minimal setup.


## Installation

```bash
pip install manim-chessrender
```

## Features

- **Initialize Chessboard**: Easily create and display a fully initialized chessboard.
- **Move Pieces**: Animate standard piece movements using UCI notation.
- **Special Moves**: Handle special chess moves like castling and en passant.
- **Load FEN Strings**: Load and display a board configuration from a FEN string.
- **Play PGN Files**: Load and animate moves from PGN files.
- **Customization**: Customize the appearance of the chessboard and pieces with different colors and image paths.


## Usage

To render the examples, you need to run the script using Manim. Below are the examples included in this project.


### MovePieceExample
This example initializes the chessboard and demonstrates moving a piece.

![MovePieceExample](https://github.com/codevardhan/manim-chess-plugin/blob/main/example/MovePieceExampleGif.gif?raw=true)


```python

class MovePieceExample(MovingCameraScene):
    """
    Scene to demonstrate moving a piece on the chessboard.
    """
    def construct(self):
        """
        Constructs the scene by initializing the chessboard and moving a piece.
        """
        chessboard = ChessBoard()
        chessboard.initialize_board()
        self.add(chessboard.board)
        self.wait(1)
        self.play(chessboard.execute_move('e2e4'))
        self.wait(2)
```

### PlayPGNExample
This example demonstrates playing moves from a PGN file on the chessboard.

![PlayPGNExample](https://github.com/codevardhan/manim-chess-plugin/blob/main/example/PlayPGNExample.gif?raw=true)


```python

class PlayPGNExample(MovingCameraScene):
    """
    Scene to demonstrate playing moves from a PGN file on the chessboard.
    """
    def construct(self):
        """
        Constructs the scene by loading a PGN file and animating the moves on the chessboard.
        """
        chessboard = ChessBoard()
        chessboard.initialize_board()
        self.add(chessboard.board)
        self.wait(1)
        
        games = chessboard.load_pgn("./example/example.pgn")
        game = games[0]
        for move in game:
            self.play(chessboard.execute_move(move.uci()))
            self.wait(0.5)
```

### Running the Examples
To run any of the examples, execute the script using Manim. For instance, to run the `InitializeChessBoard` example:

```sh
manim -pql examples.py InitializeChessBoard
```

Replace `InitializeChessBoard` with the class name of the example you want to run.

### License
This project is licensed under the MIT License. See the LICENSE file for more details.
evenv 1.0.3
Creates virtual embeddable Python environments in one or more target directories.
Requires Python: >=3.9

# Evenv: Embeddable Virtual Environment Builder

## Project Description

**Evenv** is a powerful Python virtual environment manager designed to create embeddable Python environments with enhanced flexibility. It allows users to include or exclude specific features like `tkinter`, offering fine-grained control over the environment's configuration. Built to address the needs of developers requiring highly customized environments, Evenv simplifies the management of dependencies, configurations, and system compatibility issues.

## Key Features

- **Customizable Build Options**: Create virtual environments with or without `tkinter` or `pip`.
- **Flexible Configuration**: Generate environments with customizable prompts, Python version compatibility, and pip pre-installation.
- **Cross-Platform Compatibility**: Supports symlinks and file copying across different operating systems.
- **Integration with Source Control**: Optionally generate `.gitignore` files for seamless source control management.

## Installation

### Prerequisites

- **Python**: Version 3.9 or later.
- **OS**: Compatible with Windows.
- **Dependencies**: Ensure the `venv` package is available in your Python environment.

### Installation Steps

1. Install from pypi:

   ```powershell
   pip install -U evenv
   ```

2. Verify the installation:
   ```powershell
   python -m evenv --help
   ```

## Usage

### Basic Usage

To create a new virtual environment:

```powershell
python -m evenv my_env
```

### Advanced Options

- Exclude `tkinter`:
  ```powershell
  python -m evenv my_env --without-tk
  ```
- Customize the prompt:
  ```powershell
  python -m evenv my_env --prompt "CustomEnv"
  ```

### Example

```powershell
python -m evenv my_project_env --without-tk --prompt "MyProject"
my_project_env\Scripts\activate
```
goodhomepy 1.1.2
Good Home API Client is a Python client for interacting with the Good Home API. This client allows you to manage authentication, refresh tokens, verify tokens, and retrieve information about users, devices, and homes via the Good Home API.

# Good Home API Client

Good Home API Client is a Python client for interacting with the Good Home API. This client allows you to manage authentication, refresh tokens, verify tokens, and retrieve information about users, devices, and homes via the Good Home API.

## Prerequisites

- Python 3.6+
- `requests` package
- `pydantic` package
- `requests-mock` package (for testing)

## Installation

Clone this repository and install the necessary dependencies.

```bash
git clone https://github.com/biker91620/goodhomepy.git
python setup.py install
```

## Example
```python
from good_home_client import GoodHomeClient

# Initialize the client
client = GoodHomeClient()

# Example of logging in
response = client.login("example@example.com", "password")
print(response)

# Update the access token
client.token = response.token

# Verify the token
verify_response = client.verify_token(client.token)
print(verify_response)

# Retrieve the user's devices
devices_response = client.get_devices("user_id")
print(devices_response)

# Retrieve user information
user_response = client.get_user("user_id")
print(user_response)

# Retrieve the user's homes
homes_response = client.get_homes("user_id")
print(homes_response)

```