Metadata-Version: 2.4
Name: jdat
Version: 1.1.1
Summary: Format de données structurées avec chiffrement AES-256 par bloc
Author: JDAT Project
License: MIT
Project-URL: Homepage, https://jdat-website.onrender.com
Project-URL: Repository, https://github.com/ton-compte/jdat
Project-URL: Documentation, https://jdat-website.onrender.com/docs
Keywords: jdat,data,format,encryption,aes256,configuration
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Software Development :: Libraries
Classifier: Topic :: Security :: Cryptography
Requires-Python: >=3.10
Description-Content-Type: text/markdown
Provides-Extra: crypto
Requires-Dist: cryptography>=42.0; extra == "crypto"
Provides-Extra: full
Requires-Dist: cryptography>=42.0; extra == "full"

# JDAT

Format de données structurées, lisible, modifiable et chiffrable par bloc avec AES-256.

```bash
pip install jdat
pip install jdat[crypto]   # avec chiffrement AES-256
```

---

## Démarrage rapide

### getval — équivalent de `os.getenv`

```python
import jdat

# Lit une valeur depuis un fichier .jdat (1 ligne)
email = jdat.getval("config.jdat", "utilisateur", "adresse mail")
port  = jdat.getval("config.jdat", "serveur", "port", default="5000")

# Avec bloc chiffré
mdp = jdat.getval("secrets.jdat", "db", "password", password="monmdp")
```

### JDATEnv — environnement global (comme `os.environ`)

```python
from jdat import JDATEnv

env = JDATEnv("config.jdat")

# Accès style dict
env["serveur"]["port"]               # "5000"
env.get("serveur", "port")           # "5000" ou None
env.get("serveur", "port", "80")     # "5000" ou "80"
env.require("db", "password")        # valeur ou KeyError si absente

# Typage automatique
env.getint("serveur", "port")        # 5000   (int)
env.getbool("app", "debug")          # True   (bool)
env.getlist("app", "allowed_hosts")  # ["localhost", "127.0.0.1"]

# Bloc entier
config = env.section("serveur")     # {"host": "0.0.0.0", "port": "5000"}
```

### Depuis les variables d'environnement

```bash
export JDAT_FILE=/home/<name>/<fichier>.jdat
export JDAT_PASSWORD=monmotdepasse
```

```python
env = JDATEnv.from_env()
db_url = env.require("db", "url")
```

---

## Format JDAT

```
({<commentaire>})

(n:utilisateur l:user1 t:1 {
  nom: alice
  adresse mail: alice@exemple.com
  rôle: admin
})

(n:script l:deploy t:2{
#!/bin/bash
git pull && systemctl restart app
})
```

**En-tête du bloc :**
- `n:` nom lisible
- `l:` lien unique (utilisé comme clé d'accès)
- `t:1` données structurées clé/valeur
- `t:2` texte ou code brut verbatim

---

## JDATFile — API complète

```python
from jdat import JDATFile

# Chargement
jf = JDATFile("data.jdat")
jf = JDATFile()                      # vide
jf = JDATFile.from_string(texte)
jf = JDATFile.from_env()             # lit JDAT_FILE

# Accès style dict
bloc  = jf["lien"]
valeur = jf["lien"]["clé"]
"lien" in jf                         # True/False

# Lecture
bloc.get("clé")                      # valeur ou None
bloc.get("clé", "défaut")
bloc.to_dict()                       # → dict complet
bloc.keys() / bloc.values() / bloc.items()

# Recherche
jf.get("lien")                       # bloc ou None
jf.find("partiel")                   # liste de blocs
jf.where(rôle="admin")              # filtre par clé/valeur

# Modification
bloc["clé"] = "nouvelle valeur"
bloc.update({"clé": "val", "clé2": "val2"})
jf.add("nom", "lien", data={"clé": "val"})
jf.add("script", "deploy", btype=2, content="#!/bin/bash\n...")
del jf["lien"]                       # supprime un bloc

# Chiffrement (pip install jdat[crypto])
jf.encrypt("lien", "motdepasse")
jf.decrypt("lien", "motdepasse")
jf.encrypt_all("motdepasse")
jf.decrypt_all("motdepasse")

# Export
jf.to_dict()                         # dict Python
jf.to_json()                         # JSON string

# Sauvegarde (chaînable)
jf.save()
jf.save("autre.jdat")
jf.add("x", "x1", data={...}).save()
```

---

## Chiffrement AES-256-GCM

```python
from jdat import JDATEnv

# Déchiffrement automatique au chargement
env = JDATEnv("secrets.jdat", password="monmotdepasse")
secret = env["db"]["password"]       # déjà déchiffré

# Injection dans os.environ
env.inject("secrets", prefix="APP_")
import os
print(os.environ["APP_DB_PASSWORD"])
```

---

## Intégration Flask

```python
from flask import Flask
from jdat import JDATEnv

app = Flask(__name__)
env = JDATEnv("config.jdat")

app.config["SECRET_KEY"] = env.require("flask", "secret_key")
app.config["DEBUG"]      = env.getbool("flask", "debug")
app.config["PORT"]       = env.getint("serveur", "port", 5000)
```

---

## Licence

MIT
