+ If you are using + ZenML Cloud, you can enter + your tenant url in the input box below to connect to it. That way you can + see the result of all your runs in your dashboard. +
+ ++ ZenML Cloud is a managed service that provides a hosted ZenML environment. + It allows you to run your pipelines on the cloud, manage your metadata, and + collaborate with your team. Sign up at + ZenML Cloud + for a free trial and to get started! +
+
+
+Apart from the loading the model, we must also load the preprocessing pipeline that we ran in feature engineering,
+so that we can do the exact steps that we did on training time, in inference time.
+
+The way to load the right model is to pass in the `production` stage into the `Model` config this time.
+This will ensure to always load the production model, decoupled from all other pipelines.
diff --git a/.devcontainer/zenmlQuickstart/sections/consumingModel/consumingModel.py b/.devcontainer/zenmlQuickstart/sections/consumingModel/consumingModel.py
new file mode 100644
index 0000000..2ef4f25
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/consumingModel/consumingModel.py
@@ -0,0 +1,71 @@
+from typing_extensions import Annotated
+import pandas as pd
+from zenml import step, pipeline, Model, get_step_context
+from zenml.client import Client
+from uuid import UUID
+from zenml import pipeline
+from steps import (
+ data_loader,
+ inference_preprocessor
+)
+
+client = Client()
+preprocessing_pipeline_artifact_version = client.get_artifact_version("preprocess_pipeline")
+
+@step
+def inference_predict(dataset_inf: pd.DataFrame) -> Annotated[pd.Series, "predictions"]:
+ """Predictions step"""
+ # Get the model
+ model = get_step_context().model
+
+ # run prediction from memory
+ predictor = model.load_artifact("sklearn_classifier")
+ predictions = predictor.predict(dataset_inf)
+
+ predictions = pd.Series(predictions, name="predicted")
+
+ return predictions
+
+@pipeline
+def inference(preprocess_pipeline_id: UUID):
+ """Model batch inference pipeline"""
+ # random_state = client.get_artifact_version(name_id_or_prefix=preprocess_pipeline_id).metadata["random_state"].value
+ # target = client.get_artifact_version(name_id_or_prefix=preprocess_pipeline_id).run_metadata['target'].value
+ random_state = 42
+ target = "target"
+
+ df_inference = data_loader(
+ random_state=random_state, is_inference=True
+ )
+ df_inference = inference_preprocessor(
+ dataset_inf=df_inference,
+ # We use the preprocess pipeline from the feature engineering pipeline
+ preprocess_pipeline=client.get_artifact_version(name_id_or_prefix=preprocess_pipeline_id),
+ target=target,
+ )
+ inference_predict(
+ dataset_inf=df_inference,
+ )
+
+pipeline_settings = {"enable_cache": False}
+
+# Lets add some metadata to the model to make it identifiable
+pipeline_settings["model"] = Model(
+ name="breast_cancer_classifier",
+ version="production", # We can pass in the stage name here!
+ license="Apache 2.0",
+ description="A breast cancer classifier",
+ tags=["breast_cancer", "classifier"],
+)
+
+# the `with_options` method allows us to pass in pipeline settings
+# and returns a configured pipeline
+inference_configured = inference.with_options(**pipeline_settings)
+
+# Let's run it again to make sure we have two versions
+# We need to pass in the ID of the preprocessing done in the feature engineering pipeline
+# in order to avoid training-serving skew
+
+inference_configured(
+ preprocess_pipeline_id=preprocessing_pipeline_artifact_version.id
+)
diff --git a/.devcontainer/zenmlQuickstart/sections/consumingModel/finish.md b/.devcontainer/zenmlQuickstart/sections/consumingModel/finish.md
new file mode 100644
index 0000000..cc4ed77
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/consumingModel/finish.md
@@ -0,0 +1,8 @@
+# Consuming the Model in Production ๐
+
+ZenML automatically links all artifacts to the `production` model version as well, including the predictions
+that were returned in the pipeline. This completes the MLOps loop of training to inference:
+
+You can also see all predictions ever created as a complete history in the dashboard:
+
+
diff --git a/.devcontainer/zenmlQuickstart/sections/featureEngineering/afterRunning1.md b/.devcontainer/zenmlQuickstart/sections/featureEngineering/afterRunning1.md
new file mode 100644
index 0000000..ff95b0f
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/featureEngineering/afterRunning1.md
@@ -0,0 +1,7 @@
+# Feature Engineering ๐งช
+
+Something about the pipeline we just ran
+
+
diff --git a/.devcontainer/zenmlQuickstart/sections/featureEngineering/featureEngineering1.md b/.devcontainer/zenmlQuickstart/sections/featureEngineering/featureEngineering1.md
new file mode 100644
index 0000000..ec4d981
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/featureEngineering/featureEngineering1.md
@@ -0,0 +1,5 @@
+# Feature Engineering ๐งช
+
+We're now at the right point to actually run the pipeline, since we've defined logic for the various steps.
+
+> Remember, creating a pipeline is as simple as adding a `@pipeline` decorator to a function. This specific pipeline doesn't return a value, but that option is available to you if you need.
diff --git a/.devcontainer/zenmlQuickstart/sections/featureEngineering/featureEngineering1.py b/.devcontainer/zenmlQuickstart/sections/featureEngineering/featureEngineering1.py
new file mode 100644
index 0000000..2bc5c4f
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/featureEngineering/featureEngineering1.py
@@ -0,0 +1,44 @@
+from zenml import pipeline
+from zenml.client import Client
+
+from typing import Optional, List
+
+from zenml import pipeline
+
+from steps import (
+ data_loader,
+ data_preprocessor,
+ data_splitter
+)
+
+# Initialize the ZenML client to fetch objects from the ZenML Server
+client = Client()
+# as in Notion Doc
+@pipeline
+def feature_engineering(
+ test_size: float = 0.3,
+ drop_na: Optional[bool] = None,
+ normalize: Optional[bool] = None,
+ drop_columns: Optional[List[str]] = None,
+ target: Optional[str] = "target",
+ random_state: int = 17
+):
+ """Feature engineering pipeline."""
+ # Link all the steps together by calling them and passing the output
+ # of one step as the input of the next step.
+ raw_data = data_loader(random_state=random_state, target=target)
+ dataset_trn, dataset_tst = data_splitter(
+ dataset=raw_data,
+ test_size=test_size,
+ )
+ dataset_trn, dataset_tst, _ = data_preprocessor(
+ dataset_trn=dataset_trn,
+ dataset_tst=dataset_tst,
+ drop_na=drop_na,
+ normalize=normalize,
+ drop_columns=drop_columns,
+ target=target,
+ random_state=random_state,
+ )
+
+feature_engineering()
diff --git a/.devcontainer/zenmlQuickstart/sections/featureEngineering/runLocalDashboard.html b/.devcontainer/zenmlQuickstart/sections/featureEngineering/runLocalDashboard.html
new file mode 100644
index 0000000..eb57869
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/featureEngineering/runLocalDashboard.html
@@ -0,0 +1,23 @@
+
+ If you want to view your pipeline runs in the ZenML Dashboard but aren't
+ using ZenML Cloud, you can run a local version of the
+ dashboard by running zenml up in the terminal or clicking
+ the button below.
+
+ If you are running this quickstart in codespaces, you'll get a pop-up in + the bottom right corner when your dashboard is ready. Follow the link to + open the dashboard in a new tab. +
++ Otherwise, VSCode may open the browser tab automatically. +
+
+ Log into the Dashboard using default credentials (username default
+ and password left blank) and follow the short onboarding flow.
+ From there you can inspect the pipeline or the
+ specific pipeline run.
+
+
+The whole function is decorated with the `@step` decorator, which
+tells ZenML to track this function as a step in the pipeline. This means that
+ZenML will automatically version, track, and cache the data that is produced by
+this function as an `artifact`. This is a very powerful feature, as it means that you can
+reproduce your data at any point in the future, even if the original data source
+changes or disappears.
+
+Note the use of the `typing` module's `Annotated` type hint in the output of the
+step. We're using this to give a name to the output of the step, which will make
+it possible to access it via a keyword later on.
+
+You'll also notice that we have included type hints for the outputs
+to the function. These are not only useful for anyone reading your code, but
+help ZenML process your data in a way appropriate to the specific data types.
+
+ZenML is built in a way that allows you to experiment with your data and build
+your pipelines as you work, so if you want to call this function to see how it
+works, you can just call it directly. Here we take a look at the first few rows
+of your training dataset.
diff --git a/.devcontainer/zenmlQuickstart/sections/loadingData/loadingData.py b/.devcontainer/zenmlQuickstart/sections/loadingData/loadingData.py
new file mode 100644
index 0000000..0d6cb29
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/loadingData/loadingData.py
@@ -0,0 +1,35 @@
+# Do the imports at the top
+from typing_extensions import Annotated
+from sklearn.datasets import load_breast_cancer
+
+import pandas as pd
+from rich import print
+from zenml import step
+from zenml.client import Client
+from zenml.logger import get_logger
+
+logger = get_logger(__name__)
+
+# Initialize the ZenML client to fetch objects from the ZenML Server
+client = Client()
+
+@step
+def data_loader_simplified(
+ random_state: int, is_inference: bool = False, target: str = "target"
+) -> Annotated[pd.DataFrame, "dataset"]: # We name the dataset
+ """Dataset reader step."""
+ dataset = load_breast_cancer(as_frame=True)
+ inference_size = int(len(dataset.target) * 0.05)
+ dataset: pd.DataFrame = dataset.frame
+ inference_subset = dataset.sample(inference_size, random_state=random_state)
+ if is_inference:
+ dataset = inference_subset
+ dataset.drop(columns=target, inplace=True)
+ else:
+ dataset.drop(inference_subset.index, inplace=True)
+ dataset.reset_index(drop=True, inplace=True)
+ logger.info(f"Dataset with {len(dataset)} records loaded!")
+ return dataset
+
+df = data_loader_simplified(random_state=42)
+print(df.head())
diff --git a/.devcontainer/zenmlQuickstart/sections/modelControlPlane/finish.md b/.devcontainer/zenmlQuickstart/sections/modelControlPlane/finish.md
new file mode 100644
index 0000000..73b6df4
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/modelControlPlane/finish.md
@@ -0,0 +1,28 @@
+# Using the Model Control Plane ๐ทโโ๏ธ
+
+If you are a [ZenML Cloud](https://zenml.io/cloud) user, you can see all of this visualized in the dashboard:
+
+
+
+There is a lot more you can do with ZenML models, including the ability to
+track metrics by adding metadata to it, or having them persist in a model
+registry. However, these topics can be explored more in the
+[ZenML docs](https://docs.zenml.io).
+
+For now, we will use the ZenML model control plane to promote our best
+model to `production`. You can do this by simply setting the `stage` of
+your chosen model version to the `production` tag.
+
+# Set our best classifier to production
+
+```python
+rf_zenml_model_version.set_stage("production", force=True)
+```
+
+Of course, normally one would only promote the model by comparing to all other model
+versions and doing some other tests. But that's a bit more advanced use-case. See the
+[e2e_batch example](https://github.com/zenml-io/zenml/tree/main/examples/e2e) to get
+more insight into that sort of flow!
+
+Once the model is promoted, we can now consume the right model version in our
+batch inference pipeline directly. Let's see how that works.
diff --git a/.devcontainer/zenmlQuickstart/sections/modelControlPlane/modelControlPlane.md b/.devcontainer/zenmlQuickstart/sections/modelControlPlane/modelControlPlane.md
new file mode 100644
index 0000000..fb0c377
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/modelControlPlane/modelControlPlane.md
@@ -0,0 +1,8 @@
+# Using the Model Control Plane ๐ทโโ๏ธ
+
+You can see it is relatively easy to train ML models using ZenML pipelines. But it can be somewhat clunky to track all the models produced as you develop your experiments and use-cases. Luckily, ZenML offers a _Model Control Plane_, which is a central register of all your ML models.
+
+You can easily create a ZenML Model and associate it with your pipelines using the `Model` object.
+
+This time, running both pipelines has created two associated **model versions**.
+You can list your ZenML model and their versions as follows:
diff --git a/.devcontainer/zenmlQuickstart/sections/modelControlPlane/modelControlPlane.py b/.devcontainer/zenmlQuickstart/sections/modelControlPlane/modelControlPlane.py
new file mode 100644
index 0000000..99c2e40
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/modelControlPlane/modelControlPlane.py
@@ -0,0 +1,45 @@
+from zenml import Model
+from zenml.client import Client
+from pipelines import training
+
+# Initialize the ZenML client to fetch objects from the ZenML Server
+client = Client()
+dataset_trn_artifact_version = client.get_artifact_version("dataset_trn")
+dataset_tst_artifact_version = client.get_artifact_version("dataset_tst")
+pipeline_settings = {}
+
+# Lets add some metadata to the model to make it identifiable
+pipeline_settings["model"] = Model(
+ name="breast_cancer_classifier",
+ license="Apache 2.0",
+ description="A breast cancer classifier",
+ tags=["breast_cancer", "classifier"],
+)
+
+# Let's train the SGD model and set the version name to "sgd"
+pipeline_settings["model"].version = "sgd"
+
+# the `with_options` method allows us to pass in pipeline settings
+# and returns a configured pipeline
+training_configured = training.with_options(**pipeline_settings)
+
+# We can now run this as usual
+training_configured(
+ model_type="sgd",
+ train_dataset_id=dataset_trn_artifact_version.id,
+ test_dataset_id=dataset_tst_artifact_version.id
+)
+
+# Let's train the RF model and set the version name to "rf"
+pipeline_settings["model"].version = "rf"
+
+# the `with_options` method allows us to pass in pipeline settings
+# and returns a configured pipeline
+training_configured = training.with_options(**pipeline_settings)
+
+# Let's run it again to make sure we have two versions
+training_configured(
+ model_type="rf",
+ train_dataset_id=dataset_trn_artifact_version.id,
+ test_dataset_id=dataset_tst_artifact_version.id
+)
diff --git a/.devcontainer/zenmlQuickstart/sections/modelControlPlane/modelControlPlane2.md b/.devcontainer/zenmlQuickstart/sections/modelControlPlane/modelControlPlane2.md
new file mode 100644
index 0000000..d90e6bb
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/modelControlPlane/modelControlPlane2.md
@@ -0,0 +1,8 @@
+# Using the Model Control Plane ๐ทโโ๏ธ
+
+This time, running both pipelines has created two associated **model versions**.
+
+The interesting part is that ZenML went ahead and linked all artifacts produced by the
+pipelines to that model version, including the two pickle files that represent our
+SGD and RandomForest classifier. We can see all artifacts directly from the model
+version object:
diff --git a/.devcontainer/zenmlQuickstart/sections/nextSteps/congratulations.md b/.devcontainer/zenmlQuickstart/sections/nextSteps/congratulations.md
new file mode 100644
index 0000000..ce0363c
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/nextSteps/congratulations.md
@@ -0,0 +1,21 @@
+# Congratulations!
+
+You're a legit MLOps engineer now! You trained two models, evaluated them against
+a test set, registered the best one with the ZenML model control plane,
+and served some predictions. You also learned how to iterate on your models and
+data by using some of the ZenML utility abstractions. You saw how to view your
+artifacts and models via the client as well as the ZenML Dashboard.
+
+## Further exploration
+
+This was just the tip of the iceberg of what ZenML can do; check out the [**docs**](https://docs.zenml.io/) to learn more
+about the capabilities of ZenML. For example, you might want to:
+
+- [Deploy ZenML](https://docs.zenml.io/user-guide/production-guide/connect-deployed-zenml) to collaborate with your colleagues.
+- Run the same pipeline on a [cloud MLOps stack in production](https://docs.zenml.io/user-guide/production-guide/cloud-stack).
+- Track your metrics in an experiment tracker like [MLflow](https://docs.zenml.io/stacks-and-components/component-guide/experiment-trackers/mlflow).
+
+## What next?
+
+* If you have questions or feedback... join our [**Slack Community**](https://zenml.io/slack) and become part of the ZenML family!
+* If you want to quickly get started with ZenML, check out the [ZenML Cloud](https://zenml.io/cloud).
diff --git a/.devcontainer/zenmlQuickstart/sections/trainingPipeline/finish.md b/.devcontainer/zenmlQuickstart/sections/trainingPipeline/finish.md
new file mode 100644
index 0000000..6ee1394
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/trainingPipeline/finish.md
@@ -0,0 +1,5 @@
+# Training Pipelines โ
+
+You can see from the logs already how our model training went: the
+`RandomForestClassifier` performed considerably better than the `SGDClassifier`.
+We can use the ZenML `Client` to verify this:
diff --git a/.devcontainer/zenmlQuickstart/sections/trainingPipeline/trainingPipeline1.md b/.devcontainer/zenmlQuickstart/sections/trainingPipeline/trainingPipeline1.md
new file mode 100644
index 0000000..08c6cee
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/trainingPipeline/trainingPipeline1.md
@@ -0,0 +1,25 @@
+# Training Pipelines โ
+
+Now that we have our data it makes sense to train some models to get a sense of
+how difficult the task is. The Breast Cancer dataset is sufficiently large and complex
+that it's unlikely we'll be able to train a model that behaves perfectly since the problem
+is inherently complex, but we can get a sense of what a reasonable baseline looks like.
+
+We'll start with two simple models, a SGD Classifier and a Random Forest
+Classifier, both batteries-included from `sklearn`. We'll train them both on the
+same data and then compare their performance.
+
+
+
+Our two training steps both return different kinds of `sklearn` classifier
+models, so we use the generic `ClassifierMixin` type hint for the return type.
+
+ZenML allows you to load any version of any dataset that is tracked by the framework
+directly into a pipeline using the `Client().get_artifact_version` interface. This is very convenient
+in this case, as we'd like to send our preprocessed dataset from the older pipeline directly
+into the training pipeline.
+
+The end goal of this quick baseline evaluation is to understand which of the two
+models performs better. We'll use the `evaluator` step to compare the two
+models. This step takes in the model from the trainer step, and computes its score
+over the testing set.
diff --git a/.devcontainer/zenmlQuickstart/sections/trainingPipeline/trainingPipeline1.py b/.devcontainer/zenmlQuickstart/sections/trainingPipeline/trainingPipeline1.py
new file mode 100644
index 0000000..8c8e1f5
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/trainingPipeline/trainingPipeline1.py
@@ -0,0 +1,95 @@
+import pandas as pd
+from sklearn.base import ClassifierMixin
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import SGDClassifier
+from typing_extensions import Annotated
+from zenml import ArtifactConfig, step, pipeline
+from zenml.logger import get_logger
+from typing import Optional, List
+from uuid import UUID
+logger = get_logger(__name__)
+
+from pipelines import feature_engineering
+from steps import model_evaluator
+from zenml.client import Client
+
+# Initialize the ZenML client to fetch objects from the ZenML Server
+client = Client()
+dataset_trn_artifact_version = client.get_artifact_version("dataset_trn")
+dataset_tst_artifact_version = client.get_artifact_version("dataset_tst")
+@step
+def model_trainer(
+ dataset_trn: pd.DataFrame,
+ model_type: str = "sgd",
+) -> Annotated[ClassifierMixin, ArtifactConfig(name="sklearn_classifier", is_model_artifact=True)]:
+ """Configure and train a model on the training dataset."""
+ target = "target"
+ if model_type == "sgd":
+ model = SGDClassifier()
+ elif model_type == "rf":
+ model = RandomForestClassifier()
+ else:
+ raise ValueError(f"Unknown model type {model_type}")
+
+ logger.info(f"Training model {model}...")
+
+ model.fit(
+ dataset_trn.drop(columns=[target]),
+ dataset_trn[target],
+ )
+ return model
+
+@pipeline
+def training(
+ train_dataset_id: Optional[UUID] = None,
+ test_dataset_id: Optional[UUID] = None,
+ model_type: str = "sgd",
+ min_train_accuracy: float = 0.0,
+ min_test_accuracy: float = 0.0,
+):
+
+
+ """Model training pipeline."""
+ if train_dataset_id is None or test_dataset_id is None:
+ # If we dont pass the IDs, this will run the feature engineering pipeline
+ dataset_trn, dataset_tst = feature_engineering()
+ else:
+ # Load the datasets from an older pipeline
+ dataset_trn = client.get_artifact_version(name_id_or_prefix=train_dataset_id)
+ dataset_tst = client.get_artifact_version(name_id_or_prefix=test_dataset_id)
+
+ trained_model = model_trainer(
+ dataset_trn=dataset_trn,
+ model_type=model_type,
+ )
+
+ model_evaluator(
+ model=trained_model,
+ dataset_trn=dataset_trn,
+ dataset_tst=dataset_tst,
+ min_train_accuracy=min_train_accuracy,
+ min_test_accuracy=min_test_accuracy,
+ )
+
+
+# Use a random forest model with the chosen datasets.
+# We need to pass the ID's of the datasets into the function
+training(
+ model_type="rf",
+ train_dataset_id=dataset_trn_artifact_version.id,
+ test_dataset_id=dataset_tst_artifact_version.id
+)
+
+rf_run = client.get_pipeline("training").last_run
+# Use a SGD classifier
+sgd_run = training(
+ model_type="sgd",
+ train_dataset_id=dataset_trn_artifact_version.id,
+ test_dataset_id=dataset_tst_artifact_version.id
+)
+
+sgd_run = client.get_pipeline("training").last_run
+
+# The evaluator returns a float value with the accuracy
+
+print(rf_run.steps["model_evaluator"].output.load() > sgd_run.steps["model_evaluator"].output.load())
diff --git a/.devcontainer/zenmlQuickstart/sections/welcome/code1.py b/.devcontainer/zenmlQuickstart/sections/welcome/code1.py
new file mode 100644
index 0000000..33428c4
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/welcome/code1.py
@@ -0,0 +1 @@
+print("Hello from code example 1!")
diff --git a/.devcontainer/zenmlQuickstart/sections/welcome/finish.md b/.devcontainer/zenmlQuickstart/sections/welcome/finish.md
new file mode 100644
index 0000000..8574f0c
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/welcome/finish.md
@@ -0,0 +1,3 @@
+# Welcome to the ZenML Quickstart Guide ๐
+
+Awesome! Well done! You are now ready to move on to the next section.
diff --git a/.devcontainer/zenmlQuickstart/sections/welcome/image.png b/.devcontainer/zenmlQuickstart/sections/welcome/image.png
new file mode 100644
index 0000000..6826d77
Binary files /dev/null and b/.devcontainer/zenmlQuickstart/sections/welcome/image.png differ
diff --git a/.devcontainer/zenmlQuickstart/sections/welcome/welcome.md b/.devcontainer/zenmlQuickstart/sections/welcome/welcome.md
new file mode 100644
index 0000000..0c662b6
--- /dev/null
+++ b/.devcontainer/zenmlQuickstart/sections/welcome/welcome.md
@@ -0,0 +1,15 @@
+# Welcome to the ZenML Quickstart Guide ๐
+
+This vscode extension running in codespaces gives you a sandboxed place to explore using ZenML.
+
+This repository is a minimalistic MLOps project intended as a starting point to learn how to put ML workflows in production. It features:
+
+- A feature engineering pipeline that loads data and prepares it for training.
+- A training pipeline that loads the preprocessed dataset and trains a model.
+- A batch inference pipeline that runs predictions on the trained model with new data.
+
+Follow along this notebook to understand how you can use ZenML to productionalize your ML workflows!
+
+
+
+Try running the code by clicking the `run code` button in the top right corner of this panel.
diff --git a/.gitignore b/.gitignore
index 439ea1a..7877556 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,51 @@
-.zen
\ No newline at end of file
+.zen
+__pycache__/
+*.py[cod]
+*$py.class
+sectionsBackup
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
\ No newline at end of file