semvec/pypi-packages huggingface dataset:
jupyturtle 2024.4.1
Turtle graphics for Jupyter Notebooks
Requires Python: >=3.10

# jupyturtle

Python Turtle graphics for Jupyter notebooks

For a quick demo, open
[the lab notebook](https://github.com/ramalho/jupyturtle/blob/main/notebooks/lab.ipynb).

To use on a live Jupyter Notebook, 
just download the `jupyter.py` file to the same folder where your notebook is saved,
and import it.


## Credits

The idea and some of the code for this module came from
[Tolga Atam](https://github.com/tolgaatam)'s
[ColabTurtle](https://github.com/tolgaatam/ColabTurtle/tree/master),
which I discovered reading a pre-print version of
[Allen Downey](https://github.com/allendowney)'s book
_[Think Python, Third Edition](https://greenteapress.com/wp/think-python-3rd-edition/)_ (O'Reilly, 2024).


## Design

Atam's best idea was to use SVG for drawing, which makes the code simple and lightweight, 
requiring only the Python standard library and the
`ipython` module that is always available in Jupyter.

This is a rewrite from scratch, using classes to model the turtle
and the drawing.
My goal was to make it easier to understand and extend by
encapsulating the state.

I used metaprogramming techniques to build the procedural API
with global functions like `fd()` to move the turtle.
The techniques are easier to understand in the didactic project
[abacus](https://github.com/fluentpython/abacus).

### Turtle on a canvas

[`jupyturtle2`](https://github.com/fluentpython/jupyturtle2) is a fork
that uses 
[`ipycanvas`](https://ipycanvas.readthedocs.io/en/latest/)
to draw pixels on an HTML canvas, instead of generating SVG,
so it handles complex drawings better.

But `jupyturtle2` has two main drawbacks:

* `ipycanvas` requires the binary dependencies `numpy` and `pillow`,
which may be harder to install in some environments.

* the generated drawings are not saved with the notebook like most other output cells; this is also a limitation of `ipycanvas`

*[@ramalho](https://github.com/ramalho)*
CombineFiles-csv-xlsx 1.0
Python package to combine multiple Excel and CSV files in a folder.

# File Combining Functions

This Python package provides two functions to combine multiple files present in a folder into a single file.

## Installation

You can install the package using pip: **pip install filecombiner**

#### Usage

```python
from CombineFiles import combine_excel_files

# Provide the folder path containing Excel files and the output file path
combine_excel_files("path_to_excel_folder")
from CombineFiles import combine_csv_files

# Provide the folder path containing CSV files and the output file path
combine_csv_files("path_to_csv_folder")
```
Jinja2-Haml 0.3.5
Haml-ish syntax for jinja2 templates
Requires Python: >=3.8
Keywords: jinja2, templates, haml

========================
Hamlish-Jinja
========================

Overview
========

This extension to jinja makes it possible to use a haml-ish syntax for your jinja templates. It is
implemented as a preprocessor and so it runs only the first time your template is parsed. So it will
not affect the performance of your templates except for the first run.

Forked from `Pitmairen/hamlish-jinja <https://github.com/Pitmairen/hamlish-jinja>`_

Usage
=====

Install
--------

You can install the latest version with pip

::

    pip install git+https://git.barkshark.xyz/barkshark/hamlish-jinja

or

::

    pip install jinja2-haml

Basic Usage
-----------

To use this extension you just need to add it to you jinja environment and use ".haml", ".jhaml", or
".jaml" as an extension for your templates.

.. code-block:: python

    from jinja2 import Environment
    from hamlish_jinja import HamlishExtension

    env = Environment(extensions = [HamlishExtension])


Environment
-----------

*Added in version 0.2.0*

The environment gets extended with a new method ``hamlish_from_string``
which works the same as the standard ``env.from_string`` method, but renders
the template with the hamlish preprocessor.

.. code-block:: haml

    tpl = '''
    %div
        %p
            test
    '''

    env.hamlish_from_string(tpl).render()
sqlite-kv 0.1.2
Async Key-Value interface over SQLite. Supports any datatype, including JSON and BLOB
Requires Python: >=3.10

# Sqlite Kv

> Async Key-Value interface over SQLite. Supports any datatype, including JSON and BLOB

## Usage

> Simplest is to use the `SQKliteKV` api

- JSON documents

  ```python
  from sqlite_kv import SQLiteKV

  api = await SQLiteKV.documents(db_path='mydb.sqlite', table='myjsons')
  # or, if you're sure the DB file already exists
  api = SQLiteKV.documents(db_path='mydb.sqlite', table='myjsons', create=False)
  await api.upsert('my-doc', dict(hello='world'))
  await api.read('my-doc') # dict(hello='world')
  ```

- BLOBs
  
  ```python
  from sqlite_kv import SQLiteKV

  api = await SQLiteKV.blobs(db_path='mydb.sqlite', table='myblobs')
  await api.upsert('my-image', b'<super big image>')
  await api.read('my-image') # b'...'
  ```

- Any custom datatype (e.g. JSON, but manually)

  ```python
  import json
  from sqlite_kv import SQLiteKV

  api = await SQLiteKV.new(
    db_path='mydb.sqlite', table='my-jsons',
    dtype='JSON', parse=json.loads, dump=json.dumps
  )
  await api.upsert('my-image', dict(hello='world'))
  await api.read('my-image') # dict(hello='world')
  ```