hyf

Context-aware query service for Radroots
git clone https://radroots.dev/git/hyf.git
Log | Files | Refs | README | LICENSE

registry.mojo (9571B)

      1 from std.collections import List, Optional
      2 
      3 from json import Value
      4 
      5 from hyf_core.capabilities.explain_result import execute_explain_result
      6 from hyf_core.capabilities.query_rewrite import execute_query_rewrite
      7 from hyf_core.capabilities.semantic_rank import execute_semantic_rank
      8 from hyf_core.errors import (
      9     CapabilityResult,
     10     capability_not_implemented_error,
     11     failed_capability,
     12     invalid_input_error,
     13     successful_capability,
     14 )
     15 from hyf_core.request_context import RequestContext
     16 from hyf_application.farm_operation import execute_farm_update_interpret
     17 from hyf_application.buyer_operation import (
     18     execute_buyer_request_interpret,
     19     execute_buyer_request_match,
     20 )
     21 
     22 
     23 @fieldwise_init
     24 struct BusinessCapabilityDescriptor(Copyable, Movable):
     25     var id: String
     26     var deterministic_enabled: Bool
     27     var implemented: Bool
     28     var callable: Bool
     29     var deterministic_backend: String
     30     var assisted_available: Bool
     31     var disabled_reason: String
     32 
     33 
     34 def canonical_business_capabilities() -> List[BusinessCapabilityDescriptor]:
     35     var capabilities = List[BusinessCapabilityDescriptor]()
     36     capabilities.append(
     37         BusinessCapabilityDescriptor(
     38             id="query_rewrite",
     39             deterministic_enabled=True,
     40             implemented=True,
     41             callable=True,
     42             deterministic_backend="heuristic",
     43             assisted_available=False,
     44             disabled_reason="",
     45         )
     46     )
     47     capabilities.append(
     48         BusinessCapabilityDescriptor(
     49             id="filter_extraction",
     50             deterministic_enabled=False,
     51             implemented=False,
     52             callable=False,
     53             deterministic_backend="",
     54             assisted_available=False,
     55             disabled_reason="deferred_bootstrap_capability",
     56         )
     57     )
     58     capabilities.append(
     59         BusinessCapabilityDescriptor(
     60             id="semantic_rank",
     61             deterministic_enabled=True,
     62             implemented=True,
     63             callable=True,
     64             deterministic_backend="heuristic",
     65             assisted_available=False,
     66             disabled_reason="",
     67         )
     68     )
     69     capabilities.append(
     70         BusinessCapabilityDescriptor(
     71             id="summarize_listing",
     72             deterministic_enabled=False,
     73             implemented=False,
     74             callable=False,
     75             deterministic_backend="",
     76             assisted_available=False,
     77             disabled_reason="deferred_bootstrap_capability",
     78         )
     79     )
     80     capabilities.append(
     81         BusinessCapabilityDescriptor(
     82             id="summarize_farm",
     83             deterministic_enabled=False,
     84             implemented=False,
     85             callable=False,
     86             deterministic_backend="",
     87             assisted_available=False,
     88             disabled_reason="deferred_bootstrap_capability",
     89         )
     90     )
     91     capabilities.append(
     92         BusinessCapabilityDescriptor(
     93             id="workflow_plan",
     94             deterministic_enabled=False,
     95             implemented=False,
     96             callable=False,
     97             deterministic_backend="",
     98             assisted_available=False,
     99             disabled_reason="deferred_bootstrap_capability",
    100         )
    101     )
    102     capabilities.append(
    103         BusinessCapabilityDescriptor(
    104             id="explain_result",
    105             deterministic_enabled=True,
    106             implemented=True,
    107             callable=True,
    108             deterministic_backend="heuristic",
    109             assisted_available=False,
    110             disabled_reason="",
    111         )
    112     )
    113     capabilities.append(
    114         BusinessCapabilityDescriptor(
    115             id="dedupe_cluster",
    116             deterministic_enabled=False,
    117             implemented=False,
    118             callable=False,
    119             deterministic_backend="",
    120             assisted_available=False,
    121             disabled_reason="deferred_bootstrap_capability",
    122         )
    123     )
    124     return capabilities^
    125 
    126 
    127 def bootstrap_capability_count() -> Int:
    128     return len(canonical_business_capabilities())
    129 
    130 
    131 def implemented_deterministic_capability_count() -> Int:
    132     var implemented = 0
    133     for capability in canonical_business_capabilities():
    134         if capability.deterministic_enabled and capability.implemented:
    135             implemented += 1
    136     return implemented
    137 
    138 
    139 def deterministic_enabled_capabilities() -> List[String]:
    140     var enabled = List[String]()
    141     for capability in canonical_business_capabilities():
    142         if capability.deterministic_enabled:
    143             enabled.append(String(capability.id))
    144     return enabled^
    145 
    146 
    147 def all_deterministic_capabilities_implemented() -> Bool:
    148     return implemented_deterministic_capability_count() == len(
    149         deterministic_enabled_capabilities()
    150     )
    151 
    152 
    153 def deferred_capabilities() -> List[String]:
    154     var disabled = List[String]()
    155     for capability in canonical_business_capabilities():
    156         if not capability.deterministic_enabled:
    157             disabled.append(String(capability.id))
    158     return disabled^
    159 
    160 
    161 def canonical_business_capability(
    162     capability_id: String,
    163 ) -> Optional[BusinessCapabilityDescriptor]:
    164     for capability in canonical_business_capabilities():
    165         if capability.id == capability_id:
    166             return Optional[BusinessCapabilityDescriptor](capability.copy())
    167     return Optional[BusinessCapabilityDescriptor](None)
    168 
    169 
    170 def _dispatch_heuristic_registered_business_capability(
    171     capability_id: String, input: Value, context: RequestContext
    172 ) raises -> CapabilityResult:
    173     if capability_id == "query_rewrite":
    174         return execute_query_rewrite(input, context)
    175     if capability_id == "semantic_rank":
    176         return execute_semantic_rank(input, context)
    177     if capability_id == "explain_result":
    178         return execute_explain_result(input, context)
    179     return failed_capability(capability_not_implemented_error(capability_id))
    180 
    181 
    182 def is_gated_operation(capability_id: String) -> Bool:
    183     for descriptor in gated_operation_descriptors():
    184         if descriptor.id == capability_id:
    185             return True
    186     return False
    187 
    188 
    189 def execute_gated_operation(
    190     capability_id: String, input: Value
    191 ) raises -> CapabilityResult:
    192     try:
    193         if capability_id == "farm_update.interpret":
    194             return successful_capability(execute_farm_update_interpret(input))
    195         if capability_id == "buyer_request.interpret":
    196             return successful_capability(execute_buyer_request_interpret(input))
    197         if capability_id == "buyer_request.match":
    198             return successful_capability(execute_buyer_request_match(input))
    199         return failed_capability(
    200             capability_not_implemented_error(capability_id)
    201         )
    202     except e:
    203         return failed_capability(invalid_input_error(String(e)))
    204 
    205 
    206 def execute_registered_business_capability(
    207     capability_id: String, input: Value, context: RequestContext
    208 ) raises -> CapabilityResult:
    209     var capability = canonical_business_capability(capability_id)
    210     if not capability:
    211         return failed_capability(
    212             capability_not_implemented_error(capability_id)
    213         )
    214 
    215     var descriptor = capability.value().copy()
    216     if (
    217         not descriptor.deterministic_enabled
    218         or not descriptor.implemented
    219         or not descriptor.callable
    220     ):
    221         return failed_capability(
    222             capability_not_implemented_error(capability_id)
    223         )
    224 
    225     if descriptor.deterministic_backend == "heuristic":
    226         return _dispatch_heuristic_registered_business_capability(
    227             capability_id, input, context
    228         )
    229 
    230     return failed_capability(capability_not_implemented_error(capability_id))
    231 
    232 
    233 @fieldwise_init
    234 struct CapabilityExposure(Copyable, Movable):
    235     var capability_id: String
    236     var implementation_supported: Bool
    237     var provider_configured: Bool
    238     var assistance_permitted: Bool
    239     var provider_ready: Bool
    240     var exposed: Bool
    241 
    242 
    243 def capability_assisted_supported(capability_id: String) -> Bool:
    244     return capability_id == "query_rewrite"
    245 
    246 
    247 def capability_exposure(
    248     capability_id: String,
    249     provider_configured: Bool,
    250     assistance_permitted: Bool,
    251     provider_ready: Bool,
    252 ) -> CapabilityExposure:
    253     var supported = capability_assisted_supported(capability_id)
    254     return CapabilityExposure(
    255         capability_id=String(capability_id),
    256         implementation_supported=supported,
    257         provider_configured=provider_configured,
    258         assistance_permitted=assistance_permitted,
    259         provider_ready=provider_ready,
    260         exposed=(
    261             supported
    262             and provider_configured
    263             and assistance_permitted
    264             and provider_ready
    265         ),
    266     )
    267 
    268 
    269 @fieldwise_init
    270 struct GatedOperationDescriptor(Copyable, Movable):
    271     var id: String
    272     var requires_assistance: Bool
    273     var exposed: Bool
    274 
    275 
    276 def gated_operation_descriptors() -> List[GatedOperationDescriptor]:
    277     var descriptors = List[GatedOperationDescriptor]()
    278     descriptors.append(
    279         GatedOperationDescriptor(
    280             id="farm_update.interpret", requires_assistance=False, exposed=False
    281         )
    282     )
    283     descriptors.append(
    284         GatedOperationDescriptor(
    285             id="buyer_request.interpret",
    286             requires_assistance=False,
    287             exposed=False,
    288         )
    289     )
    290     descriptors.append(
    291         GatedOperationDescriptor(
    292             id="buyer_request.match", requires_assistance=False, exposed=False
    293         )
    294     )
    295     return descriptors^
    296 
    297 
    298 def gated_operation_is_exposed(
    299     operation: String, exposure_enabled: Bool
    300 ) -> Bool:
    301     for descriptor in gated_operation_descriptors():
    302         if descriptor.id == operation:
    303             return exposure_enabled
    304     return False