Graphbrain

https://graphbrain.net/
Admin
Graphbrain is an artificial intelligence open-source library for automated meaning extraction, text...
Tokens:96,966
Snippets:859
Trust Score:6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Agent Lifecycle: On Start

Source: https://graphbrain.net/_modules/graphbrain/cognition/agent.html

Callback method invoked before an agent begins a cycle of activity. Intended for setup operations.

```python
[docs]
    def on_start(self):
        """Called before a cycle of activity is started."""

```

--------------------------------

### Install Graphbrain from source

Source: https://graphbrain.net/installation.html

Build and install Graphbrain from the cloned source code. This command installs the package using the setup.py file.

```bash
$ pip install .

```

--------------------------------

### Taxonomy Agent Output Example

Source: https://graphbrain.net/cli.html

Example of a hyperedge produced by the taxonomy agent.

```text
(type_of/P/. city/C (of/B city/C berlin/C))
```

--------------------------------

### Install pip with easy_install (macOS)

Source: https://graphbrain.net/installation.html

Install the pip package manager using easy_install. This is a prerequisite for installing other Python packages.

```bash
$ sudo easy_install pip

```

--------------------------------

### Activate virtual environment and install Graphbrain

Source: https://graphbrain.net/installation.html

Activate the virtual environment and then install Graphbrain using pip. This ensures dependencies are managed within the isolated environment.

```bash
$ source venv/bin/activate
$ pip install graphbrain

```

--------------------------------

### Import necessary libraries

Source: https://graphbrain.net/tutorials/hypergraph-operations.html

These imports are assumed for the tutorial. Ensure these libraries are installed.

```python
from graphbrain import *
from graphbrain.notebook import *
from graphbrain.parsers import *

```

--------------------------------

### Install Graphbrain in editable mode

Source: https://graphbrain.net/installation.html

Install Graphbrain from source in editable mode. Changes to the local code will be reflected immediately without reinstallation.

```bash
$ pip install -e .

```

--------------------------------

### Install Xcode Command Line Tools (macOS)

Source: https://graphbrain.net/installation.html

Install the necessary Xcode command line tools on macOS. This is a prerequisite for several development tasks.

```bash
$ xcode-select --install

```

--------------------------------

### Install Python 3 with Homebrew (macOS)

Source: https://graphbrain.net/installation.html

If Python 3 is not already installed, use Homebrew to install it on macOS.

```bash
$ brew install python3

```

--------------------------------

### Install Graphbrain with pip

Source: https://graphbrain.net/installation.html

Use this command to install the latest stable version of Graphbrain. It's recommended to do this within a virtual environment.

```bash
$ pip install graphbrain

```

--------------------------------

### Example Accuracy Results

Source: https://graphbrain.net/manual/internals/create-parser.html

Example output showing accuracy results for different categories and overall, as presented by the alpha stage testing script.

```text
news accuracy: 0.962852897473997 [648 correct out of 673]
science accuracy: 0.9427083333333334 [543 correct out of 576]
fiction accuracy: 0.9581881533101045 [275 correct out of 287]
non-fiction accuracy: 0.9338235294117647 [254 correct out of 272]
wikipedia accuracy: 0.9482288828337875 [696 correct out of 734]

overall accuracy: 0.950432730133753 [2416 correct out of 2542]

```

--------------------------------

### Install Graphbrain development dependencies

Source: https://graphbrain.net/installation.html

Install Graphbrain along with its development dependencies, including tools like pytest. Use this if you plan to contribute to the project.

```bash
$ pip install '.[dev]'

```

--------------------------------

### Define Hyperedge Examples

Source: https://graphbrain.net/reference/notation.html

Examples of various hyperedge types including atomic concepts, predicates, and modifiers.

```text
apple/C
```

```text
(is/P berlin/C nice/C)
```

```text
(red/M shoes/C)
```

```text
(of/B capital/C germany/C)
```

```text
(in/T 1994/C)
```

```text
(and/J meat/C potatoes/C)
```

```text
(is/P berlin/C nice/C)
```

```text
(in/T 1976/C)
```

--------------------------------

### Create or Get Hypergraph Instance

Source: https://graphbrain.net/api.html

Use this function to get an instance of Hypergraph. The hypergraph will be created if it does not exist. Currently, only LevelDB storage is supported.

```python
graphbrain.hgraph(locator_string)
```

--------------------------------

### Install virtualenv with pip (macOS)

Source: https://graphbrain.net/installation.html

Install the virtualenv package using pip. This tool is used to create isolated Python environments.

```bash
$ sudo -H pip install virtualenv

```

--------------------------------

### Define Builder Subtypes

Source: https://graphbrain.net/reference/notation.html

Examples of possessive and relational builder subtypes.

```text
‘s/Bp
```

```text
in/Br
```

--------------------------------

### hopen(*args, **kwds)

Source: https://graphbrain.net/_modules/graphbrain/__init__.html

A context manager that opens a hypergraph, starts a transaction, and ensures proper cleanup.

```APIDOC
## hopen(*args, **kwds)

### Description
A context manager that initializes a hypergraph using the provided arguments, begins a transaction, and sets batch mode to True. It ensures the transaction is ended and the connection is closed upon exiting the context.

### Parameters
- **args** (list) - Optional - Arguments passed to the hgraph initialization function.
- **kwds** (dict) - Optional - Keyword arguments passed to the hgraph initialization function.
```

--------------------------------

### Define Predicate Subtypes

Source: https://graphbrain.net/reference/notation.html

Examples of declarative, interrogative, and imperative predicate subtypes.

```text
is/Pd
```

```text
is/P?
```

```text
go/P!
```

--------------------------------

### Begin SQLite Transaction

Source: https://graphbrain.net/_modules/graphbrain/memory/sqlite.html

Starts a new SQLite transaction if not already in batch mode. Sets up a cursor for transaction operations.

```python
def begin_transaction(self):
    if self.batch_mode:
        return
    self.cur = self.conn.cursor()
    self.cur.execute('BEGIN TRANSACTION')
```

--------------------------------

### Download spaCy CPU-optimized language model

Source: https://graphbrain.net/installation.html

Install the larger, CPU-optimized English language model for spaCy. This is a good alternative if your system lacks a GPU.

```bash
$ python -m spacy download en_core_web_lg

```

--------------------------------

### Build Atom from Text

Source: https://graphbrain.net/reference/api.html

Constructs an atom from provided text and other components. No specific setup or constraints are mentioned.

```python
graphbrain.hyperedge.build_atom()
```

--------------------------------

### Clone Graphbrain repository

Source: https://graphbrain.net/installation.html

Clone the Graphbrain source code from GitHub to your local machine. This is the first step for installing from source.

```bash
$ git clone https://github.com/graphbrain/graphbrain.git
$ cd graphbrain

```

--------------------------------

### Define Predicate Role and Verb Features

Source: https://graphbrain.net/reference/notation.html

Examples of complex predicates specifying roles and verb features.

```text
(is/Pd.sc (the/Md sky/Cc.s) blue/Ca.s)
```

```text
(is/P?.cs.|f–3s- (what/Mw time/Cc.s) it/Ci)
```

--------------------------------

### Defining Semantic Constructs with Connectors

Source: https://graphbrain.net/manual/overview.html

Examples of using connectors to define propositions, combine concepts, and modify concepts within the hypergraph formalism.

```text
(is berlin nice)
```

```text
(of capital germany)
```

```text
(and meat potatoes)
```

```text
(highest (in mountain brazil))
```

```text
(when (is (the sky) blue))
```

```text
(climbs mary (the (highest (in mountain brazil))))
```

--------------------------------

### Get the type of an atom

Source: https://graphbrain.net/reference/api.html

Returns the type of an atom, which is its first subrole. For example, the type of 'graphbrain/Cp.s/1' is 'Cp'.

```python
atom.type()
```

--------------------------------

### View CLI Help and Options

Source: https://graphbrain.net/cli.html

Displays the full list of available arguments and options for the CLI.

```text
graphbrain [-h] [--hg HG] [--infile INFILE] [--outfile OUTFILE]
           [--fields FIELDS] [--show_namespaces] [--lang LANG]
           [--pattern PATTERN] [--agent AGENT]
           command

positional arguments:
  command               command to execute

optional arguments:
  -h, --help            show this help message and exit
  --hg HG               hypergraph db file path
  --infile INFILE       input file
  --outfile OUTFILE     output file
  --fields FIELDS       field names
  --show_namespaces     show namespaces
  --lang LANG           language
  --pattern PATTERN     hyperedge pattern
  --agent AGENT         agent name
```

--------------------------------

### Configure Plyvel Setup.py

Source: https://graphbrain.net/manual/backends.html

Update the setup.py file to include the necessary LevelDB and Boost libraries for Plyvel.

```python
Extension(
                ...
                libraries=['leveldb vaskomitanov-r x64',
                                   'libboost_chrono-vc141-mt-x64-1_69',
                                   'libboost_date_time-vc141-mt-x64-1_69',
                                   'libboost_filesystem-vc141-mt-x64-1_69',
                                   'libboost_system-vc141-mt-x64-1_69',
                                   'libboost_thread-vc141-mt-x64-1_69'],
                ...
    )

```

--------------------------------

### LevelDB Import Error Message

Source: https://graphbrain.net/manual/backends.html

Example of the ImportError encountered when plyvel is incorrectly installed in an Anaconda environment on macOS.

```text
ImportError: dlopen(/opt/anaconda3/lib/python3.8/site-packages/plyvel/plyvel.cpython-38-darwin.so, 2): Symbol not found: _ZTIN7leveldb10ComparatorE
Referenced from: /opt/anaconda3/lib/python3.8/site-packages/plyvel/_plyvel.cpython-38-darwin.so
Expected in: /usr/local/opt/leveldb/lib/libleveldb.1.dylib
in /opt/anaconda3/lib/python3.8/site-packages/plyvel/_plyvel.cpython-38-darwin.so
```

--------------------------------

### Manage Hypergraph Transactions

Source: https://graphbrain.net/_modules/graphbrain/__init__.html

Context manager for opening a hypergraph, starting a transaction, and ensuring proper closure.

```python
@contextmanager
def hopen(*args, **kwds):
    hg = hgraph(*args, **kwds)
    hg.begin_transaction()
    hg.batch_mode = True
    try:
        yield hg
    finally:
        hg.batch_mode = False
        hg.end_transaction()
        hg.close()
```

--------------------------------

### Get Edge Type

Source: https://graphbrain.net/reference/api.html

Returns the type of an edge as a string. The type is determined by the connector's type and is applied recursively if necessary. Examples illustrate type derivation for different edge structures.

```python
type()
```

--------------------------------

### Get Argument Role

Source: https://graphbrain.net/reference/api.html

Retrieves the argument role for a specific position within a relation. Returns None if the role cannot be determined. Example provided shows 's' for the first argument of (is/Pd.sc graphbrain/C great/C).

```python
graphbrain.rel_arg_role()
```

--------------------------------

### Get Atoms Contained in Edge

Source: https://graphbrain.net/_modules/graphbrain/hyperedge.html

Returns a set of all unique atoms present within a given Hyperedge. For example, in '(the/Md (of/Br mayor/Cc (the/Md city/Cs)))', it returns {the/Md, of/Br, mayor/Cc, city/Cs}.

```python
def atoms(self):
        """Returns the set of atoms contained in the edge.

        For example, consider the edge:
        (the/Md (of/Br mayor/Cc (the/Md city/Cs)))
        in this case, edge.atoms() returns:
        [the/Md, of/Br, mayor/Cc, city/Cs]
        """
        return {self}
```

--------------------------------

### Build Boost Library with B2

Source: https://graphbrain.net/manual/backends.html

Execute this command to build the Boost library. Adjust 'stagedir' and 'build-dir' to your specific directory names and VS version.

```bash
$ b2.exe stage --toolset=msvc-14.1 address-model=64 --stagedir="E:\mylib\boost\bin1.64.0\VC14.
1" threading=multi --build-type=complete --build-dir="E:\mylib\boost\boost_1_64_0\build"

```

--------------------------------

### View CLI Help

Source: https://graphbrain.net/manual/cli.html

Display the usage information and available arguments for the Graphbrain CLI.

```bash
usage: graphbrain [-h] [--col COL] [--corefs] [--hg HG]
                  [--indir INDIR] [--infile INFILE] [--lang LANG]
                  [--outfile OUTFILE] [--parser PARSER]
                  [--sequence SEQUENCE] [--url URL]
                  command

positional arguments:
  command               command to execute

optional arguments:
  -h, --help            show this help message and exit
  --col                 table column
  --corefs              perform coreference resolution
  --hg HG               hypergraph db
  --indir INDIR         input directory
  --infile INFILE       input file
  --lang LANG           language
  --outfile OUTFILE     output file
  --parser PARSER       parser
  --sequence SEQUENCE   sequence name
  --url URL             url
```

--------------------------------

### GraphBrain Lemma Specification Example

Source: https://graphbrain.net/manual/parsing.html

Illustrates the hyperedge format for specifying lemma relationships in GraphBrain, where 'lemma/J/.' precedes the word atom and its lemma form.

```text
(lemma/J/. published/P/en publish/P/en)
```

--------------------------------

### Initialize a Hypergraph instance

Source: https://graphbrain.net/reference/api.html

Creates or retrieves a LevelDB-backed hypergraph instance using the specified path.

```python
graphbrain.__init__.hgraph(locator_string)
```

--------------------------------

### Create and Open a Hypergraph

Source: https://graphbrain.net/manual/hypergraph-operations.html

Initialize a hypergraph by providing a database file path. The database will be created if it doesn't exist. Supports various file extensions for SQLite.

```python
from graphbrain import hgraph
hg = hgraph('example.db')
```

--------------------------------

### Create a Hypergraph

Source: https://graphbrain.net/cli.html

Initializes an empty hypergraph at the specified path.

```bash
graphbrain --hg <hypergraph> create
```

--------------------------------

### Compile Boost Library

Source: https://graphbrain.net/manual/backends.html

Run this command in the x64 Native Tools Command Prompt for VS2017 after downloading and unzipping the Boost library.

```bash
$ bootstrap.bat

```

--------------------------------

### Create a new hypergraph instance

Source: https://graphbrain.net/tutorials/hypergraph-operations.html

Creates or opens a hypergraph database file. If the file does not exist, it will be created.

```python
hg = hgraph('example.db')

```

--------------------------------

### Initialize Hypergraph Instance

Source: https://graphbrain.net/_modules/graphbrain/__init__.html

Creates a Hypergraph instance based on the provided locator string, supporting SQLite and LevelDB formats.

```python
def hgraph(locator_string):
    """Returns an instance of Hypergraph identified by the locator_string.
    The hypergraph will be created if it does not exist.

    The location_string can be the path to an SQLite3 file or LevelDB folder.
    """
    filename_parts = locator_string.split('.')
    if len(filename_parts) > 1:
        extension = filename_parts[-1]
        if extension in {'sqlite', 'sqlite3', 'db'}:
            return graphbrain.memory.sqlite.SQLite(locator_string)
        elif extension in {'leveldb', 'hg'}:
            return graphbrain.memory.leveldb.LevelDB(locator_string)
    raise RuntimeError('Unknown hypergraph database type.')
```

--------------------------------

### Create a virtual environment (Linux/macOS)

Source: https://graphbrain.net/installation.html

Create a virtual environment named 'venv' in the current directory. Replace '<path to python3>' with the actual path to your Python 3 executable.

```bash
$ virtualenv -p <path to python3> venv

```

```bash
$ python3 -m venv venv

```

--------------------------------

### Create and Use an English Parser

Source: https://graphbrain.net/manual/parsing.html

Instantiate an English language parser and use it to parse a sentence. Note that parser creation can take 10-20 seconds as it loads language models.

```python
from graphbrain.parsers import create_parser
parser = create_parser(lang='en')
parse_results = parser.parse('Einstein first published the theory of relativity in 1905')
parse_results['parses'][0]['main_edge']
```

--------------------------------

### Get unique atoms in an edge

Source: https://graphbrain.net/reference/api.html

Returns a set of unique atoms contained within an edge. This is useful for getting a distinct list of components without regard to their frequency.

```python
edge.atoms()
```

--------------------------------

### Derive Taxonomy Hyperedge Example

Source: https://graphbrain.net/manual/agents.html

Illustrates the hyperedge added by the taxonomy agent when deriving a 'type_of' relationship between concepts. This example shows how concepts defined with builders and modifiers are categorized.

```text
(type_of/P/. (of/Br.ma founder/Cc.s psychoanalysis/Cc.s) founder/Cc.s)
```

--------------------------------

### Basic Hyperedge Example

Source: https://graphbrain.net/manual/notation.html

Represents a simple sentence 'The sky is blue' using SH notation. This demonstrates the basic structure of a hyperedge with a predicate and atomic arguments.

```sh
(is/P (the/M sky/C) blue/C)
```

--------------------------------

### Derive Modifier-Defined Concept Hyperedge Example

Source: https://graphbrain.net/manual/agents.html

Shows the hyperedge generated by the taxonomy agent for modifier-defined concepts. This example demonstrates how concepts like '(black/Ma cat/Cc.s)' are classified under a broader category.

```text
(type_of/P/. (black/Ma cat/Cc.s) cat/Cc.s)
```

--------------------------------

### Command: create

Source: https://graphbrain.net/cli.html

Creates an empty hypergraph.

```APIDOC
## POST /graphbrain/create

### Description

Creates an empty hypergraph.

### Method

POST

### Endpoint

`/graphbrain --hg <hypergraph> create`

### Parameters

#### Path Parameters

- **hypergraph** (string) - Required - The path to the hypergraph database file to be created.

### Request Example

```bash
graphbrain --hg my_new_graph.hgr create
```
```

--------------------------------

### Batch Add Hyperedges using hopen Context Manager

Source: https://graphbrain.net/manual/hypergraph-operations.html

Optimizes adding a large number of hyperedges by using the `hopen` context manager. This is recommended for performance with backends like SQLite.

```python
with hopen('example.db') as hg:
    for edge in large_edge_list:
        hg.add(edge)
```

--------------------------------

### Text Representation

Source: https://graphbrain.net/manual/api.html

Function to get the text representation of an edge.

```APIDOC
## text(_edge_)

### Description
Returns the text representation of an edge.

### Endpoint
`text(edge)`

### Parameters
- **_edge_** (Hyperedge | str | list | tuple) - The edge to represent as text.
```

--------------------------------

### Get Edge Degree

Source: https://graphbrain.net/_modules/graphbrain/hypergraph.html

Returns the degree of an entity (hyperedge).

```python
def degree(self, edge):
        """Returns the degree of an entity."""
        return self._degree(hedge(edge))
```

--------------------------------

### Run Agent from Command Line

Source: https://graphbrain.net/manual/agents.html

Use the 'run' command with the '--hg' and '--agent' arguments to execute a knowledge agent. Specify additional arguments as required by the agent.

```bash
graphbrain --hg <hypergraph> --agent <agent name> run
```

```bash
graphbrain --hg books --sequence alice-in-wonderland --infile alice.txt --agent txt_parser run
```

```bash
graphbrain --hg chemistry --agent example.molecules run
```

--------------------------------

### Define Concept Numbering

Source: https://graphbrain.net/reference/notation.html

Examples of singular and plural concept numbering.

```text
apple/Cc.s
```

```text
apples/Cc.p
```

--------------------------------

### Create an English Parser

Source: https://graphbrain.net/tutorials/parsing-a-sentence.html

Initializes a parser for the English language. Loading language models may take some time.

```python
from graphbrain.parsers import *
parser = create_parser(lang='en')
```

--------------------------------

### Command: run

Source: https://graphbrain.net/cli.html

Runs a knowledge agent on a hypergraph.

```APIDOC
## POST /graphbrain/run

### Description

Runs a specified knowledge agent on a hypergraph. Agents can introspect the graph or use external sources to introduce knowledge.

### Method

POST

### Endpoint

`/graphbrain --hg <hypergraph> --agent <agent name> run`

### Parameters

#### Path Parameters

- **hypergraph** (string) - Required - The path to the hypergraph database file.
- **agent name** (string) - Required - The name of the knowledge agent to run (e.g., `taxonomy`, `txt_parser`).

#### Query Parameters

- **--infile** (string) - Optional - Input file path, used by agents like `txt_parser`.

### Request Example

Running the `taxonomy` agent:
```bash
graphbrain --hg my_graph.hgr --agent taxonomy run
```

Running the `txt_parser` agent with an input file:
```bash
graphbrain --infile some_test_file.txt --hg my_graph.hgr --agent txt_parser run
```

### Response Example

Example output from the `taxonomy` agent:
```
(type_of/P/. city/C (of/B city/C berlin/C))
```
```

--------------------------------

### Identify Actors

Source: https://graphbrain.net/manual/cli.html

Example of a hyperedge added after identifying an actor in the hypergraph.

```text
(actor/P/. mary/Cp.s/en)
```

--------------------------------

### Create Parser with Lemma Support (Python)

Source: https://graphbrain.net/manual/parsing.html

Demonstrates how to initialize a GraphBrain parser with lemma extraction enabled for a specified language.

```python
from graphbrain.parsers import create_parser
parser = create_parser(lang='en', lemmas=True)
```

--------------------------------

### GET /supertypes

Source: https://graphbrain.net/_modules/graphbrain/meaning/ontology.html

Retrieves all supertypes of a given edge within the hypergraph.

```APIDOC
## GET /supertypes

### Description
Returns all supertypes of the given edge. If deep is set to true, it recursively finds all supertypes.

### Parameters
#### Query Parameters
- **hg** (object) - Required - The hypergraph instance.
- **edge** (string) - Required - The edge to find supertypes for.
- **deep** (boolean) - Optional - Whether to perform a deep search for all nested supertypes.
```

--------------------------------

### GraphBrain Initialization and Modules

Source: https://graphbrain.net/genindex.html

Information about the GraphBrain initialization and available modules.

```APIDOC
## Initialization and Modules

### hedge()

### Description
(Description not provided in source)

### Method
(In module graphbrain.__init__)

### Endpoint
N/A (Module function)

### Parameters
None explicitly mentioned.

### Request Example
None applicable.

### Response
(Type and details not specified in source)

### Response Example
None applicable.

## Initialization and Modules

### Available Modules
- graphbrain.__init__
- graphbrain.hyperedge
- graphbrain.hypergraph
- graphbrain.memory.permutations
- graphbrain.memory.sqlite
- graphbrain.parsers.__init__
- graphbrain.parsers.parser
- graphbrain.patterns
- graphbrain.processor
- graphbrain.processors.actors
- graphbrain.processors.claims
- graphbrain.processors.conflicts
- graphbrain.processors.names
- graphbrain.processors.number
- graphbrain.processors.onto
- graphbrain.processors.taxonomy
- graphbrain.readers.csv
- graphbrain.readers.dir
- graphbrain.readers.reader
- graphbrain.readers.reddit
- graphbrain.readers.txt
- graphbrain.readers.wikipedia
- graphbrain.utils.concepts
- graphbrain.utils.conjunctions
- graphbrain.utils.corefs
- graphbrain.utils.lemmas
- graphbrain.utils.number
- graphbrain.utils.ontology
```

--------------------------------

### GET /subtypes

Source: https://graphbrain.net/_modules/graphbrain/meaning/ontology.html

Retrieves all subtypes of a given edge within the hypergraph.

```APIDOC
## GET /subtypes

### Description
Returns all subtypes of the given edge. If deep is set to true, it recursively finds all subtypes.

### Parameters
#### Query Parameters
- **hg** (object) - Required - The hypergraph instance.
- **edge** (string) - Required - The edge to find subtypes for.
- **deep** (boolean) - Optional - Whether to perform a deep search for all nested subtypes.
```

--------------------------------

### Derive Taxonomy Hyperedges

Source: https://graphbrain.net/manual/cli.html

Examples of hyperedges added when deriving taxonomies from concepts.

```text
(type_of/P/. (of/Br.ma founder/Cc.s psychoanalysis/Cc.s) founder/Cc.s)
```

```text
(type_of/P/. (black/Ma cat/Cc.s) cat/Cc.s)
```

--------------------------------

### Render HTML in Notebooks

Source: https://graphbrain.net/_modules/graphbrain/notebook.html

Wraps HTML content in a styled container and displays it using the IPython display utility.

```python
html = '<div style="background-color:#fcfcfc; padding:50px">{}'\
       '</div>'.format(html)
display(HTML(html))
```

--------------------------------

### GET /atom/main_concepts

Source: https://graphbrain.net/_modules/graphbrain/hyperedge.html

Retrieves the list of main concepts within a concept edge.

```APIDOC
## GET /atom/main_concepts

### Description
Returns a list of main concepts identified in a concept edge. Returns an empty list if no main concept is annotated.

### Method
GET

### Endpoint
/atom/main_concepts

### Response
#### Success Response (200)
- **concepts** (array) - List of main concept identifiers.
```

--------------------------------

### Initialize Parser class

Source: https://graphbrain.net/_modules/graphbrain/parsers/parser.html

Constructor for the Parser base class, setting up configuration for lemmas, coreferences, and debugging.

```python
def __init__(self, lemmas=True, corefs=True, debug=False):
    self.lemmas = lemmas
    self.corefs = corefs
    self.debug = debug

    # to be created by derived classes
    self.lang = None
```

--------------------------------

### Manage Hypergraph Database

Source: https://graphbrain.net/manual/cli.html

Commands for creating, exporting, and importing hypergraph databases.

```bash
graphbrain --hg <hypergraph_database> create
```

```bash
graphbrain --hg <hypergraph_database> --outfile <json_file> export
```

```bash
graphbrain --hg <hypergraph_database> --infile <json_file> import
```

--------------------------------

### GET /atom/argroles

Source: https://graphbrain.net/_modules/graphbrain/hyperedge.html

Retrieves the argument roles string associated with an edge, if applicable.

```APIDOC
## GET /atom/argroles

### Description
Returns the argument roles string of the edge. If the edge is not a relation (R) or concept (C) with defined roles, it returns an empty string.

### Method
GET

### Endpoint
/atom/argroles

### Response
#### Success Response (200)
- **argroles** (string) - The argument roles string.
```

--------------------------------

### Render Hyperedge with show()

Source: https://graphbrain.net/tutorials/parsing-a-sentence.html

Replaces the standard print function with `show(edge)` for a more visually appealing rendering of hyperedges in notebooks. The `show()` function offers various visualization styles and options to reduce clutter.

```python
show(edge)
```

--------------------------------

### Get Deep Degree of an Entity

Source: https://graphbrain.net/_modules/graphbrain/hypergraph.html

Returns the deep degree of an entity (hyperedge).

```python
def deep_degree(self, edge):
        """Returns the deep degree of an entity."""
        return self._deep_degree(hedge(edge))
```

--------------------------------

### Define Verbal Modifier Features

Source: https://graphbrain.net/reference/notation.html

Example of a non-atomic predicate with verbal modifier features.

```text
(have/Mv.|f—– (been/Mv.<pf—- tracking/Pd.sox.|pg—-))
```

--------------------------------

### Hypergraph Attribute Management

Source: https://graphbrain.net/api.html

Methods for setting, getting, and modifying attributes associated with edges.

```APIDOC
## set_attribute(edge, attribute, value)

### Description
Sets the value of a specific attribute for an edge.

### Parameters
#### Request Body
- **edge** (Hyperedge/string) - Required - The target edge.
- **attribute** (string) - Required - The attribute name.
- **value** (any) - Required - The value to set.

## get_str_attribute(edge, attribute, or_else=None)

### Description
Retrieves an attribute value as a string.

### Parameters
#### Request Body
- **edge** (Hyperedge/string) - Required - The target edge.
- **attribute** (string) - Required - The attribute name.
- **or_else** (any) - Optional - Default value if attribute is missing.
```

--------------------------------

### Define a hyperedge with variables

Source: https://graphbrain.net/manual/patterns.html

Variables are represented by atom labels starting with an uppercase letter.

```text
(plays/P.{so} PLAYER/C *)
```

--------------------------------

### Hyperedge with Argument Roles (Builder)

Source: https://graphbrain.net/manual/notation.html

Shows argument roles for builders, distinguishing main ('m') and auxiliary ('a') concepts. Here, 'founder' is the main concept, and 'psychoanalysis' is auxiliary, specifying a type of founder.

```sh
(of/B.ma founder/C psychoanalysis/C)
```

--------------------------------

### Extract the root of an atom

Source: https://graphbrain.net/reference/api.html

Extracts the root component of an atom. For example, the root of 'graphbrain/Cp.s/1' is 'graphbrain'.

```python
atom.root()
```

--------------------------------

### Get Connector Type

Source: https://graphbrain.net/_modules/graphbrain/hyperedge.html

Returns the type of the edge's connector, or None if the edge is an atom.

```python
def connector_type(self):
    """Returns the type of the edge's connector.
    If the edge has no connector (i.e. it's an atom), then None is
    returned.
    """
    return None
```

--------------------------------

### Get Edge Depth

Source: https://graphbrain.net/_modules/graphbrain/hyperedge.html

Returns the maximal depth of an edge, where atoms are defined as depth 0.

```python
def depth(self):
    """Returns maximal depth of edge, an atom has depth 0."""
    return 0
```

--------------------------------

### Create a language parser

Source: https://graphbrain.net/_modules/graphbrain/parsers/__init__.html

Instantiates a parser for a specified language or custom class. Requires either 'lang' or 'parser_class' to be defined.

```python
from importlib import import_module

from .nlp import print_tree
from .parser_en import ParserEN
from .text import edge_text



[docs]
def create_parser(lang=None, parser_class=None, lemmas=False, corefs=False, beta='repair', normalize=True,
                  post_process=True):
    """Creates and returns a parser (as an instanceof a subclass of Parser)
    for the language specified in the parameter. If parser_class is specified,
    then the parser specified by this class is instantiated instead. Throws
    exception if language is not implemented.

    Available parsers:
    'en' -- English

    Keyword argument:
    parser_class -- specify an external parser class.
    lemmas -- if True, lemma edges are generated by the parser.
    corefs -- if True, coreference resolution is performed.
    (default: False)
    beta -- beta stage mode, current options are 'strict' and 'repair'
    (default: 'repair')
    normalize -- perform hyperedge normalization (default: True)
    post_process -- perform hyperedge post-processing (default: True)
    """
    if not lang and not parser_class:
        raise RuntimeError(
            'Either "lang" or "parser_class" must be specified.')

    if parser_class:
        package = None
        if parser_class[0] == '.':
            parser_class = parser_class[1:]
            package = '.'
        path_parts = parser_class.split('.')
        module_name = '.'.join(path_parts[:-1])
        class_name = path_parts[-1]
        class_obj = getattr(import_module(module_name, package=package),
                            class_name)
        parser = class_obj(lemmas=lemmas, corefs=corefs, beta=beta, normalize=normalize, post_process=post_process)
        if lang and parser.lang != lang:
            raise RuntimeError(
                'Specified language and parser class do not match.')
        return parser
    elif lang == 'en':
        return ParserEN(lemmas=lemmas, corefs=corefs, beta=beta, normalize=normalize, post_process=post_process)
    else:
        raise RuntimeError('Unknown parser: {}'.format(lang))
```

--------------------------------

### Get Root Atoms

Source: https://graphbrain.net/_modules/graphbrain/hyperedge.html

Returns a new edge containing only the root atoms of the original edge.

```python
def roots(self):
    """Returns edge with root-only atoms."""
    return Hyperedge(tuple(item.roots() for item in self))
```

--------------------------------

### Visualize hyperedges with show()

Source: https://graphbrain.net/manual/notebooks.html

Produces an indented visualization with syntax highlighting based on hyperedge type.

```python
from graphbrain.notebook import *
show('((first/M published/P.sox) einstein/C (the/M (of/B theory/C relativity/C)) (in/T 1905/C))')
```

--------------------------------

### Get Connected Atoms (Ego)

Source: https://graphbrain.net/_modules/graphbrain/hypergraph.html

Returns all atoms directly connected to a center atom by hyperedges.

```python
def ego(self, center):
        """Returns all atoms directly connected to center
           by hyperedges.
        """
        edges = self.star(center)
        atom_set = set()
        for edge in edges:
            for atom in edge.atoms():
                atom_set.add(atom)
        return atom_set
```

--------------------------------

### Hypergraph Initialization

Source: https://graphbrain.net/api.html

Initializes or retrieves an instance of a Hypergraph based on a provided locator string. Supports LevelDB storage.

```APIDOC
## graphbrain.hgraph

### Description
Returns an instance of Hypergraph identified by the locator_string. The hypergraph will be created if it does not exist. Currently, the only type of hypergraph is based on LevelDB storage, and the location_string is the path to the LevelDB folder.

### Method
`hgraph`

### Parameters
#### Path Parameters
- **locator_string** (string) - Required - The string identifying the hypergraph, typically a path to the LevelDB folder.
```

--------------------------------

### Configure Boost Project-Config.jam

Source: https://graphbrain.net/manual/backends.html

Modify the project-config.jam file to specify your VS version and cl.exe path. Ensure 'keep-going' is set to false.

```jam
$ import option ;
$ using msvc : 14.1 : ‘E: \VS2017\VC\Tools\MSVC\14.1-.250117\bin\HostX64\x64\cl.exe’ ;
$ option.set keep-going : false ;

```

--------------------------------

### Get Float Attribute

Source: https://graphbrain.net/_modules/graphbrain/hypergraph.html

Retrieves an attribute as a float. Returns a default value if the attribute is not found.

```python
def get_float_attribute(self, edge, attribute, or_else=None):
        """Returns attribute as float value.

        or_else -- value to return if the entity does not have
                   the give attribute. (default None)
        """
        return self._get_float_attribute(hedge(edge), attribute, or_else=or_else)
```

--------------------------------

### Building Concepts: 'meat and potatoes'

Source: https://graphbrain.net/overview/hypergraph.html

Demonstrates building concepts from other concepts using a hyperedge.

```plaintext
(and meat potatoes)
```

--------------------------------

### Get Integer Attribute

Source: https://graphbrain.net/_modules/graphbrain/hypergraph.html

Retrieves an attribute as an integer. Returns a default value if the attribute is not found.

```python
def get_int_attribute(self, edge, attribute, or_else=None):
        """Returns attribute as integer value.

        or_else -- value to return if the entity does not have
                   the give attribute. (default None)
        """
        return self._get_int_attribute(hedge(edge), attribute, or_else=or_else)
```

--------------------------------

### Run Agent System from Command Line

Source: https://graphbrain.net/manual/agents.html

Executes a defined agent system using the GraphBrain CLI. This command specifies the hypergraph database, the input URL for the Wikipedia agent, and the system definition file.

```bash
graphbrain --hg wikipedia.db --url https://en.wikipedia.org/wiki/Artificial_intelligence --system systems/wikipedia.sys run
```

--------------------------------

### Get String Attribute

Source: https://graphbrain.net/_modules/graphbrain/hypergraph.html

Retrieves an attribute as a string. Returns a default value if the attribute is not found.

```python
def get_str_attribute(self, edge, attribute, or_else=None):
        """Returns attribute as string value.

        or_else -- value to return if the entity does not have
                   the given attribute. (default None)
        """
        return self._get_str_attribute(hedge(edge), attribute, or_else=or_else)
```
Tokens:
Raw