Forem: Daniel Kantor

[Boost]

Daniel Kantor — Tue, 14 Oct 2025 12:39:36 +0000

Simplify Your AI Agent Development: Test and Tune MCP Servers Instantly with the ToolHive Playground

Samuele Verzi for Stacklok ・ Oct 14

#toolhive #agents #mcp

[Boost]

Daniel Kantor — Tue, 22 Apr 2025 15:35:37 +0000

Eleftheria Stein-Kousathana for Stacklok

Apr 22 '25

Announcing the LLM Security Leaderboard: Evaluating AI Models Through a Security Lens

#ai #security #opensource

Comments

2 min read

[Boost]

Daniel Kantor — Thu, 23 Jan 2025 10:58:04 +0000

Avoid risky dependencies in AI generated code

Dan Barr for Stacklok ・ Jan 22

#ai #supplychain #security

[Boost]

Daniel Kantor — Tue, 17 Dec 2024 19:32:05 +0000

CodeGate: Capturing the productivity gains of AI coding assistants without sacrificing control of privacy and security

Luke Hinds for Stacklok ・ Dec 17

#githubcopilot #ai #coding #developer

Practice TDD by creating a LibreLingo-based language-learning app

Daniel Kantor — Tue, 06 Apr 2021 07:20:54 +0000

In this tutorial you'll learn how to use LibreLingo course data to create
language-learning apps in Python.

We'll build a simple function that lists the audio files required by
a LibreLingo course.

LibreLingo comes with some tools that make it easier to build such
programs and also to test them. I structured the tutorial as a small
Test-Driven-Development session so that you'll see how to use these tools.

By the end of the tutorial you should have a good basis to build
your own apps, APIs or software using LibreLingo, or to contribute
to LibreLingo or existing LibreLingo-based software.

Requirements

To enjoy this tutorial, you'll need to have some experience with
Python, and you also need to have Python 3.9 installed on your system,
as well as the poetry dependency management tool.

Setting up your project

To set up our project, we're going to first create an empty folder.

If you are creating your app inside the LibreLingo monorepo,
that's how you'd do it:

cd apps/
mkdir librelingo_audios
cd librelingo_audios/

Let's initialize our project using poetry:

poetry init

If you want to learn more about poetry, you can check out their
documentation on initializing your project.

Let's create the basic folder structure of our project:

mkdir librelingo_audios
mkdir tests
touch librelingo_audios/__init__.py

We want to test our app, so we need to install pytest as a development
dependency of our project:

poetry add --dev pytest

Let's see if pytest works:

poetry run pytest

The output is:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
collected 0 items                                                                            

=================================== no tests ran in 0.00s ====================================

Looks like pytest works and we can start writing our tests!

Let's create tests/test_list_missing_audios.py with this simple test case:

from librelingo_audios import list_missing_audios

def test_returns_hello_world():
    assert list_missing_audios() == "Hello World"

Let's try running this test:

poetry run pytest

We get this error:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo
plugins: pyfakefs-4.4.0, mock-3.5.1, snapshottest-0.6.0
collected 178 items / 1 error / 177 selected                                                 

=========================================== ERRORS ===========================================
_________ ERROR collecting apps/librelingo_audios/tests/test_list_missing_audios.py __________
ImportError while importing test module '/home/kdani/repos/LibreLingo/apps/librelingo_audios/tests/test_list_missing_audios.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
/usr/lib/python3.9/importlib/__init__.py:127: in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
apps/librelingo_audios/tests/test_list_missing_audios.py:1: in <module>
    from librelingo_audios import list_missing_audios
E   ModuleNotFoundError: No module named 'librelingo_audios'
================================== short test summary info ===================================
ERROR apps/librelingo_audios/tests/test_list_missing_audios.py
!!!!!!!!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!!!!!!!!
====================================== 1 error in 0.88s ======================================

Makes sense, because we haven't created our implementation yet!

Lets create librelingo_audios/list_missing_audios.py with the following content:

def list_missing_audios():
    return "Hello World"

We need to be able to import that in our test, so let's create librelingo_audios/__init__.py:

__version__ = '0.1.0'

from librelingo_audios.list_missing_audios import list_missing_audios

If you did that, this is how your directory structure should look like now:

├── librelingo_audios
│   ├── __init__.py
│   ├── list_missing_audios.py
├── poetry.lock
├── pyproject.toml
└── tests
    └── test_list_missing_audios.py

Let's try running our tests again:

poetry run pytest

You'll get the following output:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
collected 1 item                                                                             

tests/test_list_missing_audios.py .                                                    [100%]

===================================== 1 passed in 0.01s ======================================

Loading LibreLingo courses

LibreLingo comes with a Python package that facilitates loading courses in
Python programs. Let's install it:

poetry add librelingo_yaml_loader

Let's play around with this library in ipython to see how it works:

poetry run ipython

In [1]: import librelingo_yaml_loader
In [2]: course = librelingo_yaml_loader.load_course('../../courses/spanish-from-english/')

We've loaded our course into the variable course.
Now you should be able to access course data.

For example, we can see what the target language of the course is:

In [3]: course.target_language.name
Out[3]: 'Spanish'

We can see what the title of the first Module is:

In [4]: course.modules[0].title
Out[4]: 'Basics'

We can list the Phrase objects included in
the second Skill of the first Module like so:

In [6]: course.modules[0].skills[1].phrases
Out[6]: 
[Phrase(in_target_language=['Buen provecho'], in_source_language=['Enjoy your meal']),
 Phrase(in_target_language=['Por favor'], in_source_language=['Please']),
 Phrase(in_target_language=['Pan, por favor'], in_source_language=['Bread, please']),
 Phrase(in_target_language=['Agua, por favor'], in_source_language=['Water, please']),
 Phrase(in_target_language=['Cecilia bebe agua'], in_source_language=['Cecilia drinks water']),
 Phrase(in_target_language=['La pareja bebe cerveza'], in_source_language=['The couple drinks beer']),
 Phrase(in_target_language=['José come pan'], in_source_language=['José eats bread']),
 Phrase(in_target_language=['Yo como pasta'], in_source_language=['I eat pasta'])]

Adding some tests

We'll need some data to write our tests. We could use real data here, but hat
would have some disadvantages:

Real courses evolve over time, so they might break our tests in the future
A real course can be difficult to navigate due to it's size
A real course can take up a lot of memory
Loading real courses could slow our tests down

Thankfully, LibreLingo comes with a library that has fake data to simplify
writing tests! Let's install it:

poetry add --dev librelingo-fakes

Let's remove our existing test:


def test_returns_hello_world():
    assert list_missing_audios() == "Hello World"

And replace it with a real test that verifies that an empty course doesn't
need any audio files:

from librelingo_fakes import fakes

from librelingo_audios.list_missing_audios import list_missing_audios


def test_an_empty_course_does_not_have_any_audios():
    assert list(list_missing_audios(fakes.courseEmpty)) == []

If we run our tests again, we see the following failure:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, snapshottest-0.6.0
collected 1 item                                                                             

tests/test_list_missing_audios.py F                                                    [100%]

========================================== FAILURES ==========================================
_______________________ test_an_empty_course_does_not_have_any_audios ________________________

    def test_an_empty_course_does_not_have_any_audios():
>       assert list(list_missing_audios(fakes.courseEmpty)) == []
E       TypeError: list_missing_audios() takes 0 positional arguments but 1 was given

tests/test_list_missing_audios.py:7: TypeError
================================== short test summary info ===================================
FAILED tests/test_list_missing_audios.py::test_an_empty_course_does_not_have_any_audios - T...
===================================== 1 failed in 0.03s ======================================

Let's cheat a little bit to make that test pass:

def list_missing_audios(course):
    return []

This shows us that our "implementation" already works for empty courses, but
that's a rather unrealistic edge-case. So we need to come up with some
more precise test cases to force ourselves to write the correct implementation.

Let's look at the first fake course. By running this code,
we figure out that this course has 2 phrases in total:

In [41]: count = 0

In [42]: for module in fakes.course1.modules:
    ...:     for skill in module.skills:
    ...:         count += len(skill.phrases)
    ...: 

In [43]: count
Out[43]: 2

Every phrase has one corresponding audio, so this means our fake course
is going to need 2 audios.

We expect our function to return 2 items:

def test_a_course_with_2_phrases_needs_2_audios():
    assert len(list(list_missing_audios(fakes.course1))) == 2

Let's cheat again to make that test pass:

def list_missing_audios(course):
    if not course.modules:
        return []

    return ["foo", 42]

By further exploration, we learn that the second fake course doesn't have
any phrases:

In [41]: count = 0

In [42]: for module in fakes.course2.modules:
    ...:     for skill in module.skills:
    ...:         count += len(skill.phrases)
    ...: 

In [43]: count
Out[43]: 0

Lets change the test for the empty course to instead use course2:

def test_a_course_with_0_phrases_needs_zero_audios():
    assert len(list(list_missing_audios(fakes.course2))) == 0

Our tests are failing again:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, snapshottest-0.6.0
collected 2 items                                                                            

tests/test_list_missing_audios.py F.                                                   [100%]

========================================== FAILURES ==========================================
_______________________ test_a_course_with_0_phrases_needs_zero_audios _______________________

    def test_a_course_with_0_phrases_needs_zero_audios():
>       assert len(list(list_missing_audios(fakes.course2))) == 0
E       AssertionError: assert 2 == 0
E        +  where 2 = len(['foo', 42])
E        +    where ['foo', 42] = list(['foo', 42])
E        +      where ['foo', 42] = list_missing_audios(Course(target_language=Language(name='another language', code='tr'), source_language=Language(name='my language', code...fruit', is_in_target_language=True), DictionaryItem(word='ipsum', definition='red fruit', is_in_target_language=True)]))
E        +        where Course(target_language=Language(name='another language', code='tr'), source_language=Language(name='my language', code...fruit', is_in_target_language=True), DictionaryItem(word='ipsum', definition='red fruit', is_in_target_language=True)]) = fakes.course2

tests/test_list_missing_audios.py:7: AssertionError
================================== short test summary info ===================================
FAILED tests/test_list_missing_audios.py::test_a_course_with_0_phrases_needs_zero_audios - ...
================================ 1 failed, 1 passed in 0.03s =================================

Since course2 has modules (all with no phrases) this time it's not as easy to
cheat with the implementation.

The simplest way to make the test pass is probably actually
implementing the iteration:

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                yield None

Our tests are now passing!

One problem is that although now every phrase is there,
the output format is still useless.

We need to include the text of each phrase in the target language
of the course. Let's make sure it's always the second item in the output:

def test_result_includes_the_phrase_in_the_target_language():
    result = list(list_missing_audios(fakes.course1))
    # We are using in_target_language[0] because only the first version is used for audios
    assert result[0][1] == fakes.course1.modules[0].skills[0].phrases[0].in_target_language[0]

Let's run our tests again:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, snapshottest-0.6.0
collected 3 items                                                                            

tests/test_list_missing_audios.py ..F                                                  [100%]

========================================== FAILURES ==========================================
___________________ test_result_includes_the_phrase_in_the_target_language ___________________

    def test_result_includes_the_phrase_in_the_target_language():
        result = list(list_missing_audios(fakes.course1))
>       assert result[0][1] == fakes.course1.modules[0].skills[0].phrases[0].in_target_language
E       TypeError: 'NoneType' object is not subscriptable

tests/test_list_missing_audios.py:16: TypeError
================================== short test summary info ===================================
FAILED tests/test_list_missing_audios.py::test_result_includes_the_phrase_in_the_target_language
================================ 1 failed, 2 passed in 0.03s =================================

Let's try cheating with the implementation:

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                yield [None, ""]

Now we get this error:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, snapshottest-0.6.0
collected 3 items                                                                            

tests/test_list_missing_audios.py ..F                                                  [100%]

========================================== FAILURES ==========================================
___________________ test_result_includes_the_phrase_in_the_target_language ___________________

    def test_result_includes_the_phrase_in_the_target_language():
        result = list(list_missing_audios(fakes.course1))
>       assert result[0][1] == fakes.course1.modules[0].skills[0].phrases[0].in_target_language
E       AssertionError: assert '' == ['lorem ipsum']
E        +  where ['lorem ipsum'] = Phrase(in_target_language=['lorem ipsum'], in_source_language=['john smith']).in_target_language

tests/test_list_missing_audios.py:16: AssertionError
================================== short test summary info ===================================
FAILED tests/test_list_missing_audios.py::test_result_includes_the_phrase_in_the_target_language
================================ 1 failed, 2 passed in 0.03s =================================

We can continue cheating though:

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                yield [None, "lorem ipsum"]

Our tests are now passing again 🎉!

This shows our test wasn't specific enough. Let's add another example:

def test_result_includes_the_phrase_in_the_target_language_2():
    result = list(list_missing_audios(fakes.course1))
    assert result[1][1] == fakes.course1.modules[0].skills[1].phrases[0].in_target_language[0]

We get the following failure:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, snapshottest-0.6.0
collected 4 items                                                                            

tests/test_list_missing_audios.py ...F                                                 [100%]

========================================== FAILURES ==========================================
__________________ test_result_includes_the_phrase_in_the_target_language_2 __________________

    def test_result_includes_the_phrase_in_the_target_language_2():
        result = list(list_missing_audios(fakes.course1))
>       assert result[1][1] == fakes.course1.modules[0].skills[1].phrases[0].in_target_language[0]
E       AssertionError: assert 'lorem ipsum' == 'foous barus'
E         - foous barus
E         + lorem ipsum

tests/test_list_missing_audios.py:21: AssertionError
================================== short test summary info ===================================
FAILED tests/test_list_missing_audios.py::test_result_includes_the_phrase_in_the_target_language_2
================================ 1 failed, 3 passed in 0.03s =================================

This time around writing the actual implementation is easier than
trying to trick the tests:

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                # Returning only the first version because
                # the other versions never need audio.
                yield [None, phrase.in_target_language[0]]

Let's refactor a bit: we extract the text to a new variable!

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                # Returning only the first version because
                # the other versions never need audio.
                text = phrase.in_target_language[0]
                yield [None, text]

The reason anyone would call the function list_missing_audios is probably because
they want to download/create those audios somehow.

If they want to create those files, then for practical reasons the filenames
should follow a standardized system that other LibreLingo-related software
can also recognize.

To achieve that, we can use the audio_id function from librelingo-utils.

Let's start simple. First let's make sure that the IDs are string:

def test_audio_id_is_a_string():
    assert [type(result[0]) for result in list_missing_audios(fakes.course1)] == [str, str]

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, snapshottest-0.6.0
collected 5 items                                                                            

tests/test_list_missing_audios.py ....F                                                [100%]

========================================== FAILURES ==========================================
_________________________________ test_audio_id_is_a_string __________________________________

    def test_audio_id_is_a_string():
>       assert [type(result[0]) for result in list_missing_audios(fakes.course1)] == [str, str]
E       AssertionError: assert [<class 'None...s 'NoneType'>] == [<class 'str'>, <class 'str'>]
E         At index 0 diff: <class 'NoneType'> != <class 'str'>
E         Use -v to get the full diff

tests/test_list_missing_audios.py:24: AssertionError
================================== short test summary info ===================================
FAILED tests/test_list_missing_audios.py::test_audio_id_is_a_string - AssertionError: asser...
================================ 1 failed, 4 passed in 0.04s =================================

We can still cheat by returning an empty string:

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                # Returning only the first version because
                # the other versions never need audio.
                text = phrase.in_target_language[0]
                yield ["", text]

And out tests are passing again... We better make sure somehow that
audio_id is actually used to perform the filename-logic.

First let's install librelingo-utils:

poetry add librelingo-utils

And write a tests that only passes if our function calls audio_id.

To do that, we'll need to install pytest-mock:

poetry add --dev pytest-mock

We can now write our test:

def test_calls_audio_id_to_get_the_id(mocker):
    audio_id = mocker.patch('librelingo_audios.list_missing_audios.audio_id')
    list_missing_audios(fakes.course1)
    assert audio_id.call_count == 2

This will mock the audio_id function and see how many times it has been called.
We assert that it has to run twice, since there are 2 phrases that need audio files.

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, mock-3.5.1, snapshottest-0.6.0
collected 6 items                                                                            

tests/test_list_missing_audios.py .....F                                               [100%]

========================================== FAILURES ==========================================
_____________________________ test_calls_audio_id_to_get_the_id ______________________________

mocker = <pytest_mock.plugin.MockerFixture object at 0x7ff94ee398e0>

    def test_calls_audio_id_to_get_the_id(mocker):
>       audio_id = mocker.patch('librelingo_audios.list_missing_audios.audio_id')

tests/test_list_missing_audios.py:29: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/home/kdani/.cache/pypoetry/virtualenvs/librelingo-audios-yD2wurwN-py3.9/lib/python3.9/site-packages/pytest_mock/plugin.py:352: in __call__
    return self._start_patch(
/home/kdani/.cache/pypoetry/virtualenvs/librelingo-audios-yD2wurwN-py3.9/lib/python3.9/site-packages/pytest_mock/plugin.py:161: in _start_patch
    mocked = p.start()  # type: unittest.mock.MagicMock
/usr/lib/python3.9/unittest/mock.py:1541: in start
    result = self.__enter__()
/usr/lib/python3.9/unittest/mock.py:1405: in __enter__
    original, local = self.get_original()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <unittest.mock._patch object at 0x7ff94ee39a00>

    def get_original(self):
        target = self.getter()
        name = self.attribute

        original = DEFAULT
        local = False

        try:
            original = target.__dict__[name]
        except (AttributeError, KeyError):
            original = getattr(target, name, DEFAULT)
        else:
            local = True

        if name in _builtins and isinstance(target, ModuleType):
            self.create = True

        if not self.create and original is DEFAULT:
>           raise AttributeError(
                "%s does not have the attribute %r" % (target, name)
            )
E           AttributeError: <function list_missing_audios at 0x7ff94ee4c5e0> does not have the attribute 'audio_id'

/usr/lib/python3.9/unittest/mock.py:1378: AttributeError
================================== short test summary info ===================================
FAILED tests/test_list_missing_audios.py::test_calls_audio_id_to_get_the_id - AttributeErro...
================================ 1 failed, 5 passed in 0.13s =================================

That's not exactly what I expected. Looks like mocking is problematic in Python when your
file name is the same of a function name, because it will try to mock an attribute of the
function instead of the file.

After some Googling I couldn't find an easy and clean solution for this, so
let's just rename list_missing_audios.py to functions.py to avoid trouble.

I'm planning to put more functions here anyway.

In our test file, let's change the import:

from librelingo_audios.functions import list_missing_audios

Let's change the mock:

def test_calls_audio_id_to_get_the_id(mocker):
    audio_id = mocker.patch('librelingo_audios.functions.audio_id')
    list_missing_audios(fakes.course1)
    assert audio_id.call_count == 2

Let's also change the import in __init__.py:

__version__ = '0.1.0'

from librelingo_audios.functions import list_missing_audios

Now if we run our tests, we see the failure that I originally expected, or at least something similar:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, mock-3.5.1, snapshottest-0.6.0
collected 6 items                                                                            

tests/test_list_missing_audios.py .....F                                               [100%]

========================================== FAILURES ==========================================
_____________________________ test_calls_audio_id_to_get_the_id ______________________________

mocker = <pytest_mock.plugin.MockerFixture object at 0x7f458c9cc8e0>

    def test_calls_audio_id_to_get_the_id(mocker):
        audio_id = mocker.patch('librelingo_audios.functions.audio_id')
        list_missing_audios(fakes.course1)
>       assert audio_id.call_count == 2
E       AssertionError: assert 0 == 2
E        +  where 0 = <MagicMock name='audio_id' id='139936688556448'>.call_count

tests/test_list_missing_audios.py:31: AssertionError
================================== short test summary info ===================================
FAILED tests/test_list_missing_audios.py::test_calls_audio_id_to_get_the_id - AssertionErro...
================================ 1 failed, 5 passed in 0.04s =================================

Whoops, our test forgot to actually iterate over the result, lets wrap the function call in
list() to fix that.

def test_calls_audio_id_to_get_the_id(mocker):
    audio_id = mocker.patch('librelingo_audios.functions.audio_id')
    list(list_missing_audios(fakes.course1))
    assert audio_id.call_count == 2

Now let's change the implementation so that it actually calls audio_id:

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                # Returning only the first version because
                # the other versions never need audio.
                text = phrase.in_target_language[0]
                audio_id(course.source_language, "lorem ipsum")
                yield ["", text]

Our tests are now passing:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, mock-3.5.1, snapshottest-0.6.0
collected 6 items                                                                            

tests/test_list_missing_audios.py ......                                               [100%]

===================================== 6 passed in 0.02s ======================================

Notice though, we are actually passing the source language instead of
the target language! Also we're calling it with an empty string instead of
the actual string:

audio_id(course.source_language, "")

We need to be a lot stricter in our tests so let's fix that:

def test_calls_audio_id_with_the_correct_arguments(mocker):
    audio_id = mocker.patch('librelingo_audios.functions.audio_id')
    list(list_missing_audios(fakes.course1))
    expected_call = mocker.call(fakes.course1.target_language, fakes.course1.modules[0].skills[0].phrases[0].in_target_language[0])
    audio_id.assert_has_calls([expected_call])

That causes our tests to fail so let's update the implementation:

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                # Returning only the first version because
                # the other versions never need audio.
                text = phrase.in_target_language[0]
                audio_id(course.target_language, "lorem ipsum")
                yield ["", text]

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, mock-3.5.1, snapshottest-0.6.0
collected 7 items                                                                            

tests/test_list_missing_audios.py .......                                              [100%]

===================================== 7 passed in 0.03s ======================================

But you'll notice this is still cheating, because we're always using
"lorem ipsum" as the text. Let's extend our test case to fix that.

def test_calls_audio_id_with_the_correct_arguments(mocker):
    audio_id = mocker.patch('librelingo_audios.functions.audio_id')
    list(list_missing_audios(fakes.course1))
    expected_call_1 = mocker.call(fakes.course1.target_language, fakes.course1.modules[0].skills[0].phrases[0].in_target_language[0])
    expected_call_2 = mocker.call(fakes.course1.target_language, fakes.course1.modules[0].skills[1].phrases[0].in_target_language[0])
    audio_id.assert_has_calls([expected_call_1, expected_call_2])

Yup, our tests are failing again!

Let's make them pass:

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                # Returning only the first version because
                # the other versions never need audio.
                text = phrase.in_target_language[0]
                audio_id(course.target_language, phrase.in_target_language[0])
                yield ["", text]

This looks good, but we're still not returning the ID!
You guessed it, that's a new test case for us!

We will make our mock function return a fake value and we'll
assert that value shows up in the result.

def test_returns_correct_audio_id(mocker):
    audio_id = mocker.patch('librelingo_audios.functions.audio_id')
    audio_id.return_value = "omg"
    assert list(list_missing_audios(fakes.course1))[0][0] == "omg"

If we run the tests we get the error that we expected:

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, mock-3.5.1, snapshottest-0.6.0
collected 8 items                                                                            

tests/test_list_missing_audios.py .......F                                             [100%]

========================================== FAILURES ==========================================
_______________________________ test_returns_correct_audio_id ________________________________

mocker = <pytest_mock.plugin.MockerFixture object at 0x7fe9191977f0>

    def test_returns_correct_audio_id(mocker):
        audio_id = mocker.patch('librelingo_audios.functions.audio_id')
        audio_id.return_value = "omg"
>       assert list(list_missing_audios(fakes.course1))[0][0] == "omg"
E       AssertionError: assert '' == 'omg'
E         - omg

tests/test_list_missing_audios.py:45: AssertionError
================================== short test summary info ===================================
FAILED tests/test_list_missing_audios.py::test_returns_correct_audio_id - AssertionError: a...
================================ 1 failed, 7 passed in 0.04s =================================

Let's cheat again to make the test pass:

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                # Returning only the first version because
                # the other versions never need audio.
                text = phrase.in_target_language[0]
                audio_id(course.target_language, phrase.in_target_language[0])
                yield ["omg", text]

Our tests now pass, but we are still returning the wrong output.

Let's make another test case to make it impossible to cheat.

Since the return value of the mock function is entirely determined by the fake
value that we supply in our test case, this is a value the implementation can
only reproduce by actually calling the function and taking the return value.

The only one way our implementation can cheat is if the return value is
one simple static example, which is exactly what we have right now.

The most straightforward way to avoid that is by adding an identical test case
with a different mock value:

def test_returns_correct_audio_id_2(mocker):
    audio_id = mocker.patch('librelingo_audios.functions.audio_id')
    audio_id.return_value = "foobar"
    assert list(list_missing_audios(fakes.course1))[0][0] == "foobar"

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, mock-3.5.1, snapshottest-0.6.0
collected 9 items                                                                            

tests/test_list_missing_audios.py ........F                                            [100%]

========================================== FAILURES ==========================================
______________________________ test_returns_correct_audio_id_2 _______________________________

mocker = <pytest_mock.plugin.MockerFixture object at 0x7f83d4646a00>

    def test_returns_correct_audio_id_2(mocker):
        audio_id = mocker.patch('librelingo_audios.functions.audio_id')
        audio_id.return_value = "foobar"
>       assert list(list_missing_audios(fakes.course1))[0][0] == "foobar"
E       AssertionError: assert 'omg' == 'foobar'
E         - foobar
E         + omg

tests/test_list_missing_audios.py:51: AssertionError
================================== short test summary info ===================================
FAILED tests/test_list_missing_audios.py::test_returns_correct_audio_id_2 - AssertionError:...
================================ 1 failed, 8 passed in 0.05s =================================

Let's fix our implementation:

from librelingo_utils import audio_id

def list_missing_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                # Returning only the first version because
                # the other versions never need audio.
                text = phrase.in_target_language[0]
                id_ = audio_id(course.target_language, phrase.in_target_language[0])
                yield [id_, text]

Now let's do a little bit of refactoring. I don't want to shove more functionality
into this function, so let's rename it to list_required_audios across all files.

Later I can create a list_missing_audios which will actually filter out all
the audio files that already exist.

from librelingo_utils import audio_id

def list_required_audios(course):
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                # Returning only the first version because
                # the other versions never need audio.
                text = phrase.in_target_language[0]
                id_ = audio_id(course.target_language, phrase.in_target_language[0])
                yield [id_, text]

Just checking that the tests still pass...

==================================== test session starts =====================================
platform linux -- Python 3.9.1, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
rootdir: /home/kdani/repos/LibreLingo/apps/librelingo_audios
plugins: pyfakefs-4.4.0, mock-3.5.1, snapshottest-0.6.0
collected 9 items                                                                            

tests/test_list_missing_audios.py .........                                            [100%]

===================================== 9 passed in 0.03s ======================================

Now let's extract the iteration part to simplify our function:

from librelingo_utils import audio_id

def _iterate_phrases(course):
    '"Flatten" a course into a sequence of phrases'
    for module in course.modules:
        for skill in module.skills:
            for phrase in skill.phrases:
                yield phrase


def list_required_audios(course):
    for phrase in _iterate_phrases(course):
        # Returning only the first version because
        # the other versions never need audio.
        text = phrase.in_target_language[0]
        id_ = audio_id(course.target_language, phrase.in_target_language[0])
        yield [id_, text]

That concludes this tutorial! If you are interested in learning more about
how LibreLingo works,
check out our source code on GitHub,
our development documentation or
join our chat.

Generate screenshots for your translation keys

Daniel Kantor — Tue, 13 Oct 2020 18:02:51 +0000

Screenshots are a useful tool for your translators, because they give context for your translation keys. Seeing text in it's proper context will make it much easier to create the correct translation.

This guide assumes that you know how to use Cypress, and have already set it up in your project. I do not recommend installing Cypress just to create screenshots for your translation keys.

Providing the `tkey` data attribute

In order for this solution to work, you'll need to provide the tkey data attribute for all translation keys. This is required so that the screenshots can receive the correct filename.

There are different ways to achieve this, and the implementation depends on the framework that you use.

In the case of my Svelte code in LibreLingo, I created a component which I use to wrap my translation keys.

<script>
  import { format } from "svelte-i18n"

  export let key
</script>

<span data-tkey={key}>
  {$format(key)}
</span>

This way I never have to specify this manually. It's implicit for every translation key.

Creating the screenshots

Creating screenshots with Cypress is easy:

cy.screenshot(fileName)

But, we need to create a separate file for each translation key, and with the correct filename:

cy.get('[data-tkey]').each($el => {
  const tkey = $el.data('tkey')
  console.log(`📸 Creating screenshots for ${tkey}}`)
  cy.screenshot(`__tkey-${tkey}`)
})

I am already using Cypress for visual regression testing, so I just put this code where I already create screenshots. There are other options if you don't use visual regression testing. You can consider running this code on the window:load event.

After running my Cypress tests, I already see the screenshots:

The problem is that a page can contain various translation keys. With this method, each translation key will have an identical screenshot, if they are on the same page. This is not ideal, because it can be hard to spot the specific translation key.

Outlining the translation on the screenshots

A nice way to guide the attention of the translator is to mark the relevant part of the screenshot.

I chose to draw a red rectangle around the relevant DOM node. Fortunately, it's very easy to find out the position and size of a DOM node relative to the viewport:

$el[0].getBoundingClientRect()

Using that, I can create a function that highlights a specific DOM element on the page:

const createRectangle = ({ left, top, width, height }) => {
  const rectangle = document.createElement("div");
  rectangle.setAttribute(
    "style",
    `position: fixed;
     left: ${left - 5}px;
     top: ${top - 5}px;
     width: ${width + 15}px;
     height: ${height + 15}px;
     border: 3px dashed red;
     z-index: 1000000;`
  );

  return rectangle;
};

const createElementHighlighter = (element) => {
  return createRectangle(element.getBoundingClientRect());
};

I can use that function to highlight each element before their screenshot is taken:

cy.get("[data-tkey]").each(($el) => {
  const tkey = $el.data("tkey");
  const highlighter = createElementHighlighter($el[0]);

  cy.window().then((win) => {
    win.document.body.appendChild(highlighter);
  });

  console.log(`📸 Creating screenshots for ${tkey}}`);
  cy.screenshot(`__tkey-${tkey}`);

  cy.window().then((win) => {
    win.document.body.removeChild(highlighter);
  });
});

If I run my tests now, I can see that the elements are correctly marked 🎉. Examples:

Drawbacks

This approach has several limitations and drawbacks. To name a few:

I wouldn't recommend checking these files into git, because they can change very often. Instead, it's better to upload them into your translation platform directly.
It's not useful to create screenshots this way if you don't already have Cypress tests covering the specific area of your app
It will slow down your Cypress tests slightly, although this can be mitigated if you only create the screenshots when an environment variable is set

"Reading mode" for i3

Daniel Kantor — Mon, 28 Sep 2020 16:42:34 +0000

After reading about the benefits of using your phone in grayscale mode, I wanted to try it on my computer too.

Grayscale mode in the browser

I started by creating a userstyle with the following content:

html {
    filter: grayscale() !important;
}

this actually worked great! It is blazing fast on most websites, and it's even applied to things like videos!

The problems started to arise when I realized that on websites that my laptop is getting louder than usual when I'm using websites that are already somewhat resource-intensive, like YouTube. Besides, there was a noticeable framerate drop in videos!

I tried several of the already existing browser plugins that aim to implement this, but they had the same performance issues.

That's not a price I wanted to pay for this feature.

Compton GLX shaders

When I was setting up compton as my compositor for i3, I noticed that it has a weird flag that I'm not using:

--glx-fshader-win SHADER
  GLX backend: Use specified GLSL fragment shader for rendering window contents. See compton-default-fshader-win.glsl
  and compton-fake-transparency-fshader-win.glsl in the source tree for examples.

I have no idea about how shaders work, but I figured if it can be used in compton-fake-transparency-fshader-win, it might be useful for a color filter too.

After Googling some examples, I figured something like this should work for a shader:

uniform sampler2D tex;

void main() {
   vec4 c = texture2D(tex, gl_TexCoord[0].xy);
   float y = dot(c.rgb, vec3(0.299, 0.587, 0.114));
   vec4 gray = vec4(y, y, y, 1.0);
   gl_FragColor = mix(c, gray, 0.95);

}

I chose to drastically desaturate the image rather than turning it completely grayscale. This way, colors are displayed in a very very subtle way.

I passed that shader to compton --glx-fshader-win, and it works!

Not only I haven't experienced any performance drop this way, but as an added benefit, I now have a reading mode in my entire OS, not just the browser. I can even play games in grayscale mode!

I created this shell script so that I can easily turn it on and off through keybinding.

#!/usr/bin/env bash

 #Define shader
GRAYSCALE=$(cat <<-END
uniform sampler2D tex;
void main() {
   vec4 c = texture2D(tex, gl_TexCoord[0].xy);
   float y = dot(c.rgb, vec3(0.299, 0.587, 0.114));
   vec4 gray = vec4(y, y, y, 1.0);
   gl_FragColor = mix(c, gray, 0.95);
}
END
)

# Restart compton with the selected mode
killall -q compton
if [[ $MODE == "grayscale" ]]; then
   compton "$@" --glx-fshader-win "$GRAYSCALE" --backend glx
else
   compton "$@"
fi

You can grab that script from GitHub:

kantord / compton-grayscale-reading-mode

compton-grayscale-reading-mode

This script implements a reading mode/grayscale mode in i3 window manager and other window managers using compton.

The level of desaturation is 95%, so there is still some color present, but it's desaturated to a very large degree. This has no effect on your wallpaper: I recommend setting a black wallpaper using hsetroot.

In grayscale mode, backend is always glx.

Usage

compton-grayscale-reading-mode is a wrapper around compton. Any command line arguments are passed along to compton.

Any running compton instances are killed, therefore this script can be used to switch grayscale mode on and off.

Enable grayscale mode

MODE=grayscale compton.sh

Disable grayscale mode

MODE=normal compton.sh

View on GitHub

Why I built LibreLingo

Daniel Kantor — Tue, 22 Sep 2020 20:00:54 +0000

TL;DR I wanted to have a wiki-like language learning app, so I created LibreLingo.

Every morning, I make my smoothie and sit down to study a foreign language for half an hour. This has been part of my morning routine for years.

There is something relaxing and meditative about practicing languages: it's an infinite source of new challenges, but broken down with the right tools, those challenges never become stressful. This is a habit I can do anywhere, and I can start and finish whenever I want.

You might love it or hate it, but my go-to tool has always been Duolingo. It has everything I need: skills are small and roughly uniform in size. I almost never have to look up grammar, because grammar is incorporated into skills. I can dive straight in! That makes the routine more predictable. Isn't it much easier to stick to a habit that's predictable?

This is my ideal way to warm up my brain for more unpredictable challenges later in my day!

The itch

Every good work of software starts by scratching a developer's personal itch. - Eric S. Raymond

People have different reasons to learn a language: I use it to clear my mind, others use it to connect to their roots. People learn languages to find their dream job. People learn languages to fit in. People learn languages to explore. Every priority requires a different method.

As a developer who loves open source, I want my essential tools to be open and hackable.

Duolingo offers a very wide variety of courses and an increasingly high variety of ways to practice. They, however, lack an open API, and although they have some open-source software and have released some of their findings, their course content, as well as their software is proprietary.

Because my morning routine is important for me, I don't want my tools to change in ways I don't like, even if such changes make more money to a company. I don't want to end up in a different A/B test group. I don't want to have limited hearts. I don't want to depend on a SaaS. I want to own the tool I use every day.

There are some great alternatives. Anki has a great license and customizability. Shared Anki decks offer a wide variety of content tailored to different needs.

That being said, all the alternatives I could find require the user to be much more proactive: you have to look up the grammar on your own, and you have to know what you want to practice, and in what order. This is ideal if you are experienced in learning languages and want to learn in the most efficient way, but it's not very beginner-friendly, and it's harder to make it into a habit.

The sheer size of the online language-learning and language nerd community, as well as the vast amount of user-created content, shows that there's great interest in creating resources. In a perfect world, these efforts could be channeled into a common cause: something like a Wikipedia of interactive online-learning resources, that offers a clean, fun, and consistent experience. Something that removed the barriers to learning a language and at the same time, gives the user more freedom in choosing how they want to learn.

For a very long time, I have been contemplating creating a project like that. Unfortunately, I had no experience in designing something so complicated. Even if I had a good plan, the amount and diversity of the work alone would mean that I need to attract some people to help me, and doing that without offering a direct financial incentive seemed impossible.

The solution

Release early. Release often. And listen to your customers. - Eric S. Raymond

Eventually, I decided to just give it a go, and see what happens! If I could find the smallest module of this concept that people would find cool and useful, I could perhaps get some feedback or even incite interest in the project.

I chose to begin with building a simple front-end for practicing skills. This is the most concrete, visual, and user-centered part of the ecosystem I envisioned. Because it's simple and tangible, I felt that people would just get it.

Another reason why I started by building the practice screen is that there are many great examples of this feature, so I wouldn't really have to reinvent the wheel. Also, there are resources I could use for building most of this.

I considered that this part wouldn't initially need any sort of back-end, and I could get away with replacing the course editor with a couple of hand-written JSON files.

An early screenshot of the practice screen

The "Launch"

Immediately, I wanted to show it to people. Since what I had was working perfectly as a static site, I decided to simply publish it on GitHub pages.

Once I deployed to GitHub pages, I created a README.md, trying to be as informative as I could: I described the project and my motivations, and I laid out some possible milestones. I included a license and some notes about how to contribute.

All set, I was ready to post to Hacker News.

The reception

So far, LibreLingo received 620⭐ stars on GitHub. While I've had projects that attracted way more GitHub stars, I did not anticipate the amount of interest and contributions this very basic demo and product concept received.

Almost 70 people expressed their interest in working on course content, and many people contacted me with different ideas, proposals, and comments. A lot of people were enthusiastic and started contributing by creating issues and submitting pull requests!

Our contributors list now stands at 30 people, and with the contribution of Caroline Delesalle, we have our amazing mascot, Lili:

Someone even proposed a new design.

The progress

Thanks to PouchDB, LibreLingo users can now track their progress on their own devices. This means that storing user data doesn't require communication with a remote server. Thanks to that, the app is snappy and reliable: the functionality of the entire app can be made available without an internet connection.

Current screenshots of the front-end

What's also brilliant about PouchDB is that the data can be synced with a remote database, so the user can still see the same progress across multiple devices.

Another important piece of the puzzle is the course editor. I chose to implement it using Django Admin. It might not be the sexiest framework you can think of in 2020, but I knew from my previous work experience that it's incredibly easy to create CRUD apps with it. You just have to do define your database models, and Django creates your database and your admin app.

The current LibreLingo course editor

Once the course editor was working, I just had to deploy it to Heroku, create a simple script that can export the course data, fetch any missing illustrations from Unsplash, and generate any missing audio files using Amazon Polly.

The challenges

In most projects, the first system built is barely usable... Hence plan to throw one away; you will, anyhow. - Fred Brooks, The Mythical Man-Month

An early adopter might be able to use LibreLingo productively already. Nonetheless, before widespread use, much work needs to be done on course content.

I want LibreLingo to empower anyone to work on courses. The real power of a wiki-like system would be unleashed by having content for minority/endangered languages, specific dialects and constructed languages through the enthusiasm of the language nerd community.

While the course editor is fully functional and makes it easy to edit the course content, it does not facilitate collaboration sufficiently. It's not enough to draw in a wealth of contributions, it's also extremely important to maintain an efficient, sensible, and fun course structure. To do this, the course editor would probably need to enforce some sophisticated constraints, and also have a way to determine who can approve content.

I have ideas on how to make this work: extend Django Admin with the required functionality. Or perhaps use Django to create a GraphQL or REST API, and build a custom frontend on top of that for the course editor. Perhaps move to a document store model for the course editor. Perhaps let some people experiment with course content being stored in a git repo for a specific course. Or try using a MediaWiki instance. If you know how to do this in baby steps, please head to this issue!

Want to help out LibreLingo?

Here's a couple ideas how you could get involved:

👀 Help making contribution to LibreLingo easier
💡 Help more people get involved with the course editor
👩🏽‍💻 Check out some good first issues
📜 Check out the LibreLingo GitHub repo for more info
🎨 Help us work out the new design
💸 Sponsors me on GitHub Sponsors

Hacktoberfest 2020

Hacktoberfest is a global hackathon event celebrating open-source software. To read more about Hacktoberfest, check out their website.

LibreLingo has a curated list of issues for Hacktoberfest.

Update April 2021

Interested in learning more about the LibreLingo platform? Check out my new dev.to post about creating a LibreLingo-based app in Python!

Forem: Daniel Kantor

[Boost]

Simplify Your AI Agent Development: Test and Tune MCP Servers Instantly with the ToolHive Playground

Samuele Verzi for Stacklok ・ Oct 14

[Boost]

Announcing the LLM Security Leaderboard: Evaluating AI Models Through a Security Lens

[Boost]

Avoid risky dependencies in AI generated code

Dan Barr for Stacklok ・ Jan 22

[Boost]

CodeGate: Capturing the productivity gains of AI coding assistants without sacrificing control of privacy and security

Luke Hinds for Stacklok ・ Dec 17

Practice TDD by creating a LibreLingo-based language-learning app

Requirements

Setting up your project

Loading LibreLingo courses

Adding some tests

Generate screenshots for your translation keys

Providing the tkey data attribute

Creating the screenshots

Outlining the translation on the screenshots

Drawbacks

"Reading mode" for i3

Grayscale mode in the browser

Compton GLX shaders

kantord / compton-grayscale-reading-mode

compton-grayscale-reading-mode

Usage

Why I built LibreLingo

The itch

The solution

The "Launch"

The reception

The progress

The challenges

Want to help out LibreLingo?

Hacktoberfest 2020

Update April 2021

Providing the `tkey` data attribute