DEV Community: Leonardo Cumplido

My experience in Summer of Bitcoin 2022

Leonardo Cumplido — Thu, 25 Aug 2022 04:29:00 +0000

Hi! I’m Leonardo Cumplido

Since May 23rd, 2022, till August 15th I worked as a data science assistant in LN Capital, a startup that built Torq, a capital management software for routing nodes. This opportunity was possible thanks to Summer of Bitcoin (SoB) internship program. SoB is

a global, online summer internship program focused on introducing university students to bitcoin open-source development and design.

SoB has come to an end, so I'm wrapping up my experience in the program in this post. I hope you like it, and that it encourages you in some way to apply maybe next year 😃

Admission process

When I got to know SoB, thanks to Adi, the SoB founder, I didn’t really know much about Bitcoin, and nothing about the Lightning Network (LN). I decided it was a good idea to explore the different organizations and projects I could apply to.
At the very beginning, I was kind of lost. I didn’t really know where to start, because almost every project required some skills I didn’t have. Then, I found the right project for me: Routing node research and automation, from LN Capital 🚀

The reason I liked this project

Currently, I’m studying a Bachelor of Science in data science in Tecnológico de Monterrey 🐏. I’d love to become a data scientist because I like how you can find solutions to business problems, and how you can predict future behaviors, based on data, by manipulating that data with smart algorithms that come from a pure mathematical background 😁

The project from LN Capital fitted my interests and current skills at that moment. The requirements where to know Python 🐍, have experience with Jupyter and Pandas, and have basic analytical skills and some experience cleaning and wrangling data into useful features 💻. During my winter break I took a data science course in Coursera platform, and also read some books about Pandas library. So, I had just acquired those skills. It fitted like a glove.

Competency test

Before writing my project proposal, a competency test was asked to be done 😨. It involved some basic data manipulation to calculate some things regarding the LN. Although the coding part didn’t bring trouble to me, learning about the LN did. As I mentioned already, I knew nothing about it then, so I began to learn what it is, what it is used for, why it’s a game changer in the Bitcoin ecosystem, and more technical stuff around how it works.

Project proposal

After completing the competency test and getting good feedback, I began my project proposal. It is titled Clustering and outlier detection for tagging, automation and alerts, and you can find it here: Project proposal. The main objective was to produce interesting articles about the procedures, findings, and insights obtained from the data analysis.

Henrik Skogstrøm, the CEO of LN Capital and the mentor of the project, liked my proposal, and after some days, I was told by him that I was accepted as a SoB intern at LN Capital ⚡ ⚡ ⚡

First steps

The internship began on May 23rd. At that time, I was still attending classes at my university, so the first month of the program was a little chaotic for me. During that month I kept learning about the LN, specifically about routing nodes, their channels, and the transactions behavior in the network. I was handed 5 databases containing data from a real routing node, as well as data representing all the transactions that node has participated in. I began by exploring the data to create new features involving the channels behavior of the node. These features were useful for a more concise analysis, and the writing of an article.

One thing I loved about the SoB program is that they didn’t just connect us with the organizations and then left us alone, but they also offered weekly seminars about Bitcoin. So, with LN Capital I got to know the LN, and with the weekly seminars I learned about Bitcoin in a more deeply way than I could imagine learning by myself.

When my courses were over, I had plenty of time to concentrate on my work and really get the most out of the internship.

Clustering task and first article written

This was for me probably the most interesting work I did during SoB. It consisted of searching for a suitable clustering algorithm to group the channels of our routing node based on their features similarities. I liked this task for several reasons:

I was able to explore and apply different ML models to a dataset.
After selecting the appropriate ML model, I managed to visualize the clusters in a way that helped me understand why the model was giving these outputs.
Previous work was retaken to help gain insights from the clusters.

I wrote a first article, titled Increasing our lightning node activity, explaining the whole process, the whys of the analysis, the outcomes, and the conclusions.

I published the article in my LinkedIn profile, where I reached 1,764 impressions, and in my Twitter account, where I reached 5,737 impressions. If you want to read the article, you can find it here: Increasing our lightning node activity.

The rest of my work

After writing the mentioned article, the middle evaluation period began. I uploaded all my work, in form of Jupyter notebooks, to a repository in my GitHub account. I passed the evaluation, and this gave me confidence to keep on working with the same quality as the last task.

From then onwards, I worked on creating interactive visualizations of payment routes. First, I used Altair library for building a cool way of visualizing one or more payment attempts, whether they’ve been successful or not. This is useful because you can see which paths are taken more often, which are being the most successful ones, which channels charge the most fees, which nodes might not be reliable based on their forwarding behavior, etc. I wrote an article on this here: Visualizing Lightning Network payments.

Then, Henrik asked me to search for a way of visualizing the potential paths when rebalancing a channel. We find this interesting because it would be great to have a tool that helps node owners visualize potential paths to rebalance their channels. With it, they could select which paths to probe by filtering and sorting the data of the different possible routes. You can find the article I wrote about this here: Visualizing Lightning Network payments.

Overall experience

I loved Summer of Bitcoin. I had the opportunity to begin a journey working with an emerging technology like is Bitcoin. I really like what LN Capital is building with Torq, and I really enjoyed my role with them during this internship. I learned a lot from these months, and I think I couldn’t have a better first experience working in a real project as someone analyzing data and extracting important features from it, to gain insights that help a user make better decisions with its routing node.

I’m incredibly grateful with Henrik, my mentor. He had been supportive the whole duration of the internship. What I’ve done wouldn’t have been possible without his mentoring.

Now that I got to know these technologies, I'm eager to learn more about them, and to continue this journey. Thanks SoB and LN Capital for giving me the opportunity to learn and grow as a developer, and as a person.

How can you contribute to LN Capital

You can start by joining their Telegram group at ln.capital/telegram, and asking anything there. It's a very active group and Henrik is always solving doubts regarding Torq.
You could also DM them in their Twitter account.

Those could be the first steps in reaching LN Capital. If you're a node owner, then you could try Torq, and point all the things you consider are the best features, the weakest features that can be improved, and the things that are not still there that could be very useful for managing your node's data. All kind of input is welcomed and encouraged. Remember that Torq is a product in development, so having opinions on the product is very good for it to be improved.

On the other hand, if you are a developer and want to contribute to an open-source project, you could visit Torq's repository on GitHub and start exploring the way it's built.

The main programming languages used for Torq are TypeScript and Go. Check it out!

Visualizing potential paths for rebalancing channels in the Lightning Network

Leonardo Cumplido — Mon, 15 Aug 2022 16:14:30 +0000

Once again, working with LN Capital under Summer of Bitcoin 2022 program, we were able to produce interesting visualizations for selecting potential paths for a payment in the Lightning Network (LN).

Recall that the LN is a payment channel network (PCN) built on top of Bitcoin. If you have a LN node, then you can send, receive, and forward payments through the network. Here, we are going to focus on sending payments.

When you send a payment to another node, data gets back to you when the payment rather succeeds or fails. You are able to see the route of the payment, the fees in each channel, and in which channel, if any, the payment failed.

You can also send a payment to yourself for rebalancing purposes. Rebalancing is needed when the inbound and outbound capacities of a channel become unbalanced. One way to rebalance your channels is creating a circular route, i.e. sending a payment from your node back to your node.

Figure 1: Circular route rebalancing. Image taken from Matering the Lightning Network book, p. 139.

It would be great to have a tool that helps node owners visualize potential paths to rebalance their channels. With it, they could select which paths to probe by filtering and sorting the data of the different possible routes.

Visualization tool

This time, we decided the best way to easily visualize this was with interactive tables, where you can filter, sort, and select data to display the full route you're interested in.

The tool consists of 4 tables. The first one is for selecting a node you want to include in the rebalancing (central node), and the channel you want to send the payment from. The second table is for selecting a route that starts from the channel you selected before, and ends in the central node. Third one is for selecting the channel where you want to receive the payment. Finally, the fourth table is for selecting a route from the central node to your node, ending in the channel you selected right before.

For this task, the 3 main libraries used were networkx, pandas, and dash. network was used for computing the simple paths from one node to the rest in the network. pandas was used for creating the suitable dataframes, that later were converted into interactive tables using dash.

First table

Figure 2: Table 1 for selecting central node and outgoing channel.

This table has 3 columns:

source: to choose your node
central_node: to choose a certain node you want to include in the rebalancing path
Channel_out: to choose the channel you want to send the payment from.

Second table

Figure 3: Table 2 for selecting a path to the central node.

This table is more interesting. All columns support filtering and sorting. It's an easy way to see which routes are cheaper, which take fewer hops, and which have a higher overall capacity.

Here is part of the code to build this table:

@app.callback(
    Output('secondtable-container', 'children'),
    Input('first-table', 'selected_row_ids'),
)
def make_second_table(selected_rows):
    if selected_rows is None:
        source_central, channel_out = [], []
    else:
        rows = [row.split(' -> ') for row in selected_rows]
        source_central = [row[0] for row in rows]
        channel_out = [row[1] for row in rows]

    masks = (grouped_routes.peers.isin(source_central) & grouped_routes.channel_out.isin(channel_out))
    second_dff = grouped_routes[masks]

    return html.Div([
        dash_table.DataTable(
            id='second-table',
            columns=[
                {'name': i, 'id': i, 'deletable': True} for i in second_dff.columns
                if i != 'id' and i != 'channel_out'
            ],
            data=second_dff.to_dict('records'),
            editable=False, # cells are not editable
            filter_action='native', # filter by entering text in the input box
            sort_action='native',
            sort_mode='multi',
            row_selectable='single',  
            page_action='native',
            page_current=0,
            page_size=10,
        ),
        html.Div(id='thirdtable-container'),  
    ])

Third table

Figure 4: Table 3 for selecting the channel where you want to receive the payment.

The third table is similar to the first one. It's only purpose is showing the channels you have, in order to select the one where you want to receive the payment, hence completing the circular path.

Fourth table

Figure 5: Table 4 for selecting the route back to your node.

The final table is this one, similar to the second one but for selecting an appropriate route, based on your criteria, to complete the rebalancing path.

After selecting a row, a new container displays the whole information of the circular path, like this:
Figure 6: The aggregated data of the whole path.

Here is a full demonstration of the tables functionality:

The value of having a tool like this is being tested. Feel free to leave in the comments whether this would help you in some way with your lightning node.

Visualizing Lightning Network payments

Leonardo Cumplido — Mon, 25 Jul 2022 13:38:00 +0000

As Andreas M. Antonopoulos, Olaoluwa Osuntokun, and René Pickhardt explain in Matering the Lightning Network (2021) book:

The Lightning Network (LN) is a second layer peer-to-peer network that allows us to make Bitcoin [near-instantaneous] payments "off-chain".

If you have a LN node, then you can send, receive and route payments through the network. When you send a payment to a node you don't have a channel with, then a path is found to route the payment. Multiple paths are tried in a payment attempt until one succeeds or all fail. All payment attempts come with data related to the different routes the payment tried in order to get to its destination.

Being able to analyse this data might lead to valuable insights around what channels/nodes perform well and are reliable, to whom it might be okay to create a channel with, which directions present more activity, the effects of the chosen fee limit in a payment attempt, etc.

Working alongside LN Capital, under Summer of Bitcoin 2022 internship, mentored by Henrik Skogstrøm, we were able to produce valuable visualizations that represent payment attempts in the LN. All data used for this task is real.

Visualizing payments with networkx

Undirected graph

One tool that's often used for graph analysis and visualization with python is networkx. Networkx provides built-in algorithms for setting the position of the nodes for when the network is displayed. Let's look at two payment attempts drawn using networkx, and go through the elements of both charts.

The code for displaying the following figures goes something like this:

plt.figure(figsize=(10,10))

# G is our graph. It already has the edges and nodes attributes.
widths = np.array([w for *_, w in G.edges.data('weight')])
colors = np.array(['tab:red' if w >=1 else 'black' for *_, w in G.edges.data('fail_weight') ])

pos = nx.spring_layout(G, seed=7)  # positions for all nodes - seed for reproducibi

# nodes
nx.draw_networkx_nodes(G, pos, node_size=600, alpha=0.7)

# edges
nx.draw_networkx_edges(G, pos, width=(widths+0.1)*10, edge_color=colors)  

# labels
nx.draw_networkx_labels(G, pos, font_size=10, font_family="sans-serif")

ax = plt.gca()
ax.margins(0.08)
plt.axis("off")
plt.tight_layout()

The source node is hidden, and the destination node is WalletOfSatoshi.com

Figure 1: Failed payment attempt

Figure 2: Successful payment attempt

Some things you may notice at first glance:

The edges, henceforth we'll call them channels, are coloured differently: they can be black, green or red.
The channels thickness varies.
The position of the nodes from both charts has nothing to do with each other.
In general, both look messy and it's difficult to interpret what they supposedly show.

The color of the channels isn't random. If a payment fails in that given hop, that channel is coloured in red. If a payment succeeds, the successful route is coloured in green. Otherwhise, the channel must be black.

The channels width also represents data from the payment. The more a channel is used in a payment attempt, the thicker that channel will be.

We want to achieve the following: combine different payment attempts aggregating their data, and visually seeing this information without struggle. So far, if we do this adapting the code used to display the above figures, it's impossible to search for insights.

Figure 3: Many payment attempts aggregated in one visualization

This tells us nothing. There're a lot of improvements to make the visualization readable and valuable, starting with the nodes position.

Directed graph

Let's improve the payments visual representation by:

Adding the source node (our node).
Colouring the source and destination nodes in another color than the rest of the nodes.
Placing the nodes better to enhance visualization of the routes.

As for the last point, let's compare two graph structures when the nodes are well positioned.

Figure 4: Undirected graph structure

Figure 5: Directed graph structure with curved edges

Figure 4 shows an undirected graph. I've seen that for other payment attempts, some edges overlaped, making it difficult to follow the routes in those payments. That's why a directed graph with curved edges is better for the visualization.

Improved visualization:

Figure 6: More readable payment attempt visualization

Now, let's add the channel features Figures 1 and 2 show, plus these ones:

If a channel is red, meaning the payment failed there, and there're still channels in the route to get to the destination, those channels should be coloured in blue. This highlights what channels were never attempted to route the payment.
Place channel average fees below each channel. Showing this information might lead to useful insights regarding channels behaviour.
Set node size based on the number of times a node has been in a route.

Figure 7: Visual representation of a payment attempt

This looks way better. Now you can clearly see who sent the payment, who the destination was, which routes the payment tried, where in those routes the payment failed, which channels were never tried because of a previous failure, which nodes and channels participated the most in this payment attempt, and the fee amount in msats each channel was going to charge if the payment was to be succesful.

The code for displaying Figures 6 and 7 is:

def show_graph_of_routes(g, node_positions, nodes_colors, widths=1, 
                         edges_colors='black', nodes_size=700, draw_fee_labels=False,
                         fee_labels=None):
    plt.figure(figsize=(12, 9))
    # drawing nodes
    nx.draw_networkx_nodes(g, pos=node_positions, node_size=nodes_size, 
                           node_color=nodes_colors, alpha=0.5,
                           )
    # drawing edges
    nx.draw_networkx_edges(
        g, pos=node_positions, 
        connectionstyle="arc3,rad=-0.1",  # curve the edges
        width=widths,
        edge_color=edges_colors,
    )

    # labels
    nx.draw_networkx_labels(g, pos=node_positions, labels=nodes_labels,
                            font_size=5, font_family="sans-serif",
                            font_color='purple', verticalalignment='top')
    if draw_fee_labels:
        nx.draw_networkx_edge_labels(g, pos=node_positions, edge_labels=fee_labels,
                                 font_size=4, label_pos=0.35)

    _ = plt.title('Graph Representation of the routes attempted trying to pay an invoice', size=15)

Interactive visualization with Altair

We already have a nice way to display one payment attempt with networkx. What if we could visualize more payment attempts aggregated without loosing readability? Moreover, what if we could decide what payments, channels, or nodes to filter out based on their properties? In order to do this, we need to create an interactive visualization.

Altair is a data visualization tool for making interactive charts with Python. An advantaje to other visualization libraries is that you can produce visualizations with a minimal amount of code. The hard work is done previously cleaning the data and transforming it into a format that altair can understand (done with pandas).

Some main ideas to make an interactive visualization for the payment attempts:

Menu to select the payments to visualize.
Zoom in and out.
Panning.
Drag the pointer on top of a node to see the node alias, number of times it's been part of a route, and number of failures.
Drag the pointer on top of a channel to see the average fee of the channel, number of times it's been part of a route, number of failures, and the number of times it's been part of a successful route.
Filtering by dragging:
- Brush to select channels based on their payment activity.
- Brush to select nodes based on their payment activity.

This is how the visualization looks:

Figure 8: How the interactive visualization looks like

Characteristics of the interactive visualization

Zooming and panning

Information displayed when placing the cursor on top of a node or a channel

Filter by dragging

You can interact with the two charts at the top, by holding and dragging the cursor to filter out channels or nodes based on how many times they've been part of a route.

Selecting multiple payments

The chart at the left is to select which payment/s you want to visualize. When selecting multiple payments, the channels and nodes information updates, based on the aggregated data.

There are more ideas we want to explore to look for things visually. Transforming data into visual representations of it is always the best way to understand it.

Any ideas are welcome :)

Ninth-week check in for PSF, GSoC 2021

Leonardo Cumplido — Wed, 18 Aug 2021 20:59:00 +0000

Hi! This is my ninth post of my GSoC 2021 series 😃

This week I did 3 things.

I fixed some details of my third milestone PRs. Also, I added the final exercise that was missing in the second challenge. This was pretty straightforward.
I reviewed the PRs of the other students.
I had to research about pytest-vcr, a plugin for managing VCR.py cassettes, and to implement it in 2 tests of the project. See its docs here

To implement pytest-vcrcorrectly, I needed to undestand what a decorator is, and what it does, because to use pytest-vcr tools I had to add decorators to the tests functions. In a nutshell, this was necessary for a couple of tests that make API calls because sometimes this APIs are not active. What pytest-vcr does is that the fisrt time a test is run, the request to a web page is made, and a .yaml file is generated with the information of that request. Next time the same test is run, there will not be a web request. Instead, the data will be returned from the .yaml file. This not only speeds up the tests, but makes them less error prone.

This week, I can't say I got stuck somewhere, because I didn't. However, I took more time than expected in the pytest-vcr thing.

Seventh-week check in for PSF, GSoC 2021

Leonardo Cumplido — Tue, 20 Jul 2021 15:58:48 +0000

Hi! This weeks check in may be short but interesting. Firstly, I was given great news: I passed the first evaluation 😃. Now, the second period begins, and I plan to keep my good workflow ongoing.

What did I do this week?

I focused on my third milestone. I made two challenges for the course. The first one is a called Hangman challenge, and it is about creating a hangman game. The hard thing was coding its web test. I'll explain this later. The second challenge is called Pergamino challenge, and it is about deciphering a parchment with Python code. This was very straightforward, even its web test.

Did I get stuck anywhere?

Yes. The playwright test for the hangman challenge was tricky. Interacting with the exercises of this challenge meant dealing with several dialog prompts. I already knew how to accept one dialog prompt:

page.on("dialog", lambda dialog: dialog.accept("sth"))

But I had trouble when more than one needed to be handled in the same test. By looking at playwrights documentation I found a solution. First, expect for the dialog event to appear on screen. Then, accept that single dialog once. This, translated to code, is:

with page.expect_event("dialog") as prompt1:
    page.once("dialog", lambda dialog: dialog.accept("sth"))
with page.expect_event("dialog") as prompt2:
    page.once("dialog", lambda dialog: dialog.accept("sth"))

What is coming up next?

I made two PRs this week. Both are regarding the new challenges. They are still awaiting review. So this week I will tackle the review suggestions, and will review my peers PRs.

Sixth-week blog post for PSF, GSoC 2021

Leonardo Cumplido — Tue, 13 Jul 2021 17:47:54 +0000

Welcome to my sixth blog post about my experience in Google Summer of Code (GSoC) 2021.

What am I working on

Last week I finished working with my second milestone. This is what I did. There is a lecture in the project called Hackeando con Pyhton that is supposed to teach how to access an API and retrieve information using pyhton. Before last week, this lecture had only one exercise because others were eliminated due to the APIs they used (They have changed a lot and they are no longer public). Now, this lecture has six new exercises.

You might know these two python modules to do HTTP requests: urllib and requests. For the new exercises I used both, mainly because I encountered a problem with Runestone and I had to change the python interpreter to solve this.

This week I will be working on my third milestone.

What have I struggled with this week?

I had trouble with the dumps method from the json module. For an exercise I needed to display on screen the json data retrieved from an API. In order to print it with indentation I passed the indent argument. Like this:

print(json.dumps(datos, indent=4))

However, it wasn't working.

What solutions have I found?

So, I was using requests module before this. I had to change the python interpreter to brython for some exercises, because in Brython json.dumps with the indent arg works just fine, but Brython doesn't support the requests module yet. This is why I changed to urllib. In the Brython's console, the output finally dislplayed nicely with indentation.

Fifth-week check-in for PSF, GSoC 2021

Leonardo Cumplido — Sun, 04 Jul 2021 20:15:24 +0000

It's been a month since the coding period started. The upcoming week in particular is important because it's the last week before the first evaluation period, meaning I have to deliver everything I've worked on for the past month.

What did I do this week?

I finally finished my first milestone. In total, for this milestone I opened 21 issues, and closed 16 so far. The missing 5 have linked pull requests (PRs) that are awaiting review.

For 2 lectures I had to use Brython for their exercises.

Brython is designed to replace Javascript as the scripting language for the Web. As such, it is a Python 3 implementation (you can take it for a test drive through a web console), adapted to the HTML5 environment, that is to say with an interface to the DOM objects and events.

I use Brython beacause the current python interpreter of Runestone is skulpt, and it doesn't support some python libraries that Brython does. So this past week I had to recall how Brython works. I had to read its documentation again, where I found the browser.timer module, which I found helpful.

Did I get stuck anywhere?

Not really. The Brython stuff took time to do, but I didn't feel stuck.

What is coming up next?

This fifth week I will be aware of my existing PRs in case the mentors suggest changes. Meanwhile, I'll continue with my second milestone.

Fourth-week blog post for PSF, GSoC 2021

Leonardo Cumplido — Mon, 28 Jun 2021 01:32:07 +0000

Once again, I'm writing this as part of my Google Summer of Code (GSoC) for Python Software Foundation (PSF). The third week has ended, and along with it I finished my first milestone... Or at least that's what I thought. Last post I told you I was ready to tackle my second milestone, however, I forgot some lectures need to be checked as well. So, I did start my second milestone, but I had to pause it. Let the questions begin.

What am I working on?

I worked on 2 different things. First, regarding my second milestone, I worked on two tickets. Before ellaborating on them, let me introduce you to what this milestone is about:
It consists of refactoring Facebook's API lesson. The expected outcome is to have created new exercises with other APIs, public ones so that no special requirements are asked for.

The 1st ticket was a piece of cake. I just had to debug a block of code that involved using Reddit API.
The 2nd one wasn't as easy. Here's why: I had to create 3 exercises from scratch involving TestDive API. Here's one of them:

import requests
import json

api_url = "https://tastedive.com/api/similar"
proxy = "https://cors.bridged.cc/"
parametros = {"q": "Coco", "limit": 5, "info": 1}

solicitud = requests.get(proxy + api_url, params=parametros)
datos = json.loads(solicitud.text)

resultados = len(datos["Similar"]["Results"])
print(f"resultados: {resultados}")

peliculas_similares = []
for peli in datos["Similar"]["Results"]:
    peliculas_similares.append(peli["Name"])

print(f"Pelis: {peliculas_similares} len: {len(peliculas_similares)}")

pixar = 0
for peli in datos["Similar"]["Results"]:
    for pal in peli["wTeaser"].split():
        if pal == "Pixar":
            pixar += 1

print(f"Pixar: {pixar}")

I also added unittest for automatic grading to it. Apart from that, I made a web test with playwright for this same exercise. I learned about page.keyboard from Playwright.

Keyboard provides an api for managing a virtual keyboard. The high level api is keyboard.type(text, **kwargs), which takes raw characters and generates proper keydown, keypress/input, and keyup events on your page.

Before this, to press a key or type something I used:

page.press("text=def remplazar_primer_caracter(s):", "Tab")
page.type(
    "text=def remplazar_primer_caracter(s):",
    "return s[0] + s[1:].replace(s[0], '*')",
)

Notice the first argument, which is the "selector", an element to tell playwright where to apply an event. Now, I just have to place the cursor where I want to start typing and, with the keyboard class, tell it what to do. For example:

page.click("#ac_l45_5 >> text=parametros = {}")
# Clear all code
page.keyboard.press("Control+A")
page.keyboard.press("Backspace")
# Type something
page.keyboard.type("Hello world")

The second thing I worked on was fixing 2 lectures.

What have I struggled with this week?

Once again, git gave me trouble. I don't know why, but git push and all its variants decided to not work anymore. Regarding python, my major problem was when I wanted to clear all code with playwright using the ctrl+A & backspace keys.

What solutions have I found?

For the git problem, I had to install GitHub Desktop to push my local commits to my remote repo. For playwright doubts, I checked its documentation and found the keyboard class.

This is all for now :)

Third-week check-in for GSoC 2021

Leonardo Cumplido — Wed, 23 Jun 2021 14:13:26 +0000

Hi! Today June 21 I begin my third week for GSoC 2021. I am loving this experience so far. Now, I'm going to answer 3 questions regarding my work last week, what I struggled with, and what I will focus on this week.

What did I do this week?

In my last post, I mentioned I was working on fixing the existing quizzes of the project. I kept doing that, and I finished. I started fixing some lectures. By fixing I mean:

Formatting all python code with black.
Changing static snippets to activecode.
Creating some exercises with automating grading using unit test
Creating some web tests (where needed), with playwright

I've already finished fixing 4 lectures. This week I made 8 PRs, some of which were proposing simple changes.

Did I get stuck anywhere?

Yes I did. As I've mentioned over the past posts, we use pytest-playwright as our web tester. I've been coding easy tests for the quizzes, and I thought that was enough. Until I got to program a test for a lecture that involved writing into a prompt box. I got stuck there beacause I didn't know playwright had a special way to deal with dialog prompts. So I had to search in their documentation for an answer, and I got one.
Here's the piece of code I was searching for:

    
        def test_TWP18_ac_5(page):
            # Deal with prompt box
            def handle_dialog(dialog):
                dialog.accept("una palabra")

           # Code to go to TWP18 page, do the exercise and run it.
                    
           # Fill prompt box
           page.on("dialog", handle_dialog)

What is coming up next?

Last Saturday (June 19), the team got together in a videocall to discuss what we've done so far and what is coming up. So, now that I've finished with the quizzes and the easy lectures, some of which are awaiting review, I will begin my second milestone. It consists on refactoring a lecture that involves accesing some APIs. My idea is to fix one existing exercise that uses Reddit API, and to create two exercises using two different public and easy to manipulate API's. Meanwhile, I'll continue searching for ways to make the SQL lecture work.

Second-week blog post for PSF, GSoC 2021

Leonardo Cumplido — Mon, 14 Jun 2021 23:22:17 +0000

Hi everyone! This is my second post for Google Summer of Code (GSoC) 2021. The coding period has started and so far my experience has been most enjoyable. As I stated in my first post, this week I began working on my first milestone, and I can say I've done wonderfully.

What am I working on?

This week, a fellow collaborator (Ybrahin) and I worked on fixing the existing python quizzes of the project Python para Zombis. We divided the number of quizzes each one would fix; I get to fix 7. From those, I've completed 5. So far, I've done 5 PR's, 4 of which have been merged into the master branch, and 1 awaiting review. Completing a quiz fix also involves making a web test with pytest-playwright for an exercise in that quiz. Moreover, this weekend I did some research about Runestone supporting SQL language. This is relevant to us because there is a lesson in the project that is currently in standby due to the sqlite3 python module used in there. To be clear, Runestone doesn't support that module, and that's why this lesson isn't working.

Do you remember I talked about flake8 in my first post? Well, Ybrahin introduced me to another tool to automate code formatting, named Black.

Black is the uncompromising Python code formatter.
Black makes code review faster by producing the smallest diffs possible.

What have I struggled with this week?

I had no bigger problems than trouble understanding git commands. I am still getting used to working with GitHub, and sometimes I don't know the exact sintax, nor the correct time to execute them. Regarding python, I haven't struggled.

What solutions have I found?

If any doubts come to me while programming I tend to do one of two things:

Ask my workmates and mentors.
Try to find an answer from Google.

Get tunned for the next post.

First-week check-in for PSF, GSoC 2021

Leonardo Cumplido — Mon, 07 Jun 2021 19:00:04 +0000

Hi! I'm Leo, and I'm glad to share that I was accepted into Google Summer of Code (GSoC) 2021,

a global program focused on bringing more student developers into open source software development.

On May 17th I received the great news: Python Argentina, the organization I applied to, under the umbrella of Python Software Foundation (PSF), accepted me to contribute to their project titled PyZombis. Since then, all accepted students entered the community bonding period. For three weeks, I've been in touch with my mentors and with two other students. We have discussed the techniques of how we'll be working this GSoC, and most importantly, we have separated our initial proposals into milestones and issues in GitHub.

PyZombis is intended to be a MOOC to teach Python to Spanish speakers. Here is an overview of my proposal.

What did I do this week?

So far, I've done solid progress. As I stated already, I got to know my working team and discussed everything around the project. Also, as I'm new to GitHub, I had to learn its basics. I learned about PEP8, the Style Guide for Python Code, and about a tool that checks whether my code follows those rules, named flake8. I learned about Playwright as well, a tool to automate tests for web apps. Now, I feel ready to start the coding period.

What is coming up next?

Today, June 7th, the coding period starts. I'll be working for 2 months on this open source software project. These first two weeks, I'll focus on completing my first milestone: fixing existing code, adding python quizzes with unit test and adding minimal Playwright tests.

Did I get stuck anywhere?

Indeed. My second milestone involves using Brython and the Twitter API. My mentor recomended trying to combine both by integrating twitter-scraper library in Brython. Unfortunately, everything I have tried so far hasn't worked.