Api-referens för Graph Builder (förhandsversion)

Klassen sentinel_graph är ett sätt att interagera med grafen Microsoft Sentinel, så att du kan definiera ditt grafschema, transformera data från Microsoft Sentinel datasjö till noder och kanter, publicera ett diagram, frågediagram och köra avancerade grafalgoritmer. Den här klassen är utformad för att fungera med Spark-sessioner i Jupyter Notebooks som körs på Microsoft Sentinel Spark-beräkning.

GraphSpecBuilder

Klassen GraphSpecBuilder är en fluent-byggare för att skapa grafspecifikationer med datapipelines och schemaintegrering.

Viktigt

Aliaset GraphBuilder för den här klassen är inaktuellt och tas bort i en framtida version. Använd GraphSpecBuilder i all ny kod.

# Deprecated — emits DeprecationWarning
from sentinel_graph.builders.graph_builder import GraphBuilder

# Recommended
from sentinel_graph import GraphSpecBuilder

Konstruktören

GraphSpecBuilder(context: ExecutionContext)

Parametrar:

context (ExecutionContext): Körningskontext som innehåller Spark-session och konfiguration

Höjer:

ValueError: Om kontexten är Ingen eller om grafnamnet inte kan fastställas

Statiska metoder

`start`

GraphSpecBuilder.start(context: Optional[ExecutionContext] = None) -> GraphSpecBuilder

Definiera en ny fluent graph builder.

Parametrar:

context (ExecutionContext, valfritt): ExecutionContext-instans. Om ingen används standardkontext.

Returnerar:

GraphSpecBuilder: Ny builder-instans

Exempel:

builder = GraphSpecBuilder.start(context=context)

Instansmetoder

`add_node`

def add_node(alias: str) -> NodeBuilderInitial

Börja skapa en noddefinition.

Parametrar:

alias (str): Unik identifierare för den här noden i grafen

Returnerar:

NodeBuilderInitial: Node Builder i initialt tillstånd

Exempel:

builder.add_node("user")

`add_edge`

def add_edge(alias: str) -> EdgeBuilderInitial

Börja skapa en gränsdefinition.

Parametrar:

alias (str): Identifierare för den här gränsen i grafen (kan delas över flera kanter)

Returnerar:

EdgeBuilderInitial: Edge builder i initialt tillstånd

Exempel:

builder.add_edge("accessed")

`done`

def done() -> GraphSpec

Slutför grafspecifikationen och returnera GraphSpec-instansen.

Returnerar:

GraphSpec: Fullständig grafspecifikation med datapipeline och schema

Höjer:

ValueError: Om grafen inte har några noder eller kanter, eller om verifieringen misslyckas

Exempel:

graph_spec = builder.done()

GraphSpec

Grafspecifikation med funktioner för datapipeline, schema och visning.

Konstruktören

GraphSpec(
    name: str,
    context: ExecutionContext,
    graph_schema: GraphSchema,
    etl_pipeline: Optional[ETLPipeline] = None
)

Parametrar:

name (str): Grafnamn
context (ExecutionContext): Körningskontext
graph_schema (GraphSchema): Diagramschemadefinition
etl_pipeline (ETLPipeline, valfritt): Datapipeline för förberedelse av diagram

Egenskaper

`nodes`

def nodes() -> DataFrame

Hämta noder DataFrame (lat, cachelagrad). Avgör automatiskt källan från datapipelinen eller lake-tabellen.

Returnerar:

DataFrame: Spark DataFrame som innehåller alla noder

Höjer:

ValueError: Om kontext saknas eller om DataFrames inte kan läsas in

`edges`

def edges() -> DataFrame

Hämta kanter DataFrame (lat, cachelagrad). Avgör automatiskt källan från datapipelinen eller lake-tabellen.

Returnerar:

DataFrame: Spark DataFrame som innehåller alla kanter

Höjer:

ValueError: Om kontext saknas eller om DataFrames inte kan läsas in

Metoder

`build_graph_with_data`

Obs!

build_graph_with_data är inaktuell och tas bort i en framtida version. Använd Graph.build(spec) i stället.

def build_graph_with_data() -> Dict[str, Any]

Kör datapipelinen och publicera diagrammet. Anropar Graph.build(self)internt , hämtar den returnerade Graphoch returnerar en bakåtkompatibel ordlista.

Returnerar:

Dict[str, Any]: Ordlista som innehåller:
- etl_result: Dataförberedelseresultat
- api_result: Publicera resultat (om det lyckas)
- api_error: Felsträng (om publiceringen misslyckades)
- instance_name: Graph-instansens namn
- status: "published" eller "prepared"

Exempel:

graph = Graph.build(spec)
print(f"Status: {graph.build_status.status}")

`get_schema`

def get_schema() -> GraphSchema

Hämta grafschemat.

Returnerar:

GraphSchema: Diagramschemadefinition

`get_pipeline`

Obs!

Den här metoden är inaktuell och kommer att tas bort i en framtida version. Datapipelinen är en intern implementeringsinformation och bör inte nås direkt.

def get_pipeline() -> Optional[ETLPipeline]

Hämta datapipelinen (Ingen för befintliga grafer).

Returnerar:

ETLPipeline eller None: Datapipeline om det är tillgängligt

`to_graphframe`

def to_graphframe(column_mapping: Optional[Dict[str, str]] = None) -> GraphFrame

Konvertera hela grafen till GraphFrame för att köra grafalgoritmer. Fungerar endast på lokala data (från datapipeline eller lake table).

Parametrar:

column_mapping (Dict[str, str], valfritt): Anpassad kolumnmappning med nycklar:
- "id": Kolumnnamn för hörn-ID
- "source_id": Kolumnnamn för Edge-käll-ID
- "target_id": Kolumnnamn för Edge-mål-ID

Returnerar:

GraphFrame: GraphFrame-objekt med alla hörn och kanter

Höjer:

ValueError: Om ExecutionContext inte är tillgängligt

Exempel:

gf = graph_spec.to_graphframe()
pagerank = gf.pageRank(resetProbability=0.15, maxIter=10)

`show`

def show(limit: int = 100, viz_format: str = "visual") -> None

Visa grafdata i olika format.

Parametrar:

limit (int, default=100): Maximalt antal noder/kanter som ska visas
viz_format (str, default="visual"): Utdataformat
- "table": Fullständiga DataFrame-tabeller (alla kolumner)
- "visual": Interaktiv grafvisualisering
- "all": Visa alla format

Höjer:

ValueError: Om formatet inte är ett av de värden som stöds

Exempel:

graph_spec.show(limit=50, viz_format="table")

`show_schema`

def show_schema() -> None

Visa grafschemat som en interaktiv grafvisualisering.

Exempel:

spec.show_schema()

Diagram

Frågebar grafinstans. Skapas via Graph.get() (befintlig graf) eller Graph.build() (från en GraphSpec).

Konstruktören

Graph(
    name: str,
    context: ExecutionContext,
    spec: Optional[GraphSpec] = None,
    build_status: Optional[BuildStatus] = None,
)

Parametrar:

name (str): Grafnamn
context (ExecutionContext): Körningskontext
spec (GraphSpec, valfritt): Bifogad grafspecifikation (anges av Graph.build())
build_status (BuildStatus, valfritt): Skapa resultatmetadata (anges av Graph.build())

Höjer:

ValueError: Om ExecutionContext är Ingen

Statiska metoder

`get`

Graph.get(name: str, context: Optional[ExecutionContext] = None) -> Graph

Hämta en grafinstans från en befintlig graf. Den returnerade Graph har spec=None och build_status=None.

Parametrar:

name (str): Graph-instansens namn
context (ExecutionContext, valfritt): Körningskontext (standardvärdet ExecutionContext.default())

Returnerar:

Graph: Graph-instans

Höjer:

ValueError: Om grafnamnet är tomt eller om grafinstansen inte finns

Exempel:

graph = Graph.get("my_graph", context=context)
graph.query("MATCH (n) RETURN n")

`prepare`

Graph.prepare(spec: GraphSpec) -> Graph

Kör förberedelsefasen för data för en GraphSpecutan publicering. Använd publish() efteråt för att registrera grafen och göra den frågebar.

Parametrar:

spec (GraphSpec): Diagramspecifikation som ska förberedas

Returnerar:

Graph: Grafinstans med spec bifogad och build_status.status == "prepared"

Höjer:

ValueError: Om specifikationen inte har någon datapipeline eller ingen körningskontext
RuntimeError: Om körningen av datapipelinen misslyckas

Exempel:

spec = GraphSpecBuilder.start(context=ctx).add_node(...).done()
graph = Graph.prepare(spec)
# Inspect results before publishing
graph.nodes.show()
graph.publish()
graph.query("MATCH (n) RETURN n")

`build`

Graph.build(spec: GraphSpec) -> Graph

Skapa ett diagram från en GraphSpec genom att förbereda data och publicera. Anropar Graph.prepare(spec) internt och försöker graph.publish()sedan . Till skillnad från att anropa dessa två metoder separat fångas publiceringsfel upp – det returnerade diagrammet har build_status.status == "prepared" och build_status.api_error anges i stället för att höjas.

Parametrar:

spec (GraphSpec): Diagramspecifikation att bygga från

Returnerar:

Graph: Grafinstans med spec bifogad och build_status ifylld

Höjer:

ValueError: Om specifikationen inte har någon datapipeline eller ingen körningskontext
RuntimeError: Om körningen av datapipelinen misslyckas

Exempel:

spec = GraphSpecBuilder.start(context=ctx).add_node(...).done()
graph = Graph.build(spec)
print(graph.build_status.status)  # "published" or "prepared" (None if neither ran)
graph.query("MATCH (n) RETURN n")

Egenskaper

`nodes`

def nodes() -> Optional[DataFrame]

Hämta noder DataFrame. Delegerar till self.spec.nodes när en specifikation är kopplad. Returnerar None annars.

`edges`

def edges() -> Optional[DataFrame]

Hämta dataramens kanter. Delegerar till self.spec.edges när en specifikation är kopplad. Returnerar None annars.

`schema`

def schema() -> Optional[GraphSchema]

Hämta diagramschema. Delegerar till self.spec.get_schema() när en specifikation är kopplad. Returnerar None annars.

Metoder

`query`

def query(query_string: str, query_language: str = "GQL") -> QueryResult

Kör en fråga mot grafinstansen med hjälp av GQL.

Parametrar:

query_string (str): Diagramfrågesträng (GQL-språk)
query_language (str, default="GQL"): Frågespråk

Returnerar:

QueryResult: Objekt som innehåller noder, kanter och metadata

Höjer:

ValueError: Om ExecutionContext eller Spark-sessionen saknas
RuntimeError: Om klientinitiering eller frågekörning misslyckas

Exempel:

result = graph.query("MATCH (u:user) WHERE u.age > 30 RETURN u")
result.show()

`reachability`

def reachability(
    *,
    source_property_value: str = None,
    target_property_value: str = None,
    source_property: Optional[str] = None,
    participating_source_node_labels: Optional[List[str]] = None,
    target_property: Optional[str] = None,
    participating_target_node_labels: Optional[List[str]] = None,
    participating_edge_labels: Optional[List[str]] = None,
    is_directional: bool = True,
    min_hop_count: int = 1,
    max_hop_count: int = 4,
    shortest_path: bool = False,
    max_results: int = 500
) -> QueryResult

[! OBS! reachability(query_input=ReachabilityQueryInput(...)) accepteras fortfarande men genererar DeprecationWarning och tas bort i en framtida version.

Utföra nåbarhetsanalys mellan käll- och målnoder.

Parametrar:

source_property_value (str): Värde som ska matchas för källegenskapen (verifieras vid körning. Måste anges när du inte använder query_input)
target_property_value (str): Värde som ska matchas för målegenskapen (verifieras vid körning. Måste anges när du inte använder query_input)
source_property (Valfritt[str]): Egenskapsnamn för att filtrera källnoder
participating_source_node_labels (Valfritt[List[str]]): Nodetiketter att betrakta som källor
target_property (Valfritt[str]): Egenskapsnamn för att filtrera målnoder
participating_target_node_labels (Valfritt[List[str]]): Nodetiketter att betrakta som mål
participating_edge_labels (Valfritt[List[str]]): Kantetiketter som ska bläddras igenom
is_directional (bool): Om kanterna är riktningsbaserade (standard: True)
min_hop_count (int): Minsta hopp (standard: 1)
max_hop_count (int): Maximalt antal hopp (standard: 4)
shortest_path (bool): Returnerar endast kortaste sökvägar (standard: False)
max_results (int): Maximalt resultat (standard: 500)

Höjer:

ValueError: Om source_property_value eller target_property_value saknas, min_hop_count < 1, max_hop_count < min_hop_counteller max_results < 1
RuntimeError: Om klientinitiering eller frågekörning misslyckas

Returnerar:

QueryResult: Innehåller sökvägarna för nåbarhet

Exempel:

result = graph.reachability(
    source_property_value="user-001",
    target_property_value="device-003")
result.show()

`k_hop`

def k_hop(
    *,
    source_property: Optional[str] = None,
    source_property_value: Optional[str] = None,
    participating_source_node_labels: Optional[List[str]] = None,
    target_property: Optional[str] = None,
    target_property_value: Optional[str] = None,
    participating_target_node_labels: Optional[List[str]] = None,
    participating_edge_labels: Optional[List[str]] = None,
    is_directional: bool = True,
    min_hop_count: int = 1,
    max_hop_count: int = 4,
    shortest_path: bool = False,
    max_results: int = 500
) -> QueryResult

Obs!

k_hop(query_input=K_HopQueryInput(...)) godkänns DeprecationWarning fortfarande men genererar och tas bort i en framtida version.

Utför k-hop-analys från en viss källnod.

Parametrar:

Samma som reachability

Validering:

Minst en av source_property_value eller target_property_value måste tillhandahållas

Höjer:

ValueError: Om varken source_property_value eller target_property_value tillhandahålls, eller om numeriska begränsningar överträds (samma som reachability)
RuntimeError: Om klientinitiering eller frågekörning misslyckas

Returnerar:

QueryResult: Innehåller k-hop-resultaten

Exempel:

result = graph.k_hop(source_property_value="user-001")
result.show()

`blast_radius`

def blast_radius(
    *,
    source_property_value: str = None,
    target_property_value: str = None,
    source_property: Optional[str] = None,
    participating_source_node_labels: Optional[List[str]] = None,
    target_property: Optional[str] = None,
    participating_target_node_labels: Optional[List[str]] = None,
    participating_edge_labels: Optional[List[str]] = None,
    is_directional: bool = True,
    min_hop_count: int = 1,
    max_hop_count: int = 4,
    shortest_path: bool = False,
    max_results: int = 500
) -> QueryResult

Obs!

blast_radius(query_input=BlastRadiusQueryInput(...)) godkänns DeprecationWarning fortfarande men genererar och tas bort i en framtida version.

Utföra blastradieanalys från källnod till målnod.

Parametrar:

source_property_value (str): Värde som identifierar källnoden (verifieras vid körning. Måste anges när du inte använder query_input)
target_property_value (str): Värde som identifierar målnoden (verifieras vid körning. Måste anges när du inte använder query_input)
Andra parametrar: samma som reachability

Höjer:

ValueError: Om source_property_value eller target_property_value saknas, eller om numeriska begränsningar överträds (samma som reachability)
RuntimeError: Om klientinitiering eller frågekörning misslyckas

Returnerar:

QueryResult: Innehåller resultat från explosionsradien

Exempel:

result = graph.blast_radius(
    source_property_value="user-003",
    target_property_value="device-003",
    min_hop_count=1)
result.show()

`centrality`

def centrality(
    *,
    participating_source_node_labels: Optional[List[str]] = None,
    participating_target_node_labels: Optional[List[str]] = None,
    participating_edge_labels: Optional[List[str]] = None,
    threshold: int = 3,
    centrality_type: CentralityType = None,
    max_paths: int = 1000000,
    is_directional: bool = True,
    min_hop_count: int = 1,
    max_hop_count: int = 4,
    shortest_path: bool = False,
    max_results: int = 500
) -> QueryResult

Obs!

centrality(query_input=CentralityQueryInput(...)) godkänns DeprecationWarning fortfarande men genererar och tas bort i en framtida version.

Utför centralitetsanalys i diagrammet.

Parametrar:

participating_source_node_labels (Valfritt[List[str]]): Källnodetiketter
participating_target_node_labels (Valfritt[List[str]]): Målnodetiketter
participating_edge_labels (Valfritt[List[str]]): Kantetiketter som ska bläddras igenom
threshold (int): Minsta centralitetspoäng (standard: 3); måste vara icke-negativ
centrality_type (CentralityType): CentralityType.Node eller CentralityType.Edge (standard: None, återgår till CentralityType.Node)
max_paths (int): Maximalt antal sökvägar att överväga (standard: 1000000; 0 = alla sökvägar); måste vara icke-negativa
is_directional (bool): Om kanterna är riktningsbaserade (standard: True)
min_hop_count (int): Minsta hopp (standard: 1); måste vara ≥ 1
max_hop_count (int): Maximalt antal hopp (standard: 4); måste vara ≥ min_hop_count
shortest_path (bool): Returnerar endast kortaste sökvägar (standard: False)
max_results (int): Maximalt resultat (standard: 500); måste vara ≥ 1

Höjer:

ValueError: Om threshold < 0, max_paths < 0, min_hop_count < 1, max_hop_count < min_hop_counteller max_results < 1
RuntimeError: Om klientinitiering eller frågekörning misslyckas

Returnerar:

QueryResult: Innehåller måtten för centralitet

Exempel:

result = graph.centrality(
    participating_source_node_labels=["user", "device"],
    participating_target_node_labels=["device", "user"],
    participating_edge_labels=["sign_in"],
    is_directional=False)
result.show()

`ranked`

def ranked(
    *,
    rank_property_name: str = None,
    threshold: int = 0,
    max_paths: int = 1000000,
    decay_factor: float = 1,
    is_directional: bool = True,
    min_hop_count: int = 1,
    max_hop_count: int = 4,
    shortest_path: bool = False,
    max_results: int = 500
) -> QueryResult

Obs!

ranked(query_input=RankedQueryInput(...)) godkänns DeprecationWarning fortfarande men genererar och tas bort i en framtida version.

Utför rangordnad analys i diagrammet.

Parametrar:

rank_property_name (str): Egenskapsnamn som ska användas för rangordning (verifieras vid körning. Måste anges när du inte använder query_input)
threshold (int): Returnera endast sökvägar över den här vikten (standard: 0); får inte vara negativa
max_paths (int): Maximalt antal sökvägar att överväga (standard: 1000000; 0 = alla sökvägar); måste vara icke-negativa
decay_factor (flyttal): Rangordna förfall per steg; 2 innebär halvering (standard: 1); måste vara icke-negativ
is_directional (bool): Om kanterna är riktningsbaserade (standard: True)
min_hop_count (int): Minsta hopp (standard: 1); måste vara ≥ 1
max_hop_count (int): Maximalt antal hopp (standard: 4); måste vara ≥ min_hop_count
shortest_path (bool): Returnerar endast kortaste sökvägar (standard: False)
max_results (int): Maximalt resultat (standard: 500); måste vara ≥ 1

Höjer:

ValueError: Om rank_property_name saknas, threshold < 0, max_paths < 0, decay_factor < 0, min_hop_count < 1, max_hop_count < min_hop_counteller max_results < 1
RuntimeError: Om klientinitiering eller frågekörning misslyckas

Returnerar:

QueryResult: Innehåller rangordnade noder/kanter

Exempel:

result = graph.ranked(
    rank_property_name="risk_score",
    threshold=5,
    decay_factor=2)
result.show()

`to_graphframe`

def to_graphframe(column_mapping: Optional[Dict[str, str]] = None) -> GraphFrame

Konvertera hela grafen till GraphFrame. Använder specifikationsdata när de är tillgängliga. läsningar från laketabeller annars.

Parametrar:

column_mapping (Dict[str, str], valfritt): Anpassad kolumnmappning

Returnerar:

GraphFrame: GraphFrame-objekt med alla hörn och kanter

Exempel:

gf = graph.to_graphframe()

`show`

def show() -> None

Visa diagraminformation. Delegerar till spec.show() för omfattande visning när en specifikation är kopplad. Skriver ut minimal information annars.

`show_schema`

def show_schema() -> None

Visa diagramschema. Delegerar till spec.show_schema() när en specifikation är kopplad. Skriver ut ett meddelande som anger att inget schema är tillgängligt annars.

`publish` (ny i v0.3.3)

def publish() -> Graph

Registrera grafen med API:et, vilket gör den frågebar. Anropa detta efter Graph.prepare() (eller på någon Graph som har en specifikation bifogad) för att publicera grafinstansen.

Returnerar:

Graph: Själv för metodlänkning

Höjer:

ValueError: Om ingen specifikation är kopplad eller om kontext saknas
RuntimeError: Om publiceringen misslyckas

Exempel:

graph = Graph.prepare(spec)
graph.publish()
# Now the graph is queryable
graph.query("MATCH (n) RETURN n")

BuildStatus

Dataklass som bär metadata från en Graph.build() åtgärd.

Fält

Fält	Typ	Beskrivning
`etl_result`	`Any`	Resultat från fasen (körning av `prepare` datapipeline)
`api_result`	`Optional[Dict]`	Resultat från publiceringsfasen (`None` om publiceringen misslyckades)
`api_error`	`Optional[str]`	Felmeddelande om publiceringen misslyckades (`None` om publiceringen lyckades)
`instance_name`	`str`	Namn på grafinstansen
`status`	`Optional[BuildStatusKind]`	`None`, `"published"`, eller `"prepared"`

Byggvägar

GraphSpecBuilder.start(...).done()  →  GraphSpec             (spec only, no graph yet)
Graph.get(name, context)            →  Graph (spec=None, build_status=None)
Graph.prepare(spec)                 →  Graph (spec=spec, build_status.status="prepared")
graph.publish()                     →  Graph (build_status.status="published")
Graph.build(spec)                   →  Graph (prepare + publish in one step)

Exempel:

graph = Graph.build(spec)
if graph.build_status.status == "published":
    print("Graph prepared and published successfully")
elif graph.build_status.status == "prepared":
    print(f"Prepare succeeded but publish failed: {graph.build_status.api_error}")
elif graph.build_status.status is None:
    print("Neither prepare nor publish has run")

Node Builders

NodeBuilderInitial

Initialt tillstånd för node builder: endast tillgängliga datakällasmetoder.

Konstruktören

NodeBuilderInitial(alias: str, graph_builder: GraphSpecBuilder)

Observera: Skapas vanligtvis via GraphSpecBuilder.add_node(), inte direkt instansierad.

Metoder

Obs!

Användning av understreck _ när du namnger noder, kanter eller egenskaper i en anpassad graf stöds inte. Ett ogiltigt begärandefel returneras när understreck används.

`from_table`

def from_table(table_name: str, database: Optional[str] = None) -> NodeBuilderSourceSet

Ange en tabell som datakälla med intelligent databasupplösning.

Parametrar:

table_name (str): Namnet på tabellen (krävs)
database (str, valfritt): Explicit databasnamn (har företräde framför kontextstandard)

Returnerar:

NodeBuilderSourceSet: Builder för ytterligare konfiguration

Höjer:

ValueError: Om tabellen inte hittas eller flera tabeller i konflikt hittas

Databasmatchningsordning:

Explicit database parameter (högsta prioritet)
ExecutionContext.default_database
Sök i alla databaser (med konfliktidentifiering)

Exempel:

builder.add_node("user").from_table("SigninLogs", database="security_db")

`from_dataframe`

def from_dataframe(dataframe: DataFrame) -> NodeBuilderSourceSet

Ange Spark DataFrame som datakälla.

Parametrar:

dataframe (DataFrame): Spark DataFrame

Returnerar:

NodeBuilderSourceSet: Builder för ytterligare konfiguration

Exempel:

df = spark.read.table("users")
builder.add_node("user").from_dataframe(df)

NodeBuilderSourceSet

Node Builder när datakällan har angetts: konfigurationsmetoder är tillgängliga.

Konstruktören

NodeBuilderSourceSet(alias: str, graph_builder: GraphSpecBuilder, source_step: DataInputETLStep)

Observera: Skapades internt av NodeBuilderInitial-källmetoder.

Metoder

`with_time_range`

def with_time_range(
    time_column: str,
    start_time: Optional[Union[str, datetime]] = None,
    end_time: Optional[Union[str, datetime]] = None,
    lookback_hours: Optional[float] = None
) -> NodeBuilderSourceSet

Tillämpa tidsintervallfiltrering på nodens datakälla.

Parametrar:

time_column (str): Kolumnnamn som innehåller tidsstämpeldata (krävs)
start_time (str eller datetime, valfritt): Startdatum ("10/20/25", "2025-10-20" eller datetime-objekt)
end_time (str eller datetime, valfritt): Slutdatum (samma format som start_time)
lookback_hours (flyttal, valfritt): Timmar att se tillbaka från och med nu

Returnerar:

NodeBuilderSourceSet: Själv för metodlänkning

Höjer:

ValueError: Om tidskolumnen inte hittades i källschemat

Tidsintervalllogik:

Om start_time och end_time tillhandahålls: använd dem direkt
Om endast lookback_hours tillhandahålls: end=now, start=now-lookback_hours
Om inget anges: ingen tidsfiltrering
Om start/slut OCH lookback_hours: start/slut har företräde

Exempel:

# Explicit date range
builder.add_node("user").from_table("SigninLogs") \
    .with_time_range(time_column="TimeGenerated", start_time="2025-01-01", end_time="2025-01-31")

# Lookback window
builder.add_node("user").from_table("SigninLogs") \
    .with_time_range(time_column="TimeGenerated", lookback_hours=24)

`with_label`

def with_label(label: str) -> NodeBuilderSourceSet

Ange nodetikett (standardvärdet är alias om det inte anropas).

Parametrar:

label (str): Nodetikett

Returnerar:

NodeBuilderSourceSet: Själv för metodlänkning

Höjer:

ValueError: Om etiketten redan har angetts

Exempel:

builder.add_node("u").from_table("Users").with_label("user")

`with_columns`

def with_columns(
    *columns: str,
    key: str,
    display: str
) -> NodeBuilderSourceSet

Konfigurera kolumner med nödvändig nyckel- och visningsbeteckning.

Parametrar:

*columns (str): Kolumnnamn som ska inkluderas (minst ett krävs)
key (str): Kolumnnamn som ska markeras som nyckel (krävs, måste finnas i kolumner)
display (str): Kolumnnamn som ska markeras som visningsvärde (krävs, måste finnas i kolumner, kan vara samma som nyckel)

Returnerar:

NodeBuilderSourceSet: Själv för metodlänkning

Höjer:

ValueError: Om valideringen misslyckas (dubblettkolumner, nyckel/skärm saknas osv.)

Kommentarer:

Egenskaper skapas automatiskt från kolumntyper
Kolumnen tidsfilter läggs automatiskt till om den anges
Egenskapstyper härleds automatiskt från källschemat
Se Begränsningar

Exempel:

builder.add_node("user").from_table("Users") \
    .with_columns("id", "name", "email", "created_at", key="id", display="name")

`add_node`

def add_node(alias: str) -> NodeBuilderInitial

Slutför den här noden och börja skapa en annan nod.

Parametrar:

alias (str): Alias för den nya noden

Returnerar:

NodeBuilderInitial: Ny nodbyggare

Exempel:

builder.add_node("user").from_table("Users") \
    .with_columns("id", "name", key="id", display="name") \
    .add_node("device")

`add_edge`

def add_edge(alias: str) -> EdgeBuilderInitial

Slutför den här noden och börja skapa en kant.

Parametrar:

alias (str): Alias för gränsenheten

Returnerar:

EdgeBuilderInitial: Ny edge builder

Exempel:

builder.add_node("user").from_table("Users") \
    .with_columns("id", "name", key="id", display="name") \
    .add_edge("accessed")

`done`

def done() -> GraphSpec

Slutför den här noden och slutför grafspecifikationen.

Returnerar:

GraphSpec: Fullständig grafspecifikation

Exempel:

graph_spec = builder.add_node("user").from_table("Users") \
    .with_columns("id", "name", key="id", display="name") \
    .done()

Edge Builders

EdgeBuilderInitial

Inledande tillstånd för edge builder: endast tillgängliga datakällasmetoder.

Konstruktören

EdgeBuilderInitial(alias: str, graph_builder: GraphSpecBuilder)

Observera: Skapas vanligtvis via GraphSpecBuilder.add_edge(), inte direkt instansierad.

Metoder

Obs!

Användning av understreck _ när du namnger noder, kanter eller egenskaper i en anpassad graf stöds inte. Ett ogiltigt begärandefel returneras när understreck används.

`from_table`

def from_table(table_name: str, database: Optional[str] = None) -> EdgeBuilderSourceSet

Ange en tabell som datakälla med intelligent databasupplösning.

Parametrar:

table_name (str): Namnet på tabellen (krävs)
database (str, valfritt): Explicit databasnamn

Returnerar:

EdgeBuilderSourceSet: Builder för ytterligare konfiguration

Höjer:

ValueError: Om tabellen inte hittas eller flera tabeller i konflikt hittas

Exempel:

builder.add_edge("accessed").from_table("AccessLogs")

`from_dataframe`

def from_dataframe(dataframe: DataFrame) -> EdgeBuilderSourceSet

Ange Spark DataFrame som datakälla.

Parametrar:

dataframe (DataFrame): Spark DataFrame

Returnerar:

EdgeBuilderSourceSet: Builder för ytterligare konfiguration

Exempel:

df = spark.read.table("access_logs")
builder.add_edge("accessed").from_dataframe(df)

EdgeBuilderSourceSet

Edge Builder efter att datakällan har angetts: tillgängliga konfigurationsmetoder.

Konstruktören

EdgeBuilderSourceSet(alias: str, graph_builder: GraphSpecBuilder, source_step: DataInputETLStep)

Observera: Skapades internt av EdgeBuilderInitial-källmetoder.

Metoder

`with_label`

def with_label(label: str) -> EdgeBuilderSourceSet

Ange gränsrelationstyp/-etikett (standardvärdet är alias om det inte anropas).

Parametrar:

label (str): Edge-etikett

Returnerar:

EdgeBuilderSourceSet: Själv för metodlänkning

Höjer:

ValueError: Om etiketten redan har angetts

Exempel:

builder.add_edge("rel").from_table("AccessLogs").with_label("ACCESSED")

`edge_label`

Obs!

Använd with_label() i stället. Den här metoden tas bort i en framtida version.

def edge_label(label: str) -> EdgeBuilderSourceSet

Ange gränsrelationstyp/-etikett (standardvärdet är alias om det inte anropas).

Parametrar:

label (str): Edge-etikett

Returnerar:

EdgeBuilderSourceSet: Själv för metodlänkning

Höjer:

ValueError: Om etiketten redan har angetts

Exempel:

builder.add_edge("acc").from_table("AccessLogs").edge_label("accessed")

`source`

def source(id_column: str, node_type: str) -> EdgeBuilderSourceSet

Ange källnod med ID-kolumn och etikett.

Parametrar:

id_column (str): Kolumnnamn som innehåller källnod-ID
node_type (str): Källnodetikett

Returnerar:

EdgeBuilderSourceSet: Själv för metodlänkning

Höjer:

ValueError: Om källan redan har angetts

Exempel:

builder.add_edge("accessed").from_table("AccessLogs") \
    .source(id_column="user_id", node_type="user")

`target`

def target(id_column: str, node_type: str) -> EdgeBuilderSourceSet

Ange målnod med ID-kolumn och etikett.

Parametrar:

id_column (str): Kolumnnamn som innehåller målnod-ID
node_type (str): Målnodetikett

Returnerar:

EdgeBuilderSourceSet: Själv för metodlänkning

Höjer:

ValueError: Om målet redan har angetts

Exempel:

builder.add_edge("accessed").from_table("AccessLogs") \
    .source(id_column="user_id", node_type="user") \
    .target(id_column="device_id", node_type="device")

`with_time_range`

def with_time_range(
    time_column: str,
    start_time: Optional[Union[str, datetime]] = None,
    end_time: Optional[Union[str, datetime]] = None,
    lookback_hours: Optional[float] = None
) -> EdgeBuilderSourceSet

Tillämpa tidsintervallfiltrering på gränsens datakälla.

Parametrar:

time_column (str): Kolumnnamn som innehåller tidsstämpeldata (krävs)
start_time (str eller datetime, valfritt): Startdatum
end_time (str eller datetime, valfritt): Slutdatum
lookback_hours (flyttal, valfritt): Timmar att se tillbaka från och med nu

Returnerar:

EdgeBuilderSourceSet: Själv för metodlänkning

Höjer:

ValueError: Om tidskolumnen inte hittades i källschemat

Exempel:

builder.add_edge("accessed").from_table("AccessLogs") \
    .with_time_range(time_column="TimeGenerated", lookback_hours=48)

`with_columns`

def with_columns(
    *columns: str,
    key: str,
    display: str
) -> EdgeBuilderSourceSet

Konfigurera kolumner med nödvändig nyckel- och visningsbeteckning.

Parametrar:

*columns (str): Kolumnnamn som ska inkluderas (minst ett krävs)
key (str): Kolumnnamn som ska markeras som nyckel (krävs, måste finnas i kolumner)
display (str): Kolumnnamn som ska markeras som visningsvärde (obligatoriskt, måste finnas i kolumner)

Returnerar:

EdgeBuilderSourceSet: Själv för metodlänkning

Höjer:

ValueError: Om verifieringen misslyckas

Exempel:

builder.add_edge("accessed").from_table("AccessLogs") \
    .source(id_column="user_id", node_type="user") \
    .target(id_column="device_id", node_type="device") \
    .with_columns("id", "location", "status", key="id", display="location")

`add_node`

def add_node(alias: str) -> NodeBuilderInitial

Slutför den här gränsen och börja skapa en nod.

Parametrar:

alias (str): Alias för den nya noden

Returnerar:

NodeBuilderInitial: Ny nodbyggare

`add_edge`

def add_edge(alias: str) -> EdgeBuilderInitial

Slutför den här kanten och börja skapa en annan kant.

Parametrar:

alias (str): Alias för den nya gränsen

Returnerar:

EdgeBuilderInitial: Ny edge builder

Exempel:

builder.add_edge("accessed").from_table("AccessLogs") \
    .source(id_column="user_id", node_type="user") \
    .target(id_column="device_id", node_type="device") \
    .with_columns("id", "location", key="id", display="location") \
    .add_edge("connected_to")

`done`

def done() -> GraphSpec

Slutför den här kanten och slutför grafspecifikationen.

Returnerar:

GraphSpec: Fullständig grafspecifikation

Schemaklasser

GraphDefinitionReference

Referens till en grafdefinition med namn och version.

Konstruktören

GraphDefinitionReference(
    fully_qualified_name: str,
    version: str
)

Parametrar:

fully_qualified_name (str): Fullständigt kvalificerat namn på den refererade grafen
version (str): Version av den refererade grafen

Höjer:

ValueError: Om fully_qualified_name eller versionen är tom

Metoder

`to_dict`

def to_dict() -> Dict[str, Any]

Serialisera till ordlista.

Returnerar:

Dict[str, Any]: Serialiserad referens

Egenskap

Egenskapsdefinition med typsäkert gränssnitt.

Konstruktören

Property(
    name: str,
    property_type: PropertyType,
    is_non_null: bool = False,
    description: str = "",
    is_key: bool = False,
    is_display_value: bool = False,
    is_internal: bool = False
)

Parametrar:

name (str): Egenskapsnamn
property_type (PropertyType): Egenskapsdatatyp
is_non_null (bool, default=False): Om egenskapen krävs
description (str, default=""): Egenskapsbeskrivning
is_key (bool, default=False): Om egenskapen är en nyckel
is_display_value (bool, default=False): Om egenskapen är visningsvärde
is_internal (bool, default=False): Om egenskapen är intern

Höjer:

ValueError: Om namnet är tomt eller om verifieringen misslyckas

Klassmetoder

`key`

@classmethod
Property.key(
    name: str,
    property_type: PropertyType,
    description: str = "",
    is_non_null: bool = False
) -> Property

Skapa en nyckelegenskap med vanliga inställningar (is_key=Sant, is_display_value=Sant).

`display`

@classmethod
Property.display(
    name: str,
    property_type: PropertyType,
    description: str = "",
    is_non_null: bool = False
) -> Property

Skapa en visningsvärdesegenskap (is_display_value=Sant).

Metoder

`describe`

def describe(text: str) -> Property

Lägg till beskrivning flytande.

Parametrar:

text (str): Beskrivningstext

Returnerar:

Property: Själv för metodlänkning

`to_dict`

def to_dict() -> Dict[str, Any]

Serialisera egenskapen till ordlistan med @-prefixerade anteckningsnycklar.

Returnerar:

Dict[str, Any]: Serialiserad egenskap

`to_gql`

def to_gql() -> str

Generera GQL-egenskapsdefinition.

Returnerar:

str: GQL-strängrepresentation

EdgeNode

Nodreferens som används i gränsdefinitioner.

Konstruktören

EdgeNode(
    alias: Optional[str] = None,
    labels: List[str] = []
)

Parametrar:

alias (str, valfritt): Nodalias (ange automatiskt till första etikett om ingen eller tom)
labels (Lista[str]): Nodetiketter (minst en krävs)

Höjer:

ValueError: Om listan med etiketter är tom
TypeError: Om etiketter inte är strängar

Automatisk mutation:

Om aliaset är Inget eller tomt anges det till den första etiketten

Metoder

`to_dict`

def to_dict() -> Dict[str, Any]

Serialisera till ordlista.

Returnerar:

Dict[str, Any]: Referens för serialiserad kantnod

Nod

Noddefinition med typsäkert gränssnitt.

Konstruktören

Node(
    alias: str = "",
    labels: List[str] = [],
    implies_labels: List[str] = [],
    properties: List[Property] = [],
    description: str = "",
    entity_group: str = "",
    dynamic_labels: bool = False,
    abstract_edge_aliases: bool = False
)

Parametrar:

alias (str, default=""): Nodalias (automatiskt inställd på första etiketten om den är tom)
labels (Lista[str]): Nodetiketter (minst en krävs)
implies_labels (List[str], default=[]): Underförstådda etiketter
properties (List[Property], default=[]): Nodegenskaper
description (str, default=""): Nodbeskrivning
entity_group (str, default=""): Entitetsgruppnamn
dynamic_labels (bool, default=False): Om noden har dynamiska etiketter
abstract_edge_aliases (bool, default=False): Om noden använder abstrakta kantalias

Höjer:

ValueError: Om valideringen misslyckas (inga etiketter, ingen nyckelegenskap, ingen visningsegenskap osv.)

Automatisk mutation:

Om aliaset är tomt anges det till den första etiketten
Om entity_group är tom anges den till den primära etiketten

Metoder

`get_primary_label`

def get_primary_label() -> Optional[str]

Hämta den primära (första) etiketten.

Returnerar:

str eller None: Primär etikett eller Ingen om det inte finns några etiketter

`get_entity_group_name`

def get_entity_group_name() -> str

Hämta entitetsgruppens namn eller återställning till den primära etiketten.

Returnerar:

str: Entitetsgruppnamn

`get_primary_key_property_name`

def get_primary_key_property_name() -> Optional[str]

Hämta namnet på primärnyckelegenskapen.

Returnerar:

str eller None: Egenskapsnamn för primärnyckel

`get_properties`

def get_properties() -> Dict[str, Property]

Hämta egenskaper som en ordlista för enkel åtkomst.

Returnerar:

Dict[str, Property]: Egenskaper som är nyckelade efter namn

`get_property`

def get_property(name: str) -> Optional[Property]

Hämta en specifik egenskap efter namn.

Parametrar:

name (str): Egenskapsnamn

Returnerar:

Property eller None: Egenskapen om den hittas

`add_property`

def add_property(prop: Property) -> None

Lägg till en egenskap i den här noden.

Parametrar:

prop (Egenskap): Egenskap som ska läggas till

Höjer:

ValueError: Om egenskapsnamnet är duplicerat

`is_dynamically_labeled`

def is_dynamically_labeled() -> bool

Kontrollera om noden har dynamiska etiketter.

Returnerar:

bool: Sant om dynamiska etiketter är aktiverade

`is_abstract_edge_node_aliases`

def is_abstract_edge_node_aliases() -> bool

Kontrollera om noden använder abstrakta kantnodalias.

Returnerar:

bool: Sant om abstrakta kantalias är aktiverade

`describe`

def describe(text: str) -> Node

Lägg till beskrivning flytande.

Parametrar:

text (str): Beskrivningstext

Returnerar:

Node: Själv för metodlänkning

`to_dict`

def to_dict() -> Dict[str, Any]

Serialisera noden till ordlistan.

Returnerar:

Dict[str, Any]: Serialiserad nod

`to_gql`

def to_gql() -> str

Generera GQL-noddefinition.

Returnerar:

str: GQL-strängrepresentation

Höjer:

ValueError: Om noden saknar obligatoriska fält för GQL

Klassmetoder

`create`

@classmethod
Node.create(
    alias: str,
    labels: List[str],
    properties: List[Property],
    description: str = "",
    entity_group: str = "",
    **kwargs
) -> Node

Skapa en nod med alla obligatoriska fält.

Parametrar:

alias (str): Nodalias
labels (Lista[str]): Nodetiketter
properties (Lista[egenskap]): Nodegenskaper
description (str, default=""): Nodbeskrivning
entity_group (str, default=""): Entitetsgruppnamn

Returnerar:

Node: Ny nodinstans

Kanten

Gränsdefinition med typsäkert gränssnitt.

Konstruktören

Edge(
    relationship_type: str,
    source_node_label: str,
    target_node_label: str,
    direction: EdgeDirection = EdgeDirection.DIRECTED_RIGHT,
    properties: List[Property] = [],
    description: str = "",
    entity_group: str = "",
    dynamic_type: bool = False
)

Parametrar:

relationship_type (str): Relationstypen Edge (till exempel "FOLLOWS", "OWNS")
source_node_label (str): Källnodetikett
target_node_label (str): Målnodetikett
direction (EdgeDirection, default=DIRECTED_RIGHT): Edge-riktning
properties (List[Property], default=[]): Edge-egenskaper
description (str, default=""): Edge-beskrivning
entity_group (str, default=""): Entitetsgruppnamn
dynamic_type (bool, default=False): Om kant har dynamisk typ

Höjer:

ValueError: Om verifieringen misslyckas

Automatisk mutation:

labels listan fylls i automatiskt med [relationship_type]
Om entity_group är tom är den inställd på relationship_type

Egenskaper

`edge_type`

def edge_type() -> str

Bakåtkompatibilitetsalias för relationship_type.

Returnerar:

str: Relationstyp

Metoder

`get_entity_group_name`

def get_entity_group_name() -> str

Hämta entitetsgruppnamn eller återställning till relationstyp.

Returnerar:

str: Entitetsgruppnamn

`is_dynamic_type`

def is_dynamic_type() -> bool

Kontrollera om gränsen har dynamisk typ.

Returnerar:

bool: Sant om dynamisk typ

`add_property`

def add_property(edge_property: Property) -> None

Lägg till en egenskap i den här kanten.

Parametrar:

edge_property (Egenskap): Egenskap som ska läggas till

`describe`

def describe(text: str) -> Edge

Lägg till beskrivning flytande.

Parametrar:

text (str): Beskrivningstext

Returnerar:

Edge: Själv för metodlänkning

`to_dict`

def to_dict() -> Dict[str, Any]

Serialisera kant till ordlista.

Returnerar:

Dict[str, Any]: Serialiserad kant

`to_gql`

def to_gql() -> str

Generera GQL-gränsdefinition.

Returnerar:

str: GQL-strängrepresentation

Klassmetoder

`create`

Edge.create(
    relationship_type: str,
    source_node_label: str,
    target_node_label: str,
    properties: List[Property] = None,
    description: str = "",
    entity_group: str = "",
    **kwargs
) -> Edge

Skapa en kant med alla obligatoriska fält.

Parametrar:

relationship_type (str): Gränsrelationstyp
source_node_label (str): Källnodetikett
target_node_label (str): Målnodetikett
properties (Lista[egenskap], valfritt): Edge-egenskaper
description (str, default=""): Edge-beskrivning
entity_group (str, default=""): Entitetsgruppnamn

Returnerar:

Edge: Ny gränsinstans

GraphSchema

Diagramschemadefinition med typsäkert gränssnitt.

Konstruktören

GraphSchema(
    name: str,
    nodes: List[Node] = [],
    edges: List[Edge] = [],
    base_graphs: List[GraphSchema] = [],
    description: str = "",
    version: str = "1.0",
    fully_qualified_name: str = "",
    namespace: str = ""
)

Parametrar:

name (str): Diagramschemanamn
nodes (List[Node], default=[]): Noddefinitioner
edges (List[Edge], default=[]): Edge-definitioner
base_graphs (List[GraphSchema], default=[]): Basdiagramscheman
description (str, default=""): Schemabeskrivning
version (str, default="1.0"): Schemaversion
fully_qualified_name (str, default=""): Fullständigt kvalificerat namn
namespace (str, default=""): Namnområde

Höjer:

ValueError: Om valideringen misslyckas (dubbletter av alias, kanter refererar till noder som inte finns osv.)

Metoder

`get_fully_qualified_name`

def get_fully_qualified_name() -> str

Hämta fullständigt kvalificerat namn.

Returnerar:

str: Fullständigt kvalificerat namn

`get_namespace`

def get_namespace() -> str

Hämta namnområdet från ett fullständigt kvalificerat namn eller returnera standardvärdet.

Returnerar:

str:Namnområde

`get_version`

def get_version() -> str

Hämta version.

Returnerar:

str: Versionssträng

`get_node`

def get_node(label_or_alias: str) -> Optional[Node]

Hämta nod efter etikett eller alias.

Parametrar:

label_or_alias (str): Nodetikett eller alias

Returnerar:

Node eller None: Nod om den hittas

`get_edge`

def get_edge(name: str) -> Optional[Edge]

Hämta kant efter namn/typ.

Parametrar:

name (str): Gränsrelationstyp

Returnerar:

Edge eller None: Edge om det hittas

`add_node`

def add_node(node: Node) -> None

Lägg till en nod i det här diagrammet.

Parametrar:

node (Nod): Nod att lägga till

Höjer:

ValueError: Om nodalias är duplicerat

`add_edge`

def add_edge(edge: Edge) -> None

Lägg till en kant i den här grafen.

Parametrar:

edge (Edge): Kant att lägga till

Höjer:

ValueError: Om kanttypen är duplicerad

`include_graph`

def include_graph(fully_qualified_name: str, version: str) -> GraphSchema

Lägg till ett diagram med inkludering (fluent API).

Parametrar:

fully_qualified_name (str): Fullständigt kvalificerat namn på grafen som ska inkluderas
version (str): Version av grafen som ska inkluderas

Returnerar:

GraphSchema: Själv för metodlänkning

`get_included_graph_references`

def get_included_graph_references() -> List[GraphDefinitionReference]

Hämta en lista över inkluderade grafreferenser.

Returnerar:

List[GraphDefinitionReference]: Lista över diagramdefinitionsreferenser

`describe`

def describe(text: str) -> GraphSchema

Lägg till beskrivning flytande.

Parametrar:

text (str): Beskrivningstext

Returnerar:

GraphSchema: Själv för metodlänkning

`to_dict`

def to_dict() -> Dict[str, Any]

Serialisera schemat till ordlistan.

Returnerar:

Dict[str, Any]: Serialiserat schema

`to_json`

def to_json(indent: int = 2) -> str

Generera JSON-representation.

Parametrar:

indent (int, default=2): JSON-indragsnivå

Returnerar:

str: JSON-sträng

`to_gql`

def to_gql() -> str

Generera GQL-schemadefinition.

Returnerar:

str: GQL-strängrepresentation

Klassmetoder

`create`

@classmethod
GraphSchema.create(
    name: str,
    nodes: List[Node] = None,
    edges: List[Edge] = None,
    description: str = "",
    version: str = "1.0",
    **kwargs
) -> GraphSchema

Skapa ett diagramschema med alla obligatoriska fält.

Parametrar:

name (str): Diagramschemanamn
nodes (Lista[Nod], valfritt): Noddefinitioner
edges (List[Edge], valfritt): Edge-definitioner
description (str, default=""): Schemabeskrivning
version (str, default="1.0"): Schemaversion

Returnerar:

GraphSchema: Ny grafschemainstans

Frågeindataklasser

Dataklasser som representerar indataparametrar för fördefinierade graffrågor.

Obs!

Att skicka QueryInput objekt direkt till Graph frågemetoder är inaktuellt och tas bort i framtida versioner. Använd nyckelordsargument i stället. Metoderna Graph (reachability, k_hop, blast_radius, centrality, ranked) accepterar alla parametrar som nyckelordsargument och konstruerar indataobjekten internt. Dessa klasser finns kvar i kodbasen för tillfället men bör inte användas i ny kod.

QueryInputBase

Basklass för alla frågeindataparametrar.

Metoder

`to_json_payload`

def to_json_payload() -> Dict[str, Any]

Konvertera indataparametrarna till en ordlista för API-överföring.

Returnerar:

Dict[str, Any]: Ordlisterepresentation av indataparametrarna

`validate`

def validate() -> None

Verifiera indataparametrarna.

Höjer:

ValueError: Om indataparametrarna är ogiltiga

ReachabilityQueryInput

Indataparametrar för en nåbarhetsfråga mellan käll- och målnoder. Ärver som ReachabilityQueryInputBase ärver från QueryInputBase.

Fält

Fält	Typ	Standard	Beskrivning
`source_property_value`	`str`	(krävs)	Värde som ska matchas för källegenskapen
`target_property_value`	`str`	(krävs)	Värde som ska matchas för målegenskapen
`source_property`	`Optional[str]`	`None`	Egenskapsnamn för att filtrera källnoder
`participating_source_node_labels`	`Optional[List[str]]`	`None`	Nodetiketter att betrakta som källnoder
`target_property`	`Optional[str]`	`None`	Egenskapsnamn för att filtrera målnoder
`participating_target_node_labels`	`Optional[List[str]]`	`None`	Nodetiketter att betrakta som målnoder
`participating_edge_labels`	`Optional[List[str]]`	`None`	Kantetiketter som ska bläddras i sökvägen
`is_directional`	`Optional[bool]`	`True`	Om kanterna är riktningsbaserade
`min_hop_count`	`Optional[int]`	`1`	Minsta antal hopp i sökvägen
`max_hop_count`	`Optional[int]`	`4`	Maximalt antal hopp i sökvägen
`shortest_path`	`Optional[bool]`	`False`	Om du bara ska hitta den kortaste sökvägen
`max_results`	`Optional[int]`	`500`	Maximalt antal resultat som ska returneras

Validering:

source_property_value krävs
target_property_value krävs

Exempel:

# Preferred: keyword arguments (no import needed)
result = graph.reachability(
    source_property="UserId",
    source_property_value="user123",
    target_property="DeviceId",
    target_property_value="device456",
    participating_edge_labels=["accessed", "connected_to"],
    shortest_path=True
)

# DEPRECATED — will be removed in a future version. Use keyword arguments above.
from sentinel_graph.builders.query_input import ReachabilityQueryInput
result = graph.reachability(query_input=ReachabilityQueryInput(
    source_property_value="user123",
    target_property_value="device456"
))

K_HopQueryInput

Indataparametrar för en k-hop-fråga från en viss källnod. Ärver från ReachabilityQueryInputBase.

Ärver alla fält från ReachabilityQueryInput.

Validering:

Minst en av source_property_value eller target_property_value måste tillhandahållas

Exempel:

# Preferred: keyword arguments
result = graph.k_hop(
    source_property_value="user123",
    max_hop_count=3,
    participating_edge_labels=["accessed"]
)

# DEPRECATED — will be removed in a future version. Use keyword arguments above.
from sentinel_graph.builders.query_input import K_HopQueryInput
result = graph.k_hop(query_input=K_HopQueryInput(source_property_value="user123"))

BlastRadiusQueryInput

Indataparametrar för en blastradiefråga från käll- till målnoder. Ärver från ReachabilityQueryInputBase.

Ärver alla fält från ReachabilityQueryInput, med följande obligatoriska fält:

Fält	Typ	Obligatoriskt	Beskrivning
`source_property_value`	`str`	Ja	Värde för att identifiera källnoden
`target_property_value`	`str`	Ja	Värde för att identifiera målnoden

Validering:

source_property_value krävs
target_property_value krävs

Exempel:

# Preferred: keyword arguments
result = graph.blast_radius(
    source_property_value="user123",
    target_property_value="device456",
    participating_edge_labels=["accessed", "connected_to"]
)

# DEPRECATED — will be removed in a future version. Use keyword arguments above.
from sentinel_graph.builders.query_input import BlastRadiusQueryInput
result = graph.blast_radius(query_input=BlastRadiusQueryInput(
    source_property_value="user123",
    target_property_value="device456"
))

CentralityQueryInput

Indataparametrar för en centralitetsanalysfråga. Ärver från QueryInputBase.

CentralityType-uppräkning

Värde	Beskrivning
`CentralityType.Node`	Centralitet för beräkningsnod
`CentralityType.Edge`	Centralitet för beräkningskant

Fält

Fält	Typ	Standard	Beskrivning
`threshold`	`Optional[int]`	`3`	Minsta centralitetspoäng att tänka på
`centrality_type`	`CentralityType`	`CentralityType.Node`	Typ av centralitet för beräkning
`max_paths`	`Optional[int]`	`1000000`	Maximalt antal sökvägar att överväga (0 = alla)
`participating_source_node_labels`	`Optional[List[str]]`	`None`	Källnodetiketter
`participating_target_node_labels`	`Optional[List[str]]`	`None`	Målnodetiketter
`participating_edge_labels`	`Optional[List[str]]`	`None`	Kantetiketter att passera
`is_directional`	`Optional[bool]`	`True`	Om kanterna är riktningsbaserade
`min_hop_count`	`Optional[int]`	`1`	Minsta hopp
`max_hop_count`	`Optional[int]`	`4`	Maximalt antal hopp
`shortest_path`	`Optional[bool]`	`False`	Endast kortaste sökvägar
`max_results`	`Optional[int]`	`500`	Maximalt resultat

Exempel:

# Preferred: keyword arguments (works for all centrality types)
result = graph.centrality(
    centrality_type=CentralityType.Edge,  # or CentralityType.Node (default)
    participating_edge_labels=["accessed", "connected_to"],
    threshold=5,
    max_results=100
)

# DEPRECATED — will be removed in a future version. Use keyword arguments above.
from sentinel_graph.builders.query_input import CentralityQueryInput, CentralityType
result = graph.centrality(query_input=CentralityQueryInput(
    centrality_type=CentralityType.Edge,
    participating_edge_labels=["accessed"]
))

RankedQueryInput

Indataparametrar för en rangordnad analysfråga. Ärver från QueryInputBase.

Fält

Fält	Typ	Standard	Beskrivning
`rank_property_name`	`str`	(krävs)	Egenskapsnamn som ska användas för rangordningssökvägar
`threshold`	`Optional[int]`	`0`	Returnera endast sökvägar med vikter över det här värdet
`max_paths`	`Optional[int]`	`1000000`	Maximalt antal sökvägar att överväga (0 = alla)
`decay_factor`	`Optional[float]`	`1`	Hur mycket varje diagramsteg minskar rangordningen (2 = halverar varje steg)
`is_directional`	`Optional[bool]`	`True`	Om kanterna är riktningsbaserade
`min_hop_count`	`Optional[int]`	`1`	Minsta hopp
`max_hop_count`	`Optional[int]`	`4`	Maximalt antal hopp
`shortest_path`	`Optional[bool]`	`False`	Endast kortaste sökvägar
`max_results`	`Optional[int]`	`500`	Maximalt resultat

Exempel:

# Preferred: keyword arguments
result = graph.ranked(
    rank_property_name="risk_score",
    threshold=5,
    decay_factor=2,
    max_results=50
)

# DEPRECATED — will be removed in a future version. Use keyword arguments above.
from sentinel_graph.builders.query_input import RankedQueryInput
result = graph.ranked(query_input=RankedQueryInput(
    rank_property_name="risk_score",
    threshold=5
))

Frågeresultat

QueryResult

Resultat från en graffråga med lat DataFrame-åtkomst.

Konstruktören

QueryResult(raw_response: Dict[str, Any], graph: Graph)

Parametrar:

raw_response (Dict[str, Any]): Raw API-svarsordlista
graph (Diagram): Referens till överordnad graf

Observera: Skapas vanligtvis av Graph.query(), inte direkt instansierad.

Metoder

`to_dataframe`

def to_dataframe() -> DataFrame

Konverterar frågeresultatet till en Spark DataFrame.

Returnerar:

DataFrame: Frågeresultat som Spark DataFrame

Höjer:

ValueError: Om konverteringen misslyckas

Exempel:

result = graph.query("MATCH (u:user) RETURN u")
df = result.to_dataframe()
df.show()

`get_raw_data`

def get_raw_data() -> Dict[str, Any]

Hämta RawData-avsnittet från svaret.

Returnerar:

Dict[str, Any]: Ordlista med råmetadata eller tom diktamen om den inte finns

Exempel:

result = graph.query("MATCH (u:user) RETURN u")
metadata = result.get_raw_data()

`show`

def show(format: str = "visual") -> None

Visa frågeresultat i olika format.

Parametrar:

format (str, default="visual"): Utdataformat
- "table": Fullständiga DataFrame-tabeller (alla kolumner)
- "visual": Interaktiv grafvisualisering med VSC-plugin-program
- "all": Visa alla format

Höjer:

ValueError: Om formatet inte är ett av de värden som stöds

Exempel:

result = graph.query("MATCH (u:user)-[r:accessed]->(d:device) RETURN u, r, d")
result.show()  # Visual by default
result.show(format="table")  # Table format

Fullständigt exempel (rekommenderas – v0.3+)

# 0. Imports
from sentinel_graph import GraphSpecBuilder, Graph

# 1. Define graph specification
spec = (
    GraphSpecBuilder.start()
    
    .add_node("User")
        .from_dataframe(user_nodes)  # native Spark DF from groupBy → no .df
            .with_columns(
                "UserId", "UserDisplayName", "UserPrincipalName",
                "DistinctLocationCount", "DistinctIPCount", "DistinctAppCount",
                "TotalSignIns", "RiskySignInCount", "ImpossibleTravelFlag",
                key="UserId", display="UserDisplayName"
            )
    
    .add_node("IPAddress")
        .from_dataframe(ip_nodes)  # native Spark DF from groupBy → no .df
            .with_columns(
                "IPAddress", "UniqueUsers", "UniqueLocations",
                "SignInCount", "RiskySignInCount", "SharedIPFlag",
                key="IPAddress", display="IPAddress"
            )
    
    .add_edge("UsedIP")
        .from_dataframe(edge_used_ip)  # native Spark DF → no .df
            .source(id_column="UserId", node_type="User")
            .target(id_column="IPAddress", node_type="IPAddress")
            .with_columns(
                "SignInCount", "FirstSeen", "LastSeen", "EdgeKey",
                key="EdgeKey", display="EdgeKey"
            )
   
    .done()
)

# 2. Inspect schema before building (GraphSpec owns this)
spec.show_schema()

# 3. Build: prepares data + publishes graph → returns Graph
graph = Graph.build(spec)
print(f"Build status: {graph.build_status.status}")

# 4. Query the graph (query lives on Graph)
result = graph.query("MATCH (u:user)-[used:UsedIP]->(ip:IPAddress) RETURN * LIMIT 100")
result.show()

# 5. Access data via delegation
df = result.to_dataframe()
df.printSchema()

# 6. Graph algorithms
gf = graph.to_graphframe()
pagerank_result = gf.pageRank(resetProbability=0.15, maxIter=10)
pagerank_result.vertices.select("id", "pagerank").show()

# 7. Fetch an existing graph (no spec needed)
graph = Graph.get("my_existing_graph", context=context)
graph.query("MATCH (n) RETURN n LIMIT 10").show()

Information om designmönster

Fluent API

Alla byggare stöder metodlänkning för läsbara, deklarativa grafdefinitioner:

builder.add_node("user") \
    .from_table("Users") \
    .with_columns("id", "name", key="id", display="name") \
    .add_edge("follows")

Union-scheman

Flera kanter med samma alias är automatiskt union'ed med sammanfogade egenskaper:

# Both edges use alias "sign_in" - they will be merged into one schema edge
builder.add_edge("sign_in") \
    .from_table("AzureSignins") \
    .source(id_column="UserId", node_type="AZuser") \
    .target(id_column="DeviceId", node_type="device")

builder.add_edge("sign_in") \
    .from_table("EntraSignins") \
    .source(id_column="UserId", node_type="EntraUser") \
    .target(id_column="DeviceId", node_type="device")

Autokonfiguration

Många fält har lämpliga standardvärden:

Nod-/gränsetiketter är standard för deras alias
Egenskaper härleds automatiskt från källscheman
Entitetsgrupper är standard för primära etiketter/relationstyper

Lazy Evaluation

DataRamar och resurser läses in lazily och cachelagras:

graph_spec.nodes och graph_spec.edges läses in vid första åtkomsten
Frågeresultat skapar endast DataFrames när det begärs

Feedback

Var den här sidan till hjälp?

Last updated on 2026-04-23

Api-referens för Graph Builder (förhandsversion)

GraphSpecBuilder

Konstruktören

Statiska metoder

start

Instansmetoder

add_node

add_edge

done

GraphSpec

Konstruktören

Egenskaper

nodes

edges

Metoder

build_graph_with_data

get_schema

get_pipeline

to_graphframe

show

show_schema

Diagram

Konstruktören

Statiska metoder

get

prepare

build

Egenskaper

nodes

edges

schema

Metoder

query

reachability

k_hop

blast_radius

centrality

ranked

to_graphframe

show

show_schema

publish (ny i v0.3.3)

BuildStatus

Fält

Byggvägar

Node Builders

NodeBuilderInitial

Konstruktören

Metoder

from_table

from_dataframe

NodeBuilderSourceSet

Konstruktören

Metoder

with_time_range

with_label

with_columns

add_node

add_edge

done

Edge Builders

EdgeBuilderInitial

Konstruktören

Metoder

from_table

from_dataframe

EdgeBuilderSourceSet

Konstruktören

Metoder

with_label

edge_label

source

target

with_time_range

with_columns

add_node

add_edge

done

Schemaklasser

GraphDefinitionReference

`start`

`add_node`

`add_edge`

`done`

`nodes`

`edges`

`build_graph_with_data`

`get_schema`

`get_pipeline`

`to_graphframe`

`show`

`show_schema`

`get`

`prepare`

`build`

`nodes`

`edges`

`schema`

`query`

`reachability`

`k_hop`

`blast_radius`

`centrality`

`ranked`

`to_graphframe`

`show`

`show_schema`

`publish` (ny i v0.3.3)

`from_table`

`from_dataframe`

`with_time_range`

`with_label`

`with_columns`

`add_node`

`add_edge`

`done`

`from_table`

`from_dataframe`

`with_label`

`edge_label`

`source`

`target`

`with_time_range`

`with_columns`

`add_node`

`add_edge`

`done`

`to_dict`

`key`

`display`

`describe`

`to_dict`

`to_gql`

`to_dict`

`get_primary_label`

`get_entity_group_name`

`get_primary_key_property_name`

`get_properties`

`get_property`

`add_property`

`is_dynamically_labeled`

`is_abstract_edge_node_aliases`

`describe`

`to_dict`

`to_gql`

`create`

`edge_type`

`get_entity_group_name`

`is_dynamic_type`

`add_property`

`describe`

`to_dict`

`to_gql`

`create`

`get_fully_qualified_name`

`get_namespace`

`get_version`

`get_node`

`get_edge`

`add_node`