Replace poetry by uv

Author: fmind

docs/0. Overview/0.6. Resources.md

@@ -21,6 +21,7 @@ To propose a new project resource, please forward your suggestions to the course
 ## Additional vendor resources
 
 - **[MLOps Python Package](https://github.com/fmind/mlops-python-package)**
+- **[LLMOps Python Package](https://github.com/callmesora/llmops-python-package/)**
 - **[Cookiecutter MLOps Package](https://github.com/fmind/cookiecutter-mlops-package)**
 - [MLOps: Continuous delivery and automation pipelines in machine learning](https://cloud.google.com/architecture/mlops-continuous-delivery-and-automation-pipelines-in-machine-learning)
 - [The Big Book of MLOps](https://www.databricks.com/sites/default/files/2023-10/2023-10-eb-big-book-of-mlops-2nd-edition-v2-102723-final.pdf)

docs/1. Initializing/1.0. System.md

@@ -14,10 +14,10 @@ While [JupyterLab](https://jupyterlab.readthedocs.io/en/latest/) is an acceptabl
 
 ## Are additional software installations required?
 
-Engaging with this course material necessitates installing several key software packages, including Python, Poetry, git, and VS Code. These tools form the backbone of your development workflow:
+Engaging with this course material necessitates installing several key software packages, including Python, uv, git, and VS Code. These tools form the backbone of your development workflow:
 
 - **Python** is indispensable for all course-related coding activities.
-- **Poetry** offers an efficient way to manage Python package dependencies.
+- **uv** offers an efficient way to manage Python package dependencies.
 - **Git** is crucial for version control and collaboration.
 - **VS Code** is recommended for its integrated development environment (IDE) capabilities, although alternatives may be used based on personal preference or specific needs.
 

docs/1. Initializing/1.3. Poetry.md

@@ -126,14 +126,14 @@ These configurations ensure that Poetry creates virtual environments directly wi
 
 ## How can you install dependencies for your project with Poetry?
 
-Poetry differentiates between main (production) and development dependencies, offering an organized approach to dependency management. To add dependencies, use the following commands:
+Uv differentiates between main (production) and development dependencies, offering an organized approach to dependency management. To add dependencies, use the following commands:
 
 ```bash
 # For main dependencies
-$ poetry add pandas scikit-learn
+$ uv add pandas scikit-learn
 
 # For development dependencies
-$ poetry add -G dev ipykernel
+$ uv add --group dev ipykernel
 ```
 
 Executing these commands updates the `pyproject.toml` file, accurately managing and versioning your project's dependencies.
@@ -144,9 +144,9 @@ In production, you can decide to install only the main dependencies using [this
 poetry install --only main
 ```
 
-## What is the difference between main and dev dependencies in Poetry?
+## What is the difference between main and dev dependencies in uv?
 
-In Poetry, dependencies are divided into two types: main dependencies and development (dev) dependencies.
+In uv, dependencies are divided into two types: main dependencies and development (dev) dependencies.
 
 **Main Dependencies**: These are essential for your project's production environment—your application can't run without them. For example, libraries like Pandas or XGBoost would be main dependencies for an MLOps project.
 

docs/1. Initializing/1.4. git.md

@@ -49,7 +49,7 @@ When using Git, it's important to selectively track files. Consider the followin
 
 - **Exclude Secrets**: Sensitive data, such as API keys and passwords, should never be committed to your repository.
 - **Manage Large Files**: For files exceeding 100MB (e.g., dataset files), use Git Large File Storage ([git-lfs](https://git-lfs.github.com/)) instead of directly committing them to your Git repository.
-- **Omit Cache Files**: Do not track temporary or environment-specific files (e.g., `.venv`, `poetry.lock`, log files) that don't contribute to the project's primary function.
+- **Omit Cache Files**: Do not track temporary or environment-specific files (e.g., `.venv`, `mlruns`, log files) that don't contribute to the project's primary function.
 
 To exclude certain files and directories from being tracked, create a `.gitignore` file in your project's root directory. This file should list patterns to match filenames you wish to exclude, for example:
 

docs/1. Initializing/1.6. VS Code.md

@@ -238,19 +238,19 @@ You can find below some settings for configuring VS Code. Each setting is annota
 }
 ```
 
-## How to configure VS Code for using the [Jupyter Extension](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter) with [Poetry](https://python-poetry.org/)?
+## How to configure VS Code for using the [Jupyter Extension](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter) with [uv](https://docs.astral.sh/uv/)?
 
-To configure VS Code for using the [Jupyter Extension](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter) with [Poetry](https://python-poetry.org/), follow these steps to ensure that your Poetry-managed virtual environment is recognized within VS Code. This allows you to use the Jupyter Extension seamlessly with the Python interpreter provided by Poetry.
+To configure VS Code for using the [Jupyter Extension](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter) with [uv](https://docs.astral.sh/uv/), follow these steps to ensure that your uv-managed virtual environment is recognized within VS Code. This allows you to use the Jupyter Extension seamlessly with the Python interpreter provided by uv.
 
 1. **Install the Jupyter Extension**: First, ensure that the [Jupyter Extension](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter) is installed in VS Code. You can find and install this extension from the [VS Code Marketplace](https://marketplace.visualstudio.com/VSCode).
-2. **Open Your Project in VS Code**: Open your project folder in VS Code. If you've just created a new Poetry project, this will be the directory containing your `pyproject.toml` file.
-3. **Select Python Interpreter**: To make VS Code use the Python interpreter from your Poetry environment:
+2. **Open Your Project in VS Code**: Open your project folder in VS Code. If you've just created a new uv project, this will be the directory containing your `pyproject.toml` file.
+3. **Select Python Interpreter**: To make VS Code use the Python interpreter from your uv environment:
     - Open the Command Palette (`Ctrl+Shift+P` on Windows/Linux, `Cmd+Shift+P` on macOS).
     - Type `Python: Select Interpreter` and select it.
-    - Look for the interpreter that corresponds to your Poetry environment. It will typically be located under the `.venv` path within your project directory or listed as a virtual environment with your project's name.
+    - Look for the interpreter that corresponds to your uv environment. It will typically be located under the `.venv` path within your project directory or listed as a virtual environment with your project's name.
     - Select the appropriate interpreter.
-4. **Verify Jupyter Notebook Configuration**: Create a new Jupyter notebook in VS Code (`*.ipynb` file) and verify that the cells execute using the Python interpreter from your Poetry environment. You can check the upper-right corner of the notebook interface to see which interpreter is currently active.
-5. **Install Necessary Libraries**: If you need additional Python libraries that are not yet part of your Poetry project, you can add them by running `poetry add <library-name>` in your terminal or command prompt. This ensures that all dependencies are managed by Poetry and available in the notebook.
+4. **Verify Jupyter Notebook Configuration**: Create a new Jupyter notebook in VS Code (`*.ipynb` file) and verify that the cells execute using the Python interpreter from your uv environment. You can check the upper-right corner of the notebook interface to see which interpreter is currently active.
+5. **Install Necessary Libraries**: If you need additional Python libraries that are not yet part of your uv project, you can add them by running `uv add <library-name>` in your terminal or command prompt. This ensures that all dependencies are managed by uv and available in the notebook.
 
 ## VS Code additional resources
 

docs/2. Prototyping/2.0. Notebooks.md

@@ -28,7 +28,7 @@ As an alternative to notebooks, consider using the [Python Interactive Window](h
 
 Using notebooks in the early stages of development offers many advantages; however, they are not well-suited for production environments due to several limitations:
 
-- **Lack of Integration**: Notebooks often do not integrate seamlessly with tools commonly used in the Python software development ecosystem, such as testing frameworks (pytest), linting tools (ruff), and package managers (poetry).
+- **Lack of Integration**: Notebooks often do not integrate seamlessly with tools commonly used in the Python software development ecosystem, such as testing frameworks (pytest), linting tools (ruff), and package managers (uv).
 - **Mixed Content**: The intermingling of code, output, and narrative in a single document can complicate version control and maintenance, especially with complex projects.
 - **Non-Sequential Flow**: Notebooks do not enforce a linear execution order, which can lead to confusion and errors if cells are run out of sequence.
 - **Lack of Reusability**: The format of notebooks does not naturally encourage the development of reusable and modular code, such as functions, classes, or packages.

docs/2. Prototyping/2.1. Imports.md

@@ -33,13 +33,13 @@ In the realm of data science, a few key Python packages form the backbone of mos
 - **[Matplotlib](https://matplotlib.org/) or [Plotly](https://plotly.com/)**: For creating static, interactive, and animated visualizations.
 - **[Scikit-learn](https://scikit-learn.org/stable/)**: For machine learning, providing simple and efficient tools for data analysis and modeling.
 
-To integrate these packages into your project using poetry, you can execute the following command in your terminal:
+To integrate these packages into your project using uv, you can execute the following command in your terminal:
 
 ```bash
-poetry add pandas numpy matplotlib scikit-learn plotly
+uv add pandas numpy matplotlib scikit-learn plotly
 ```
 
-This command tells poetry to download and install these packages, along with their dependencies, into your project environment, ensuring version compatibility and easy package management.
+This command tells uv to download and install these packages, along with their dependencies, into your project environment, ensuring version compatibility and easy package management.
 
 ## How should you organize your imports to facilitate your work?
 

docs/2. Prototyping/2.2. Configs.md

@@ -12,16 +12,20 @@ Here's a practical illustration of configs within a notebook context:
 
 ```python
 # Define paths for caching and training data
-CACHE_PATH = '../.cache/'
-TRAIN_DATA_PATH = '../data/train.csv'
+ROOT = Path("../")
+DATA = str(ROOT / "data")
+CACHE = str(ROOT / ".cache")
+HOUR = str(DATA / "hour.csv")
 # Configure random state for reproducibility
-RANDOM_STATE = 0
+RANDOM = 42
+# Define dataset columns for feature engineering
+INDEX = "instant"
+TARGET = "cnt"
 # Setup dataset parameters for testing and shuffling
-SHUFFLE = True
-TEST_SIZE = 0.2
-TARGET = "SalePrice"
+SPLITS = 4
+SHUFFLE = False  # required (time sensitive)
+TEST_SIZE = 24 * 30 * 2  # use 2 months for backtesting
 # Parameters for pipeline configurations
-CV = 5
 SCORING = "neg_mean_squared_error"
 PARAM_GRID = {
     "regressor__max_depth": [12, 15, 18, 21],

docs/2. Prototyping/2.4. Analysis.md

@@ -46,8 +46,8 @@ For instance, [Plotly Express's `scatter_matrix`](https://plotly.com/python/splo
 import plotly.express as px
 df = pd.read_csv('your_dataset.csv')
 px.scatter_matrix(
-df, dimensions=["feature1", "feature2", "feature3"], color="target_variable",
-height=800, title="Scatter Matrix of Features"
+    df, dimensions=["feature1", "feature2", "feature3"], color="target_variable",
+    height=800, title="Scatter Matrix of Features"
 )
 ```
 

docs/2. Prototyping/2.5. Modeling.md

@@ -135,7 +135,6 @@ PARAM_GRID = {
     "regressor__max_depth": [15, 20, 25],
     "regressor__n_estimators": [150, 200, 250],
 }
-RANDOM_STATE = 0
 
 splitter = model_selection.TimeSeriesSplit(n_splits=CV)
 

docs/3. Productionizing/3.0. Package.md

@@ -19,26 +19,26 @@ Additionally, creating a package can enhance the maintainability of your code, e
 
 ## Which tool should you use to create a Python package?
 
-The Python ecosystem provides several tools for packaging, each with its unique features and advantages. While the choice can seem overwhelming, as humorously depicted in the [xkcd comic on Python environments](https://xkcd.com/1987/), [Poetry](https://python-poetry.org/) emerges as a standout option. Poetry simplifies dependency management and packaging, offering an intuitive interface for developers.
+The Python ecosystem provides several tools for packaging, each with its unique features and advantages. While the choice can seem overwhelming, as humorously depicted in the [xkcd comic on Python environments](https://xkcd.com/1987/), [uv](https://docs.astral.sh/uv/) emerges as a standout option. Uv simplifies dependency management and packaging, offering an intuitive interface for developers.
 
-To get started with Poetry for packaging, you can use the following commands:
+To get started with uv for packaging, you can use the following commands:
 
-- **Initiate a Poetry package**:
+- **Initiate an uv package**:
 
 ```bash
-poetry init
+uv sync
 ```
 
 - **Start developing the package**:
 
 ```bash
-poetry install
+uv sync --all-groups
 ```
 
-- **Build a package with Poetry**:
+- **Build a package with uv**:
 
 ```bash
-poetry build --format wheel
+uv build --wheel
 ```
 
 At the end of the build process, a `.whl` file is generated in the `dist` folder with the name and version of the project from `pyproject.toml`.
@@ -49,35 +49,46 @@ For those seeking alternatives, tools like [PDM](https://pdm-project.org/en/late
 
 Although [Conda](https://conda.io/projects/conda/en/latest/user-guide/install/index.html) is a popular choice among data scientists for its ability to manage complex dependencies, it's important to be aware of its limitations. Challenges such as slow performance, a complex dependency resolver, and confusing channel management can hinder productivity. Moreover, Conda's integration with the Python ecosystem, especially with new standards like `pyproject.toml`, is limited. For managing complex dependencies in AI/ML projects, Docker containers present a robust alternative, offering better isolation and compatibility across environments.
 
-## How can you install new dependencies with Poetry?
+## How can you install new dependencies with uv?
 
-Please refer to [this section of the course](../1. Initializing/1.3. Poetry.md).
+Please refer to [this section of the course](../1. Initializing/1.3. uv.md).
 
 ## Which metadata should you provide to your Python package?
 
-Including detailed metadata in your [`pyproject.toml`](https://python-poetry.org/docs/pyproject/) file is crucial for defining your package's identity and dependencies. This file should contain essential information such as the package name, version, authors, and dependencies. Here's an example that outlines the basic structure and content for your package's metadata:
+Including detailed metadata in your [`pyproject.toml`](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/) file is crucial for defining your package's identity and dependencies. This file should contain essential information such as the package name, version, authors, and dependencies. Here's an example that outlines the basic structure and content for your package's metadata:
 
 ```toml
-# Example metadata for a Python package
+# https://docs.astral.sh/uv/reference/settings/
+# https://packaging.python.org/en/latest/guides/writing-pyproject-toml/
 
-[tool.poetry]
+[project]
 name = "bikes"
-version = "1.0.0"
+version = "3.0.0"
 description = "Predict the number of bikes available."
-repository = "https://github.com/yourusername/mlops-python-package"
-documentation = "https://yourusername.github.io/mlops-python-package/"
-authors = ["Your Name <[email protected]>"]
+authors = [{ name = "Médéric HURIER", email = "[email protected]" }]
 readme = "README.md"
-license = "CC BY"
+requires-python = ">=3.12"
+dependencies = []
+license = { file = "LICENSE.txt" }
 keywords = ["mlops", "python", "package"]
-packages = [{ include = "bikes", from = "src" }]
 
-[tool.poetry.dependencies]
-python = "^3.10"
+[project.urls]
+Homepage = "https://github.com/fmind/bikes"
+Documentation = "https://fmind.github.io/bikes"
+Repository = "https://github.com/fmind/bikes"
+"Bug Tracker" = "https://github.com/fmind/bikes/issues"
+Changelog = "https://github.com/fmind/bikes/blob/main/CHANGELOG.md"
+
+[project.scripts]
+bikes = 'bikes.scripts:main'
+
+[tool.uv]
+default-groups = ["checks", "commits", "dev", "docs", "notebooks"]
 
 [build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
 ```
 
 This information not only aids users in understanding what your package does but also facilitates its discovery and integration into other projects.
@@ -101,10 +112,10 @@ Deciding whether to publish your Python package depends on your goals. If you ai
 
 For private packages or when sharing within a limited group or organization, platforms like [AWS CodeArtifact](https://aws.amazon.com/codeartifact/) or [GCP Artifact Registry](https://cloud.google.com/artifact-registry) offer secure hosting and management of your packages.
 
-To publish a package using Poetry, you can use the command:
+To publish a package using uv, you can use the command:
 
 ```bash
-poetry publish
+uv publish
 ```
 
 This will upload your package to PyPI, making it available for installation via `pip` by the Python community.

docs/3. Productionizing/3.1. Modules.md

@@ -52,7 +52,7 @@ import sys
 print(sys.path)
 ```
 
-After installing your package locally (e.g., using `poetry install`), your package's directory will be added to `sys.path`, allowing you to import its modules without specifying their full path.
+After installing your package locally (e.g., using `uv sync`), your package's directory will be added to `sys.path`, allowing you to import its modules without specifying their full path.
 
 ## How should you organize your Python modules?