semvec/pypi-packages huggingface dataset:
TurtleEssentials 0.0.8
Extention of the built in Turtle package
Requires Python: >=3.8


# **Turtle Extentions**
![LOGO](https://i.postimg.cc/y6JWpLvM/Untitled-design.png)

## Docs:
### Install:
- Open CMD Prompt by pressing the windows button and typing cmd, then hit enter
- Type ```py -m pip install TurtleExtentions``` (Windows) or 
```python pip install TurtleExtentions``` (Linux/MacOS)
- Import the module inside the code like this: 
```python
import TurtleExtentions as TE
# Code here
```
### Basic shapes and arguments:
#### Basic Shapes:
- The `Shape` class contains all basic shapes
- To use it, just type 
```python
import TurtleExtentions as TE
TE.Shape.ShapeHere(params)
```
- Lets make a hexagon appear
```python
TE.Shape.Hexagon(Size=50) # The size by default is 20
```
- To change its position just use the pos1 and pos2 arguments
```python
TE.Shape.Hexagon(Size=50, pos1=150, pos2=150) # Default positons are 100, 100
```
- Now by default this would not be filled in. To do so set the DoFill paramater to True 
- You can also edit the fillcolor with the FillColor paramater like this
```python
TE.Shape.Hexagon(Size=50, pos1=150, pos2=150, DoFill=True, FillColor="Green")
```
- That would result in this
![HEXAGON-SHAPE-DOCS](https://i.postimg.cc/VLpqHSqR/image.png)

- Now if you want to delete the last drawn shape, simply use the Remove_Shape function
```python
TE.Shape.Hexagon()
TE.Shape.Remove_Shape()
``` 
- And if you want to delete a certain shape, just set the index of your shape! (Note: The shapes are stored in a list, therefore the index starts at 0)
```python
TE.Shape.Hexagon()
TE.Shape.Triangle()
TE.Shape.Remove_Shape(0)
```
- Which results in the hexagon getting deleted.

## Release 0.0.8
- Remove_Shape adjusted
sparta-spanner 0.2.1
Sparta spanner library
Requires Python: >=3.9

# sparta-spanner

Sparta [Google Spanner](https://console.cloud.google.com/spanner/instances) library.

## Usage

```python
import os

import sparta.spanner

instance_id = os.getenv("INSTANCE_ID")
database_id = os.getenv("DATABASE_ID")
db_service = sparta.spanner.DBService(
    instance_id=instance_id,
    database_id=database_id,
    pool_size=5,
    session_request_timeout=2,
)

# Blocking
results = sparta.spanner.zip_results(db_service.execute_sql("SELECT 1 as my_field"))
assert results is not None
assert len(results) == 1
assert results[0] == {"my_field": 1}


# Non-Blocking
def task(snapshot):
    result1 = sparta.spanner.zip_results(snapshot.execute_sql("SELECT 1 as my_field"))
    result2 = sparta.spanner.zip_results(snapshot.execute_sql("SELECT 2 as my_field"))
    return result1 + result2


results = await db_service.run_in_snapshot(task, multi_use=True)
assert results is not None
assert len(results) == 2
assert results[0] == {"my_field": 1}
assert results[1] == {"my_field": 2}
```
gradio-molgallery3d 1.1.0
A Gradio component designed for displaying an interactive gallery of 3D molecular structures.
Requires Python: >=3.8
Keywords: 3D structures,Molecules Structures,gradio-custom-component,gradio-template-Gallery,py3Dmol


# gradio_molgallery3d
A Gradio component designed for displaying an interactive gallery of 3D molecular structures. It is designed to accept inputs consisting of [`RDKit`](https://www.rdkit.org/docs/source/rdkit.Chem.rdchem.html#rdkit.Chem.rdchem.Mol) objects.

## Installation
This component can be installed through pip:
```bash
pip install gradio_molgallery3d
```

## Example usage

```python
import gradio as gr
from gradio_molgallery import MolGallery3D

gallery3d = MolGallery3D(columns=5, height=1000, label="3D Interactive Structures", automatic_rotation=True)
```

## Features

* When the `automatic_rotation` parameter is set to `True`, the molecular structures rotate automatically.
* Clicking the right mouse button on the 3D structure allows you to download the image as a .png file.

## Known Issues

* Web browsers typically impose limits on the number of canvas objects that can be displayed on a single page, which may result in some structures not being drawn. The specific limitations vary depending on the browser. More details: [[1](https://stackoverflow.com/questions/59140439/allowing-more-webgl-contexts), [2](https://webglfundamentals.org/webgl/lessons/webgl-multiple-views.html#:%7E:text=Another%20issue%20is%20most%20browsers,that%20covers%20the%20entire%20window.)]

# Information
For any questions and comments, contact [Davide Rigoni](mailto:davide.rigoni.1@unipd.it).

# Licenze
GPL-3.0
gradio-molgallery2d 1.1.0
A Gradio component designed for displaying a gallery of 2D molecular structures.
Requires Python: >=3.8
Keywords: 2D Molecular Structure,Gallery,Molecular Structure,RDKit,gradio-custom-component,gradio-template-gallery

# gradio_molgallery2d
A Gradio component designed for displaying a gallery of 2D molecular structures. It is designed to accept inputs consisting of [`RDKit`](https://www.rdkit.org/docs/source/rdkit.Chem.rdchem.html#rdkit.Chem.rdchem.Mol) objects.

## Installation
This component can be installed through `pip`:
```bash
pip install gradio_molgallery2d
```

## Example usage

```python
import gradio as gr
from gradio_molgallery import MolGallery2D

gallery2d = MolGallery2D(columns=5, height=1000, label="3D Interactive Structures")
```

# Information
For any questions and comments, contact [Davide Rigoni](mailto:davide.rigoni.1@unipd.it).

# Licenze
GPL-3.0
json-relational 0.0.3
convert nested json to flat objects and their mapping

# json_relational: Transforming Nested JSON to Relational Format

`json_relational` is a small Python package for converting complex, nested JSON data into a flat, relational format. This transformation makes it significantly easier to work with JSON data in contexts where relational databases are more suitable, such as SQL databases. The package is designed to be dynamic and flexible, accommodating various levels of nested structures and converting them into a format that can be easily mapped to SQL tables.

## Features

- **Dynamic Nesting Handling**: Effortlessly manages various levels of nested JSON data.
- **SQL Table Ready**: Transforms JSON into a format that is easily convertible to SQL tables.
- **Customizable Depth Control**: Set the maximum depth for flattening nested structures.
- **Key Mapping Support**: Allows for the remapping of keys to desired names in the output.

## Installation

To install `json_relational`, clone the repository from GitHub and install it using pip:

```bash
git clone https://github.com/gr0vity-dev/json-relational.git
cd json_relational
pip install .
```

## Usage

Here's a simple example to demonstrate how `json_relational` can be used to transform nested JSON data into a relational format:

```python
from json_relational import JsonRelational
import json

# Example JSON data
json_data = {
    "type": "employee",
    "id": 123,
    "data": {
        "department": "sales",
        "manager": "Bob"
    }
}

# Create an instance of JsonRelational
jr = JsonRelational()

# Flatten the JSON data
flattened_data = jr.flatten_json(json_data)

print(json.dumps(flattened_data, indent=4))

```

### Output:

The output will be a dictionary containing flattened data, along with mappings and accumulated children, ready to be transformed into SQL tables.

```json
{
    "log": [
        {
            "sql_id": 1,
            "type": "employee",
            "id": 123
        }
    ],
    "data": [
        {
            "sql_id": 1,
            "department": "sales",
            "manager": "Bob"
        }
    ],
    "mappings": [
        {
            "main_type": "log",
            "main_sql_id": 1,
            "link_type": "data",
            "link_sql_id": 1
        }
    ]
}
```

## Contributing

Contributions, issues, and feature requests are welcome! Feel free to check [issues page](https://github.com/gr0vity-dev/json-relational/issues).

## License

Distributed under the MIT License. See `LICENSE` for more information.

---

`json_relational` offers an innovative solution for managing and transforming JSON data into a relational structure, making it an invaluable tool for database management, data analysis, and software development involving complex JSON data structures.