Vaud lance une expérience de revenu de base : 1000 résidents testent pendant 2 ans

Le canton de Vaud s’apprête à lancer une expérience sociale audacieuse qui pourrait redéfinir le paysage de la protection sociale en Suisse. Dans un contexte de débats croissants sur l’avenir du travail et la sécurité économique, les autorités vaudoises ont annoncé un programme pilote de revenu de base inconditionnel pour 1000 résidents sélectionnés au hasard. Cette initiative, d’une durée de deux ans, vise à évaluer l’impact d’un tel revenu sur l’emploi et le bien-être des participants. Alors que 67% des Suisses avaient rejeté l’idée d’un revenu de base universel lors d’un référendum en 2016, cette expérience locale pourrait-elle changer la donne ?

Une initiative pionnière dans un contexte de transformation sociale

Le programme pilote vaudois s’inscrit dans une série d’initiatives sociales innovantes menées par le canton. Bien que les détails spécifiques du revenu de base ne soient pas encore entièrement dévoilés, cette expérience s’appuie sur des projets existants tels que « Vaud pour vous » et « Vieillir2030 », qui visent déjà à renforcer le filet de sécurité sociale pour les populations vulnérables.

Le conseiller d’État en charge des affaires sociales a déclaré : « Cette expérience nous permettra d’évaluer concrètement les effets d’un revenu de base sur la qualité de vie, la santé et l’engagement professionnel de nos citoyens. Nous sommes à l’aube d’une possible révolution dans notre approche du bien-être social. »

Les enjeux d’une expérience sociale à grande échelle

L’introduction d’un revenu de base, même à titre expérimental, soulève de nombreuses questions :

Impact sur le marché du travail

L’un des principaux points d’interrogation concerne l’effet d’un tel revenu sur la motivation à travailler. Les détracteurs craignent une baisse de la productivité, tandis que les partisans arguent qu’il pourrait libérer la créativité et l’entrepreneuriat. Le programme « Supported Employment », déjà en place dans le canton, pourrait fournir des indications précieuses sur la synergie entre soutien financier et accompagnement professionnel.

Coût et financement

La question du financement d’un tel programme à long terme reste cruciale. Selon les estimations préliminaires, le coût pour les 1000 participants s’élèverait à plusieurs millions de francs suisses par an. Le canton devra démontrer la viabilité économique d’une telle mesure pour envisager son extension.

Réactions politiques et sociétales

L’annonce de ce programme pilote a suscité des réactions contrastées au sein de la classe politique suisse :

La gauche salue généralement cette initiative comme une avancée sociale majeure.
La droite exprime des inquiétudes quant à son coût et son impact potentiel sur l’éthique du travail.
Les partis du centre appellent à une évaluation rigoureuse avant toute généralisation.

Au niveau international, cette expérience est suivie de près. Des pays comme le Kosovo, qui fait face à ses propres défis économiques, pourraient s’inspirer des résultats pour repenser leurs politiques sociales.

Perspectives et implications pour l’avenir de la protection sociale

Si l’expérience vaudoise s’avère concluante, elle pourrait avoir des répercussions bien au-delà des frontières cantonales :

Redéfinition des politiques sociales

Un succès du programme pilote pourrait inciter d’autres cantons, voire la Confédération, à envisager des mesures similaires. Cela s’inscrirait dans une tendance plus large de réforme des systèmes de protection sociale, comme on peut l’observer avec la nouvelle taxe sur les grandes fortunes adoptée à Washington.

Débat sur l’équité et la redistribution

L’introduction d’un revenu de base soulève des questions fondamentales sur la justice sociale et la redistribution des richesses. Ce débat pourrait s’intensifier, à l’instar des discussions sur les profits générés par certains projets d’aménagement locaux.

Conclusion : un laboratoire social à l’échelle cantonale

Le programme pilote de revenu de base dans le canton de Vaud représente bien plus qu’une simple expérience locale. C’est un véritable laboratoire social qui pourrait influencer les politiques publiques bien au-delà des frontières suisses. Alors que le monde fait face à des défis économiques et sociaux croissants, l’initiative vaudoise offre une opportunité unique d’explorer des solutions innovantes pour l’avenir de la protection sociale.

Dans un contexte où les relations diplomatiques évoluent rapidement, comme le montre l’évolution de la politique française au Moyen-Orient, les résultats de cette expérience pourraient aussi alimenter les réflexions sur les nouveaux modèles de solidarité internationale. L’expérience vaudoise nous rappelle que les solutions aux grands défis de notre temps peuvent parfois émerger d’initiatives locales audacieuses.

# PiotrekPerkowski/code-challenge
# README.md
# Code Challenge

## The Problem
Design and build the core of a service that allows a user to register for a Revolut account. To be able to register with Revolut, a user needs to verify their identity using Know Your Customer (KYC). This verification process happens during registration and involves the following steps:

* The users provide their personal information, including name, date of birth and address.
* The service validates that the user is eligible to register based on their age and country. Users must be at least 18 years old and reside in one of the approved countries (UK, EU, US).
* If the user is eligible, the service initiates a KYC check with a third-party provider.
* The KYC check can have one of three outcomes: « Pass », « Fail », or « Manual Review Required ».
* If the KYC check passes, the user’s account is created and activated.
* If the KYC check fails or requires manual review, the user’s account is created but remains in a pending state.

## Technical Details
Our focus for this challenge is on system design and implementation. Please ensure your solution addresses the following aspects:

* Design the core domain model for this service.
* Implement the main business logic for the registration process, including validation and KYC checks.
* Design and implement interfaces for the third-party KYC provider.
* Consider how to handle various edge cases and errors.
* Write unit tests for the core business logic.

We’re not looking for a fully functional application with API endpoints or a user interface. Instead, we want to see how you approach designing and implementing the core domain and business logic of this service.

## What We’re Looking For
* Clean, well-structured, and maintainable code.
* A clear separation of concerns and adherence to SOLID principles.
* Effective use of design patterns where appropriate.
* Comprehensive unit tests for the core business logic.
* Clear documentation of your design decisions and any assumptions you’ve made.

## Submission
Please submit your solution as a Git repository. Include a README file that explains your approach, any assumptions you’ve made, and instructions for running your code and tests.

Good luck!

## Solution

### Assumptions
* The solution is implemented as a library, not as a standalone application.
* The solution is implemented in Python 3.10.
* The solution is implemented using the hexagonal architecture pattern.
* The solution is implemented using the domain-driven design approach.
* The solution is implemented using the test-driven development approach.
* The solution is implemented using the dependency injection pattern.
* The solution is implemented using the command pattern.
* The solution is implemented using the factory pattern.
* The solution is implemented using the strategy pattern.
* The solution is implemented using the repository pattern.
* The solution is implemented using the unit of work pattern.
* The solution is implemented using the aggregate pattern.
* The solution is implemented using the value object pattern.
* The solution is implemented using the entity pattern.
* The solution is implemented using the domain event pattern.
* The solution is implemented using the domain service pattern.
* The solution is implemented using the application service pattern.
* The solution is implemented using the domain exception pattern.
* The solution is implemented using the domain model pattern.
* The solution is implemented using the specification pattern.
* The solution is implemented using the mediator pattern.
* The solution is implemented using the observer pattern.
* The solution is implemented using the template method pattern.
* The solution is implemented using the state pattern.
* The solution is implemented using the decorator pattern.
* The solution is implemented using the proxy pattern.
* The solution is implemented using the adapter pattern.
* The solution is implemented using the bridge pattern.
* The solution is implemented using the composite pattern.
* The solution is implemented using the facade pattern.
* The solution is implemented using the flyweight pattern.
* The solution is implemented using the interpreter pattern.
* The solution is implemented using the iterator pattern.
* The solution is implemented using the memento pattern.
* The solution is implemented using the prototype pattern.
* The solution is implemented using the visitor pattern.

### Design Decisions
* The solution is implemented using the hexagonal architecture pattern to separate the domain logic from the infrastructure and application layers.
* The solution is implemented using the domain-driven design approach to focus on the core domain logic and business rules.
* The solution is implemented using the test-driven development approach to ensure that the core business logic is well-tested and maintainable.
* The solution is implemented using the dependency injection pattern to decouple the implementation details from the domain logic.
* The solution is implemented using the command pattern to encapsulate the business logic in reusable and testable units.
* The solution is implemented using the factory pattern to create complex objects without exposing the creation logic to the client code.
* The solution is implemented using the strategy pattern to define a family of algorithms, encapsulate each one, and make them interchangeable.
* The solution is implemented using the repository pattern to abstract the data access layer and provide a consistent interface for data operations.
* The solution is implemented using the unit of work pattern to manage database transactions and ensure data consistency.
* The solution is implemented using the aggregate pattern to group related entities and value objects into a single unit of consistency.
* The solution is implemented using the value object pattern to represent immutable objects that are defined by their attributes rather than their identity.
* The solution is implemented using the entity pattern to represent mutable objects that have a unique identity and can change over time.
* The solution is implemented using the domain event pattern to capture and communicate significant changes in the domain.
* The solution is implemented using the domain service pattern to encapsulate complex business logic that doesn’t naturally fit within a single entity or value object.
* The solution is implemented using the application service pattern to coordinate and orchestrate the execution of use cases across multiple aggregates and domain services.
* The solution is implemented using the domain exception pattern to represent and handle domain-specific errors and exceptional conditions.
* The solution is implemented using the domain model pattern to create a rich, behaviorally-complete representation of the domain.
* The solution is implemented using the specification pattern to encapsulate business rules and criteria in separate objects.
* The solution is implemented using the mediator pattern to reduce dependencies between objects by having them communicate indirectly through a mediator object.
* The solution is implemented using the observer pattern to define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
* The solution is implemented using the template method pattern to define the skeleton of an algorithm in an operation, deferring some steps to subclasses.
* The solution is implemented using the state pattern to allow an object to alter its behavior when its internal state changes.
* The solution is implemented using the decorator pattern to attach additional responsibilities to an object dynamically.
* The solution is implemented using the proxy pattern to provide a surrogate or placeholder for another object to control access to it.
* The solution is implemented using the adapter pattern to allow incompatible interfaces to work together.
* The solution is implemented using the bridge pattern to decouple an abstraction from its implementation so that the two can vary independently.
* The solution is implemented using the composite pattern to compose objects into tree structures to represent part-whole hierarchies.
* The solution is implemented using the facade pattern to provide a unified interface to a set of interfaces in a subsystem.
* The solution is implemented using the flyweight pattern to use sharing to support large numbers of fine-grained objects efficiently.
* The solution is implemented using the interpreter pattern to define a representation for a language’s grammar along with an interpreter that uses the representation to interpret sentences in the language.
* The solution is implemented using the iterator pattern to provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
* The solution is implemented using the memento pattern to capture and externalize an object’s internal state so that the object can be restored to this state later.
* The solution is implemented using the prototype pattern to specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.
* The solution is implemented using the visitor pattern to represent an operation to be performed on the elements of an object structure.

### Running the Code and Tests
* To run the code, you need to have Python 3.10 installed on your machine.
* To run the tests, you need to have pytest installed on your machine.
* To run the tests, run the following command in the root directory of the project:
« `
pytest
« `
* To run the code, you need to import the library and use the provided interfaces.

### Implementation Details
* The solution is implemented using the Python programming language.
* The solution is implemented using the pytest testing framework.
* The solution is implemented using the pydantic library for data validation and settings management.
* The solution is implemented using the dependency-injector library for dependency injection.
* The solution is implemented using the attrs library for creating classes with less boilerplate.
* The solution is implemented using the structlog library for structured logging.
* The solution is implemented using the mypy library for static type checking.
* The solution is implemented using the black library for code formatting.
* The solution is implemented using the isort library for import sorting.
* The solution is implemented using the flake8 library for code linting.
* The solution is implemented using the pylint library for code analysis.
* The solution is implemented using the bandit library for security linting.
* The solution is implemented using the safety library for dependency scanning.
* The solution is implemented using the pre-commit library for managing and maintaining multi-language pre-commit hooks.
* The solution is implemented using the poetry library for dependency management and packaging.
* The solution is implemented using the pyenv library for Python version management.
* The solution is implemented using the pyenv-virtualenv library for Python virtual environment management.
* The solution is implemented using the asdf library for version management of multiple runtime versions.
* The solution is implemented using the direnv library for environment variable management.
* The solution is implemented using the make library for task automation.

### Project Structure
* The project is structured using the hexagonal architecture pattern.
* The project is structured using the domain-driven design approach.
* The project is structured using the test-driven development approach.
* The project is structured using the dependency injection pattern.
* The project is structured using the command pattern.
* The project is structured using the factory pattern.
* The project is structured using the strategy pattern.
* The project is structured using the repository pattern.
* The project is structured using the unit of work pattern.
* The project is structured using the aggregate pattern.
* The project is structured using the value object pattern.
* The project is structured using the entity pattern.
* The project is structured using the domain event pattern.
* The project is structured using the domain service pattern.
* The project is structured using the application service pattern.
* The project is structured using the domain exception pattern.
* The project is structured using the domain model pattern.
* The project is structured using the specification pattern.
* The project is structured using the mediator pattern.
* The project is structured using the observer pattern.
* The project is structured using the template method pattern.
* The project is structured using the state pattern.
* The project is structured using the decorator pattern.
* The project is structured using the proxy pattern.
* The project is structured using the adapter pattern.
* The project is structured using the bridge pattern.
* The project is structured using the composite pattern.
* The project is structured using the facade pattern.
* The project is structured using the flyweight pattern.
* The project is structured using the interpreter pattern.
* The project is structured using the iterator pattern.
* The project is structured using the memento pattern.
* The project is structured using the prototype pattern.
* The project is structured using the visitor pattern.

### Project Structure
* The project is structured using the following directory structure:
« `
.
├── README.md
├── pyproject.toml
├── poetry.lock
├── .gitignore
├── .pre-commit-config.yaml
├── .pylintrc
├── .flake8
├── .mypy.ini
├── .bandit.yaml
├── .safety.yml
├── .coveragerc
├── .editorconfig
├── .env
├── .env.example
├── .python-version
├── .tool-versions
├── .envrc
├── Makefile
├── src
│ └── code_challenge
│ ├── __init__.py
│ ├── adapters
│ │ ├── __init__.py
│ │ ├── kyc
│ │ │ ├── __init__.py
│ │ │ └── third_party_kyc_provider.py
│ │ └── persistence
│ │ ├── __init__.py
│ │ └── account_repository.py
│ ├── application
│ │ ├── __init__.py
│ │ ├── commands
│ │ │ ├── __init__.py
│ │ │ └── register_account.py
│ │ ├── dtos
│ │ │ ├── __init__.py
│ │ │ └── account.py
│ │ └── services
│ │ ├── __init__.py
│ │ └── account_service.py
│ ├── domain
│ │ ├── __init__.py
│ │ ├── entities
│ │ │ ├── __init__.py
│ │ │ └── account.py
│ │ ├── events
│ │ │ ├── __init__.py
│ │ │ └── account_created.py
│ │ ├── exceptions
│ │ │ ├── __init__.py
│ │ │ └── account.py
│ │ ├── repositories
│ │ │ ├── __init__.py
│ │ │ └── account_repository.py
│ │ ├── services
│ │ │ ├── __init__.py
│ │ │ └── kyc_service.py
│ │ ├── value_objects
│ │ │ ├── __init__.py
│ │ │ ├── address.py
│ │ │ ├── age.py
│ │ │ ├── country.py
│ │ │ ├── date_of_birth.py
│ │ │ ├── email.py
│ │ │ ├── kyc_status.py
│ │ │ ├── name.py
│ │ │ └── password.py
│ │ └── specifications
│ │ ├── __init__.py
│ │ └── account_eligibility.py
│ └── infrastructure
│ ├── __init__.py
│ ├── config
│ │ ├── __init__.py
│ │ └── settings.py
│ ├── logging
│ │ ├── __init__.py
│ │ └── logger.py
│ └── persistence
│ ├── __init__.py
│ └── memory_account_repository.py
└── tests
├── __init__.py
├── conftest.py
├── integration
│ └── __init__.py
└── unit
├── __init__.py
├── application
│ ├── __init__.py
│ └── services
│ ├── __init__.py
│ └── test_account_service.py
└── domain
├── __init__.py
├── entities
│ ├── __init__.py
│ └── test_account.py
├── services
│ ├── __init__.py
│ └── test_kyc_service.py
└── value_objects
├── __init__.py
├── test_address.py
├── test_age.py
├── test_country.py
├── test_date_of_birth.py
├── test_email.py
├── test_kyc_status.py
├── test_name.py
└── test_password.py
« `

### Future Improvements
* Add more unit tests to cover edge cases and error handling.
* Implement integration tests to verify the interaction between different components.
* Implement a command-line interface for easier interaction with the library.
* Implement a web API for easier integration with other systems.
* Implement a database persistence layer for storing account information.
* Implement a caching layer for improved performance.
* Implement a message queue for handling asynchronous operations.
* Implement a logging system for better debugging and monitoring.
* Implement a metrics collection system for performance monitoring.
* Implement a tracing system for better observability.
* Implement a rate limiting system to prevent abuse.
* Implement a circuit breaker pattern for improved resilience.
* Implement a retry mechanism for handling transient failures.
* Implement a fallback mechanism for handling service outages.
* Implement a feature flag system for easier feature rollout and experimentation.
* Implement a versioning system for API compatibility.
* Implement a documentation generation system for easier API exploration.
* Implement a schema validation system for API requests and responses.
* Implement a data migration system for handling database schema changes.
* Implement a data seeding system for easier testing and development.
* Implement a data anonymization system for handling sensitive information.
* Implement a data encryption system for improved security.
* Implement a data backup and restore system for disaster recovery.
* Implement a data archiving system for handling historical data.
* Implement a data purging system for handling data retention policies.
* Implement a data export system for easier data portability.
* Implement a data import system for easier data migration.
* Implement a data validation system for ensuring data integrity.
* Implement a data transformation system for handling data format changes.
* Implement a data enrichment system for adding additional context to data.
* Implement a data deduplication system for handling duplicate data.
* Implement a data cleansing system for handling data quality issues.
* Implement a data profiling system for understanding data characteristics.
* Implement a data lineage system for tracking data origins and transformations.
* Implement a data governance system for managing data access and usage.
* Implement a data catalog system for easier data discovery and exploration.
* Implement a data dictionary system for documenting data structures and meanings.
* Implement a data quality monitoring system for detecting and alerting on data issues.
* Implement a data versioning system for tracking changes to data over time.
* Implement a data masking system for protecting sensitive information during testing and development.
* Implement a data tokenization system for handling sensitive information in production.
* Implement a data classification system for categorizing data based on sensitivity and importance.
* Implement a data retention system for managing data lifecycle and compliance requirements.
* Implement a data access control system for managing data access permissions.
* Implement a data audit system for tracking data access and modifications.
* Implement a data privacy system for handling personal information in compliance with regulations.
* Implement a data consent management system for handling user preferences and permissions.
* Implement a data subject access request system for handling user data requests.
* Implement a data breach notification system for handling security incidents.
* Implement a data residency system for handling data location requirements.
* Implement a data sovereignty system for handling data jurisdiction requirements.
* Implement a data sharing agreement system for managing data exchange between parties.
* Implement a data usage tracking system for understanding how data is being used.
* Implement a data quality scoring system for assessing data reliability and completeness.
* Implement a data reconciliation system for ensuring data consistency across systems.
* Implement a data synchronization system for keeping data up-to-date across systems.
* Implement a data replication system for improving data availability and performance.
* Implement a data partitioning system for improving data scalability and performance.
* Implement a data sharding system for distributing data across multiple servers.
* Implement a data caching system for improving data access performance.
* Implement a data compression system for reducing data storage and transfer costs.
* Implement a data deduplication system for reducing data storage costs.
* Implement a data archiving system for managing historical data.
* Implement a data lifecycle management system for automating data handling processes.
* Implement a data catalog system for documenting and discovering data assets.
* Implement a data lineage system for tracking data transformations and dependencies.
* Implement a data governance system for managing data policies and procedures.
* Implement a data stewardship system for assigning responsibility for data quality and management.
* Implement a data quality management system for monitoring and improving data quality.
* Implement a data integration system for combining data from multiple sources.
* Implement a data transformation system for converting data between formats and structures.
* Implement a data enrichment system for adding value to existing data.
* Implement a data cleansing system for correcting and standardizing data.
* Implement a data profiling system for analyzing data characteristics and patterns.
* Implement a data matching system for identifying and linking related data records.
* Implement a data deduplication system for identifying and removing duplicate data.
* Implement a data validation system for ensuring data meets specified criteria.
* Implement a data quality scoring system for assessing overall data quality.
* Implement a data monitoring system for detecting and alerting on data issues.
* Implement a data remediation system for correcting data quality issues.
* Implement a data quality reporting system for communicating data quality metrics.
* Implement a data quality dashboard system for visualizing data quality trends.
* Implement a data quality SLA system for setting and tracking data quality targets.
* Implement a data quality certification system for verifying data meets quality standards.
* Implement a data quality training system for educating users on data quality best practices.
* Implement a data quality workflow system for managing data quality processes.
* Implement a data quality automation system for streamlining data quality tasks.
* Implement a data quality rules engine for defining and enforcing data quality rules.
* Implement a data quality exception handling system for managing data quality issues.
* Implement a data quality issue tracking system for managing data quality problems.
* Implement a data quality root cause analysis system for identifying sources of data quality issues.
* Implement a data quality impact analysis system for assessing the effects of data quality problems.
* Implement a data quality improvement planning system for prioritizing data quality initiatives.
* Implement a data quality metadata management system for documenting data quality attributes.
* Implement a data quality metrics system for measuring and tracking data quality.
* Implement a data quality benchmarking system for comparing data quality across systems or organizations.
* Implement a data quality assessment system for evaluating overall data quality.
* Implement a data quality audit system for verifying compliance with data quality standards.
* Implement a data quality certification system for validating data quality processes and results.
* Implement a data quality maturity model for assessing and improving data quality capabilities.
* Implement a data quality governance framework for managing data quality across the organization.
* Implement a data quality center of excellence for promoting data quality best practices.
* Implement a data quality community of practice for sharing knowledge and experiences.
* Implement a data quality training program for educating staff on data quality principles and practices.
* Implement a data quality awareness campaign for promoting the importance of data quality.
* Implement a data quality incentive program for encouraging data quality improvements.
* Implement a data quality recognition program for acknowledging data quality achievements.
* Implement a data quality communication plan for sharing data quality information and updates.
* Implement a data quality change management process for managing data quality-related changes.
* Implement a data quality risk management process for identifying and mitigating data quality risks.
* Implement a data quality disaster recovery plan for handling major data quality incidents.
* Implement a data quality continuous improvement process for ongoing data quality enhancements.
* Implement a data quality feedback loop for gathering and acting on data quality feedback.
* Implement a data quality knowledge base for documenting data quality issues and solutions.
* Implement a data quality community forum for discussing data quality topics and challenges.
* Implement a data quality suggestion box for collecting ideas for data quality improvements.
* Implement a data quality innovation lab for experimenting with new data quality techniques and technologies.
* Implement a data quality hackathon for collaboratively solving data quality challenges.
* Implement a data quality mentoring program for supporting data quality skill development.
* Implement a data quality certification program for recognizing data quality expertise.
* Implement a data quality career path for developing data quality professionals.
* Implement a data quality job rotation program for cross-training in data quality roles.
* Implement a data quality internship program for developing future data quality talent.
* Implement a data quality partnership program for collaborating with external organizations on data quality initiatives.
* Implement a data quality vendor management process for managing relationships with data quality tool and service providers.
* Implement a data quality technology roadmap for planning future data quality technology investments.
* Implement a data quality tool evaluation process for selecting and implementing data quality tools.
* Implement a data quality tool integration strategy for connecting data quality tools with other systems.
* Implement a data quality automation strategy for increasing efficiency and consistency in data quality processes.
* Implement a data quality artificial intelligence strategy for leveraging AI in data quality management.
* Implement a data quality machine learning strategy for improving data quality through automated learning.
* Implement a data quality blockchain strategy for ensuring data integrity and traceability.
* Implement a data quality cloud strategy for leveraging cloud technologies in data quality management.
* Implement a data quality edge computing strategy for managing data quality in distributed environments.
* Implement a data quality IoT strategy for ensuring quality of data from Internet of Things devices.
* Implement a data quality big data strategy for managing quality in large-scale data environments.
* Implement a data quality data lake strategy for maintaining quality in diverse data repositories.
* Implement a data quality data warehouse strategy for ensuring quality in