Cet article propose de détailler la création pas à pas du classique jeu de Pong en Python avec une UI s’appuyant sur la bibliothèque Tkinter.
Serveur OpenID Connect simpliste, basé sur OpenLDAP
Bibliothèque python de gestion de formulaires web
SelectFieldreadonly et disabledIntégration de WTForms dans Flask
Anymail: Intégration de fournisseurs d'e-mails transactionnels dans Django
Une application web simple de gestion de budget
setup.cfg à pyproject.tomlBibliothèque python de gestion des identités et des accès
Utilitaires de test d'applications Flask avec WebTest
Simplistic OpenID Connect provider over OpenLDAP
A flexible forms validation and rendering library for Python.
SelectField refactoringreadonly and disabled validatorsSimple integration of Flask and WTForms, including CSRF, file upload and Recaptcha integration.
Anymail: Django email integration for transactional ESPs
A simple shared budget manager web application
setup.cfg to pyproject.toml migrationIdentity and Access management library for python
Utilities for testing Flask applications with WebTest*
Depuis un certain temps l’équipe de Yaal Coop travaille sur Canaille, un logiciel de gestion d’identité et d’accès. Nous profitons de la fin de travaux financés par la fondation NLNet pour vous raconter l’histoire autour de Canaille.
À Yaal Coop (comme presque partout ailleurs) nous utilisons une palette d’outils qui nous permettent de travailler ensemble. Emails, fichiers, carnets de contacts, gestion de projet, suivi du temps, comptabilité, intégration continue, collecte de rapports de bugs… la liste est longue. Pour des raisons de praticité (et de sécurité) on cherche généralement à connecter une telle collection d’outils à un logiciel central qui se charge de la gestion des utilisateur·ices et de leurs accès. Traditionnellement, c’est LDAP1 qui est utilisé pour cet usage, on parle alors d’annuaire.
Si un outil est connecté à un annuaire, vous n’avez pas besoin de vous y créer un compte, vous pouvez vous connecter en utilisant votre mot de passe habituel, celui que vous avez renseigné dans l’annuaire. C’est pratique pour vous puisque vous n’avez qu’un unique mot de passe à retenir (ou à oublier), on parle généralement d’inscription unique ou Single Sign On (SSO). C’est aussi pratique pour les personnes qui gèrent les comptes dans votre organisation, puisqu’elles peuvent créer et révoquer des comptes utilisateur·ices une seule fois pour tous les outils à la fois.
LDAP, c’est vieux et c’est robuste. Pour des logiciels, ce sont des qualités. Les quelques décennies d’expérience de LDAP en font une technologie éprouvée et compatible avec un énorme choix de logiciels.
Mais LDAP, c’est aussi compliqué et austère. C’est une base de donnée en arbre qui ressemble à peu d’autres choses, la documentation est éparse et absconse, les conventions sont curieuses, pleines d’acronymes angoissants, l’outillage est rare… Et puis c’est conçu pour les données qui sont lues souvent mais écrites rarement. Les modèles de données utilisables dans LDAP sont eux aussi peu évolutifs. Généralement quelques uns sont fournis d’office et permettent de manipuler des attributs de base sur des utilisateur·ices et des groupes. Et si on veut que son système puisse gérer d’autres attributs comme les couleurs préférées, alors il faut écrire ses propres modèles de données, et on a intérêt à être sûr de soi puisqu’aucun mécanisme de mise à jour des schémas ou de migration des données n’est prévu2. Si on souhaite ensuite partager ces modèles de données, alors il est conseillé de s’enregistrer à l’IANA3, et de fournir une référence en ligne de ses schémas. Quand on se plonge dans l’univers de LDAP, on a l’impression qu’une fois mises en place, les installations ne bougent pas pendant des années ; et donc les personnes qui ont la connaissance fuient l’austérité de cette technologie sans avoir à s’y ré-intéresser (puisque ça fonctionne), et sans trop documenter leurs aventures. J’exagère à peine, si on compare4 le nombre de questions sur stackoverflow, pour ldap on en dénombre environ 1000 tandis que postgresql ou mongodb en comptent environ 14 000 et mysql 45 000.
Lors de temps de bénévolat à Supercoop5, nous avons notamment travaillé à installer, comme pour chez nous, plusieurs outils numériques de collaboration. Évidemment tous les outils étaient branchés sur un annuaire LDAP. Nous nous sommes rendus compte que l’équipe dite de gestion des membres, passait un certain temps à traiter des demandes de réinitialisation de mot de passe, à aider des personnes qui échouaient à utiliser les outils dès les premières étapes de connexion. Ce constat nous a donc poussé à chercher des outils (libres, évidemment) d’authentification unique et de gestion d’utilisateur·ices, en complément ou remplacement de l’annuaire. Ce que l’authentification unique ou Single Login Identification (SLI) apporte au SSO fourni par LDAP, c’est que les utilisateur·ices peuvent naviguer entre les outils sans avoir à s’identifier à nouveau. On peut passer de l’interface mail à son calendrier en ligne sans repasser par l’écran d’identification, tandis qu’avec un simple annuaire, il aurait été nécessaire d’entrer son mot de passe une fois pour chaque outil. Pour un public non technophile, c’est l’opportunité de se passer de quelques écrans techniques, et limiter les sources d’erreur et de frustration.
Actuellement les protocoles de prédilection pour faire du SLI sont OAuth2 et OpenID Connect (OIDC)6. On note qu’il existe d’autres standards, plus historiques ou bien plus orientés vers les grosses organisations, tels SAML ou CAS. Les normes OAuth2 et OIDC sont modernes mais bénéficient d’une dizaine d’années de retours d’expérience. Les outils et les documentations sont nombreuses, la communauté est active, et les standards évoluent en ce moment même grâce au groupe de travail oauth de l’IETF7. Mais là encore tout n’est pas rose et OIDC vient avec son lot de difficultés.
Tout d’abord, OAuth2 et OIDC c’est environ 30 standards complémentaires, dont certains contredisent et apportent des corrections sur des standards antérieurs. Tous ne sont pas pertinents dans l’usage que nous visons, mais ne serait-ce que simplement comprendre le fonctionnement de ceux qui nous intéressent demande déjà du temps et de la réflexion. Les implémentations d’OIDC — par les logiciels de gestions d’utilisateur·ices, ou par les outils qui s’y branchent — sont généralement partielles, et parfois bugguées. Pour ne rien arranger, les gros acteurs de l’industrie prennent délibérément des libertés avec les standards et forcent le développement de spécificités pour être compatibles avec leurs logiciels.8
Mais revenons à nos moutons. Pour Supercoop nous souhaitions trouver un outil qui soit d’une grande simplicité à plusieurs points de vue :
Notre recherche nous a montré qu’il existait une quinzaine d’outils pouvant répondre aux besoins que nous avons identifiés. Pour autant, aucun outil ne nous semblait cocher toutes les cases. En fait, par leur nature, les outils de gestion d’identité et d’autorisations ou Identity and Authorization Management (IAM) sont destinés à de grosses organisations, qui peuvent donc s’offrir les services de personnes qualifiées pour s’en occuper. Ce sont donc des logiciels lourds mais puissants, supportant beaucoup de protocoles qui ne nous concernent pas, requiérant une certaine technicité pour l’installation, la maintenance ou la gestion. Motivés par notre curiosité nous avons fini par bricoler quelque chose dans notre coin.
Quelques temps après, notre prototype a grossi et a donné Canaille.
Canaille est un logiciel qui permet de gérer des utilisateur·ices et des groupes d’utilisateur·ices, de créer, modifier et administrer des comptes, de réinitialiser des mots de passes perdus, d’inviter des nouveaux utilisateur·ices. En plus de ça, Canaille implémente OIDC et fournit donc une authentification unique aux utilisateur·ices vers d’autres outils. Son interface est personnalisable et … c'est tout. Nous tâchons de garder le périmètre fonctionnel de Canaille assez restreint pour qu'il reste simple.
Canaille peut être utilisé pour :
Canaille est un logiciel écrit en python, avec flask pour le côté serveur et fomantic-ui et htmx pour la partie client utilisateur·ice. Nous apprécions la simplicité de python et celle de flask et croyons sincèrement que ce sont autant de freins en moins à la participation d’éventuels contributeur·ices. Nous avons été sidérés par notre découverte récente de HTMX, qui en deux mots nous permet de créer des pages web dynamiques sans plus écrire de Javascript. Un langage en moins dans un projet c'est autant de complexité en moins.
Sous le capot, Canaille peut se brancher au choix à un annuaire LDAP ou à une base de données SQL.
Nous utilisons Canaille en production, à Supercoop donc où il est utilisé pour gérer environ 1800 membres, mais aussi chez nous à Yaal Coop et au sein de notre offre mutualisée de services Nubla, et sur des instances dédiées Nubla Pro. Cette large base d’utilisateur·ices nous permet de récolter des retours d’expérience, et nous améliorons le logiciel au fur et à mesure des besoins.
Canaille suit le principe du développement dirigé par les tests, ou Test Driven Development (TDD), dans la mesure du possible. La couverture du code est de 100% (branches comprises), et c’est un pré-requis pour toute contribution. En plus d’avoir confiance dans nos tests, cela nous a permis à plusieurs reprises de simplement supprimer du code qui n’était plus utilisé, et simplifier d’autant le projet. On débusque plus facilement les bugs quand il y a moins de code.
Canaille utilise tous les analyseurs et formatteurs de code source modernes, au sein de pre-commit, et les test unitaires sont joués sur toutes les versions de Python officiellement supportées.
Enfin la traduction de l’interface de Canaille se fait de manière communautaire sur weblate.
Comme la plupart des logiciels modernes, Canaille réutilise des bibliothèques logicielles existantes pour que nous n’ayions pas à ré-inventer ce que d’autres ont déjà fait.
Lorsque nous rencontrons des erreurs dans ces bibliothèques, nous suivons une stratégie qui consiste à implémenter les corrections à la fois dans Canaille et dans les logiciels. D’une part nous amenons donc les corrections dans Canaille, de manière temporaire et efficace. Mais tout ce code que nous écrivons nous-même est un fardeau de maintenance à venir, nous tâchons donc en parallèle de proposer des solutions mieux conçues aux mainteneur·euses desdites bibliothèques, en discutant avec eux en amont. C'est pour nous la garantie que les briques logicielles sur lesquelles nous nous appuyons sont pérennes, et c’est un moyen de contribuer à cet écosystème nécessaire qu’est celui du logiciel libre.
Par ailleurs lorsque nous souhaitons des fonctionnalités supplémentaires dans ces bibliothèques, nous expliquons nos motivations aux mainteneur·euses et parfois proposons des implémentations. Nous avons par exemple développé le support des spécifications OIDC RFC7591 et RFC9068 dans authlib, une brique utilisée pour la partie OIDC de Canaille.
Le résultat de ces efforts est visible dans nos articles trimestriels de contributions à des logiciels libres.
Le hasard des contributions nous a amené à partager la maintenance de certaines des bibliothèques que nous utilisons, comme wtforms qui permet de gérer les formulaires dans Canaille, ou encore nextcloud-oidc-login et OpenIDConnect-PHP qui permettent à nextcloud (le gestionnaire de fichiers proposé par Nubla) de se connecter à Canaille.
Nous sponsorisons aussi modestement tous les mois les mainteneur·ices de fomantic-ui et authlib.
Canaille a été développé pour répondre aux besoins spécifiques que nous avons rencontrés : à l’origine Canaille s’interfaçait donc seulement avec des annuaires LDAP. L’écosystème évoluant, nous nous sommes aperçus que de plus en plus de logiciels étaient capables de communiquer avec OIDC en plus de LDAP. In fine, si plus aucun des logiciels que nous utilisons ne dépend directement de LDAP, alors nous pouvons envisager un outil de remplacement avec lequel nous nous sentons plus à l’aise. Pour aller dans cette direction, nous avons sollicité fin 2022 l’aide de 7 000€ au fond NGI Zero Entrust de la fondation NLNet pour financer le support de travaux dans Canaille :
Ces développements ont été achevés fin novembre 2023, et ont été la source de nombreux réusinages, de nombreuses corrections de bogues, et plus généralement d’une meilleure conception et d’une meilleure fiabilité de Canaille. Nous sommes particulièrement reconnaissant·es à la fondation NLNet de nous avoir permis de travailler sur notre outil, et de nous aider à contribuer à notre échelle à l’écosystème du logiciel libre.
Nous avons depuis le début gardé Canaille en version alpha, nous sommes à l’heure actuelle à la version 0.0.35.
Nous indiquions que le logiciel était impropre aux environnements de production.
C’était pour nous un moyen de pouvoir expérimenter dans notre coin sans avoir à se soucier de rétrocompatibilité.
Nous souhaitons sévir une dernière fois en remettant à plat la manière de configurer Canaille avant de passer Canaille en bêta, et lever les mises en garde d’usage.
Nous regroupons les tickets pour le passage en version bêta de Canaille dans ce jalon.
Les travaux que nous immaginons réaliser pour passer d’une version bêta à une version finale sont principalement des efforts de documentation, d’installation et de prise en main de Canaille. L’objectif est pour nous de rendre Canaille facile d’accès, afin de créer de l’usage et collecter des retours utilisateurs.
Nous regroupons les tickets pour le passage en version stable de Canaille dans ce jalon.
Pour l’avenir nous souhaitons travailler sur le provisionnement, en implémentant la norme SCIM. Ce travail permettra de découpler l’authentification des utilisateur·ices et la création des comptes utilisateur·ices. En effet aujourd’hui dans les outils externes que nous avons branchés à Canaille, les comptes des utilisateur·ices sont créés à la première connexion. Cela peut s’avérer problématique dans certaines situations : par exemple si l’on veut partager des fichiers dans Nextcloud avec un utilisateur·ice qui ne s’est encore jamais connecté. SCIM permet aussi de supprimer des comptes utilisateur·ices sur ces outils externes, tâche qui doit être réalisée plus ou moins manuellement à l’heure actuelle.
Parmi les chantiers à venir, nous voyons aussi le travail sur la déconnexion unique, ou Single Log-Out (SLO). C’est un développement qui devra être réalisé en premier lieu dans authlib, et qui permettra aux utilisateur·ices de se déconnecter de tous les outils en une seule action. C’est une fonctionnalité qui apportera de la sécurité et du confort d’utilisation.
Enfin, nous aimerions travailler sur une gestion avancée des groupes d’utilisateur·ices et des droits, ainsi que sur des mécanismes d’authentification multi-facteurs.
Si tout cela vous intéresse, vous pouvez tester Canaille immédiatement sur notre interface de demo. Canaille est évidemment ouvert aux contributions, alors si vous souhaitez nous aider dans tout ça, la porte est ouverte !
Since a while, the Yaal Coop team is working on Canaille, an identity and authorization management software (or IAM). At the occasion of the end of an endeavour that benefited the help of the NLNet foundation, we want to tell the history around Canaille.
At Yaal Coop (like anywhere else) we use a bunch of tools to work together as a team. Emails, files, address book, project management, time tracking, accountability, continuous integration, bug reporting… and the list goes on. For the comfort of use (and for security), those tools are generally plugged to a central software that manages user accounts and accesses. Usually, LDAP[ref]or more exactly, a software implementing the LDAP protocol[/ref] is used for that, and this is called a directory. If a service is connected to a directory, you do not need to register to that service, you can just use your usual password, the one you set in the directory. It is convenient for you since you just have one single password to remember (or to forget). This is what is called Single Sign On (SSO). It is also convenient for people managing the user accounts in your organization, as they can create and revoke accounts for all the plugged services at a time.
LDAP is old and robust, and for software those are qualities. The few decades of experience behind LDAP make it a battle-tested technology compatible with a large selection of services. But unfortunately LDAP is also complicated and abstruse.
Its tree model looks like few other things you might know, the documentation is rare and obscure, conventions are intriguing, with a lot of distressing acronyms, tooling is sparse… Also, this was made for data often read but rarely written. The data models LDAP offers cannot easily evolve. Generally, the provided ones allow to handle basic attributes on users and groups. If you want to manage more advanced aspects like the favourite color of users, then you need to write your own data models[ref]that are called schemas[/ref]. And you'd better be confident when you do it, because no update mechanism is provided for neither data nor data models[ref]at least with OpenLDAP[/ref]. Then, if you wish to share your data models with the world, it is advised that your register at the IANA[ref]what we did, our IANA number is 56207[/ref], and provide an online reference of your schemas.
When we took a close look at the LDAP universe, we had the impression that once set up, LDAP installation were left alone for years ; like if people who might had knowledge to share had flew the austerity of that technology without documenting their adventures, and without need to returning to it because it just works. I am barely exaggerating, if we have a look[ref]OK, the comparison has limits since those different databases are not used for the same needs, but the magnitude of the numbers says something about the interest around those technologies[/ref] at the number of questions in stackoverflow, ldap has approximately 1000 questions, while postgresql or mongodb have around 14.000, and mysql has 45.000.
During our volunteer time at Supercoop[ref]a cooperative supermarket near Bordeaux, France[/ref], among other tasks, we worked to install collaboration software, like we did for ourselves. Obviously, those tools were plugged on a LDAP directory. We noticed that the members management team of the supermarket was spending a certain amount of time dealing with user support, notably with password reset demands. People were failing to use the tools we deployed for them as soon as the first login step. This verdict pushed us to look for Single Login Identification (SLI) software (free and open-source, obviously), in replacement or in addition to our historical directory. What SLI brings, is that users can navigate between services without having to sign in every time. They can switch from the webmail interface to the calendar without having to make a step by the authentication screen, while with a simple directory, they would have to enter their password once for each service. For a non tech-savvy public, this is the opportinity to get rid of several technical screens, limit the error sources and the frustration.
Currently the predilection protocols for SLI are OAuth2 and OpenID Connect (OIDC)[ref]for sake of simplicity, I will keep to OIDC[/ref]. (There are other existing standards, more historical or more focused towards big organizations, like SAML or CAS.) The OAuth2 and OIDC specifications are recent but they still benefit from a decade of feedback. Tooling and documentation are numerous, the community is alive and active, and standards are still evolving at this day with the work of the IETF oauth workgroup. But here again, everything is not perfect and OIDC comes with its difficulties. First of all, OAuth2 and OIDC make about 30 different standards, some of which contradicting or bringing corrections upon prior standards. All of those are not pertinent for what we want to do, but simply understanding how work the few standards that actually interests us already requires a certain amount of time and work. The OIDC implementations – by the IAMs or the services connected to IAMs – are sometimes partial or bugged. To make nothing better, big industry actors sometimes deliberately take some liberties with the standards, and make some additional developments a requirements to be compatible with their software.[ref]They can also be a driving force for new features, like RFC7628 or RFC9068 that were commonly used before they became standards.[/ref]
Let's get back on topic. For Supercoop, we wanted to find a tool that would be utterly simple from several point of views:
Our search showed us that there was a dozen of tools that could answer our needs. However, none was fitting all our expectations. Actually, by their very nature, the IAM software are intended to big organizations, that consequently can afford to hire competent people to administrate them, so complexity is not really an issue. Those are mostly big powerful software, with a large protocol compatibility not pertinent for us, and requiring some technical knowledge for installation, maintenance and administration. Pushed by our curiosity, we finally hacked something on our side.
A few times later, our prototype had grown bigger and became Canaille.
Canaille is a user and group management software that allows account creation, edition, administration, registration, forgotten password reset, user invitation etc. In addition, Canaille implements OIDC and provide a SLI layer for other services. Its interface is customizable and… that's all. We try to keep the functional scope tight so Canaille can stay simple to maintain and to operate.
Canaille can be used for:
Canaille is written in Python, with Flask for the backend and fomantic-ui and htmx for the frontend. We like the simplicity of Python and Flask, and strongly believe those are arguments that make contributions easier and increase software longevity. We have been shocked by our discovery of HTMX earlier this year, that in short allows us to build dynamical pages without writing Javascript. One language less is as much less complexity in the project.
Under the hood, Canaille can be plugged to a LDAP directory or a SQL database.
We use Canaille in production, at Supercoop where it is used to manage 1800 users, but also in our own stack in our Nubla mutualized cloud services, and on dedicated Nubla Pro instances. That large userbase allows us to collect user feedback, and we improve Canaille gradually in reaction to demands and according to our roadmap.
Cannaille development follows the principles of the Test Driven Development (TDD) when possible. The code coverage reaches 100% (including branches), and this is a prerequisite for new contributions. In addition to giving us confidence in our tests, this allowed us to simply delete unused pieces of code. Bugs are easier to find when there is less code to search them into.
Canaille uses all the modern Python source code linters and formatters, with pre-commit, and the unit tests are run on all the officially supported Python versions.
Finally, the translation of Canaille is done by the community with Weblate.
Like most of modern software, Canaille relies on libraries so we don't have to re-invent what is already existing.
At Yaal Coop for all our projects, when we find bugs in libraries, we follow a strategy that consists in implementing fixes both in our code and the libraries at the same time. At first we patch our code with temporary but functional fixes. However all that code we write is a maintenance burden to come, so in parallel we discuss with the maintainers of those libraries, and propose better conceived long term fixes. This is for us a guarantee of the sustainability of those pieces of software we rely upon, and this is a way to contribute to that necessary FLOSS ecosystem. Once the upstream library is patched, we delete our quick fix.
In the same fashion when we wish additional features in libraries, we discuss our motivations with maintainers and sometimes provide implementations. We have for instance developed the OIDC specifications RFC7591 and RFC9068 in authlib, a library Canaille uses to deal with OIDC.
The results of those efforts can be seen in our seasonal blogposts about our FLOSS contributions.
The chance of the contributions brought us to share the maintenance of certain libraries we rely upon, like wtforms that is a form management tool, or nextcloud-oidc-login and the underlying OpenIDConnect-PHP that allow nextcloud (the file manager integrated in Nubla) to connect with Canaille.
We also modestly sponsor the maintainers of fomantic-ui and authlib on a monthly basis.
Canaille has been developed to answer specific needs we met: initially Canaille was only made to work with LDAP directories. Watching the ecosystem, we noticed that more and more software became compatible with OIDC in addition to LDAP. Ultimately, if no service we use directly rely upon LDAP, then we could consider a replacement database with which we feel more comfortable. In addition to this, it is more likely that people interested by the Canaille approach will have experience with things like SQL than with LDAP. To go towards this directory, we sollicitated the NGI Zero Entrust fund of the NLNet foundation in the late 2022, for a amount of 7.000€, to help us realize tasks on Canaille (and around):
Those developments have been achieved in november 2023, and have implied numerous refactoring, bugfixes, and better conception and reliability on Canaille. We are very grateful towards the NLNet foundation for having allowed us to work on our tool, and help at our scale to contribute to the free and open source ecosystem.
From the beginning we have kept Canaille in alpha, we are currently at version 0.0.35.
We advise in the documentation that the software is still not suited for production environments.
This was for us a way to experiment and break things without having to be worried about compatibility.
We would like to break one last little thing by re-thinking the configuration files before we let Canaille go in bêta, and remove usage warnings.
We track the beta version tasks in this milestone.
The work we intend to realize to go from a bêta version to a finale version will essentially consists in documentation efforts and ease of installation and usage of Canaille. The goal is to make Canaille really easy to access, in order to create usage and collect more user feedback.
We track the finale version tasks in this milestone.
In the future, we would like to work on provisioning, by implementing the SCIM specification. This will allow to decouple user authentication and account creation. Indeed, at the moment user accounts are created the first time users log in at our services. This can raise issues in some situations: for instance one cannot share files in Nextcloud with users who have not log in yet. SCIM also provides a mechanism to delete user accounts in those services, that is a thing we do more or less manually at the moment.
Among the things we look forward to implement, there are also the Single Log-Out (SLO) OIDC specifications. This will allow users to disconnect from all the services in a single action. SLO is a feature that will bring security and comfort of use. This will need to be developed in authlib in a first time.
At last, we would like to work on advanced group management and permissions, and on multi-factor authentication to bring even more flexibility and security in Canaille.
Canaille is open to contributions, if you want to help us in this endeavour, the door is open!
Dans cet article, nous allons passer en revue toutes les nouveautés de la version 3.12 de Python.
Pour les Pythonistes : un article qui donne des bonnes pratiques pour écrire du clean code avec Django. Réduire le couplage, granularité des tests, utilisation des modèles et des vues, etc.
This summer we decided to sponsor two authors of tools we are depending on. This is a small amount for the moment, but hopefully this will grow or we add more recipients to the list.
We spent a bit of energy on Canaille, and implementing the big part of our NLNet subsidy, that is the database backend genericity. The inmemory backend allowed us to use canaille in pytest-iam, a tool that bring a lightweight OpenID Connect provider to be used in your unit tests.
Simplistic OpenID Connect provider over OpenLDAP
USER_FILTER configuration is parsed with jinjaOIDC.REQUIRE_NONCE configuration parameterA flexible forms validation and rendering library for Python.
Simple integration of Flask and WTForms, including CSRF, file upload and Recaptcha integration.
A simple shared budget manager web application
Controls a slapd process in a pythonic way
Identity and Access management library for python
A lightweight OAuth2/OIDC server to be used in your test suite
Cet été nous avons décidé de sponsoriser deux auteurs d'outils desquels nous dépendons. C'est un petit montant pour le moment, mais nous espérons qu'à l'avenir il augmentera ou que la liste des récipiendaires s'élargira.
Nous avons mis une partie de notre énergie sur Canaille, en implémentant le gros morceau de notre engagement à la subvention NLNet, à savoir la généricité des backends de base de données. L'implémentation de la base de données en mémoire nous a permis d'utiliser Canaille dans pytest-iam, un outil qui permet de lancer un serveur OpenID Connect dans des tests unitaires.
Serveur OpenID Connect simpliste, basé sur OpenLDAP
USER_FILTER est analysé avec jinjaOIDC.REQUIRE_NONCEextras pour des installations dans différents contextesBibliothèque python de gestion de formulaires web
Intégration de WTForms dans Flask
Une application web simple de gestion de budget
Interface pythonique pour contrôler un serveur OpenLDAP
Bibliothèque python de gestion des identités et des accès
Serveur OAuth2/OIDC léger pour vos tests unitaires
f"{x}" et str(x) ?Voici mes tests qui m’ont surpris, car je m’attendais à l’inverse :
from typing import Dict
def benchmark() -> None:
"""Main
function for benchmark.
"""
t1 = timeit.timeit("f_str()",
globals=globals(),
number=50000000)
t2 = timeit.timeit("u_str()",
globals=globals(),
number=50000000)
t3 = timeit.timeit("n_str()",
globals=globals(),
number=50000000)
d: Dict[str, float] = {
"f-string": t1,
"str": t2,
"no str": t3
}
s: Dict[str, float] = {k: v
for k, v
in sorted(d.items(),
key=lambda i:
i[1])}
f: float = min(s.values())
print("Method\tTime\tPerc.")
print("------\t----\t-----")
for k, v in s.items():
p: float = (v / f) * 100
print(f"{k}\t{v:.2f}\t{p:.2f}%")
if __name__ == "__main__":
import timeit
class T:
def __init__(
self, l: str) -> None:
self.l: str = l
o: T = T("test")
def f_str() -> str:
return f"{o.l}"
def u_str() -> str:
return str(o.l)
def n_str() -> str:
return o.l
benchmark()
f"{self.label}" utilise le mécanisme d’interpolation de chaînes de caractères de Python qui peut être légèrement plus rapide parce qu’il est optimisé pour concaténer des littéraux de chaîne et des variables ;str(self.label) appelle explicitement le constructeur de la classe str, ce est un peu plus lent en raison de l’appel de fonction.