I'm not from the Python world, but I know some basic aspects of python syntax.

One challenge I faced was getting VSCode to play nice with pants.

I was getting help from IntelliSense in impporting stuff from my own .py files, but I couldn't resolve the pants imports. Frustratingly, everything actually working when I ran

./pants list package

(from @wide-midnight-78598’s tutorial), but Pylance was complaining that it could not resolve any of the pants modules.

I ended up figuring it out eventually, and this was the trick, which I wrote down in a little readme for my team: In order to get VSCode's IntelliSense to play nice with python, do these steps: 1. Export pants (whatever this means, I'm not sure)

./pants export ::

2. select the virtualenv (may not be necessary?)

source dist/export/python/virtualenv/3.9.16/bin/activate

3. Open a python file so that VSCode says "Python" in the bottom blue bar 4. Click "select interpreter" in the bottom of VSCode's GUI. 5. Select "browse file system" 6. Navigate to and select

dist/export/python/3.9.16/__main.py__

Your python files should now have working IntelliSense

That aside, I am generally struggling to understand the concepts of pants and pants plugins. I've started methodically writing my own documentation explaining individual concepts such as goals, targets, rules, dependencies, etc.I'm slowly working my way towards understanding what they mean on an abstract level, but I honestly feel super lost when it comes to actually implementing something useful. Making a rule that does nothing or converts an int to a string is fair enough, but I have no clue what return types or input types I should use if I want to perform an operation on a file.

@rule
async def run_my_plugin(???) -> ????:

Converting typescript to runnable javascript is essentially voodoo magic for all I know

**Goal**
A goal is a command that pants runs, such as `lint`, `fmt` (format) and so on.

Building a docker image is done with the `package` goal.

**Target**
A target is a set of metadata to describe some code.

Here is our docker image target described in the `packages/backend/BUILD` file:
```BUILD
docker_image(
    name="docker",
)

The target consists of fields. Currently there is only one The command for building our docker image looks like this:

sh
./pants package packages/backend:docker

A breakdown of this command: -

package

is the goal -

packages/backend:docker

is the target address of our target, comprised of two parts: -

packages/backend

is the path to the directory of our target -

docker

is the

name

field specified in our

docker_image

target, which is defined in the BUILD file. TODO Rule Dependency **core_fields**```

One thing I have found a bit confusing: What is a target? Is it something that looks like this:

class ProjectVersionTarget(Target):
    alias = "version_file"
    core_fields = (*COMMON_TARGET_FIELDS, SingleSourceField)
    help = "A project version target representing the VERSION file."

(in a plugin's python code) or this?

version_file(
    name="hello_there"
    source="some/file/path"
)

(in a BUILD file) At this point in time I am led to think that the latter is the target and the former is the target definition. But maybe the former is the target and the latter is instead a "target call" or a "target configuration"?

There's also this thing

def target_types():
    return []

I don't exactly comprehend why this is an array. I guess one plugin can contain a bunch of different targets that are completely different features within that plugin? That makes sense, but to me this wasn't obvious from the get go, since I want to make a simple plugin that does one thing (and I could make it do many different things with different fields and rules anyway?).