Modifying global variables

[maxhenze]

Hey. Wanted to use this plugin for consecutive numbering of images across markdown pages.

I defined a counter variable in my extra section in my mkdocs.yml and assigned 0 to it. I then created a function increment:

    def increment():
        env.variables.counter += 1
        return env.variables.counter

It works correctly on the first page I used this macro on, but on the second page it repeated the increments from the first page and then added the increments from the second page on top.

Any ideas what could be the problem, or what i should do instead ?

Something else i tried was assigning local variables in every markdown file and importing it in the following, so I could keep incrementing on top of it.
It worked well for the first import but on the second import I recieved an error:

RecursionError: maximum recursion depth exceeded while calling a Python object

Hopefully my explanations make sense and leave a hint what I could do to improve it :)

[github-actions[bot]]

Welcome to this project and thank you!' first issue

[fralau]

@maxhenze This makes sense. The module provides global values for the pages, so if you have a counter managed centrally, every page is going to increase it.

Off my hat, I would do it this way:

 def increment(i:int):
        i += 1
        return int

Then

1. Declare your counter (initial value) at the top of the page, in the YAML header: counter:0
2. Call your counter in the page {{ increment(counter) }}

Voilà (let me know if that works)

For your next question: importing a page into another page can be dodgy, because you could precisely hit a recursive loop. I wouldn't try that, if I could avoid it.

[maxhenze]

@fralau Thanks for your fast reply.

I tried implementing your idea, but it seems to still not work. Defined counter: 0 under the extra section in my mkdocs.yml.

Then called {{ increment(counter) }} twice. Both gave 1 back so the incrementing changes seem not to be pushed to the YAML file.
Another observation I made was that calling {{ counter }} after the two increment calls gave back 0. So another hint, that changes might not be taken over.

Defining counter locally through: {% set counter = 0%} also didn't work and produced the same results as above.

[fralau]

The counter initial value is of course, read from the YAML file and is used to initialize counter variable, but it is not "pushed" back to it.

I have a solution that works, with a minimal example. The trick is to reset the counter for every page (or when you want). Since the building of the pages is sequential (not parallel), page by page, this is going to work:

def define_env(env):
    """
    This is the hook for defining variables, macros and filters
    """
    counter = 0

    @env.macro
    def set_counter(value:int=0):
        nonlocal counter
        counter = value
        return ''

    @env.macro
    def increment():
        nonlocal counter
        counter += 1
        return counter

Example of page:

# Example of counter

## First

Initialize {{ set_counter ()}}

First: {{ increment() }} 

Second: {{ increment() }}

Third: {{ increment() }}


## Second

Initialize {{ set_counter ()}}

First: {{ increment() }} 

Second: {{ increment() }}

Third: {{ increment() }}

This is tested and works.

[maxhenze]

Works like a charm!

[fralau]

It is funny that what we would call global variable in the perspective of mkdocs-macros, we would need to define as nonlocal in the module.

This is just a question of perspective: since we must define the main procedure as define_env() then if we define some shared value at that level, the macros will have to declare it as nonlocal (i.e. i.e. belonging to a calling function). I hope that makes sense...

Unless you want to do like this, with a real global value:

counter = 0

def define_env(env):
    """
    This is the hook for defining variables, macros and filters
    """
  

    @env.macro
    def set_counter(value:int=0):
        global counter
        counter = value
        return ''

    @env.macro
    def increment():
        global counter
        counter += 1
        return counter

[maxhenze]

Something else I found, while working with your solution is that the counter gets incremented according to the order of the markdown files and not to the order specified in the nav section in the mkdocs.yml.

For example:

If I have the documents:

• a.md
• b.md
• c.md

in my folder, but in my nav I have specified:

• a.md
• c.md
• b.md

and in each of them I increase the counter two times, then I will get a counter = 2 in a.md, counter = 4 in b.md and a counter = 6
in c.md.

But intentionally I wanted to have: counter = 2 in a.md, counter = 4 in c.md and counter = 6 in b.md