minos-framework/minos-python
47.2
Weak · 10 November 2026
24.7k
lines of production code
Python
primary language
8
measurements over time
What this system is
This system is the Minos Framework, a Python library for building event-driven microservices. It provides core abstractions for implementing the CQRS and Saga patterns, including aggregate management, event sourcing, and distributed transaction coordination. The framework supports multiple database backends and message brokers through a plugin architecture, while offering tools for service discovery, HTTP networking, and automated API documentation.
Features
Add AIOPG-specific database operation factories for locks and management
The aiopg plugin now includes specific factory implementations for database locking and management operations. The new \AiopgLockDatabaseOperationFactory\ enables distributed locking via PostgreSQL advisory locks (\pg\_advisory\_lock\/\pg\_advisory\_unlock\), while \AiopgManagementDatabaseOperationFactory\ allows creating and dropping databases using standard SQL commands. These factories are registered with the \AiopgDatabaseClient\ to handle these specific database operations.
packages/plugins/minos-database-aiopg/minos/plugins/aiopg/factories/common · high confidence
Add HTTP and REST enroute decorator definitions
The \minos.networks.decorators.definitions.http\ module is introduced, providing base and specialized classes for HTTP-based routing. \HttpEnrouteDecorator\ serves as the base class, accepting \path\ and \method\ arguments (with a deprecation warning for the legacy \url\ argument). It is extended by \RestEnrouteDecorator\, which is further specialized into \RestCommandEnrouteDecorator\ and \RestQueryEnrouteDecorator\ to distinguish between command and query operations via the \EnrouteDecoratorKind\.
packages/core/minos-microservice-networks/minos/networks/decorators/definitions/http · high confidence
Add InMemoryDiscoveryClient for service discovery
A new InMemoryDiscoveryClient is now available in the minos.networks.discovery.clients module, providing an in-memory implementation of the DiscoveryClient interface. This allows users to perform service discovery operations without relying on external infrastructure, which is particularly useful for testing or lightweight deployments.
packages/core/minos-microservice-networks/minos/networks/discovery/clients · high confidence
Add PostgreSQL-backed database operation factories for broker queues and duplicate validation
This change introduces a new set of factory classes within the \minos.plugins.aiopg.factories.networks\ module that implement database operations for message broker queues and subscriber duplicate detection using PostgreSQL via \aiopg\. Specifically, it adds \AiopgBrokerQueueDatabaseOperationFactory\ to manage queue table lifecycle (create, mark processed, delete, mark processing, count, submit, query) and its specialized implementations for publishers (\AiopgBrokerPublisherQueueDatabaseOperationFactory\) and subscribers (\AiopgBrokerSubscriberQueueDatabaseOperationFactory\). It also adds \AiopgBrokerSubscriberDuplicateValidatorDatabaseOperationFactory\ to handle the \broker\_subscriber\_processed\_messages\ table for tracking processed message UUIDs. These factories are registered with \AiopgDatabaseClient.set\_factory\ to enable PostgreSQL-backed persistence for network broker components.
packages/plugins/minos-database-aiopg/minos/plugins/aiopg/factories/networks · high confidence
Add aiopg database operation factories for aggregates
This change introduces the \minos.plugins.aiopg.factories.aggregate\ module, providing PostgreSQL-specific database operation factories for the Minos aggregate root. It adds \AiopgEventDatabaseOperationFactory\ to manage the \aggregate\_event\ table (including the \action\_type\ enum and event submission logic), \AiopgSnapshotDatabaseOperationFactory\ to handle the \snapshot\ and \snapshot\_aux\_offset\ tables for entity state persistence, and \AiopgTransactionDatabaseOperationFactory\ to manage the \aggregate\_transaction\ table with its \transaction\_status\ enum. These components enable the aiopg plugin to perform CRUD operations on aggregate events, snapshots, and transaction states using async PostgreSQL.
packages/plugins/minos-database-aiopg/minos/plugins/aiopg/factories/aggregate · high confidence
Add binary protocol implementations for Avro and JSON
The \minos.common.protocol\ module now provides concrete binary encoding and decoding capabilities alongside its abstract interface. It introduces \MinosAvroProtocol\ for serializing data using the Avro format, with specialized subclasses \MinosAvroDatabaseProtocol\ for storing database values and \MinosAvroMessageProtocol\ for handling message headers and bodies. Additionally, \MinosJsonBinaryProtocol\ is added to support JSON-based binary serialization using the \orjson\ library, allowing users to encode and decode data to and from bytes.
packages/core/minos-microservice-common/minos/common/protocol · high confidence
Added AsyncAPI and OpenAPI specification generation services
New services have been added to the \minos.networks.specs\ module to automatically generate API specifications. The \AsyncAPIService\ exposes a \/spec/asyncapi\ endpoint that produces an AsyncAPI 2.3.0 document based on detected broker events, while the \OpenAPIService\ exposes a \/spec/openapi\ endpoint that generates an OpenAPI 3.0.0 document based on registered REST commands and queries.
packages/core/minos-microservice-networks/minos/networks/specs · high confidence
Added cart query microservice for reading cart state
This change introduces a new read-side component for the cart microservice, enabling users to retrieve cart details and items via REST endpoints. The implementation includes SQLAlchemy models for Cart, CartItem, and Product, a repository layer for PostgreSQL persistence, and a query service that exposes GET /cart/{uuid} and GET /cart/{uuid}/items. It also listens to domain events (CartCreated, CartUpdated) to keep the query store synchronized with the write model.
tutorials/eboutique/microservices/cart/src/queries · high confidence
Added checkout and currency microservice scaffolding
New microservice skeletons for 'checkout' and 'currency' have been added to the tutorial, providing the foundational structure for these domain services. The checkout service includes a command service to create checkout instances via REST and broker, along with a query repository setup for PostgreSQL, though the query service itself is currently a placeholder. The currency service implements a command handler that fetches exchange rates from the ECB and converts amounts, while its query service remains unimplemented. Both services include CLI entry points and aggregate definitions.
tutorials/eboutique/microservices/checkout, tutorials/eboutique/microservices/currency · high confidence
Added crypto microservice for stock-wallet tutorial
A new 'crypto' microservice has been added to the stock-wallet tutorial. It implements a Minos-based architecture with a Crypto aggregate, command service, and query service. The service periodically crawls crypto prices from Kraken using the ccxt library and publishes quote updates to a Kafka broker. It is configured to run via Docker Compose with PostgreSQL and Redis dependencies.
tutorials/stock-wallet/microservices/crypto · high confidence
Added external infrastructure for the stock-wallet tutorial
This change introduces the external service dependencies required to run the stock-wallet tutorial, including an API gateway (using minos-apigateway), a service discovery component (using minos-discovery), and a PostgreSQL database setup. The database initialization script creates specific schemas for the wallet, stocks, and crypto domains, enabling the tutorial's microservices to operate with their necessary backend services.
tutorials/stock-wallet/external · high confidence
Added shipping microservice with quote calculation logic
The tutorials/eboutique/microservices/shipping location now contains a new shipping microservice built on the Minos framework. It exposes a broker command, GetShippingQuote, which calculates a shipping price based on the distance from Madrid to a destination (resolved via geocoding) and applies a surcharge if the item count exceeds two. The service also includes an aggregate structure for Shipping, a CLI entry point for launching the service, and a query service that currently stubs out REST retrieval but listens for ShippingCreated, ShippingUpdated, and ShippingDeleted events.
tutorials/eboutique/microservices/shipping · high confidence
Added stocks microservice for crawling
A new stocks microservice has been added to the tutorial, providing the core logic for stock data crawling. This includes a Stocks aggregate with methods to add tickers, update timestamps, and retrieve all tickers, along with CLI commands to start the service using a configuration file.
tutorials/stock-wallet/microservices/stocks/src · high confidence
Added the Notifier microservice with email sending and event handling capabilities
This change introduces the Notifier microservice within the eboutique tutorial, providing a new component for handling notifications. The service includes a command handler that sends email notifications via SMTP (configured for Gmail) when receiving a 'SendEmailNotification' command, and a query service that listens for aggregate lifecycle events (NotifierCreated, NotifierUpdated, NotNotifierDeleted) to log changes. It also sets up a PostgreSQL repository for query operations and exposes a CLI for launching the microservice.
tutorials/eboutique/microservices/notifier · high confidence
Cart microservice command handling and saga integration
The cart microservice now exposes REST endpoints for creating a new cart and adding items to an existing cart. The 'Create Cart' endpoint accepts a POST request to /cart to initialize a new cart instance. The 'Add Item' endpoint accepts a POST request to /cart/{uuid}/item, which triggers a saga process (ADD\_CART\_ITEM) to handle the item addition logic, returning the updated cart on success or raising an error if the saga fails.
tutorials/eboutique/microservices/cart/src/commands · high confidence
Initial cart microservice implementation with saga-based item addition
This change introduces the initial structure for the cart microservice within the eboutique tutorial. It defines the core data models (Cart, CartItem, Product) and provides basic aggregate operations for creating a cart and adding items. Additionally, it implements a CLI entry point for starting the service and includes a Saga pattern implementation (\ADD\_CART\_ITEM\) that validates product existence via a remote request before committing the item to the cart.
tutorials/eboutique/microservices/cart/src · high confidence
Initial eboutique tutorial scaffolding
Added the initial scaffolding for the 'eboutique' tutorial project, providing a complete microservices-based online boutique example. This includes a docker-compose configuration to orchestrate services (product, cart, checkout, currency, payment, shipping, notifier) alongside infrastructure components (PostgreSQL, Kafka, Redis, Minos API Gateway, and Discovery). The diff also introduces the project structure with configuration files, Dockerfiles, and initial test suites for the cart and checkout microservices.
tutorials/eboutique · high confidence
Initial product microservice scaffolding with CQRS and read/write separation
This change introduces the initial structure for the product microservice within the tutorial. It implements a Command-Query Responsibility Segregation (CQRS) pattern: the command side exposes REST endpoints (POST /product, DELETE /product/{uuid}) and broker commands to create and delete products, while the query side provides read-only REST endpoints (GET /products, GET /product/{uuid}) backed by a SQLAlchemy-based PostgreSQL repository. The service also listens for domain events (ProductCreated, ProductUpdated, ProductDeleted) to keep the read model in sync, and includes a CLI entry point for launching the microservice.
tutorials/eboutique/microservices/product · high confidence
Initial query-side scaffolding for the stocks microservice
This change introduces the foundational query components for the new stocks microservice within the tutorial application. It adds a SQLAlchemy-based repository (\StocksQueryServiceRepository\) configured to connect to a PostgreSQL database (\stocks\_query\_db\) and a CQRS query service (\StocksQueryService\) that exposes a REST endpoint at \/stockss\. The query service is currently a stub returning a 'Not implemented yet' exception, with event handlers for stock creation, update, and deletion commented out, indicating this is the initial structural setup for the read model.
tutorials/stock-wallet/microservices/stocks/src/queries · high confidence
Initial release of the Kong discovery plugin
This change introduces the \minos-discovery-kong\ plugin (v0.7.0), enabling service discovery and routing integration with Kong. The plugin provides a \KongClient\ to manage services, routes, and consumers (supporting Basic Auth, JWT, and ACL configurations) via the Kong Admin API. It includes a \KongDiscoveryClient\ that implements the Minos discovery interface, automatically registering microservices and their endpoints in Kong while handling circuit breaking. Additionally, a middleware is provided to extract user identity from Kong's \X-Consumer-Custom-ID\ header and inject it into the Minos request context.
packages/plugins/minos-discovery-kong/minos/plugins/kong · high confidence
Initial wallet microservice implementation
This change introduces the core structure for the wallet microservice within the stock-wallet tutorial. It defines the data model with a \Wallet\ root entity and \Ticker\ entity, implements the \WalletAggregate\ to handle creating wallets and adding tickers, and exposes REST endpoints (\POST /wallet\ and \POST /wallet/ticker\) via \WalletCommandService\ for managing these operations. A CLI entry point is also provided to launch the service using a configuration file.
tutorials/stock-wallet/microservices/wallet/src · high confidence
Introduce Avro serialization for Minos models
The \minos/common/model/serializers\ module now provides a complete Avro serialization implementation. This adds abstract base classes for schema and data encoding/decoding, alongside concrete \AvroDataEncoder\, \AvroDataDecoder\, \AvroSchemaEncoder\, and \AvroSchemaDecoder\ classes. Users can now serialize Minos models and their fields to and from Avro-compatible data formats and schemas, supporting standard types (int, float, string, bool, bytes, UUID, datetime, date, time, timedelta) as well as complex structures like lists, sets, dicts, and nested models.
packages/core/minos-microservice-common/minos/common/model/serializers · high confidence
Introduce BrokerClient and BrokerClientPool for managed message handling
Users now have access to a new \BrokerClient\ class that encapsulates both publishing and subscribing to a specific topic, simplifying the API for sending and receiving messages. This client is designed to work with a new \BrokerClientPool\, which manages a pool of these clients and automatically handles the \REQUEST\_REPLY\_TOPIC\ context variable during acquisition, ensuring correct routing for request-reply patterns. The pool leverages the generic \Pool\ base class and integrates with the new \Inject\ decorator for dependency injection, replacing previous manual construction patterns.
packages/core/minos-microservice-networks/minos/networks/brokers · high confidence
Introduce GraphQL schema builder for Minos router
A new \builders\ module has been added to the Minos GraphQL plugin, introducing the \GraphQLSchemaBuilder\ class. This component automatically constructs a GraphQL schema from registered route decorators, mapping query and mutation endpoints to their corresponding GraphQL fields. It handles the adaptation of internal request-response callbacks into the GraphQL execution structure and ensures schema validity by adding a dummy query field when no queries are defined.
packages/plugins/minos-router-graphql/minos/plugins/graphql/builders · high confidence
Introduce LMDB database plugin for Minos
This change adds the \minos-database-lmdb\ package, providing an LMDB-backed implementation of the Minos database client. Users can now use \LmdbDatabaseClient\ to persist saga execution states and other data using the LMDB embedded database, with support for create, read, update, and delete operations via \LmdbDatabaseOperation\. The plugin includes \LmdbSagaExecutionDatabaseOperationFactory\ to handle saga-specific storage logic, registering itself as the factory for saga execution operations.
packages/plugins/minos-database-lmdb/minos/plugins/lmdb, packages/plugins/minos-router-graphql/minos/plugins/graphql · high confidence
Introduce Minos Saga pattern implementation (v0.7.0)
This release adds the core SAGA pattern implementation for the Minos Framework, introducing the \minos.saga\ module. Users can now define distributed transactions using \Saga\ definitions with local and remote steps, managed by the \SagaManager\. The module includes a \SagaContext\ for state management, specific exception types for execution failures, and executors (\LocalExecutor\, \RequestExecutor\, \ResponseExecutor\) to handle step execution and broker communication. It also provides a \SagaService\ for handling replies and a \transactional\_command\ middleware to ensure transactional consistency for commands originating from sagas.
packages/core/minos-microservice-saga/minos/saga · high confidence
Introduce MinosDiscoveryClient with circuit breaker support
The minos-discovery plugin now provides a MinosDiscoveryClient that handles service discovery subscriptions and unsubscriptions via HTTP POST and DELETE requests. This client integrates a CircuitBreakerMixin to improve resilience against transient failures during network calls, defaulting to localhost:5567 for the discovery service endpoint.
_packages/plugins/minos-discovery-minos/minos/plugins/minos\discovery · high confidence
Introduce RabbitMQ broker plugin for message publishing and subscribing
The Minos Framework now includes a new RabbitMQ broker plugin (version 0.7.0) that enables asynchronous message communication via RabbitMQ. This update adds the \RabbitMQBrokerPublisher\ and \RabbitMQBrokerSubscriber\ components, allowing users to publish messages to and subscribe from RabbitMQ queues. The plugin supports configuration of connection details (host, port, user, password) through the standard Minos Config system, with sensible defaults (localhost, port 5672, guest/guest) if not specified.
packages/plugins/minos-broker-rabbitmq/minos/plugins/rabbitmq · high confidence
Introduce Ref, RefExtractor, RefInjector, and RefResolver for model reference handling
This change introduces a new module for managing model references within the aggregate layer. It adds the \Ref\ class, which acts as a generic wrapper for model identifiers (UUIDs) or resolved model instances, supporting attribute and item access that transparently delegates to the underlying data when resolved. To support this, \RefExtractor\ is added to traverse data structures and collect unresolved \Ref\ instances, while \RefInjector\ replaces those references with actual model instances using a provided UUID-to-model mapper. Finally, \RefResolver\ orchestrates the resolution process by extracting references, querying a broker pool via generated topic names (e.g., \\_Get{name}Snapshots\), and injecting the results, utilizing \PoolFactory\ for broker pool management.
packages/core/minos-microservice-aggregate/minos/aggregate/entities/refs · high confidence
Introduce abstract transaction repository with in-memory implementation
The transaction repository layer now exposes an abstract base class, \TransactionRepository\, which enforces dependency injection for lock management via \LockPool\ and \PoolFactory\. This abstraction is implemented by \InMemoryTransactionRepository\, providing a concrete, in-memory storage solution that validates transaction status transitions (e.g., preventing invalid moves from PENDING to COMMITTED) and supports filtering queries by UUID, status, event offset, and timestamps.
packages/core/minos-microservice-aggregate/minos/aggregate/transactions/repositories · high confidence
Introduce aiopg plugin with circuit breaker and connection recovery
The new \minos-database-aiopg\ plugin provides an \AiopgDatabaseClient\ that integrates with the framework's \CircuitBreakerMixin\ to automatically handle PostgreSQL connection failures. This change introduces automatic connection recreation during outages, ensuring that database operations can recover without manual intervention. The plugin also exports a suite of database operation factories for aggregates, snapshots, locks, and broker queues, enabling the use of aiopg as the underlying database driver for these core Minos components.
packages/plugins/minos-database-aiopg/minos/plugins/aiopg · high confidence
Introduce core microservice components for dynamic models, network callables, and saga steps
This release adds foundational building blocks across three core packages. In \minos-microservice-common\, it introduces the \dynamic\ model module, providing \DynamicModel\, \BucketModel\, and \DataTransferObject\ classes that allow entities to be constructed dynamically from type hints and field definitions. In \minos-microservice-networks\, it adds the \decorators.callables\ module, implementing \Checker\ and \Handler\ wrappers with retry logic (via \CheckerMeta\) and request/response handling (via \HandlerMeta\) to manage network call execution and validation. In \minos-microservice-saga\, it adds the \executions.steps\ module, defining the execution lifecycle for saga steps through \SagaStepExecution\ and its concrete implementations: \LocalSagaStepExecution\ for local operations, \RemoteSagaStepExecution\ for inter-service communication with success/error handling, and \ConditionalSagaStepExecution\ for branching logic based on conditions.
packages/core/minos-microservice-common/minos/common/model/dynamic, packages/core/minos-microservice-networks/minos/networks/decorators/callables, packages/core/minos-microservice-saga/minos/saga/executions/steps · high confidence
Introduce core type-hint resolution and comparison utilities
This change adds a new \minos.common.model.types\ module providing the foundational infrastructure for handling Python type hints within the Minos framework. It introduces \ModelType\ as a metaclass for representing model schemas, \TypeHintBuilder\ and \TypeHintParser\ for constructing and resolving dynamic type hints, and \TypeHintComparator\ for validating type compatibility. The implementation includes \GenericTypeProjector\ to resolve generic type variables and leverages \lru\_cache\ for performance optimization in type building and comparison operations.
packages/core/minos-microservice-common/minos/common/model/types · high confidence
Introduce extensible BrokerPublisher with builder pattern and in-memory implementation
The publisher subsystem has been restructured to provide a new abstract \BrokerPublisher\ base class and a \BrokerPublisherBuilder\ that allows users to configure and construct publisher instances, including support for optional queuing via \BrokerPublisherQueue\. An \InMemoryBrokerPublisher\ implementation is now available for testing or lightweight scenarios, capturing sent messages in a list for inspection. This change establishes the foundation for pluggable publisher backends while maintaining a consistent builder-based configuration API.
packages/core/minos-microservice-networks/minos/networks/brokers/publishers · high confidence
Introduce extensible database locking mechanism
This change introduces a new database locking implementation within the \locks\ module, providing a \DatabaseLock\ class that manages lock acquisition and release via a pluggable \LockDatabaseOperationFactory\. Users can now utilize this factory pattern to customize how database operations are constructed for locking, allowing for flexible integration with different database backends while maintaining a consistent \Lock\ interface.
packages/core/minos-microservice-common/minos/common/database/locks · high confidence
Introduce filtered broker subscriber with pluggable duplicate validation
The \minos-microservice-networks\ package now includes a \FilteredBrokerSubscriber\ that wraps an existing subscriber to filter out duplicate messages before processing. This component uses a pluggable \BrokerSubscriberValidator\ strategy, providing two built-in implementations: \InMemoryBrokerSubscriberDuplicateValidator\ for simple, in-memory deduplication and \DatabaseBrokerSubscriberDuplicateValidator\ for persistent deduplication backed by a database (using a configurable \database\_key\, defaulting to \broker\). Users can now ensure idempotent message handling by injecting the appropriate validator into the filtered subscriber.
packages/core/minos-microservice-networks/minos/networks/brokers/subscribers/filtered · high confidence
Introduce new HTTP networking module with connector and port abstractions
A new \minos.networks.http\ module has been added, providing the \HttpConnector\, \HttpAdapter\, \HttpPort\, and request/response classes (\HttpRequest\, \HttpResponse\). This introduces a structured abstraction for handling HTTP traffic, including route mounting, callback adaptation, and concurrency limiting via a semaphore. The \RestService\ class is now deprecated in favor of \HttpPort\.
packages/core/minos-microservice-networks/minos/networks/http · high confidence
Introduce new dependency injection system
A new dependency injection system is now available in the \minos.common.injections\ module, providing the \InjectableMixin\ base class, \Injectable\ and \Inject\ decorators, and a \DependencyInjector\ to manage the lifecycle of injected components. This allows users to declaratively define injectable dependencies and automatically resolve them in functions or classes, replacing the previous manual or external wiring approaches.
packages/core/minos-microservice-common/minos/common/injections · high confidence
Introduce periodic task scheduling with CronTab and PeriodicPort
The scheduling module now provides a new capability for executing periodic tasks based on cron patterns. Users can define scheduled jobs using the new \CronTab\ class, which wraps the \crontab\ library to handle pattern matching and delay calculations. These tasks are managed by \PeriodicTaskScheduler\ and exposed via the \PeriodicPort\, which handles the lifecycle (start/stop) of the underlying scheduler. The module also introduces \ScheduledRequest\ and \ScheduledRequestContent\ to represent the context passed to scheduled functions, and deprecates the legacy \PeriodicTaskSchedulerService\ in favor of the new \PeriodicPort\.
packages/core/minos-microservice-networks/minos/networks/scheduling · high confidence
Introduce queued broker publisher with in-memory and database-backed queues
A new \QueuedBrokerPublisher\ implementation has been added to the broker networks module, enabling message publishing through an intermediate queue rather than directly to the broker. This publisher supports two queue backends: an \InMemoryBrokerPublisherQueue\ for lightweight, non-persistent buffering, and a \DatabaseBrokerPublisherQueue\ for durable storage, which includes a corresponding \BrokerPublisherQueueDatabaseOperationFactory\ for database schema management. This allows users to decouple message production from broker availability and ensure message persistence via the database.
packages/core/minos-microservice-networks/minos/networks/brokers/publishers/queued · high confidence
Introduce structured BrokerMessage models and queue abstractions
The broker subsystem now exposes a formal \BrokerMessage\ interface and a \BrokerMessageV1\ implementation, standardizing message properties such as topic, identifier, payload, status, and headers. This change also introduces a \BrokerQueue\ abstraction with concrete \InMemoryBrokerQueue\ and \DatabaseBrokerQueue\ implementations, allowing users to configure message storage backends. Additionally, context variables for request headers and reply topics are now available to support distributed tracing and request-reply patterns within the broker layer.
packages/core/minos-microservice-networks/minos/networks/brokers/collections · high confidence
Introduce structured enroute decorator definitions for broker, HTTP, and periodic routes
The \minos.networks.decorators.definitions\ module now provides a comprehensive set of decorator classes that define routing metadata for commands, queries, events, and periodic tasks. Users can now explicitly decorate handlers with \BrokerCommandEnrouteDecorator\, \BrokerQueryEnrouteDecorator\, \BrokerEventEnrouteDecorator\, \HttpEnrouteDecorator\, \RestCommandEnrouteDecorator\, \RestQueryEnrouteDecorator\, and \PeriodicEventEnrouteDecorator\. These decorators standardize how route information (such as topics, HTTP methods, or cron expressions) is attached to handler functions, enabling the framework to correctly identify and dispatch incoming requests or scheduled events based on the specific decorator type used.
packages/core/minos-microservice-networks/minos/networks/decorators/definitions · high confidence
Introduce versioned Config API with V1 and V2 implementations
The configuration system now supports multiple schema versions via a new \Config\ base class that dispatches to \ConfigV1\ or \ConfigV2\ based on the file's version field. \ConfigV1\ maintains the existing behavior for service metadata, REST/broker interfaces, and database connections, while \ConfigV2\ introduces a more structured approach with explicit \databases\, \interfaces\, \pools\, \routers\, \middleware\, and \services\ sections, allowing for more granular configuration of components like HTTP connectors, broker publishers/subscribers, and dependency injection targets. Users can now define their configuration files with a \version\ key to opt into the new V2 structure, which offers better separation of concerns and extensibility, while existing V1 configurations remain supported for backward compatibility.
packages/core/minos-microservice-common/minos/common/config · high confidence
Introduction of BrokerDispatcher for message routing and handling
The broker dispatcher subsystem has been implemented to handle incoming messages from the network. This change introduces the \BrokerDispatcher\ class, which routes messages to registered actions based on topics and manages the publishing of replies. It includes new request and response types (\BrokerRequest\, \BrokerResponse\, \BrokerResponseException\) tailored for broker interactions, and utilizes \EnrouteFactory\ to build handler decorators from configuration. Users will now have a concrete mechanism for dispatching broker messages and handling responses with proper context management for user tokens and headers.
packages/core/minos-microservice-networks/minos/networks/brokers/dispatchers · high confidence
Introduction of DiscoveryConnector for service registration
The \minos.networks.discovery\ module now exposes a \DiscoveryConnector\ class that handles the lifecycle of service discovery. This connector automatically subscribes to the discovery service upon setup and unsubscribes on teardown, using configuration to determine the client type, network endpoints, and service metadata. It also introduces an \InMemoryDiscoveryClient\ for local testing and reorganizes the public API to export \DiscoveryClient\ and \DiscoveryConnector\ directly from the discovery package.
packages/core/minos-microservice-networks/minos/networks/discovery · high confidence
Introduction of the Minos Model package with declarative and dynamic model support
The \minos.common.model\ package has been introduced, providing the core infrastructure for defining and managing data models within the Minos microservice framework. This change adds a \Model\ base class that supports serialization and deserialization via Avro, along with \DeclarativeModel\ (aliased as \MinosModel\) for defining models using Python type hints and \DynamicModel\ for runtime model creation. The package includes a \Field\ class that handles value parsing, validation, and type checking, ensuring data integrity when setting attributes. Additionally, it provides a suite of serializers and decoders (\AvroDataEncoder\, \AvroSchemaDecoder\, etc.) to convert between Python objects and Avro formats, enabling consistent data exchange across services.
packages/core/minos-microservice-common/minos/common/model · high confidence
Minos Aggregate module v0.7.0 release
The \minos.aggregate\ package has been updated to version 0.7.0, introducing a comprehensive set of core classes for the aggregate pattern. This release adds the \Aggregate\ service class for managing transactions, events, and snapshots, alongside new entity models like \RootEntity\, \ExternalEntity\, and \ValueObject\. It also introduces \IncrementalSet\ for tracking collection changes, a new \Action\ enum for CRUD operations, and expanded query capabilities with the \LIKE\ condition. The module exposes updated exception hierarchies (e.g., \NotFoundException\, \AlreadyDeletedException\) and repository interfaces (\EventRepository\, \SnapshotRepository\, \TransactionRepository\) to support these features.
packages/core/minos-microservice-aggregate/minos/aggregate · high confidence
New aiohttp HTTP plugin implementation
The \minos.plugins.aiohttp\ package has been introduced (renamed from \minos.plugins.rest\_aiohttp\) to provide an HTTP connector and request/response abstractions specifically for the aiohttp framework. This change adds \AioHttpConnector\, \AioHttpRequest\, \AioHttpResponse\, and \AioHttpResponseException\ classes, enabling users to integrate Minos microservices with aiohttp-based servers. The connector manages the aiohttp application lifecycle, including startup, shutdown timeouts, and route mounting, while the request/response classes handle content parsing (JSON, form, Avro, text, binary) and header/parameter extraction.
packages/plugins/minos-http-aiohttp/minos/plugins/aiohttp · high confidence
New decorator-based routing system with HTTP support
The \minos.networks.decorators\ module has been introduced to provide a new mechanism for defining and managing service routes. This change adds support for HTTP-based routing via the \HttpEnrouteDecorator\ and \RestEnroute\ classes, allowing services to expose REST commands and queries. It also introduces a factory pattern (\EnrouteFactory\) and collector (\EnrouteCollector\) to automatically discover, validate, and wrap decorated handler methods with middleware and pre/post hooks, replacing the previous implicit routing logic with an explicit, extensible decorator system.
packages/core/minos-microservice-networks/minos/networks/decorators · high confidence
New wallet query service with REST API and event-driven read model
A new query-side microservice has been added to the wallet tutorial, introducing a dedicated read model for wallets, tickers, and stock quotes. This service exposes REST endpoints (GET /wallets, /wallet/{uuid}, /wallet/{uuid}/tickers, and /wallet/{uuid}/ticker/{ticker\_uuid}/quotes) to retrieve wallet data and historical price quotes. It maintains its PostgreSQL database by listening to domain events (WalletCreated, WalletUpdated.tickers.create, and a custom QuotesChannel event) to keep the read model in sync with the command-side aggregates.
tutorials/stock-wallet/microservices/wallet/src/queries · high confidence
RootEntity now supports dependency injection and bulk retrieval methods
The \RootEntity\ class in the \entities\ module has been updated to use the \@Inject\ decorator for its \EventRepository\ and \SnapshotRepository\ dependencies, replacing previous internal warning mechanisms. Additionally, new class methods \get\_all\ and \find\ have been added to \RootEntity\, allowing users to retrieve multiple entity instances with optional ordering, limits, and conditions directly from the snapshot repository.
packages/core/minos-microservice-aggregate/minos/aggregate/entities · high confidence
Saga execution engine and transaction commit logic introduced
This change introduces the core saga execution engine located in \minos/saga/executions\. It adds the \SagaExecution\ class to manage saga lifecycles (created, running, paused, finished, errored) and step execution, along with \SagaStatus\ and \SagaStepStatus\ enums for tracking state. The \TransactionCommitter\ class handles the commit, reserve, and reject phases of saga transactions by publishing messages via a \BrokerClientPool\ (acquired through \PoolFactory\) and a \BrokerPublisher\. Additionally, repository interfaces (\SagaExecutionRepository\, \DatabaseSagaExecutionRepository\) and step execution classes (\LocalSagaStepExecution\, \RemoteSagaStepExecution\, etc.) are provided to support saga persistence and step invocation.
packages/core/minos-microservice-saga/minos/saga/executions · high confidence
Stocks microservice now fetches and publishes real-time price quotes
The stocks microservice now actively crawls external market data and publishes it to the system. A new \StocksCommandService\ listens for wallet updates to identify tracked tickers, then uses a scheduled job to fetch historical and current stock aggregates from the Polygon API. For each new data point, it publishes a \QuoteContent\ message to the \QuotesChannel\, making live stock values available to other parts of the application.
tutorials/stock-wallet/microservices/stocks/src/commands · high confidence
Removals
Removed top-level package metadata file
The top-level \minos/\_\init\\_.py\ file has been removed, eliminating the package's author, email, and version metadata definitions from the public interface.
minos · high confidence
Behavioural changes
Broker handler concurrency limit and deprecation of legacy service class
The broker handler now enforces a maximum concurrency of 5 concurrent message consumers by default, addressing previous unbounded concurrency issues. Additionally, the legacy \BrokerHandlerService\ class has been deprecated in favor of the new \BrokerPort\ class, which serves as the primary entry point for broker handling and extends the \Port\ base class.
packages/core/minos-microservice-networks/minos/networks/brokers/handlers · high confidence
CQRS services now skip reference resolution by default
The \PreEventHandler\ in the CQRS module now defaults \resolve\_references\ to \False\, meaning aggregate references are no longer automatically resolved during event handling unless explicitly enabled. This behavioral change is implemented in the new \minos/cqrs\ package structure (version 0.7.0), which introduces \CommandService\ and \QueryService\ base classes that utilize this handler, alongside updated exception classes like \MinosIllegalHandlingException\ to enforce command/query separation.
packages/core/minos-microservice-cqrs/minos · high confidence
Database layer refactored to support multiple databases and generic operation factories
The database module has been restructured to replace PostgreSQL-specific classes with generic, database-agnostic components. \PostgreSqlMinosDatabase\ is now \DatabaseMixin\, and \PostgreSqlLock\ is now \DatabaseLock\, allowing the library to support multiple database backends. The API now uses \DatabaseClientPool\ and \DatabaseLockPool\ for connection management, and introduces \DatabaseOperation\ and \DatabaseOperationFactory\ classes to allow users to register and execute custom database operations via a generic factory pattern. Method names have also been updated (e.g., \submit\_query\ to \execute\_on\_database\) to reflect this broader scope.
packages/core/minos-microservice-common/minos/common/database · high confidence
Database-agnostic transaction repository implementation
The PostgreSQL-specific transaction repository has been replaced with a generic \DatabaseTransactionRepository\ that relies on a \TransactionDatabaseOperationFactory\. This change decouples the transaction storage logic from the PostgreSQL driver, allowing the system to support multiple database backends by simply providing different operation factories, while maintaining the same transaction submission and querying capabilities for users.
packages/core/minos-microservice-aggregate/minos/aggregate/transactions/repositories/database · high confidence
Event repository refactored with new base class and in-memory implementation
The event repository module has been restructured to introduce a new abstract base class, \EventRepository\, which now handles core submission logic, validation, and transaction management using \LockPool\ and \PoolFactory\ for concurrency control. This change replaces the previous \AggregateDiff\ model with a unified \Event\ model and introduces \InMemoryEventRepository\ for testing or lightweight scenarios, while also exposing \DatabaseEventRepository\ and associated operation factories for database-backed storage. Users interacting with this module will now rely on the new \EventRepository\ interface and its concrete implementations rather than the older, removed PostgreSQL-specific classes.
packages/core/minos-microservice-aggregate/minos/aggregate/events/repositories · high confidence
Introduce HTTP status codes for responses and exceptions
The \Response\ and \ResponseException\ classes in the network requests module now support explicit HTTP status codes. \Response\ accepts a \status\ argument (defaulting to 200) and exposes it via a property, while \ResponseException\ defaults to status 400. This allows callers to specify custom status values when constructing responses or raising exceptions, enabling more precise HTTP status reporting in microservice interactions.
packages/core/minos-microservice-networks/minos/networks/requests · high confidence
Introduce abstract DatabaseClient with centralized locking and timeout management
The database client layer now features a new abstract \DatabaseClient\ base class that centralizes the management of database locks and operation timeouts, moving this responsibility away from specific implementations like \AiopgDatabaseClient\. This change introduces a factory registration system (\set\_factory\/\get\_factory\) to allow pluggable database operation implementations, alongside a new \DatabaseClientBuilder\ for construction. Additionally, the exception hierarchy has been refined with new specific exceptions (\ConnectionException\, \IntegrityException\, \ProgrammingException\) replacing previous generic error types to provide clearer error signaling for connection and programming issues.
packages/core/minos-microservice-common/minos/common/database/clients · high confidence
Introduce database-backed broker subscriber queue implementation
The database queue location now provides a concrete implementation for broker subscriber queues using a database backend. This change introduces \DatabaseBrokerSubscriberQueue\ and \DatabaseBrokerSubscriberQueueBuilder\, which leverage a new \BrokerSubscriberQueueDatabaseOperationFactory\ to construct database operations for counting and dequeuing messages. This replaces previous provider-specific logic (such as PostgreSQL-specific classes) with a generic, factory-driven approach that allows the queue behavior to be customized via database operations.
packages/core/minos-microservice-networks/minos/networks/brokers/subscribers/queued/queues/database · high confidence
Introduce modular broker subscriber architecture with in-memory and queued implementations
The broker subscriber logic has been restructured into a new modular package under \minos.networks.brokers.subscribers\, replacing the previous flat structure. This change introduces a core abstract base class (\BrokerSubscriber\) and a dedicated builder (\BrokerSubscriberBuilder\) that supports chaining for filtering and queuing behaviors. Specifically, it adds an \InMemoryBrokerSubscriber\ for testing or lightweight scenarios, as well as the foundational classes for queued and filtered (duplicate-validated) subscribers. Users interacting with this module will now import from the new \minos.networks.brokers.subscribers\ namespace, and the builder pattern allows configuring validators and queues via configuration or programmatic builders.
packages/core/minos-microservice-networks/minos/networks/brokers/subscribers · high confidence
Introduce structured queue implementations and builders
The queued subscriber queue subsystem has been reorganized into a dedicated \queues\ package, introducing abstract base classes (\BrokerSubscriberQueue\, \BrokerSubscriberQueueBuilder\) and concrete implementations for in-memory storage (\InMemoryBrokerSubscriberQueue\). This change establishes a standardized builder pattern for configuring queue topics and provides a clear extension point for future database-backed queue implementations, replacing the previous flat structure with a more modular architecture.
packages/core/minos-microservice-networks/minos/networks/brokers/subscribers/queued/queues · high confidence
Introduction of queued broker subscriber with deprecated builder
This change introduces the \QueuedBrokerSubscriber\ and its associated queue implementations (\InMemoryBrokerSubscriberQueue\, \DatabaseBrokerSubscriberQueue\) to the \minos.networks.brokers.subscribers.queued\ module, enabling message queuing between broker subscribers and their implementations. The existing \QueuedBrokerSubscriberBuilder\ is now deprecated in favor of using the standard \BrokerSubscriberBuilder\, although the new subscriber class remains available for direct instantiation or via the legacy builder for backward compatibility.
packages/core/minos-microservice-networks/minos/networks/brokers/subscribers/queued · high confidence
Kafka broker plugin v0.7.0 with circuit breaker and builder refactoring
The Kafka broker plugin has been updated to version 0.7.0, introducing a circuit breaker pattern to \KafkaBrokerPublisher\ and \KafkaBrokerSubscriber\ to improve resilience against Kafka connection errors. The plugin now exposes a new \KafkaCircuitBreakerMixin\ and \KafkaBrokerBuilderMixin\ in the common module, which are used by the publisher and subscriber builders. The subscriber implementation now correctly raises \StopAsyncIteration\ when the underlying \AIOKafkaConsumer\ raises a \ConsumerStoppedError\, ensuring proper iteration termination. Additionally, the builder classes have been refactored to support the new configuration API, and the plugin's public API is now cleanly exported via the \\_\init\\_.py\ module.
packages/plugins/minos-broker-kafka/minos/plugins/kafka · high confidence
Migrate to Poetry and unify pre-commit checks
The project has switched from \setup.py\/\setup.cfg\ to \poetry\ for dependency management and build configuration, removing legacy files like \MANIFEST.in\ and \bitbucket-pipelines.yml\. A new \.pre-commit-config.yaml\ is introduced to run per-package \make check\ targets for core and plugin modules (e.g., \minos-microservice-aggregate\, \minos-broker-kafka\, \minos-database-aiopg\). The \Makefile\ is simplified to use \poetry install\ and \poetry run\ for docs, and the license is changed from GPL-3.0 to MIT.
(repo-wide) · high confidence
Minos Framework networks module v0.7.0 release
The \minos.networks\ package has been updated to version 0.7.0, introducing a restructured public API and new system capabilities. This release adds a \SystemService\ that exposes a \/system/health\ REST endpoint for health checks, and introduces a new \routers\ module with specialized router classes (\HttpRouter\, \BrokerRouter\, \PeriodicRouter\) to manage routing logic. The public interface has been standardized with several renames: \BrokerSubscriberDuplicateDetector\ is now \BrokerSubscriberDuplicateValidator\, \IdempotentBrokerSubscriber\ is now \FilteredBrokerSubscriber\, \EnrouteBuilder\ is now \EnrouteFactory\, \EnrouteAnalyzer\ is now \EnrouteCollector\, \BrokerHandlerPort\ is now \BrokerPort\, \PeriodicTaskSchedulerPort\ is now \PeriodicPort\, and \HttpApplication\ is now \HttpConnector\. Additionally, new utility functions for host IP and name resolution have been added to the public exports.
packages/core/minos-microservice-networks/minos/networks · high confidence
Minos Framework v0.7.0: Core library restructuring and new capabilities
This release updates the \minos-microservice-common\ package to version 0.7.0, introducing a comprehensive set of architectural changes and new features. The core configuration API has been refactored with the introduction of \ConfigV1\ and \ConfigV2\ abstractions, while the \Builder\ class has been significantly improved with the addition of \BuildableMixin\ and \InjectableMixin\ to support dependency injection patterns. Database connectivity is now abstracted through generic \DatabaseMixin\, \DatabaseClient\, and \DatabaseLock\ classes, replacing previous PostgreSQL-specific implementations to support multiple database backends. The framework also adds a \CircuitBreakerMixin\ for resilience, a \PoolFactory\ for managing resource pools, and a \Port\ abstraction for service entry points. Additionally, the \EntrypointLauncher\ now supports external modules and packages, and several legacy classes like \MinosSetup\ and \MinosPool\ are deprecated in favor of \SetupMixin\ and \Pool\.
packages/core/minos-microservice-common/minos/common · high confidence
Refactor event repository to use a database-agnostic operation factory pattern
The database event repository implementation has been refactored to decouple database-specific logic from the core repository. The new \DatabaseEventRepository\ now relies on an \EventDatabaseOperationFactory\ to generate \DatabaseOperation\ instances for creating tables, submitting events, and querying data. This change replaces the previous direct PostgreSQL-specific classes with a generic interface, allowing the repository to support multiple database backends through different factory implementations while maintaining the same external API for event storage and retrieval.
packages/core/minos-microservice-aggregate/minos/aggregate/events/repositories/database · high confidence
Refactored SnapshotRepository with simplified database abstraction
The snapshot repository module has been restructured to simplify the database integration layer. The previous \DatabaseSnapshotReader\, \DatabaseSnapshotWriter\, and \DatabaseSnapshotSetup\ classes have been removed and replaced by a streamlined \DatabaseSnapshotRepository\ and \SnapshotDatabaseOperationFactory\. The core \SnapshotRepository\ abstract base class and its \InMemory\ implementation remain, providing a consistent interface for accessing \RootEntity\ instances via snapshots, but the underlying database wiring is now more direct.
packages/core/minos-microservice-aggregate/minos/aggregate/snapshots/repositories · high confidence
Refactored database snapshot repository with simplified module structure
The database snapshot repository implementation has been refactored to simplify the module hierarchy. The previous \DatabaseSnapshotReader\, \DatabaseSnapshotWriter\, and \DatabaseSnapshotSetup\ classes have been removed and replaced with a unified \DatabaseSnapshotRepository\ and a new \SnapshotDatabaseOperationFactory\. This change consolidates snapshot persistence logic, introduces dependency injection for event and transaction repositories, and standardizes database interaction methods (e.g., \execute\_on\_database\ instead of \submit\_query\).
packages/core/minos-microservice-aggregate/minos/aggregate/snapshots/repositories/database · high confidence
Renamed Aggregate to RootEntity and merged models into events module
The core domain concept previously called 'Aggregate' has been renamed to 'RootEntity' throughout the events module, including the \Event\ model and \EventEntry\ class. The \models\ module has been merged into \events\, consolidating event-related classes like \Event\, \FieldDiff\, and \FieldDiffContainer\ into a single location. Additionally, the \Event\ class now exposes \get\_field\ and \get\_fields\ methods, deprecating the older \get\_one\ and \get\_all\ methods which now emit warnings.
packages/core/minos-microservice-aggregate/minos/aggregate/events · high confidence
Saga definition API introduces step-specific callback methods and deprecates legacy signatures
The \minos.saga.definitions\ module now provides a structured API for defining saga workflows, introducing \local\_step()\ and \remote\_step()\ methods on the \Saga\ class to add local and remote steps respectively, while deprecating the legacy \step()\ method and the \commit()\ callback argument in favor of using \local\_step()\ for post-commit logic. The \SagaStep\ base class now exposes \local\_step()\, \remote\_step()\, and \commit()\ methods, allowing users to append subsequent steps or commit the saga directly from within a step's context. Additionally, \LocalSagaStep\ and \RemoteSagaStep\ now use dedicated \on\_execute()\, \on\_failure()\, \on\_success()\, and \on\_error()\ methods to register callbacks, replacing the previous constructor-based initialization pattern.
packages/core/minos-microservice-saga/minos/saga/definitions · high confidence
Saga execution persistence now uses a repository pattern with database operation factories
The saga execution storage mechanism has been refactored to use a \SagaExecutionRepository\ interface and a \DatabaseSagaExecutionRepository\ implementation. This change introduces a \SagaExecutionDatabaseOperationFactory\ abstraction, allowing database operations for storing, loading, and deleting saga executions to be built dynamically. Users benefit from a more modular persistence layer that cleanly separates repository logic from specific database operations and handles missing executions via a dedicated \SagaExecutionNotFoundException\.
packages/core/minos-microservice-saga/minos/saga/executions/repositories · high confidence
Snapshot service now synchronizes automatically every minute
The \SnapshotService\ in the aggregate module now includes a periodic \\_\synchronize\\_\ method that triggers snapshot synchronization every minute via a scheduled event. This ensures that snapshots are kept up-to-date without requiring manual intervention, improving data consistency for root entities.
packages/core/minos-microservice-aggregate/minos/aggregate/snapshots · high confidence
Transaction service command topics are renamed
The \TransactionService\ now exposes broker command topics with a dynamic naming scheme that includes the service name (e.g., \\_Reserve{ServiceName}Transaction\, \\_Reject{ServiceName}Transaction\, \\_Commit{ServiceName}Transaction\) instead of static, hardcoded topic names. This change allows multiple transaction services to coexist without topic collisions and aligns the command routing with the configured service identity.
packages/core/minos-microservice-aggregate/minos/aggregate/transactions · high confidence
Updated stock-wallet tutorial infrastructure with new microservices and Kafka images
The stock-wallet tutorial now includes configuration for additional microservices (stocks and crypto) alongside the existing wallet service, all orchestrated via Docker Compose. The infrastructure has been updated to use Confluent's Kafka and Zookeeper images instead of the previous Wurstmeister/DigitalWonderland variants, and the project now includes a .minos-answers.yml file to define the template configuration for this microservice example.
tutorials/stock-wallet · high confidence
Test coverage
Added mocked broker database operation factories for testing; Added test fixtures for command and query services; Added test infrastructure and fixtures for minos-microservice-common; Added test infrastructure and utilities for the aggregate module; Added test infrastructure for minos-microservice-saga; Added test infrastructure for the aiopg database plugin; Added test suite for GraphQL plugin components; Added testing utilities for aggregate repositories; Added testing utilities for database mocking and test case management; Added tests for AsyncAPI and OpenAPI specification generation services; Added tests for BrokerClient and BrokerClientPool; Added tests for BrokerHandler and BrokerPort; Added tests for CQRS handlers and services; Added tests for ConfigV1 configuration loading and parameterization; Added tests for ConfigV2 configuration loading and overrides; Added tests for DiscoveryConnector configuration and lifecycle; Added tests for EntitySet and EntitySetDiff behavior; Added tests for HTTP networking components; Added tests for QueuedBrokerSubscriber and its builder; Added tests for Ref, RefExtractor, RefInjector, and RefResolver; Added tests for Saga execution repository and database operations; Added tests for SnapshotEntry and SnapshotService; Added tests for SnapshotRepository implementations; Added tests for SystemService and EnrouteCollector; Added tests for aggregate event models and entries; Added tests for aiopg database operation factories; Added tests for broker publisher components; Added tests for broker queue implementations; Added tests for broker subscriber components; Added tests for database client and operation abstractions; Added tests for database locking, pooling, and mixin components; Added tests for declarative model attribute access and Avro serialization; Added tests for discovery client implementations; Added tests for enroute decorator registration, collection, and factory logic; Added tests for event repository implementations; Added tests for filtered broker subscriber and duplicate validators; Added tests for network decorator definitions; Added tests for network request and response abstractions; Added tests for queued broker publisher and queue implementations; Added tests for queued broker subscriber queues; Added tests for root entity lifecycle and database integration; Added tests for saga step execution logic; Added tests for scheduling components; Added tests for the LMDB database plugin; Added tests for the dependency injection system; Added tests for transaction entry and service logic; Added tests for transaction repository implementations; Added unit and integration tests for RabbitMQ broker plugin; Added unit tests for AioHttpConnector and AioHttpRequest; Added unit tests for Avro serializers; Added unit tests for BrokerDispatcher and BrokerRequest; Added unit tests for Kafka broker plugin components; Added unit tests for MinosDiscoveryClient; Added unit tests for WalletCommandService; Added unit tests for aiopg database client and operations; Added unit tests for core microservice components; Added unit tests for minos-microservice-common core components; Added unit tests for minos-microservice-networks; Added unit tests for model type utilities; Added unit tests for network components; Added unit tests for saga execution and executor components; Added unit tests for the Config class and its abstract base; Added unit tests for the Minos Kong Discovery plugin; Added unit tests for the saga module; Added unit tests for the stocks microservice command and query services; Added unit tests for wallet query services and repositories; Removal of initial test scaffolding files.
Dependencies
Minos Framework packages updated to version 0.7.0
The core Minos packages (\minos-microservice-common\, \minos-microservice-aggregate\, \minos-microservice-networks\, \minos-microservice-saga\, \minos-microservice-cqrs\) and their plugins (\minos-broker-kafka\, \minos-broker-rabbitmq\, \minos-database-aiopg\, \minos-database-lmdb\) have been updated to version 0.7.0. This release updates the dependency constraints for internal packages to \^0.7.0\ and refreshes the \poetry.lock\ files to resolve specific library versions, including \aiomisc\ 15.7.3, \fastavro\ 1.4.11, \dependency-injector\ 4.39.1, and \flake8\ 4.0.1.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 49 → 47 (-1.3)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 70 → 70 (+0.0)
- Architecture 94 → 94 (+0.0)
- Maturity 62 → 65 (+3.4)
- Readiness 41 → 41 (+0.0)
- Security 41 → 38 (-3.4)
- Domain Modelling 59 → 59 (+0.0)
- Performance 100 → 100 (+0.0)
Resolved (3)
- Change-coupling hub: impl.py → impl.py, impl.py, impl.py (packages/core/minos-microservice-aggregate/minos/aggregate/transactions/repositories/database/impl.py)
- High CVE: [GHSA redacted] (poetry.lock)
- Medium CVE: [GHSA redacted] (poetry.lock)
New (2)
- High CVE: [GHSA redacted] (poetry.lock)
- Medium CVE: [GHSA redacted] (poetry.lock)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
minos-framework/minos-python was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 10 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 3427fdaed489d3b9330c80ce15d77975e0135b9c — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.4+preprod-464a0040a931.