semvec/pypi-packages huggingface dataset:
pynestor 1.13.0
Nestor wrapper in python
Requires Python: >=3.8

# Variables d'environnement
NO_DB_DUMP (default FALSE):
if not already existing, preview will be mounted without dump from prod instance, but with demo datas

NO_CLEAN (default FALSE): if set, the dump restored will not be cleaned. To be used only if providing already clean dump  to preview !!!!

MODULES_WITHOUT_DEMO (Optionnel) :
list of modules for --without-demo option (modules that will be loaded without demo data)

NESTOR_NAME_PREFIX (Optionnel) :
Le nom et l'url de la preview commenceront par cette variable si présente. Ceci permet de différencier les preview de 2 projets (par exemple core et filiale) qui utilisent la même branche.

NESTOR_NAME (Optionnel) :
Le nom de la previews et son url utiliseront cette variable à la place du nom de la branche

ENABLE_QUEUE_JOB (Optionnel) :
Les jobs sont activés si True. Charge le server_wide module queue_job, community doit être en dépendance 

ALWAYS_DELETE (Optionnel) :
Si True, l'instance est supprimée et recrée à chaque preview up

ALWAYS_RESTORE (Optionnel) :
Si True, la base est restaurée à chaque preview up, même si l'instance existe déjà

NEVER_DELETE_ON_FAIL (Optionnel) : Si True, l'instance ne sera pas supprimée si le redémarage après le restore se passe mal, afin de pouvoir analyser et éventuellement corriger manuellement la BDD. Ceci peut être utile pour les qualifs clients permanentes. 

NO_RESET_PASSWORD (Optionnel) : permet de ne pas réinitialiser les mots de passe, qui resteront ceux de la prod restaurée. Le comportement par défaut est de remplacer tous les mots de passe par un mot de passe généré.

S3_DUMP_SECRET (Optionnel) : le nom du secret dans le kube (nestor) qui sera utilisé pour obtenir les informations d'accès au S3 sur lequel sont stockés les dumps

# Dev interaction

### déploiement
Penser à changer la version dans le `setup.cfg` pour que le pipeline de deploy se lance
### lancement en local pour tester le mode interactif :
`python -m pynestor preview --interactive --up`
pypostcard 0.1.1
Python implementation of the postcard serialization format
Requires Python: >=3.10

# PyPostcard

Python implementation of the postcard serialization format.

## Installation

### Using uv (recommended)

```bash
uv pip install .
```

The package automatically detects your Python implementation and installs the appropriate dependencies:
- On CPython: Installs with pyserde for efficient serialization
- On PyPy: Uses a custom optimized implementation

### Development Installation

Install in editable mode:
```bash
uv pip install -e .
```

## Implementation Details

The library automatically detects whether you're using CPython or PyPy and uses the appropriate implementation:
- On CPython: Uses `pyserde` for efficient serialization/deserialization
- On PyPy: Uses a custom implementation optimized for PyPy
paxutils 0.3.0
Miscellaneous utilities for PAX notebooks.
Requires Python: >=3.6

# paxutils
Miscellaneous utilities for PAX notebooks.

The `path.Path` class is a dropin replacement for `pathlib.Path` in the context of the PAX platform. Use the standard `pathlib` in any other context.

# Usage
```python
from paxutils.path import Path

# define path for file `myfile` in the context of the PAX course `GIF-U014`
path = Path('myfile', course='GIF-U014')
...
```

# build distribution
uv build

# upload to pypi
uv publish
persistent-sql 0.2.2
Persistent SQLite Database using S3 on Cloud Workspaces
Requires Python: >=3.6

# Persistant SQLite Database on Cloud Workspaces 

As a data science enthusiast, I have been using Lightning AI for my analytics and upskilling. It’s a great and cost-effective platform, but I’ve often faced one major limitation—the absence of SQL Server or any other persistent database.

This isn’t just a Lightning AI issue; it’s a common challenge with Google Colab, Codespaces, and other cloud workspaces. One common workaround is using SQLite, but there’s a catch—since cloud workspaces are ephemeral, all data is lost after every session, forcing me to recreate tables from scratch each time.

In Lightning AI, I could reuse the same database file within the same studio, but what if I wanted to access it across different studios? While there is a way around this, it’s neither easy nor straightforward.

Exploring Alternatives

I considered using AWS RDS or Azure Databases, but they are expensive and not ideal for someone using them for personal projects or learning.

The Solution: Persistent SQL Database for Cloud Workspaces

To address this, I built a python module 'persistent-sql' that allows users to maintain a persistent SQL database in cloud environments using:
✅ SQLite Database for local queries
✅ AWS S3 Bucket for persistent storage

How to Use - 
1. pip install persistent-sql
2. import persistent-sql as ps
	ps.configure_aws(AWS_KEY, AWS_SECRET, AWS_BUCKET_NAME) 
	ps.connect_db('DEV')
	%sql select * from tablename
	ps.close_connection()

Limitations & Considerations

🔹 This works best when your database size is small.
🔹 If your data grows significantly, consider splitting tables across multiple database files to optimize performance.

GitHub Repository & Demo Notebook

I have shared sample notebook demonstrating how to use this solution. Feel free to explore, contribute, and share your feedback! 🚀
shellman 1.0.2
Write documentation in comments and render it with templates.
Requires Python: >=3.9

<p align="center">
  <img src="https://rawgit.com/pawamoy/shellman/master/logo.png">
</p>

<h1 align="center">Shell Script Documentation</h1>

<p align="center">Write documentation in comments and render it with templates.</p>

<p align="center">
  <a href="https://github.com/pawamoy/shellman/actions?query=workflow%3Aci">
    <img alt="ci" src="https://github.com/pawamoy/shellman/workflows/ci/badge.svg" />
  </a>
  <a href="https://pawamoy.github.io/shellman/">
    <img alt="documentation" src="https://img.shields.io/badge/docs-mkdocs%20material-blue.svg?style=flat" />
  </a>
  <a href="https://pypi.org/project/shellman/">
    <img alt="pypi" src="https://img.shields.io/pypi/v/shellman.svg" />
  </a>
  <a href="https://gitpod.io/#https://github.com/pawamoy/shellman">
    <img alt="gitpod" src="https://img.shields.io/badge/gitpod-workspace-blue.svg?style=flat" />
  </a>
  <a href="https://gitter.im/shellman/community">
    <img alt="gitter" src="https://badges.gitter.im/join%20chat.svg" />
  </a>
</p>

`shellman` can generate man pages, wiki pages and help text
using documentation written in shell scripts comments.

For example:

```bash
#!/bin/bash

## \brief Just a demo
## \desc This script actually does nothing.

main() {
  case "$1" in
    ## \option -h, --help
    ## Print this help and exit.
    -h|--help) shellman "$0"; exit 0 ;;
  esac
}

## \usage demo [-h]
main "$@"
```

Output when calling ``./demo -h``:

```
Usage: demo [-h]

This script actually does nothing.

Options:
  -h, --help            Print this help and exit.
```

You can see more examples in the documentation: https://pawamoy.github.io/shellman/.

<h2 align="center">Demo</h2>
<p align="center"><img src="https://rawgit.com/pawamoy/shellman/master/demo.svg"></p>

In the demo above we saw the three builtin templates:
helptext, manpage and wikipage.

You can use your own templates
by specifying them with the ``--template path:my/template`` syntax.

You can also write a plugin, see the docs: https://pawamoy.github.io/shellman/plugins.

## Installation

```bash
pip install shellman
```

With [`uv`](https://docs.astral.sh/uv/):

```bash
uv tool install shellman
```

## Some projects using shellman

- [shellm](https://github.com/shellm-org) —
  A collection of scripts and libraries
  built on a [core inclusion-system](https://github.com/shellm-org/core),
  all installable with [basher](https://github.com/basherpm/basher).
  Here are a few examples:
  - [daemon](https://github.com/shellm-org/daemon) —
    A library that facilitates the writing of daemonized scripts that consume
    files in a watched directory.
  - [debug](https://github.com/shellm-org/debug) —
    A simple script that sets the verbose/dry-run/debug
    Bash flags before running another script.
  - [format](https://github.com/shellm-org/format) —
    Format your output with style and color.
  - [home](https://github.com/shellm-org/home) —
    A home for your shell scripts! 
  - [loop](https://github.com/shellm-org/loop) —
    Control the flow of your loops (pause/resume/etc.).
ftpsocket 0.0.1
Internal packages included, don't change any string at here

#ftpsocket: FTP using socket.
<img src="https://static.pepy.tech/badge/ftpsocket" height="30" /> <img src="https://static.pepy.tech/badge/ftpsocket/month" height="30" />

#ftpsocket: SOCKET-FTP

#ftpsocket:
__is a Python library designed to implement FTP server and client functionality using sockets for transferring files over the network. It allows you to send and receive files securely between devices connected to the same network.__
--- 
##Installation:
To install the ftpsocket library:
```bash
pip install ftpsocket
```
---

Usage Examples

#1. Starting the FTP Server:

In this example, we'll create and run an FTP server.

from ftpsocket.server import FTPServer

# Create and start the FTP server on the desired address and port
```python
ftp_server = FTPServer(host='0.0.0.0', port=21)
ftp_server.start()
```
#2. FTP Client Example:

The client connects to the server and sends a file.
```python
from ftpsocket.client import FTPClient
```
# Connect to an FTP server on a specific address and port
```python
ftp_client = FTPClient(host='127.0.0.1', port=21)# the local hosted.
ftp_client.connect()
```
# Send a file to the server
```python
ftp_client.send_file('example.txt')
```
# Close the connection after the file is sent
```python
ftp_client.close()
```

---

##Explanation:

FTPServer: This class allows you to start an FTP server that listens for incoming client connections, handling file uploads and downloads, at the local network.
FTPClient: The client connects to the server, sends files, and manages the connection.


##Features:

**FTP-like server-client file transfer over the network.**
##Note:**To secure connection using Python sockets, use ftpsocket.**
dbis-btree 1.0.8
RWTH Aachen Computer Science i5/dbis assets for Lecture Datenbanken und Informationssysteme
Requires Python: >=3.10

![DBIS Informatik 5 - Informationssysteme und Datenbank](https://dbis.rwth-aachen.de/dbis/wp-content/uploads/2022/04/dbis-logo.png)



# Dokumentation zur Nutzung des B-Baum
In der Vorlesung haben Sie B-Bäume kennengelernt.
Dieses Blatt gibt einen kurzen Überblick über ein von uns entwickeltes Python-Tool.\
Im DBIS Image des Jupyter Hub der RWTH ist dieses Package bereits integriert, falls Sie das Tool lokal benutzen möchten, können Sie diese über den folgenden Befehl installieren:
```python_pip install dbis-btree
pip install dbis-btree
# in jupyter notebooks:
!pip install dbis-btree
```
Die folgende Zelle importiert das Python Modul und ermöglicht dessen Nutzung innerhalb des Notebooks:
```python
from dbis_btree.BBaum import BTree
```

## B-Baum als Objekt

Als erstes müssen Sie eine neue Instanz der Klasse `BTree` erzeugen. Diesem Objekt werden im weiteren Verlauf Knoten `nodes` und Kanten `edges` hinzugefügt.
Geben Sie die `M`-Value für den B-Baum an.

```python
# zum Beispiel M = 4
M = 4
bbaum = BTree(4)
# anzeigen des noch leeren bbaums:
bbaum.draw()
```

## Knoten
Neue Knoten zum Baum hinzufügen: `add_node(name, elements)`

Geben sie dem Knoten einen _eindeutigen_ Namen und die Zahlen, die im Knoten sich befinden sollen.\
Wenn im Graph schon der Knoten mit diesem Namen existiert, kommt der Fehler:
```commandline
AssertionError: Bitte nutze einen anderen Name für diese Node.
```

Konstruktor einer Relation:
* `name`: String - Eindeutiger Name des Knoten
* `elements`: Int Liste - Liste aus Int

```python
bbaum = BTree(4)
# hinzufügen Knoten A
name = "A"
elements = [10,20]

bbaum.add_node(name, elements)

# hinzufügen Knoten B
bbaum.add_node("B", [1,2])

# nicht vergessen, den baum anzuzeigen:
bbaum.draw()
```
![B-Tree generated above](./examples/images/image_1.svg)


## Kanten
Neue Knoten zum Baum hinzufügen: `add_edge(parent, child, n_child):`

Dies fügt im Baum eine Kante vom `parent`-Knoten zum `child`-Knoten, an der der `n_child`-ten Stelle im `parent`-Knoten.

Konstruktor einer Relation:
* `name`: String - Eindeutiger Name des Parent Knoten
* `child`: String - Eindeutiger Name des Child Knoten
* `n_child`: Int - Position im Parent Knoten.


```python
bbaum = BTree(4)
# hinzufügen Knoten A
name = "A"
elements = [10,20]

bbaum.add_node(name, elements)

# hinzufügen Knoten B
bbaum.add_node("B", [1,2])

# hinzufügen einer Kante an 1st Stelle
positionImParentNode = 1
bbaum.add_edge("A", "B", positionImParentNode)

# nicht vergessen, den baum anzuzeigen:
bbaum.draw()
```
![B-Tree generated above](./examples/images/image_2.svg)

### Häufige Fehler und Warnungen

`Warning: node A, port f5 unrecognized`\
\
bedeutet, dass eine falsche Zahl beim Parameter `n_child` genutzt wurde.\
`add_edge(parent, child, n_child):`\
In unserem Fall wurde dieser Fehler wurde ausgelöst, als eine Kante an Stelle 5 in Knoten A hinzugefügt wurde. Jedoch besaß A nur insgesamt Stellen 1 bis 4 um Kanten hinzuzufügen.