hydra | OAuth Provider written in Go - cloud | Authentication library

# Option 1: With a non-overridable defaults list
defaults:
  - site/fb@site.fb
  - site/google@site.google
# Option 2: With an overridable defaults list
defaults:
  - site@site.fb: fb
  - site@site.google: google

$ python my_app.py
server:
  site:
    fb:
      domain: facebook.com
    google:
      domain: google.com
  host: localhost
  port: 443

# Option 1: With a non-overridable defaults list
defaults:
  - site/fb@foo
  - site/google@bar
# Option 2: With an overridable defaults list
defaults:
  - site@foo: fb
  - site@bar: google

$ python my_app.py
server:
  foo:
    domain: facebook.com
  bar:
    domain: google.com
  host: localhost
  port: 443

$ python my_app.py server/site@server.foo=amazon
server:
  foo:
    domain: amazon.com
  bar:
    domain: google.com
  host: localhost
  port: 443

 ["removeFakeIdentifiersFromJsonLdResponseBody", EventPriorities::POST_SERIALIZE],
        ];
    }

    public function removeFakeIdentifiersFromJsonLdResponseBody(ViewEvent $event): void
    {
        $requestAcceptHeader = $event->getRequest()->headers->get('accept', 'none');
        if (str_contains($requestAcceptHeader, "application/ld+json")) {
            $this->removefakeIdentifiersFromResponseBody($event);
        }
    }

    private function removefakeIdentifiersFromResponseBody(ViewEvent $event): void
    {
        $responseBody = $event->getControllerResult();
        $decodedResponseBody = json_decode($responseBody);
        $this->removeFakeIdentifiersFromObject($decodedResponseBody);
        $encodedResponseBody = json_encode($decodedResponseBody);
        $event->setControllerResult($encodedResponseBody);
    }

    private function removeFakeIdentifiersFromObject(object $responseBody): void
    {
        foreach ($responseBody as $property => $value) {
            $this->removeFakeIdRecursively($property, $value, $responseBody);
        }
    }

    private function removeFakeIdRecursively(string $property, mixed $value, object $responseBody): void
    {
        if ($property === "@id" && str_starts_with($value, "_:")) {
            unset($responseBody->$property); // removes "@id"
            unset($responseBody->{"@type"});
        } elseif (is_object($value)) {
            $this->removeFakeIdentifiersFromObject($value);
        } elseif (is_array($value)) {
            foreach ($value as $object) {
                if (is_object($object)) {
                    $this->removeFakeIdentifiersFromObject($object);
                }
            }
        }
    }
}

    
        net6.0
        enable
        enable
        grey
    
....

    
    
    Blazr.Medusa.Grey
    
    
    
    



    Loading...

    
        An unhandled error has occurred.
        Reload
        🗙
    
    

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorPages();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.MapWhen(ctx => ctx.Request.Path.StartsWithSegments("/grey"), app1 =>
{
    app1.UseBlazorFrameworkFiles("/grey");
    app1.UseRouting();
    app1.UseEndpoints(endpoints =>
    {
        endpoints.MapFallbackToFile("/grey/{*path:nonfile}", "/grey/index.html");
    });
});

app.MapWhen(ctx => ctx.Request.Path.StartsWithSegments("/green"), app1 =>
{
    app1.UseBlazorFrameworkFiles("/green");
    app1.UseRouting();
    app1.UseEndpoints(endpoints =>
    {
        endpoints.MapFallbackToFile("/green/{*path:nonfile}", "/green/index.html");
    });
});

app.MapWhen(ctx => ctx.Request.Path.StartsWithSegments("/purple"), app1 =>
{
    app1.UseBlazorFrameworkFiles("/purple");
    app1.UseRouting();
    app1.UseEndpoints(endpoints =>
    {
        endpoints.MapFallbackToFile("/purple/{*path:nonfile}", "/purple/index.html");
    });
});

app.UseBlazorFrameworkFiles("");

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();


app.MapFallbackToFile("/index.html");

app.Run();

    Go Base
    Go Grey
    Go Green
    Go Purple


@code {

    [Inject] private NavigationManager? NavManager { get; set; }
    
    private void Go(string colour)
        => this.NavManager?.NavigateTo($"/{colour}", true);
}

# conf/config.yaml
defaults:
  - callbacks@_callback_dict.cb1: callback_01
  - callbacks@_callback_dict.cb2: callback_02
  - trainer: default
  - _self_

# conf/trainer/default.yaml
_target_: pytorch_lightning.Trainer
callbacks: ${oc.dict.values:_callback_dict}

# my_app.py
from typing import Any
import hydra
from omegaconf import DictConfig, OmegaConf

@hydra.main(config_path="conf", config_name="config")
def app(cfg: DictConfig) -> Any:
    OmegaConf.resolve(cfg)
    del cfg._callback_dict
    print(OmegaConf.to_yaml(cfg))

if __name__ == "__main__":
    app()

$ python my_app.py
trainer:
  _target_: pytorch_lightning.Trainer
  callbacks:
  - _target_: callback_to_instantiate_01
  - _target_: callback_to_instantiate_02

# app.py
from dataclasses import dataclass
from enum import Enum
import hydra
from hydra.core.config_store import ConfigStore
from omegaconf import DictConfig

class SomeEnumClass(Enum):
    ENUM1 = 1
    ENUM2 = 2

@dataclass
class Schema:
    enum: SomeEnumClass
    x: int = 123
    y: str = "abc"

def store_schema() -> None:
    cs = ConfigStore.instance()
    cs.store(name="base_config_cs", node=Schema)

@hydra.main(config_path=".", config_name="foo")
def app(cfg: DictConfig) -> None:
    print(cfg)

if __name__ == "__main__":
    store_schema()
    app()

# foo.yaml
defaults:
  - base_config_cs
  - _self_
enum: ENUM1
x: 456

$ python app.py y=xyz
{'enum': , 'x': 456, 'y': 'xyz'}

# reload.py
import os
from hydra import compose, initialize_config_dir
from hydra.core.config_store import ConfigStore
from app import store_schema

config_name = "config"
exp_dir = os.path.abspath("outputs/2022-02-05/07-19-56")
saved_cfg_dir = os.path.join(exp_dir, ".hydra")
assert os.path.exists(f"{saved_cfg_dir}/{config_name}.yaml")

store_schema()  # stores `base_config_cs`
cs = ConfigStore.instance()
cs.store(
    name="reload_conf",
    node={
        "defaults": [
            "base_config_cs",
            config_name,
        ]
    },
)

with initialize_config_dir(config_dir=saved_cfg_dir):
    cfg = compose("reload_conf")
print(cfg)

$ python reload.py
{'enum': , 'x': 456, 'y': 'xyz'}

# app2.py
from dataclasses import dataclass
from enum import Enum
from typing import Any, List
import hydra
from hydra.core.config_store import ConfigStore
from omegaconf import MISSING, DictConfig

class SomeEnumClass(Enum):
    ENUM1 = 1
    ENUM2 = 2

@dataclass
class RootConfig:
    defaults: List[Any] = MISSING
    enum: SomeEnumClass = MISSING
    x: int = 123
    y: str = "abc"

def store_root_config(primary_config_name: str) -> None:
    cs = ConfigStore.instance()
    # defaults list defined here:
    cs.store(
        name="root_config", node=RootConfig(defaults=["_self_", primary_config_name])
    )

@hydra.main(config_path=".", config_name="root_config")
def app(cfg: DictConfig) -> None:
    print(cfg)

if __name__ == "__main__":
    store_root_config("foo2")
    app()

# foo2.yaml (note NO DEFAULTS LIST)
enum: ENUM1
x: 456

$ python app2.py hydra.job.chdir=false y=xyz
{'enum': , 'x': 456, 'y': 'xyz'}

# reload2.py
import os
from hydra import compose, initialize_config_dir
from hydra.core.config_store import ConfigStore
from app2 import store_root_config

config_name = "config"
exp_dir = os.path.abspath("outputs/2022-02-05/07-45-43")
saved_cfg_dir = os.path.join(exp_dir, ".hydra")
assert os.path.exists(f"{saved_cfg_dir}/{config_name}.yaml")

store_root_config("config")
with initialize_config_dir(config_dir=saved_cfg_dir):
    cfg = compose("root_config")
print(cfg)

$ python reload2.py
{'enum': , 'x': 456, 'y': 'xyz'}

# reload3.py
import os
import yaml
from hydra import compose, initialize
from app import store_schema

config_name = "config"
exp_dir = os.path.abspath("outputs/2022-02-05/07-19-56")
saved_cfg_dir = os.path.join(exp_dir, ".hydra")
overrides_path = f"{saved_cfg_dir}/overrides.yaml"
assert os.path.exists(overrides_path)

overrides = yaml.unsafe_load(open(overrides_path, "r"))
print(f"{overrides=}")
store_schema()
with initialize(config_path="."):
    cfg = compose("foo", overrides=overrides)
print(cfg)

$ python reload3.py
overrides=['y=xyz']
{'enum': , 'x': 456, 'y': 'xyz'}

# config.yaml

arg1: numpy.float32  # note: use "numpy" here, not "np"
arg2: tensorflow.float16

# python code
...
from hydra.utils import get_class
arg1 = get_class(config.arg1)
arg2 = get_class(config.arg2)

from omegaconf import OmegaConf
from hydra.utils import get_class

OmegaConf.register_new_resolver(name="get_cls", resolver=lambda cls: get_class(cls))

config = OmegaConf.create("""
# config.yaml

arg1: "${get_cls: numpy.float32}"
arg2: "${get_cls: tensorflow.float16}"
""")

arg1 = config.arg1
arg1 = config.arg2

>>> isinstance(tf.float16, type)
False
>>> callable(tf.float16)
False

>>> tf.as_dtype("float16")
tf.float16