Deply : gardez votre architecture Python propre

Les grands projets Python évoluent souvent vers des bases de code complexes et difficiles à maintenir. Garder une trace des importations, des couches et de qui dépend de qui peut rapidement se transformer en désordre. Deply est là pour vous aider. Il analyse la structure de votre code et applique des règles architecturales, garantissant ainsi que votre projet Python reste propre, modulaire et facile à maintenir, même à mesure qu'il se développe.

Pourquoi l'application architecturale est importante

La flexibilité de Python facilite l'introduction de code spaghetti si nous ne faisons pas attention. L'ajout de nouveaux modules, de décorateurs ou même la modification de la façon dont les classes héritent peuvent introduire de subtils problèmes de dépendance au sein des grandes équipes. Des limites claires, appliquées par des contrôles automatisés, contribuent à maintenir une qualité de code élevée. Cette approche booste la lisibilité et la productivité des équipes.

Qu’est-ce que Deply ?

Deply est un outil autonome qui :

1. Vous permet de définir des couches de projet (comme des vues, des modèles, des services) dans une configuration YAML.
2. Collecte les éléments de code dans ces couches via des règles (par exemple, class_inherits, decorator_usage, file_regex).
3. Applique des politiques architecturales pour éviter les couplages indésirables ou les incidents de dénomination.

Pourquoi ne pas utiliser un autre outil ?

• pydeps : se concentre sur la visualisation des importations.
• import-linter : vérifie les contraintes d'importation.
• pytestarch ou pytest-archon : s'appuie sur l'écriture de tests basés sur du code pour l'architecture.
• Tach (basé sur Rust) : approche indépendante du langage, peut ne pas s'aligner parfaitement avec les spécificités de Python.

L'avantage de Deply est qu'il va au-delà des importations, en examinant les décorateurs, l'héritage de classe, les modèles de fichiers, etc. Sa configuration basée sur YAML facilite l'intégration dans les pipelines CI sans écrire de nouveaux fichiers de test.

Nouveau dans la version 0.5.2

1. Collecteurs améliorés : moyens plus flexibles de définir des classes et des fonctions, y compris des modèles d'expression régulière avancés.
2. Performance Boost : Deply s'exécute désormais jusqu'à 10 fois plus vite qu'auparavant. L'intégrer à CI ne ralentira pas vos builds.
3. Règles étendues : des contrôles supplémentaires pour l'héritage, l'utilisation du décorateur et les conventions de dénomination vous permettent de concevoir des politiques granulaires.

Installation

pip install deply

Vous obtiendrez la dernière version, actuellement 0.5.2.

Configuration de déploiement (deply.yaml)

Créez un fichier deply.yaml à la racine de votre projet. Au minimum, définissez les chemins que vous souhaitez analyser, les fichiers à exclure, vos couches et vos règles. Vous trouverez ci-dessous un exemple d'extrait pour un projet de type Django.

deply:
  paths:
    - /path/to/your/project

  exclude_files:
    - ".*\.venv/.*"

  layers:
    - name: models
      collectors:
        - type: bool
          any_of:
            - type: class_inherits
              base_class: "django.db.models.Model"
            - type: class_inherits
              base_class: "django.contrib.auth.models.AbstractUser"

    - name: views
      collectors:
        - type: file_regex
          regex: ".*/views_api.py"

  ruleset:
    views:
      disallow_layer_dependencies:
        - models
      enforce_function_decorator_usage:
        - type: bool
          any_of:
            - type: bool
              must:
                - type: function_decorator_name_regex
                  decorator_name_regex: "^HasPerm$"
                - type: function_decorator_name_regex
                  decorator_name_regex: "^extend_schema$"
            - type: function_decorator_name_regex
              decorator_name_regex: "^staticmethod$"

Comment ça marche :

1. La couche models collecte les classes héritant du modèle ou de AbstractUser de Django.
2. La couche de vues collecte le code des fichiers se terminant par vues_api.py.
3. Règles :
4. disallow_layer_dependencies : la couche de vues ne peut pas dépendre directement des modèles.
5. enforce_function_decorator_usage : toutes les fonctions dans les vues nécessitent soit (HasPerm et extend_schema) soit une méthode statique.

Exécution de Deply

Une fois votre configuration prête, exécutez :

pip install deply

• --config=another_config.yaml vous permet de spécifier un fichier différent.
• --report-format=text|json|github-actions contrôle la façon dont les violations sont affichées.

Exemples supplémentaires

Dénomination des classes :

deply:
  paths:
    - /path/to/your/project

  exclude_files:
    - ".*\.venv/.*"

  layers:
    - name: models
      collectors:
        - type: bool
          any_of:
            - type: class_inherits
              base_class: "django.db.models.Model"
            - type: class_inherits
              base_class: "django.contrib.auth.models.AbstractUser"

    - name: views
      collectors:
        - type: file_regex
          regex: ".*/views_api.py"

  ruleset:
    views:
      disallow_layer_dependencies:
        - models
      enforce_function_decorator_usage:
        - type: bool
          any_of:
            - type: bool
              must:
                - type: function_decorator_name_regex
                  decorator_name_regex: "^HasPerm$"
                - type: function_decorator_name_regex
                  decorator_name_regex: "^extend_schema$"
            - type: function_decorator_name_regex
              decorator_name_regex: "^staticmethod$"

Toutes les classes de la couche service doivent se terminer par Service.

Dénomination de la fonction :

deply analyze

Toutes les fonctions des tâches doivent commencer par task_.

Conseil de pro : combinez plusieurs conditions avec bool pour former une logique avancée (must, any_of, must_not), garantissant ainsi la possibilité d'élaborer des règles très spécifiques.

Intégration CI

Ajoutez une étape à votre pipeline CI :

service:
  enforce_class_naming:
    - type: class_name_regex
      class_name_regex: ".*Service$"

Votre pipeline peut échouer si des violations architecturales sont détectées.

Conclure

Deply est conçu pour vous aider à détecter les violations architecturales avant qu'elles ne deviennent des refactorisations fastidieuses. En automatisant ces contrôles, vous pouvez conserver une conception claire et superposée, même au sein de grandes équipes.

• GitHub : https://github.com/Vashkatsi/deply
• PyPI : https://pypi.org/project/deply/

N'hésitez pas à le tester et à ajuster la configuration selon vos propres besoins. Si vous avez des questions ou des idées, consultez le dépôt pour plus de détails sur le dépôt de problèmes ou la contribution. Bon codage !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!