Tackle

• Documentation
• PyPI
• BSD License

Tackle box is a tool for making modular code generators and declarative CLIs. It can make any config file dynamic with both strong and weakly typed programmable flow control common to a general purpose programming language. Basically you can write a fully functional CLI and Turing-complete program in yaml. It's wild.

Warning: Tool is in it's very early phases and only now considered stable enough to use. It may never reach 1.x version as, if it gets enough stars, it will be converted to a spec and re-written in rust (ie give it a star if you'd like to see that).

Install

Note: tackle can install dependencies on its own. Check docs for advanced installation methods to isolate tackle from your system python.

python -m venv env
pip install tackle-box

Hello world

To call tackle, create a yaml file and run tackle hello-world.yaml.

Simply use the print hook.

hw->: print Hello world!

Which using jinja templating can be called in four different ways.

words: Hello world!
expanded:
  ->: print
  objects: "{{words}}"
compact->: print {{words}}
jinja_extension->: "{{ print(words) }}"
jinja_filter->: "{{ words | print }}"

And can also have interactive prompt hooks.

name->: input
target:
  ->: select Say hi to who?
  choices:
    - world
    - universe
hello->: print My name is {{name}}. Hello {{target}}!

Hooks can have loops, conditionals, and other base methods.

words:
  - Hello
  - cruel
  - world!
expanded:
  ->: print {{item}}
  for: words
  if: item != 'cruel'
compact->: print {{item}} --for words --if "item != 'cruel'"

Hooks can be written in python.

from tackle import BaseHook

class Greeter(BaseHook):
    hook_type: str = "greeter"
    target: str
    args: list = ['target']
    def exec(self):
        print(f"Hello {self.target}")

Or new hooks can be declaratively created with tackle.

greeter<-:
  target: str
  args: ['target']
  exec:
    hi->: print Hello {{target}}

And both can be called in the same way.

hello: world!
compact->: greeter {{hello}}
expanded:
  ->: greeter
  target: "{{hello}}"
jinja_extension->: "{{ greeter(hello) }}"
jinja_filter->: "{{ hello | greeter }}"

Declarative hooks are strongly typed objects.

words<-:
  hi:
    type: str
    default: Hello
    regex: ^(Bonjour|Hola|Hello)
  target: str

p->: print {{item}} --for values(words(hi="Hello",target="world!"))

Which can have methods that extend the base.

words<-:
  hi:
    type: str
    default: Hello
    regex: ^(Bonjour|Hola|Hello)
  say<-:
    target: str
    exec:
      p->: print {{hi}} {{target}}

p->: words.say --hi Hello --target world!

And also support inheritance.

base<-:
  hi: Hello

words<-:
  extends: base
  say<-:
    target: str
    exec:
      p->: print {{hi}} {{target}}

p->: words.say --target world!

And last, everything can be imported / called remotely from github repos.

import-hello_>: import robcxyz/tackle-hello-world
call->: greeter world!
# Or
local-call->: tackle hello-world.yaml
remote-call->: tackle robcxyz/tackle-hello-world --version v0.1.0

Creating a web of declarative CLIs.

Topics

• Writing Tackle Files
• Creating Providers
• Blocks and Flow Control - wip
• Memory Management
• Special Variables - wip
• Declarative Hooks
• Declarative CLIs - wip

Roadmap

• Declarative hook inheritance
• Declarative schemas
• Declarative methods
• Cached providers
• State management

Code of Conduct

Everyone interacting in the tackle-box project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the PyPA Code of Conduct.

Credit

Special thanks to the cookiecutter community for laying the basis for this project.