-
-
-
-
-
-```python
+ {'MODULE[main]': {'content': [{'FUNCTION[main]': {'content': {'args': {'Arguments(0)': {'content': [],
+ 'metadata': {'loc': {line: -1, col: -1},
+ 'comment': '',
+ 'ref': '',
+ 'kind': - OUTPUT - -
-
-
-{'MODULE[main]': {'content': [{'FUNCTION[main]': {'content': {'args': {'Arguments(0)': {'content': [],
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-'body': {'BLOCK': {'content': [{'VariableDeclaration[a, Int32]': {'content': {'Literal[Int32]: 1': {'content': 1,
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': 'c4848732a3c542f1b3818bc799dc0b26',
-'kind': }}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-{'VariableDeclaration[b, Int32]': {'content': {'Literal[Int32]: 2': {'content': 2,
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': 'b63f0bf700194bb7abbdf99d8cc20336',
-'kind': }}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-{'VariableDeclaration[c, Int32]': {'content': {'Literal[Int32]: 4': {'content': 4,
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '0c0686b5f12a45bd9ff1a20da82702a0',
-'kind': }}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-{'RETURN': {'content': {'BINARY[+]': {'content': {'lhs': {'BINARY[-]': {'content': {'lhs': {'BINARY[+]': {'content': {'lhs': {'Literal[Int32]: 1': {'content': 1,
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '8d5d86d52b98484a8e5947ae4e6556f1',
-'kind': }}},
-'rhs': {'Variable[b]': {'content': 'b',
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-'rhs': {'BINARY[/]': {'content': {'lhs': {'BINARY[*]': {'content': {'lhs': {'Variable[a]': {'content': 'a',
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-'rhs': {'Variable[c]': {'content': 'c',
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-'rhs': {'Variable[a]': {'content': 'a',
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-'rhs': {'BINARY[-]': {'content': {'lhs': {'Variable[b]': {'content': 'b',
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-'rhs': {'BINARY[/]': {'content': {'lhs': {'Variable[a]': {'content': 'a',
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-'rhs': {'Variable[a]': {'content': 'a',
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}],
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}},
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}],
-'metadata': {'loc': {line: -1, col: -1},
-'comment': '',
-'ref': '',
-'kind': }}}
-
-
-
-
-
-
-
-We can also get the PNG representation of parts of the AST, such as `basic_op` and the variable `a`:
-
-
-```python
+``` python
# Create PNG representation
basic_op
```
-
-
-
-
-
-
-
-- OUTPUT - -
-
-
-
-
-
-
-
-
-
-
-
-```python
+``` python
# Create PNG representation
a
```
-
-
-
-
-
-
-
-
-- OUTPUT - -
-
-
-
-
-
-
-
-
-
## Custom shapes
-It is also possible to use custom shapes for the output using the function `viz.visualize`. The Default shape is `box`, but `diamond`, `ellipse`, and `circle` are also avaiable options.
+It is also possible to use custom shapes for the output using the
+function `viz.visualize`. The Default shape is `box`, but `diamond`,
+`ellipse`, and `circle` are also avaiable options.
-
-```python
+``` python
# Import visualization module
from astx import viz
@@ -359,36 +302,28 @@ from astx import viz
viz.visualize(a.get_struct(), shape="diamond")
```
-
-
-
-
-
-```python
+``` python
# Create PNG representation with circle shape
viz.visualize(a.get_struct(), shape="circle")
```
-
-
-
-
-
-```python
+``` python
# Create PNG representation with ellipse shape
viz.visualize(a.get_struct(), shape="ellipse")
```
-
-
-
-
# Conclusion
-This guide provides clear instructions and a simple example for you to start using the ASTx library. But this is just the beginning of your journey. Make sure to check out the other tutorials available, such as the one for [variables](https://github.com/arxlang/astx/blob/main/docs/tutorials/variables.ipynb) and the one for [functions](https://github.com/arxlang/astx/blob/main/docs/tutorials/functions.ipynb).
+This guide provides clear instructions and a simple example for you to
+start using the ASTx library. But this is just the beginning of your
+journey. Make sure to check out the other tutorials available, such as
+the one for
+[variables](https://github.com/arxlang/astx/blob/main/docs/tutorials/variables.ipynb)
+and the one for
+[functions](https://github.com/arxlang/astx/blob/main/docs/tutorials/functions.ipynb).
\ No newline at end of file
diff --git a/pages/blog/console-based-representation-in-astx/index.qmd b/pages/blog/console-based-representation-in-astx/index.qmd
new file mode 100644
index 000000000..5ea1c5f68
--- /dev/null
+++ b/pages/blog/console-based-representation-in-astx/index.qmd
@@ -0,0 +1,357 @@
+---
+title: "Console-based representation in ASTx"
+slug: "console-based-representation-in-astx"
+date: 2024-08-08
+authors: ["Ana Krelling", "Ivan Ogasawara"]
+tags: ["abstract syntax tree", "ascii", "console"]
+categories: ["abstract syntax tree", "console"]
+description: |
+ Recently, console-based AST representation was included in the ASTx framework. Such feature can enhance the debugging and analysis capabilities of ASTx, particularly in environments such as a pdb session. In this tutorial, we'll explore this new feature as well as the ASTx Graphviz visualization.
+thumbnail: "/header.png"
+template: "blog-post.html"
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+# Introduction
+
+The ASTx library is an agnostic framework for constructing and representing Abstract Syntax Trees (ASTs). Its primary objective is to provide a versatile and language-independent structure for ASTs, with the flexibility to be utilized across various programming languages and parsing tools. ASTx doesn't aim to be a lexer or a parser, although it could be used by any programming language or parser written in Python in order to provide a high level representation of the AST.
+
+Many kinds of nodes (classes) are currently supported. Below is a list with just some examples:
+
+##### Statements:
+* Function
+* Function Prototype
+* FunctionReturn
+* ForRangeLoop
+* VarDecl
+
+##### Operators:
+* BinaryOp
+* UnaryOp
+
+##### Data types:
+* Boolean
+* Literal
+* Variable
+
+
+The ASTx project is still under development, so new classes may be added to the ones above at any time.
+
+Below are installation instructions and an example, so you can have an overview of how you can leverage the ASTx library for your needs.
+
+# Installation
+The first step is to install ASTx. You can do it simply by running the command below in your terminal:\
+`$ pip install astx`\
+If you need more information on installation, you can get it in the [ASTx installation page](https://github.com/arxlang/astx/blob/main/docs/installation.md).
+After that, you can just open a Jupyter Notebook instance and start writing your first AST.
+
+
+# Example: an AST of a series of mathematical operations
+Here we will present a quick example of an AST of the expression \
+`basic_op = lit_1 + b - a * c / a + (b - a / a)`, in which \
+$~~~~$ `lit_1` is a defined integer, and \
+$~~~~$ `a`, `b`, and `c` are variables.\
+The first thing to do is, in your Jupyter Notebook instance, import `display`, which will allow you to have a basic visualization of the AST, and the astx library itself.
+
+
+```python
+# import display for AST visualization
+import astx
+
+from astx.viz import graph_to_ascii, traverse_ast_ascii
+```
+
+Then we create an instance of the Module class, and this instance will be the first node of the tree, or the root node. After that, we declare the variables and literal that will be part of the basic operation that we will parse into an AST.
+
+
+```python
+# Create module
+module = astx.Module()
+
+# Declare variables
+decl_a = astx.VariableDeclaration(name="a", type_=astx.Int32, value=astx.LiteralInt32(1))
+decl_b = astx.VariableDeclaration(name="b", type_=astx.Int32, value=astx.LiteralInt32(2))
+decl_c = astx.VariableDeclaration(name="c", type_=astx.Int32, value=astx.LiteralInt32(4))
+
+a = astx.Variable(name="a")
+b = astx.Variable(name="b")
+c = astx.Variable(name="c")
+
+# Declare literal
+lit_1 = astx.LiteralInt32(1)
+
+# State the expression
+basic_op = lit_1 + b - a * c / a + (b - a / a)
+```
+
+After the basic expression is stated, we create an instance of the Function class. As mentioned in the API documentation, each instance of the Function class must have a prototype and a body, so we'll create those first.
+
+The body is made of a block that is created and the variables, as well as the basic operation, are appended to it afterwards.
+
+
+```python
+# Create FunctionPrototype
+main_proto = astx.FunctionPrototype(
+ name="main", args=astx.Arguments(), return_type=astx.Int32
+)
+
+# Create FunctionReturn
+main_block = astx.Block()
+main_block.append(decl_a)
+main_block.append(decl_b)
+main_block.append(decl_c)
+main_block.append(astx.FunctionReturn(basic_op))
+
+# Create Function
+main_fn = astx.Function(prototype=main_proto, body=main_block)
+
+# Append function to module
+module.block.append(main_fn)
+```
+
+After this, the module is complete. We can get its AST structure as a dictionary, as well as a PNG representation.
+
+
+```python
+# Create dictionary representation
+module.get_struct()
+```
+
+
+
+
+ {'MODULE[main]': {'content': [{'FUNCTION[main]': {'content': {'args': {'Arguments(0)': {'content': [],
+ 'metadata': {'loc': {line: -1, col: -1},
+ 'comment': '',
+ 'ref': '',
+ 'kind': - OUTPUT - -
-
-
-
-
-
-
+
-As my Google Summer of Code journey continued, I found myself faced with an
-exciting yet daunting task: implementing a whole new build-system as an option
-for templates in the esteemed Open-Science Lab. This endeavor demanded
-meticulous planning, unwavering dedication, and the exploration of various
-build-systems, including Maturin, Hatchling, Scikit-build, and `pybuild11`.
+As my Google Summer of Code journey continued, I found myself faced with
+an exciting yet daunting task: implementing a whole new build-system as
+an option for templates in the esteemed Open-Science Lab. This endeavor
+demanded meticulous planning, unwavering dedication, and the exploration
+of various build-systems, including Maturin, Hatchling, Scikit-build,
+and `pybuild11`.
-In this period, I started working on to add support for `Maturin` build-system.
+In this period, I started working on to add support for `Maturin`
+build-system.
### Maturin
-[**Maturin**]() was the first build-system I explored. Its unique approach of
-building Python bindings for Rust libraries intrigued me, and I wondered if it
-could provide a novel solution to the lab's needs. The seamless blending of
-Python and Rust offered the potential for unparalleled performance and memory
-efficiency in research projects. However, I faced a steep learning curve to
-master the intricacies of Rust and its integration with Python. Overcoming these
-challenges was a significant achievement, and I managed to create a functional
-prototype that demonstrated Maturin's potential to revolutionize the
-Open-Science Lab's workflow. My contribution to this issue is
+[**Maturin**]() was the first build-system I explored. Its unique
+approach of building Python bindings for Rust libraries intrigued me,
+and I wondered if it could provide a novel solution to the lab’s needs.
+The seamless blending of Python and Rust offered the potential for
+unparalleled performance and memory efficiency in research projects.
+However, I faced a steep learning curve to master the intricacies of
+Rust and its integration with Python. Overcoming these challenges was a
+significant achievement, and I managed to create a functional prototype
+that demonstrated Maturin’s potential to revolutionize the Open-Science
+Lab’s workflow. My contribution to this issue is
[here](https://github.com/osl-incubator/scicookie/pull/152)
-After merging this pull request, I started to add support for `Hatchling`
-build-system.
+After merging this pull request, I started to add support for
+`Hatchling` build-system.
### Hatchling
-[**Hatchling**]() known for its user-friendly nature, was my next target. It
-promised to simplify the build and deployment processes, which could be
-particularly beneficial for newcomers to the lab and projects with
-straightforward requirements. Integrating Hatchling into the lab's ecosystem
-required thorough documentation and integration tests to ensure its smooth
-adoption. Overcoming initial hurdles, I was elated to see the positive response
-from the lab's community as they began adopting Hatchling for their projects. My
-contribution to this issue is
-[here](https://github.com/osl-incubator/scicookie/pull/144)
+[**Hatchling**]() known for its user-friendly nature, was my next
+target. It promised to simplify the build and deployment processes,
+which could be particularly beneficial for newcomers to the lab and
+projects with straightforward requirements. Integrating Hatchling into
+the lab’s ecosystem required thorough documentation and integration
+tests to ensure its smooth adoption. Overcoming initial hurdles, I was
+elated to see the positive response from the lab’s community as they
+began adopting Hatchling for their projects. My contribution to this
+issue is [here](https://github.com/osl-incubator/scicookie/pull/144)
After completetion of this issue, I jumped to a task to add support for
`Scikit-Build-Core`.
### Scikit-build-core
-[**Scikit-build-core**]() a cross-platform build-system, offered a robust option
-for integrating CPython extensions. While challenging to implement, I recognized
-its potential to support projects with complex native code dependencies. My
-experience with Scikit-build exposed me to advanced build and packaging
-concepts, and I was thrilled to see it complementing the existing build-systems
-in the lab, catering to a broader range of projects. My contribution to this
-issue is [here](https://github.com/osl-incubator/scicookie/pull/161)
+[**Scikit-build-core**]() a cross-platform build-system, offered a
+robust option for integrating CPython extensions. While challenging to
+implement, I recognized its potential to support projects with complex
+native code dependencies. My experience with Scikit-build exposed me to
+advanced build and packaging concepts, and I was thrilled to see it
+complementing the existing build-systems in the lab, catering to a
+broader range of projects. My contribution to this issue is
+[here](https://github.com/osl-incubator/scicookie/pull/161)
### Conclusions
In conclusion, my Google Summer of Code experience with implementing new
-build-systems for the Open-Science Lab was a transformative journey. Overcoming
-hurdles with Maturin, embracing user-friendliness with Hatchling, exploring the
-potential of Scikit-build.I realized the importance of innovation and
-adaptability in the world of open-source development. This experience has not
-only enriched my technical skills but also instilled in me a passion for
-contributing to projects that drive positive change in the world of scientific
-research. As I look to the future, I am excited to continue this journey,
-collaborating with the open-source community to create solutions that empower
-researchers and advance the boundaries of knowledge.
+build-systems for the Open-Science Lab was a transformative journey.
+Overcoming hurdles with Maturin, embracing user-friendliness with
+Hatchling, exploring the potential of Scikit-build.I realized the
+importance of innovation and adaptability in the world of open-source
+development. This experience has not only enriched my technical skills
+but also instilled in me a passion for contributing to projects that
+drive positive change in the world of scientific research. As I look to
+the future, I am excited to continue this journey, collaborating with
+the open-source community to create solutions that empower researchers
+and advance the boundaries of knowledge.
You can read my previous blog [here](https://medium.com/@ayeankit)
If want to connect with me on LinkedIn
[here](https://www.linkedin.com/in/ayeankit/). Github
-[here](https://github.com/ayeankit).
+[here](https://github.com/ayeankit).
\ No newline at end of file
diff --git a/pages/blog/google-summer-of-code-week-4th-and-7th-midterm-evaluation/index.qmd b/pages/blog/google-summer-of-code-week-4th-and-7th-midterm-evaluation/index.qmd
new file mode 100644
index 000000000..5575b80a0
--- /dev/null
+++ b/pages/blog/google-summer-of-code-week-4th-and-7th-midterm-evaluation/index.qmd
@@ -0,0 +1,90 @@
+---
+title: "Google Summer of Code- Week 4th & 7th Midterm Evaluation"
+slug: google-summer-of-code-week-4th-and-7th-midterm-evaluation
+date: 2023-07-25
+authors: ["Ankit Kumar"]
+tags: [google summer of code, gsoc, open-source open-sciencelab]
+categories: [open-source, gsoc]
+description: |
+ In this article, I will share the progress for Week 4th week to 7th week for my
+ contribution to Open-science labs as a part of Google Summer of Code 2023.
+thumbnail: "/GSoC-Vertical.png"
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+
+## Google Summer of Code- Week 4th & 7th Midterm Evaluation
+
+In this article, I will share the progress for Week 4th week to 7th week for my
+contribution to Open-science labs as a part of Google Summer of Code 2023.
+
+
+
+As my Google Summer of Code journey continued, I found myself faced with an
+exciting yet daunting task: implementing a whole new build-system as an option
+for templates in the esteemed Open-Science Lab. This endeavor demanded
+meticulous planning, unwavering dedication, and the exploration of various
+build-systems, including Maturin, Hatchling, Scikit-build, and `pybuild11`.
+
+In this period, I started working on to add support for `Maturin` build-system.
+
+### Maturin
+
+[**Maturin**]() was the first build-system I explored. Its unique approach of
+building Python bindings for Rust libraries intrigued me, and I wondered if it
+could provide a novel solution to the lab's needs. The seamless blending of
+Python and Rust offered the potential for unparalleled performance and memory
+efficiency in research projects. However, I faced a steep learning curve to
+master the intricacies of Rust and its integration with Python. Overcoming these
+challenges was a significant achievement, and I managed to create a functional
+prototype that demonstrated Maturin's potential to revolutionize the
+Open-Science Lab's workflow. My contribution to this issue is
+[here](https://github.com/osl-incubator/scicookie/pull/152)
+
+After merging this pull request, I started to add support for `Hatchling`
+build-system.
+
+### Hatchling
+
+[**Hatchling**]() known for its user-friendly nature, was my next target. It
+promised to simplify the build and deployment processes, which could be
+particularly beneficial for newcomers to the lab and projects with
+straightforward requirements. Integrating Hatchling into the lab's ecosystem
+required thorough documentation and integration tests to ensure its smooth
+adoption. Overcoming initial hurdles, I was elated to see the positive response
+from the lab's community as they began adopting Hatchling for their projects. My
+contribution to this issue is
+[here](https://github.com/osl-incubator/scicookie/pull/144)
+
+After completetion of this issue, I jumped to a task to add support for
+`Scikit-Build-Core`.
+
+### Scikit-build-core
+
+[**Scikit-build-core**]() a cross-platform build-system, offered a robust option
+for integrating CPython extensions. While challenging to implement, I recognized
+its potential to support projects with complex native code dependencies. My
+experience with Scikit-build exposed me to advanced build and packaging
+concepts, and I was thrilled to see it complementing the existing build-systems
+in the lab, catering to a broader range of projects. My contribution to this
+issue is [here](https://github.com/osl-incubator/scicookie/pull/161)
+
+### Conclusions
+
+In conclusion, my Google Summer of Code experience with implementing new
+build-systems for the Open-Science Lab was a transformative journey. Overcoming
+hurdles with Maturin, embracing user-friendliness with Hatchling, exploring the
+potential of Scikit-build.I realized the importance of innovation and
+adaptability in the world of open-source development. This experience has not
+only enriched my technical skills but also instilled in me a passion for
+contributing to projects that drive positive change in the world of scientific
+research. As I look to the future, I am excited to continue this journey,
+collaborating with the open-source community to create solutions that empower
+researchers and advance the boundaries of knowledge.
+
+You can read my previous blog [here](https://medium.com/@ayeankit)
+
+If want to connect with me on LinkedIn
+[here](https://www.linkedin.com/in/ayeankit/). Github
+[here](https://github.com/ayeankit).
diff --git a/pages/blog/internship-call-2-2024/index.md b/pages/blog/internship-call-2-2024/index.md
index 082952d53..4e1d5b1f0 100644
--- a/pages/blog/internship-call-2-2024/index.md
+++ b/pages/blog/internship-call-2-2024/index.md
@@ -16,8 +16,9 @@ categories:
- Mentors
- Technology Students
description: >
- The Open Science Labs (OSL) has announced its Internship and Learning Program
- for the second cycle of 2024, in collaboration with The GRAPH Network.
+ The Open Science Labs (OSL) has announced its Internship and
+ Learning Program for the second cycle of 2024, in collaboration with The GRAPH
+ Network.
thumbnail: "/header.jpg"
template: "blog-post.html"
---
@@ -30,41 +31,34 @@ template: "blog-post.html"
overflow: hidden;
box-shadow: 0 0 20px rgba(0, 0, 0, 0.1);
}
-
- th, td {
+
th, td {
border: 1px solid #ddd;
padding: 12px;
text-align: left;
transition: background-color 0.3s;
color: #000; /* Cambio del color del texto a negro */
}
-
- th {
+
th {
background-color: #74c69d; /* Color del título */
color: #000;
}
-
- td {
+
td {
background-color: #d8f3dc;
}
-
- tr:hover td {
+
tr:hover td {
background-color: #f2f2f2;
}
-
- pre {
+
pre {
background-color: #f8f8f8;
padding: 10px;
border: 1px solid #ddd;
overflow-x: auto;
}
-
- a {
+
a {
color: #3498db;
text-decoration: none;
}
-
- a:hover {
+
a:hover {
text-decoration: underline;
}
@@ -72,92 +66,94 @@ template: "blog-post.html"
This program presents valuable opportunities for both mentors and
-student/collaborators to engage and grow, despite being an unpaid initiative.
+student/collaborators to engage and grow, despite being an unpaid
+initiative.
## Summary of steps to got into internship program
-- Choose a project of your interest. Please read the project ideas document and
- see if yout meet the prerequisites or the stack required (normally the mentor
- rejects applicants if they do not meet the stack required)
+- Choose a project of your interest. Please read the project ideas
+ document and see if yout meet the prerequisites or the stack required
+ (normally the mentor rejects applicants if they do not meet the stack
+ required)
- Contact to the project mentor through email with the following info.
- Curriculum Vitae
- The project name
- Project idea name
- Motivation for wanting to collaborate on that specific project.
-- The mentor will assign you a minor issue to solve. (This step is required to
- verify if the applicant is able to solve the project tasks.)
-- After solving the issue The mentor will ask you to fill a form via google
- forms.
+- The mentor will assign you a minor issue to solve. (This step is
+ required to verify if the applicant is able to solve the project
+ tasks.)
+- After solving the issue The mentor will ask you to fill a form via
+ google forms.
- The selected applicant will be contacted via email on May 20.
-Candidates should have a basic understanding of Git and how to contribute. For
-guidance, we recommend reading this
-[blog post](https://opensciencelabs.org/blog/first-time-contributors/) designed
-for first-time contributors. Additionally, to stay informed about announcements
-related to the Internship Program, candidates are encouraged to join the
-[OSL Discord](https://opensciencelabs.org/discord).
+Candidates should have a basic understanding of Git and how to
+contribute. For guidance, we recommend reading this [blog
+post](https://opensciencelabs.org/blog/first-time-contributors/)
+designed for first-time contributors. Additionally, to stay informed
+about announcements related to the Internship Program, candidates are
+encouraged to join the [OSL
+Discord](https://opensciencelabs.org/discord).
-Please keep in mind about the timeline, and if you have any more questions do
-not hesitate to contact us at team@opensciencelabs.org.
+Please keep in mind about the timeline, and if you have any more
+questions do not hesitate to contact us at team@opensciencelabs.org.
## Timeline
-The following is the timeline for the OSL Internship Program Cycle 2024-02:
+The following is the timeline for the OSL Internship Program Cycle
+2024-02:
- **April 22**: Call for Interns opens.
- **May 13**: Deadline for Interns applications.
-- **May 20**: Announcement of approved Interns and start of the bonding period
-- **May 27**: Official Start Date of Internship Period; an alternative for
- projects not selected by GSoC to run under the OSL Internship Program with The
- Graph Network support.
+- **May 20**: Announcement of approved Interns and start of the bonding
+ period
+- **May 27**: Official Start Date of Internship Period; an alternative
+ for projects not selected by GSoC to run under the OSL Internship
+ Program with The Graph Network support.
- **July 8**: Mid-term Evaluation.
- **August 26**: Final Evaluation.
- **September 3**: Official End Date; Certification process begins.
-## Info about participating Projects
+## \## Info about participating Projects
----
-
-Below is the list of projects participating in the current internship cycle.
-Each entry provides key details to assist candidates in understanding the scope
-and requirements of the projects.
+Below is the list of projects participating in the current internship
+cycle. Each entry provides key details to assist candidates in
+understanding the scope and requirements of the projects.
### ArtBox
-- **Description:** ArtBox is a tool set for handling multimedia files with a
- bunch of useful functions.
+- **Description:** ArtBox is a tool set for handling multimedia files
+ with a bunch of useful functions.
- **Category:** Multimedia Processing.
- **Organization/Project Webpage URL:**
- [https://mediatoolbox-org.github.io/artbox/](https://mediatoolbox-org.github.io/artbox/)
-- **Contact:** Ivan Ogasawara
- [ivan.ogasawara@gmail.com](mailto:ivan.ogasawara@gmail.com)
+
-
-
+ Overwriting .makim.yaml
-```python
+``` python
!makim --makim-file ./.makim.yaml backend_python.lint
!makim --makim-file ./.makim.yaml backend_java.test
!makim --makim-file ./.makim.yaml frontend_react.test
!makim --makim-file ./.makim.yaml frontend_vue.build
```
-- OUTPUT - -
-
-
-Overwriting .makim.yaml
-
-
-
-
-
+ Linting Python code...
+ Running Java backend tests...
+ Running React frontend tests...
+ Building Vue.js frontend...
## Conclusion
-In conclusion, Makim's working-directory feature empowers users with a flexible and efficient approach to project management. Throughout this blog, we explored how this feature, applied at the global, group, and target scopes, provides unparalleled customization and control over the execution environment.
-
-By isolating commands, offering flexibility in configuration, and ensuring ease of use, Makim's working-directory feature becomes an invaluable asset in your toolkit. It not only streamlines the execution of commands but also enhances the overall organization and maintainability of your projects.
-
-Harness the power of working directories in Makim to elevate your project management game. As you integrate this tool into your workflow, you'll discover a newfound simplicity and clarity in your command execution. Enjoy the benefits of an organized and optimized project environment, courtesy of Makim's innovative features.
-
-Start optimizing your projects with Makim today!
+In conclusion, Makim’s working-directory feature empowers users with a
+flexible and efficient approach to project management. Throughout this
+blog, we explored how this feature, applied at the global, group, and
+target scopes, provides unparalleled customization and control over the
+execution environment.
+
+By isolating commands, offering flexibility in configuration, and
+ensuring ease of use, Makim’s working-directory feature becomes an
+invaluable asset in your toolkit. It not only streamlines the execution
+of commands but also enhances the overall organization and
+maintainability of your projects.
+
+Harness the power of working directories in Makim to elevate your
+project management game. As you integrate this tool into your workflow,
+you’ll discover a newfound simplicity and clarity in your command
+execution. Enjoy the benefits of an organized and optimized project
+environment, courtesy of Makim’s innovative features.
+
+Start optimizing your projects with Makim today!
\ No newline at end of file
diff --git a/pages/blog/makim-efficient-workflows-with-makims-working-directory/index.qmd b/pages/blog/makim-efficient-workflows-with-makims-working-directory/index.qmd
new file mode 100644
index 000000000..e4af21b3c
--- /dev/null
+++ b/pages/blog/makim-efficient-workflows-with-makims-working-directory/index.qmd
@@ -0,0 +1,196 @@
+---
+title: "Efficent Workflows with Makim's Working Directory"
+slug: "makim-efficient-workflows-with-makims-working-directory"
+date: 2023-12-10
+authors: ["Abhijeet Saroha"]
+tags: ["makim", "automation", "working-directory", "devops", "open-source"]
+categories: ["devops", "automation", "python"]
+description: |
+ In this blog post, we'll explore the Working Directory feature, understand
+ its syntax, and witness its power in action through real-world examples. Whether
+ you're a Makim veteran or a newcomer, this feature is designed to make your
+ command-line experience more flexible and tailored to your project's needs.
+ Let's dive into the details and unleash the potential of Makim's Working Directory
+ feature!
+thumbnail: "/header.jpg"
+template: "blog-post.html"
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+# **Efficent Workflows with Makim's Working Directory**
+
+Welcome to the world of [Makim](https://github.com/osl-incubator/makim), your go-to command-line companion for project automation. In our ongoing effort to enhance Makim's capabilities, we've introduced an exciting new feature—the Working Directory. This feature brings a new level of control and flexibility to your project workflows.
+
+In this blog post, we'll explore the Working Directory feature, understand its syntax, and witness its power in action through real-world examples. Whether you're a Makim veteran or a newcomer, this feature is designed to make your command-line experience more flexible and tailored to your project's needs. Let's dive into the details and unleash the potential of Makim's Working Directory feature!
+
+## Unveiling the attribute: working-directory
+
+In the bustling realm of project management, one of the key challenges is orchestrating a seamless workflow while ensuring command executions are precisely where they need to be. This is where Makim's **Working Directory** steps into the spotlight, offering a robust solution for organizing, customizing, and optimizing your project commands.
+
+## Syntax and Scopes
+
+The Working Directory feature in Makim operates across three distinct scopes: Global, Group, and Target.
+1. **Global Scope**
+
+ At the global scope, setting the working directory impacts all targets and groups within the Makim configuration. It provides a top-level directive to establish a standardized execution environment.
+```yaml
+version: 1.0
+working-directory: /path/to/global/directory
+
+# ... other configuration ...
+```
+
+2. **Group Scope**
+
+ Moving a level deeper, the group scope allows you to tailor the working directory for all targets within a specific group.
+```yaml
+version: 1.0
+
+groups:
+ my-group:
+ working-directory: /path/to/group/directory
+ targets:
+ target-1:
+ run: |
+ # This target operates within the /path/to/group/directory
+```
+3. **Target Scope**
+
+ For fine-grained control over individual targets, the working directory can be specified at the target scope.
+```yaml
+version: 1.0
+
+groups:
+ my-group:
+ targets:
+ my-target:
+ working-directory: /path/to/target/directory
+ run: |
+ # This target operates within the /path/to/target/directory
+```
+
+The flexibility provided by these scopes ensures that your commands are executed in precisely the right context, maintaining a clean and organized project structure.
+
+## Why is it helpful?
+
+Embracing the Working Directory feature in Makim brings forth a multitude of advantages, enhancing the overall project management experience. Let's delve into why this feature is a game-changer for your Makim configurations:
+1. **Isolation of Commands:**
+ Users can isolate commands within specific directories, avoiding potential conflicts and ensuring that commands run in the expected environment.
+
+2. **Flexibility in Configuration:**
+ Different targets or groups may require different execution environments. The working-directory attribute provides the flexibility to customize these environments, tailoring them to the unique needs of each segment of your project.
+
+3. **Ease of Use:**
+ Users can easily understand and manage the execution context of commands within the Makim configuration. This makes the configuration more readable and maintainable, especially when dealing with complex project structures.
+
+4. **Support for Absolute and Relative Paths:**
+ The feature supports both absolute and relative paths, allowing users to specify directories based on their requirements. This flexibility ensures compatibility with diverse project structures and simplifies the configuration process.
+
+## Real-Life Example
+
+Consider a scenario where a development team is working on a project that involves multiple programming languages and technologies. The project structure looks like this:
+
+```
+multi_language_project/
+│
+├── backend/
+│ ├── python/
+│ │ └── src/
+│ └── java/
+│ └── src/
+│
+└── frontend/
+ ├── react/
+ │ └── src/
+ └── vue/
+ └── src/
+```
+
+The project consists of a backend with components implemented in both Python and Java, and a frontend with components using React and Vue.js. To efficiently manage and run tasks for each language or framework, the Working Directory feature proves invaluable.
+
+Let's create a Makim configuration file *(.makim.yaml)* that showcases the flexibility of the Working Directory feature in managing tasks for different languages.
+
+
+```python
+%%writefile .makim.yaml
+version: 1.0
+working-directory: "/tmp/multi_language_project"
+groups:
+ backend_python:
+ working-directory: "backend/python"
+ targets:
+ test:
+ run: |
+ echo "Running Python backend tests..."
+ # Add commands to run Python backend tests
+ lint:
+ run: |
+ echo "Linting Python code..."
+ # Add commands for linting Python code
+
+ backend_java:
+ working-directory: "backend/java"
+ targets:
+ test:
+ working-directory: "src"
+ run: |
+ echo "Running Java backend tests..."
+ # Add commands to run Java backend tests
+ build:
+ run: |
+ echo "Building Java artifacts..."
+ # Add commands for building Java artifacts
+
+ frontend_react:
+ working-directory: "frontend/react"
+ targets:
+ test:
+ run: |
+ echo "Running React frontend tests..."
+ # Add commands to run React frontend tests
+ build:
+ run: |
+ echo "Building React frontend..."
+ # Add commands for building React frontend
+
+ frontend_vue:
+ working-directory: "frontend/vue"
+ targets:
+ test:
+ run: |
+ echo "Running Vue.js frontend tests..."
+ # Add commands to run Vue.js frontend tests
+ build:
+ working-directory: "src"
+ run: |
+ echo "Building Vue.js frontend..."
+ # Add commands for building Vue.js frontend
+```
+
+ Overwriting .makim.yaml
+
+
+
+```python
+!makim --makim-file ./.makim.yaml backend_python.lint
+!makim --makim-file ./.makim.yaml backend_java.test
+!makim --makim-file ./.makim.yaml frontend_react.test
+!makim --makim-file ./.makim.yaml frontend_vue.build
+```
+
+ Linting Python code...
+ Running Java backend tests...
+ Running React frontend tests...
+ Building Vue.js frontend...
+
+
+## Conclusion
+
+In conclusion, Makim's working-directory feature empowers users with a flexible and efficient approach to project management. Throughout this blog, we explored how this feature, applied at the global, group, and target scopes, provides unparalleled customization and control over the execution environment.
+
+By isolating commands, offering flexibility in configuration, and ensuring ease of use, Makim's working-directory feature becomes an invaluable asset in your toolkit. It not only streamlines the execution of commands but also enhances the overall organization and maintainability of your projects.
+
+Harness the power of working directories in Makim to elevate your project management game. As you integrate this tool into your workflow, you'll discover a newfound simplicity and clarity in your command execution. Enjoy the benefits of an organized and optimized project environment, courtesy of Makim's innovative features.
+
+Start optimizing your projects with Makim today!
diff --git a/pages/blog/my-google-summer-of-code-journey/index.md b/pages/blog/my-google-summer-of-code-journey/index.md
index b2c146054..861fde8b5 100644
--- a/pages/blog/my-google-summer-of-code-journey/index.md
+++ b/pages/blog/my-google-summer-of-code-journey/index.md
@@ -11,90 +11,189 @@ template: "blog-post.html"
---
# About Me
-I am [Kishan Ved](https://github.com/Kishan-Ved), an undergraduate student at the Indian Institute of Technology Gandhinagar (IIT Gandhinagar), India, in the department of Computer Science and Engineering. I spent the summer after my second year doing my Google Summer of Code 2024 project with the NumFOCUS organization (which serves as an umbrella organization for open source projects), which had Open Science Labs as a sub organization. The project I worked on is: [PyDataStructs](https://github.com/codezonediitj/pydatastructs).
+
+I am [Kishan Ved](https://github.com/Kishan-Ved), an
+undergraduate student at the Indian Institute of Technology Gandhinagar
+(IIT Gandhinagar), India, in the department of Computer Science and
+Engineering. I spent the summer after my second year doing my Google
+Summer of Code 2024 project with the NumFOCUS organization (which serves
+as an umbrella organization for open source projects), which had Open
+Science Labs as a sub organization. The project I worked on is:
+[PyDataStructs](https://github.com/codezonediitj/pydatastructs).
# About PyDataStructs
-[PyDataStructs](https://github.com/codezonediitj/pydatastructs) aims to be a Python package for various data structures in computer science. It also contains several algorithms including their parallel implementations. Everything is just a few calls away, and users don't need to write any code from scratch. The APIs provided are consistent with each other, clean and easy to use. All implementations are well tested, 99% lines of code have already been tested by developers. PyDataStructs is the first well-designed library/package which covers most of the data structures and algorithms, with different backends like Python and C++.
+[PyDataStructs](https://github.com/codezonediitj/pydatastructs)
+aims to be a Python package for various data structures in computer
+science. It also contains several algorithms including their parallel
+implementations. Everything is just a few calls away, and users don’t
+need to write any code from scratch. The APIs provided are consistent
+with each other, clean and easy to use. All implementations are well
+tested, 99% lines of code have already been tested by developers.
+PyDataStructs is the first well-designed library/package which covers
+most of the data structures and algorithms, with different backends like
+Python and C++.
## My first contribution to open source
-I began contributing to open source in December 2023, when I connected to a senior student at my university who had also done GSoC in 2023, with PyDataStructs. I was interested in the project that she did and hence I started exploring the codebase.
+
+I began contributing to open source in December 2023, when I connected
+to a senior student at my university who had also done GSoC in 2023,
+with PyDataStructs. I was interested in the project that she did and
+hence I started exploring the codebase.
### Finding a good first issue
-I went to the issues tab on the repository's github page and searched for good first issues. I noticed an issue that seemed doable: [Implement Introsort](https://github.com/codezonediitj/pydatastructs/issues/545). This involved implementing the sorting algorithm: Introsort in the Python backend. I had learned this as a part of my academic cousework, and hence, I was able to code this.
+
+I went to the issues tab on the repository’s github page and searched
+for good first issues. I noticed an issue that seemed doable:
+[Implement
+Introsort](https://github.com/codezonediitj/pydatastructs/issues/545).
+This involved implementing the sorting algorithm: Introsort in the
+Python backend. I had learned this as a part of my academic cousework,
+and hence, I was able to code this.
### My first Pull Request
-I started reading the README file and set up the repository locally and created the conda environment. Then I got to work. In a day, I was able to successfully create a PR (pull request) and open it on GitHub: [Implemented Introsort](https://github.com/codezonediitj/pydatastructs/pull/549). This PR was reviewed and changes were requested. Once I had done all of them and all the CI checks passed, it was merged. And that's my first open souce contribution!
+
+I started reading the README file and set up the repository locally and
+created the conda environment. Then I got to work. In a day, I was able
+to successfully create a PR (pull request) and open it on GitHub:
+[Implemented
+Introsort](https://github.com/codezonediitj/pydatastructs/pull/549).
+This PR was reviewed and changes were requested. Once I had done all of
+them and all the CI checks passed, it was merged. And that’s my first
+open souce contribution!
## Pre-GSoC Phase
-Next, I connected to the maintainer, [Gagandeep Singh](https://github.com/czgdp1807), and expressed my interest for contributing. He suggested that I contribute to more organizations, like: [LFortran](https://github.com/lfortran/lfortran) and [LPython](https://github.com/lcompilers/lpython) to maximize my chances for GSoC. These organizations also had Gagandeep Sir as the core maintainer and developer.
+Next, I connected to the maintainer, [Gagandeep
+Singh](https://github.com/czgdp1807), and expressed my interest for
+contributing. He suggested that I contribute to more organizations,
+like: [LFortran](https://github.com/lfortran/lfortran) and
+[LPython](https://github.com/lcompilers/lpython) to maximize my
+chances for GSoC. These organizations also had Gagandeep Sir as the core
+maintainer and developer.
### The amazing open source community
-I found the open source community amazing, everyone was ready to help me with every doubt I had, patiently guide me with differnt git commands to resolve conflicts and review my PRs and give valueable advice. I made new friends, who were almost of the same age as me, who had been contributing since quite a while. They made things easier for me and helped me contribute.
+
+I found the open source community amazing, everyone was ready to help me
+with every doubt I had, patiently guide me with differnt git commands to
+resolve conflicts and review my PRs and give valueable advice. I made
+new friends, who were almost of the same age as me, who had been
+contributing since quite a while. They made things easier for me and
+helped me contribute.
### More open source contributions
-I spent the next 3 months contributing to these organizations, and I had 10 merged PRs in the LFortran repository and 5 merged PRs in the LPython repository. Here's a link to these:
-- [LFortran contributions](https://github.com/lfortran/lfortran/pulls?q=is%3Apr+author%3AKishan-Ved+is%3Amerged)
+I spent the next 3 months contributing to these organizations, and I had
+10 merged PRs in the LFortran repository and 5 merged PRs in the LPython
+repository. Here’s a link to these:
+
+- [LFortran
+ contributions](https://github.com/lfortran/lfortran/pulls?q=is%3Apr+author%3AKishan-Ved+is%3Amerged)
-- [LPython contributions](https://github.com/lcompilers/lpython/pulls?q=is%3Apr+author%3AKishan-Ved+is%3Amerged)
+- [LPython
+ contributions](https://github.com/lcompilers/lpython/pulls?q=is%3Apr+author%3AKishan-Ved+is%3Amerged)
-These made me well versed with various git commands, the skill of handling a large and dynamic codebase and communicating effectively with the community to incorporate suggestions and solve issues.
+These made me well versed with various git commands, the skill of
+handling a large and dynamic codebase and communicating effectively with
+the community to incorporate suggestions and solve issues.
### Drafting my GSoC proposal
-Next, it was time to submit proposals for GSoC projects. By then, I had been contributing to open source for nearly 3 months. I requested a meeting with Gagandeep Sir to help me decide my proposal. He kindly agreed and we set up an online meeting, where we discussed potential GSoC ideas and the timeline that was best suited for me.
-I submitted 2 proposals, to LPython (Python Software Foundation) and PyDataStructs (NumFOCUS):
+Next, it was time to submit proposals for GSoC projects. By then, I had
+been contributing to open source for nearly 3 months. I requested a
+meeting with Gagandeep Sir to help me decide my proposal. He kindly
+agreed and we set up an online meeting, where we discussed potential
+GSoC ideas and the timeline that was best suited for me.
-- [NumFOCUS - Open Science Labs: PyDataStructs: Add C++ Backend for all trees](https://drive.google.com/file/d/1khpreH4pVJSj26VGJOf2v_XDCrOlo8qP/view?usp=sharing)
+I submitted 2 proposals, to LPython (Python Software Foundation) and
+PyDataStructs (NumFOCUS):
-- [Python Software Foundation - LPython: Implement modules from the Python Standard Library](https://drive.google.com/file/d/1to69uW9rb9vAE6pJCooamQo-Q1f_BYBt/view?usp=sharing)
+- [NumFOCUS - Open Science Labs: PyDataStructs: Add C++ Backend for
+ all
+ trees](https://drive.google.com/file/d/1khpreH4pVJSj26VGJOf2v_XDCrOlo8qP/view?usp=sharing)
-The proposals should have personal information, details about previous open source contributions made to the organization's repository, and detailed information about the project that you wish to take up, with a structured plan about your goals. In addition to this, it must contain an expected timeline that you will follow. It's a good practice to set a large number of small goals and plan tasks before starting the project.
+- [Python Software Foundation - LPython: Implement modules from the
+ Python Standard
+ Library](https://drive.google.com/file/d/1to69uW9rb9vAE6pJCooamQo-Q1f_BYBt/view?usp=sharing)
+
+The proposals should have personal information, details about previous
+open source contributions made to the organization’s repository, and
+detailed information about the project that you wish to take up, with a
+structured plan about your goals. In addition to this, it must contain
+an expected timeline that you will follow. It’s a good practice to set a
+large number of small goals and plan tasks before starting the project.
### Continuing open source contributions
-It's a good practice to remain active in the organizations by contributing even after submitting GSoC proposals, this makes the developers believe that you are genuinely interested in the project and enthusiastic to contribute. This amplifies chances for getting selected for Google Summer of Code!
+
+It’s a good practice to remain active in the organizations by
+contributing even after submitting GSoC proposals, this makes the
+developers believe that you are genuinely interested in the project and
+enthusiastic to contribute. This amplifies chances for getting selected
+for Google Summer of Code!
## GSoC Phase
-I got my acceptance letter at 11:32 pm IST on May 1, 2024. It was 2 minutes past the result declaration time and I was at the edge of my seat. I was overjoyed to get the mail saying I was accepted as a Google Summer of Code contributor for NumFOCUS! Here's my project: **[Open Science Labs: PyDataStructs: Add a C++ Backend for tree data structures and their algorithms](https://summerofcode.withgoogle.com/programs/2024/projects/2nrxEFTg)**
-### My GSoC project goals
+I got my acceptance letter at 11:32 pm IST on May 1, 2024. It was 2
+minutes past the result declaration time and I was at the edge of my
+seat. I was overjoyed to get the mail saying I was accepted as a Google
+Summer of Code contributor for NumFOCUS! Here’s my project: **[Open
+Science Labs: PyDataStructs: Add a C++ Backend for tree data structures
+and their
+algorithms](https://summerofcode.withgoogle.com/programs/2024/projects/2nrxEFTg)**
-My project involved adding a C++ backend for all tree data structures in **[PyDataStructs](https://github.com/codezonediitj/pydatastructs)**, a Python package for advanced data structures and algorithms. The user has an option to select either the Python backend or the C++ backend.
+### My GSoC project goals
+My project involved adding a C++ backend for all tree data structures in
+**[PyDataStructs](https://github.com/codezonediitj/pydatastructs)**, a
+Python package for advanced data structures and algorithms. The user has
+an option to select either the Python backend or the C++ backend.
-```python
+``` python
tree = RedBlackTree(backend=Backend.CPP)
```
-
-For any data structure, the Python backend is developed first, and once completely tested and ready, its C++ backend is developed. Both the backends share full functionality and are completely compatible. The C++ backend is extremely fast, it executes codes 8-10 times faster. This enhances the computation speed, making it extremely valuable for scientific computing and high-performance applications.
+For any data structure, the Python backend is developed first, and once
+completely tested and ready, its C++ backend is developed. Both the
+backends share full functionality and are completely compatible. The C++
+backend is extremely fast, it executes codes 8-10 times faster. This
+enhances the computation speed, making it extremely valuable for
+scientific computing and high-performance applications.
### The community bonding period
-I'll be honest, it was difficult at the start. I found the project a little more difficult than I had anticipated, and realized that it demanded a little more that my current skillset. My mentor, Gagandeep Sir, adviced me to read the documentation and first learn about Python-C API, which was something totally new for me. I spent the first week doing this, and I could barely write any code. However, I soon realized the importance of reading the documentation and how smoothly things went following that. Within a week, I became well versed with all the new technology and started coding up my first PR.
+
+I’ll be honest, it was difficult at the start. I found the project a
+little more difficult than I had anticipated, and realized that it
+demanded a little more that my current skillset. My mentor, Gagandeep
+Sir, adviced me to read the documentation and first learn about Python-C
+API, which was something totally new for me. I spent the first week
+doing this, and I could barely write any code. However, I soon realized
+the importance of reading the documentation and how smoothly things went
+following that. Within a week, I became well versed with all the new
+technology and started coding up my first PR.
### Coding phase
-I started working from the community bonding period itself, and this gave me a good headstart and allowed me to complete the project in 12 weeks. Here's an outline of all the work I did:
+I started working from the community bonding period itself, and this
+gave me a good headstart and allowed me to complete the project in 12
+weeks. Here’s an outline of all the work I did:
#### Pre GSoC Work
| PR Description |
-|------------------|
+|----|
| **[Added Introsort algorithm](https://github.com/codezonediitj/pydatastructs/pull/549)** |
| **[Fixed version related bugs](https://github.com/codezonediitj/pydatastructs/pull/553)** |
#### Community Bonding Period
| PR Description |
-|------------------|
+|----|
| **[C++ backend for Node, TreeNode, ArrayForTrees, BinaryTree and BinarySearchTree and all tree traversals implemented](https://github.com/codezonediitj/pydatastructs/pull/556)** |
#### Coding Phase 1
| PR Description |
-|------------------|
+|----|
| **[C++ backend for Self Balancing Binary Tree](https://github.com/codezonediitj/pydatastructs/pull/559)** |
| **[C++ backend for Red Black Trees](https://github.com/codezonediitj/pydatastructs/pull/560)** |
| **[C++ backend for Binary Indexed Trees](https://github.com/codezonediitj/pydatastructs/pull/561)** |
@@ -103,15 +202,14 @@ I started working from the community bonding period itself, and this gave me a g
#### Coding Phase 2
| PR Description |
-|------------------|
+|----|
| **[C++ backend for AVL Trees](https://github.com/codezonediitj/pydatastructs/pull/564)** |
| **[C++ backend for Cartesian Trees](https://github.com/codezonediitj/pydatastructs/pull/567)** |
| **[C++ backend for Treap](https://github.com/codezonediitj/pydatastructs/pull/568)** |
| **[C++ backend for all trees in `binary_trees.py` file complete](https://github.com/codezonediitj/pydatastructs/pull/569)** |
| **[Updated Documentation](https://github.com/codezonediitj/pydatastructs/pull/570)** |
----
-
+------------------------------------------------------------------------
### Contribution Stats:
@@ -121,22 +219,28 @@ Commits made: 12
Total merged Pull Requests : 12
-Here's a complete list of all my **[merged PRs](https://github.com/codezonediitj/pydatastructs/pulls?q=is%3Apr+is%3Amerged+author%3AKishan-Ved)**
+Here’s a complete list of all my **[merged
+PRs](https://github.com/codezonediitj/pydatastructs/pulls?q=is%3Apr+is%3Amerged+author%3AKishan-Ved)**
### Speed results
- OUTPUT - -
-
-
-Linting Python code...
-Running Java backend tests...
-Running React frontend tests...
-Building Vue.js frontend...
-
-
-
-
-
-Time taken for methods of Binary Search Tree class to execute in different backends:
+Time taken for methods of Binary Search Tree class to execute in
+different backends:
Click to see a benchmark code
- - To run this code, you need PyDataStructs installed with the following imports: - ```python ++ +Click to see a benchmark code +
+ +To run this code, you need PyDataStructs installed with the following +imports: + +``` python import timeit, functools, os, pytest from pydatastructs.trees.binary_trees import (BinarySearchTree, RedBlackTree) from pydatastructs.utils.misc_util import Backend - ``` +``` - ```python +``` python def test_BinarySearchTree(**kwargs): cpp = Backend.CPP repeat = 1 @@ -200,39 +304,60 @@ Here's a complete list of all my **[merged PRs](https://github.com/codezonediitj print("C++ backend is",round(python_total/cpp_total),"times faster!") test_BinarySearchTree() - ``` +``` +
- 
+
+
+
+
+Time taken for methods of Binary Search Tree class to execute in different backends:
+Click to see a benchmark code
+ + To run this code, you need PyDataStructs installed with the following imports: + + ```python + import timeit, functools, os, pytest + from pydatastructs.trees.binary_trees import (BinarySearchTree, RedBlackTree) + from pydatastructs.utils.misc_util import Backend + ``` + + ```python + def test_BinarySearchTree(**kwargs): + cpp = Backend.CPP + repeat = 1 + number = 1 + + size = int(os.environ.get("PYDATASTRUCTS_BENCHMARK_SIZE", "1000")) + size = kwargs.get("size", size) + + BST = BinarySearchTree + b1 = BST(backend=Backend.PYTHON) + b2 = BST(backend=Backend.CPP) + + def f(backend, tree): + for node in range(-1000,1000): + tree.insert(node, node) + def g(backend, tree): + for node in range(-1000, 1000): + tree.search(node) + def h(backend, tree): + for node in range(2000): + tree.delete(node) + + kwds_dict_PY = {"backend": Backend.PYTHON, "tree":b1} + kwds_dict_CPP = {"backend": Backend.CPP, "tree":b2} + + timer_python = timeit.Timer(functools.partial(f, **kwds_dict_PY)) + python_insert = min(timer_python.repeat(repeat, number)) + + timer_cpp = timeit.Timer(functools.partial(f, **kwds_dict_CPP)) + cpp_insert = min(timer_cpp.repeat(repeat, number)) + assert cpp_insert < python_insert + + timer_python = timeit.Timer(functools.partial(g, **kwds_dict_PY)) + python_search = min(timer_python.repeat(repeat, number)) + + timer_cpp = timeit.Timer(functools.partial(g, **kwds_dict_CPP)) + cpp_search = min(timer_cpp.repeat(repeat, number)) + assert cpp_search < python_search + + timer_python = timeit.Timer(functools.partial(h, **kwds_dict_PY)) + python_delete = min(timer_python.repeat(repeat, number)) + + timer_cpp = timeit.Timer(functools.partial(h, **kwds_dict_CPP)) + cpp_delete = min(timer_cpp.repeat(repeat, number)) + assert cpp_delete < python_delete + + print("Python Time:") + print("insert(): ",python_insert,"s") + print("search(): ",python_search,"s") + print("delete(): ",python_delete,"s") + python_total = python_insert+python_search+python_delete + print("Total Python time: ", python_total,"s\n") + + print("C++ Time:") + print("insert(): ",cpp_insert,"s") + print("search(): ",cpp_search,"s") + print("delete(): ",cpp_delete,"s") + cpp_total = cpp_insert+cpp_search+cpp_delete + print("Total C++ time: ", cpp_total,"s\n") + + print("C++ backend is",round(python_total/cpp_total),"times faster!") + + test_BinarySearchTree() + ``` +
+
+
-• software development project work
-• coding challenges
-• project/code reviews
-• open-source events
-• weekly open study group sessions
-• Relevant online courses
-• personal study sessions
+My internship at Open Science Labs was designed to be comprehensive. As +such, I was introduced to:
• software development project work
• +coding challenges
• project/code reviews
• open-source +events
• weekly open study group sessions
• Relevant online +courses
• personal study sessions
# My First Contribution to Open Source -My first open-source contribution was a bug fix for an issue pointed out by the linter in the Growth Forge repository. Here is a link to the PR: https://github.com/osl-incubator/growth-forge/pull/9 +My first open-source contribution was a bug fix for an issue pointed out +by the linter in the Growth Forge repository. Here is a link to the PR: +https://github.com/osl-incubator/growth-forge/pull/9 -As a pre-requirement for participating in the OSL internship, potential candidates are to make, at least, one simple contribution. My mentor directed me to the open ‘linter’ issue on the Growth Forge repo, informing me that it was simple enough to start with. I took a look at the issue and was able to run pre-commit hooks to fix the linter problem. +As a pre-requirement for participating in the OSL internship, potential +candidates are to make, at least, one simple contribution. My mentor +directed me to the open ‘linter’ issue on the Growth Forge repo, +informing me that it was simple enough to start with. I took a look at +the issue and was able to run pre-commit hooks to fix the linter +problem. # About My Internship -During my internship program, I worked on some of the most amazing incubated and affiliated projects under the OSL umbrella. Here’s a list of the repositories I engaged with and some of my activities. +During my internship program, I worked on some of the most amazing +incubated and affiliated projects under the OSL umbrella. Here’s a list +of the repositories I engaged with and some of my activities. ## Project Work -[Growth Forge:](https://github.com/osl-incubator/growth-forge) -My contribution to the Growth Forge repository involved creating test codes for the project’s views and models and running the respective tests, as well as recording the results. -[OSL Website:](https://www.opensciencelabs.org) -For the OSL website repository, I engaged in backend updates of several pages, including the home, team, events, and blogs pages. I also added a few new pages such as the career page, and worked to implement a website-wide search feature. +[Growth Forge:](https://github.com/osl-incubator/growth-forge) My +contribution to the Growth Forge repository involved creating test codes +for the project’s views and models and running the respective tests, as +well as recording the results. -[Artbox:](https://github.com/osl-incubator/artbox) -I utilized the Artbox text-to-speech feature to generate audio summaries of the monthly newsletter. These audios were applied to the OSL podcast. +[OSL Website:](https://www.opensciencelabs.org) For the OSL website +repository, I engaged in backend updates of several pages, including the +home, team, events, and blogs pages. I also added a few new pages such +as the career page, and worked to implement a website-wide search +feature. -Aside from coding activities and project work, I also contributed by identifying and raising issues, particularly in the Artbox repository. +[Artbox:](https://github.com/osl-incubator/artbox) I utilized the Artbox +text-to-speech feature to generate audio summaries of the monthly +newsletter. These audios were applied to the OSL podcast. -## Contribution Stats -Two statistics that define my internship contribution are: 21 merged pull requests and Python being the dominant programming language. - -## OSL and Advent of Code Challenges -I attempted several challenges from the OSL Challenge repo including the train, padlock-secret, and money-calculation challenges. I also participated in solving Advent of Code 2024 challenges themed around finding a missing Santa using sketchy direction clues. +Aside from coding activities and project work, I also contributed by +identifying and raising issues, particularly in the Artbox repository. -## Course Completions -Continuous learning is at the core of the OSL internship program. As such, I undertook several online courses, to enhance my understanding of coding concepts and learn new things altogether. Some of the courses I undertook during my internship were: Version Control with Git (available on [Software Carpentry](https://swcarpentry.github.io/git-novice/)), Docker Training Course for the Absolute Beginner (available on [KodeKloud](https://learn.kodekloud.com/courses/docker-training-course-for-the-absolute-beginner)), and Python for Everyone (available on [Runestone Academy](https://runestone.academy/ns/books/published/py4e-int/index.html)). - -## Open Source Events -Finding and participating in open-source events was another highlight of my internship journey. In October, I applied and received a scholarship to participate in the maiden edition of the [pyOpenSci Fall Festival](https://www.pyopensci.org/events/pyopensci-2024-fall-festival.html). This event featured interactive sessions on writing modular, clean code, building a Python package, and creating reproducible reports and presentations with Quarto and Great Tables. +## Contribution Stats -## Open Study Calls -My mentor, Ivan Ogasawara, invited me to join the LiteRev-sponsored Open Study Calls every Thursday. Here, I came across several new concepts/tools such as Retrieval-Augumented Generation (RAG), JupyterLabs, etc. +Two statistics that define my internship contribution are: 21 merged +pull requests and Python being the dominant programming language. -After participating in more than 20 Open Study Calls, I built a culture of learning, was exposed to expert suggestions and reviews, and came across relevant courses and resources on coding and software development in general. +## OSL and Advent of Code Challenges -## Impact of the Open Source and Open Science Community # +I attempted several challenges from the OSL Challenge repo including the +train, padlock-secret, and money-calculation challenges. I also +participated in solving Advent of Code 2024 challenges themed around +finding a missing Santa using sketchy direction clues. -Support from the open-source and open-science community proved handy throughout my internship at Open Science Labs. The OSL Discord server was a place where I could throw questions and get prompt and helpful responses from a number of experts. This significantly lightened the burden of finding my footing as a beginner in software development. +## Course Completions -## Lessons Learnt # +Continuous learning is at the core of the OSL internship program. As +such, I undertook several online courses, to enhance my understanding of +coding concepts and learn new things altogether. Some of the courses I +undertook during my internship were: Version Control with Git +(available on [Software +Carpentry](https://swcarpentry.github.io/git-novice/)), Docker +Training Course for the Absolute Beginner (available on +[KodeKloud](https://learn.kodekloud.com/courses/docker-training-course-for-the-absolute-beginner)), +and Python for Everyone (available on [Runestone +Academy](https://runestone.academy/ns/books/published/py4e-int/index.html)). -There are numerous lessons to be learnt from an impactful internship like the one I had at Open Science Labs (OSL). I’ll share them with you. +## Open Source Events -• Be Open to Corrections: -Seek corrections. At the beginning, it might be difficult or overwhelming. However, with time, you will be grateful for it. Having someone to correct you will only make your learning process easy as you can quickly move on from mistakes and avoid them in the future. +Finding and participating in open-source events was another highlight of +my internship journey. In October, I applied and received a scholarship +to participate in the maiden edition of the [pyOpenSci Fall +Festival](https://www.pyopensci.org/events/pyopensci-2024-fall-festival.html). +This event featured interactive sessions on writing modular, clean code, +building a Python package, and creating reproducible reports and +presentations with Quarto and Great Tables. -• Be Upfront about Challenges: -The Open Science Labs internship is designed to be safe, warm, and welcoming. If you happen to have challenges during the program, it is okay to speak up about it. In fact, you should speak up about it. This will help your mentor/program coordinator make necessary adjustments, enabling your continued participation and progress. +## Open Study Calls -• Put Your Mind In the Work: -If you like your work, it becomes easier. One notable way to build this liking is to put your mind to it. Your focus will easily translate into an interest, improving the quality of your participation and your output in general. \ No newline at end of file +My mentor, Ivan Ogasawara, invited me to join the LiteRev-sponsored Open +Study Calls every Thursday. Here, I came across several new +concepts/tools such as Retrieval-Augumented Generation (RAG), +JupyterLabs, etc. + +After participating in more than 20 Open Study Calls, I built a culture +of learning, was exposed to expert suggestions and reviews, and came +across relevant courses and resources on coding and software development +in general. + +## Impact of the Open Source and Open Science Community + +Support from the open-source and open-science community proved handy +throughout my internship at Open Science Labs. The OSL Discord server +was a place where I could throw questions and get prompt and helpful +responses from a number of experts. This significantly lightened the +burden of finding my footing as a beginner in software development. + +## Lessons Learnt + +There are numerous lessons to be learnt from an impactful internship +like the one I had at Open Science Labs (OSL). I’ll share them with you. + +• Be Open to Corrections: Seek corrections. At the beginning, it +might be difficult or overwhelming. However, with time, you will be +grateful for it. Having someone to correct you will only make your +learning process easy as you can quickly move on from mistakes and avoid +them in the future. + +• Be Upfront about Challenges: The Open Science Labs internship +is designed to be safe, warm, and welcoming. If you happen to have +challenges during the program, it is okay to speak up about it. In fact, +you should speak up about it. This will help your mentor/program +coordinator make necessary adjustments, enabling your continued +participation and progress. + +• Put Your Mind In the Work: If you like your work, it becomes +easier. One notable way to build this liking is to put your mind to it. +Your focus will easily translate into an interest, improving the quality +of your participation and your output in general. \ No newline at end of file diff --git a/pages/blog/my-opensciencelabs-internship-journey/index.qmd b/pages/blog/my-opensciencelabs-internship-journey/index.qmd new file mode 100644 index 000000000..298164061 --- /dev/null +++ b/pages/blog/my-opensciencelabs-internship-journey/index.qmd @@ -0,0 +1,85 @@ +--- +title: "My Open Science Labs Internship Journey" +slug: "my-opensciencelabs-internship-journey" +date: 2025-01-30 +authors: ["Mfonobong Uyah"] +tags: ["OpenScienceLabs", "OSL", "internship"] +categories: ["Internship", "Backend"] +description: "This blog post summarizes my internship in backend development at Open Science Labs with Ivan Ogasawara as my mentor and supervisor!" +thumbnail: "/header.png" +template: "blog-post.html" +format: + gfm: + variant: +yaml_metadata_block +--- + +# About Me + +I am [Mfonobong Uyah](https://www.linkedin.com/in/mfonobong-uyah-26901620a/), a graduate of Electrical and Electronics Engineering (EEE) from the Federal University of Technology, Akure (FUTA). In June 2024, I was privileged to be accepted for an internship at Open Science Labs. This program was mentored by [Ivan Ogasawara](https://github.com/xmnlab), the founder of Open Science Labs and a seasoned professional with over 10 years of experience in open-source and 22 years of experience in software development. + +# The Focus of My Internship Program + +My internship at Open Science Labs was designed to be comprehensive. As such, I was introduced to:
+• software development project work
+• coding challenges
+• project/code reviews
+• open-source events
+• weekly open study group sessions
+• Relevant online courses
+• personal study sessions
+ +# My First Contribution to Open Source + +My first open-source contribution was a bug fix for an issue pointed out by the linter in the Growth Forge repository. Here is a link to the PR: https://github.com/osl-incubator/growth-forge/pull/9 + +As a pre-requirement for participating in the OSL internship, potential candidates are to make, at least, one simple contribution. My mentor directed me to the open ‘linter’ issue on the Growth Forge repo, informing me that it was simple enough to start with. I took a look at the issue and was able to run pre-commit hooks to fix the linter problem. + +# About My Internship + +During my internship program, I worked on some of the most amazing incubated and affiliated projects under the OSL umbrella. Here’s a list of the repositories I engaged with and some of my activities. + +## Project Work +[Growth Forge:](https://github.com/osl-incubator/growth-forge) +My contribution to the Growth Forge repository involved creating test codes for the project’s views and models and running the respective tests, as well as recording the results. + +[OSL Website:](https://www.opensciencelabs.org) +For the OSL website repository, I engaged in backend updates of several pages, including the home, team, events, and blogs pages. I also added a few new pages such as the career page, and worked to implement a website-wide search feature. + +[Artbox:](https://github.com/osl-incubator/artbox) +I utilized the Artbox text-to-speech feature to generate audio summaries of the monthly newsletter. These audios were applied to the OSL podcast. + +Aside from coding activities and project work, I also contributed by identifying and raising issues, particularly in the Artbox repository. + +## Contribution Stats +Two statistics that define my internship contribution are: 21 merged pull requests and Python being the dominant programming language. + +## OSL and Advent of Code Challenges +I attempted several challenges from the OSL Challenge repo including the train, padlock-secret, and money-calculation challenges. I also participated in solving Advent of Code 2024 challenges themed around finding a missing Santa using sketchy direction clues. + +## Course Completions +Continuous learning is at the core of the OSL internship program. As such, I undertook several online courses, to enhance my understanding of coding concepts and learn new things altogether. Some of the courses I undertook during my internship were: Version Control with Git (available on [Software Carpentry](https://swcarpentry.github.io/git-novice/)), Docker Training Course for the Absolute Beginner (available on [KodeKloud](https://learn.kodekloud.com/courses/docker-training-course-for-the-absolute-beginner)), and Python for Everyone (available on [Runestone Academy](https://runestone.academy/ns/books/published/py4e-int/index.html)). + +## Open Source Events +Finding and participating in open-source events was another highlight of my internship journey. In October, I applied and received a scholarship to participate in the maiden edition of the [pyOpenSci Fall Festival](https://www.pyopensci.org/events/pyopensci-2024-fall-festival.html). This event featured interactive sessions on writing modular, clean code, building a Python package, and creating reproducible reports and presentations with Quarto and Great Tables. + +## Open Study Calls +My mentor, Ivan Ogasawara, invited me to join the LiteRev-sponsored Open Study Calls every Thursday. Here, I came across several new concepts/tools such as Retrieval-Augumented Generation (RAG), JupyterLabs, etc. + +After participating in more than 20 Open Study Calls, I built a culture of learning, was exposed to expert suggestions and reviews, and came across relevant courses and resources on coding and software development in general. + +## Impact of the Open Source and Open Science Community # + +Support from the open-source and open-science community proved handy throughout my internship at Open Science Labs. The OSL Discord server was a place where I could throw questions and get prompt and helpful responses from a number of experts. This significantly lightened the burden of finding my footing as a beginner in software development. + +## Lessons Learnt # + +There are numerous lessons to be learnt from an impactful internship like the one I had at Open Science Labs (OSL). I’ll share them with you. + +• Be Open to Corrections: +Seek corrections. At the beginning, it might be difficult or overwhelming. However, with time, you will be grateful for it. Having someone to correct you will only make your learning process easy as you can quickly move on from mistakes and avoid them in the future. + +• Be Upfront about Challenges: +The Open Science Labs internship is designed to be safe, warm, and welcoming. If you happen to have challenges during the program, it is okay to speak up about it. In fact, you should speak up about it. This will help your mentor/program coordinator make necessary adjustments, enabling your continued participation and progress. + +• Put Your Mind In the Work: +If you like your work, it becomes easier. One notable way to build this liking is to put your mind to it. Your focus will easily translate into an interest, improving the quality of your participation and your output in general. \ No newline at end of file diff --git a/pages/blog/newsletter-first-edition/index.md b/pages/blog/newsletter-first-edition/index.md index fd5f723a7..dca59fe12 100644 --- a/pages/blog/newsletter-first-edition/index.md +++ b/pages/blog/newsletter-first-edition/index.md @@ -22,63 +22,68 @@ template: "blog-post.html" ## News: OSL Receives PSF Grant for MAKIM and ASTx Projects -We're thrilled to announce that the Python Software Foundation (PSF) has granted -funding to two of our key projects: **MAKIM** and **ASTx**. This support will -help accelerate development and enhance the capabilities of these tools. Read on -to learn more about these projects and the impact of the PSF grant. +We’re thrilled to announce that the Python Software Foundation (PSF) has +granted funding to two of our key projects: **MAKIM** and **ASTx**. This +support will help accelerate development and enhance the capabilities of +these tools. Read on to learn more about these projects and the impact +of the PSF grant. ### About the Python Software Foundation -Founded in March 2001, the Python Software Foundation (PSF) is a nonprofit -organization dedicated to advancing and promoting the Python programming -language. The PSF supports a wide range of open-source Python projects, -fostering a vibrant and inclusive community. +Founded in March 2001, the Python Software Foundation (PSF) is a +nonprofit organization dedicated to advancing and promoting the Python +programming language. The PSF supports a wide range of open-source +Python projects, fostering a vibrant and inclusive community. ## Are You a Pythonista? Join the pyOpenSci Fall Festival 2024 Mark your calendars! Our partner is hosting a one-of-a-kind event. The -**pyOpenSci Fall Festival 2024** is an inaugural online meeting of Python, Open -Science, and Open Source enthusiasts set to take place from October 28 to -November 1, 2024. +**pyOpenSci Fall Festival 2024** is an inaugural online meeting of +Python, Open Science, and Open Source enthusiasts set to take place from +October 28 to November 1, 2024. -The event promises to feature insightful talks, essential hands-on workshops, -and office hours with numerous industry experts exchanging ideas and sharing -experiences. -[Go here](https://www.pyopensci.org/events/pyopensci-2024-fall-festival.html) to -learn more. +The event promises to feature insightful talks, essential hands-on +workshops, and office hours with numerous industry experts exchanging +ideas and sharing experiences. [Go +here](https://www.pyopensci.org/events/pyopensci-2024-fall-festival.html) +to learn more. ## OSL Projects Development Report ### MAKIM Improvements -**MAKIM** is a YAML-based task automation tool inspired by Make. It offers -structured definitions for tasks and dependencies, supporting conditionals, -arguments, grouping, variables, Jinja2 templating, and environment file -integration. +**MAKIM** is a YAML-based task automation tool inspired by Make. It +offers structured definitions for tasks and dependencies, supporting +conditionals, arguments, grouping, variables, Jinja2 templating, and +environment file integration. Makim team has made several recent updates to the project, including the addition of new features supported by the PSF grant. -- Added support for checking the .makim.yaml structure with a schema definition. +- Added support for checking the .makim.yaml structure with a schema + definition. - Added support for matrix variables for tasks. -- Changed from dependencies support to hooks with pre and post run support. +- Changed from dependencies support to hooks with pre and post run + support. - Fixed text problems and issues in the continuous integration jobs. -- Introduced support for interactive arguments, allowing for more dynamic user - input. -- Refactored the attribute "shell" to "backend," improving code clarity. -- Updated the configuration for MyPy to ensure better type-checking practices. +- Introduced support for interactive arguments, allowing for more + dynamic user input. +- Refactored the attribute “shell” to “backend,” improving code clarity. +- Updated the configuration for MyPy to ensure better type-checking + practices. Read more about MAKIM [here](https://dev.to/opensciencelabs/streamlining-project-automation-with-makim-21nc). ### ASTx Improvements -**ASTx** is a language-agnostic expression structure designed primarily for the -ArxLang project. However, it can be utilized by any programming language or -parser to create high-level representations of Abstract Syntax Trees (AST). +**ASTx** is a language-agnostic expression structure designed primarily +for the ArxLang project. However, it can be utilized by any programming +language or parser to create high-level representations of Abstract +Syntax Trees (AST). -ArxLang team has made several developmental improvements to ASTx, including the -addition of new features supported by the PSF grant: +ArxLang team has made several developmental improvements to ASTx, +including the addition of new features supported by the PSF grant: - Added a new import statement feature for improved module management. - Implemented runtime type checking using Typeguard. @@ -89,17 +94,19 @@ addition of new features supported by the PSF grant: - Added support to float16, and float64 - Added support to uint8, uint16, unit32, uint64, uint128 -If you would like to read more on ASTx, -[go here](https://opensciencelabs.org/blog/console-based-representation-in-astx/). +If you would like to read more on ASTx, [go +here](https://opensciencelabs.org/blog/console-based-representation-in-astx/). ### Sugar and SciCookie Both Have New Updates -**Sugar** and **SciCookie** projects are also receiving updates. The latest PRs on the Sugar repository include: +**Sugar** and **SciCookie** projects are also receiving updates. The +latest PRs on the Sugar repository include: -- Added support for checking the .sugar.yaml structure with a schema definition. +- Added support for checking the .sugar.yaml structure with a schema + definition. - A fix for the Jinja2 template. -- A refactor of the interface for plugins/extensions that moves the main command - to the compose group. +- A refactor of the interface for plugins/extensions that moves the main + command to the compose group. On the SciCookie project, SciCookie team has added some feature and improvements: @@ -110,33 +117,38 @@ improvements: ## What’s Next? How to Get Started Learning About OSL Projects and Activities -- **Tour Our Website:** Explore our mission, vision, contribution guidelines, - and more on the [OSL website](https://www.opensciencelabs.org). -- **Become a Member:** Join our - [OSL Discord server](https://www.opensciencelabs.org/discord) to connect with - like-minded individuals, contribute to discussions, and collaborate to project - under OSL umbrella. Whether you have a technical background or are a new - enthusiast, everyone is welcome! +- **Tour Our Website:** Explore our mission, vision, contribution + guidelines, and more on the [OSL + website](https://www.opensciencelabs.org). + +- **Become a Member:** Join our [OSL Discord + server](https://www.opensciencelabs.org/discord) to connect with + like-minded individuals, contribute to discussions, and collaborate to + project under OSL umbrella. Whether you have a technical background or + are a new enthusiast, everyone is welcome! - **Stay Connected:** Follow us on [LinkedIn](https://www.linkedin.com/company/opensciencelabs) and - [X](https://twitter.com/opensciencelabs) to get updates about published - articles and events before they hit your email. + [X](https://twitter.com/opensciencelabs) to get updates about + published articles and events before they hit your email. -- **Explore Our Projects and Ideas:** Visit our - [YouTube channel](https://www.youtube.com/@opensciencelabs/videos). With 12 - insightful videos already available and many more rolling out soon, you can - learn how to install and use our most popular tools, as well as gain knowledge - on programming languages, coding best practices, and past events. +- **Explore Our Projects and Ideas:** Visit our [YouTube + channel](https://www.youtube.com/@opensciencelabs/videos). With 12 + insightful videos already available and many more rolling out soon, + you can learn how to install and use our most popular tools, as well + as gain knowledge on programming languages, coding best practices, and + past events. ### Open Study Group -Join our Open Study Group! Everyone is welcome to participate in our dedicated -one-hour sessions designed to support your personal studies. Use this online -meeting space to focus on your work, ask questions, and share updates about your -progress. Whether you're tackling a new project, learning a new skill, or simply -seeking a quiet time to study, our study group provides a supportive and -collaborative environment to help you achieve your goals. Come connect with -fellow learners and make the most of your study time together! - -Ask for more information on our [Discord](https://www.opensciencelabs.org/discord). +Join our Open Study Group! Everyone is welcome to participate in our +dedicated one-hour sessions designed to support your personal studies. +Use this online meeting space to focus on your work, ask questions, and +share updates about your progress. Whether you’re tackling a new +project, learning a new skill, or simply seeking a quiet time to study, +our study group provides a supportive and collaborative environment to +help you achieve your goals. Come connect with fellow learners and make +the most of your study time together! + +Ask for more information on our +[Discord](https://www.opensciencelabs.org/discord). \ No newline at end of file diff --git a/pages/blog/newsletter-first-edition/index.qmd b/pages/blog/newsletter-first-edition/index.qmd new file mode 100644 index 000000000..f30c69803 --- /dev/null +++ b/pages/blog/newsletter-first-edition/index.qmd @@ -0,0 +1,145 @@ +--- +title: "Newsletter First Edition" +slug: "newsletter-first-edition" +date: 2024-10-19 +authors: ["Mfonobong Uyah"] +tags: ["Newsletter", "OSL", "First Edition"] +categories: ["Newsletter"] +description: | + The OSL newsletter is launching soon! Our first edition has been repurposed + for this blog post, but you can subscribe to receive future releases directly + in your inbox. +thumbnail: "/header.jpg" +template: "blog-post.html" +format: + gfm: + variant: +yaml_metadata_block +--- + +**Highlights:** + +- **OSL Grant News** +- **pyOpenSci’s Upcoming Fall Festival Event** +- **OSL Projects Development Report** +- **Open Study Group** + +## News: OSL Receives PSF Grant for MAKIM and ASTx Projects + +We're thrilled to announce that the Python Software Foundation (PSF) has granted +funding to two of our key projects: **MAKIM** and **ASTx**. This support will +help accelerate development and enhance the capabilities of these tools. Read on +to learn more about these projects and the impact of the PSF grant. + +### About the Python Software Foundation + +Founded in March 2001, the Python Software Foundation (PSF) is a nonprofit +organization dedicated to advancing and promoting the Python programming +language. The PSF supports a wide range of open-source Python projects, +fostering a vibrant and inclusive community. + +## Are You a Pythonista? Join the pyOpenSci Fall Festival 2024 + +Mark your calendars! Our partner is hosting a one-of-a-kind event. The +**pyOpenSci Fall Festival 2024** is an inaugural online meeting of Python, Open +Science, and Open Source enthusiasts set to take place from October 28 to +November 1, 2024. + +The event promises to feature insightful talks, essential hands-on workshops, +and office hours with numerous industry experts exchanging ideas and sharing +experiences. +[Go here](https://www.pyopensci.org/events/pyopensci-2024-fall-festival.html) to +learn more. + +## OSL Projects Development Report + +### MAKIM Improvements + +**MAKIM** is a YAML-based task automation tool inspired by Make. It offers +structured definitions for tasks and dependencies, supporting conditionals, +arguments, grouping, variables, Jinja2 templating, and environment file +integration. + +Makim team has made several recent updates to the project, including the +addition of new features supported by the PSF grant. + +- Added support for checking the .makim.yaml structure with a schema definition. +- Added support for matrix variables for tasks. +- Changed from dependencies support to hooks with pre and post run support. +- Fixed text problems and issues in the continuous integration jobs. +- Introduced support for interactive arguments, allowing for more dynamic user + input. +- Refactored the attribute "shell" to "backend," improving code clarity. +- Updated the configuration for MyPy to ensure better type-checking practices. + +Read more about MAKIM +[here](https://dev.to/opensciencelabs/streamlining-project-automation-with-makim-21nc). + +### ASTx Improvements + +**ASTx** is a language-agnostic expression structure designed primarily for the +ArxLang project. However, it can be utilized by any programming language or +parser to create high-level representations of Abstract Syntax Trees (AST). + +ArxLang team has made several developmental improvements to ASTx, including the +addition of new features supported by the PSF grant: + +- Added a new import statement feature for improved module management. +- Implemented runtime type checking using Typeguard. +- Enhanced type safety and reliability. +- Improved the development configuration structure, and dependencies. +- Added a transpiler from astx to python +- Added support to complex32 and complex64 +- Added support to float16, and float64 +- Added support to uint8, uint16, unit32, uint64, uint128 + +If you would like to read more on ASTx, +[go here](https://opensciencelabs.org/blog/console-based-representation-in-astx/). + +### Sugar and SciCookie Both Have New Updates + +**Sugar** and **SciCookie** projects are also receiving updates. The latest PRs on the Sugar repository include: + +- Added support for checking the .sugar.yaml structure with a schema definition. +- A fix for the Jinja2 template. +- A refactor of the interface for plugins/extensions that moves the main command + to the compose group. + +On the SciCookie project, SciCookie team has added some feature and +improvements: + +- Improved tests and infrastructure. +- Added support to pixi with pyproject. +- Added support to circleci. + +## What’s Next? How to Get Started Learning About OSL Projects and Activities + +- **Tour Our Website:** Explore our mission, vision, contribution guidelines, + and more on the [OSL website](https://www.opensciencelabs.org). +- **Become a Member:** Join our + [OSL Discord server](https://www.opensciencelabs.org/discord) to connect with + like-minded individuals, contribute to discussions, and collaborate to project + under OSL umbrella. Whether you have a technical background or are a new + enthusiast, everyone is welcome! + +- **Stay Connected:** Follow us on + [LinkedIn](https://www.linkedin.com/company/opensciencelabs) and + [X](https://twitter.com/opensciencelabs) to get updates about published + articles and events before they hit your email. + +- **Explore Our Projects and Ideas:** Visit our + [YouTube channel](https://www.youtube.com/@opensciencelabs/videos). With 12 + insightful videos already available and many more rolling out soon, you can + learn how to install and use our most popular tools, as well as gain knowledge + on programming languages, coding best practices, and past events. + +### Open Study Group + +Join our Open Study Group! Everyone is welcome to participate in our dedicated +one-hour sessions designed to support your personal studies. Use this online +meeting space to focus on your work, ask questions, and share updates about your +progress. Whether you're tackling a new project, learning a new skill, or simply +seeking a quiet time to study, our study group provides a supportive and +collaborative environment to help you achieve your goals. Come connect with +fellow learners and make the most of your study time together! + +Ask for more information on our [Discord](https://www.opensciencelabs.org/discord). diff --git a/pages/blog/newsletter-second-edition/index.md b/pages/blog/newsletter-second-edition/index.md index d09d597d2..450eedc99 100644 --- a/pages/blog/newsletter-second-edition/index.md +++ b/pages/blog/newsletter-second-edition/index.md @@ -22,77 +22,125 @@ template: "blog-post.html" ## Review: pyOpenSci Fall Festival 2024 in A Few Sentences -Our partner, pyOpenSci, just concluded the maiden edition of its Fall Festival. The highly anticipated event ran from October 28 to November 1, 2024, exposing participants to coding best practices, exciting sample projects, new tools and products, and games like Roast My Repo. The entire event was hosted on Spatial Chat. +Our partner, pyOpenSci, just concluded the maiden edition of its Fall +Festival. The highly anticipated event ran from October 28 to November +1, 2024, exposing participants to coding best practices, exciting sample +projects, new tools and products, and games like Roast My Repo. The +entire event was hosted on Spatial Chat. -If you were unable to attend this event, we got you covered. Here’s a brief summary of each day’s activities: +If you were unable to attend this event, we got you covered. Here’s a +brief summary of each day’s activities: -- Day 1: Keynote talks from Eric Ma, Melissa Medoca, and Rowan Cockett. These experts spoke on Open Science in Relation to biomedicine and LLMs, the impact of Open Source on Open Science, and how Markdown catalyses scientific computations through MySTMd. +- Day 1: Keynote talks from Eric Ma, Melissa Medoca, and Rowan Cockett. + These experts spoke on Open Science in Relation to biomedicine and + LLMs, the impact of Open Source on Open Science, and how Markdown + catalyses scientific computations through MySTMd. -- Day 2: A three-part session on formatting code, modularising code, and finally, testing code. +- Day 2: A three-part session on formatting code, modularising code, and + finally, testing code. -- Day 3: Insightful package creation tutorial using a template designed and owned by the pyOpenSci community. +- Day 3: Insightful package creation tutorial using a template designed + and owned by the pyOpenSci community. -- Day 4: Tips and tricks to effectively sharing a code. How to publish your package on TestPyPI, and add a DOI to your GitHub repo using Zenodo. +- Day 4: Tips and tricks to effectively sharing a code. How to publish + your package on TestPyPI, and add a DOI to your GitHub repo using + Zenodo. -- Day 5: Reproducible reports with Quarto (interactive Python and R in your browser). Speech by George Stagg and demo by James Balamuta. +- Day 5: Reproducible reports with Quarto (interactive Python and R in + your browser). Speech by George Stagg and demo by James Balamuta. ## News: ArxLang/ASTx talk at PyConLadies2024 -Ana Krelling, an impeccable contributor to the OSL community, gave a talk tiled “ASTx: Empowering Language Processing Through Custom Abstract Syntax Trees” at the recently concluded PyConLadies 2024 event. +Ana Krelling, an impeccable contributor to the OSL community, gave a +talk tiled “ASTx: Empowering Language Processing Through Custom Abstract +Syntax Trees” at the recently concluded PyConLadies 2024 event. -You can watch Ana's insightful session [here](https://www.youtube.com/watch?v=azVNQTFmuhA). +You can watch Ana’s insightful session +[here](https://www.youtube.com/watch?v=azVNQTFmuhA). ## Did You Know? -You can convert a Jupyter notebook to a script in the terminal -Once you have the terminal open, you can use it to run Jupyter notebooks as scripts by running: +You can convert a Jupyter notebook to a script in the terminal Once you +have the terminal open, you can use it to run Jupyter notebooks as +scripts by running: -```jupyter nbconvert --to script
-
+2. **Dask Collections:** Dask provides high-level abstractions known as
+ Dask collections, which are parallel and distributed counterparts to
+ familiar Python data structures. These include `dask.array` for
+ parallel arrays, `dask.bag` for parallel bags, and `dask.dataframe`
+ for parallel dataframes, seamlessly integrating with existing Python
+ libraries.
-2. **Dask Collections:**
- Dask provides high-level abstractions known as Dask collections, which are parallel and distributed counterparts to familiar Python data structures. These include `dask.array` for parallel arrays, `dask.bag` for parallel bags, and `dask.dataframe` for parallel dataframes, seamlessly integrating with existing Python libraries.
-
-
-```python
+``` python
#Using dask collections
import dask.array as da
@@ -111,29 +134,17 @@ result = y.mean() # Calculating the mean of y
# Computing the result
print(result.compute()) # Outputting the computed result
-
```
-- OUTPUT - -
-
-
-[ 9986.14978723 10073.19700192 9985.6576724 ... 9923.550924
-9978.70237439 9990.8504103 ]
+ [ 9986.14978723 10073.19700192 9985.6576724 ... 9923.550924
+ 9978.70237439 9990.8504103 ]
-
-
-
-
-
-3. **Lazy Evaluation:**
- One of Dask's core principles is lazy evaluation. Instead of immediately computing results, Dask builds a task graph representing the computation. The actual computation occurs only when the results are explicitly requested. This approach enhances efficiency and allows for optimizations in resource usage.
-
+ 2.0
+3. **Lazy Evaluation:** One of Dask’s core principles is lazy
+ evaluation. Instead of immediately computing results, Dask builds a
+ task graph representing the computation. The actual computation
+ occurs only when the results are explicitly requested. This approach
+ enhances efficiency and allows for optimizations in resource usage.
-
-```python
+``` python
#Lazy Evalution with dask
import dask.dataframe as dd
import numpy as np
@@ -163,27 +174,17 @@ mean_result = filtered_df['value'].mean()
# No computation happens until explicitly requested
print(mean_result.compute()) # Outputting the computed result
-
```
-- OUTPUT - -
-
-
-2.0
-
-
-
-
-
-
-4. **Integration with Existing Libraries:**
- Dask is designed to integrate seamlessly with popular Python libraries, such as NumPy, Pandas, and scikit-learn. This means that you can often replace existing code with Dask equivalents without significant modifications.
+ 0.5112260135512784
+4. **Integration with Existing Libraries:** Dask is designed to
+ integrate seamlessly with popular Python libraries, such as NumPy,
+ Pandas, and scikit-learn. This means that you can often replace
+ existing code with Dask equivalents without significant
+ modifications.
-```python
+``` python
# Integration with NumPy
import dask.array as da
import numpy as np
@@ -199,34 +200,25 @@ y_dask = x_dask + x_dask.T
# Computing the result
print(y_dask.compute())
-
```
-- OUTPUT - -
-
-
-0.5112260135512784
-
-
-
-
-
-
-5. **Task Scheduling:**
- Dask dynamically schedules the execution of tasks, optimizing the computation based on available resources. This makes it well-suited for handling larger-than-memory datasets efficiently. Dask is a powerful tool for data scientists and engineers working with large-scale data processing tasks, providing a convenient way to scale computations without requiring a complete rewrite of existing code.
-
-
-
-```python
+ [[1.40940907 1.32044698 1.48172367 ... 1.4266846 0.84142743 0.33577001]
+ [1.32044698 1.02252065 1.17250384 ... 0.40216939 1.58544767 1.12049071]
+ [1.48172367 1.17250384 1.98886224 ... 0.86271956 1.27977778 0.95136532]
+ ...
+ [1.4266846 0.40216939 0.86271956 ... 1.44980096 1.38712404 0.75331149]
+ [0.84142743 1.58544767 1.27977778 ... 1.38712404 1.50814693 1.01719649]
+ [0.33577001 1.12049071 0.95136532 ... 0.75331149 1.01719649 1.47050452]]
+
+5. **Task Scheduling:** Dask dynamically schedules the execution of
+ tasks, optimizing the computation based on available resources. This
+ makes it well-suited for handling larger-than-memory datasets
+ efficiently. Dask is a powerful tool for data scientists and
+ engineers working with large-scale data processing tasks, providing
+ a convenient way to scale computations without requiring a complete
+ rewrite of existing code.
+
+``` python
# Dynamic task scheduling with Dask
import dask
@@ -245,23 +237,21 @@ for value in data:
final_result = dask.compute(*results)
print(final_result)
-
```
-- OUTPUT - -
-
-
-[[1.40940907 1.32044698 1.48172367 ... 1.4266846 0.84142743 0.33577001]
-[1.32044698 1.02252065 1.17250384 ... 0.40216939 1.58544767 1.12049071]
-[1.48172367 1.17250384 1.98886224 ... 0.86271956 1.27977778 0.95136532]
-...
-[1.4266846 0.40216939 0.86271956 ... 1.44980096 1.38712404 0.75331149]
-[0.84142743 1.58544767 1.27977778 ... 1.38712404 1.50814693 1.01719649]
-[0.33577001 1.12049071 0.95136532 ... 0.75331149 1.01719649 1.47050452]]
-
-
-
-
-
+ (1, 4, 9, 16, 25, 36, 49, 64, 81)
## Conclusion:
-**Dask** stands as a powerful tool in the Python ecosystem, addressing the challenges posed by the ever-increasing scale of data. Its ability to seamlessly integrate with existing libraries, support lazy evaluation, and provide parallel and distributed computing makes it a valuable asset for data scientists and engineers tackling large-scale data processing tasks. Whether you're working on a single machine with moderately sized datasets or dealing with big data challenges that require distributed computing, Dask offers a flexible and efficient solution. As we continue to navigate the era of big data, Dask proves to be a key player in unlocking the full potential of Python for scalable and parallelized data processing. Start harnessing the power of Dask today and supercharge your data processing workflows!
-
+**Dask** stands as a powerful tool in the Python ecosystem, addressing
+the challenges posed by the ever-increasing scale of data. Its ability
+to seamlessly integrate with existing libraries, support lazy
+evaluation, and provide parallel and distributed computing makes it a
+valuable asset for data scientists and engineers tackling large-scale
+data processing tasks. Whether you’re working on a single machine with
+moderately sized datasets or dealing with big data challenges that
+require distributed computing, Dask offers a flexible and efficient
+solution. As we continue to navigate the era of big data, Dask proves to
+be a key player in unlocking the full potential of Python for scalable
+and parallelized data processing. Start harnessing the power of Dask
+today and supercharge your data processing workflows!
\ No newline at end of file
diff --git a/pages/blog/scaling-machine-learning-projects-with-dask/index.qmd b/pages/blog/scaling-machine-learning-projects-with-dask/index.qmd
new file mode 100644
index 000000000..f112a3f53
--- /dev/null
+++ b/pages/blog/scaling-machine-learning-projects-with-dask/index.qmd
@@ -0,0 +1,219 @@
+---
+title: Scaling Machine Learning Projects with Dask
+slug: scaling-machine-learning-projects-with-dask
+date: 2024-01-30
+authors:
+ - Satarupa Deb
+tags:
+ - open-source
+ - Machine Learning
+ - Dask
+ - python
+categories:
+ - Python
+ - Machine Learning
+ - Parallel computing
+description: |
+ This blog explores the usability of Dask in handling significant
+ challenges related to scaling models with large datasets, training and testing
+ of models, and implementing parallel computing functionalities. It also
+ provides a brief overview of the basic features of Dask.
+thumbnail: /image.png
+template: blog-post.html
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+# Scaling Python Data Analysis with Dask
+
+As the volume of digital data continues to expand, coupled with the emergence of new machine learning models each day, companies are increasingly dependent on data analysis to inform business decisions. To effectively test and train these models with large datasets, scaling becomes a significant challenge, particularly in connecting Python analysts to distributed hardware. This challenge is particularly pronounced in the realm of data science and machine learning workloads. The complexities in this process often result in discrepancies that can lead to flawed training of data and consequently, inaccurate results.
+
+In this blog, we will suggest an effective solution to address the challenges discussed above. Imagine how much easier the scaling process would be with a Python library that could perform on both parallel and distributed computing. This is precisely what **Dask** does!
+
+## What is Dask?
+
+**Dask** is an open-source, parallel and distributed computing library in Python that facilitates efficient and scalable processing of large datasets. It is designed to seamlessly integrate with existing Python libraries and tools, providing a familiar interface for users already comfortable with Python and its libraries like NumPy, Pandas, Jupyter, Scikit-Learn, and others but want to scale those workloads across a cluster. Dask is particularly useful for working with larger-than-memory datasets, parallelizing computations, and handling distributed computing.
+
+## Setting Up Dask
+
+Installing Dask is straightforward and can be done using Conda or Pip. For Anaconda users, Dask comes pre-installed, highlighting its popularity in the data science community. Alternatively, you can install Dask via Pip, ensuring to include the complete extension to install all required dependencies automatically.
+
+```bash
+#install using conda
+conda install dask
+```
+
+
+
+```python
+#install using conda
+!pip install "dask[complete]" -q
+```
+
+## Basic Concepts of Dask
+
+At its core, Dask extends the capabilities of traditional tools like pandas, NumPy, and Spark to handle larger-than-memory datasets. It achieves this by breaking large objects like arrays and dataframes into smaller, manageable chunks or partitions. This approach allows Dask to distribute computations efficiently across all available cores on your machine.
+
+## Dask DataFrames
+
+One of the standout features of Dask is its ability to handle large datasets effortlessly. With Dask DataFrames, you can seamlessly work with datasets exceeding 1 GB in size. By breaking the dataset into smaller chunks, Dask ensures efficient processing while maintaining the familiar interface of pandas DataFrames.
+
+## Features of Dask:
+
+1. **Parallel and Distributed Computing:**
+ Dask enables parallel and distributed computing, making it a go-to solution for handling datasets that exceed the available memory of a single machine. It breaks down computations into smaller tasks, allowing for concurrent execution and optimal resource utilization.
+
+
+```python
+#demonstrating parallel and distributed computing using Dask
+import dask.array as da
+
+# Create a large random array
+x = da.random.random((10000, 10000), chunks=(1000, 1000)) # 10,000 x 10,000 array
+
+# Perform element-wise computation
+y = x * 2
+
+# Compute the sum along one axis
+z = y.sum(axis=0)
+
+# Compute the result in parallel across multiple cores or distributed across a cluster
+result = z.compute()
+
+print(result)
+
+```
+
+ [ 9986.14978723 10073.19700192 9985.6576724 ... 9923.550924
+ 9978.70237439 9990.8504103 ]
+
+
+2. **Dask Collections:**
+ Dask provides high-level abstractions known as Dask collections, which are parallel and distributed counterparts to familiar Python data structures. These include `dask.array` for parallel arrays, `dask.bag` for parallel bags, and `dask.dataframe` for parallel dataframes, seamlessly integrating with existing Python libraries.
+
+
+```python
+#Using dask collections
+import dask.array as da
+
+# Creating a dummy dataset using Dask
+x = da.ones((100, 100), chunks=(10, 10)) # Creating a 100x100 array of ones with chunks of 10x10
+y = x + x.T # Adding the transpose of x to itself
+result = y.mean() # Calculating the mean of y
+
+# Computing the result
+print(result.compute()) # Outputting the computed result
+
+```
+
+ 2.0
+
+
+3. **Lazy Evaluation:**
+ One of Dask's core principles is lazy evaluation. Instead of immediately computing results, Dask builds a task graph representing the computation. The actual computation occurs only when the results are explicitly requested. This approach enhances efficiency and allows for optimizations in resource usage.
+
+
+
+
+```python
+#Lazy Evalution with dask
+import dask.dataframe as dd
+import numpy as np
+import pandas as pd
+
+# Creating a dummy dataset
+num_rows = 100 # Number of rows
+data = {
+ 'column': np.random.randint(0, 100, size=num_rows),
+ 'value': np.random.rand(num_rows)
+}
+
+# Creating a Pandas DataFrame
+df_pandas = pd.DataFrame(data)
+
+# Saving the Pandas DataFrame to a CSV file
+df_pandas.to_csv('your_dataset.csv', index=False)
+
+# Reading the CSV file into a Dask DataFrame
+df = dd.read_csv('your_dataset.csv')
+
+# Filtering the Dask DataFrame
+filtered_df = df[df['column'] > 10]
+
+# Calculating the mean of the filtered DataFrame
+mean_result = filtered_df['value'].mean()
+
+# No computation happens until explicitly requested
+print(mean_result.compute()) # Outputting the computed result
+
+```
+
+ 0.5112260135512784
+
+
+4. **Integration with Existing Libraries:**
+ Dask is designed to integrate seamlessly with popular Python libraries, such as NumPy, Pandas, and scikit-learn. This means that you can often replace existing code with Dask equivalents without significant modifications.
+
+
+```python
+# Integration with NumPy
+import dask.array as da
+import numpy as np
+
+# Generating a random NumPy array
+x_np = np.random.random((100, 100))
+
+# Converting the NumPy array to a Dask array
+x_dask = da.from_array(x_np, chunks=(10, 10))
+
+# Performing operations on the Dask array
+y_dask = x_dask + x_dask.T
+
+# Computing the result
+print(y_dask.compute())
+
+```
+
+ [[1.40940907 1.32044698 1.48172367 ... 1.4266846 0.84142743 0.33577001]
+ [1.32044698 1.02252065 1.17250384 ... 0.40216939 1.58544767 1.12049071]
+ [1.48172367 1.17250384 1.98886224 ... 0.86271956 1.27977778 0.95136532]
+ ...
+ [1.4266846 0.40216939 0.86271956 ... 1.44980096 1.38712404 0.75331149]
+ [0.84142743 1.58544767 1.27977778 ... 1.38712404 1.50814693 1.01719649]
+ [0.33577001 1.12049071 0.95136532 ... 0.75331149 1.01719649 1.47050452]]
+
+
+5. **Task Scheduling:**
+ Dask dynamically schedules the execution of tasks, optimizing the computation based on available resources. This makes it well-suited for handling larger-than-memory datasets efficiently. Dask is a powerful tool for data scientists and engineers working with large-scale data processing tasks, providing a convenient way to scale computations without requiring a complete rewrite of existing code.
+
+
+
+```python
+# Dynamic task scheduling with Dask
+import dask
+
+
+@dask.delayed
+def square(x):
+ return x * x
+
+data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+results = []
+
+for value in data:
+ result = square(value)
+ results.append(result)
+
+final_result = dask.compute(*results)
+print(final_result)
+
+
+```
+
+ (1, 4, 9, 16, 25, 36, 49, 64, 81)
+
+
+## Conclusion:
+
+**Dask** stands as a powerful tool in the Python ecosystem, addressing the challenges posed by the ever-increasing scale of data. Its ability to seamlessly integrate with existing libraries, support lazy evaluation, and provide parallel and distributed computing makes it a valuable asset for data scientists and engineers tackling large-scale data processing tasks. Whether you're working on a single machine with moderately sized datasets or dealing with big data challenges that require distributed computing, Dask offers a flexible and efficient solution. As we continue to navigate the era of big data, Dask proves to be a key player in unlocking the full potential of Python for scalable and parallelized data processing. Start harnessing the power of Dask today and supercharge your data processing workflows!
+
diff --git a/pages/blog/scicookie-collaborating-and-learning/index.ipynb b/pages/blog/scicookie-collaborating-and-learning/index.ipynb
deleted file mode 100644
index ffaad51ed..000000000
--- a/pages/blog/scicookie-collaborating-and-learning/index.ipynb
+++ /dev/null
@@ -1,96 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "raw",
- "metadata": {},
- "source": [
- "---\n",
- "title: \"Collaborating and learning from SciCookie\"\n",
- "slug: scicookie-collaborating-and-learning\n",
- "date: 2024-02-03\n",
- "authors: [\"Daniela Iglesias Rocabado\"]\n",
- "tags: [open-source, open-science, python, proyects]\n",
- "categories: [python]\n",
- "description: |\n",
- " The SciCookie template, developed by Open Science Labs, is a Python package based on the Cookieninja A Cookiecutter Fork\n",
- " command-line utility. Serving as a versatile boilerplate, it simplifies project creation for both beginners and experienced\n",
- " developers, saving significant time. Derived from ongoing research on scientific Python tools and best practices, SciCookie\n",
- " aligns with PyOpenSci recommendations, providing a standardized starting point for projects that can be easily customized\n",
- " while adhering to industry standards.\n",
- "thumbnail: \"/header.jpeg\"\n",
- "template: \"blog-post.html\"\n",
- "---"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# SciCookie\n",
- "\n",
- "The SciCookie template, developed by Open Science Labs, is a project template tool package, that uses Cookieninja as a backend, a Cookiecutter fork. Functioning as a versatile boilerplate, it facilitates project creation for both beginners and experienced developers, streamlining the process and saving considerable time. SciCookie provides an initial project layout with recommended tools, workflows, and structure. Additionally, it incorporates features like automatic documentation generation, automated testing, and project-specific configuration to enhance the development workflow. The template is aligned with PyOpenSci recommendations, derived from ongoing research on tools, libraries, best practices, and workflows in scientific Python. As a result, SciCookie offers authors a standardized starting point for projects that can be easily adjusted to meet specific requirements while maintaining industry standards.\n",
- "\n",
- "\n",
- "## Benefits of using SciCookie\n",
- "\n",
- "- **Organized Workflow:** Utilizing the SciCookie template allows for maintaining an organized workflow. By configuring elements such as project design, build system, command-line interface, and documentation engine, the development process is streamlined, ensuring a coherent and organized framework for the project.\n",
- "- **Enhanced Project Tools:** SciCookie provides the flexibility to choose from various tools that can enhance the project. These tools automate tasks, ensure consistent code formatting, and identify errors and vulnerabilities.\n",
- "- **DevOps Integration:** Another significant benefit is the seamless integration of the Python project with DevOps tools. These tools automate and optimize the development process, from code status to completion and maintenance."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## How to use SciCookie?\n",
- "\n",
- "### Quickstart\n",
- "\n",
- ">**Note:**\n",
- "Navigate to the folder where you want to create your project.\n",
- "\n",
- "\n",
- "```bash\n",
- "$ pip install scicookie\n",
- "```\n",
- "\n",
- "Once you have entered your folder, you need to generate a Python package project:\n",
- "\n",
- "```bash\n",
- "$ scicookie\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## SciCookie profiles\n",
- "\n",
- "SciCookie enables the community to create different profiles within SciCookie's platform tailored to the standards and preferences of each group or working community. Currently, only the OSL profile is available, but it is open to the community to submit pull requests with specific profiles. Each profile offers different configuration options to choose required tools, define titles for specific messages, and also set titles for documentation and help URLs.\n",
- "\n",
- "```bash\n",
- "$ scicookie --profile osl\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Demo Video\n",
- "\n",
- "For a better explanation, please watch a demonstrative video of the installation of SciCookie and the creation of a project using the OSL profile.\n",
- "\n",
- "\n"
- ]
- }
- ],
- "metadata": {
- "language_info": {
- "name": "python"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/pages/blog/scicookie-collaborating-and-learning/index.md b/pages/blog/scicookie-collaborating-and-learning/index.md
index 31d4d4565..4545b3c44 100644
--- a/pages/blog/scicookie-collaborating-and-learning/index.md
+++ b/pages/blog/scicookie-collaborating-and-learning/index.md
@@ -14,46 +14,78 @@ description: |
thumbnail: "/header.jpeg"
template: "blog-post.html"
---
-# SciCookie
-The SciCookie template, developed by Open Science Labs, is a project template tool package, that uses Cookieninja as a backend, a Cookiecutter fork. Functioning as a versatile boilerplate, it facilitates project creation for both beginners and experienced developers, streamlining the process and saving considerable time. SciCookie provides an initial project layout with recommended tools, workflows, and structure. Additionally, it incorporates features like automatic documentation generation, automated testing, and project-specific configuration to enhance the development workflow. The template is aligned with PyOpenSci recommendations, derived from ongoing research on tools, libraries, best practices, and workflows in scientific Python. As a result, SciCookie offers authors a standardized starting point for projects that can be easily adjusted to meet specific requirements while maintaining industry standards.
+# SciCookie
+The SciCookie template, developed by Open Science Labs, is a project
+template tool package, that uses Cookieninja as a backend, a
+Cookiecutter fork. Functioning as a versatile boilerplate, it
+facilitates project creation for both beginners and experienced
+developers, streamlining the process and saving considerable time.
+SciCookie provides an initial project layout with recommended tools,
+workflows, and structure. Additionally, it incorporates features like
+automatic documentation generation, automated testing, and
+project-specific configuration to enhance the development workflow. The
+template is aligned with PyOpenSci recommendations, derived from ongoing
+research on tools, libraries, best practices, and workflows in
+scientific Python. As a result, SciCookie offers authors a standardized
+starting point for projects that can be easily adjusted to meet specific
+requirements while maintaining industry standards.
## Benefits of using SciCookie
-- **Organized Workflow:** Utilizing the SciCookie template allows for maintaining an organized workflow. By configuring elements such as project design, build system, command-line interface, and documentation engine, the development process is streamlined, ensuring a coherent and organized framework for the project.
-- **Enhanced Project Tools:** SciCookie provides the flexibility to choose from various tools that can enhance the project. These tools automate tasks, ensure consistent code formatting, and identify errors and vulnerabilities.
-- **DevOps Integration:** Another significant benefit is the seamless integration of the Python project with DevOps tools. These tools automate and optimize the development process, from code status to completion and maintenance.
+- **Organized Workflow:** Utilizing the SciCookie template allows for
+ maintaining an organized workflow. By configuring elements such as
+ project design, build system, command-line interface, and
+ documentation engine, the development process is streamlined, ensuring
+ a coherent and organized framework for the project.
+- **Enhanced Project Tools:** SciCookie provides the flexibility to
+ choose from various tools that can enhance the project. These tools
+ automate tasks, ensure consistent code formatting, and identify errors
+ and vulnerabilities.
+- **DevOps Integration:** Another significant benefit is the seamless
+ integration of the Python project with DevOps tools. These tools
+ automate and optimize the development process, from code status to
+ completion and maintenance.
## How to use SciCookie?
### Quickstart
->**Note:**
-Navigate to the folder where you want to create your project.
-
+> **Note:** Navigate to the folder where you want to create your
+> project.
-```bash
+``` bash
$ pip install scicookie
```
-Once you have entered your folder, you need to generate a Python package project:
+Once you have entered your folder, you need to generate a Python package
+project:
-```bash
+``` bash
$ scicookie
```
## SciCookie profiles
-SciCookie enables the community to create different profiles within SciCookie's platform tailored to the standards and preferences of each group or working community. Currently, only the OSL profile is available, but it is open to the community to submit pull requests with specific profiles. Each profile offers different configuration options to choose required tools, define titles for specific messages, and also set titles for documentation and help URLs.
+SciCookie enables the community to create different profiles within
+SciCookie’s platform tailored to the standards and preferences of each
+group or working community. Currently, only the OSL profile is
+available, but it is open to the community to submit pull requests with
+specific profiles. Each profile offers different configuration options
+to choose required tools, define titles for specific messages, and also
+set titles for documentation and help URLs.
-```bash
+``` bash
$ scicookie --profile osl
```
### Demo Video
-For a better explanation, please watch a demonstrative video of the installation of SciCookie and the creation of a project using the OSL profile.
+For a better explanation, please watch a demonstrative video of the
+installation of SciCookie and the creation of a project using the OSL
+profile.
-
+
\ No newline at end of file
diff --git a/pages/blog/scicookie-collaborating-and-learning/index.qmd b/pages/blog/scicookie-collaborating-and-learning/index.qmd
new file mode 100644
index 000000000..12d6354b7
--- /dev/null
+++ b/pages/blog/scicookie-collaborating-and-learning/index.qmd
@@ -0,0 +1,62 @@
+---
+title: "Collaborating and learning from SciCookie"
+slug: scicookie-collaborating-and-learning
+date: 2024-02-03
+authors: ["Daniela Iglesias Rocabado"]
+tags: [open-source, open-science, python, proyects]
+categories: [python]
+description: |
+ The SciCookie template, developed by Open Science Labs, is a Python package based on the Cookieninja A Cookiecutter Fork
+ command-line utility. Serving as a versatile boilerplate, it simplifies project creation for both beginners and experienced
+ developers, saving significant time. Derived from ongoing research on scientific Python tools and best practices, SciCookie
+ aligns with PyOpenSci recommendations, providing a standardized starting point for projects that can be easily customized
+ while adhering to industry standards.
+thumbnail: "/header.jpeg"
+template: "blog-post.html"
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+# SciCookie
+
+The SciCookie template, developed by Open Science Labs, is a project template tool package, that uses Cookieninja as a backend, a Cookiecutter fork. Functioning as a versatile boilerplate, it facilitates project creation for both beginners and experienced developers, streamlining the process and saving considerable time. SciCookie provides an initial project layout with recommended tools, workflows, and structure. Additionally, it incorporates features like automatic documentation generation, automated testing, and project-specific configuration to enhance the development workflow. The template is aligned with PyOpenSci recommendations, derived from ongoing research on tools, libraries, best practices, and workflows in scientific Python. As a result, SciCookie offers authors a standardized starting point for projects that can be easily adjusted to meet specific requirements while maintaining industry standards.
+
+
+## Benefits of using SciCookie
+
+- **Organized Workflow:** Utilizing the SciCookie template allows for maintaining an organized workflow. By configuring elements such as project design, build system, command-line interface, and documentation engine, the development process is streamlined, ensuring a coherent and organized framework for the project.
+- **Enhanced Project Tools:** SciCookie provides the flexibility to choose from various tools that can enhance the project. These tools automate tasks, ensure consistent code formatting, and identify errors and vulnerabilities.
+- **DevOps Integration:** Another significant benefit is the seamless integration of the Python project with DevOps tools. These tools automate and optimize the development process, from code status to completion and maintenance.
+
+## How to use SciCookie?
+
+### Quickstart
+
+>**Note:**
+Navigate to the folder where you want to create your project.
+
+
+```bash
+$ pip install scicookie
+```
+
+Once you have entered your folder, you need to generate a Python package project:
+
+```bash
+$ scicookie
+```
+
+## SciCookie profiles
+
+SciCookie enables the community to create different profiles within SciCookie's platform tailored to the standards and preferences of each group or working community. Currently, only the OSL profile is available, but it is open to the community to submit pull requests with specific profiles. Each profile offers different configuration options to choose required tools, define titles for specific messages, and also set titles for documentation and help URLs.
+
+```bash
+$ scicookie --profile osl
+```
+
+### Demo Video
+
+For a better explanation, please watch a demonstrative video of the installation of SciCookie and the creation of a project using the OSL profile.
+
+
+
diff --git a/pages/blog/scicookie-recibe-nueva-subvencion-de-psf-para-mejoras-crecimiento/index.md b/pages/blog/scicookie-recibe-nueva-subvencion-de-psf-para-mejoras-crecimiento/index.md
index bf2c2c179..7a3889c74 100644
--- a/pages/blog/scicookie-recibe-nueva-subvencion-de-psf-para-mejoras-crecimiento/index.md
+++ b/pages/blog/scicookie-recibe-nueva-subvencion-de-psf-para-mejoras-crecimiento/index.md
@@ -14,37 +14,41 @@ template: "blog-post.html"
---
+
-¡Nos complace anunciar que SciCookie ha recibido una nueva subvención de la
-Python Software Foundation (PSF)!
-
-En Enero de 2024 la PSF aprobó una nueva subvención para SciCookie, la propuesta
-fue enviada a finales de diciembre de 2023, se estará ejecutando entre Febrero y
-Abril de 2024, durante este tiempo estaremos realizando las siguientes tareas:
-
-- Mejorar la documentación de la herramienta: para que sea más clara, completa y
-accesible para nuevos usuarios.
-- Mejorar aspectos de configuración: para facilitar la instalación y uso de
- SciCookie.
-- Incorporar y/o actualizar bibliotecas y otras herramientas: para ampliar las
- funcionalidades.
-- Mejorar la estructura de los archivos: para que el código sea más organizado y
-fácil de mantener.
-- Aplicar a la revisión por pares de pyOpenSci: para obtener la certificación de
-calidad de la herramienta.
-
- En general, las mejoras que se realizarán con esta nueva subvención permitirán
-que SciCookie sea una herramienta aún más poderosa y útil para la comunidad
-científica. Esperamos que esto contribuya a que más investigadores y científicos
-puedan utilizar SciCookie para sus proyectos, lo que a su vez impulsará el
-avance de la ciencia y el código abierto. Estamos muy entusiasmadas con esta
-nueva etapa de SciCookie y esperamos poder compartir con ustedes los avances en
-próximos posts. Agradecemos a la PSF por su apoyo y a toda la comunidad por su
+¡Nos complace anunciar que SciCookie ha recibido una nueva subvención de
+la Python Software Foundation (PSF)!
+
+En Enero de 2024 la PSF aprobó una nueva subvención para SciCookie, la
+propuesta fue enviada a finales de diciembre de 2023, se estará
+ejecutando entre Febrero y Abril de 2024, durante este tiempo estaremos
+realizando las siguientes tareas:
+
+- Mejorar la documentación de la herramienta: para que sea más clara,
+ completa y accesible para nuevos usuarios.
+- Mejorar aspectos de configuración: para facilitar la instalación y uso
+ de SciCookie.
+- Incorporar y/o actualizar bibliotecas y otras herramientas: para
+ ampliar las funcionalidades.
+- Mejorar la estructura de los archivos: para que el código sea más
+ organizado y fácil de mantener.
+- Aplicar a la revisión por pares de pyOpenSci: para obtener la
+ certificación de calidad de la herramienta.
+
+En general, las mejoras que se realizarán con esta nueva subvención
+permitirán que SciCookie sea una herramienta aún más poderosa y útil
+para la comunidad científica. Esperamos que esto contribuya a que más
+investigadores y científicos puedan utilizar SciCookie para sus
+proyectos, lo que a su vez impulsará el avance de la ciencia y el código
+abierto. Estamos muy entusiasmadas con esta nueva etapa de SciCookie y
+esperamos poder compartir con ustedes los avances en próximos posts.
+Agradecemos a la PSF por su apoyo y a toda la comunidad por su
colaboración.
-Si deseas, puedes echar un vistazo en el repositorio de SciCookie en GitHub
-haciendo clic [>aquí<](https://github.com/osl-incubator/scicookie).
+Si deseas, puedes echar un vistazo en el repositorio de SciCookie en
+GitHub haciendo clic
+[\>aquí\<](https://github.com/osl-incubator/scicookie).
Elementos gráficos de la portada fueron extraídos de
-[Work illustrations by Storyset](https://storyset.com/work).
+[Work illustrations by Storyset](https://storyset.com/work).
\ No newline at end of file
diff --git a/pages/blog/scicookie-recibe-nueva-subvencion-de-psf-para-mejoras-crecimiento/index.qmd b/pages/blog/scicookie-recibe-nueva-subvencion-de-psf-para-mejoras-crecimiento/index.qmd
new file mode 100644
index 000000000..7c1148c42
--- /dev/null
+++ b/pages/blog/scicookie-recibe-nueva-subvencion-de-psf-para-mejoras-crecimiento/index.qmd
@@ -0,0 +1,53 @@
+---
+title: "SciCookie recibe nueva subvención de PSF para mejoras y crecimiento"
+slug: scicookie-recibe-nueva-subvencion-de-psf-para-mejoras-crecimiento
+date: 2024-03-01
+authors: ["Anavelyz Perez", "Yurely Camacho"]
+tags:
+ [psf, osl, scicookie, subvención, grant, comunidad, colaboración, desarrollo]
+categories: [código abierto, desarrollo de software, python]
+description: |
+ ¡Nos complace anunciar que SciCookie ha recibido una nueva subvención
+ de la Python Software Foundation (PSF)!
+thumbnail: "/header.svg"
+template: "blog-post.html"
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+
+
+
+
+¡Nos complace anunciar que SciCookie ha recibido una nueva subvención de la
+Python Software Foundation (PSF)!
+
+En Enero de 2024 la PSF aprobó una nueva subvención para SciCookie, la propuesta
+fue enviada a finales de diciembre de 2023, se estará ejecutando entre Febrero y
+Abril de 2024, durante este tiempo estaremos realizando las siguientes tareas:
+
+- Mejorar la documentación de la herramienta: para que sea más clara, completa y
+accesible para nuevos usuarios.
+- Mejorar aspectos de configuración: para facilitar la instalación y uso de
+ SciCookie.
+- Incorporar y/o actualizar bibliotecas y otras herramientas: para ampliar las
+ funcionalidades.
+- Mejorar la estructura de los archivos: para que el código sea más organizado y
+fácil de mantener.
+- Aplicar a la revisión por pares de pyOpenSci: para obtener la certificación de
+calidad de la herramienta.
+
+ En general, las mejoras que se realizarán con esta nueva subvención permitirán
+que SciCookie sea una herramienta aún más poderosa y útil para la comunidad
+científica. Esperamos que esto contribuya a que más investigadores y científicos
+puedan utilizar SciCookie para sus proyectos, lo que a su vez impulsará el
+avance de la ciencia y el código abierto. Estamos muy entusiasmadas con esta
+nueva etapa de SciCookie y esperamos poder compartir con ustedes los avances en
+próximos posts. Agradecemos a la PSF por su apoyo y a toda la comunidad por su
+colaboración.
+
+Si deseas, puedes echar un vistazo en el repositorio de SciCookie en GitHub
+haciendo clic [>aquí<](https://github.com/osl-incubator/scicookie).
+
+Elementos gráficos de la portada fueron extraídos de
+[Work illustrations by Storyset](https://storyset.com/work).
diff --git a/pages/blog/streamlining-project-automation-with-makim/index.ipynb b/pages/blog/streamlining-project-automation-with-makim/index.ipynb
deleted file mode 100644
index dbca96736..000000000
--- a/pages/blog/streamlining-project-automation-with-makim/index.ipynb
+++ /dev/null
@@ -1,1016 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "raw",
- "id": "14c8a840-5020-486d-a007-f2d4769dfc69",
- "metadata": {},
- "source": [
- "---\n",
- "title: \"Streamlining Project Automation with Makim\"\n",
- "slug: \"streamlining-project-automation-with-makim\"\n",
- "date: 2024-03-18\n",
- "authors: [\"Ivan Ogasawara\"]\n",
- "tags: [\"makim\", \"automation\", \"devops\", \"open-source\"]\n",
- "categories: [\"devops\", \"automation\", \"python\"]\n",
- "description: |\n",
- " In software development, where efficiency, consistency, and reliability are paramount,\n",
- " automation tools play a crucial role. Makim, an innovative open-source tool, steps\n",
- " into the spotlight to improve automation workflows. It simplifies script execution,\n",
- " environment management, and task dependencies, positioning itself as a great asset in\n",
- " modern development environments.\n",
- " environment.\n",
- "thumbnail: \"/header.png\"\n",
- "template: \"blog-post.html\"\n",
- "---"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "232d0e08-2248-40d7-a1f9-c52bff1b357a",
- "metadata": {},
- "source": [
- "# Streamlining Project Automation with Makim\n",
- "\n",
- "In software development, where efficiency, consistency, and reliability are paramount, automation tools play a crucial role. Makim, an innovative open-source tool, steps into the spotlight to improve automation workflows. It simplifies script execution, environment management, and task dependencies, positioning itself as a great asset in modern development environments.\n",
- "\n",
- "## Introducing Makim\n",
- "\n",
- "`Makim` elevates project automation by offering a structured, yet flexible approach to manage routine tasks, complex task dependencies, and environment configurations. Its design is centered around the `.makim.yaml` configuration file, allowing developers to orchestrate their workflows with precision and ease. Unlike traditional script execution tools, Makim's Python-based architecture and support for multiple programming languages and shells enhance its versatility and applicability across diverse projects.\n",
- "\n",
- "Especially suited for DevOps Engineers and Software Developers, Makim eliminates redundancy in automation tasks. Its core functionality extends beyond simple script execution, encompassing:\n",
- "\n",
- "- Argument definition for scripts\n",
- "- Organization of tasks into groups\n",
- "- Advanced dependency management between tasks\n",
- "- Utilization of environment variables and custom variables\n",
- "- Dynamic content generation with Jinja2 templates\n",
- "- Specification of working directories for tasks\n",
- "- Execution flexibility through support for multiple interpreters or shells\n",
- "\n",
- "Despite its broad capabilities, Makim currently lacks support for Windows but plans to extend its compatibility in future versions.\n",
- "\n",
- "## Getting Started with Makim\n",
- "\n",
- "### Installation\n",
- "\n",
- "Makim can be installed via `pip` or `conda`, catering to different setup preferences:\n",
- "\n",
- "- To install `Makim` using `pip`, run:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "id": "761586e2-98ef-4fc1-a73b-7d9d4e1c8e7e",
- "metadata": {},
- "outputs": [],
- "source": [
- "!pip install -q \"makim==1.14.0\""
- ]
- },
- {
- "cell_type": "markdown",
- "id": "b0af5f25-4807-4637-9036-62fa6f894bef",
- "metadata": {},
- "source": [
- "- For those who prefer `conda`, execute:\n",
- "\n",
- " ```\n",
- " conda install \"makim=1.14.0\"\n",
- " ```\n",
- "\n",
- "Given Makim's active development, pinning to a specific version is recommended to ensure consistency.\n",
- "\n",
- "For this tutorial, we will disable the output color feature provided by typer, the command-line interface engine used by **Makim**."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "e6f6a633-79e3-4690-928b-4e74b725c83c",
- "metadata": {},
- "outputs": [],
- "source": [
- "import os\n",
- "\n",
- "os.environ[\"NO_COLOR\"] = \"1\""
- ]
- },
- {
- "cell_type": "markdown",
- "id": "4ff221f5-e18b-4b0b-bbb5-4cd8547bf35a",
- "metadata": {},
- "source": [
- "### Configuring `.makim.yaml`\n",
- "\n",
- "The `.makim.yaml` file is the foundation of your Makim configuration. Here's how to start:\n",
- "\n",
- "1. **Create the `.makim.yaml` File**: Place this file at the root of your project directory.\n",
- " \n",
- "2. **Define Your Automation Tasks**: Configure your tasks, specifying actions, arguments, and dependencies. For example:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "id": "dd79bbd0-73db-4d25-ae06-a143aef3b8e1",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Overwriting .makim.yaml\n"
- ]
- }
- ],
- "source": [
- "%%writefile .makim.yaml\n",
- "version: 1.0.0\n",
- "groups:\n",
- " clean:\n",
- " env-file: .env\n",
- " targets:\n",
- " tmp:\n",
- " help: Use this target to clean up temporary files\n",
- " run: |\n",
- " echo \"Cleaning up...\"\n",
- " tests:\n",
- " targets:\n",
- " unit:\n",
- " help: Build the program\n",
- " args:\n",
- " clean:\n",
- " type: bool\n",
- " action: store_true\n",
- " help: if not set, the clean dependency will not be triggered.\n",
- " dependencies:\n",
- " - target: clean.tmp\n",
- " if: ${{ args.clean == true }}\n",
- " run: |\n",
- " echo \"Runnint unit tests...\""
- ]
- },
- {
- "cell_type": "markdown",
- "id": "7bb49d00-0f25-4679-97ce-2bd2ecfa6e3c",
- "metadata": {},
- "source": [
- "This setup demonstrates Makim's ability to manage tasks with conditional logic and dependencies.\n",
- "\n",
- "### Exploring Makim's CLI\n",
- "\n",
- "Makim's CLI provides insights into available commands, arguments, and configurations through the auto-generated help menu:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "id": "5e17c7ab-a183-40d9-bc1a-96ff8be6a91b",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "\u001b[1m \u001b[0m\n",
- "\u001b[1m \u001b[0m\u001b[1mUsage: \u001b[0m\u001b[1mmakim [OPTIONS] COMMAND [ARGS]...\u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m\n",
- "\u001b[1m \u001b[0m\n",
- " Makim is a tool that helps you to organize and simplify your helper commands. \n",
- " \n",
- "\u001b[2m╭─\u001b[0m\u001b[2m Options \u001b[0m\u001b[2m───────────────────────────────────────────────────────────────────\u001b[0m\u001b[2m─╮\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-version\u001b[0m \u001b[1m-v\u001b[0m \u001b[1m \u001b[0m Show the version and exit \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-file\u001b[0m \u001b[1mTEXT\u001b[0m Makim config file \u001b[2m[default: .makim.yaml]\u001b[0m \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-dry\u001b[0m\u001b[1m-run\u001b[0m \u001b[1m \u001b[0m Execute the command in dry mode \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-verbose\u001b[0m \u001b[1m \u001b[0m Execute the command in verbose mode \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-install\u001b[0m\u001b[1m-completion\u001b[0m \u001b[1m \u001b[0m Install completion for the current \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m shell. \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-show\u001b[0m\u001b[1m-completion\u001b[0m \u001b[1m \u001b[0m Show completion for the current shell, \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m to copy it or customize the \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m installation. \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-help\u001b[0m \u001b[1m \u001b[0m Show this message and exit. \u001b[2m│\u001b[0m\n",
- "\u001b[2m╰──────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n",
- "\u001b[2m╭─\u001b[0m\u001b[2m Commands \u001b[0m\u001b[2m──────────────────────────────────────────────────────────────────\u001b[0m\u001b[2m─╮\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1mclean.tmp \u001b[0m\u001b[1m \u001b[0m Use this target to clean up temporary files \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1mtests.unit \u001b[0m\u001b[1m \u001b[0m Build the program \u001b[2m│\u001b[0m\n",
- "\u001b[2m╰──────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n",
- " \n",
- " If you have any problem, open an issue at: \n",
- " https://github.com/osl-incubator/makim \n",
- " \n",
- "\n"
- ]
- }
- ],
- "source": [
- "!makim --help"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "be6b96d3-79f8-48e2-8e9e-edeb38a4dc58",
- "metadata": {},
- "source": [
- "This feature facilitates easy access to Makim's functionalities, enhancing usability and understanding of the tool.\n",
- "\n",
- "### Executing Your First Commands\n",
- "\n",
- "With your `.makim.yaml` file set up, you can begin to use `makim`:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "id": "535b89a1-cb6c-48ce-b4d3-2a9296c97f2b",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Makim file: .makim.yaml\n",
- "Cleaning up...\n"
- ]
- }
- ],
- "source": [
- "!makim clean.tmp"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "id": "6c997aeb-eed5-4801-8bfb-dad26bb72dcb",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Makim file: .makim.yaml\n",
- "Runnint unit tests...\n"
- ]
- }
- ],
- "source": [
- "!makim tests.unit"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "48ed3970-3854-49cb-8109-53a38a72d8d4",
- "metadata": {},
- "source": [
- "In the case you type your command wrong, **Makim** will suggest you some alternative:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "id": "800ad2a4-0c45-4b1a-b4ef-927ab1230e60",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Usage: makim [OPTIONS] COMMAND [ARGS]...\n",
- "\u001b[2mTry \u001b[0m\u001b[2m'makim \u001b[0m\u001b[1;2m-\u001b[0m\u001b[1;2m-help\u001b[0m\u001b[2m'\u001b[0m\u001b[2m for help.\u001b[0m\n",
- "╭─ Error ──────────────────────────────────────────────────────────────────────╮\n",
- "│ No such command 'tests.unittest'. │\n",
- "╰──────────────────────────────────────────────────────────────────────────────╯\n",
- "\u001b[31mCommand tests.unittest not found. Did you mean tests.unit'?\u001b[0m\n"
- ]
- }
- ],
- "source": [
- "!makim tests.unittest"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "aae58d63-d028-47b1-a57e-fb21fc3f9216",
- "metadata": {},
- "source": [
- "**Makim** CLI is empowered by **Typer**, and it allows us to have auto-completion for Makim groups and targets! If you want to install, you can run the following command:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "id": "5839d8fb-0a4c-43bf-8b11-1a1ab36cc178",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "\u001b[32mbash completion installed in /home/xmn/.bash_completions/makim.sh\u001b[0m\n",
- "Completion will take effect once you restart the terminal\n"
- ]
- }
- ],
- "source": [
- "!makim --install-completion "
- ]
- },
- {
- "cell_type": "markdown",
- "id": "962a1698-31b4-4223-b08d-e065d5463bd9",
- "metadata": {},
- "source": [
- "After this command you will need to restart the terminal in order to use this auto-completion feature."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "2cc6ebb1-304b-4aab-b5f8-ca72289e1815",
- "metadata": {},
- "source": [
- "## Advanced Features and Examples\n",
- "\n",
- "Makim's adaptability is showcased through various features and practical examples:\n",
- "\n",
- "- **Conditional Dependencies and Arguments**: Define complex task dependencies with conditional execution based on passed arguments.\n",
- "- **Dynamic Configuration with Jinja2**: Leverage Jinja2 templates for advanced scripting and dynamic content generation.\n",
- "- **Environment and Custom Variable Management**: Organize and utilize variables effectively across different scopes of your project.\n",
- "- **Specifying Working Directories**: Control the execution context of your tasks by setting working directories.\n",
- "\n",
- "These examples underscore Makim's capability to accommodate intricate automation scenarios, streamlining development workflows.\n",
- "\n",
- "## Exploring Makim Through Examples\n",
- "\n",
- "### Utilizing Various Interpreters\n",
- "\n",
- "Makim extends its functionality beyond conventional script execution by supporting various interpreters and shell languages, facilitating a versatile development environment. While **xonsh** is the default interpreter - blending the capabilities of Bash and Python for an enriched command-line experience - Makim's architecture allows for seamless integration with other environments. For developers seeking to leverage this feature, a foundational understanding of **xonsh** can be beneficial. Comprehensive details and usage guidelines are available in the [official xonsh documentation](https://xon.sh/).\n",
- "\n",
- "This section demonstrates executing straightforward commands across multiple interpreters, showcasing Makim's adaptability to diverse programming contexts."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "id": "0d942c28-d13a-4131-b5e4-113667a69c3e",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Overwriting .env\n"
- ]
- }
- ],
- "source": [
- "%%writefile .env\n",
- "MSG_PREFIX=\"Running Makim: Hello, World,\""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "id": "f68e8008-f0f1-4ead-a42e-4e524fc03c22",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Overwriting .makim.yaml\n"
- ]
- }
- ],
- "source": [
- "%%writefile .makim.yaml\n",
- "version: 1.0\n",
- "env-file: .env\n",
- "groups:\n",
- " tests:\n",
- " targets:\n",
- " node:\n",
- " help: Test using nodejs\n",
- " shell: node\n",
- " run: console.log(\"${{ env.MSG_PREFIX }} from NodeJS!\");\n",
- " perl:\n",
- " help: Test using perl\n",
- " shell: perl\n",
- " run: print \"${{ env.MSG_PREFIX }} from Perl!\\n\";\n",
- "\n",
- " python:\n",
- " help: Test using php\n",
- " shell: python\n",
- " run: print(\"${{ env.MSG_PREFIX }} from Python!\")\n",
- "\n",
- " r:\n",
- " help: Test using R\n",
- " shell: Rscript\n",
- " run: print(\"${{ env.MSG_PREFIX }} from R!\")\n",
- "\n",
- " sh:\n",
- " help: Test using sh\n",
- " shell: sh\n",
- " run: echo \"${{ env.MSG_PREFIX }} from sh!\"\n",
- "\n",
- " run-all:\n",
- " help: Run tests for all the other targets\n",
- " dependencies:\n",
- " - target: node\n",
- " - target: perl\n",
- " - target: python\n",
- " - target: r\n",
- " - target: sh"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "id": "ce809dd8-7db4-4c56-8622-ec3411bad4cf",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "\u001b[1m \u001b[0m\n",
- "\u001b[1m \u001b[0m\u001b[1mUsage: \u001b[0m\u001b[1mmakim [OPTIONS] COMMAND [ARGS]...\u001b[0m\u001b[1m \u001b[0m\u001b[1m \u001b[0m\n",
- "\u001b[1m \u001b[0m\n",
- " Makim is a tool that helps you to organize and simplify your helper commands. \n",
- " \n",
- "\u001b[2m╭─\u001b[0m\u001b[2m Options \u001b[0m\u001b[2m───────────────────────────────────────────────────────────────────\u001b[0m\u001b[2m─╮\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-version\u001b[0m \u001b[1m-v\u001b[0m \u001b[1m \u001b[0m Show the version and exit \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-file\u001b[0m \u001b[1mTEXT\u001b[0m Makim config file \u001b[2m[default: .makim.yaml]\u001b[0m \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-dry\u001b[0m\u001b[1m-run\u001b[0m \u001b[1m \u001b[0m Execute the command in dry mode \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-verbose\u001b[0m \u001b[1m \u001b[0m Execute the command in verbose mode \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-install\u001b[0m\u001b[1m-completion\u001b[0m \u001b[1m \u001b[0m Install completion for the current \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m shell. \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-show\u001b[0m\u001b[1m-completion\u001b[0m \u001b[1m \u001b[0m Show completion for the current shell, \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m to copy it or customize the \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m installation. \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1m-\u001b[0m\u001b[1m-help\u001b[0m \u001b[1m \u001b[0m Show this message and exit. \u001b[2m│\u001b[0m\n",
- "\u001b[2m╰──────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n",
- "\u001b[2m╭─\u001b[0m\u001b[2m Commands \u001b[0m\u001b[2m──────────────────────────────────────────────────────────────────\u001b[0m\u001b[2m─╮\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1mtests.node \u001b[0m\u001b[1m \u001b[0m Test using nodejs \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1mtests.perl \u001b[0m\u001b[1m \u001b[0m Test using perl \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1mtests.python \u001b[0m\u001b[1m \u001b[0m Test using php \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1mtests.r \u001b[0m\u001b[1m \u001b[0m Test using R \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1mtests.run-all \u001b[0m\u001b[1m \u001b[0m Run tests for all the other targets \u001b[2m│\u001b[0m\n",
- "\u001b[2m│\u001b[0m \u001b[1mtests.sh \u001b[0m\u001b[1m \u001b[0m Test using sh \u001b[2m│\u001b[0m\n",
- "\u001b[2m╰──────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n",
- " \n",
- " If you have any problem, open an issue at: \n",
- " https://github.com/osl-incubator/makim \n",
- " \n",
- "\n"
- ]
- }
- ],
- "source": [
- "!makim --help"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "14ed7f09-9bea-490d-ad3d-629ea4ee971f",
- "metadata": {},
- "source": [
- "Prior to executing these targets, it is necessary to install the required dependencies:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "id": "defb03d3-404d-489b-9990-ed66552aa341",
- "metadata": {},
- "outputs": [],
- "source": [
- "!mamba install -q -y perl nodejs r-base sh "
- ]
- },
- {
- "cell_type": "markdown",
- "id": "402bf345-9a18-403f-be99-e428e7c78b97",
- "metadata": {},
- "source": [
- "Proceed to execute all defined targets by invoking the run-all target, which encapsulates all other targets as its dependencies for a sequential execution process:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "id": "8f4e23ef-0238-4393-9747-8f945de40f79",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Makim file: .makim.yaml\n",
- "Running Makim: Hello, World, from NodeJS!\n",
- "(node:1634785) Warning: The 'NO_COLOR' env is ignored due to the 'FORCE_COLOR' env being set.\n",
- "(Use `node --trace-warnings ...` to show where the warning was created)\n",
- "Running Makim: Hello, World, from Perl!\n",
- "Running Makim: Hello, World, from Python!\n",
- "[1] \"Running Makim: Hello, World, from R!\"\n",
- "Running Makim: Hello, World, from sh!\n"
- ]
- }
- ],
- "source": [
- "!makim tests.run-all"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "d57e524f-9ddd-4e1e-9d90-e47154c0950d",
- "metadata": {},
- "source": [
- "In scenarios where your chosen interpreter supports debugging - such as Python or Xonsh through the use of `breakpoint()` - you can introduce a breakpoint within your code. This enables the debugging of your **Makim** target, allowing for an interactive examination of the execution flow and variable states."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "43d8808a-6b75-4e54-a193-4ba148de913a",
- "metadata": {},
- "source": [
- "### Using Variables (vars)\n",
- "\n",
- "**Makim** facilitates the definition of variables within the `.makim.yaml` configuration, supporting all the **YAML** data types, including strings, lists, and dictionaries. This feature enhances script configurability and reusability across different tasks and environments.\n",
- "\n",
- "Consider reviewing the provided example to understand how to effectively leverage variables in your **Makim** configurations:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "id": "ff7b4903-8caf-454b-828f-4ab6cf57d8fa",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Overwriting .makim.yaml\n"
- ]
- }
- ],
- "source": [
- "%%writefile .makim.yaml\n",
- "version: 1.0\n",
- "\n",
- "vars:\n",
- " project-name: \"my-project\"\n",
- " dependencies:\n",
- " \"dep1\": \"v1\"\n",
- " \"dep2\": \"v1.1\"\n",
- " \"dep3\": \"v2.3\"\n",
- " authorized-users:\n",
- " - admin1\n",
- " - admin2\n",
- " - admin3\n",
- "\n",
- "groups:\n",
- " staging:\n",
- " vars:\n",
- " env-name: \"staging\"\n",
- " staging-dependencies:\n",
- " \"dep4\": \"v4.3\"\n",
- " \"dep5\": \"v1.1.1\"\n",
- " staging-authorized-users:\n",
- " - staging1\n",
- " - staging2\n",
- " - staging3\n",
- " targets:\n",
- " create-users:\n",
- " help: Create users for staging, this example uses jinja2 for loop.\n",
- " # each target can also specify their `vars`, but it will not be used in this example\n",
- " run: |\n",
- " def create_user(username):\n",
- " print(f\">>> creating user: {username} ... DONE!\")\n",
- " \n",
- " print(\"create admin users:\")\n",
- " {% for user in vars.authorized_users %}\n",
- " create_user(\"${{ user }}\")\n",
- " {% endfor %}\n",
- "\n",
- " print(\"\\ncreate staging users:\")\n",
- " {% for user in vars.staging_authorized_users %}\n",
- " create_user(\"${{ user }}\")\n",
- " {% endfor %}\n",
- "\n",
- " install:\n",
- " help: install deps for staging using native xonsh `for` loop (it could work with Python as well)\n",
- " # each target can also specify their `vars`, but it will not be used in this example\n",
- " run: |\n",
- " def install(package, version):\n",
- " print(f\">>> installing: {package}@{version} ... DONE!\")\n",
- " \n",
- " print(\"install global dependencies:\")\n",
- " for package, version in ${{ vars.dependencies | safe }}.items():\n",
- " install(package, version)\n",
- "\n",
- " print(\"\\ninstall staging dependencies:\")\n",
- " for package, version in ${{ vars.staging_dependencies | safe }}.items():\n",
- " install(package, version)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "2b67905e-2e5b-4d54-bee8-eadcfe12cd66",
- "metadata": {},
- "source": [
- "Now, let's proceed to create users within the staging environment:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 15,
- "id": "89f4ea8e-b58e-4da3-9097-61deaf5e6c70",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Makim file: .makim.yaml\n",
- "create admin users:\n",
- ">>> creating user: admin1 ... DONE!\n",
- ">>> creating user: admin2 ... DONE!\n",
- ">>> creating user: admin3 ... DONE!\n",
- "\n",
- "create staging users:\n",
- ">>> creating user: staging1 ... DONE!\n",
- ">>> creating user: staging2 ... DONE!\n",
- ">>> creating user: staging3 ... DONE!\n"
- ]
- }
- ],
- "source": [
- "!makim staging.create-users"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "cd07e3af-4527-4530-952e-01848701e185",
- "metadata": {},
- "source": [
- "Last but not least, let's run the install target:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 16,
- "id": "2eb7291c-610a-427c-a970-bb923b17678e",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Makim file: .makim.yaml\n",
- "install global dependencies:\n",
- ">>> installing: dep1@v1 ... DONE!\n",
- ">>> installing: dep2@v1.1 ... DONE!\n",
- ">>> installing: dep3@v2.3 ... DONE!\n",
- "\n",
- "install staging dependencies:\n",
- ">>> installing: dep4@v4.3 ... DONE!\n",
- ">>> installing: dep5@v1.1.1 ... DONE!\n"
- ]
- }
- ],
- "source": [
- "!makim staging.install"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "fcfc9258-a97d-4378-9cbb-e1be2678c801",
- "metadata": {},
- "source": [
- "### Defining Arguments\n",
- "\n",
- "**Makim** enhances script flexibility by allowing the use of arguments. It enables not only the definition of arguments for tasks but also the passing of arguments to dependencies and the specification of conditions for those dependencies.\n",
- "\n",
- "Explore this functionality through this example:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 17,
- "id": "cb5c198b-4644-4e92-b1a4-cc66c55fc29d",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Overwriting .makim.yaml\n"
- ]
- }
- ],
- "source": [
- "%%writefile .makim.yaml\n",
- "version: 1.0.0\n",
- "groups:\n",
- " print:\n",
- " env-file: .env\n",
- " targets:\n",
- " name:\n",
- " help: Print given name\n",
- " args:\n",
- " name:\n",
- " type: str\n",
- " required: true\n",
- " run: print(\"${{ args.name }}\")\n",
- " list:\n",
- " help: Build the program\n",
- " args:\n",
- " i-am-sure:\n",
- " type: bool\n",
- " dependencies:\n",
- " - target: print.name\n",
- " if: ${{ args.i_am_sure == true }}\n",
- " args:\n",
- " name: Mary\n",
- " - target: print.name\n",
- " if: ${{ args.i_am_sure == true }}\n",
- " args:\n",
- " name: John\n",
- " - target: print.name\n",
- " if: ${{ args.i_am_sure == true }}\n",
- " args:\n",
- " name: Ellen\n",
- " - target: print.name\n",
- " if: ${{ args.i_am_sure == true }}\n",
- " args:\n",
- " name: Marc"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 18,
- "id": "551d69e9-d074-4b70-b868-f7e9fa6faba6",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Makim file: .makim.yaml\n"
- ]
- }
- ],
- "source": [
- "!makim print.list"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 19,
- "id": "dfe7b8ba-f438-4f62-88fc-e99e11a15bee",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Makim file: .makim.yaml\n",
- "Mary\n",
- "John\n",
- "Ellen\n",
- "Marc\n"
- ]
- }
- ],
- "source": [
- "!makim print.list --i-am-sure"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "5f7c72db-31d6-47f5-a8aa-932f3e5bf2a7",
- "metadata": {},
- "source": [
- "### Utilizing Environment Variables\n",
- "\n",
- "The previous sections demonstrated the use of environment variables. Here, we'll delve into their application in more detail.\n",
- "\n",
- "**Makim** permits the incorporation of environment variables from `.env` files or directly within the `.makim.yaml` file, applicable at global, group, and target levels.\n",
- "\n",
- "Examine an example to understand the implementation:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 20,
- "id": "6e0c4c5a-ef21-43e0-ac18-40672850b93a",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Overwriting .env\n"
- ]
- }
- ],
- "source": [
- "%%writefile .env\n",
- "ENV=dev"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 21,
- "id": "678192e5-7af3-4862-bc76-4beecf030bd2",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Overwriting .makim.yaml\n"
- ]
- }
- ],
- "source": [
- "%%writefile .makim.yaml\n",
- "version: 1.0\n",
- "env-file: .env\n",
- "env:\n",
- " GLOBAL_VAR: \"1\"\n",
- "groups:\n",
- " global-scope:\n",
- " env:\n",
- " GROUP_VAR: \"2\"\n",
- " targets:\n",
- " test-var-env-file:\n",
- " help: Test env variable defined in the global scope from env-file\n",
- " run: |\n",
- " import os\n",
- " assert str(os.getenv(\"ENV\")) == \"dev\"\n",
- "\n",
- " test-var-env:\n",
- " help: Test env variable defined in the global scope in `env` section\n",
- " env:\n",
- " TARGET_VAR: \"3\"\n",
- " run: |\n",
- " import os\n",
- " # you can get an environment variable directly with xonsh/python\n",
- " assert str(os.getenv(\"GLOBAL_VAR\")) == \"1\"\n",
- " # or you can get an environment variable using jinja2 tag\n",
- " assert \"${{ env.GROUP_VAR }}\" == \"2\"\n",
- " assert \"${{ env.get(\"TARGET_VAR\") }}\" == \"3\"\n",
- " assert \"${{ env.get(\"UNKNOWN_TARGET_VAR\", \"4\") }}\" == \"4\""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 22,
- "id": "6221cfec-19b5-450e-853e-737ce0ed024f",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Makim file: .makim.yaml\n"
- ]
- }
- ],
- "source": [
- "!makim global-scope.test-var-env-file"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 23,
- "id": "548a68cf-b597-4eb9-8438-eb97729dcb46",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Makim file: .makim.yaml\n"
- ]
- }
- ],
- "source": [
- "!makim global-scope.test-var-env"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "ce5e09d7-bf8b-4b0e-9127-48958ee79601",
- "metadata": {},
- "source": [
- "### Specifying the Working Directory\n",
- "\n",
- "Makim provides the capability to set a specific working directory for tasks at any scope: global, group, or target.\n",
- "\n",
- "Review a straightforward example to learn how to apply this feature:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 24,
- "id": "65335daf-ac06-497c-a0f8-6dbb9f5a570b",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Overwriting .makim.yaml\n"
- ]
- }
- ],
- "source": [
- "%%writefile .makim.yaml\n",
- "version: 1.0\n",
- "working-directory: \"/tmp\"\n",
- "\n",
- "groups:\n",
- " check-wd:\n",
- " targets:\n",
- " is-tmp:\n",
- " help: Test if working directory is `tmp`\n",
- " run: |\n",
- " import os\n",
- " print(os.getcwd())\n",
- " assert os.getcwd() == \"/tmp\""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 25,
- "id": "0938bcee-26fb-4028-82f6-bbed8453eba7",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Makim file: .makim.yaml\n",
- "/tmp\n"
- ]
- }
- ],
- "source": [
- "!makim check-wd.is-tmp"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "ae987426-9ead-4375-bddf-b5ded48aeb1a",
- "metadata": {},
- "source": [
- "This tutorial concludes with a showcase of Makim's key features. While this overview covers the essentials, diving deeper into **Makim** will reveal more advanced and intriguing ways to leverage its capabilities."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "a5f5fb97-503f-4a3b-92a7-8ecef4d9687c",
- "metadata": {},
- "source": [
- "## Contributing to Makim\n",
- "\n",
- "Makim's growth is propelled by its community. Contributions, whether through code, documentation, or feedback, are welcome. Explore the [GitHub repository](https://github.com/osl-incubator/makim) and consider contributing to foster Makim's development."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "822a5ed4-6941-4761-9a7b-9910dd075849",
- "metadata": {},
- "source": [
- "## Conclusion\n",
- "\n",
- "Makim stands out as a transformative tool in project automation, bridging the gap between simplicity and complexity. Its comprehensive feature set, coupled with the flexibility of its configuration, makes Makim a quintessential tool for developers and DevOps engineers alike. As you incorporate Makim into your projects, its impact on enhancing productivity and consistency will become evident, marking it as an indispensable part of your development toolkit.\n",
- "\n",
- "Dive deeper into Makim's functionalities by visiting the [official documentation](https://github.com/osl-incubator/makim). Try it and let us know your thoughts about it!"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3 (ipykernel)",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.11.7"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/pages/blog/streamlining-project-automation-with-makim/index.md b/pages/blog/streamlining-project-automation-with-makim/index.md
index 03f6868fc..11c840a0b 100644
--- a/pages/blog/streamlining-project-automation-with-makim/index.md
+++ b/pages/blog/streamlining-project-automation-with-makim/index.md
@@ -15,15 +15,30 @@ description: |
thumbnail: "/header.png"
template: "blog-post.html"
---
+
# Streamlining Project Automation with Makim
-In software development, where efficiency, consistency, and reliability are paramount, automation tools play a crucial role. Makim, an innovative open-source tool, steps into the spotlight to improve automation workflows. It simplifies script execution, environment management, and task dependencies, positioning itself as a great asset in modern development environments.
+In software development, where efficiency, consistency, and reliability
+are paramount, automation tools play a crucial role. Makim, an
+innovative open-source tool, steps into the spotlight to improve
+automation workflows. It simplifies script execution, environment
+management, and task dependencies, positioning itself as a great asset
+in modern development environments.
## Introducing Makim
-`Makim` elevates project automation by offering a structured, yet flexible approach to manage routine tasks, complex task dependencies, and environment configurations. Its design is centered around the `.makim.yaml` configuration file, allowing developers to orchestrate their workflows with precision and ease. Unlike traditional script execution tools, Makim's Python-based architecture and support for multiple programming languages and shells enhance its versatility and applicability across diverse projects.
+`Makim` elevates project automation by offering a structured, yet
+flexible approach to manage routine tasks, complex task dependencies,
+and environment configurations. Its design is centered around the
+`.makim.yaml` configuration file, allowing developers to orchestrate
+their workflows with precision and ease. Unlike traditional script
+execution tools, Makim’s Python-based architecture and support for
+multiple programming languages and shells enhance its versatility and
+applicability across diverse projects.
-Especially suited for DevOps Engineers and Software Developers, Makim eliminates redundancy in automation tasks. Its core functionality extends beyond simple script execution, encompassing:
+Especially suited for DevOps Engineers and Software Developers, Makim
+eliminates redundancy in automation tasks. Its core functionality
+extends beyond simple script execution, encompassing:
- Argument definition for scripts
- Organization of tasks into groups
@@ -31,35 +46,36 @@ Especially suited for DevOps Engineers and Software Developers, Makim eliminates
- Utilization of environment variables and custom variables
- Dynamic content generation with Jinja2 templates
- Specification of working directories for tasks
-- Execution flexibility through support for multiple interpreters or shells
+- Execution flexibility through support for multiple interpreters or
+ shells
-Despite its broad capabilities, Makim currently lacks support for Windows but plans to extend its compatibility in future versions.
+Despite its broad capabilities, Makim currently lacks support for
+Windows but plans to extend its compatibility in future versions.
## Getting Started with Makim
### Installation
-Makim can be installed via `pip` or `conda`, catering to different setup preferences:
+Makim can be installed via `pip` or `conda`, catering to different setup
+preferences:
- To install `Makim` using `pip`, run:
-
-```python
+``` python
!pip install -q "makim==1.14.0"
```
- For those who prefer `conda`, execute:
- ```
- conda install "makim=1.14.0"
- ```
-
-Given Makim's active development, pinning to a specific version is recommended to ensure consistency.
+ conda install "makim=1.14.0"
-For this tutorial, we will disable the output color feature provided by typer, the command-line interface engine used by **Makim**.
+Given Makim’s active development, pinning to a specific version is
+recommended to ensure consistency.
+For this tutorial, we will disable the output color feature provided by
+typer, the command-line interface engine used by **Makim**.
-```python
+``` python
import os
os.environ["NO_COLOR"] = "1"
@@ -67,14 +83,16 @@ os.environ["NO_COLOR"] = "1"
### Configuring `.makim.yaml`
-The `.makim.yaml` file is the foundation of your Makim configuration. Here's how to start:
+The `.makim.yaml` file is the foundation of your Makim configuration.
+Here’s how to start:
-1. **Create the `.makim.yaml` File**: Place this file at the root of your project directory.
-
-2. **Define Your Automation Tasks**: Configure your tasks, specifying actions, arguments, and dependencies. For example:
+1. **Create the `.makim.yaml` File**: Place this file at the root of
+ your project directory.
+2. **Define Your Automation Tasks**: Configure your tasks, specifying
+ actions, arguments, and dependencies. For example:
-```python
+``` python
%%writefile .makim.yaml
version: 1.0.0
groups:
@@ -101,200 +119,138 @@ groups:
echo "Runnint unit tests..."
```
-- OUTPUT - -
-
-
-(1, 4, 9, 16, 25, 36, 49, 64, 81)
-
-
-
-
-
+This setup demonstrates Makim’s ability to manage tasks with conditional
+logic and dependencies.
-This setup demonstrates Makim's ability to manage tasks with conditional logic and dependencies.
+### Exploring Makim’s CLI
-### Exploring Makim's CLI
+Makim’s CLI provides insights into available commands, arguments, and
+configurations through the auto-generated help menu:
-Makim's CLI provides insights into available commands, arguments, and configurations through the auto-generated help menu:
-
-
-```python
+``` python
!makim --help
```
-- OUTPUT - -
-
-
-Overwriting .makim.yaml
+ Overwriting .makim.yaml
-
-
-
-
-
-This feature facilitates easy access to Makim's functionalities, enhancing usability and understanding of the tool.
+
+ Usage: makim [OPTIONS] COMMAND [ARGS]...
+
+ Makim is a tool that helps you to organize and simplify your helper commands.
+
+ ╭─ Options ────────────────────────────────────────────────────────────────────╮
+ │ --version -v Show the version and exit │
+ │ --file TEXT Makim config file [default: .makim.yaml] │
+ │ --dry-run Execute the command in dry mode │
+ │ --verbose Execute the command in verbose mode │
+ │ --install-completion Install completion for the current │
+ │ shell. │
+ │ --show-completion Show completion for the current shell, │
+ │ to copy it or customize the │
+ │ installation. │
+ │ --help Show this message and exit. │
+ ╰──────────────────────────────────────────────────────────────────────────────╯
+ ╭─ Commands ───────────────────────────────────────────────────────────────────╮
+ │ clean.tmp Use this target to clean up temporary files │
+ │ tests.unit Build the program │
+ ╰──────────────────────────────────────────────────────────────────────────────╯
+
+ If you have any problem, open an issue at:
+ https://github.com/osl-incubator/makim
+
+
+This feature facilitates easy access to Makim’s functionalities,
+enhancing usability and understanding of the tool.
### Executing Your First Commands
With your `.makim.yaml` file set up, you can begin to use `makim`:
-
-```python
+``` python
!makim clean.tmp
```
-- OUTPUT - -
-
-
-
- Usage: makim [OPTIONS] COMMAND [ARGS]...
-
-Makim is a tool that helps you to organize and simplify your helper commands.
-
-╭─ Options ────────────────────────────────────────────────────────────────────╮
-│ --version -v Show the version and exit │
-│ --file TEXT Makim config file [default: .makim.yaml] │
-│ --dry-run Execute the command in dry mode │
-│ --verbose Execute the command in verbose mode │
-│ --install-completion Install completion for the current │
-│ shell. │
-│ --show-completion Show completion for the current shell, │
-│ to copy it or customize the │
-│ installation. │
-│ --help Show this message and exit. │
-╰──────────────────────────────────────────────────────────────────────────────╯
-╭─ Commands ───────────────────────────────────────────────────────────────────╮
-│ clean.tmp Use this target to clean up temporary files │
-│ tests.unit Build the program │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-If you have any problem, open an issue at:
-https://github.com/osl-incubator/makim
-
-
-
-
-
-
-
-
-
-```python
+``` python
!makim tests.unit
```
-- OUTPUT - -
-
-
-Makim file: .makim.yaml
-Cleaning up...
+ Makim file: .makim.yaml
+ Cleaning up...
-
-
-
-
+ Makim file: .makim.yaml
+ Runnint unit tests...
-In the case you type your command wrong, **Makim** will suggest you some alternative:
+In the case you type your command wrong, **Makim** will suggest you some
+alternative:
-
-```python
+``` python
!makim tests.unittest
```
-- OUTPUT - -
-
-
-Makim file: .makim.yaml
-Runnint unit tests...
-
-
-
-
-
-
-**Makim** CLI is empowered by **Typer**, and it allows us to have auto-completion for Makim groups and targets! If you want to install, you can run the following command:
+ Usage: makim [OPTIONS] COMMAND [ARGS]...
+ Try 'makim --help' for help.
+ ╭─ Error ──────────────────────────────────────────────────────────────────────╮
+ │ No such command 'tests.unittest'. │
+ ╰──────────────────────────────────────────────────────────────────────────────╯
+ Command tests.unittest not found. Did you mean tests.unit'?
+**Makim** CLI is empowered by **Typer**, and it allows us to have
+auto-completion for Makim groups and targets! If you want to install,
+you can run the following command:
-```python
+``` python
!makim --install-completion
```
-- OUTPUT - -
-
-
-Usage: makim [OPTIONS] COMMAND [ARGS]...
-Try 'makim --help' for help.
-╭─ Error ──────────────────────────────────────────────────────────────────────╮
-│ No such command 'tests.unittest'. │
-╰──────────────────────────────────────────────────────────────────────────────╯
-Command tests.unittest not found. Did you mean tests.unit'?
-
-
-
-
-
-
-After this command you will need to restart the terminal in order to use this auto-completion feature.
+After this command you will need to restart the terminal in order to use
+this auto-completion feature.
## Advanced Features and Examples
-Makim's adaptability is showcased through various features and practical examples:
+Makim’s adaptability is showcased through various features and practical
+examples:
-- **Conditional Dependencies and Arguments**: Define complex task dependencies with conditional execution based on passed arguments.
-- **Dynamic Configuration with Jinja2**: Leverage Jinja2 templates for advanced scripting and dynamic content generation.
-- **Environment and Custom Variable Management**: Organize and utilize variables effectively across different scopes of your project.
-- **Specifying Working Directories**: Control the execution context of your tasks by setting working directories.
+- **Conditional Dependencies and Arguments**: Define complex task
+ dependencies with conditional execution based on passed arguments.
+- **Dynamic Configuration with Jinja2**: Leverage Jinja2 templates for
+ advanced scripting and dynamic content generation.
+- **Environment and Custom Variable Management**: Organize and utilize
+ variables effectively across different scopes of your project.
+- **Specifying Working Directories**: Control the execution context of
+ your tasks by setting working directories.
-These examples underscore Makim's capability to accommodate intricate automation scenarios, streamlining development workflows.
+These examples underscore Makim’s capability to accommodate intricate
+automation scenarios, streamlining development workflows.
## Exploring Makim Through Examples
### Utilizing Various Interpreters
-Makim extends its functionality beyond conventional script execution by supporting various interpreters and shell languages, facilitating a versatile development environment. While **xonsh** is the default interpreter - blending the capabilities of Bash and Python for an enriched command-line experience - Makim's architecture allows for seamless integration with other environments. For developers seeking to leverage this feature, a foundational understanding of **xonsh** can be beneficial. Comprehensive details and usage guidelines are available in the [official xonsh documentation](https://xon.sh/).
-
-This section demonstrates executing straightforward commands across multiple interpreters, showcasing Makim's adaptability to diverse programming contexts.
-
-
-```python
+Makim extends its functionality beyond conventional script execution by
+supporting various interpreters and shell languages, facilitating a
+versatile development environment. While **xonsh** is the default
+interpreter - blending the capabilities of Bash and Python for an
+enriched command-line experience - Makim’s architecture allows for
+seamless integration with other environments. For developers seeking to
+leverage this feature, a foundational understanding of **xonsh** can be
+beneficial. Comprehensive details and usage guidelines are available in
+the [official xonsh documentation](https://xon.sh/).
+
+This section demonstrates executing straightforward commands across
+multiple interpreters, showcasing Makim’s adaptability to diverse
+programming contexts.
+
+``` python
%%writefile .env
MSG_PREFIX="Running Makim: Hello, World,"
```
-- OUTPUT - -
-
-
-bash completion installed in /home/xmn/.bash_completions/makim.sh
-Completion will take effect once you restart the terminal
+ bash completion installed in /home/xmn/.bash_completions/makim.sh
+ Completion will take effect once you restart the terminal
-
-
-
-
-
+ Overwriting .env
-```python
+``` python
%%writefile .makim.yaml
version: 1.0
env-file: .env
@@ -335,110 +291,83 @@ groups:
- target: sh
```
-- OUTPUT - -
-
-
-Overwriting .env
-
-
-
-
-
-
-
-```python
+``` python
!makim --help
```
-- OUTPUT - -
-
-
-Overwriting .makim.yaml
+ Overwriting .makim.yaml
-
-
-
-
-
-Prior to executing these targets, it is necessary to install the required dependencies:
-
-
-```python
+
+ Usage: makim [OPTIONS] COMMAND [ARGS]...
+
+ Makim is a tool that helps you to organize and simplify your helper commands.
+
+ ╭─ Options ────────────────────────────────────────────────────────────────────╮
+ │ --version -v Show the version and exit │
+ │ --file TEXT Makim config file [default: .makim.yaml] │
+ │ --dry-run Execute the command in dry mode │
+ │ --verbose Execute the command in verbose mode │
+ │ --install-completion Install completion for the current │
+ │ shell. │
+ │ --show-completion Show completion for the current shell, │
+ │ to copy it or customize the │
+ │ installation. │
+ │ --help Show this message and exit. │
+ ╰──────────────────────────────────────────────────────────────────────────────╯
+ ╭─ Commands ───────────────────────────────────────────────────────────────────╮
+ │ tests.node Test using nodejs │
+ │ tests.perl Test using perl │
+ │ tests.python Test using php │
+ │ tests.r Test using R │
+ │ tests.run-all Run tests for all the other targets │
+ │ tests.sh Test using sh │
+ ╰──────────────────────────────────────────────────────────────────────────────╯
+
+ If you have any problem, open an issue at:
+ https://github.com/osl-incubator/makim
+
+
+Prior to executing these targets, it is necessary to install the
+required dependencies:
+
+``` python
!mamba install -q -y perl nodejs r-base sh
```
-Proceed to execute all defined targets by invoking the run-all target, which encapsulates all other targets as its dependencies for a sequential execution process:
-
+Proceed to execute all defined targets by invoking the run-all target,
+which encapsulates all other targets as its dependencies for a
+sequential execution process:
-```python
+``` python
!makim tests.run-all
```
-- OUTPUT - -
-
-
-
- Usage: makim [OPTIONS] COMMAND [ARGS]...
-
-Makim is a tool that helps you to organize and simplify your helper commands.
-
-╭─ Options ────────────────────────────────────────────────────────────────────╮
-│ --version -v Show the version and exit │
-│ --file TEXT Makim config file [default: .makim.yaml] │
-│ --dry-run Execute the command in dry mode │
-│ --verbose Execute the command in verbose mode │
-│ --install-completion Install completion for the current │
-│ shell. │
-│ --show-completion Show completion for the current shell, │
-│ to copy it or customize the │
-│ installation. │
-│ --help Show this message and exit. │
-╰──────────────────────────────────────────────────────────────────────────────╯
-╭─ Commands ───────────────────────────────────────────────────────────────────╮
-│ tests.node Test using nodejs │
-│ tests.perl Test using perl │
-│ tests.python Test using php │
-│ tests.r Test using R │
-│ tests.run-all Run tests for all the other targets │
-│ tests.sh Test using sh │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-If you have any problem, open an issue at:
-https://github.com/osl-incubator/makim
-
-
-
-
-
-
-
-
-In scenarios where your chosen interpreter supports debugging - such as Python or Xonsh through the use of `breakpoint()` - you can introduce a breakpoint within your code. This enables the debugging of your **Makim** target, allowing for an interactive examination of the execution flow and variable states.
+ Makim file: .makim.yaml
+ Running Makim: Hello, World, from NodeJS!
+ (node:1634785) Warning: The 'NO_COLOR' env is ignored due to the 'FORCE_COLOR' env being set.
+ (Use `node --trace-warnings ...` to show where the warning was created)
+ Running Makim: Hello, World, from Perl!
+ Running Makim: Hello, World, from Python!
+ [1] "Running Makim: Hello, World, from R!"
+ Running Makim: Hello, World, from sh!
+
+In scenarios where your chosen interpreter supports debugging - such as
+Python or Xonsh through the use of `breakpoint()` - you can introduce a
+breakpoint within your code. This enables the debugging of your
+**Makim** target, allowing for an interactive examination of the
+execution flow and variable states.
### Using Variables (vars)
-**Makim** facilitates the definition of variables within the `.makim.yaml` configuration, supporting all the **YAML** data types, including strings, lists, and dictionaries. This feature enhances script configurability and reusability across different tasks and environments.
+**Makim** facilitates the definition of variables within the
+`.makim.yaml` configuration, supporting all the **YAML** data types,
+including strings, lists, and dictionaries. This feature enhances script
+configurability and reusability across different tasks and environments.
-Consider reviewing the provided example to understand how to effectively leverage variables in your **Makim** configurations:
+Consider reviewing the provided example to understand how to effectively
+leverage variables in your **Makim** configurations:
-
-```python
+``` python
%%writefile .makim.yaml
version: 1.0
@@ -498,84 +427,51 @@ groups:
install(package, version)
```
-- OUTPUT - -
-
-
-Makim file: .makim.yaml
-Running Makim: Hello, World, from NodeJS!
-(node:1634785) Warning: The 'NO_COLOR' env is ignored due to the 'FORCE_COLOR' env being set.
-(Use `node --trace-warnings ...` to show where the warning was created)
-Running Makim: Hello, World, from Perl!
-Running Makim: Hello, World, from Python!
-[1] "Running Makim: Hello, World, from R!"
-Running Makim: Hello, World, from sh!
-
-
-
-
-
+ Overwriting .makim.yaml
-Now, let's proceed to create users within the staging environment:
+Now, let’s proceed to create users within the staging environment:
-
-```python
+``` python
!makim staging.create-users
```
-- OUTPUT - -
-
-
-Overwriting .makim.yaml
-
-
-
-
-
+ Makim file: .makim.yaml
+ create admin users:
+ >>> creating user: admin1 ... DONE!
+ >>> creating user: admin2 ... DONE!
+ >>> creating user: admin3 ... DONE!
-Last but not least, let's run the install target:
+ create staging users:
+ >>> creating user: staging1 ... DONE!
+ >>> creating user: staging2 ... DONE!
+ >>> creating user: staging3 ... DONE!
+Last but not least, let’s run the install target:
-```python
+``` python
!makim staging.install
```
-- OUTPUT - -
-
-
-Makim file: .makim.yaml
-create admin users:
->>> creating user: admin1 ... DONE!
->>> creating user: admin2 ... DONE!
->>> creating user: admin3 ... DONE!
-
-create staging users:
->>> creating user: staging1 ... DONE!
->>> creating user: staging2 ... DONE!
->>> creating user: staging3 ... DONE!
-
-
-
-
-
+ Makim file: .makim.yaml
+ install global dependencies:
+ >>> installing: dep1@v1 ... DONE!
+ >>> installing: dep2@v1.1 ... DONE!
+ >>> installing: dep3@v2.3 ... DONE!
+
+ install staging dependencies:
+ >>> installing: dep4@v4.3 ... DONE!
+ >>> installing: dep5@v1.1.1 ... DONE!
### Defining Arguments
-**Makim** enhances script flexibility by allowing the use of arguments. It enables not only the definition of arguments for tasks but also the passing of arguments to dependencies and the specification of conditions for those dependencies.
+**Makim** enhances script flexibility by allowing the use of arguments.
+It enables not only the definition of arguments for tasks but also the
+passing of arguments to dependencies and the specification of conditions
+for those dependencies.
Explore this functionality through this example:
-
-```python
+``` python
%%writefile .makim.yaml
version: 1.0.0
groups:
@@ -613,88 +509,43 @@ groups:
name: Marc
```
-- OUTPUT - -
-
-
-Makim file: .makim.yaml
-install global dependencies:
->>> installing: dep1@v1 ... DONE!
->>> installing: dep2@v1.1 ... DONE!
->>> installing: dep3@v2.3 ... DONE!
-
-install staging dependencies:
->>> installing: dep4@v4.3 ... DONE!
->>> installing: dep5@v1.1.1 ... DONE!
-
-
-
-
-
+ Overwriting .makim.yaml
-
-```python
+``` python
!makim print.list
```
-- OUTPUT - -
-
-
-Overwriting .makim.yaml
-
-
-
-
-
-
+ Makim file: .makim.yaml
-```python
+``` python
!makim print.list --i-am-sure
```
-- OUTPUT - -
-
-
-Makim file: .makim.yaml
-
-
-
-
-
+ Makim file: .makim.yaml
+ Mary
+ John
+ Ellen
+ Marc
### Utilizing Environment Variables
-The previous sections demonstrated the use of environment variables. Here, we'll delve into their application in more detail.
+The previous sections demonstrated the use of environment variables.
+Here, we’ll delve into their application in more detail.
-**Makim** permits the incorporation of environment variables from `.env` files or directly within the `.makim.yaml` file, applicable at global, group, and target levels.
+**Makim** permits the incorporation of environment variables from `.env`
+files or directly within the `.makim.yaml` file, applicable at global,
+group, and target levels.
Examine an example to understand the implementation:
-
-```python
+``` python
%%writefile .env
ENV=dev
```
-- OUTPUT - -
-
-
-Makim file: .makim.yaml
-Mary
-John
-Ellen
-Marc
-
-
-
-
-
+ Overwriting .env
-
-```python
+``` python
%%writefile .makim.yaml
version: 1.0
env-file: .env
@@ -725,63 +576,28 @@ groups:
assert "${{ env.get("UNKNOWN_TARGET_VAR", "4") }}" == "4"
```
-- OUTPUT - -
-
-
-Overwriting .env
-
-
-
-
-
-
+ Overwriting .makim.yaml
-```python
+``` python
!makim global-scope.test-var-env-file
```
-- OUTPUT - -
-
-
-Overwriting .makim.yaml
-
-
-
-
-
-
-
-```python
+``` python
!makim global-scope.test-var-env
```
-- OUTPUT - -
-
-
-Makim file: .makim.yaml
+ Makim file: .makim.yaml
-
-
-
-
+ Makim file: .makim.yaml
### Specifying the Working Directory
-Makim provides the capability to set a specific working directory for tasks at any scope: global, group, or target.
+Makim provides the capability to set a specific working directory for
+tasks at any scope: global, group, or target.
Review a straightforward example to learn how to apply this feature:
-
-```python
+``` python
%%writefile .makim.yaml
version: 1.0
working-directory: "/tmp"
@@ -797,46 +613,36 @@ groups:
assert os.getcwd() == "/tmp"
```
-- OUTPUT - -
-
-
-Makim file: .makim.yaml
-
-
-
-
-
-
+ Overwriting .makim.yaml
-```python
+``` python
!makim check-wd.is-tmp
```
-- OUTPUT - -
-
-
-Overwriting .makim.yaml
-
-
-
-
-
-
-This tutorial concludes with a showcase of Makim's key features. While this overview covers the essentials, diving deeper into **Makim** will reveal more advanced and intriguing ways to leverage its capabilities.
+This tutorial concludes with a showcase of Makim’s key features. While
+this overview covers the essentials, diving deeper into **Makim** will
+reveal more advanced and intriguing ways to leverage its capabilities.
## Contributing to Makim
-Makim's growth is propelled by its community. Contributions, whether through code, documentation, or feedback, are welcome. Explore the [GitHub repository](https://github.com/osl-incubator/makim) and consider contributing to foster Makim's development.
+Makim’s growth is propelled by its community. Contributions, whether
+through code, documentation, or feedback, are welcome. Explore the
+[GitHub repository](https://github.com/osl-incubator/makim) and consider
+contributing to foster Makim’s development.
## Conclusion
-Makim stands out as a transformative tool in project automation, bridging the gap between simplicity and complexity. Its comprehensive feature set, coupled with the flexibility of its configuration, makes Makim a quintessential tool for developers and DevOps engineers alike. As you incorporate Makim into your projects, its impact on enhancing productivity and consistency will become evident, marking it as an indispensable part of your development toolkit.
-
-Dive deeper into Makim's functionalities by visiting the [official documentation](https://github.com/osl-incubator/makim). Try it and let us know your thoughts about it!
+Makim stands out as a transformative tool in project automation,
+bridging the gap between simplicity and complexity. Its comprehensive
+feature set, coupled with the flexibility of its configuration, makes
+Makim a quintessential tool for developers and DevOps engineers alike.
+As you incorporate Makim into your projects, its impact on enhancing
+productivity and consistency will become evident, marking it as an
+indispensable part of your development toolkit.
+
+Dive deeper into Makim’s functionalities by visiting the [official
+documentation](https://github.com/osl-incubator/makim). Try it and let
+us know your thoughts about it!
\ No newline at end of file
diff --git a/pages/blog/streamlining-project-automation-with-makim/index.qmd b/pages/blog/streamlining-project-automation-with-makim/index.qmd
new file mode 100644
index 000000000..ffd764c8f
--- /dev/null
+++ b/pages/blog/streamlining-project-automation-with-makim/index.qmd
@@ -0,0 +1,625 @@
+---
+title: "Streamlining Project Automation with Makim"
+slug: "streamlining-project-automation-with-makim"
+date: 2024-03-18
+authors: ["Ivan Ogasawara"]
+tags: ["makim", "automation", "devops", "open-source"]
+categories: ["devops", "automation", "python"]
+description: |
+ In software development, where efficiency, consistency, and reliability are paramount,
+ automation tools play a crucial role. Makim, an innovative open-source tool, steps
+ into the spotlight to improve automation workflows. It simplifies script execution,
+ environment management, and task dependencies, positioning itself as a great asset in
+ modern development environments.
+ environment.
+thumbnail: "/header.png"
+template: "blog-post.html"
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+# Streamlining Project Automation with Makim
+
+In software development, where efficiency, consistency, and reliability are paramount, automation tools play a crucial role. Makim, an innovative open-source tool, steps into the spotlight to improve automation workflows. It simplifies script execution, environment management, and task dependencies, positioning itself as a great asset in modern development environments.
+
+## Introducing Makim
+
+`Makim` elevates project automation by offering a structured, yet flexible approach to manage routine tasks, complex task dependencies, and environment configurations. Its design is centered around the `.makim.yaml` configuration file, allowing developers to orchestrate their workflows with precision and ease. Unlike traditional script execution tools, Makim's Python-based architecture and support for multiple programming languages and shells enhance its versatility and applicability across diverse projects.
+
+Especially suited for DevOps Engineers and Software Developers, Makim eliminates redundancy in automation tasks. Its core functionality extends beyond simple script execution, encompassing:
+
+- Argument definition for scripts
+- Organization of tasks into groups
+- Advanced dependency management between tasks
+- Utilization of environment variables and custom variables
+- Dynamic content generation with Jinja2 templates
+- Specification of working directories for tasks
+- Execution flexibility through support for multiple interpreters or shells
+
+Despite its broad capabilities, Makim currently lacks support for Windows but plans to extend its compatibility in future versions.
+
+## Getting Started with Makim
+
+### Installation
+
+Makim can be installed via `pip` or `conda`, catering to different setup preferences:
+
+- To install `Makim` using `pip`, run:
+
+
+```python
+!pip install -q "makim==1.14.0"
+```
+
+- For those who prefer `conda`, execute:
+
+ ```
+ conda install "makim=1.14.0"
+ ```
+
+Given Makim's active development, pinning to a specific version is recommended to ensure consistency.
+
+For this tutorial, we will disable the output color feature provided by typer, the command-line interface engine used by **Makim**.
+
+
+```python
+import os
+
+os.environ["NO_COLOR"] = "1"
+```
+
+### Configuring `.makim.yaml`
+
+The `.makim.yaml` file is the foundation of your Makim configuration. Here's how to start:
+
+1. **Create the `.makim.yaml` File**: Place this file at the root of your project directory.
+
+2. **Define Your Automation Tasks**: Configure your tasks, specifying actions, arguments, and dependencies. For example:
+
+
+```python
+%%writefile .makim.yaml
+version: 1.0.0
+groups:
+ clean:
+ env-file: .env
+ targets:
+ tmp:
+ help: Use this target to clean up temporary files
+ run: |
+ echo "Cleaning up..."
+ tests:
+ targets:
+ unit:
+ help: Build the program
+ args:
+ clean:
+ type: bool
+ action: store_true
+ help: if not set, the clean dependency will not be triggered.
+ dependencies:
+ - target: clean.tmp
+ if: ${{ args.clean == true }}
+ run: |
+ echo "Runnint unit tests..."
+```
+
+ Overwriting .makim.yaml
+
+
+This setup demonstrates Makim's ability to manage tasks with conditional logic and dependencies.
+
+### Exploring Makim's CLI
+
+Makim's CLI provides insights into available commands, arguments, and configurations through the auto-generated help menu:
+
+
+```python
+!makim --help
+```
+
+ [1m [0m
+ [1m [0m[1mUsage: [0m[1mmakim [OPTIONS] COMMAND [ARGS]...[0m[1m [0m[1m [0m
+ [1m [0m
+ Makim is a tool that helps you to organize and simplify your helper commands.
+
+ [2m╭─[0m[2m Options [0m[2m───────────────────────────────────────────────────────────────────[0m[2m─╮[0m
+ [2m│[0m [1m-[0m[1m-version[0m [1m-v[0m [1m [0m Show the version and exit [2m│[0m
+ [2m│[0m [1m-[0m[1m-file[0m [1mTEXT[0m Makim config file [2m[default: .makim.yaml][0m [2m│[0m
+ [2m│[0m [1m-[0m[1m-dry[0m[1m-run[0m [1m [0m Execute the command in dry mode [2m│[0m
+ [2m│[0m [1m-[0m[1m-verbose[0m [1m [0m Execute the command in verbose mode [2m│[0m
+ [2m│[0m [1m-[0m[1m-install[0m[1m-completion[0m [1m [0m Install completion for the current [2m│[0m
+ [2m│[0m shell. [2m│[0m
+ [2m│[0m [1m-[0m[1m-show[0m[1m-completion[0m [1m [0m Show completion for the current shell, [2m│[0m
+ [2m│[0m to copy it or customize the [2m│[0m
+ [2m│[0m installation. [2m│[0m
+ [2m│[0m [1m-[0m[1m-help[0m [1m [0m Show this message and exit. [2m│[0m
+ [2m╰──────────────────────────────────────────────────────────────────────────────╯[0m
+ [2m╭─[0m[2m Commands [0m[2m──────────────────────────────────────────────────────────────────[0m[2m─╮[0m
+ [2m│[0m [1mclean.tmp [0m[1m [0m Use this target to clean up temporary files [2m│[0m
+ [2m│[0m [1mtests.unit [0m[1m [0m Build the program [2m│[0m
+ [2m╰──────────────────────────────────────────────────────────────────────────────╯[0m
+
+ If you have any problem, open an issue at:
+ https://github.com/osl-incubator/makim
+
+
+
+
+This feature facilitates easy access to Makim's functionalities, enhancing usability and understanding of the tool.
+
+### Executing Your First Commands
+
+With your `.makim.yaml` file set up, you can begin to use `makim`:
+
+
+```python
+!makim clean.tmp
+```
+
+ Makim file: .makim.yaml
+ Cleaning up...
+
+
+
+```python
+!makim tests.unit
+```
+
+ Makim file: .makim.yaml
+ Runnint unit tests...
+
+
+In the case you type your command wrong, **Makim** will suggest you some alternative:
+
+
+```python
+!makim tests.unittest
+```
+
+ Usage: makim [OPTIONS] COMMAND [ARGS]...
+ [2mTry [0m[2m'makim [0m[1;2m-[0m[1;2m-help[0m[2m'[0m[2m for help.[0m
+ ╭─ Error ──────────────────────────────────────────────────────────────────────╮
+ │ No such command 'tests.unittest'. │
+ ╰──────────────────────────────────────────────────────────────────────────────╯
+ [31mCommand tests.unittest not found. Did you mean tests.unit'?[0m
+
+
+**Makim** CLI is empowered by **Typer**, and it allows us to have auto-completion for Makim groups and targets! If you want to install, you can run the following command:
+
+
+```python
+!makim --install-completion
+```
+
+ [32mbash completion installed in /home/xmn/.bash_completions/makim.sh[0m
+ Completion will take effect once you restart the terminal
+
+
+After this command you will need to restart the terminal in order to use this auto-completion feature.
+
+## Advanced Features and Examples
+
+Makim's adaptability is showcased through various features and practical examples:
+
+- **Conditional Dependencies and Arguments**: Define complex task dependencies with conditional execution based on passed arguments.
+- **Dynamic Configuration with Jinja2**: Leverage Jinja2 templates for advanced scripting and dynamic content generation.
+- **Environment and Custom Variable Management**: Organize and utilize variables effectively across different scopes of your project.
+- **Specifying Working Directories**: Control the execution context of your tasks by setting working directories.
+
+These examples underscore Makim's capability to accommodate intricate automation scenarios, streamlining development workflows.
+
+## Exploring Makim Through Examples
+
+### Utilizing Various Interpreters
+
+Makim extends its functionality beyond conventional script execution by supporting various interpreters and shell languages, facilitating a versatile development environment. While **xonsh** is the default interpreter - blending the capabilities of Bash and Python for an enriched command-line experience - Makim's architecture allows for seamless integration with other environments. For developers seeking to leverage this feature, a foundational understanding of **xonsh** can be beneficial. Comprehensive details and usage guidelines are available in the [official xonsh documentation](https://xon.sh/).
+
+This section demonstrates executing straightforward commands across multiple interpreters, showcasing Makim's adaptability to diverse programming contexts.
+
+
+```python
+%%writefile .env
+MSG_PREFIX="Running Makim: Hello, World,"
+```
+
+ Overwriting .env
+
+
+
+```python
+%%writefile .makim.yaml
+version: 1.0
+env-file: .env
+groups:
+ tests:
+ targets:
+ node:
+ help: Test using nodejs
+ shell: node
+ run: console.log("${{ env.MSG_PREFIX }} from NodeJS!");
+ perl:
+ help: Test using perl
+ shell: perl
+ run: print "${{ env.MSG_PREFIX }} from Perl!\n";
+
+ python:
+ help: Test using php
+ shell: python
+ run: print("${{ env.MSG_PREFIX }} from Python!")
+
+ r:
+ help: Test using R
+ shell: Rscript
+ run: print("${{ env.MSG_PREFIX }} from R!")
+
+ sh:
+ help: Test using sh
+ shell: sh
+ run: echo "${{ env.MSG_PREFIX }} from sh!"
+
+ run-all:
+ help: Run tests for all the other targets
+ dependencies:
+ - target: node
+ - target: perl
+ - target: python
+ - target: r
+ - target: sh
+```
+
+ Overwriting .makim.yaml
+
+
+
+```python
+!makim --help
+```
+
+ [1m [0m
+ [1m [0m[1mUsage: [0m[1mmakim [OPTIONS] COMMAND [ARGS]...[0m[1m [0m[1m [0m
+ [1m [0m
+ Makim is a tool that helps you to organize and simplify your helper commands.
+
+ [2m╭─[0m[2m Options [0m[2m───────────────────────────────────────────────────────────────────[0m[2m─╮[0m
+ [2m│[0m [1m-[0m[1m-version[0m [1m-v[0m [1m [0m Show the version and exit [2m│[0m
+ [2m│[0m [1m-[0m[1m-file[0m [1mTEXT[0m Makim config file [2m[default: .makim.yaml][0m [2m│[0m
+ [2m│[0m [1m-[0m[1m-dry[0m[1m-run[0m [1m [0m Execute the command in dry mode [2m│[0m
+ [2m│[0m [1m-[0m[1m-verbose[0m [1m [0m Execute the command in verbose mode [2m│[0m
+ [2m│[0m [1m-[0m[1m-install[0m[1m-completion[0m [1m [0m Install completion for the current [2m│[0m
+ [2m│[0m shell. [2m│[0m
+ [2m│[0m [1m-[0m[1m-show[0m[1m-completion[0m [1m [0m Show completion for the current shell, [2m│[0m
+ [2m│[0m to copy it or customize the [2m│[0m
+ [2m│[0m installation. [2m│[0m
+ [2m│[0m [1m-[0m[1m-help[0m [1m [0m Show this message and exit. [2m│[0m
+ [2m╰──────────────────────────────────────────────────────────────────────────────╯[0m
+ [2m╭─[0m[2m Commands [0m[2m──────────────────────────────────────────────────────────────────[0m[2m─╮[0m
+ [2m│[0m [1mtests.node [0m[1m [0m Test using nodejs [2m│[0m
+ [2m│[0m [1mtests.perl [0m[1m [0m Test using perl [2m│[0m
+ [2m│[0m [1mtests.python [0m[1m [0m Test using php [2m│[0m
+ [2m│[0m [1mtests.r [0m[1m [0m Test using R [2m│[0m
+ [2m│[0m [1mtests.run-all [0m[1m [0m Run tests for all the other targets [2m│[0m
+ [2m│[0m [1mtests.sh [0m[1m [0m Test using sh [2m│[0m
+ [2m╰──────────────────────────────────────────────────────────────────────────────╯[0m
+
+ If you have any problem, open an issue at:
+ https://github.com/osl-incubator/makim
+
+
+
+
+Prior to executing these targets, it is necessary to install the required dependencies:
+
+
+```python
+!mamba install -q -y perl nodejs r-base sh
+```
+
+Proceed to execute all defined targets by invoking the run-all target, which encapsulates all other targets as its dependencies for a sequential execution process:
+
+
+```python
+!makim tests.run-all
+```
+
+ Makim file: .makim.yaml
+ Running Makim: Hello, World, from NodeJS!
+ (node:1634785) Warning: The 'NO_COLOR' env is ignored due to the 'FORCE_COLOR' env being set.
+ (Use `node --trace-warnings ...` to show where the warning was created)
+ Running Makim: Hello, World, from Perl!
+ Running Makim: Hello, World, from Python!
+ [1] "Running Makim: Hello, World, from R!"
+ Running Makim: Hello, World, from sh!
+
+
+In scenarios where your chosen interpreter supports debugging - such as Python or Xonsh through the use of `breakpoint()` - you can introduce a breakpoint within your code. This enables the debugging of your **Makim** target, allowing for an interactive examination of the execution flow and variable states.
+
+### Using Variables (vars)
+
+**Makim** facilitates the definition of variables within the `.makim.yaml` configuration, supporting all the **YAML** data types, including strings, lists, and dictionaries. This feature enhances script configurability and reusability across different tasks and environments.
+
+Consider reviewing the provided example to understand how to effectively leverage variables in your **Makim** configurations:
+
+
+```python
+%%writefile .makim.yaml
+version: 1.0
+
+vars:
+ project-name: "my-project"
+ dependencies:
+ "dep1": "v1"
+ "dep2": "v1.1"
+ "dep3": "v2.3"
+ authorized-users:
+ - admin1
+ - admin2
+ - admin3
+
+groups:
+ staging:
+ vars:
+ env-name: "staging"
+ staging-dependencies:
+ "dep4": "v4.3"
+ "dep5": "v1.1.1"
+ staging-authorized-users:
+ - staging1
+ - staging2
+ - staging3
+ targets:
+ create-users:
+ help: Create users for staging, this example uses jinja2 for loop.
+ # each target can also specify their `vars`, but it will not be used in this example
+ run: |
+ def create_user(username):
+ print(f">>> creating user: {username} ... DONE!")
+
+ print("create admin users:")
+ {% for user in vars.authorized_users %}
+ create_user("${{ user }}")
+ {% endfor %}
+
+ print("\ncreate staging users:")
+ {% for user in vars.staging_authorized_users %}
+ create_user("${{ user }}")
+ {% endfor %}
+
+ install:
+ help: install deps for staging using native xonsh `for` loop (it could work with Python as well)
+ # each target can also specify their `vars`, but it will not be used in this example
+ run: |
+ def install(package, version):
+ print(f">>> installing: {package}@{version} ... DONE!")
+
+ print("install global dependencies:")
+ for package, version in ${{ vars.dependencies | safe }}.items():
+ install(package, version)
+
+ print("\ninstall staging dependencies:")
+ for package, version in ${{ vars.staging_dependencies | safe }}.items():
+ install(package, version)
+```
+
+ Overwriting .makim.yaml
+
+
+Now, let's proceed to create users within the staging environment:
+
+
+```python
+!makim staging.create-users
+```
+
+ Makim file: .makim.yaml
+ create admin users:
+ >>> creating user: admin1 ... DONE!
+ >>> creating user: admin2 ... DONE!
+ >>> creating user: admin3 ... DONE!
+
+ create staging users:
+ >>> creating user: staging1 ... DONE!
+ >>> creating user: staging2 ... DONE!
+ >>> creating user: staging3 ... DONE!
+
+
+Last but not least, let's run the install target:
+
+
+```python
+!makim staging.install
+```
+
+ Makim file: .makim.yaml
+ install global dependencies:
+ >>> installing: dep1@v1 ... DONE!
+ >>> installing: dep2@v1.1 ... DONE!
+ >>> installing: dep3@v2.3 ... DONE!
+
+ install staging dependencies:
+ >>> installing: dep4@v4.3 ... DONE!
+ >>> installing: dep5@v1.1.1 ... DONE!
+
+
+### Defining Arguments
+
+**Makim** enhances script flexibility by allowing the use of arguments. It enables not only the definition of arguments for tasks but also the passing of arguments to dependencies and the specification of conditions for those dependencies.
+
+Explore this functionality through this example:
+
+
+```python
+%%writefile .makim.yaml
+version: 1.0.0
+groups:
+ print:
+ env-file: .env
+ targets:
+ name:
+ help: Print given name
+ args:
+ name:
+ type: str
+ required: true
+ run: print("${{ args.name }}")
+ list:
+ help: Build the program
+ args:
+ i-am-sure:
+ type: bool
+ dependencies:
+ - target: print.name
+ if: ${{ args.i_am_sure == true }}
+ args:
+ name: Mary
+ - target: print.name
+ if: ${{ args.i_am_sure == true }}
+ args:
+ name: John
+ - target: print.name
+ if: ${{ args.i_am_sure == true }}
+ args:
+ name: Ellen
+ - target: print.name
+ if: ${{ args.i_am_sure == true }}
+ args:
+ name: Marc
+```
+
+ Overwriting .makim.yaml
+
+
+
+```python
+!makim print.list
+```
+
+ Makim file: .makim.yaml
+
+
+
+```python
+!makim print.list --i-am-sure
+```
+
+ Makim file: .makim.yaml
+ Mary
+ John
+ Ellen
+ Marc
+
+
+### Utilizing Environment Variables
+
+The previous sections demonstrated the use of environment variables. Here, we'll delve into their application in more detail.
+
+**Makim** permits the incorporation of environment variables from `.env` files or directly within the `.makim.yaml` file, applicable at global, group, and target levels.
+
+Examine an example to understand the implementation:
+
+
+```python
+%%writefile .env
+ENV=dev
+```
+
+ Overwriting .env
+
+
+
+```python
+%%writefile .makim.yaml
+version: 1.0
+env-file: .env
+env:
+ GLOBAL_VAR: "1"
+groups:
+ global-scope:
+ env:
+ GROUP_VAR: "2"
+ targets:
+ test-var-env-file:
+ help: Test env variable defined in the global scope from env-file
+ run: |
+ import os
+ assert str(os.getenv("ENV")) == "dev"
+
+ test-var-env:
+ help: Test env variable defined in the global scope in `env` section
+ env:
+ TARGET_VAR: "3"
+ run: |
+ import os
+ # you can get an environment variable directly with xonsh/python
+ assert str(os.getenv("GLOBAL_VAR")) == "1"
+ # or you can get an environment variable using jinja2 tag
+ assert "${{ env.GROUP_VAR }}" == "2"
+ assert "${{ env.get("TARGET_VAR") }}" == "3"
+ assert "${{ env.get("UNKNOWN_TARGET_VAR", "4") }}" == "4"
+```
+
+ Overwriting .makim.yaml
+
+
+
+```python
+!makim global-scope.test-var-env-file
+```
+
+ Makim file: .makim.yaml
+
+
+
+```python
+!makim global-scope.test-var-env
+```
+
+ Makim file: .makim.yaml
+
+
+### Specifying the Working Directory
+
+Makim provides the capability to set a specific working directory for tasks at any scope: global, group, or target.
+
+Review a straightforward example to learn how to apply this feature:
+
+
+```python
+%%writefile .makim.yaml
+version: 1.0
+working-directory: "/tmp"
+
+groups:
+ check-wd:
+ targets:
+ is-tmp:
+ help: Test if working directory is `tmp`
+ run: |
+ import os
+ print(os.getcwd())
+ assert os.getcwd() == "/tmp"
+```
+
+ Overwriting .makim.yaml
+
+
+
+```python
+!makim check-wd.is-tmp
+```
+
+ Makim file: .makim.yaml
+ /tmp
+
+
+This tutorial concludes with a showcase of Makim's key features. While this overview covers the essentials, diving deeper into **Makim** will reveal more advanced and intriguing ways to leverage its capabilities.
+
+## Contributing to Makim
+
+Makim's growth is propelled by its community. Contributions, whether through code, documentation, or feedback, are welcome. Explore the [GitHub repository](https://github.com/osl-incubator/makim) and consider contributing to foster Makim's development.
+
+## Conclusion
+
+Makim stands out as a transformative tool in project automation, bridging the gap between simplicity and complexity. Its comprehensive feature set, coupled with the flexibility of its configuration, makes Makim a quintessential tool for developers and DevOps engineers alike. As you incorporate Makim into your projects, its impact on enhancing productivity and consistency will become evident, marking it as an indispensable part of your development toolkit.
+
+Dive deeper into Makim's functionalities by visiting the [official documentation](https://github.com/osl-incubator/makim). Try it and let us know your thoughts about it!
diff --git a/pages/blog/three-years-with-google-summer-of-code-what-ive-learned/index.md b/pages/blog/three-years-with-google-summer-of-code-what-ive-learned/index.md
index 040314330..2f9d9df73 100644
--- a/pages/blog/three-years-with-google-summer-of-code-what-ive-learned/index.md
+++ b/pages/blog/three-years-with-google-summer-of-code-what-ive-learned/index.md
@@ -15,55 +15,57 @@ thumbnail: "/header.png"
template: "blog-post.html"
---
-# Three Years with Google Summer of Code: What I've Learned
+# Three Years with Google Summer of Code: What I’ve Learned
-Mentoring is at the heart of Open Science Labs (OSL). It's why we joined Google
-Summer of Code (GSoC) in the first place. We started as a sub-organization under
-the NumFOCUS umbrella for two years, and in 2025 we were accepted as a
-**Mentoring Organization**. Huge thanks to **Anavelyz Pérez** for keeping us on
-track. We’re pleased to have secured four contributor slots for 2025 with
-**AlphaOneLabs**, **Extralit**, **Makim**, and **Sugar**.
+Mentoring is at the heart of Open Science Labs (OSL). It’s why we joined
+Google Summer of Code (GSoC) in the first place. We started as a
+sub-organization under the NumFOCUS umbrella for two years, and in 2025
+we were accepted as a **Mentoring Organization**. Huge thanks to
+**Anavelyz Pérez** for keeping us on track. We’re pleased to have
+secured four contributor slots for 2025 with **AlphaOneLabs**,
+**Extralit**, **Makim**, and **Sugar**.
-We're incredibly proud of the contributors and mentors who made GSoC 2025 a
-success. We were also, honestly, a bit heartbroken—many strong applicants did
-real work and still didn't get in. On a personal note, attending the **GSoC
-Summit** was a highlight: I met inspiring people and learned a lot from their
-experiences.
+We’re incredibly proud of the contributors and mentors who made GSoC
+2025 a success. We were also, honestly, a bit heartbroken—many strong
+applicants did real work and still didn’t get in. On a personal note,
+attending the **GSoC Summit** was a highlight: I met inspiring people
+and learned a lot from their experiences.
-Below are the lessons that stood out across these three years and practical
-recommendations for organizers, mentors, and contributors.
+Below are the lessons that stood out across these three years and
+practical recommendations for organizers, mentors, and contributors.
----
+------------------------------------------------------------------------
## The Big Lesson
-**GSoC isn't just about code—it's about mentoring.** Code is the artifact;
-mentoring is the engine. The best summers happen when we design for learning,
-clarity, and care. Everything else follows.
+**GSoC isn’t just about code—it’s about mentoring.** Code is the
+artifact; mentoring is the engine. The best summers happen when we
+design for learning, clarity, and care. Everything else follows.
----
+------------------------------------------------------------------------
## Recommendations for Organizers
-- **Confirm your slot count early.** The number of slots you _realistically_
- expect should shape how many projects you onboard and how you scope them.
+- **Confirm your slot count early.** The number of slots you
+ *realistically* expect should shape how many projects you onboard and
+ how you scope them.
-- **Balance mentors as well as projects.** When allocating slots, distribute
- contributors across both projects _and_ mentors. Avoid situations where one
- mentor has two contributors while another has none—burnout and uneven support
- help no one.
+- **Balance mentors as well as projects.** When allocating slots,
+ distribute contributors across both projects *and* mentors. Avoid
+ situations where one mentor has two contributors while another has
+ none—burnout and uneven support help no one.
----
+------------------------------------------------------------------------
## Recommendations for Mentors
-- **Limit the number of projects per mentor.** The pre-selection phase is
- intense. If you're stretched across multiple proposals, candidates won't get
- the guidance they deserve. One well-mentored project beats three
- under-mentored ones.
+- **Limit the number of projects per mentor.** The pre-selection phase
+ is intense. If you’re stretched across multiple proposals, candidates
+ won’t get the guidance they deserve. One well-mentored project beats
+ three under-mentored ones.
-- **Codify contribution rules up front.** Document expectations clearly and link
- them everywhere:
+- **Codify contribution rules up front.** Document expectations clearly
+ and link them everywhere:
- Max PR size (e.g., “prefer ≤300 lines; split larger changes”).
- Stale PR policy (e.g., “no updates for 10 days → close or draft”).
@@ -71,75 +73,76 @@ clarity, and care. Everything else follows.
- Clear stance on AI-generated code (allowed or not, and under what
conditions).
-- **Keep your CONTRIBUTING.md and PR template current.** Treat them as living
- documents. If you change the rules mid-summer, call it out in a pinned
- message.
+- **Keep your CONTRIBUTING.md and PR template current.** Treat them as
+ living documents. If you change the rules mid-summer, call it out in a
+ pinned message.
-- **Equip contributors to grow.** Share starter issues, architecture diagrams,
- walkthrough videos, and links to docs or talks. Provide “good first PR”
- examples.
+- **Equip contributors to grow.** Share starter issues, architecture
+ diagrams, walkthrough videos, and links to docs or talks. Provide
+ “good first PR” examples.
-- **Meet regularly.** Short weekly 1:1s or cohort calls work wonders. Use
- agendas. End with explicit next steps.
+- **Meet regularly.** Short weekly 1:1s or cohort calls work wonders.
+ Use agendas. End with explicit next steps.
-- **Nurture community, not competition.** Encourage contributors to help each
- other, co-review PRs, and pair on debugging. A supportive, respectful culture
- is non-negotiable.
+- **Nurture community, not competition.** Encourage contributors to help
+ each other, co-review PRs, and pair on debugging. A supportive,
+ respectful culture is non-negotiable.
-- **Have a Plan B for great applicants who aren't selected.** If you have
- bandwidth, offer an internship track, micro-grants, or
- “fellows-without-funding” with mentorship and recognition. It keeps momentum
- and grows your contributor base.
+- **Have a Plan B for great applicants who aren’t selected.** If you
+ have bandwidth, offer an internship track, micro-grants, or
+ “fellows-without-funding” with mentorship and recognition. It keeps
+ momentum and grows your contributor base.
----
+------------------------------------------------------------------------
## Recommendations for Contributors
-- **Default to public communication.** Ask questions in the project's public
- channels. It helps others learn and shows the team how you collaborate.
+- **Default to public communication.** Ask questions in the project’s
+ public channels. It helps others learn and shows the team how you
+ collaborate.
-- **If a mentor is unresponsive, switch projects.** They're likely overloaded;
- repeated pings won't help. Find a project with responsive maintainers and
- bandwidth for new contributors.
+- **If a mentor is unresponsive, switch projects.** They’re likely
+ overloaded; repeated pings won’t help. Find a project with responsive
+ maintainers and bandwidth for new contributors.
-- **Avoid giant PRs.** Huge changes are hard to review and often get stuck. Ship
- small, focused PRs that follow the project's style and tests.
+- **Avoid giant PRs.** Huge changes are hard to review and often get
+ stuck. Ship small, focused PRs that follow the project’s style and
+ tests.
-- **Show you understand the project's culture.** Read the docs. Match coding
- style. Follow the templates. Keep commits scoped and messages clear.
+- **Show you understand the project’s culture.** Read the docs. Match
+ coding style. Follow the templates. Keep commits scoped and messages
+ clear.
-- **Be careful with AI-generated code.** Don't paste blindly. Understand the
- problem, explain your choices, remove unnecessary comments, and **never**
- include emojis in code comments.
+- **Be careful with AI-generated code.** Don’t paste blindly. Understand
+ the problem, explain your choices, remove unnecessary comments, and
+ **never** include emojis in code comments.
-- **Discuss big changes before you implement them.** Don't refactor core
- components or alter architecture without buy-in. Open an issue, propose a
- design, gather feedback.
+- **Discuss big changes before you implement them.** Don’t refactor core
+ components or alter architecture without buy-in. Open an issue,
+ propose a design, gather feedback.
-- **Ship tests and pass CI.** If you fix a bug or add a feature, include tests.
- Make sure CI is green before asking for review.
+- **Ship tests and pass CI.** If you fix a bug or add a feature, include
+ tests. Make sure CI is green before asking for review.
-- **Submit up to three proposals to multiple orgs.** Each org has limited slots,
- so contributing and applying across organizations can improve your chances—but
- focus on quality! Note: only one proposal can be accepted per contributor.
- ([developers.google.com][can_i_submit_more_than_one_proposal])
+- **Submit up to three proposals to multiple orgs.** Each org has
+ limited slots, so contributing and applying across organizations can
+ improve your chances—but focus on quality! Note: only one proposal can
+ be accepted per contributor.
+ ([developers.google.com](https://developers.google.com/open-source/gsoc/faq#can_i_submit_more_than_one_proposal "Frequently Asked Questions | Google Summer of Code"))
-* **Write a crisp proposal.** Be clear, specific, and concise (≤10 pages).
- Demonstrate understanding of the project and outline concrete steps,
- milestones, and risks. Ask maintainers for early feedback so you have time to
- refine.
+- **Write a crisp proposal.** Be clear, specific, and concise (≤10
+ pages). Demonstrate understanding of the project and outline concrete
+ steps, milestones, and risks. Ask maintainers for early feedback so
+ you have time to refine.
----
+------------------------------------------------------------------------
## Looking Ahead
-I'm excited to keep participating in GSoC in the coming years and to keep
-welcoming new contributors into open-source communities. Thank you to the GSoC
-team for running this program year after year—it raises the visibility of
-projects, gives newcomers a safe place to learn from experts, and strengthens
-the open-source ecosystem. For hundreds of students and first-time contributors,
-GSoC isn't just a summer; it's a beginning.
-
-[can_i_submit_more_than_one_proposal]:
- https://developers.google.com/open-source/gsoc/faq#can_i_submit_more_than_one_proposal
- "Frequently Asked Questions | Google Summer of Code"
+I’m excited to keep participating in GSoC in the coming years and to
+keep welcoming new contributors into open-source communities. Thank you
+to the GSoC team for running this program year after year—it raises the
+visibility of projects, gives newcomers a safe place to learn from
+experts, and strengthens the open-source ecosystem. For hundreds of
+students and first-time contributors, GSoC isn’t just a summer; it’s a
+beginning.
\ No newline at end of file
diff --git a/pages/blog/three-years-with-google-summer-of-code-what-ive-learned/index.qmd b/pages/blog/three-years-with-google-summer-of-code-what-ive-learned/index.qmd
new file mode 100644
index 000000000..11e7bf22a
--- /dev/null
+++ b/pages/blog/three-years-with-google-summer-of-code-what-ive-learned/index.qmd
@@ -0,0 +1,148 @@
+---
+title: "Three Years with Google Summer of Code: What I've Learned"
+slug: three-years-with-google-summer-of-code-what-ive-learned
+date: 2025-11-02
+authors: ["Ivan Ogasawara"]
+tags: [open-source, gsoc, mentoring]
+categories: [gsoc]
+description: |
+ Three years in GSoC taught us one thing: mentoring matters more than code.
+ As a 2025 mentoring org (with AlphaOneLabs, Extralit, Makim, Sugar), our
+ playbook is simple—balance mentors, set explicit contribution rules, meet
+ regularly; and for contributors: communicate publicly and ship small,
+ tested PRs.
+thumbnail: "/header.png"
+template: "blog-post.html"
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+
+# Three Years with Google Summer of Code: What I've Learned
+
+Mentoring is at the heart of Open Science Labs (OSL). It's why we joined Google
+Summer of Code (GSoC) in the first place. We started as a sub-organization under
+the NumFOCUS umbrella for two years, and in 2025 we were accepted as a
+**Mentoring Organization**. Huge thanks to **Anavelyz Pérez** for keeping us on
+track. We’re pleased to have secured four contributor slots for 2025 with
+**AlphaOneLabs**, **Extralit**, **Makim**, and **Sugar**.
+
+We're incredibly proud of the contributors and mentors who made GSoC 2025 a
+success. We were also, honestly, a bit heartbroken—many strong applicants did
+real work and still didn't get in. On a personal note, attending the **GSoC
+Summit** was a highlight: I met inspiring people and learned a lot from their
+experiences.
+
+Below are the lessons that stood out across these three years and practical
+recommendations for organizers, mentors, and contributors.
+
+---
+
+## The Big Lesson
+
+**GSoC isn't just about code—it's about mentoring.** Code is the artifact;
+mentoring is the engine. The best summers happen when we design for learning,
+clarity, and care. Everything else follows.
+
+---
+
+## Recommendations for Organizers
+
+- **Confirm your slot count early.** The number of slots you _realistically_
+ expect should shape how many projects you onboard and how you scope them.
+
+- **Balance mentors as well as projects.** When allocating slots, distribute
+ contributors across both projects _and_ mentors. Avoid situations where one
+ mentor has two contributors while another has none—burnout and uneven support
+ help no one.
+
+---
+
+## Recommendations for Mentors
+
+- **Limit the number of projects per mentor.** The pre-selection phase is
+ intense. If you're stretched across multiple proposals, candidates won't get
+ the guidance they deserve. One well-mentored project beats three
+ under-mentored ones.
+
+- **Codify contribution rules up front.** Document expectations clearly and link
+ them everywhere:
+
+ - Max PR size (e.g., “prefer ≤300 lines; split larger changes”).
+ - Stale PR policy (e.g., “no updates for 10 days → close or draft”).
+ - Code style, linting, and formatting rules.
+ - Clear stance on AI-generated code (allowed or not, and under what
+ conditions).
+
+- **Keep your CONTRIBUTING.md and PR template current.** Treat them as living
+ documents. If you change the rules mid-summer, call it out in a pinned
+ message.
+
+- **Equip contributors to grow.** Share starter issues, architecture diagrams,
+ walkthrough videos, and links to docs or talks. Provide “good first PR”
+ examples.
+
+- **Meet regularly.** Short weekly 1:1s or cohort calls work wonders. Use
+ agendas. End with explicit next steps.
+
+- **Nurture community, not competition.** Encourage contributors to help each
+ other, co-review PRs, and pair on debugging. A supportive, respectful culture
+ is non-negotiable.
+
+- **Have a Plan B for great applicants who aren't selected.** If you have
+ bandwidth, offer an internship track, micro-grants, or
+ “fellows-without-funding” with mentorship and recognition. It keeps momentum
+ and grows your contributor base.
+
+---
+
+## Recommendations for Contributors
+
+- **Default to public communication.** Ask questions in the project's public
+ channels. It helps others learn and shows the team how you collaborate.
+
+- **If a mentor is unresponsive, switch projects.** They're likely overloaded;
+ repeated pings won't help. Find a project with responsive maintainers and
+ bandwidth for new contributors.
+
+- **Avoid giant PRs.** Huge changes are hard to review and often get stuck. Ship
+ small, focused PRs that follow the project's style and tests.
+
+- **Show you understand the project's culture.** Read the docs. Match coding
+ style. Follow the templates. Keep commits scoped and messages clear.
+
+- **Be careful with AI-generated code.** Don't paste blindly. Understand the
+ problem, explain your choices, remove unnecessary comments, and **never**
+ include emojis in code comments.
+
+- **Discuss big changes before you implement them.** Don't refactor core
+ components or alter architecture without buy-in. Open an issue, propose a
+ design, gather feedback.
+
+- **Ship tests and pass CI.** If you fix a bug or add a feature, include tests.
+ Make sure CI is green before asking for review.
+
+- **Submit up to three proposals to multiple orgs.** Each org has limited slots,
+ so contributing and applying across organizations can improve your chances—but
+ focus on quality! Note: only one proposal can be accepted per contributor.
+ ([developers.google.com][can_i_submit_more_than_one_proposal])
+
+* **Write a crisp proposal.** Be clear, specific, and concise (≤10 pages).
+ Demonstrate understanding of the project and outline concrete steps,
+ milestones, and risks. Ask maintainers for early feedback so you have time to
+ refine.
+
+---
+
+## Looking Ahead
+
+I'm excited to keep participating in GSoC in the coming years and to keep
+welcoming new contributors into open-source communities. Thank you to the GSoC
+team for running this program year after year—it raises the visibility of
+projects, gives newcomers a safe place to learn from experts, and strengthens
+the open-source ecosystem. For hundreds of students and first-time contributors,
+GSoC isn't just a summer; it's a beginning.
+
+[can_i_submit_more_than_one_proposal]:
+ https://developers.google.com/open-source/gsoc/faq#can_i_submit_more_than_one_proposal
+ "Frequently Asked Questions | Google Summer of Code"
diff --git a/pages/blog/typer-a-python-library-for-building-cli-applications/index.ipynb b/pages/blog/typer-a-python-library-for-building-cli-applications/index.ipynb
deleted file mode 100644
index 1a17103ac..000000000
--- a/pages/blog/typer-a-python-library-for-building-cli-applications/index.ipynb
+++ /dev/null
@@ -1,487 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "raw",
- "id": "20d00ff3-2b98-43d3-87b3-2b8142356054",
- "metadata": {},
- "source": [
- "---\n",
- "title: \"Typer: A Python Library for Building CLI Applications\"\n",
- "slug: typer-a-python-library-for-building-cli-applications\n",
- "date: 2024-01-11\n",
- "authors: [\"Ivan Ogasawara\"]\n",
- "tags: [open-source, cli, python]\n",
- "categories: [python]\n",
- "description: |\n",
- " Typer is an exciting library for Python developers, designed to make the creation of\n",
- " command-line interface (CLI) applications not just easier, but also more enjoyable.\n",
- " Built on top of the well-known Click library, Typer leverages Python 3.6+ features,\n",
- " like type hints, to define CLI commands in a straightforward and intuitive way.\n",
- "thumbnail: \"/header.svg\"\n",
- "template: \"blog-post.html\"\n",
- "---"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "24d656a5-38e6-4ed0-bf15-b8854b96b475",
- "metadata": {},
- "source": [
- "# Typer: A Python Library for Building CLI Applications\n",
- "\n",
- "## What is Typer?\n",
- "\n",
- "Typer is an exciting library for Python developers, designed to make the creation of command-line interface (CLI) applications not just easier, but also more enjoyable. Built on top of the well-known Click library, Typer leverages Python 3.6+ features, like type hints, to define CLI commands in a straightforward and intuitive way.\n",
- "\n",
- "## Why Choose Typer?\n",
- "\n",
- "- **Simplicity**: With Typer, you can create powerful CLI applications using minimal code.\n",
- "- **Type Hints**: Leverages Python's type hints for parameter declaration, reducing errors and improving code clarity.\n",
- "- **Automatic Help**: Generates help text and error messages based on your code.\n",
- "- **Subcommands**: Supports nested commands, allowing complex CLI applications.\n",
- "\n",
- "## Getting Started with Typer\n",
- "\n",
- "### Installation\n",
- "\n",
- "To begin using Typer, you first need to install it. You can easily do this using pip:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "id": "df3d4252-6fc3-46c0-93a2-009b29a06950",
- "metadata": {},
- "outputs": [],
- "source": [
- "!pip install typer -q"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "29687fe2-1c91-4193-8090-948d8f0e7f01",
- "metadata": {},
- "source": [
- "### Creating Your First Typer Application\n",
- "\n",
- "Let's start with a simple example. We'll create an application that greets a user.\n",
- "\n",
- "First, import Typer and create an instance of it:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "1978b4e0-0fb0-4206-951b-30b59d3932c7",
- "metadata": {},
- "outputs": [],
- "source": [
- "import typer\n",
- "\n",
- "app = typer.Typer()"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "6ca9ee46-01b3-45a1-a8d2-4cc6572469d0",
- "metadata": {},
- "source": [
- "Now, define a function that will act as your command. Use type hints for function arguments:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "id": "ed5cbac1-0d88-423e-a89a-13269674f8e5",
- "metadata": {},
- "outputs": [],
- "source": [
- "@app.command()\n",
- "def greet(\n",
- " name: str = typer.Option(\n",
- " \"--name\",\n",
- " \"-n\",\n",
- " help=\"The name of the person to greet.\"\n",
- " )\n",
- ") -> None:\n",
- " \"\"\"Greets the user by name.\"\"\"\n",
- " typer.echo(f\"Hello {name}!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "7d3e5fa5-89eb-452f-bff3-0db5c27a6e14",
- "metadata": {},
- "source": [
- "To run this application, use the following code block at the end of your script:"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "f3f1a6c8-f1e2-45aa-8bfc-de265508b1f2",
- "metadata": {},
- "source": [
- "```python\n",
- "if __name__ == \"__main__\":\n",
- " app()\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "ade80555-11b1-41fe-9f52-05c025c905ec",
- "metadata": {},
- "source": [
- "### Running the Application\n",
- "\n",
- "Save the script as `greet.py` and run it from the command line:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "id": "e2dc5366-aacc-4fcf-a35c-37a44c07e4a1",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Overwriting greet.py\n"
- ]
- }
- ],
- "source": [
- "%%writefile greet.py\n",
- "\n",
- "import typer\n",
- "\n",
- "app = typer.Typer()\n",
- "\n",
- "@app.command()\n",
- "def greet(\n",
- " name: str = typer.Option(\n",
- " ..., \n",
- " \"--name\",\n",
- " help=\"The name of the person to greet.\"\n",
- " )\n",
- ") -> None:\n",
- " \"\"\"Greets the user by name.\"\"\"\n",
- " typer.echo(f\"Hello {name}!\")\n",
- "\n",
- "if __name__ == \"__main__\":\n",
- " app()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "id": "ffbab51f-316b-45ae-ae0f-89ae4f2fb091",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Hello Alice!\n"
- ]
- }
- ],
- "source": [
- "!python greet.py --name Alice"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "888efccd-2376-4ae2-b5f7-9f9bb533a061",
- "metadata": {},
- "source": [
- "### Help Documentation\n",
- "\n",
- "Typer automatically generates help documentation for your application. Try running:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "id": "df751231-f505-4325-b866-d1aca5c8ea1e",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Usage: greet.py [OPTIONS]\n",
- "\n",
- " Greets the user by name.\n",
- "\n",
- "Options:\n",
- " --name TEXT The name of the person to greet. [required]\n",
- " --install-completion [bash|zsh|fish|powershell|pwsh]\n",
- " Install completion for the specified shell.\n",
- " --show-completion [bash|zsh|fish|powershell|pwsh]\n",
- " Show completion for the specified shell, to\n",
- " copy it or customize the installation.\n",
- " --help Show this message and exit.\n"
- ]
- }
- ],
- "source": [
- "!python greet.py --help"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "32c3a083-7758-4ccf-a284-b3c746bcdfc9",
- "metadata": {},
- "source": [
- "You'll get a detailed description of how to use the command, including available options.\n",
- "\n",
- "## Working with Subcommands\n",
- "\n",
- "Typer supports subcommands, allowing you to build more complex applications. In the following example, the script is structured around a main Typer application (app) and two sub-applications (app_user and app_product). This hierarchical structure is a hallmark of Typer, allowing for the organization of commands into distinct categories – in this case, user-related and product-related operations. Such an approach not only enhances the readability and maintainability of the code but also provides a more intuitive interface for the end users. They can easily navigate through the different functionalities of the application, whether it's creating or updating users, or handling product information."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "id": "f65b9abc-3ec4-403f-baea-0fc900dde19d",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Overwriting ecommerce.py\n"
- ]
- }
- ],
- "source": [
- "%%writefile ecommerce.py\n",
- "import typer\n",
- "\n",
- "from typer import Context, Option\n",
- "\n",
- "\n",
- "app = typer.Typer(help=\"Operations for e-commerce.\")\n",
- "app_user = typer.Typer(help=\"Operations for user model.\")\n",
- "app_product = typer.Typer(help=\"Operations for product model.\")\n",
- "\n",
- "app.add_typer(app_user, name=\"user\")\n",
- "app.add_typer(app_product, name=\"product\")\n",
- "\n",
- "@app.callback(invoke_without_command=True)\n",
- "def main(\n",
- " ctx: Context,\n",
- " version: bool = Option(\n",
- " None,\n",
- " \"--version\",\n",
- " \"-v\",\n",
- " is_flag=True,\n",
- " help=\"Show the version and exit.\",\n",
- " ),\n",
- ") -> None:\n",
- " \"\"\"Process envers for specific flags, otherwise show the help menu.\"\"\"\n",
- " if version:\n",
- " __version__ = \"0.1.0\"\n",
- " typer.echo(f\"Version: {__version__}\")\n",
- " raise typer.Exit()\n",
- "\n",
- " if ctx.invoked_subcommand is None:\n",
- " typer.echo(ctx.get_help())\n",
- " raise typer.Exit(0)\n",
- "\n",
- "@app_user.command(\"create\")\n",
- "def user_create(name: str = typer.Argument(..., help=\"Name of the user to create.\")) -> None:\n",
- " \"\"\"Create a new user with the given name.\"\"\"\n",
- " print(f\"Creating user: {name} - Done\")\n",
- "\n",
- "\n",
- "@app_user.command(\"update\")\n",
- "def user_update(name: str = typer.Argument(..., help=\"Name of the user to update.\")) -> None:\n",
- " \"\"\"Update user data with the given name.\"\"\"\n",
- " print(f\"Updating user: {name} - Done\")\n",
- "\n",
- "@app_product.command(\"create\")\n",
- "def product_create(name: str = typer.Argument(..., help=\"Name of the product to create.\")) -> None:\n",
- " \"\"\"Create a new product with the given name.\"\"\"\n",
- " print(f\"Creating product: {name} - Done\")\n",
- "\n",
- "\n",
- "@app_product.command(\"update\")\n",
- "def product_update(name: str = typer.Argument(..., help=\"Name of the product to update.\")) -> None:\n",
- " \"\"\"Update a product with the given name.\"\"\"\n",
- " print(f\"Updating product: {name} - Done\")\n",
- "\n",
- "\n",
- "if __name__ == \"__main__\":\n",
- " app()"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "5e4b18ac-db76-4428-a6e9-46d68aa4b80b",
- "metadata": {},
- "source": [
- "A key feature demonstrated in the script is the use of the callback function with the invoke_without_command=True parameter. This setup enables the execution of specific code (like displaying the version or help text) before any subcommands are processed. It's a powerful tool for handling pre-command logic or global options that apply to the entire CLI application.\n",
- "\n",
- "Moreover, the script showcases the simplicity and elegance of defining commands in Typer. Each operation, such as creating or updating users and products, is defined as a function, with parameters automatically translated into command-line options or arguments. This approach not only makes the code more readable but also leverages Python's type hints to ensure that the command-line arguments are correctly interpreted, providing a seamless and error-free user experience."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "d5a36362-e9dd-4653-a72b-41e54ee88717",
- "metadata": {},
- "source": [
- "In the following lines, there are some examples of the CLI call with different parameters."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "id": "5edf02bf-631b-482c-8e58-f272ce837669",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Usage: ecommerce.py [OPTIONS] COMMAND [ARGS]...\n",
- "\n",
- " Operations for e-commerce.\n",
- "\n",
- "Options:\n",
- " -v, --version Show the version and exit.\n",
- " --install-completion [bash|zsh|fish|powershell|pwsh]\n",
- " Install completion for the specified shell.\n",
- " --show-completion [bash|zsh|fish|powershell|pwsh]\n",
- " Show completion for the specified shell, to\n",
- " copy it or customize the installation.\n",
- " --help Show this message and exit.\n",
- "\n",
- "Commands:\n",
- " product Operations for product model.\n",
- " user Operations for user model.\n"
- ]
- }
- ],
- "source": [
- "!python ecommerce.py --help"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "id": "39f172a1-7a30-4c66-a1db-771711efa3ca",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Version: 0.1.0\n"
- ]
- }
- ],
- "source": [
- "!python ecommerce.py --version"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "id": "70d3db3d-1333-4a97-8b3b-8a2afc0e186d",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Usage: ecommerce.py user [OPTIONS] COMMAND [ARGS]...\n",
- "\n",
- " Operations for user model.\n",
- "\n",
- "Options:\n",
- " --help Show this message and exit.\n",
- "\n",
- "Commands:\n",
- " create Create a new user with the given name.\n",
- " update Update user data with the given name.\n"
- ]
- }
- ],
- "source": [
- "!python ecommerce.py user --help"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "id": "707cebd3-bc21-4b52-885e-b72e0923e391",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Usage: ecommerce.py user create [OPTIONS] NAME\n",
- "\n",
- " Create a new user with the given name.\n",
- "\n",
- "Arguments:\n",
- " NAME Name of the user to create. [required]\n",
- "\n",
- "Options:\n",
- " --help Show this message and exit.\n"
- ]
- }
- ],
- "source": [
- "!python ecommerce.py user create --help"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "4a6ff744-17fb-44eb-a80c-86f97b4f960a",
- "metadata": {},
- "outputs": [],
- "source": [
- "!python ecommerce.py product --help"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "c636a291-3240-4b45-bcd2-93e25b442fe0",
- "metadata": {},
- "source": [
- "## Conclusion\n",
- "\n",
- "Typer is a powerful yet straightforward tool for building CLI applications in Python. By leveraging Python's type hints, it offers an intuitive way to define commands and parameters, automatically handles help documentation, and supports complex command structures with subcommands. Whether you're a beginner or an experienced Python developer, Typer can significantly enhance your productivity in CLI development.\n",
- "\n",
- "Happy coding with Typer! 🐍✨"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3 (ipykernel)",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.11.7"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/pages/blog/typer-a-python-library-for-building-cli-applications/index.md b/pages/blog/typer-a-python-library-for-building-cli-applications/index.md
index 1989e7e00..918593358 100644
--- a/pages/blog/typer-a-python-library-for-building-cli-applications/index.md
+++ b/pages/blog/typer-a-python-library-for-building-cli-applications/index.md
@@ -13,47 +13,56 @@ description: |
thumbnail: "/header.svg"
template: "blog-post.html"
---
+
# Typer: A Python Library for Building CLI Applications
## What is Typer?
-Typer is an exciting library for Python developers, designed to make the creation of command-line interface (CLI) applications not just easier, but also more enjoyable. Built on top of the well-known Click library, Typer leverages Python 3.6+ features, like type hints, to define CLI commands in a straightforward and intuitive way.
+Typer is an exciting library for Python developers, designed to make the
+creation of command-line interface (CLI) applications not just easier,
+but also more enjoyable. Built on top of the well-known Click library,
+Typer leverages Python 3.6+ features, like type hints, to define CLI
+commands in a straightforward and intuitive way.
## Why Choose Typer?
-- **Simplicity**: With Typer, you can create powerful CLI applications using minimal code.
-- **Type Hints**: Leverages Python's type hints for parameter declaration, reducing errors and improving code clarity.
-- **Automatic Help**: Generates help text and error messages based on your code.
-- **Subcommands**: Supports nested commands, allowing complex CLI applications.
+- **Simplicity**: With Typer, you can create powerful CLI applications
+ using minimal code.
+- **Type Hints**: Leverages Python’s type hints for parameter
+ declaration, reducing errors and improving code clarity.
+- **Automatic Help**: Generates help text and error messages based on
+ your code.
+- **Subcommands**: Supports nested commands, allowing complex CLI
+ applications.
## Getting Started with Typer
### Installation
-To begin using Typer, you first need to install it. You can easily do this using pip:
-
+To begin using Typer, you first need to install it. You can easily do
+this using pip:
-```python
+``` python
!pip install typer -q
```
### Creating Your First Typer Application
-Let's start with a simple example. We'll create an application that greets a user.
+Let’s start with a simple example. We’ll create an application that
+greets a user.
First, import Typer and create an instance of it:
-
-```python
+``` python
import typer
app = typer.Typer()
```
-Now, define a function that will act as your command. Use type hints for function arguments:
+Now, define a function that will act as your command. Use type hints for
+function arguments:
-
-```python
+``` python
@app.command()
def greet(
name: str = typer.Option(
@@ -66,9 +75,10 @@ def greet(
typer.echo(f"Hello {name}!")
```
-To run this application, use the following code block at the end of your script:
+To run this application, use the following code block at the end of your
+script:
-```python
+``` python
if __name__ == "__main__":
app()
```
@@ -77,8 +87,7 @@ if __name__ == "__main__":
Save the script as `greet.py` and run it from the command line:
-
-```python
+``` python
%%writefile greet.py
import typer
@@ -100,78 +109,54 @@ if __name__ == "__main__":
app()
```
-- OUTPUT - -
-
-
-Makim file: .makim.yaml
-/tmp
+ Makim file: .makim.yaml
+ /tmp
-
-
-
-
+ Overwriting greet.py
-
-```python
+``` python
!python greet.py --name Alice
```
-- OUTPUT - -
-
-
-Overwriting greet.py
-
-
-
-
-
+ Hello Alice!
### Help Documentation
-Typer automatically generates help documentation for your application. Try running:
-
+Typer automatically generates help documentation for your application.
+Try running:
-```python
+``` python
!python greet.py --help
```
-- OUTPUT - -
-
-
-Hello Alice!
-
-
-
-
-
-
-You'll get a detailed description of how to use the command, including available options.
+You’ll get a detailed description of how to use the command, including
+available options.
## Working with Subcommands
-Typer supports subcommands, allowing you to build more complex applications. In the following example, the script is structured around a main Typer application (app) and two sub-applications (app_user and app_product). This hierarchical structure is a hallmark of Typer, allowing for the organization of commands into distinct categories – in this case, user-related and product-related operations. Such an approach not only enhances the readability and maintainability of the code but also provides a more intuitive interface for the end users. They can easily navigate through the different functionalities of the application, whether it's creating or updating users, or handling product information.
-
-
-```python
+Typer supports subcommands, allowing you to build more complex
+applications. In the following example, the script is structured around
+a main Typer application (app) and two sub-applications (app_user and
+app_product). This hierarchical structure is a hallmark of Typer,
+allowing for the organization of commands into distinct categories – in
+this case, user-related and product-related operations. Such an approach
+not only enhances the readability and maintainability of the code but
+also provides a more intuitive interface for the end users. They can
+easily navigate through the different functionalities of the
+application, whether it’s creating or updating users, or handling
+product information.
+
+``` python
%%writefile ecommerce.py
import typer
@@ -233,136 +218,94 @@ if __name__ == "__main__":
app()
```
-- OUTPUT - -
-
-
-Usage: greet.py [OPTIONS]
+ Usage: greet.py [OPTIONS]
-Greets the user by name.
+ Greets the user by name.
-Options:
---name TEXT The name of the person to greet. [required]
---install-completion [bash|zsh|fish|powershell|pwsh]
-Install completion for the specified shell.
---show-completion [bash|zsh|fish|powershell|pwsh]
-Show completion for the specified shell, to
-copy it or customize the installation.
---help Show this message and exit.
+ Options:
+ --name TEXT The name of the person to greet. [required]
+ --install-completion [bash|zsh|fish|powershell|pwsh]
+ Install completion for the specified shell.
+ --show-completion [bash|zsh|fish|powershell|pwsh]
+ Show completion for the specified shell, to
+ copy it or customize the installation.
+ --help Show this message and exit.
-
-
-
-
-
-A key feature demonstrated in the script is the use of the callback function with the invoke_without_command=True parameter. This setup enables the execution of specific code (like displaying the version or help text) before any subcommands are processed. It's a powerful tool for handling pre-command logic or global options that apply to the entire CLI application.
+ Overwriting ecommerce.py
-Moreover, the script showcases the simplicity and elegance of defining commands in Typer. Each operation, such as creating or updating users and products, is defined as a function, with parameters automatically translated into command-line options or arguments. This approach not only makes the code more readable but also leverages Python's type hints to ensure that the command-line arguments are correctly interpreted, providing a seamless and error-free user experience.
+A key feature demonstrated in the script is the use of the callback
+function with the invoke_without_command=True parameter. This setup
+enables the execution of specific code (like displaying the version or
+help text) before any subcommands are processed. It’s a powerful tool
+for handling pre-command logic or global options that apply to the
+entire CLI application.
-In the following lines, there are some examples of the CLI call with different parameters.
+Moreover, the script showcases the simplicity and elegance of defining
+commands in Typer. Each operation, such as creating or updating users
+and products, is defined as a function, with parameters automatically
+translated into command-line options or arguments. This approach not
+only makes the code more readable but also leverages Python’s type hints
+to ensure that the command-line arguments are correctly interpreted,
+providing a seamless and error-free user experience.
+In the following lines, there are some examples of the CLI call with
+different parameters.
-```python
+``` python
!python ecommerce.py --help
```
-- OUTPUT - -
-
-
-Overwriting ecommerce.py
-
-
-
-
-
-
-
-```python
+``` python
!python ecommerce.py --version
```
-- OUTPUT - -
-
-
-Usage: ecommerce.py [OPTIONS] COMMAND [ARGS]...
+ Usage: ecommerce.py [OPTIONS] COMMAND [ARGS]...
-Operations for e-commerce.
+ Operations for e-commerce.
-Options:
--v, --version Show the version and exit.
---install-completion [bash|zsh|fish|powershell|pwsh]
-Install completion for the specified shell.
---show-completion [bash|zsh|fish|powershell|pwsh]
-Show completion for the specified shell, to
-copy it or customize the installation.
---help Show this message and exit.
+ Options:
+ -v, --version Show the version and exit.
+ --install-completion [bash|zsh|fish|powershell|pwsh]
+ Install completion for the specified shell.
+ --show-completion [bash|zsh|fish|powershell|pwsh]
+ Show completion for the specified shell, to
+ copy it or customize the installation.
+ --help Show this message and exit.
-Commands:
-product Operations for product model.
-user Operations for user model.
+ Commands:
+ product Operations for product model.
+ user Operations for user model.
-
-
-
-
+ Version: 0.1.0
-
-```python
+``` python
!python ecommerce.py user --help
```
-- OUTPUT - -
-
-
-Version: 0.1.0
-
-
-
-
-
+ Options:
+ --help Show this message and exit.
+ Commands:
+ create Create a new user with the given name.
+ update Update user data with the given name.
-```python
+``` python
!python ecommerce.py user create --help
```
-- OUTPUT - -
-
-
-Usage: ecommerce.py user [OPTIONS] COMMAND [ARGS]...
-
-Operations for user model.
-
-Options:
---help Show this message and exit.
+ Usage: ecommerce.py user [OPTIONS] COMMAND [ARGS]...
-Commands:
-create Create a new user with the given name.
-update Update user data with the given name.
+ Operations for user model.
-
-
-
-
+ Arguments:
+ NAME Name of the user to create. [required]
+ Options:
+ --help Show this message and exit.
-```python
+``` python
!python ecommerce.py product --help
```
## Conclusion
-Typer is a powerful yet straightforward tool for building CLI applications in Python. By leveraging Python's type hints, it offers an intuitive way to define commands and parameters, automatically handles help documentation, and supports complex command structures with subcommands. Whether you're a beginner or an experienced Python developer, Typer can significantly enhance your productivity in CLI development.
+Typer is a powerful yet straightforward tool for building CLI
+applications in Python. By leveraging Python’s type hints, it offers an
+intuitive way to define commands and parameters, automatically handles
+help documentation, and supports complex command structures with
+subcommands. Whether you’re a beginner or an experienced Python
+developer, Typer can significantly enhance your productivity in CLI
+development.
-Happy coding with Typer! 🐍✨
+Happy coding with Typer! 🐍✨
\ No newline at end of file
diff --git a/pages/blog/typer-a-python-library-for-building-cli-applications/index.qmd b/pages/blog/typer-a-python-library-for-building-cli-applications/index.qmd
new file mode 100644
index 000000000..6ca1bc301
--- /dev/null
+++ b/pages/blog/typer-a-python-library-for-building-cli-applications/index.qmd
@@ -0,0 +1,291 @@
+---
+title: "Typer: A Python Library for Building CLI Applications"
+slug: typer-a-python-library-for-building-cli-applications
+date: 2024-01-11
+authors: ["Ivan Ogasawara"]
+tags: [open-source, cli, python]
+categories: [python]
+description: |
+ Typer is an exciting library for Python developers, designed to make the creation of
+ command-line interface (CLI) applications not just easier, but also more enjoyable.
+ Built on top of the well-known Click library, Typer leverages Python 3.6+ features,
+ like type hints, to define CLI commands in a straightforward and intuitive way.
+thumbnail: "/header.svg"
+template: "blog-post.html"
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+# Typer: A Python Library for Building CLI Applications
+
+## What is Typer?
+
+Typer is an exciting library for Python developers, designed to make the creation of command-line interface (CLI) applications not just easier, but also more enjoyable. Built on top of the well-known Click library, Typer leverages Python 3.6+ features, like type hints, to define CLI commands in a straightforward and intuitive way.
+
+## Why Choose Typer?
+
+- **Simplicity**: With Typer, you can create powerful CLI applications using minimal code.
+- **Type Hints**: Leverages Python's type hints for parameter declaration, reducing errors and improving code clarity.
+- **Automatic Help**: Generates help text and error messages based on your code.
+- **Subcommands**: Supports nested commands, allowing complex CLI applications.
+
+## Getting Started with Typer
+
+### Installation
+
+To begin using Typer, you first need to install it. You can easily do this using pip:
+
+
+```python
+!pip install typer -q
+```
+
+### Creating Your First Typer Application
+
+Let's start with a simple example. We'll create an application that greets a user.
+
+First, import Typer and create an instance of it:
+
+
+```python
+import typer
+
+app = typer.Typer()
+```
+
+Now, define a function that will act as your command. Use type hints for function arguments:
+
+
+```python
+@app.command()
+def greet(
+ name: str = typer.Option(
+ "--name",
+ "-n",
+ help="The name of the person to greet."
+ )
+) -> None:
+ """Greets the user by name."""
+ typer.echo(f"Hello {name}!")
+```
+
+To run this application, use the following code block at the end of your script:
+
+```python
+if __name__ == "__main__":
+ app()
+```
+
+### Running the Application
+
+Save the script as `greet.py` and run it from the command line:
+
+
+```python
+%%writefile greet.py
+
+import typer
+
+app = typer.Typer()
+
+@app.command()
+def greet(
+ name: str = typer.Option(
+ ...,
+ "--name",
+ help="The name of the person to greet."
+ )
+) -> None:
+ """Greets the user by name."""
+ typer.echo(f"Hello {name}!")
+
+if __name__ == "__main__":
+ app()
+```
+
+ Overwriting greet.py
+
+
+
+```python
+!python greet.py --name Alice
+```
+
+ Hello Alice!
+
+
+### Help Documentation
+
+Typer automatically generates help documentation for your application. Try running:
+
+
+```python
+!python greet.py --help
+```
+
+ Usage: greet.py [OPTIONS]
+
+ Greets the user by name.
+
+ Options:
+ --name TEXT The name of the person to greet. [required]
+ --install-completion [bash|zsh|fish|powershell|pwsh]
+ Install completion for the specified shell.
+ --show-completion [bash|zsh|fish|powershell|pwsh]
+ Show completion for the specified shell, to
+ copy it or customize the installation.
+ --help Show this message and exit.
+
+
+You'll get a detailed description of how to use the command, including available options.
+
+## Working with Subcommands
+
+Typer supports subcommands, allowing you to build more complex applications. In the following example, the script is structured around a main Typer application (app) and two sub-applications (app_user and app_product). This hierarchical structure is a hallmark of Typer, allowing for the organization of commands into distinct categories – in this case, user-related and product-related operations. Such an approach not only enhances the readability and maintainability of the code but also provides a more intuitive interface for the end users. They can easily navigate through the different functionalities of the application, whether it's creating or updating users, or handling product information.
+
+
+```python
+%%writefile ecommerce.py
+import typer
+
+from typer import Context, Option
+
+
+app = typer.Typer(help="Operations for e-commerce.")
+app_user = typer.Typer(help="Operations for user model.")
+app_product = typer.Typer(help="Operations for product model.")
+
+app.add_typer(app_user, name="user")
+app.add_typer(app_product, name="product")
+
+@app.callback(invoke_without_command=True)
+def main(
+ ctx: Context,
+ version: bool = Option(
+ None,
+ "--version",
+ "-v",
+ is_flag=True,
+ help="Show the version and exit.",
+ ),
+) -> None:
+ """Process envers for specific flags, otherwise show the help menu."""
+ if version:
+ __version__ = "0.1.0"
+ typer.echo(f"Version: {__version__}")
+ raise typer.Exit()
+
+ if ctx.invoked_subcommand is None:
+ typer.echo(ctx.get_help())
+ raise typer.Exit(0)
+
+@app_user.command("create")
+def user_create(name: str = typer.Argument(..., help="Name of the user to create.")) -> None:
+ """Create a new user with the given name."""
+ print(f"Creating user: {name} - Done")
+
+
+@app_user.command("update")
+def user_update(name: str = typer.Argument(..., help="Name of the user to update.")) -> None:
+ """Update user data with the given name."""
+ print(f"Updating user: {name} - Done")
+
+@app_product.command("create")
+def product_create(name: str = typer.Argument(..., help="Name of the product to create.")) -> None:
+ """Create a new product with the given name."""
+ print(f"Creating product: {name} - Done")
+
+
+@app_product.command("update")
+def product_update(name: str = typer.Argument(..., help="Name of the product to update.")) -> None:
+ """Update a product with the given name."""
+ print(f"Updating product: {name} - Done")
+
+
+if __name__ == "__main__":
+ app()
+```
+
+ Overwriting ecommerce.py
+
+
+A key feature demonstrated in the script is the use of the callback function with the invoke_without_command=True parameter. This setup enables the execution of specific code (like displaying the version or help text) before any subcommands are processed. It's a powerful tool for handling pre-command logic or global options that apply to the entire CLI application.
+
+Moreover, the script showcases the simplicity and elegance of defining commands in Typer. Each operation, such as creating or updating users and products, is defined as a function, with parameters automatically translated into command-line options or arguments. This approach not only makes the code more readable but also leverages Python's type hints to ensure that the command-line arguments are correctly interpreted, providing a seamless and error-free user experience.
+
+In the following lines, there are some examples of the CLI call with different parameters.
+
+
+```python
+!python ecommerce.py --help
+```
+
+ Usage: ecommerce.py [OPTIONS] COMMAND [ARGS]...
+
+ Operations for e-commerce.
+
+ Options:
+ -v, --version Show the version and exit.
+ --install-completion [bash|zsh|fish|powershell|pwsh]
+ Install completion for the specified shell.
+ --show-completion [bash|zsh|fish|powershell|pwsh]
+ Show completion for the specified shell, to
+ copy it or customize the installation.
+ --help Show this message and exit.
+
+ Commands:
+ product Operations for product model.
+ user Operations for user model.
+
+
+
+```python
+!python ecommerce.py --version
+```
+
+ Version: 0.1.0
+
+
+
+```python
+!python ecommerce.py user --help
+```
+
+ Usage: ecommerce.py user [OPTIONS] COMMAND [ARGS]...
+
+ Operations for user model.
+
+ Options:
+ --help Show this message and exit.
+
+ Commands:
+ create Create a new user with the given name.
+ update Update user data with the given name.
+
+
+
+```python
+!python ecommerce.py user create --help
+```
+
+ Usage: ecommerce.py user create [OPTIONS] NAME
+
+ Create a new user with the given name.
+
+ Arguments:
+ NAME Name of the user to create. [required]
+
+ Options:
+ --help Show this message and exit.
+
+
+
+```python
+!python ecommerce.py product --help
+```
+
+## Conclusion
+
+Typer is a powerful yet straightforward tool for building CLI applications in Python. By leveraging Python's type hints, it offers an intuitive way to define commands and parameters, automatically handles help documentation, and supports complex command structures with subcommands. Whether you're a beginner or an experienced Python developer, Typer can significantly enhance your productivity in CLI development.
+
+Happy coding with Typer! 🐍✨
diff --git a/pages/blog/unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch/index.ipynb b/pages/blog/unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch/index.ipynb
deleted file mode 100644
index b201f1fd0..000000000
--- a/pages/blog/unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch/index.ipynb
+++ /dev/null
@@ -1,216 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "raw",
- "id": "f170f83a-7776-4ed8-b295-4eb57b5d0219",
- "metadata": {},
- "source": [
- "---\n",
- "title: \"Unlocking the Power of Multiple Dispatch in Python with Plum-Dispatch\"\n",
- "slug: unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch\n",
- "date: 2024-01-05\n",
- "authors: [\"Ivan Ogasawara\"]\n",
- "tags: [open-source, multiple-dispatch, python]\n",
- "categories: [python]\n",
- "description: |\n",
- " Python, known for its simplicity and readability, sometimes requires a bit of\n",
- " creativity when it comes to implementing certain programming paradigms. One such\n",
- " paradigm is multiple dispatch (or multimethods), which allows functions to behave\n",
- " differently based on the type of their arguments. This is where plum-dispatch\n",
- " comes into play.\n",
- "thumbnail: \"/header.png\"\n",
- "template: \"blog-post.html\"\n",
- "---"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "46aadcef-e7c2-480a-bf3a-bbe20d09cc3b",
- "metadata": {},
- "source": [
- "Python, known for its simplicity and readability, sometimes requires a bit of creativity when it comes to implementing certain programming paradigms. One such paradigm is multiple dispatch (or multimethods), which allows functions to behave differently based on the type of their arguments. While not natively supported in Python, this feature can be incredibly powerful, particularly in complex applications such as mathematical computations, data processing, or when working with abstract syntax trees (ASTs). This is where `plum-dispatch` comes into play.\n",
- "\n",
- "## What is Multiple Dispatch?\n",
- "\n",
- "Multiple dispatch is a feature where the function to be executed is determined by the types of multiple arguments. This is different from single dispatch (which Python supports natively via the `functools.singledispatch` decorator), where the function called depends only on the type of the first argument.\n",
- "\n",
- "## Introducing Plum-Dispatch\n",
- "\n",
- "`plum-dispatch` is a Python library that provides an efficient and easy-to-use implementation of multiple dispatch. It allows you to define multiple versions of a function, each tailored to different types of input arguments.\n",
- "\n",
- "### Installation\n",
- "\n",
- "First things first, let's install `plum-dispatch`:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "id": "5d233782-8974-4758-aac8-0a6cfe757376",
- "metadata": {},
- "outputs": [],
- "source": [
- "!pip install plum-dispatch -q"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "84a8444d-6f2b-442e-8ab8-44f92c645c01",
- "metadata": {},
- "source": [
- "### Basic Usage\n",
- "\n",
- "To demonstrate the basic usage of `plum-dispatch`, let's start with a simple example. Suppose we have a function that needs to behave differently when passed an integer versus when it's passed a string."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "8a1320a3-4531-4d60-80af-4c8ae6301ad4",
- "metadata": {},
- "outputs": [],
- "source": [
- "from plum import dispatch\n",
- "\n",
- "\n",
- "class Processor:\n",
- " @dispatch\n",
- " def process(self, data: int):\n",
- " return f\"Processing integer: {data}\"\n",
- "\n",
- " @dispatch\n",
- " def process(self, data: str):\n",
- " return f\"Processing string: {data}\""
- ]
- },
- {
- "cell_type": "markdown",
- "id": "b396547c-3601-4d32-b6b3-25eba3c13be0",
- "metadata": {},
- "source": [
- "In this example, `Processor` has two `process` methods, one for integers and one for strings. `plum-dispatch` takes care of determining which method to call based on the type of `data`."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "6f2f654d-c142-408b-981c-ea0f4875a36d",
- "metadata": {},
- "source": [
- "### Advanced Example: Working with ASTs\n",
- "\n",
- "`plum-dispatch` shines in more complex scenarios, such as when working with different types of nodes in an abstract syntax tree. Let's create a simple AST representation with different node types and a visitor class to process these nodes."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "id": "4314c83a-8c69-41e7-be27-7738cd1003a9",
- "metadata": {},
- "outputs": [],
- "source": [
- "class StringNode:\n",
- " def __init__(self, value):\n",
- " self.value = value\n",
- "\n",
- "class NumberNode:\n",
- " def __init__(self, value):\n",
- " self.value = value\n",
- "\n",
- "class BaseASTVisitor:\n",
- " @dispatch\n",
- " def visit(self, node: StringNode):\n",
- " raise Exception(\"Not implemented yet.\")\n",
- "\n",
- " @dispatch\n",
- " def visit(self, node: NumberNode):\n",
- " raise Exception(\"Not implemented yet.\")\n",
- "\n",
- "class ASTVisitor(BaseASTVisitor):\n",
- " @dispatch\n",
- " def visit(self, node: StringNode):\n",
- " return f\"Visited StringNode with value: {node.value}\"\n",
- "\n",
- " @dispatch\n",
- " def visit(self, node: NumberNode):\n",
- " return f\"Visited NumberNode with value: {node.value}\""
- ]
- },
- {
- "cell_type": "markdown",
- "id": "d04e9401-e2a3-415a-9b85-0d1e0bf459e6",
- "metadata": {},
- "source": [
- "With `plum-dispatch`, our `ASTVisitor` can have a single `visit` method that behaves differently depending on whether it's visiting a `StringNode` or a `NumberNode`."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "312c3a2f-27b4-4abc-ab0d-ab6cd531066d",
- "metadata": {},
- "source": [
- "### Putting It All Together\n",
- "Now, let's see `plum-dispatch` in action:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "id": "a321b28b-25ab-47a7-bd28-bbed52107952",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Processing integer: 123\n",
- "Processing string: abc\n",
- "Visited StringNode with value: Hello\n",
- "Visited NumberNode with value: 456\n"
- ]
- }
- ],
- "source": [
- "processor = Processor()\n",
- "print(processor.process(123)) # \"Processing integer: 123\"\n",
- "print(processor.process(\"abc\")) # \"Processing string: abc\"\n",
- "\n",
- "visitor = ASTVisitor()\n",
- "print(visitor.visit(StringNode(\"Hello\"))) # \"Visited StringNode with value: Hello\"\n",
- "print(visitor.visit(NumberNode(456))) # \"Visited NumberNode with value: 456\""
- ]
- },
- {
- "cell_type": "markdown",
- "id": "1045a8fa-87ca-44fa-86ea-425429377ee1",
- "metadata": {},
- "source": [
- "## Conclusion\n",
- "\n",
- "`plum-dispatch` offers a neat and powerful way to implement multiple dispatch in Python, making your code more modular, readable, and elegant. Whether you're dealing with simple data types or complex structures like ASTs, `plum-dispatch` can help you write more efficient and maintainable code.\n",
- "\n",
- "For more complex examples and advanced usage, check out the [plum-dispatch documentation](https://github.com/wesselb/plum)."
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3 (ipykernel)",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.11.7"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/pages/blog/unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch/index.md b/pages/blog/unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch/index.md
index 609ce5fb9..4836f8ca4 100644
--- a/pages/blog/unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch/index.md
+++ b/pages/blog/unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch/index.md
@@ -14,31 +14,47 @@ description: |
thumbnail: "/header.png"
template: "blog-post.html"
---
-Python, known for its simplicity and readability, sometimes requires a bit of creativity when it comes to implementing certain programming paradigms. One such paradigm is multiple dispatch (or multimethods), which allows functions to behave differently based on the type of their arguments. While not natively supported in Python, this feature can be incredibly powerful, particularly in complex applications such as mathematical computations, data processing, or when working with abstract syntax trees (ASTs). This is where `plum-dispatch` comes into play.
+
+Python, known for its simplicity and readability, sometimes requires a
+bit of creativity when it comes to implementing certain programming
+paradigms. One such paradigm is multiple dispatch (or multimethods),
+which allows functions to behave differently based on the type of their
+arguments. While not natively supported in Python, this feature can be
+incredibly powerful, particularly in complex applications such as
+mathematical computations, data processing, or when working with
+abstract syntax trees (ASTs). This is where `plum-dispatch` comes into
+play.
## What is Multiple Dispatch?
-Multiple dispatch is a feature where the function to be executed is determined by the types of multiple arguments. This is different from single dispatch (which Python supports natively via the `functools.singledispatch` decorator), where the function called depends only on the type of the first argument.
+Multiple dispatch is a feature where the function to be executed is
+determined by the types of multiple arguments. This is different from
+single dispatch (which Python supports natively via the
+`functools.singledispatch` decorator), where the function called depends
+only on the type of the first argument.
## Introducing Plum-Dispatch
-`plum-dispatch` is a Python library that provides an efficient and easy-to-use implementation of multiple dispatch. It allows you to define multiple versions of a function, each tailored to different types of input arguments.
+`plum-dispatch` is a Python library that provides an efficient and
+easy-to-use implementation of multiple dispatch. It allows you to define
+multiple versions of a function, each tailored to different types of
+input arguments.
### Installation
-First things first, let's install `plum-dispatch`:
-
+First things first, let’s install `plum-dispatch`:
-```python
+``` python
!pip install plum-dispatch -q
```
### Basic Usage
-To demonstrate the basic usage of `plum-dispatch`, let's start with a simple example. Suppose we have a function that needs to behave differently when passed an integer versus when it's passed a string.
+To demonstrate the basic usage of `plum-dispatch`, let’s start with a
+simple example. Suppose we have a function that needs to behave
+differently when passed an integer versus when it’s passed a string.
-
-```python
+``` python
from plum import dispatch
@@ -52,14 +68,18 @@ class Processor:
return f"Processing string: {data}"
```
-In this example, `Processor` has two `process` methods, one for integers and one for strings. `plum-dispatch` takes care of determining which method to call based on the type of `data`.
+In this example, `Processor` has two `process` methods, one for integers
+and one for strings. `plum-dispatch` takes care of determining which
+method to call based on the type of `data`.
### Advanced Example: Working with ASTs
-`plum-dispatch` shines in more complex scenarios, such as when working with different types of nodes in an abstract syntax tree. Let's create a simple AST representation with different node types and a visitor class to process these nodes.
-
+`plum-dispatch` shines in more complex scenarios, such as when working
+with different types of nodes in an abstract syntax tree. Let’s create a
+simple AST representation with different node types and a visitor class
+to process these nodes.
-```python
+``` python
class StringNode:
def __init__(self, value):
self.value = value
@@ -87,13 +107,15 @@ class ASTVisitor(BaseASTVisitor):
return f"Visited NumberNode with value: {node.value}"
```
-With `plum-dispatch`, our `ASTVisitor` can have a single `visit` method that behaves differently depending on whether it's visiting a `StringNode` or a `NumberNode`.
+With `plum-dispatch`, our `ASTVisitor` can have a single `visit` method
+that behaves differently depending on whether it’s visiting a
+`StringNode` or a `NumberNode`.
### Putting It All Together
-Now, let's see `plum-dispatch` in action:
+Now, let’s see `plum-dispatch` in action:
-```python
+``` python
processor = Processor()
print(processor.process(123)) # "Processing integer: 123"
print(processor.process("abc")) # "Processing string: abc"
@@ -103,24 +125,18 @@ print(visitor.visit(StringNode("Hello"))) # "Visited StringNode with value: Hel
print(visitor.visit(NumberNode(456))) # "Visited NumberNode with value: 456"
```
-- OUTPUT - -
-
-
-Usage: ecommerce.py user create [OPTIONS] NAME
-
-Create a new user with the given name.
-
-Arguments:
-NAME Name of the user to create. [required]
+ Usage: ecommerce.py user create [OPTIONS] NAME
-Options:
---help Show this message and exit.
+ Create a new user with the given name.
-
-
-
-
+ Processing integer: 123
+ Processing string: abc
+ Visited StringNode with value: Hello
+ Visited NumberNode with value: 456
## Conclusion
-`plum-dispatch` offers a neat and powerful way to implement multiple dispatch in Python, making your code more modular, readable, and elegant. Whether you're dealing with simple data types or complex structures like ASTs, `plum-dispatch` can help you write more efficient and maintainable code.
+`plum-dispatch` offers a neat and powerful way to implement multiple
+dispatch in Python, making your code more modular, readable, and
+elegant. Whether you’re dealing with simple data types or complex
+structures like ASTs, `plum-dispatch` can help you write more efficient
+and maintainable code.
-For more complex examples and advanced usage, check out the [plum-dispatch documentation](https://github.com/wesselb/plum).
+For more complex examples and advanced usage, check out the
+[plum-dispatch documentation](https://github.com/wesselb/plum).
\ No newline at end of file
diff --git a/pages/blog/unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch/index.qmd b/pages/blog/unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch/index.qmd
new file mode 100644
index 000000000..608cef3a6
--- /dev/null
+++ b/pages/blog/unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch/index.qmd
@@ -0,0 +1,119 @@
+---
+title: "Unlocking the Power of Multiple Dispatch in Python with Plum-Dispatch"
+slug: unlocking-the-power-of-multiple-dispatch-in-python-with-plum-dispatch
+date: 2024-01-05
+authors: ["Ivan Ogasawara"]
+tags: [open-source, multiple-dispatch, python]
+categories: [python]
+description: |
+ Python, known for its simplicity and readability, sometimes requires a bit of
+ creativity when it comes to implementing certain programming paradigms. One such
+ paradigm is multiple dispatch (or multimethods), which allows functions to behave
+ differently based on the type of their arguments. This is where plum-dispatch
+ comes into play.
+thumbnail: "/header.png"
+template: "blog-post.html"
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+Python, known for its simplicity and readability, sometimes requires a bit of creativity when it comes to implementing certain programming paradigms. One such paradigm is multiple dispatch (or multimethods), which allows functions to behave differently based on the type of their arguments. While not natively supported in Python, this feature can be incredibly powerful, particularly in complex applications such as mathematical computations, data processing, or when working with abstract syntax trees (ASTs). This is where `plum-dispatch` comes into play.
+
+## What is Multiple Dispatch?
+
+Multiple dispatch is a feature where the function to be executed is determined by the types of multiple arguments. This is different from single dispatch (which Python supports natively via the `functools.singledispatch` decorator), where the function called depends only on the type of the first argument.
+
+## Introducing Plum-Dispatch
+
+`plum-dispatch` is a Python library that provides an efficient and easy-to-use implementation of multiple dispatch. It allows you to define multiple versions of a function, each tailored to different types of input arguments.
+
+### Installation
+
+First things first, let's install `plum-dispatch`:
+
+
+```python
+!pip install plum-dispatch -q
+```
+
+### Basic Usage
+
+To demonstrate the basic usage of `plum-dispatch`, let's start with a simple example. Suppose we have a function that needs to behave differently when passed an integer versus when it's passed a string.
+
+
+```python
+from plum import dispatch
+
+
+class Processor:
+ @dispatch
+ def process(self, data: int):
+ return f"Processing integer: {data}"
+
+ @dispatch
+ def process(self, data: str):
+ return f"Processing string: {data}"
+```
+
+In this example, `Processor` has two `process` methods, one for integers and one for strings. `plum-dispatch` takes care of determining which method to call based on the type of `data`.
+
+### Advanced Example: Working with ASTs
+
+`plum-dispatch` shines in more complex scenarios, such as when working with different types of nodes in an abstract syntax tree. Let's create a simple AST representation with different node types and a visitor class to process these nodes.
+
+
+```python
+class StringNode:
+ def __init__(self, value):
+ self.value = value
+
+class NumberNode:
+ def __init__(self, value):
+ self.value = value
+
+class BaseASTVisitor:
+ @dispatch
+ def visit(self, node: StringNode):
+ raise Exception("Not implemented yet.")
+
+ @dispatch
+ def visit(self, node: NumberNode):
+ raise Exception("Not implemented yet.")
+
+class ASTVisitor(BaseASTVisitor):
+ @dispatch
+ def visit(self, node: StringNode):
+ return f"Visited StringNode with value: {node.value}"
+
+ @dispatch
+ def visit(self, node: NumberNode):
+ return f"Visited NumberNode with value: {node.value}"
+```
+
+With `plum-dispatch`, our `ASTVisitor` can have a single `visit` method that behaves differently depending on whether it's visiting a `StringNode` or a `NumberNode`.
+
+### Putting It All Together
+Now, let's see `plum-dispatch` in action:
+
+
+```python
+processor = Processor()
+print(processor.process(123)) # "Processing integer: 123"
+print(processor.process("abc")) # "Processing string: abc"
+
+visitor = ASTVisitor()
+print(visitor.visit(StringNode("Hello"))) # "Visited StringNode with value: Hello"
+print(visitor.visit(NumberNode(456))) # "Visited NumberNode with value: 456"
+```
+
+ Processing integer: 123
+ Processing string: abc
+ Visited StringNode with value: Hello
+ Visited NumberNode with value: 456
+
+
+## Conclusion
+
+`plum-dispatch` offers a neat and powerful way to implement multiple dispatch in Python, making your code more modular, readable, and elegant. Whether you're dealing with simple data types or complex structures like ASTs, `plum-dispatch` can help you write more efficient and maintainable code.
+
+For more complex examples and advanced usage, check out the [plum-dispatch documentation](https://github.com/wesselb/plum).
diff --git a/pages/blog/working-with-boolean-expressions-in-python/index.ipynb b/pages/blog/working-with-boolean-expressions-in-python/index.ipynb
deleted file mode 100644
index f39017259..000000000
--- a/pages/blog/working-with-boolean-expressions-in-python/index.ipynb
+++ /dev/null
@@ -1,397 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "raw",
- "id": "4a31e70a-75c7-47aa-8793-b44efeaaa0b1",
- "metadata": {},
- "source": [
- "---\n",
- "title: \"Working with Boolean Expressions in Python\"\n",
- "slug: \"working-with-boolean-expressions-in-python\"\n",
- "date: 2024-01-31\n",
- "authors: [\"Ivan Ogasawara\"]\n",
- "tags: [\"boolean expressions\", \"boolean\", \"python\"]\n",
- "categories: [\"devops\", \"automation\", \"python\"]\n",
- "description: |\n",
- " Boolean logic is a crucial component in many programming tasks, especially\n",
- " in searching and querying data. In this tutorial, we'll explore how to use boolean.py,\n",
- " a Python library, for handling Boolean expressions. \n",
- " We'll apply it to medical symptom data as an illustrative example.\n",
- "thumbnail: \"/header.png\"\n",
- "template: \"blog-post.html\"\n",
- "---"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "458e17dc-2853-49cd-9ad3-ecd0c617019c",
- "metadata": {},
- "source": [
- "# Working with Boolean Expressions in Python\n",
- "\n",
- "Boolean logic is a crucial component in many programming tasks, especially in searching and querying data. In this tutorial, we'll explore how to use `boolean.py`, a Python library, for handling Boolean expressions. We'll apply it to medical symptom data as an illustrative example.\n",
- "\n",
- "## Introduction to `boolean.py`\n",
- "\n",
- "`boolean.py` is a Python library for creating, manipulating, and evaluating Boolean expressions. It's particularly useful in scenarios where you need to parse and evaluate expressions that represent conditions or filters, such as searching for specific symptoms in a medical database.\n",
- "\n",
- "## Installation\n",
- "\n",
- "First and foremost, you need to have `boolean.py` installed in your Python environment. You can easily install it using pip. Run the following command:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "id": "d231485b-1aef-45b6-99b6-f4d850238e16",
- "metadata": {},
- "outputs": [],
- "source": [
- "!pip install -q boolean.py"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "fefb2dd4-bfa3-4603-96e0-fd520c11d2da",
- "metadata": {},
- "source": [
- "## Basic Usage\n",
- "\n",
- "We begin with basic Boolean operations, which are the foundation of working with this library.\n",
- "\n",
- "### Creating Boolean Variables"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "ab358eda-ea90-4635-b6cc-ab8ece1a6439",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "(Symbol('fever'), Symbol('cough'))"
- ]
- },
- "execution_count": 2,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "import boolean\n",
- "\n",
- "from boolean.boolean import BooleanAlgebra\n",
- "\n",
- "# Create a Boolean algebra system\n",
- "algebra = BooleanAlgebra()\n",
- "\n",
- "# Define some symptoms as variables\n",
- "fever = algebra.Symbol('fever')\n",
- "cough = algebra.Symbol('cough')\n",
- "\n",
- "fever, cough"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "0225585b-5fdc-466b-806c-bb9f266d12b6",
- "metadata": {},
- "source": [
- "In this code, we import `BooleanAlgebra` from `boolean.py` and create an instance of it. We then define Boolean variables (symbols) for common symptoms. These symbols act as the basic units for our Boolean expressions.\n"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "47e97f30-9bfa-4cf2-9ead-829c7f75cb3b",
- "metadata": {},
- "source": [
- "### Basic Boolean Operations"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "id": "84a63a66-72e4-430f-b8c1-b27a472c8e02",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "fever&cough\n",
- "fever|cough\n",
- "~fever\n"
- ]
- }
- ],
- "source": [
- "# AND operation\n",
- "symptoms_and = fever & cough\n",
- "print(symptoms_and)\n",
- "\n",
- "# OR operation\n",
- "symptoms_or = fever | cough\n",
- "print(symptoms_or)\n",
- "\n",
- "# NOT operation\n",
- "no_fever = ~fever\n",
- "print(no_fever)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "8e68c8b3-fae1-4ffc-8bd8-2682f522ce8b",
- "metadata": {},
- "source": [
- "Here, we demonstrate basic Boolean operations: AND, OR, and NOT. These operations are essential in constructing more complex Boolean expressions. For example, `symptoms_and` represents a scenario where a patient has both fever and cough."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "183fe7e0-acb6-48dc-b0be-020f7dc51aee",
- "metadata": {},
- "source": [
- "## Advanced Expressions\n",
- "\n",
- "Now, let's create more complex expressions that could simulate queries for medical symptoms.\n",
- "\n",
- "### Complex Expressions"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "id": "a777a904-405d-45cd-8323-bad8fb398c58",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "((fever|cough)&~headache)&fatigue\n"
- ]
- }
- ],
- "source": [
- "headache = algebra.Symbol('headache')\n",
- "fatigue = algebra.Symbol('fatigue')\n",
- "\n",
- "# Complex expression\n",
- "complex_symptoms = (fever | cough) & ~headache & fatigue\n",
- "print(complex_symptoms)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "931725d2-c48c-4c6c-974d-f9bb229ee12c",
- "metadata": {},
- "source": [
- "This complex expression can represent a more specific medical query. For instance, it could be used to find patients who have either fever or cough, do not have a headache, but are experiencing fatigue."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "724132e3-b4a1-44ee-ba6b-4c388685f3ce",
- "metadata": {},
- "source": [
- "### Evaluating Expressions\n",
- "\n",
- "We can evaluate these expressions with specific values to simulate checking a patient's symptoms against our criteria."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "id": "9a28ae95-012b-4c77-8329-5dcde7410bb2",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Does the patient match the criteria? (((1)|(0))&(~(0)))&(1) = True\n"
- ]
- }
- ],
- "source": [
- "# Define truthy and falsy symbols\n",
- "true = algebra.TRUE\n",
- "false = algebra.FALSE\n",
- "\n",
- "# Define complex expression\n",
- "complex_symptoms = (fever | cough) & ~headache & fatigue\n",
- "\n",
- "# Define a patient's symptoms using truthy and falsy symbols\n",
- "patient_symptoms = {fever: true, cough: false, headache: false, fatigue: true}\n",
- "\n",
- "# Substitute symbols in the expression with the corresponding patient symptoms\n",
- "substituted_expression = complex_symptoms.subs(patient_symptoms)\n",
- "\n",
- "# Evaluate the expression\n",
- "# The expression itself is the result since boolean.py does not evaluate to Python booleans\n",
- "result = substituted_expression\n",
- "\n",
- "print(\"Does the patient match the criteria?\", result, \"=\", result.simplify() == true)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "2e5d3c70-2750-4aa9-bdd2-a60a4203671b",
- "metadata": {},
- "source": [
- "In this example, we demonstrate how to evaluate a Boolean expression against a set of patient symptoms. We use `.subs()` to replace each symbol in our expression with the corresponding value (symptom presence) from `patient_symptoms`. The `.simplify()` method then evaluates this substituted expression to a Boolean value, indicating whether the patient's symptoms match our query criteria.\n"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "d2972b0a-635a-49cb-9527-1d265b43d2bd",
- "metadata": {},
- "source": [
- "## Parsing Expressions from Strings\n",
- "\n",
- "Lastly, we explore parsing Boolean expressions from strings, a powerful feature for dynamic expression construction.\n",
- "\n",
- "### Parsing Example"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "id": "ff5f2bfb-05cb-4cf5-8b13-23e0ad6de5e8",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "parsed expression: (fever|cough)&~headache&fatigue\n",
- "Does the patient match the criteria? True\n"
- ]
- }
- ],
- "source": [
- "expression_string = \"(fever | cough) & ~headache & fatigue\"\n",
- "\n",
- "# Parse the expression from string\n",
- "parsed_expression = algebra.parse(expression_string)\n",
- "\n",
- "# Display the parsed expression\n",
- "print(\"parsed expression:\", parsed_expression)\n",
- "\n",
- "# Evaluate with the same patient symptoms\n",
- "result = parsed_expression.subs(patient_symptoms)\n",
- "print(f\"Does the patient match the criteria? {result.simplify() == true}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "618bb340-10f6-44ea-82b1-869a7c090da0",
- "metadata": {},
- "source": [
- "Parsing expressions from strings is extremely useful when you need to construct Boolean expressions dynamically, such as from user inputs or configuration files. In this example, we parse a string representing a Boolean expression and then evaluate it as before."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "id": "d452b111-c9fc-4566-8af8-bf552b7184f3",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[EE] Unknown token for token: \"\"\" at position: 9\n"
- ]
- }
- ],
- "source": [
- "expression_string = '(fever | \"blood cough\") & ~headache & fatigue'\n",
- "\n",
- "# Parse the expression from string\n",
- "try:\n",
- " parsed_expression = algebra.parse(expression_string)\n",
- "except boolean.ParseError as e:\n",
- " print(\"[EE]\", str(e))"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "4f042b9c-18f6-4955-9dcf-acb7ef9e3197",
- "metadata": {},
- "source": [
- "The string parser doesn't work with complex strings directly, but creating a manual symbol for the disease works fine."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "id": "ff396a7c-f69d-4058-a219-c196d8c4936a",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "================================================================================\n",
- "patient without fever\n",
- "Does the patient match the criteria? False\n",
- "================================================================================\n",
- "patient with all symptoms\n",
- "Does the patient match the criteria? True\n"
- ]
- }
- ],
- "source": [
- "blood_cough = boolean.Symbol(\"blood cough\")\n",
- "\n",
- "chest_infection = blood_cough & fever\n",
- "\n",
- "print(\"=\" * 80)\n",
- "print(\"patient without fever\")\n",
- "chest_infection_patient_symptoms = {blood_cough: true, fever: false}\n",
- "result = chest_infection.subs(chest_infection_patient_symptoms)\n",
- "print(f\"Does the patient match the criteria? {result.simplify() == true}\")\n",
- "\n",
- "print(\"=\" * 80)\n",
- "print(\"patient with all symptoms\")\n",
- "chest_infection_patient_symptoms = {blood_cough: true, fever: true}\n",
- "result = chest_infection.subs(chest_infection_patient_symptoms)\n",
- "print(f\"Does the patient match the criteria? {result.simplify() == true}\")"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "85dd008d-61ca-408c-9928-7cee4029b654",
- "metadata": {},
- "source": [
- "## Conclusion\n",
- "\n",
- "Throughout this tutorial, we have explored how to use `boolean.py` for handling and evaluating Boolean expressions in Python. By starting from basic operations and moving to parsing expressions from strings, we've covered a range of functionalities provided by this library. While we focused on a medical context, the principles and methods are broadly applicable across different domains."
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3 (ipykernel)",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.11.7"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/pages/blog/working-with-boolean-expressions-in-python/index.md b/pages/blog/working-with-boolean-expressions-in-python/index.md
index 9001e500a..507130a0d 100644
--- a/pages/blog/working-with-boolean-expressions-in-python/index.md
+++ b/pages/blog/working-with-boolean-expressions-in-python/index.md
@@ -13,31 +13,41 @@ description: |
thumbnail: "/header.png"
template: "blog-post.html"
---
+
# Working with Boolean Expressions in Python
-Boolean logic is a crucial component in many programming tasks, especially in searching and querying data. In this tutorial, we'll explore how to use `boolean.py`, a Python library, for handling Boolean expressions. We'll apply it to medical symptom data as an illustrative example.
+Boolean logic is a crucial component in many programming tasks,
+especially in searching and querying data. In this tutorial, we’ll
+explore how to use `boolean.py`, a Python library, for handling Boolean
+expressions. We’ll apply it to medical symptom data as an illustrative
+example.
## Introduction to `boolean.py`
-`boolean.py` is a Python library for creating, manipulating, and evaluating Boolean expressions. It's particularly useful in scenarios where you need to parse and evaluate expressions that represent conditions or filters, such as searching for specific symptoms in a medical database.
+`boolean.py` is a Python library for creating, manipulating, and
+evaluating Boolean expressions. It’s particularly useful in scenarios
+where you need to parse and evaluate expressions that represent
+conditions or filters, such as searching for specific symptoms in a
+medical database.
## Installation
-First and foremost, you need to have `boolean.py` installed in your Python environment. You can easily install it using pip. Run the following command:
-
+First and foremost, you need to have `boolean.py` installed in your
+Python environment. You can easily install it using pip. Run the
+following command:
-```python
+``` python
!pip install -q boolean.py
```
## Basic Usage
-We begin with basic Boolean operations, which are the foundation of working with this library.
+We begin with basic Boolean operations, which are the foundation of
+working with this library.
### Creating Boolean Variables
-
-```python
+``` python
import boolean
from boolean.boolean import BooleanAlgebra
@@ -52,30 +62,16 @@ cough = algebra.Symbol('cough')
fever, cough
```
+ (Symbol('fever'), Symbol('cough'))
-
-
-- OUTPUT - -
-
-
-Processing integer: 123
-Processing string: abc
-Visited StringNode with value: Hello
-Visited NumberNode with value: 456
-
-
-
-
-
-
-
-
-In this code, we import `BooleanAlgebra` from `boolean.py` and create an instance of it. We then define Boolean variables (symbols) for common symptoms. These symbols act as the basic units for our Boolean expressions.
-
+In this code, we import `BooleanAlgebra` from `boolean.py` and create an
+instance of it. We then define Boolean variables (symbols) for common
+symptoms. These symbols act as the basic units for our Boolean
+expressions.
### Basic Boolean Operations
-
-```python
+``` python
# AND operation
symptoms_and = fever & cough
print(symptoms_and)
@@ -89,31 +85,23 @@ no_fever = ~fever
print(no_fever)
```
-- OUTPUT - -
-
-
-(Symbol('fever'), Symbol('cough'))
-
-
-
-
+ fever&cough
+ fever|cough
+ ~fever
-Here, we demonstrate basic Boolean operations: AND, OR, and NOT. These operations are essential in constructing more complex Boolean expressions. For example, `symptoms_and` represents a scenario where a patient has both fever and cough.
+Here, we demonstrate basic Boolean operations: AND, OR, and NOT. These
+operations are essential in constructing more complex Boolean
+expressions. For example, `symptoms_and` represents a scenario where a
+patient has both fever and cough.
## Advanced Expressions
-Now, let's create more complex expressions that could simulate queries for medical symptoms.
+Now, let’s create more complex expressions that could simulate queries
+for medical symptoms.
### Complex Expressions
-
-```python
+``` python
headache = algebra.Symbol('headache')
fatigue = algebra.Symbol('fatigue')
@@ -122,27 +110,18 @@ complex_symptoms = (fever | cough) & ~headache & fatigue
print(complex_symptoms)
```
-- OUTPUT - -
-
-
-fever&cough
-fever|cough
-~fever
-
-
-
-
-
+ ((fever|cough)&~headache)&fatigue
-This complex expression can represent a more specific medical query. For instance, it could be used to find patients who have either fever or cough, do not have a headache, but are experiencing fatigue.
+This complex expression can represent a more specific medical query. For
+instance, it could be used to find patients who have either fever or
+cough, do not have a headache, but are experiencing fatigue.
### Evaluating Expressions
-We can evaluate these expressions with specific values to simulate checking a patient's symptoms against our criteria.
-
+We can evaluate these expressions with specific values to simulate
+checking a patient’s symptoms against our criteria.
-```python
+``` python
# Define truthy and falsy symbols
true = algebra.TRUE
false = algebra.FALSE
@@ -161,33 +140,25 @@ substituted_expression = complex_symptoms.subs(patient_symptoms)
result = substituted_expression
print("Does the patient match the criteria?", result, "=", result.simplify() == true)
-
```
-- OUTPUT - -
-
-
-((fever|cough)&~headache)&fatigue
-
-
-
-
-
-
-In this example, we demonstrate how to evaluate a Boolean expression against a set of patient symptoms. We use `.subs()` to replace each symbol in our expression with the corresponding value (symptom presence) from `patient_symptoms`. The `.simplify()` method then evaluates this substituted expression to a Boolean value, indicating whether the patient's symptoms match our query criteria.
+ Does the patient match the criteria? (((1)|(0))&(~(0)))&(1) = True
+In this example, we demonstrate how to evaluate a Boolean expression
+against a set of patient symptoms. We use `.subs()` to replace each
+symbol in our expression with the corresponding value (symptom presence)
+from `patient_symptoms`. The `.simplify()` method then evaluates this
+substituted expression to a Boolean value, indicating whether the
+patient’s symptoms match our query criteria.
## Parsing Expressions from Strings
-Lastly, we explore parsing Boolean expressions from strings, a powerful feature for dynamic expression construction.
+Lastly, we explore parsing Boolean expressions from strings, a powerful
+feature for dynamic expression construction.
### Parsing Example
-
-```python
+``` python
expression_string = "(fever | cough) & ~headache & fatigue"
# Parse the expression from string
@@ -201,24 +172,15 @@ result = parsed_expression.subs(patient_symptoms)
print(f"Does the patient match the criteria? {result.simplify() == true}")
```
-- OUTPUT - -
-
-
-Does the patient match the criteria? (((1)|(0))&(~(0)))&(1) = True
-
-
-
-
-
-
-Parsing expressions from strings is extremely useful when you need to construct Boolean expressions dynamically, such as from user inputs or configuration files. In this example, we parse a string representing a Boolean expression and then evaluate it as before.
+ parsed expression: (fever|cough)&~headache&fatigue
+ Does the patient match the criteria? True
+Parsing expressions from strings is extremely useful when you need to
+construct Boolean expressions dynamically, such as from user inputs or
+configuration files. In this example, we parse a string representing a
+Boolean expression and then evaluate it as before.
-```python
+``` python
expression_string = '(fever | "blood cough") & ~headache & fatigue'
# Parse the expression from string
@@ -228,23 +190,12 @@ except boolean.ParseError as e:
print("[EE]", str(e))
```
-- OUTPUT - -
-
-
-parsed expression: (fever|cough)&~headache&fatigue
-Does the patient match the criteria? True
-
-
-
-
-
-
-The string parser doesn't work with complex strings directly, but creating a manual symbol for the disease works fine.
+ [EE] Unknown token for token: """ at position: 9
+The string parser doesn’t work with complex strings directly, but
+creating a manual symbol for the disease works fine.
-```python
+``` python
blood_cough = boolean.Symbol("blood cough")
chest_infection = blood_cough & fever
@@ -262,24 +213,18 @@ result = chest_infection.subs(chest_infection_patient_symptoms)
print(f"Does the patient match the criteria? {result.simplify() == true}")
```
-- OUTPUT - -
-
-
-[EE] Unknown token for token: """ at position: 9
-
-
-
-
-
+ ================================================================================
+ patient without fever
+ Does the patient match the criteria? False
+ ================================================================================
+ patient with all symptoms
+ Does the patient match the criteria? True
## Conclusion
-Throughout this tutorial, we have explored how to use `boolean.py` for handling and evaluating Boolean expressions in Python. By starting from basic operations and moving to parsing expressions from strings, we've covered a range of functionalities provided by this library. While we focused on a medical context, the principles and methods are broadly applicable across different domains.
+Throughout this tutorial, we have explored how to use `boolean.py` for
+handling and evaluating Boolean expressions in Python. By starting from
+basic operations and moving to parsing expressions from strings, we’ve
+covered a range of functionalities provided by this library. While we
+focused on a medical context, the principles and methods are broadly
+applicable across different domains.
\ No newline at end of file
diff --git a/pages/blog/working-with-boolean-expressions-in-python/index.qmd b/pages/blog/working-with-boolean-expressions-in-python/index.qmd
new file mode 100644
index 000000000..7e2420685
--- /dev/null
+++ b/pages/blog/working-with-boolean-expressions-in-python/index.qmd
@@ -0,0 +1,218 @@
+---
+title: "Working with Boolean Expressions in Python"
+slug: "working-with-boolean-expressions-in-python"
+date: 2024-01-31
+authors: ["Ivan Ogasawara"]
+tags: ["boolean expressions", "boolean", "python"]
+categories: ["devops", "automation", "python"]
+description: |
+ Boolean logic is a crucial component in many programming tasks, especially
+ in searching and querying data. In this tutorial, we'll explore how to use boolean.py,
+ a Python library, for handling Boolean expressions.
+ We'll apply it to medical symptom data as an illustrative example.
+thumbnail: "/header.png"
+template: "blog-post.html"
+format:
+ gfm:
+ variant: +yaml_metadata_block
+---
+# Working with Boolean Expressions in Python
+
+Boolean logic is a crucial component in many programming tasks, especially in searching and querying data. In this tutorial, we'll explore how to use `boolean.py`, a Python library, for handling Boolean expressions. We'll apply it to medical symptom data as an illustrative example.
+
+## Introduction to `boolean.py`
+
+`boolean.py` is a Python library for creating, manipulating, and evaluating Boolean expressions. It's particularly useful in scenarios where you need to parse and evaluate expressions that represent conditions or filters, such as searching for specific symptoms in a medical database.
+
+## Installation
+
+First and foremost, you need to have `boolean.py` installed in your Python environment. You can easily install it using pip. Run the following command:
+
+
+```python
+!pip install -q boolean.py
+```
+
+## Basic Usage
+
+We begin with basic Boolean operations, which are the foundation of working with this library.
+
+### Creating Boolean Variables
+
+
+```python
+import boolean
+
+from boolean.boolean import BooleanAlgebra
+
+# Create a Boolean algebra system
+algebra = BooleanAlgebra()
+
+# Define some symptoms as variables
+fever = algebra.Symbol('fever')
+cough = algebra.Symbol('cough')
+
+fever, cough
+```
+
+
+
+
+ (Symbol('fever'), Symbol('cough'))
+
+
+
+In this code, we import `BooleanAlgebra` from `boolean.py` and create an instance of it. We then define Boolean variables (symbols) for common symptoms. These symbols act as the basic units for our Boolean expressions.
+
+
+### Basic Boolean Operations
+
+
+```python
+# AND operation
+symptoms_and = fever & cough
+print(symptoms_and)
+
+# OR operation
+symptoms_or = fever | cough
+print(symptoms_or)
+
+# NOT operation
+no_fever = ~fever
+print(no_fever)
+```
+
+ fever&cough
+ fever|cough
+ ~fever
+
+
+Here, we demonstrate basic Boolean operations: AND, OR, and NOT. These operations are essential in constructing more complex Boolean expressions. For example, `symptoms_and` represents a scenario where a patient has both fever and cough.
+
+## Advanced Expressions
+
+Now, let's create more complex expressions that could simulate queries for medical symptoms.
+
+### Complex Expressions
+
+
+```python
+headache = algebra.Symbol('headache')
+fatigue = algebra.Symbol('fatigue')
+
+# Complex expression
+complex_symptoms = (fever | cough) & ~headache & fatigue
+print(complex_symptoms)
+```
+
+ ((fever|cough)&~headache)&fatigue
+
+
+This complex expression can represent a more specific medical query. For instance, it could be used to find patients who have either fever or cough, do not have a headache, but are experiencing fatigue.
+
+### Evaluating Expressions
+
+We can evaluate these expressions with specific values to simulate checking a patient's symptoms against our criteria.
+
+
+```python
+# Define truthy and falsy symbols
+true = algebra.TRUE
+false = algebra.FALSE
+
+# Define complex expression
+complex_symptoms = (fever | cough) & ~headache & fatigue
+
+# Define a patient's symptoms using truthy and falsy symbols
+patient_symptoms = {fever: true, cough: false, headache: false, fatigue: true}
+
+# Substitute symbols in the expression with the corresponding patient symptoms
+substituted_expression = complex_symptoms.subs(patient_symptoms)
+
+# Evaluate the expression
+# The expression itself is the result since boolean.py does not evaluate to Python booleans
+result = substituted_expression
+
+print("Does the patient match the criteria?", result, "=", result.simplify() == true)
+
+```
+
+ Does the patient match the criteria? (((1)|(0))&(~(0)))&(1) = True
+
+
+In this example, we demonstrate how to evaluate a Boolean expression against a set of patient symptoms. We use `.subs()` to replace each symbol in our expression with the corresponding value (symptom presence) from `patient_symptoms`. The `.simplify()` method then evaluates this substituted expression to a Boolean value, indicating whether the patient's symptoms match our query criteria.
+
+
+## Parsing Expressions from Strings
+
+Lastly, we explore parsing Boolean expressions from strings, a powerful feature for dynamic expression construction.
+
+### Parsing Example
+
+
+```python
+expression_string = "(fever | cough) & ~headache & fatigue"
+
+# Parse the expression from string
+parsed_expression = algebra.parse(expression_string)
+
+# Display the parsed expression
+print("parsed expression:", parsed_expression)
+
+# Evaluate with the same patient symptoms
+result = parsed_expression.subs(patient_symptoms)
+print(f"Does the patient match the criteria? {result.simplify() == true}")
+```
+
+ parsed expression: (fever|cough)&~headache&fatigue
+ Does the patient match the criteria? True
+
+
+Parsing expressions from strings is extremely useful when you need to construct Boolean expressions dynamically, such as from user inputs or configuration files. In this example, we parse a string representing a Boolean expression and then evaluate it as before.
+
+
+```python
+expression_string = '(fever | "blood cough") & ~headache & fatigue'
+
+# Parse the expression from string
+try:
+ parsed_expression = algebra.parse(expression_string)
+except boolean.ParseError as e:
+ print("[EE]", str(e))
+```
+
+ [EE] Unknown token for token: """ at position: 9
+
+
+The string parser doesn't work with complex strings directly, but creating a manual symbol for the disease works fine.
+
+
+```python
+blood_cough = boolean.Symbol("blood cough")
+
+chest_infection = blood_cough & fever
+
+print("=" * 80)
+print("patient without fever")
+chest_infection_patient_symptoms = {blood_cough: true, fever: false}
+result = chest_infection.subs(chest_infection_patient_symptoms)
+print(f"Does the patient match the criteria? {result.simplify() == true}")
+
+print("=" * 80)
+print("patient with all symptoms")
+chest_infection_patient_symptoms = {blood_cough: true, fever: true}
+result = chest_infection.subs(chest_infection_patient_symptoms)
+print(f"Does the patient match the criteria? {result.simplify() == true}")
+```
+
+ ================================================================================
+ patient without fever
+ Does the patient match the criteria? False
+ ================================================================================
+ patient with all symptoms
+ Does the patient match the criteria? True
+
+
+## Conclusion
+
+Throughout this tutorial, we have explored how to use `boolean.py` for handling and evaluating Boolean expressions in Python. By starting from basic operations and moving to parsing expressions from strings, we've covered a range of functionalities provided by this library. While we focused on a medical context, the principles and methods are broadly applicable across different domains.
diff --git a/pages/funding.json b/pages/funding.json
index 2e4900277..14a213e17 100644
--- a/pages/funding.json
+++ b/pages/funding.json
@@ -94,7 +94,7 @@
"name": "ArtBox",
"description": "ArtBox processes multimedia files, including speech-to-text, text-to-speech, and other media workflows.",
"webpageUrl": {
- "url": "https://mediatoolbox-org.github.io/artbox/"
+ "url": "https://mediatoolbox-org.github.io/artbox"
},
"repositoryUrl": {
"url": "https://github.com/mediatoolbox-org/artbox"
diff --git a/pages/opportunities/gsoc/project-ideas/index.md b/pages/opportunities/gsoc/project-ideas/index.md
index 4eb748585..a2f8fb033 100644
--- a/pages/opportunities/gsoc/project-ideas/index.md
+++ b/pages/opportunities/gsoc/project-ideas/index.md
@@ -44,8 +44,7 @@ touch with them directly if you have any inquiries._
learning environment that goes beyond traditional online education.
- **Project WEB Page**: - OUTPUT - -
-
-
-================================================================================
-patient without fever
-Does the patient match the criteria? False
-================================================================================
-patient with all symptoms
-Does the patient match the criteria? True
-
-
-
-