Metadata-Version: 2.1
Name: microservice-story-manager
Version: 0.1.0
Summary: 
Author: radix1001
Author-email: luis@thedogcompany.cl
Requires-Python: >=3.12,<4.0
Classifier: Programming Language :: Python :: 3
Requires-Dist: deap (>=1.4.1,<2.0.0)
Requires-Dist: matplotlib (>=3.9.1,<4.0.0)
Requires-Dist: mpld3 (>=0.5.10,<0.6.0)
Requires-Dist: networkx (>=3.3,<4.0)
Description-Content-Type: text/markdown

# Microservice Story Manager

Microservice Story Manager is a Python library for managing user stories and microservices, optimizing story assignments, and visualizing microservice dependencies. It provides tools for organizing user stories, assigning them to microservices, and optimizing these assignments using various algorithms.

## Features

- User Story Management: Create, store, and manage user stories with detailed attributes.
- Microservice Management: Organize user stories into microservices.
- Dependency Visualization: Visualize dependencies between microservices based on user story relationships.
- Genetic Algorithm Assignment: Optimize the assignment of user stories to microservices using genetic algorithms.
- Particle Swarm Optimization: Alternative method for optimizing story assignments.
- Customizable Fitness Functions: Define your own criteria for optimal story distribution.
- Multi-language Support: Error messages available in multiple languages.

## Installation

You can install the Microservice Story Manager using pip:

```bash
pip install microservice-story-manager
```

## Quickstart

Here's a quick example of how to use the Microservice Story Manager to manage user stories and optimize their assignment to microservices:

```python
from microservice_story_manager import UserStoryManager, MicroserviceManager, MicroserviceVisualizer, GeneticMicroserviceAssigner

# Initialize managers
user_story_manager = UserStoryManager()
user_story_manager.load_stories_from_csv('path/to/your/stories.csv')

microservice_manager = MicroserviceManager(user_story_manager)

# Create microservices
for _ in range(5):
    microservice_manager.create_microservice()

# Define a fitness function
def simple_fitness(assignment):
    microservice_loads = [0] * len(microservice_manager.microservices)
    for ms_index in assignment:
        microservice_loads[ms_index] += 1
    return (1 / (max(microservice_loads) - min(microservice_loads) + 1),)

# Use genetic algorithm to assign stories
assigner = GeneticMicroserviceAssigner(user_story_manager, microservice_manager)
assigner.optimize_assignment(simple_fitness, population_size=100, generations=50)

# Visualize the result
visualizer = MicroserviceVisualizer(microservice_manager)
visualizer.plot_microservices()
```

## Detailed Usage

### User Story Management

The `UserStoryManager` class is used to create, store, and manage user stories. You can create user stories manually or load them from a CSV file. Here's an example of how to create a user story:

```python
user_story_manager = UserStoryManager()
user_story_manager.load_stories_from_csv('stories.csv')
```

### Microservice Management

The `MicroserviceManager` class is used to organize user stories into microservices. You can create microservices manually or let the manager create them for you. Here's an example of how to create microservices:

```python
microservice_manager = MicroserviceManager(user_story_manager)
ms_id = microservice_manager.create_microservice()
microservice_manager.add_story_to_microservice(ms_id, story_id)
```

### Genetic Microservice Assigner

The `GeneticMicroserviceAssigner` class is used to optimize the assignment of user stories to microservices using genetic algorithms. You can define your own fitness function to determine the optimal assignment. Here's an example of how to use the assigner:

```python
assigner = GeneticMicroserviceAssigner(user_story_manager, microservice_manager)
assigner.optimize_assignment(fitness_function, population_size=100, generations=50)
```

### Particle Swarm Optimization

The `ParticleSwarmOptimization` class is an alternative method for optimizing story assignments. You can use it in place of the genetic algorithm assigner. Here's an example of how to use the particle swarm optimization:

```python
pso_assigner = PSOMicroserviceAssigner(user_story_manager, microservice_manager)
best_particle = pso_assigner.optimize_assignment(population_size=50, generations=100)
pso_assigner.assign_stories_to_microservices(best_particle)
```

### Microservice Visualizer

The `MicroserviceVisualizer` class is used to visualize the dependencies between microservices based on user story relationships. Here's an example of how to use the visualizer:

```python
visualizer = MicroserviceVisualizer(microservice_manager)
visualizer.plot_microservices(base_color='lightblue')
```

## Customization

You can customize various aspects of the library:

* Define your own fitness functions for optimization algorithms.
* Adjust visualization parameters like colors and node sizes.
* Implement additional optimization algorithms.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.







