improvements to the auto scoping mechanisms

[ms-lolo]

we're creating more types of data structures that act as global identifiers across the project. ServiceId, CommandId, and others need to be globally unique, so we auto-prefix them with the module path in order to guarantee uniqueness and also give log messages useful metadata that shows authors the path to the definition of a given id.

Elon pointed out that using the full module path typically includes the private module file, which makes things fragile when we move the implementation across private files. We decided the prefix should probably be the path to the nearest public package where this id object is exposed. this allows us to move the class without breaking things like serialized json that might include these id objects. it's reasonable to expect things to break when we move an id class between public packages, but that matches the expectation of any other public api change.

so instead of ServiceId("rats.pipelines._something:some-service"), we want the prefixing to be something along the lines of ServiceId("rats.pipelines:Something.some-service").

[ms-lolo]

used the current api for a few months and have some thoughts.

this is our current pattern for defining service ids:

from rats import apps

@apps.autoscope
class PluginServices:
    THING_ONE = ServiceId[apps.Executable]("thing-one")
    THING_TWO = ServiceId[apps.Executable]("thing-two")

but this pattern doesn't provide an obvious enough api:

• it's not clear that i shouldn't initialize the class
• it's not possible to put the class grouping to any real use because we can't create instances with different values
• it's easy to accidentally mutate the global state
• probably a few others? it feels a little too special

maybe a similar direction along these lines could work and looks less foreign to me:

from rats import apps
from typing import NamedTuple

@apps.autoscope
class PluginServices(NamedTuple):
    thing_one: ServiceId[apps.Executable]
    thing_two: ServiceId[apps.Executable]

SERVICES = PluginServices(
    thing_one=ServiceId[apps.Executable]("thing-one"),
    thing_two=ServiceId[apps.Executable]("thing-two"),
)

• feels more natural to look at rats.pipelines.SERVICES.thing_one than rats.pipelines.PluginServices.THING_ONE
• SERVICES is immutable and iterable
• we can serialize the value and pass it to other parts of the system
• we can abstract and inject different instances for testing more of our wiring logic
• we can probably simplify apps.autoscope()

… still noodling

[ms-lolo]

this is the most recent version i'm using in projects:

class PluginServices(NamedTuple):
    thing_one: ServiceId[apps.Executable]
    thing_two: ServiceId[apps.Executable]


SERVICES = auto(PluginServices)


class Plugin(apps.Container):

  @apps.service(SERVICES.thing_one)
  def _thing_one(self) -> apps.Executable:
    …

i very much like this version because:

• we no longer need to create the ServiceId instances, no longer needing to choose a mapping between the property and the name
• we can create multiple instances of the services namedtuple, in cases where things are more dynamic
• type hints by IDEs are much more obvious

the implementation of auto() in this case is very similar, but simpler, than apps.autoscope(). it takes a namedtuple of service ids, and returns an instance with the ids being tied to the property name.