ourocode 1.6.0__py3-none-any.whl

ourocode/eurocode/EC8_Sismique.py

@@ -0,0 +1,2 @@
+#! env\Scripts\python.exe
+# Encoding in UTF-8 by Anthony PARISOT

ourocode/eurocode/logical.py

@@ -0,0 +1,83 @@
+from ourocode.eurocode.objet import Objet
+    
+class And(Objet):
+    def __init__(self):
+        super().__init__()
+        pass
+
+
+class For(Objet):
+    def __init__(self, liste: list, index: int=None, key: str=None, start: int=None, stop: int=None, **kwargs):
+        """Boucle sur les valeurs d'une liste, en option on peux donner un index pour retourner une valeur spécifique d'une sous liste et une clé pour un dictionnaire.
+        On peut aussi donner un start et un stop pour boucler que sur une partie de la liste.
+
+        Args:
+            liste (list): la liste sur laquelle on doit itérer.
+            index (int|otional): l'index optionnel.
+            key (str, optional): on utilise la clé spécifique si la liste transmise est un dictionnaire.
+
+        Returns:
+            Retourne l'item présent dans la liste.
+        """
+        super().__init__()
+        self.liste = liste
+        self.index = index
+        self.key = key
+        self.start = start
+        self.stop = stop
+        self.counter = -1
+        self.selected_item = None
+
+        for key, val in kwargs.items():
+            setattr(self, key, val)
+                        
+        self._get_items()
+        
+    def _get_items(self):
+        """Détermine le début d'une boucle
+        """
+        self.items = []
+        if isinstance(self.liste, list):
+            strt = 0
+            stp = len(self.liste)+1
+            if self.start:
+                strt = self.start
+            if self.stop:
+                stp = self.stop
+            self.liste = self.liste[strt:stp]
+            for item in self.liste:
+                if self.index:
+                    self.items.append(item[self.index])
+                else:
+                    self.items.append(item)
+        elif isinstance(self.liste, dict):
+            for item in self.liste.values():
+                if self.key:
+                    self.items.append(item[self.key])
+                else:
+                    self.items.append(item)
+        return self.items
+
+    def _get_item(self, selection="Tous"):
+        """Retourne un élément spécifique ou la sélection."""
+        if selection == "Tous":
+            self.counter += 1
+            if self.counter >= len(self.items):
+                self.counter = 0
+            self.selected_item = self.items[self.counter]
+        else:
+            for item in self.items:
+                if item == selection:
+                    self.selected_item = item
+        return self.selected_item
+    
+    def get_min_value_in_loop():
+        """Retourne la valeur de sortie de la boucle pour laquelle le résultat (valeur numérique uniquement) est le plus faible.
+        Le résultat peut ce trouver dans un dictionnaire, une liste, un tuple. Si c'est le cas alors on parcours toute les valeurs numérique et l'on récupère la plus faible.
+        Cette méthode permet pour exemple de trouver le taux de travail le plus faible dans une 
+
+        Args:
+            result (float): le résultat à comparer avec la précédente valeur minimal
+
+        """
+                

ourocode/eurocode/objet.py

@@ -0,0 +1,263 @@
+# coding in UTF-8 
+# by Anthony PARISOT
+
+import os
+import json
+import math as mt
+import importlib.resources as pkg_resources
+from PIL import Image
+import pandas as pd
+import pickle
+import inspect
+from PySide6.QtWidgets import QFileDialog
+# from tkinter import filedialog
+
+import forallpeople as si
+si.environment("structural")
+
+
+def get_package_path(package):
+    # Obtenir le chemin du fichier principal du module
+    package_path = os.path.dirname(package.__file__)
+    return package_path
+
+
+class Objet(object):
+    """Classe permetant la sauvegarde ou l'ouverture d'un objet ou de plusieur sous un fichier .ec
+    """
+    OPERATOR = ("+", "-", "x", "/")
+    try:
+        import ourocode
+        PATH_CATALOG = os.path.join(get_package_path(ourocode))
+    except:
+        PATH_CATALOG = os.path.join(os.getcwd(), "ourocode")
+
+    def _data_from_csv(self, data_file: str, index_col=0):
+        """ Retourne un dataframe d'un fichier CSV """
+        repertory = os.path.join(self.PATH_CATALOG, "data", data_file)
+        data_csv = pd.read_csv(repertory, sep=';', header=0, index_col=index_col)
+        return data_csv
+    
+    def _data_from_json(self, data_file: str):
+        """ Retourne un dataframe d'un fichier JSON """
+        repertory = os.path.join(self.PATH_CATALOG, "data", data_file)
+        data_json = pd.read_json(repertory)
+        return data_json
+    
+    
+    @property
+    def objet(self):
+        """Retourne l'objet lui même.
+        """
+        return self
+
+    def get_value(self, value: str, index: int=None, key: str=None):
+        """Retourne l'argument transmit.
+
+        Args:
+            index (int, optional): index à retourner dans une liste python. 
+                Attention sous pyhon le premier élément d'une liste ce trouve à l'index 0.
+            key (str, optional): clé à renvoyer dans un dictionnaire python.
+        """
+        if index:
+            value = list(value)[index]
+        elif key:
+            value = f"{value.replace("'", '"')}"
+            value = json.loads(value)[key]
+        return str(value)
+        
+    def operation_between_values(self, value1: float, value2: float, operator: str=OPERATOR):
+        """Retourne l'opération donnée entre la valeur 1 et la valeur 2.
+        Pour les calculs trigonométrique, la valeur 2 est en degré."""
+        if operator not in self.OPERATOR:
+            raise ValueError(f"Invalid operator: {operator}")
+        match operator:
+            case "+":
+                result = value1 + value2
+            case "-":
+                result = value1 - value2
+            case "x":
+                result = value1 * value2
+            case "/":
+                result = value1 / value2
+        return result
+    
+    def abs_value(self, value: float):
+        """Retourne la valeur absolue.
+        """
+        return abs(float(value))
+    
+    def max(self, value1: float, value2: float):
+        """Retourne la valeur max entre la valeur 1 et valeur 2.
+        """
+        return max(float(value1), float(value2))
+    
+    def min(self, value1: float, value2: float):
+        """Retourne la valeur min entre la valeur 1 et valeur 2.
+        """
+        return min(float(value1), float(value2))
+    
+    def cos(self, value: float):
+        """Retourne le cosinus de la valeur donnée en degré."""
+        return mt.cos(mt.radians(float(value)))
+    
+    def sin(self, value: float):
+        """Retourne le sinus de la valeur donnée en degré."""
+        return mt.sin(mt.radians(float(value)))
+    
+    def tan(self, value: float):
+        """Retourne la tangente de la valeur donnée en degré."""
+        return mt.tan(mt.radians(float(value)))
+    
+
+    @classmethod
+    def _convert_unit_physical(cls, value: int|float, si_unit: si.Physical, unit_to_convert: si.Physical):
+            """Convertie l'unité de base dans l'unité nécessaire à l'instanciation de la classe parente
+
+            Args:
+                value (int|float): valeur à convertir
+                si_unit (si.Physical): unité si de base
+                unit_to_convert (si.Physical): unité dans la quelle convertir
+            """
+            si_unit, unit_to_convert = str(si_unit), str(unit_to_convert)
+            if si_unit != unit_to_convert:
+                if si_unit == str(si.m):
+                    if unit_to_convert == str(si.mm):
+                        return value * 10**3
+                elif si_unit == str(si.m**2):
+                    if unit_to_convert == str(si.mm**2):
+                        return value * 10**6
+                elif si_unit == str(si.m**3):
+                    if unit_to_convert == str(si.mm**3):
+                        return value * 10**9
+                elif si_unit == str(si.m**4):
+                    if unit_to_convert == str(si.mm**4):
+                        return value * 10**12
+                elif si_unit == str(si.N):
+                    if unit_to_convert == str(si.kN):
+                        return value * 10**-3
+                elif si_unit == str(si.Pa):
+                    if unit_to_convert == str(si.MPa):
+                        return value * 10**-6
+            return value
+    
+    @classmethod           
+    def _reset_physical_dictionnary(cls, objet: object, dictionnary: dict) -> dict:
+        """Class méthode permetant de réinitialiser les valeurs physiques d'un dictionnaire d'argument d'une classe parent.
+
+        Args:
+            objet (object): l'objet à réinitailiser
+            dictionnary (dict): le dictionnaire d'argument de la classe parent
+
+        Returns:
+            dict: le dictionnaire d'argument de la classe parent avec les valeurs physiques réinitialisées
+        """
+        dict_physical = {}
+        # Si un argument utilise forallpeople on récupère que la valeur pour ne pas multiplier l'unité par elle même
+        for key, val in dictionnary.items():
+            if isinstance(val, si.Physical):
+                physical = val.split(base_value=True)
+                # On test si l'objet est une classe ou une instance de classe
+                if isinstance(objet, type):
+                    mro = objet.mro()
+                else:
+                    mro = type(objet).mro()
+                for objt in mro:
+                    spec = inspect.getfullargspec(objt.__init__).annotations
+                    if spec.get(key):
+                        unit = spec[key]
+                        value = cls._convert_unit_physical(physical[0], physical[1], unit)
+                        dict_physical[key] = value
+                        break
+        return dict_physical
+    
+    @classmethod           
+    def _reset_physical_object(cls, objet: object):
+        """Class méthode permetant de réinitialiser les valeurs physiques d'un objet d'une classe parent.
+        """
+        dictionnary = objet.__dict__
+        return cls._reset_physical_dictionnary(objet, dictionnary)
+    
+    
+
+    @classmethod
+    def _from_dict(cls, dictionary:dict):
+        """Class méthode permetant l'intanciation des classe hérité de la classe parent, par une classe déjà instanciée.
+
+        Args:
+            object (class object): l'objet Element déjà créer par l'utilisateur
+        """ 
+        return cls(**dictionary)
+    
+    @classmethod
+    def _from_parent_class(cls, objet: list|object, **kwargs):
+        """Class méthode permetant l'intanciation des classe hérité de la classe parent, par une classe déjà instanciée.
+
+        Args:
+            object (class object): l'objet Element déjà créer par l'utilisateur
+        """
+        dict_objet = {}
+        if isinstance(objet, list):
+            for obj in objet:
+                dict_objet.update(obj.__dict__)
+                dict_objet.update(Objet._reset_physical_object(obj))
+        else:
+            dict_objet = objet.__dict__
+            dict_objet.update(Objet._reset_physical_object(objet))
+        return cls(**dict_objet, **kwargs)
+
+    
+    def _save_muliple_objects(self, object: list):
+        save_file_path = QFileDialog.getSaveFileName(
+                filter="Ourea catalog object (*.oco);;'Text Document' (*.txt)",
+                selectedFilter=".oco",
+            )[0]
+        # with filedialog.asksaveasfile('wb', filetypes=(("Ourea catalog object", "*.oco"), ('Text Document', '*.txt')), defaultextension='.oco') as f:
+        with open(save_file_path, "wb") as f:
+            for ligne in object:
+                pickle.dump(ligne, f)
+    
+    
+    def save_object(self):
+        save_file_path = QFileDialog.getSaveFileName(
+                filter="Ourea catalog object (*.oco);;'Text Document' (*.txt)",
+                selectedFilter=".oco",
+            )[0]
+        with open(save_file_path, "wb") as f:
+            pickle.dump(self, f)
+
+    
+    def _show_element(self, picture: str):
+        """Affiche l'image des caractéristiques d'une entaille au cisaillement
+        """
+        file = os.path.join(self.PATH_CATALOG, "data", "screenshot", picture)
+        image = Image.open(file)
+        image.show()
+            
+            
+    @classmethod
+    def _open_multiple_objects(cls):
+        data = []
+        # with filedialog.askopenfile('rb', filetypes=(("Ourea catalog object", "*.oco"), ('Text Document', '*.txt')), defaultextension='.oco') as f:
+        file_path = QFileDialog.getOpenFileName(
+                    filter="Ourea catalog object (*.oco);;'Text Document' (*.txt)", selectedFilter=".oco"
+                )[0]
+        with open(file_path, "rb") as f:
+            while True:
+                try:
+                    data.append(pickle.load(f))
+                except EOFError:
+                    break
+            return data
+    
+    @classmethod
+    def _open_object(cls, path: str=None):
+        if not path:
+            file_path = QFileDialog.getOpenFileName(
+                    filter="Ourea catalog object (*.oco);;'Text Document' (*.txt)", selectedFilter=".oco"
+                )[0]
+            with open(file_path, "rb") as f:
+                return pickle.load(f)
+        else:
+            with open(path, mode="rb") as f:
+                return pickle.load(f)

ourocode-1.6.0.dist-info/METADATA

@@ -0,0 +1,331 @@
+Metadata-Version: 2.4
+Name: ourocode
+Version: 1.6.0
+Summary: Ceci est un catalogue de fonction permettant une utilisation rapide pour la réalisation de note de calcul personnalisée.
+Home-page: https://github.com/Icelone73/OUREA-EasyCode
+Author: Anthony PARISOT
+Author-email: Anthony PARISOT <contact@ourea-structure.fr>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright [2025] [Anthony PARISOT]
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+Project-URL: Homepage, https://github.com/AnthonyPrst/ourocode
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: handcalcs
+Requires-Dist: forallpeople
+Requires-Dist: PyNiteFEA
+Requires-Dist: pyvista[all,trame]
+Requires-Dist: PySide6
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: Pillow
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+
+# 📐 Ourocode - Bibliothèque Python pour le calcul de structure selon les Eurocodes
+
+[![License: Apache License 2.0](https://img.shields.io/badge/License-A-blue.svg)](LICENSE)
+<!-- [![PyPI](https://img.shields.io/pypi/v/eurocode-calc.svg)](https://pypi.org/project/ourocode/) -->
+[![Tests](https://img.shields.io/github/v/release/AnthonyPrst/ourocode)](https://github.com/AnthonyPrst/ourocode/pyptoject.toml)
+[![Coverage](https://img.shields.io/codecov/c/github/ton-org/eurocode)](https://codecov.io/gh/ton-org/ourocode)
+
+---
+
+## 🔍 Description
+
+**Ourocode** est une bibliothèque Python regroupant les formules normalisées issues des différentes parties des Eurocodes :
+
+- **EN 1990** : Bases de calcul
+- **EN 1991** : Actions sur les structures
+- **EN 1993** : Calcul des structures en acier
+- **EN 1995** : Calcul des structures en bois
+
+Elle permet de construire un **catalogue de fonctions réutilisables** pour générer rapidement des **notes de calcul personnalisées**, intégrables dans des applications de vérification ou de génération de rapports.
+
+---
+
+## 🚀 Objectifs
+
+- Offrir une **implémentation fiable et vérifiée** des formules Eurocode.
+- Permettre une **utilisation modulaire** dans des interfaces No-Code, des scripts ou des applications.
+- Fournir une **base open source transparente**, adaptée aux ingénieurs, bureaux d’études, enseignants ou développeurs.
+
+---
+
+## 📦 Installation
+
+<!-- ```bash
+pip install ourocode
+``` -->
+
+> Installez directement depuis le dépôt :
+```bash
+pip install git+https://github.com/AnthonyPrst/ourocode.git
+```
+
+---
+
+## ✨ Fonctionnalités
+
+- Calculs normalisés : flexion, traction, cisaillement, flambement, assemblage EC5 et EC3, flèche…
+- Support des classes de résistance bois (C24, GL24h, etc.) et acier (S235, S355…)
+- Prise en compte des effets de feu (EN 1995-1-2)
+- Intégration avec `handcalcs` pour génération LaTeX des formules
+- Compatible avec le logiciel [OUREA-NoCode](https://ourea-structure.fr/telechargement)
+- Organisé en modules clairs par norme et fonction (EN1990, EN1991, etc.)
+
+---
+
+## 🛠 Exemple d'utilisation
+
+```python
+from eurocode.EC5_Element_droit import Barre
+
+panne = Barre(b=100, h=200, section="Rectangulaire", classe="C24", cs=2, Hi=12, Hf=12)
+panne_flexion = Flexion(lo=5000, coeflef=0.9, pos="Charge sur fibre comprimée")
+latex_fmd, fmd = panne_flexion.f_m_d("Moyen terme", "Fondamentales")
+latex_sigmamd, sigmamd = panne_flexion.sigma_m_d(20, axe="y")
+latex_taux, taux = panne_flexion.taux_m_d()
+```
+
+## ✅ Tests & couverture
+
+```bash
+pytest --cov=eurocode --cov-report=html
+```
+
+Les tests couvrent les modules principaux.
+
+---
+
+## 🤝 Contribuer
+
+Les contributions sont les bienvenues ! Pour proposer une amélioration ou corriger un bug :
+
+1. Fork le dépôt
+2. Crée une branche (`git checkout -b feature/ta-fonction`)
+3. Commits (`git commit -am "feat: ajout nouvelle vérif"`),
+4. Pull request 📥
+
+---
+
+## 📄 Licence
+
+Distribué sous licence **MIT** – libre d’usage, même commercial, avec attribution.
+
+---
+
+## 👷 Auteur
+
+Développé par **Anthony PARISOT**, ingénieur structure bois & développeur, dans le cadre du projet open source [OUREA STRUCTURE](https://ourea-structure.fr).
+
+---
+
+## ⭐ Si vous trouvez ce projet utile...
+
+N'hésitez pas à [⭐️ le repo GitHub](https://github.com/Icelone73/ourocode) pour le soutenir !