DFFML Rolling Alice: Engineering Logs: Volume 1: Coach Alice, 7 Jul 2022

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Coach Alice: Volume 1: Chapter 2: Part: 34: Debugging Meta Issues as Output Operations

Description

https://github.com/intel/dffml/pull/1401#issuecomment-1170489046

A

Ready all right, let's go so primitive uh balance, control house operations could have issue mediation. Body outputs result could not be a determined meta issue, buddy, okay, so these things are mad at us right now um and we had opened the df base file, which I'm going to close right now and this one that we're looking at is. Oh, I just made a new file. Let's name this quote.

A

All right, this is recommended community standards, uh overlay, alice operations, github issue, um there's no overlay; actually, that's not okay. So the path is entities alice alice. Please contribute recommended community standards, alice operations, github issue, uh okay, so, and what we did was we made these things output operations and we added this. This collect one in and this collect one.

B

A

Going to give us a list of other ones um and then okay, so meta issue body, no okay. So that's not what it is.

A

That's result: okay, so it's mad about the result. Okay, so let's, let's take these stage outputs off and let's just go back to basically what was there and comment this one out.

A

And let's see what happens right, so, let's eliminate one variable: okay, so path, all right, 234! So not this file path, all right! Okay, um so we have run into the dreaded unification of types problem again. Okay, so uh there's yet another place where the types aren't unified- and this is this is exactly why I was probably so stressed out, um because now I'm not anymore, okay, so um so all right. It's all! Fine! Okay, so recommended community standard contribution, name tuple. So what is this name tuple? And what?

A

Why did I switch from data class to name tuple earlier when I said oh, but we can use the name temple stuff? Maybe it was because I was going to hit this bug. I don't know, um maybe let's make it a data class.

A

ah Third, I think the problem with this is that we don't have a serialization for it. Yes, um so the spec on the export of the import object fails. So let's do re, dfmo, df types and let's check out.

B

Where are we here, def export.

A

A

So the offending line.

A

339 in dfdf types, okay, so this thing here is ex this: this line, this field defaults only exists within the name tuple. It doesn't exist within the data class. So what we should.

B

A

All right: okay, okay, okay, so I mean I really. What we should do is.

A

All right, so what we should do is we should export spec as a spec should be.

A

Manifest in the shekimah, the spec is the.

B

Manifest yeah the spec is the manifest.

A

Respect is the manifest.

A

Because this tells you, how do I reconstruct this type and a manifest can be used to describe the construction of a type right? So thinking of a did method right essentially as the init method, so exported spec.

A

All right, so, let's see how do we make this because I'm not satisfied, I'm not satisfied with just throwing, so we so what what we could do and why I haven't done it is is, is I want this to become what it should be and not to become the half thing that it it? It is not right now um because it's time for this stuff to change so all right. So, okay, so I think it's it's it's a config dict, which is the stuff that we just did.

B

C

Let's look at the log.

A

Okay, traverse config, set. Remember this patch. um Actually did you all didn't? Maybe this is the one.

B

A

Like you know, because I didn't write it: okay on screen; okay, that's right! Okay! Maybe that is what this is and I.

B

A

We ever properly went over this, so I think I got distracted with something else so.

D

A

What we did was we came in here and we said just did a little refactoring to this uh to make the class name dynamic, because then we're going to take a list and then we go in and we add one, that's like hey, you know alice. Should I contribute because we're going to add, um because I I don't have time I want, I want to make sure everybody can do.

A

Should I contribute and everybody can do, please contribute right um and hopefully, if we have docs on should I contribute and please contribute that's a single action and a single response. And then you know one one is one: is safe mode, one is not safe mode um and so.

A

You know, because should I is more of like collect the data and please contribute so please the please family of commands will be like hey. Please do something um the should I um is you know, I'm asking for your recommendation um and uh the um then we'll have other ones you know, but we'll.

B

Try to keep it.

A

Sort of natural language.

B

E

And and obviously.

A

You know with the overlays: the cli is just like one: it's one interface right, so we'll plug and play stuff; um okay, so all right, okay, so yeah. So we added that and then we basically said: okay, we formatted the file with black because apparently haven't been formatted, and then we refactored out the object operation stuff. So basically, this function that was here within the alice alice alice our entities alice alice cli.

A

um We pulled that that object, operation functions out and we put it in uh uh df, dfml, util, df internal, and that was uh the move to one file. Okay. So then we came in here and we just real quick hacked in the collector data flow within the inner source operations.

A

Right so remember we did the the tutorial series on the industry stuff. It is back in like december or something um with the sap uh in in where you, where we build, we build off the sap thing. Actually, I can show the docs now, because I realize the docs, for the main is working right, so this docs is working. I realized. So um where was that? uh Yeah?

A

Okay? So there's this sap thing? Oh and are the: are we just going to the right place.

A

Okay, well that one was already pointed at scp: okay,.

A

Okay, uh all right: this is this image.

C

Okay, this is just okay.

A

Okay, well I don't know, I don't know if the images are working or not. um Well, let's go to retrogame.

C

Okay, they aren't.

A

Working, why aren't they working okay? No, so they didn't get rewritten. Why didn't they get rewritten? Oh, um oh because then I started erroring out yeah, oh god that was dumb, okay, um okay, so but anyways. So here's the here's, the here's, the software portal demo- um and you know once again this builds on this talk here and where are we at here we're talking about okay yeah? So this is basically it's.

A

It's an alternate automating classification by using sap center source portal right and then we talked about how we're going to do some of the stuff in the build tree or with our uh you know, our mentors who have uh now go gone off to start their own work um there. So um all right.

A

A

Yeah, okay and so the collector flow and the collector terminology is because of the living threat, model, stuff um and and john.

B

A

I it really is drove a lot of this uh living threat, model stuff um and I've worked with him and- and uh you know, we we we're seeing where this stuff goes, and so with alice, we're gonna beat the living threat model right, um and so that's what we're going to do with our should. I contribute um is we're going to feed the living threat modeling with our alice.

A

Please contribute we're going to take action um on the analysis that we do based off of the the should I results and we may trigger uh you know people to manually do those actions or we may have alice, do it in an automated fashion, right and so there's it will be. The code will be. The living throughout model will be alice. um Okay, so it all wraps up into one thing: it all wraps up into the same thing.

A

Okay, so directly include alice um okay, so this is basically just doing that same overlay load, uh which you're seeing here, which we already did uh for the recommended community standards. So this is our second top level command, so alice should I contribute um so now that we have those two things and we have the ability to load basic overlays on them which are really just the auto.

A

uh Whatever auto flow does um data flow, dfml, df types, data flow, auto and then the auto flow keyword argument. There.

A

Okay, so this auto flow here right, so, okay, self.autoflow, so there's an autoflow operation right, so this autoflow operation. What this does is it goes, and it looks at all those definitions right all the all the the the different operations and what what they're different, what their inputs and their outputs are and their conditionals are, and it links them up into this into this internal structure called the flow dict right.

A

So the dictionary because all the mappings in python are called dictionaries, and so then yeah and and and this like pre, the suffix prefix of the type name- is another thing that I've been playing around with uh when we think about like refactoring and getting into automated refactoring, because you can really start to look at. If you start to name types based on a certain convention, you can then begin to pull out structures, and so we'll have alice.

A

Do this she'll infer based on, like um you, know, the the patterns of usage of different variables, um uh which ones really are sort of about the same data and then name them appropriately and then create structures out of them, which is exactly what we've just done right. So we'll do this automated refactoring process eventually, um so so it links them up into this flow dict um and it throws.

A

What is that? What is that?

A

What is that seed conditions? Okay, that's the origin; okay, that's fine! So and then the origin concept is that whole. You know. Where does this thing come from? Okay, so, basically yeah, so we get it's included in the auto flow. So now we have the overlays there. We have overlays on both of our key entry points.

A

Should I and and uh please contribute, uh should I contribute and please contribute, and then we went through and we fixed this one, and I think we just did this one together- and this is the auto import use variable names instead of generated names, okay, yeah. So this is the init py problem, okay and then yeah okay, so we might have done this one together, yeah we went in and we or did we yeah. The problem here was basically that yeah, the name was not the same.

D

And then the problem.

A

Here was that we need this little helper for these config dictionary things and that's what we're using right now is these config dictionary things right, so um the the format for those is: um let's go to the doc site.

A

The format for the.

A

uh Where is it so.

D

D

A

There should be docs, I know, there's docks on this somewhere.

D

D

A

Here I'll put this in the notes.

A

Okay, so what are we doing right now, so uh input definition, dot spec is in type loading information is so what are we doing and why? Why? What so? Why are we doing this way? So so yaml? So if you saw the yaml by doing it, this way uh we're we're sort of by separating we, we we separate the config structure from the initialization of the object, because the initialization of the object happens on a enter and therefore uh we can apply the overlays and we can apply. You know any sandboxing that needs to happen.

A

So we effectively end up with like this. You know this loadable, uh it's like the yaml. It's like the yaml python function, calling stuff. That is a vulnerability.

A

You get the same functionality, you get a cross language um being, and you get it by doing this nested config structure right because then you can um and you get and and and by accessing non-entry, um okay, so definition spec at least, let's hope, because or else this is going to be not fun. So um that's what we're about to find out. Okay,.

A

What is it 1400 when we started.

C

E

C

And what is this called.

C

All right, all right: okay,.

C

Type loading information is.

A

Limited to us built-in types.

C

C

A

Need to move to plugin, slash, config, dict style, uh serialization.

A

A

C

Where was that patch here.

A

Leveraging traverse config set um recently changed in any case. Oh, was that why we did this in case, we.

C

Is that where we did this.

A

Future patches, we used to create an output operation.

A

Oh, that's not even why we did this. Oh yeah, okay, let's make a note of that too.

C

Which is for future patches where.

D

A

An output operation which serializes the graph of inputs within the input network.

A

To a json to a.

A

A

And then that's what we're going to take and dump to you know we can.

A

This is what we can then take and import to the web. Five.

C

C

A

Our data lake, all right.

D

C

A

We got an extra bullet point for whatever we'll probably have another block. Okay, so.

A

Where are we now all right, so this thing's still in flight and what's happening over here, hey.

A

Oh did I remove, I removed the.

C

A

A

I just removed it, and then it worked. Okay, oh because it didn't try to generate the spec okay, so.

A

um Boo, okay,.

A

Okay, no, this is fine. I mean it's good, it's good! It's good! It's good! It's fine! um What happens when we do data class.

A

I wanted the bug. Apparently, apparently I really wanted to fix the vlog okay.

E

A

Okay, great okay, here's the book um so yeah because, or else it basically just says, um oh.

C

Oh yeah, okay,.

A

Just give him a hand, it's mad okay. So why can't we do.

C

A

We do. um Why is that? Why can't? Why can we do data class.

C

Okay, export digged, okay, spec.

A

Okay, so it must be saying it must be trying to create. I think op must be doing it yeah, it must be op. Where is it.

D

A

C

A

What is happening, then? Okay, so if you set that as a date, if you make it a data class, if you make it nothing, it just says you can't do that. You make it a name tuple, it blows up because it wants to represent a path.

C

Okay, what if we make that config.

C

Or let's just make a data class right, we should support regular data classes, all right.

C

A

C

C

C

All right, export, tick.

A

All right, so how could we do this.

A

In such a way, I think what we could do here is say.

D

C

C

A

I'm trying it with a bunch of different types: um okay, so.

A

Okay, um all right, let's try, I think I think it might work um we'll just we'll just see where it takes so.

A

A

A

Okay, so if is instance.

A

All right, our good old friend.

F

Ray is not.

A

Implemented here when.

B

In doubt, ray's.

A

Not implemented error, it's a good thing, it's better than implementing it wrong. um Then it lets somebody else know if you want this functionality, here's exactly where you insert it. So, okay, so not implemented here.

A

So, basically attempt conversion if you fail raise not implemented error. So if not spec.

A

Okay, subspec is meant to denote when um the top level is a list or a mapping itself, or I think yeah is a list or a mapping itself. Yeah.

A

And then spec is treated as the interior type.

C

Okay, so exported spec.

A

And I think that's determined based off the primitive.

A

So if the primitive is array then um or the primitive is uh mapping for a dictionary uh that will be stored in the primitive value of the definition and then subspec and that are used together to determine whether it's you know needs to be converted from an array or from a mapping um with spec as the internal type. Okay. So, um if is alif, is instance, um okay, so this is named hubble.

A

Right, that's what we've got right now so and then we'll put.

E

A

You know self.spec is of unknown type or export.

A

Or unknown unknown how to export cell types back.

B

Okay, let's see.

A

Is instance, r2 must be type or tuple of types. So what's named, tuplegum you're not a type super.

A

Let's just do tuple.

A

Okay, so unknown how to export class get revo spec all right. Let's see what the what's up with that. So do so feature get dfml futuregate definition, featured definitions, garypo spec, all right name, tuple, okay, elections.name, tuple,.

A

I bet it's, I think, typing.

C

I can just input selections.

A

Arc two must be type or tuple of types all right. Let's go find out all right.

C

A

D

A

I think I've tried this before.

A

Okay, we'll just do.

D

A

So uh what am I doing? I am saying I'm removing our. If is instance check, I'm adding a check which says.

A

Okay, so for all okay, so l, if all of these things, so if the spec has all of these attributes call name annotations field default, then export dict, right, okay, so but we're not going to do export dict we're actually going to do something else internally um and we'll say for key in that array.

C

And then that's a nested array, okay, so oh.

F

A

Oh okay, unknown how to export recommended standard community standard contribution? Okay, so it knows how to export that now. So now, let's see so, if so um and.

C

A

All right, so I want to add this dfmo df types file if staged all right. So this is what we've got so we we modified this a little bit and we we basically just said you know we're going to raise exception. If we don't know what to do with this thing right, so we're going to do we added some input, validation, rather just blindly doing it there so git commit, or actually let's run, the auto formatter on that.

A

Okay, so that's what I was worried about. Okay, so the auto formatter picked up something else. So.

C

C

Yeah, I need to go run the auto format around everything actually.

D

A

Me make a note of that: okay.

C

A

Okay, okay, so actually we might be getting close to this one. That's dataflow.export, okay, because this is where we're we're reaching towards the same stuff here. Remember so the config deck stuff and the manifest stuff are going to combine.

A

Remember it's all going to combine so um the um so we're going to we're going to use we're going to have the init function have uh include uh a you know like the schema reference for the for the config of the object being created, um and uh when we do that we have the inner function. Okay, so we have the inner function. Okay, so.

A

When we do that.

D

A

First, config set data flow export.

C

B

There's something here.

C

D

C

A

Okay, so when we return something from exported.

A

When we return something from export.

B

It should be an.

A

Object which is a manifest, so it should be. ah Oh, the unified config.

B

The unified, uh what was that the unified theory of config, unified theory of configuration or the unified configuration methodology or something uh saksham? You will probably remember this. You'll, probably notice.

A

There's uh when we did oh man, where is that? Okay? Well, it doesn't matter now, but basically what we said was, but this must be. This is yeah. Oh, this must be where that yeah. This is where this came from: okay, okay, so effectively what the hypothesis was was. um If you have three fields um you can you can?

A

Oh it's the same thing again, see upstream the overlay in the orchestrator.

A

Okay. The upstream is the plugin. The overlay is the config in the orchestrator. Is the sandbox.

E

A

Is the shima which is the archetype.

A

C

That makes sense.

D

A

A

So let me read my notes on the archetype: real quick while we're at it, um because I think we figured this out. um Let me put it to do and then let's, let's do it um so.

A

Okay, so uh archetype.

A

Okay, so um we'll cover the architect but okay, so the archetype is a construct for data.

A

So the archetype is a mental conscious drug to help us understand when data is aligned to a particular.

A

Set a system context, uh strategic principles.

A

And we'll put perhaps an overlay in part.

C

A

Okay, so that's the archetype.

A

Okay, so and there's more.

B

A

That, but actually I think I'm not going to do that so um so.

A

Okay, so the unified config, unified, config theory.

B

C

Where is that? Even if I can.

A

D

It's on a branch somewhere.

C

Based on sound shaking.

C

Oh yeah, I started okay, so it's three comments ahead of whatever it was.

D

A

A

How's, the ci, failing still still hasn't, picked it up. Okay, um so.

A

All right so, okay,.

A

Oh yeah, so let me just write this yeah, so the unified unified.

A

Config technology, uh okay, plug in was the other thing and the other one. It was plugin config.

A

What is it, where can I find it, and how do I know it is conforms to that.

A

A

Yeah, um okay,.

E

A

Here's the exchange manifest okay, so the manifest is there for also sort of the open architecture. Oh yeah, because the manifest is when the open architecture is a one level thing.

A

C

Spec versus subspec, okay,.

A

Okay, so that means we should be able to store anything in this format. Okay, um all right, let's do it. So this is the assertion. So then we should we should do it. We should follow.

C

Through with that, then okay.

A

C

D

A

So this thing will basically say.

A

And this is where it's a d id as well, because then you would add the did in that and the did doc. Okay, so um so the did doc would be the upstream and the did would be the overlay. I guess in that context.

A

It doesn't really, I mean it doesn't matter, okay, so.

A

Okay, it's like it's all right here, but it's like it's it's so close! So close, okay, um okay! So what are we? What are we running into so, let's, uh let's deal with this problem in hand so and we'll move towards that, and I think we'll end up.

C

A

um Okay, so what am I because I'm thinking right now, I think I think this input stuff will lead us to the right decision with um the data flow export, because I'm I'm debating every time you call export. Do you really want to know what the data is like? Do you really want the nested structure.

A

A

D

Argument is yes,.

A

Argument is yes, that's the argument of the manifest is hey. Let's all just agree that we should put all this stuff in every blob of data, and if we always agree that we can always put all this stuff in every blob of data, or we can figure it out by context.

A

Then we should be okay.

A

In this case context would be the parent object right, so the parent object has the context I have two now I have two. um The parent object has the context, and so the parent object should decide whether the child needs to be wrapped with schema and plugin name.

A

A

Explicit within the manifest.

A

Contract, what that data is, and therefore the schema to validate it, lives within the manifest itself and should be pulled or sourced as a reference from the schema of the object, which is internal.

A

So this is kind of like our subspec stuff, so.

A

Okay, come on come on, come on, come on, okay, come on come on, come on.

C

A

This is kind of like the subspec stuff, the context, the parent.

A

Stream of consciousness, folks, okay,.

C

D

A

Remember we're going for stream of consciousness, we're going for stream of consciousness. Okay. So if I were to make a next move, what would I make? What would my next move be? If I had to make a next move?

A

Well, uh we I would write down what I just said before um and then that will lead us to the next step. Okay, so when.

B

A

Write it down write down everything you know right. This is the methodology.

A

Methodology is right, enumerate everything you know uh enumerate of the things that you know, which ones are processes uh which ones are assets or processes which you could interconnect, uh enumerate all the possible interconnections, all the possible graphs right and then do a tuned brute force to find the best solution within the given time frame. This is the methodology, okay, so, okay, so.

A

What do we know? So, let's write down everything. We know um everything we know.

A

E

Is the methodology.

A

Okay and then let me write a little note here, um and this is in the thread button right everything you know.

A

Which are assets.

A

And which are processes uh how what okay so uh using tuned fruit force pruning the trees based on strategic principles.

A

And remember, the strategic principles are the very top level strategic plans.

A

Okay- and these are the top level conscious- you know we're also thinking of these as conscious or conceptual layers, or maybe even layers in a neural network, um and these are the strategic plans which you know are being.

B

A

Successfully so, basically any anywhere anywhere so where's, our giant uh where's, our giant graph right so where's, the giant graph.

A

uh I'll switch the giant graph.

A

No, not in there okay hmm um swear. We had to graph this a flow.

C

Chart where was it?

C

Okay, whatever.

A

Oh, it's here and then contributing okay. This, oh.

C

Great, it's horrible, okay, fantastic.

A

Not helpful, okay, anyways, you see this right so uh and you can sort of make out here um how there are different layers. Basically, as we move through and then we're gonna have the stages right, and so, if you had, what we need to do is we need to link up the uh the stages that we just created that we set to output?

A

um What we really need to do is is do something that's more like that: shim based approach, where we say next phase right or the next phase parser right- and we really just mean to say call this thing after everything in the last phase has completed right and so uh that that will that will because, because what's what's not shown in this diagram, I think is output operations and cleanup operations and those are the successive stages right. So we need to have this rolling ah okay, we need to have this rolling stage.

A

This rolling set of stages, this rolling set of stages, okay, we're gonna, have this rolling set of stages um and yeah, and then it just rolls just rolls forever: okay, um yeah, you just keep rolling you keep rolling. You keep rolling.

A

Okay, yeah and in each stage you could potentially add another stage. How could you potentially add another stage um on the fly?

A

How do you, how would you add another stage on the fly.

C

A

How would you add another stage on the fly?

A

You need to communicate with the input network and the operation network you need to trace through the the code in df memory. You see gather inputs in the dispatch operations, you need to see where the data flow is used and you need to be able to recommunicate a new data flow and update to the data flow to all of the network. Components within the.

A

Within the within the orchestrator that the orchestra uses so the the the lock network and the redundancy checker and all of this stuff, anything that might use the data flow it needs to, uh it needs to have a refresh on it, okay, and that would be able to signify what what that there's a new stage.

A

But what about the rolling through that doesn't seem like. So if it's rolling, why can't it just? Can it just roll back? Can it roll back into itself? It should be able to um so.

A

From that perspective, you have different entry points, yeah you're different in a in a given stage.

A

You may have different inputs from different origins, and so you could then uh trigger via a subflow or the launching of a context. Yeah you trigger, via the launching of a context.

D

A

Yeah, you would trigger, via the launching of a context with the input network, cache swapped in such a way that you.

A

What do you do you do a you, do a.

A

It's like a copy on.

D

A

A it's a it's a negative overlay. It's like. I ran into this problem with overhead overlay. If that's recently, it's a.

E

A

The overlay you, you want to subtract subtract a subtractive overlay, so you want to do it so so because overlay, the application is dynamic.

E

A

It's not just, and so right now.

E

A

Have is we just have a pure merge, but because it's dynamic and when we do get to doing it with the apply at the run time, which is what we're supposed to be doing and not just combining all the operations right via the load call we, which is what we're doing right now. Just for sake of time.

A

We can have this overlay, we can. We can, in the overlay application, remove bits of inputs from the cache of the flow of the data flow being the data flow having overlays applied to.

D

A

Okay, so here data flow having overlays data flow, we are applying overlays to by running overlay data flow and passing as an input. This is the one that actually is the real data flow that we're putting in here that we're this is the upstream. This should just say upstream. This should say upstream. This should say upstream.

A

How dumb is that? Okay um excuse me.

A

Upstream hilarious.

C

D

D

A

Okay, so now we can just pass in upstream.

A

Oh so now, oh, oh, okay, where's the code show me the code show me the code. Okay,.

A

Okay, so where is it upstream overlay orchestrator.

A

Okay, so the input definition, conversion by origin, values, operation instance, name.

C

A

uh That is at the wrong indentation level.

A

Or no, it's not! Okay, it's just okay! So this is basically this just didn't get deleted. Okay, um so load default deployment, environment, input, definitions, list, input, definitions,.

A

Okay um inputs items, okay, yeah, so short names, it is going to do it on short name, so we can do upstream, so, uh okay, so we can do upstream.

A

So we can take the system context, so we can take a data flow. We can make it a system context as class and then we can take a data flow. We can make it a system. Context is class and we can pass it to.

A

Okay system context: upstream: okay, so okay, apply overlay, overlay.deployment, okay, overlay, okay, so system context. Okay, here we go hallelujah.

A

All right: what is the system context? The system context is the upstream, the overlay and the orchestrator, so um the upstream, in this case is overlay, is not none, so overlay system context equals create so, let's say, create a system context to.

D

A

The overlay all right okay, so if it is not already okay, no, let's actually say okay, so, let's actually say so. Overlay is class. Overlay overlay overlay apply overlay, okay, so, let's actually so to do to move this into overlay.load.

A

Okay, so inspect is class overlay, overlays overlay, okay, so basically instantiate it. If it's a class, if it's not instantiated, so apply overlay.

F

Okay, all right so.

C

Come on come on come on all right.

A

A

A

So, let's play with it right now, let's say.

C

So let's ignore this.

A

Okay, so overlay system context: okay, some memory.

A

So, oh the overlay system context. So if you give us a data flow okay, so if you give us a data flow here, so if is instance.

A

D

C

A

Let's just do, if not raise.

C

A

C

Okay, so let's say data flow system.

C

C

F

A

B

Come on, we almost have the overlay stuff. This is exciting.

D

C

D

A

Orchestrated equals none.

C

It's just the systems.

C

A

All right what.

C

A

The overlay dfmo overlays installed: okay.

A

And this is happening because apply, install overlays is set okay, so.

A

And then this thing comes in and it says basically gtfo. Okay, so.

A

Why is that? Why are you telling us to gtfo, okay, so union system context config data flow okay? So let's do union system context.

C

System context, config data file.

A

No support for string types other than own class, oh yeah, so you're.

C

So so you are correct.

A

What are you on about here? Okay, so basically, let's say data flow first and then maybe I think it's a bug with the typing code.

A

That does the conversion.

C

And it only checks the first thing: let's, let's just fix it: let's fix the bug gear file base.

A

Okay, so 281.

C

Okay, so convert value and then 248 okay. So if convert okay. So if aug's.

A

Annotation is not none.

D

C

Okay, possible type, okay class.

C

If not overlays.

A

Installed, so is that not a data flow.

A

System, context.subclass, okay, so.

F

Oh wow, that's ugly.

A

Oh, that's horrendous.

A

C

So this is already a system context.

A

I've got all these windows and I'm working on it.

C

A

A

So if it is a data flow, then convert it.

A

Go apply installed, overlays.

A

System contacts, okay,.

C

Export self.config.upstream.export.

A

What is this thing.

A

Okay, david philbin, overlaid.

C

Okay, so this is.

A

Okay, so configurably apply installed. Overlays.

D

C

Oh yeah didn't sleep very well all right.

C

F

C

So then, whenever you define a system context, you better define the upstream, you might define the overlay, you might find your exterior, you might leave it up to the execution environment, at which point the execution environment would produce.

F

A manifest which is.

C

So your schema is built out of your types or out of your data flows, which build your types for your system, account access, class and.

A

C

Implicit with the plugins.

A

C

C

D

All right, okay, so.

D

A

Overlay is instead, okay, so that's happy now! Okay, so let's continue apply overlay.

C

So what actually happens here is anything happening.

C

Okay, so what is apply? Overlay overlay, dot deployment.

A

Oh we're not running it with any inputs. That's why so.

C

C

C

So ctx right over there, where is this breakpoint.

D

D

C

C

So apply the overlay.

C

I think I'm done right now. Wow. I just took a short turn.