nexy 0.0a1__tar.gz

nexy-0.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Espoir Loém
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nexy-0.0a1/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.1
+Name: nexy
+Version: 0.0a1
+Summary: 
+Author: Espoir-Loem
+Author-email: hopcy.forcy@gmail.com
+Requires-Python: >=3.13,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: fastapi (>=0.115.6,<0.116.0)
+Description-Content-Type: text/markdown
+
+
+# 🌟 **Nexy**
+
+Bienvenue dans l'univers de **Nexy**, un framework de développement back-end **innovant et performant**, conçu pour **optimiser votre productivité**.  
+🚀 **Simplicité**, 🌍 **dynamisme**, et **efficacité maximale** : Nexy vous permet de **concevoir, tester et déployer vos applications** avec rapidité et fluidité, tout en réduisant la complexité du processus de développement.
+
+---
+
+### **🧩 Pourquoi Choisir Nexy ?**  
+
+👉 **Configuration simplifiée** : La structure de vos dossiers se transforme automatiquement en un routeur, sans nécessiter de décorateurs ou d'importations complexes.  
+
+👉 **Gagnez du temps** : Ajoutez simplement un fichier ou un dossier dans `app/`, et Nexy génère les routes pour vous, automatiquement.  
+
+👉 **Simplicité et puissance** : Libérez-vous des contraintes inutiles pour vous concentrer sur l’essentiel — votre logique métier.  
+
+👉 **Un projet open-source, une communauté engagée** : Nexy est un projet open-source, conçu avec passion ❤️. Rejoignez notre communauté pour contribuer et façonner l'avenir du développement web.
+
+---
+
+### **📂 Structure de Projet avec Nexy**  
+
+Voici comment structurer votre projet en utilisant Nexy :  
+
+```plaintext
+nexy/
+ ├── app/                # Dossier contenant les contrôleurs et routes
+ │   ├── controller.py   # Route par défaut /
+ │   ├── documents/      # Dossier pour /documents
+ │   │   ├── controller.py  # Route /documents
+ │   │   └── [documentId]/  # Dossier dynamique pour /documents/{documentId}
+ │   │       └── controller.py  # Route /documents/{documentId}
+ │   └── users/          # Dossier pour /users
+ │       └── controller.py  # Route /users
+ └── main.py             # Fichier de configuration de Nexy
+```
+
+📝 **Chaque fichier `controller.py`** définit les routes de la section correspondante.  
+🎯 **La structure des dossiers correspond aux routes de l'API**, générées automatiquement.
+
+---
+
+### **🌐 Exemple de Code avec Nexy**  
+
+#### **Route par défaut `/`**  
+
+**Fichier** : `app/controller.py`  
+
+```python
+async def GET():
+    return {"message": "Bienvenue sur l'API Nexy"}
+
+async def POST(data: dict):
+    return {"message": "Données reçues avec succès", "data": data}
+```
+
+---
+
+#### **Route dynamique pour `/documents/{documentId}` avec WebSocket**  
+
+**Fichier** : `app/documents/[documentId]/controller.py`  
+
+```python
+async def GET(documentId: int):
+    return {"documentId": documentId, "message": "Voici votre document"}
+
+async def PUT(documentId: int, document: dict):
+    return {"message": "Document mis à jour", "documentId": documentId, "document": document}
+
+async def DELETE(documentId: int):
+    return {"message": f"Document {documentId} supprimé"}
+
+async def Socket(websocket):
+    await websocket.accept()
+    await websocket.send_text("Connexion WebSocket établie.")
+    await websocket.close()
+```
+
+---
+
+#### **Route pour `/users`**  
+
+**Fichier** : `app/users/controller.py`  
+
+```python
+async def GET():
+    return {"message": "Liste des utilisateurs"}
+
+async def POST(user: dict):
+    return {"message": "Nouvel utilisateur ajouté", "user": user}
+```
+
+---
+
+### **✨ Pourquoi Contribuer à Nexy ?**  
+
+🚀 **Rejoignez une aventure passionnante** : Nexy est en constante évolution, et nous avons besoin de votre expertise pour continuer à repousser les limites de l'innovation.  
+🤝 **Collaborez avec une communauté dynamique** : Venez partager vos idées et apprendre aux côtés de développeurs de talent.  
+🌟 **Participez à un projet qui transforme l’industrie** : Votre contribution pourrait simplifier la vie de milliers de développeurs à travers le monde.  
+
+---
+
+### **💬 Un Message pour Vous, Contributeurs et Passionnés**  
+
+**Nexy est conçu pour vous** 💛. Que vous soyez débutant ou expert, ce framework est pensé pour rendre le développement **plus intuitif, rapide et agréable**.  
+
+👉 **Testez-le dès aujourd’hui** : Téléchargez Nexy et découvrez sa simplicité.  
+👉 **Envie de contribuer ?** Rejoignez-nous sur [GitHub](#) et aidez-nous à bâtir le framework full-stack de demain.  
+
+**💡 Nexy : Simplifions ensemble le développement web avec Python.** 🌍✨
+
+

nexy-0.0a1/README.md

@@ -0,0 +1,111 @@
+
+# 🌟 **Nexy**
+
+Bienvenue dans l'univers de **Nexy**, un framework de développement back-end **innovant et performant**, conçu pour **optimiser votre productivité**.  
+🚀 **Simplicité**, 🌍 **dynamisme**, et **efficacité maximale** : Nexy vous permet de **concevoir, tester et déployer vos applications** avec rapidité et fluidité, tout en réduisant la complexité du processus de développement.
+
+---
+
+### **🧩 Pourquoi Choisir Nexy ?**  
+
+👉 **Configuration simplifiée** : La structure de vos dossiers se transforme automatiquement en un routeur, sans nécessiter de décorateurs ou d'importations complexes.  
+
+👉 **Gagnez du temps** : Ajoutez simplement un fichier ou un dossier dans `app/`, et Nexy génère les routes pour vous, automatiquement.  
+
+👉 **Simplicité et puissance** : Libérez-vous des contraintes inutiles pour vous concentrer sur l’essentiel — votre logique métier.  
+
+👉 **Un projet open-source, une communauté engagée** : Nexy est un projet open-source, conçu avec passion ❤️. Rejoignez notre communauté pour contribuer et façonner l'avenir du développement web.
+
+---
+
+### **📂 Structure de Projet avec Nexy**  
+
+Voici comment structurer votre projet en utilisant Nexy :  
+
+```plaintext
+nexy/
+ ├── app/                # Dossier contenant les contrôleurs et routes
+ │   ├── controller.py   # Route par défaut /
+ │   ├── documents/      # Dossier pour /documents
+ │   │   ├── controller.py  # Route /documents
+ │   │   └── [documentId]/  # Dossier dynamique pour /documents/{documentId}
+ │   │       └── controller.py  # Route /documents/{documentId}
+ │   └── users/          # Dossier pour /users
+ │       └── controller.py  # Route /users
+ └── main.py             # Fichier de configuration de Nexy
+```
+
+📝 **Chaque fichier `controller.py`** définit les routes de la section correspondante.  
+🎯 **La structure des dossiers correspond aux routes de l'API**, générées automatiquement.
+
+---
+
+### **🌐 Exemple de Code avec Nexy**  
+
+#### **Route par défaut `/`**  
+
+**Fichier** : `app/controller.py`  
+
+```python
+async def GET():
+    return {"message": "Bienvenue sur l'API Nexy"}
+
+async def POST(data: dict):
+    return {"message": "Données reçues avec succès", "data": data}
+```
+
+---
+
+#### **Route dynamique pour `/documents/{documentId}` avec WebSocket**  
+
+**Fichier** : `app/documents/[documentId]/controller.py`  
+
+```python
+async def GET(documentId: int):
+    return {"documentId": documentId, "message": "Voici votre document"}
+
+async def PUT(documentId: int, document: dict):
+    return {"message": "Document mis à jour", "documentId": documentId, "document": document}
+
+async def DELETE(documentId: int):
+    return {"message": f"Document {documentId} supprimé"}
+
+async def Socket(websocket):
+    await websocket.accept()
+    await websocket.send_text("Connexion WebSocket établie.")
+    await websocket.close()
+```
+
+---
+
+#### **Route pour `/users`**  
+
+**Fichier** : `app/users/controller.py`  
+
+```python
+async def GET():
+    return {"message": "Liste des utilisateurs"}
+
+async def POST(user: dict):
+    return {"message": "Nouvel utilisateur ajouté", "user": user}
+```
+
+---
+
+### **✨ Pourquoi Contribuer à Nexy ?**  
+
+🚀 **Rejoignez une aventure passionnante** : Nexy est en constante évolution, et nous avons besoin de votre expertise pour continuer à repousser les limites de l'innovation.  
+🤝 **Collaborez avec une communauté dynamique** : Venez partager vos idées et apprendre aux côtés de développeurs de talent.  
+🌟 **Participez à un projet qui transforme l’industrie** : Votre contribution pourrait simplifier la vie de milliers de développeurs à travers le monde.  
+
+---
+
+### **💬 Un Message pour Vous, Contributeurs et Passionnés**  
+
+**Nexy est conçu pour vous** 💛. Que vous soyez débutant ou expert, ce framework est pensé pour rendre le développement **plus intuitif, rapide et agréable**.  
+
+👉 **Testez-le dès aujourd’hui** : Téléchargez Nexy et découvrez sa simplicité.  
+👉 **Envie de contribuer ?** Rejoignez-nous sur [GitHub](#) et aidez-nous à bâtir le framework full-stack de demain.  
+
+**💡 Nexy : Simplifions ensemble le développement web avec Python.** 🌍✨
+

nexy-0.0a1/nexy/__init__.py

@@ -0,0 +1,5 @@
+from .app import *
+from .components import *
+from .hooks import *
+from fastapi import *
+

nexy-0.0a1/nexy/app.py

@@ -0,0 +1,15 @@
+from fastapi import FastAPI
+from .router import Router
+import sys
+from pathlib import Path
+
+
+def Nexy(title: str = "Nexy",**args):
+    # Configurer le cache
+    app:FastAPI = FastAPI(title,**args)
+    cache_dir = Path('./__nexy__')
+    cache_dir.mkdir(exist_ok=True)
+    sys.pycache_prefix = str(cache_dir)
+    Router(appModule=app)
+    return app
+

nexy-0.0a1/nexy/components.py

@@ -0,0 +1,72 @@
+class Component:
+    def __init__(self, children=None, tagName: str = "", tagNameList = [],  **attributes):
+        self.type = tagName
+        self.children = children or []
+        self.attributes = attributes
+        self.tagNameList= tagNameList 
+
+    def __str__(self):
+        # Convertir chaque enfant en sa représentation HTML
+        children_html = ''.join(str(child) for child in self.children)
+        # Générer les attributs de la balise
+        attrs = ' '.join(f'{k.replace("_", "-")}="{v}"' for k, v in self.attributes.items())
+        # Retourner la balise complète
+        
+        return f'<{self.type} {attrs}>{children_html}</{self.type}>'
+    
+
+class Text(Component):
+    def __init__(self, content=None, type="span", **attributes):
+        super().__init__(tagName=type, children=content,**attributes)
+
+class Button(Component):
+    def __init__(self, children=None,  type="button", **attributes):
+        super().__init__(tagName="button", children=children, type=type ,**attributes)
+
+
+class Link(Component):
+    pass
+class Container(Component):
+    pass
+
+class Image(Component):
+    pass
+
+class Audio(Component):
+    pass
+
+class Video(Component):
+    pass
+
+class Column(Component):
+    pass
+
+class Row(Component):
+    pass
+
+class Flex(Component):
+    pass
+
+class Grid(Component):
+    pass
+
+class Table(Component):
+    pass
+
+class Head(Component):
+    pass
+
+class Media(Component):
+    pass
+
+class Dialog(Component):
+    pass
+
+class Form(Component):
+    pass
+
+class Section(Component):
+    pass
+
+class Header(Component):
+    pass

nexy-0.0a1/nexy/hooks.py

@@ -0,0 +1,5 @@
+
+from fastapi.responses import  HTMLResponse
+def useView(content):
+    return HTMLResponse(content=f"{content}")
+

nexy-0.0a1/nexy/router.py

@@ -0,0 +1,63 @@
+import os
+from fastapi import FastAPI
+from .utils import deleteFistDotte, dynamicRoute,importModule,convertPathToModulePath
+
+# 
+def FIND_ROUTES(base_path):
+    routes:list = []
+    
+    # Verify if the 'app' folder exists
+    if os.path.exists(base_path) and os.path.isdir(base_path):
+        # Explore the 'app' folder and its subfolders
+        for root, dirs, files in os.walk(base_path):
+            #supprimers des _folder
+            dirs[:] = [d for d in dirs if not d.startswith("_")]
+
+            route = {
+                "pathname": f"{'/' if os.path.basename(root) == base_path else '/' +  deleteFistDotte(os.path.relpath(root, base_path).replace("\\","/"))}",
+                "dirName": root
+            }
+            controller = os.path.join(root, 'controller.py')
+
+            # Check for files and add to dictionary
+            if os.path.exists(controller):
+                route["module"] = convertPathToModulePath(f"{root}/controller")    
+
+            routes.append(route)
+
+    return routes
+
+
+
+
+def Router(appModule: FastAPI, appFolder:str = "app"):
+    """
+    Charge dynamiquement les routes à partir du répertoire 'app'.
+    """
+    # Parcours des répertoires dans 'app'
+    routes = FIND_ROUTES(base_path=appFolder);
+    HTTP_METHODES:tuple = ("GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS");
+    for route in routes:
+
+        pathname = dynamicRoute(route_in=route["pathname"]);
+
+        if "module" in route:
+
+            module = importModule(path=route["module"]);
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                
+                # Vérifie que l'attribut est une fonction utilisable par FastAPI
+                if callable(attr) and hasattr(attr, "__annotations__"):
+                    # Ajout de la route pour chaque méthode HTTP
+                    if attr_name in HTTP_METHODES:
+                        
+                        method = attr_name
+                        appModule.add_api_route(pathname, attr, methods=[method])
+
+                    # Ajout d'une route WebSocket si la méthode 'Socket' existe
+                    if attr_name == "Socket":
+                        appModule.add_api_websocket(f"{pathname}/ws", attr)
+
+
+

nexy-0.0a1/nexy/utils.py

@@ -0,0 +1,27 @@
+import re
+import importlib
+# 
+def deleteFistDotte(string:str)-> str:
+    if string.startswith('.'):
+        return re.sub(r'^.', '', string)
+    else:
+        return string
+    
+def dynamicRoute(route_in:str)-> str:
+
+    # Remplacer [id] par {id}
+    route_out = re.sub(r"\[([^\]]+)\]", r"{\1}",route_in)
+    # Remplacer {_slug} par {slug:path} pour capturer plusieurs segments
+    route_out = re.sub(r"\{_([^\}]+)\}", r"{\1}:path", route_out)
+
+    return route_out
+
+def convertPathToModulePath(path:str)->str:
+    return re.sub(r"\\|/", ".", path)
+
+def importModule(path:str):
+    try:
+        module =importlib.import_module(path) 
+    except ModuleNotFoundError as e:
+        print(f"Error importing module '{path}': {e}")
+    return module

nexy-0.0a1/pyproject.toml

@@ -0,0 +1,15 @@
+[tool.poetry]
+name = "nexy"
+version = "0.0.alpha-0000000001"
+description = ""
+authors = ["Espoir-Loem <hopcy.forcy@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.13"
+fastapi = "^0.115.6"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"