semvec/pypi-packages huggingface dataset:
svfs3 3.0.0
Multi-purpose virtual file system inside single file (ported to Python 3)
Requires Python: >=3.9
Keywords: archiving, file-system, filesystem


# SVFS
*(Quoting from the original project [README](https://pypi.org/project/SVFS/)):*

SVFS allows to create virtual filesystem inside file on real filesystem. It can be used to store multiple files inside single file (with directory structure). Unlike archives, SVFS allows to modify files in-place. SVFS files use file-like interface, so they can be used (pretty much) like regular Python file objects. Finally, it’s implemented in pure python and doesn’t use any 3rd party modules, so it should be very portable. Tests show write speed to be around 10-12 MB/s and read speed to be around 26-28 MB/s.

## Example

Following code creates SVFS, opens file in it, writes string and reads it back:

from svfs3 import SVFS #Import SVFS class

s = SVFS() # Create instance of SVFS class
s.CreateSVFS('test.svfs','testvolume',100,100,100) # Create SVFS with 100 inodes and 100 blocks of 100 bytes.
s.OpenSVFS('test.svfs') # Open created SVFS
with s.open('testfile','w') as file: # Create and open new file for writing in SVFS.
    file.write('write test') # Write string into file
t = s.open('testfile','r') # Open same file for reading
print(t.read()) # Read entire file and print data
t.close() # Close file
s.CloseSVFS() # Close SVFS

That code outputs:

    write test

Which means it works correctly.

## Updates to v3:

SVFS now distinguishes between strings/bytes and will transparently encode/decode:

    # Open up a file in text mode. 
    with s.open('text_file','w', encoding='utf8') as text_file: 
        # If no encoding is given, defaults to 'utf-8'
        text_file.write("""This is a\nmultiline\ntext file""") # Write string into file, encoded as utf-8

    t_file = s.open('text_file','r') # Open same file for reading
    t_file.readlines()

This code outputs:

    ['This is a\n', 'multiline\n', 'text file']

Binary files work similarly:

    # Open up a file in binary mode. 
    with s.open('binary_file','wb') as binary_file: 
        # Passing 'b' as part of the mode parameter sets binary mode
        binary_file.write(b'Some bytes')
    
    b_file = s.open('binary_file', 'rb')
    b_file.read()

Outputs:

    b'Some bytes'

## Encrypted Files

Another update is the availability of encrypted files. Example:

    s = EncryptedSVFS('keytext-must-be-at-least-32-bytes-long') 
    # Create instance of EncryptedSVFS class, pass in encryption key, must be at least 32 bytes long
    s.CreateSVFS('encrypted.svfs','testvolume',100,100,100) 
    # Create SVFS with 100 inodes and 100 blocks of 100 bytes.
    s.OpenSVFS('encrypted.svfs') # Open created SVFS
    with s.open('testfile','w') as file: # Create and open new file for writing in SVFS. Contents of this file will be encrypted
        file.write('write test') # Write string into file

Now the contents of "testfile" are encrypted on disk.

    t = s.open('testfile','r') # Open same file for reading
    print(t.read()) # Read entire file and print data, things are transparently decrypted
    t.close() # Close file
    s.CloseSVFS() # Close SVFSf
VizDat 1.0.3
A fast and simple data visualization library for tabular data.
Requires Python: >=3.6

# VizDat

## Overview 📖
**VizDat** is a lightweight and efficient visualization library designed to simplify data exploration.
It provides a quick function for visualizing data distributions, helping users identify patterns and insights effortlessly.

## Features ⚙️
- 🚀 **Fast and Simple** – Quickly generate visualizations for tabular data.
- 🌟 **User-Friendly API** – Easily integrates into any workflow.
- ⚡ **Lightweight** – Minimal dependencies for high performance.

## Installation 📦
```
pip install VizDat
```

## Usage 📊
```
import VizDat  
import pandas as pd  

df = pd.read_csv("your_data.csv")  

#Generate histograms for numerical features
VizDat.data_dist(
    data=df, bins=30, exclude=None, include=None, 
    exclude_binary=False, color="skyblue", kde_color="crimson", kde=True
)
```

### Explaination of the function and its parameters 📝
What this function does:
- Plots histograms for all numerical features in a DataFrame in a grid layout.
- Determines the number of rows and columns in the grid dynamically.
- Allows excluding or including specific features.
- Supports Kernel Density Estimate (KDE) overlay.

Parameters explanation:
- **data** (*pd.DataFrame*): The input DataFrame (required).
- **bins** (*int*): Number of bins for histograms (default: `30`).
- **exclude** (*list*): Features to exclude from visualization (default: `None`).
- **include** (*list*): Features to specifically include (default: `None`).
- **exclude_binary** (*bool*): Whether to exclude binary features (default: `False`).
- **color** (*str*): Color of the histogram bars (default: `"skyblue"`).
- **kde_color** (*str*): Color of the Kernel Density Estimate (KDE) curve (default: `"crimson"`).
- **kde** (*bool*): Whether to show the KDE curve over histograms (default: `True`).

## Contribution 🤝
We welcome contributions to improve **VizDat**! Whether it's fixing bugs, enhancing features, or improving documentation, your help is appreciated.

Please contact me via my email **mustafa.farajallah99@gmail.com** or through my linked in profile, [LinkedIn profile](https://www.linkedin.com/in/mustafa-farajallah-a274a8298/)
pydal-limbo 0.1.1
Custom pyDAL adapter for limbo (SQLite rebuild)
Requires Python: >=3.10

# Limbo for pyDAL

**Proof of concept** pydal driver and dbapi2 implementation.

Note that the limbo python bindings are very limited, thus also limiting the pydal features!

This project is not ready yet for any real-life usage!

---

## Example usage:

```python
from pydal import DAL

# required to register limbo://
import pydal_limbo

db = DAL("limbo://storage.sqlite", folder="database")

# table = db.define_table(...)
# table.insert(id=1, ...)
# row = table(id=1)
# db.executesql(...)
# etc.

```

`db` should in the future support the same features the `sqlite3` driver
for [pyDAL](http://www.web2py.com/books/default/chapter/29/06/the-database-abstraction-layer) does.

## Limitations

Transactions are not supported in the Python driver for limbo.  
There also seems to be a problem where changes are written to a WAL-file instead of the actual database, even if 
`PRAGMA journal_mode=OFF` is used instead of `PRAGMA journal_mode=WAL`.