ceoseshell/zenv repository overview

# Clonez le repository
git clone https://github.com/gopu-inc/zenv.git
cd zenv

# Installation
pip install -e .

# Vérifiez l'installation
zenv version

pip install zenv-lang

// Commentaire simple
print "Hello Zenv!"

// Variables
var nom = "Alice"
let age = 30
const PI = 3.14159

// Fonctions
function saluer(personne):
    return "Bonjour " + personne + "!"

// Conditions
if age > 18 then:
    print "Majeur"
else:
    print "Mineur"

// Boucles
for i in range(5) do:
    print "Itération: " + i

while x > 0 do:
    print x
    x = x - 1

// Classes
class Personne:
    function __init__(self, nom, age):
        self.nom = nom
        self.age = age
    
    function presentation(self):
        return self.nom + " a " + self.age + " ans"

// String interpolation
let message = "Nom: #{nom}, Age: #{age}"

// Listes
let fruits = list("pomme", "banane", "orange")
fruits.append("kiwi")

// Dictionnaires
let personne = dict()
personne["nom"] = "Bob"
personne["age"] = 25

// Sets
let nombres = set(1, 2, 3, 3, 4)  // {1, 2, 3, 4}

// Tuples
let coord = tuple(45.5, -73.5)

// Lambdas
let doubler = lambda x => x * 2
let addition = lambda a, b => a + b

// Map/Filter
let nombres = [1, 2, 3, 4, 5]
let carres = map(lambda x => x * x, nombres)
let pairs = filter(lambda x => x % 2 == 0, nombres)

// List comprehensions
let carres = [for x in nombres if x > 2 => x * x]

# Exécuter un fichier .zv
zenv run programme.zv

# Avec des arguments
zenv run programme.zv arg1 arg2

# Transpiler vers Python
zenv transpile programme.zv -o programme.py

# Valider la syntaxe
zenv validate programme.zv

mkdir mon-package
cd mon-package

[Zenv]
name = mon-package
version = 1.0.0
author = Votre Nom
description = Description du package
license = MIT

[File-build]
main = main.zv
files = *.zv
        README.md
        LICENSE

[docs]
description = README.md

[dep.zv]
# Dépendances Zenv
zenv-stdlib = 1.0.0

[dep.py]
# Dépendances Python
requests = latest

print "Mon package Zenv!"

function hello(name):
    return "Hello " + name + "!"

if __name__ == "__main__":
    print hello("World")

zenv build -f package.zcf
# Génère: dist/mon-package-1.0.0.zv

# Se connecter au Zenv Hub
zenv hub login zenv_votre_token

# Publier un package
zenv hub publish dist/mon-package-1.0.0.zv

# Rechercher des packages
zenv hub search "web framework"

# Installer un package
zenv pkg install requests

# Lister les packages installés
zenv pkg list

# Supprimer un package
zenv pkg remove package-name

# Vérifier le statut
zenv hub status

# Rechercher des packages
zenv hub search "database"

# Publier
zenv hub publish mon-package.zv

# Télécharger (via pkg install)
zenv pkg install nom-package

zenv/
├── zenv/                    # Code source
│   ├── __init__.py
│   ├── cli.py              # Interface en ligne de commande
│   ├── transpiler.py       # Transpileur Zenv → Python
│   ├── runtime.py          # Runtime d'exécution
│   ├── builder.py          # Système de build de packages
│   ├── hub/                # Client pour Zenv Hub
│   └── utils/              # Utilitaires
├── examples/               # Exemples de code
├── tests/                  # Tests unitaires
├── setup.py               # Configuration d'installation
└── README.md              # Ce fichier

Zenv Code (.zv) → Transpileur → Python Code (.py) → Interpréteur Python
     │                              │
     ├── Syntaxe moderne           ├── Compatible Python 3.7+
     ├── String interpolation      ├── Performance native
     └── Mot-clés en français      └── Accès à tout l'écosystème Python

// webapp.zv
from flask import Flask, jsonify
import json

app = Flask(__name__)

class Utilisateur:
    function __init__(self, nom, email):
        self.nom = nom
        self.email = email
    
    function to_dict(self):
        return {
            "nom": self.nom,
            "email": self.email
        }

@app.route("/")
function accueil():
    return "Bienvenue sur mon app Zenv!"

@app.route("/api/utilisateurs")
function get_utilisateurs():
    utilisateurs = [
        Utilisateur("Alice", "[email protected]"),
        Utilisateur("Bob", "[email protected]")
    ]
    return jsonify([u.to_dict() for u in utilisateurs])

if __name__ == "__main__":
    app.run(debug=true)

// data_processing.zv
function charger_donnees(fichier):
    with open(fichier, 'r') as f:
        return json.load(f)

function traiter(donnees):
    // Filtre
    let filtrees = filter(lambda x: x["actif"], donnees)
    
    // Transformation
    let transformees = map(lambda x: {
        "nom": x["nom"].upper(),
        "valeur": x["score"] * 2
    }, filtrees)
    
    // Agrégation
    let total = reduce(lambda acc, x: acc + x["valeur"], transformees, 0)
    
    return {
        "nombre": len(transformees),
        "total": total,
        "moyenne": total / len(transformees) if transformees else 0
    }

function main():
    let donnees = charger_donnees("data.json")
    let resultats = traiter(donnees)
    print "Résultats: " + str(resultats)

if __name__ == "__main__":
    main()

// async_demo.zv
import asyncio
import aiohttp

async function fetch_url(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async function main():
    let urls = [
        "https://api.example.com/data1",
        "https://api.example.com/data2",
        "https://api.example.com/data3"
    ]
    
    // Exécution parallèle
    let tasks = [fetch_url(url) for url in urls]
    let results = await asyncio.gather(*tasks)
    
    for i, result in enumerate(results):
        print f"Résultat {i}: {len(result)} caractères"

if __name__ == "__main__":
    asyncio.run(main())

// ~/.zenv/config.json
{
    "user": {
        "name": "Votre Nom",
        "email": "[email protected]"
    },
    "hub": {
        "url": "https://zenv-hub.onrender.com",
        "auto_update": true
    },
    "transpiler": {
        "strict_mode": false,
        "auto_format": true
    }
}

export ZENV_HUB_TOKEN="zenv_votre_token"
export ZENV_DEBUG="true"
export ZENV_CACHE_DIR="$HOME/.zenv/cache"

# 1. Transpiler vers Python
zenv transpile app.zv -o app.py

# 2. Créer requirements.txt
echo "flask==2.3.0" > requirements.txt

# 3. Déployer comme une app Python normale

# 1. Build le package
zenv build -f package.zcf

# 2. Publier sur le hub
zenv hub publish dist/*.zv

# 3. Les autres peuvent installer
zenv pkg install votre-package

# Exécuter tous les tests
python -m pytest tests/

# Tests spécifiques
python -m pytest tests/test_transpiler.py

# Avec couverture
python -m pytest --cov=zenv tests/

# tests/test_basics.py
import pytest
from zenv.transpiler import ZenvTranspiler

def test_print_statement():
    transpiler = ZenvTranspiler()
    zv_code = 'print "Hello"'
    python_code = transpiler.transpile(zv_code)
    assert python_code == 'print("Hello")'