relationalai 0.13.5__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

relationalai/experimental/SF.py

@@ -1,38 +0,0 @@
-from relationalai.dsl import safe_symbol
-from relationalai.rel_utils import sanitize_identifier
-from relationalai.std import rel
-
-
-def SFRawType(model, *, source):
-    raw_relation_name = sanitize_identifier(source.lower())
-
-    # We run the normal machinery to setup the source + retrieve metadata, but never actually consume the relations
-    PyRelType = model.Type(f"__PyRel__{raw_relation_name}", source=source)
-
-    sf_gnf_rel_name = sanitize_identifier(raw_relation_name + "_pyrel_id")
-
-    # Generate the type from the raw table
-    # @NOTE: The actual type isn't associated with the source, we handle mapping the raw CDC relations directly via
-    #        zero-copy rules. This means the SFRawType entity ids are SF 160bit IDs instead of 128bit IDs, so
-    #        intermixing will cause issues. Use with caution.
-    # @NOTE: This work will be replaced by upstream work that does a similar thing but updates the CDC-created relations
-    #        to be in the exact format we want.
-    Typ = model.Type(f"__SF_RAW__{sf_gnf_rel_name}")
-    relation = getattr(rel, sf_gnf_rel_name)  # unary relation of IDs
-    with model.rule():
-        Typ.add(relation())
-
-    props = PyRelType.known_properties()
-
-    # Generate the property mappings for the SF columns
-    code = ""
-    for prop in props:
-        code += f"""
-            def {sanitize_identifier(prop)}(row, value): {{
-                {raw_relation_name}({safe_symbol(prop.upper())}, row, value)
-            }}
-        """
-
-    model.install_raw(code)
-
-    return Typ

relationalai/experimental/inspect.py

@@ -1,47 +0,0 @@
-from pandas import DataFrame
-import rich
-from rich.table import Table
-from rich import box
-from rich.console import Console
-from relationalai.environments.base import SourceInfo
-from relationalai.metamodel import Namer
-from relationalai.std import rel
-from relationalai.environments import runtime_env
-from relationalai.dsl import to_var
-
-_watch_info = {}
-
-def watch(*args):
-    ix = len(_watch_info)
-    namer = Namer()
-    _watch_info[ix] = {"loc": runtime_env.get_source(), "args": [namer.get(to_var(a)) for a in args]}
-    rel.output.__pyrel_debug_watch.add(ix, *args)
-
-def _watch_table(df:DataFrame):
-    # Create a table
-    table = Table(show_header=True, box=box.ROUNDED, padding=(0, 1))
-    for k in df.columns:
-        table.add_column(k)
-
-    for row in df.itertuples(index=False):
-        table.add_row(*[str(p) for p in row])
-
-    console = Console()
-    width = console.measure(table).maximum
-    rich.print(table)
-    row_str = f"{len(df)} rows"
-    rich.print(f"[dim white]{row_str:>{width-1}}")
-
-def _print_watch_frame(result_frame:DataFrame):
-    first_col = result_frame.columns[0]
-    for ix, group in result_frame.groupby(first_col):
-        source_info:SourceInfo = _watch_info[ix]["loc"]
-        line = source_info.source.split("\n")[source_info.line - source_info.source_start_line]
-        print()
-        rich.print(f"[yellow bold]{line.strip()}")
-        rich.print(f"[dim white]{source_info.file}:{source_info.line}")
-        print()
-        group = group.drop(first_col, axis=1)
-        group.columns = _watch_info[ix]["args"]
-        group.reset_index(drop=True, inplace=True)
-        _watch_table(group)

relationalai/experimental/pathfinder/__init__.py

@@ -1,158 +0,0 @@
-import typing
-import relationalai
-
-import relationalai.experimental
-import relationalai.experimental.pathfinder
-import relationalai.experimental.pathfinder.bridge
-from relationalai.experimental.pathfinder.rpq import RPQ
-
-__all__ = [
-    'node_filter',
-    'node',
-    'edge',
-    'path',
-    'optional',
-    'plus',
-    'star',
-    'union',
-    'RPQ',
-    'find_paths'
-]
-
-#-----------------------------------------------------------------------------
-# Parsing RPQ elements specified with strings (node and edge labels).
-#-----------------------------------------------------------------------------
-
-Segment = typing.Union[str, relationalai.dsl.Type, RPQ]
-
-def _process_segment(s: Segment) -> RPQ:
-    from relationalai.experimental.pathfinder.filter import NodeLabel, parse_label
-    from relationalai.experimental.pathfinder.rpq import Node, Edge
-
-    if isinstance(s, str):
-        label = parse_label(s)
-        if isinstance(label, NodeLabel):
-            return Node(label)
-        else:
-            return Edge(label)
-    elif isinstance(s, relationalai.dsl.Type):
-        return Node(NodeLabel(s._type.name))
-    elif isinstance(s, RPQ):
-        return s
-    else:
-        raise Exception(f"Incorrect type {type(s)} of segment '{s}'")
-
-
-#-----------------------------------------------------------------------------
-# User-facing RPQ constructors
-#-----------------------------------------------------------------------------
-
-# (filter)
-def node_filter(filter: typing.Callable) -> RPQ:
-    from relationalai.experimental.pathfinder.filter import AnonymousNodeFilter
-    from relationalai.experimental.pathfinder.rpq import Node
-
-    return Node(label = None, filter = AnonymousNodeFilter(filter))
-
-
-# (node_lab {∧ filter})
-def node(node_lab: typing.Union[str,relationalai.dsl.Type],
-         filter: typing.Optional[typing.Callable] = None) -> RPQ:
-    from relationalai.experimental.pathfinder.filter import (
-        NodeLabel, AnonymousNodeFilter, parse_label
-    )
-    from relationalai.experimental.pathfinder.rpq import Node
-
-    filter = AnonymousNodeFilter(filter) if filter is not None else None
-
-    if isinstance(node_lab, relationalai.dsl.Type):
-        label = NodeLabel(node_lab._type.name)
-    else:
-        label = parse_label(node_lab)
-    assert isinstance(label, NodeLabel), f"Expected a node label, got {label}"
-
-    return Node(label, filter)
-
-# -[edge_lab {∧ filter}]- or <-[edge_lab {∧ filter}]-
-def edge(edge_lab:str, filter: typing.Optional[typing.Callable] = None) -> RPQ:
-    from relationalai.experimental.pathfinder.filter import (
-        EdgeLabel, AnonymousEdgeFilter, parse_label
-    )
-    from relationalai.experimental.pathfinder.rpq import Edge
-
-    label = parse_label(edge_lab)
-    assert isinstance(label, EdgeLabel), f"Expected an edge label, either `-[...]->` or `<-[...]-`, got {label}"
-    filter = AnonymousEdgeFilter(filter) if filter is not None else None
-    return Edge(label, filter)
-
-
-# (expr₁ ⋅ ... ⋅ exprₙ)
-def path(segment: Segment, *segments: Segment) -> RPQ:
-    from relationalai.experimental.pathfinder.rpq import Concat
-
-    pattern = _process_segment(segment)
-    for seg in segments:
-        pattern = Concat(pattern, _process_segment(seg))
-
-    return pattern
-
-# (expr₁ ⋅ ... ⋅ exprₙ)?
-def optional(*segments: Segment) -> RPQ:
-    from relationalai.experimental.pathfinder.rpq import Optional
-
-    return Optional(path(*segments))
-
-# (expr₁ ⋅ ... ⋅ exprₙ)+
-def plus(segment: Segment, *segments: Segment) -> RPQ:
-    from relationalai.experimental.pathfinder.rpq import Plus
-
-    return Plus(path(segment, *segments))
-
-# (expr₁ ⋅ ... ⋅ exprₙ)*
-def star(segment: Segment, *segments: Segment) -> RPQ:
-    from relationalai.experimental.pathfinder.rpq import Star
-
-    return Star(path(segment, *segments))
-
-# (expr₁ | ... | exprₙ)
-def union(segment: Segment, *segments: Segment) -> RPQ:
-    from relationalai.experimental.pathfinder.rpq import Union
-
-    pattern = _process_segment(segment)
-    for seg in segments:
-        pattern = Union(pattern, _process_segment(seg))
-
-    return pattern
-
-#-----------------------------------------------------------------------------
-# UI for path finding
-#-----------------------------------------------------------------------------
-
-# Create a type storing paths specified by the given RPQ pattern.
-def find_paths(pattern: RPQ, **params):
-    from relationalai.experimental.pathfinder.options import normalized_options
-    from relationalai.experimental.pathfinder.bridge import invoke_pathfinder
-
-    options = normalized_options(params)
-
-    return invoke_pathfinder(pattern, options)
-
-# Creates a connectivity relation from a given RPQ pattern.
-def conn(pattern: RPQ, **params):
-    from relationalai.std import rel
-    from relationalai.dsl import create_vars
-    from relationalai.experimental.pathfinder.options import normalized_options
-    from relationalai.experimental.pathfinder.compiler import compile_conn
-    from relationalai.experimental.pathfinder.datalog import install_program
-    from relationalai.experimental.pathfinder.utils import get_model
-
-    options = {**normalized_options(params), 'suppress_groundedness_test': True}
-    program = compile_conn(pattern, options)
-    pq_conn_rel = program.root_rel['conn_rel']
-
-    install_program(get_model(options), program, options)
-
-    x, y = create_vars(2)
-    getattr(rel, pq_conn_rel)(x, y)
-
-    return x, y

relationalai/experimental/pathfinder/api.py

@@ -1,160 +0,0 @@
-from relationalai.dsl import Symbol, InlineRelation
-from relationalai.debugging import logger
-
-
-#
-# This is the schema of the `Config` relation required by the Pathfinder Rel library, in
-# versions 0.7+.
-#
-CONFIG_SCHEMA = {
-    "graph_type": {
-        "type": "symbol",
-        "enum": ["labeled"],
-        "default": "labeled"
-    },
-    "semantics": {
-        "type": "symbol",
-        "enum": ["shortest_paths"],
-        "default": "shortest_paths"
-    },
-    "group": {
-        "type": "symbol",
-        "enum": ["any_pair"],
-        "default": "any_pair"
-    },
-    "selector": {
-        "type": "symbol",
-        "enum": ["all", "single", "limit"],
-        "default": "all"
-    },
-    "path_count": {
-        "type": int,
-        "default": None
-    },
-    "max_path_length": {
-        "type": int,
-        "default": None
-    },
-    "random_seed": {
-        "type": int,
-        "default": None
-    },
-    "path_ids": {
-        "type": "symbol",
-        "enum": ["canonical", "non_canonical"],
-        "default": "non_canonical"
-    },
-    "node_indexing": {
-        "type": "symbol",
-        "enum": ["zero_based", "one_based"],
-        "default": "zero_based"
-    },
-    "edge_indexing": {
-        "type": "symbol",
-        "enum": ["zero_based", "one_based"],
-        "default": "one_based"
-    },
-    "product_graph": {
-        "type": "symbol",
-        "enum": ["materialized", "non_materialized"],
-        "default": "non_materialized"
-    },
-    "search_strategy": {
-        "type": "symbol",
-        "enum": ["from_both_sides", "from_source", "from_target"],
-        "default": "from_both_sides"
-    },
-    "path_enum_partials": {
-        "type": "symbol",
-        "enum": ["dynamic", "static"],
-        "default": "dynamic"
-    },
-    "search_start_nodes": {
-        "type": "symbol",
-        "enum": ["multiple", "unique"],
-        "default": "multiple"
-    },
-    "search_radius": {
-        "type": "symbol",
-        "enum": ["unbounded", "bounded"],
-        "default": "bounded"
-    }
-}
-
-DEFAULT_CONFIG = {
-    "graph_type": "labeled",
-    "semantics": "shortest_paths",
-    "group": "any_pair",
-    "selector": "all",
-    "path_ids": "non_canonical",
-    "node_indexing": "zero_based",
-    "edge_indexing": "one_based",
-    "debug": "debug_off",
-    "product_graph": "materialized",
-    "search_strategy": "from_both_sides",
-    "path_enum_partials": "dynamic",
-    "search_start_nodes": "multiple",
-    "search_radius": "bounded"
-}
-
-#
-# Creates an inline relation with the content specified by the `contents` dict
-# interpreted with the help of the `schema`.
-#
-def make_inline_relation(model, contents, schema):
-    pairs = []
-    for k, v in contents.items():
-        if k not in schema:
-            logger.info(f"Skipping unknown key {k} with value {v}")
-            continue
-        elif v is None:
-            logger.info(f"Skipping key {k} with null value")
-            continue
-        elif schema[k]['type'] == 'symbol':
-            assert isinstance(v, str), f"Expected a string for {k}, got {v} of type {type(v)}"
-            pairs.append((Symbol(k), Symbol(v)))
-        else:
-            pairs.append((Symbol(k), v))
-
-
-    logger.info(f"Creating inline relation with {len(pairs)} pairs:")
-    for k, v in pairs:
-        logger.info(f"  {k._var.value}: {v._var.value if isinstance(v, Symbol) else v}")
-
-    return InlineRelation(model, pairs) # TAG: #pyrel
-
-#
-# Uses option values to creates an inlined `Config` relation with relevant configuration
-# values for a call of `find_paths` in Pathfinder Rel library.
-#
-def make_config_relation(model, options):
-    config = DEFAULT_CONFIG.copy()
-    config.update(options)
-
-    return make_inline_relation(model, config, CONFIG_SCHEMA)
-
-INPUT_SCHEMA = {
-    'pg_graph' :{
-        'type': 'relation'
-    },
-    'pg_source': {
-        'type': 'relation'
-    },
-    'pg_target': {
-        'type': 'relation'
-    }
-}
-
-#
-# Creates an inline relation with `Input` relation specifying the path query in the form of
-# a product graph.
-#
-def make_input_relation(model, pg_graph, pg_source, pg_target):
-
-    d = {
-        'pg_graph': pg_graph,
-        'pg_source': pg_source,
-        'pg_target': pg_target
-    }
-
-    return make_inline_relation(model, d, INPUT_SCHEMA)