LinkML

https://linkml.io/linkml
Admin
LinkML is a flexible modeling language for authoring YAML schemas that describe data structure, with...
Tokens:955,328
Snippets:11,248
Trust Score:8.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Setup Development Environment

Source: https://linkml.io/linkml/maintainers/contributing.html

Commands to clone the repository and install dependencies using uv.

```bash
  git clone https://github.com/linkml/linkml
  cd linkml
  # Full installation (all optional dependencies - same as CI)
  uv sync --all-groups
  # OR lighter development installation (recommended for most development)
  uv sync --group dev
  # OR if you need to run the full test suite locally
  uv sync --group dev --group tests-extra
```

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

### Install LinkML-Store with all extras

Source: https://linkml.io/linkml-store/_sources/about.rst.txt

Use this command to install LinkML-Store with all optional dependencies included.

```bash
pip install "linkml-store[all]"
```

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

### Clone Repository and Install Dependencies

Source: https://linkml.io/linkml/_sources/maintainers/contributing.md.txt

Clone the LinkML repository and install development dependencies using uv. Choose between a full installation or a lighter development setup.

```shell
git clone https://github.com/linkml/linkml
cd linkml
# Full installation (all optional dependencies - same as CI)
uv sync --all-groups
# OR lighter development installation (recommended for most development)
uv sync --group dev
# OR if you need to run the full test suite locally
uv sync --group dev --group tests-extra
```

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

### Download Biolink Model and Setup Environment

Source: https://linkml.io/linkml/_sources/generators/pydantic.rst.txt

Commands to download the Biolink Model YAML, create a virtual environment, and install LinkML.

```bash
curl -OJ https://raw.githubusercontent.com/biolink/biolink-model/master/biolink-model.yaml
python3 -m venv venv
source venv/bin/activate
pip install linkml
```

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

### Setup for Array Generation and Comparison

Source: https://linkml.io/linkml/_sources/schemas/arrays.md.txt

Imports necessary libraries and defines helper functions for rendering and comparing LinkML schemas with their Pydantic and numpydantic representations. This setup is used throughout the examples.

```python
from linkml.generators import PydanticGenerator
from linkml_runtime.loaders.yaml_loader import YAMLLoader
from linkml_runtime.dumpers.yaml_dumper import YAMLDumper
from IPython.display import display, Markdown
from pathlib import Path
import numpy as np
from rich.console import Console
from rich.theme import Theme
from rich.style import Style
from rich.color import Color

theme = Theme({
    "repr.call": Style(color=Color.from_rgb(110,191,38), bold=True),
    "repr.attrib_name": Style(color="slate_blue1"),
    "repr.number": Style(color="deep_sky_blue1"),

})
console = Console(theme=theme)

schemas = Path('.').resolve().parent / '_includes' / 'arrays'

COMPARISON = """
:::::{{tab-set}}
::::{{tab-item}} LinkML
:::{{
code-block}} yaml
{linkml}
:::
::::
::::{{tab-item}} pydantic - LoL
:::{{
code-block}} python
{pydantic_lol}
:::
::::
::::{{tab-item}} numpydantic
:::{{
code-block}} python
{pydantic_npd}
:::
::::
:::::
"""

def render_module(path, representation='list'):
    generator = PydanticGenerator(str(path), array_representations=[representation])
    module = generator.render()
    return module

def compile_module(path, representation='list'):
    generator = PydanticGenerator(str(path), array_representations=[representation])
    module = generator.compile_module()
    return module

def render_class(path, cls, representation='list') -> str:
    module = render_module(path, representation)
    cls = module.classes[cls]
    code = cls.render(black=True)
    return code

def render_comparison(path, cls, string=False) -> str:
    if not isinstance(cls, list):
        cls = [cls]

    path = str(path)
    sch = YAMLLoader().load_as_dict(path)
    class_strs = []
    pydantic_strs = []
    npd_strs = []

    for a_cls in cls:
        class_def = sch['classes'][a_cls]
        class_def = {a_cls: class_def}
        class_strs.append(YAMLDumper().dumps(class_def))
        pydantic_strs.append(render_class(path, a_cls))
        npd_strs.append(render_class(path, a_cls, representation='numpydantic'))

    class_str = "\n".join(class_strs)
    pydantic_str = "\n".join(pydantic_strs)
    npd_str = "\n".join(npd_strs)
    md = COMPARISON.format(linkml=class_str, pydantic_lol=pydantic_str, pydantic_npd=npd_str)
    if string:
        return md
    else:
        display(Markdown(md))
```

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

### Install LinkML in a virtual environment

Source: https://linkml.io/linkml/intro/tutorial01.html

Commands to create a directory, set up a virtual environment, and install the linkml package.

```bash
mkdir linkml-tutorial
cd linkml-tutorial
python3 -m venv venv
source venv/bin/activate
pip install linkml
```

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

### Install LinkML in a virtual environment

Source: https://linkml.io/linkml/_sources/intro/tutorial01.md.txt

Set up a virtual environment and install LinkML using pip. This is the recommended approach for development.

```bash
mkdir linkml-tutorial
cd linkml-tutorial
python3 -m venv venv
source venv/bin/activate
pip install linkml
```

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

### Verify LinkML installation

Source: https://linkml.io/linkml/intro/tutorial01.html

Check that the installation was successful by invoking the help command.

```bash
linkml-convert --help
```

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

### Install LinkML-Store from source

Source: https://linkml.io/linkml-store/_sources/about.rst.txt

For developers working on the LinkML-Store codebase, clone the repository and use the make command to install all packages.

```bash
git clone <URL>
cd linkml-store
make install
```

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

### Install linkml-store with all extras using Poetry

Source: https://linkml.io/linkml-store/tutorials/Command-Line-Tutorial.html

Installs all extras for the linkml-store package when using Poetry.

```bash
poetry install --all-extras
```

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

### Configuration YAML Example

Source: https://linkml.io/linkml/_modules/linkml/generators/projectgen.html

Example of a configuration file used to define generator arguments.

```yaml
directory: .
generator_args:
  json_schema:
    top_class: Container
```

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

### Install minimal LinkML-Store

Source: https://linkml.io/linkml-store/_sources/about.rst.txt

Install the core LinkML-Store package without any optional dependencies.

```bash
pip install "linkml-store"
```

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

### Install linkml-store with all dependencies

Source: https://linkml.io/linkml-store/faq.html

This command installs the linkml-store package along with all necessary and optional dependencies. It is recommended for most users.

```bash
pip install "linkml-store[all]"

```

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

### LinkML CLI Command Example

Source: https://linkml.io/linkml/_sources/intro/install.md.txt

Example of running a LinkML command within the Docker container to display help for the 'gen-project' command.

```bash
gen-project --help
```

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

### Boolean Conversion Examples

Source: https://linkml.io/linkml/data/csvs.html

Examples showing input data and the resulting output formats based on different boolean configuration settings.

```yaml
items:
  - id: "1"
    is_active: true
  - id: "2"
    is_active: false
```

```text
id	is_active
1	true
2	false
```

```text
id	is_active
1	yes
2	no
```

```text
id	is_active
1	1
2	0
```

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

### Install linkml-store with MongoDB support

Source: https://linkml.io/linkml-store/reference/linkml_store.api.stores.mongodb.html

Install the linkml-store package with the 'mongodb' extra for MongoDB functionality, or 'all' for all available extras.

```bash
pip install linkml-store[mongodb]
```

```bash
pip install linkml-store[all]
```

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

### GitHub Actions CI/CD Validation Setup

Source: https://linkml.io/linkml-term-validator/configuration

Example GitHub Actions workflow to validate schemas, including setting up Python, installing dependencies, caching ontology databases, and running the validator in strict mode.

```yaml
# .github/workflows/validate.yml
name: Validate Schemas

on: [push, pull_request]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.10'

      - name: Install dependencies
        run: |
          pip install linkml-term-validator

      - name: Cache ontology databases
        uses: actions/cache@v3
        with:
          path: cache
          key: ontology-cache-${{ hashFiles('oak_config.yaml') }}

      - name: Validate schemas
        run: |
          linkml-term-validator validate-schema \
            --strict \
            --config oak_config.yaml \
            --cache-dir cache \
            src/schema/

```

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

### Start linkml-store Web UI

Source: https://linkml.io/linkml-store/faq.html

To start the rudimentary web UI, create a configuration file (e.g., db/conf.yaml), set the LINKML_STORE_CONFIG environment variable, and then run the 'make app' command.

```bash
export LINKML_STORE_CONFIG=./db/conf.yaml
make app

```

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

### Set up the project

Source: https://linkml.io/linkml/howtos/linkml-project-copier.html

Configures the project environment using the just command runner.

```bash
just setup
```

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

### Neo4j Cypher RETURN DISTINCT Example

Source: https://linkml.io/linkml-store/_sources/how-to/Use-Neo4j.ipynb.txt

Example of using RETURN DISTINCT to get unique values from a query. Useful for avoiding duplicate results.

```cypher
MATCH (p:Person) RETURN DISTINCT p.age
```

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

### Client Initialization with Configuration

Source: https://linkml.io/linkml-store/_modules/linkml_store/api/client.html

Shows how to create a client instance using a configuration object, file, or dictionary, with options for auto-attaching databases.

```APIDOC
## Client.from_config Method

### Description
Creates a client instance from a provided configuration, which can be a `ClientConfig` object, a dictionary, a file path, or a `Path` object. Supports automatically attaching databases defined in the configuration.

### Usage with ClientConfig Object
```python
from linkml_store.api.config import ClientConfig

config = ClientConfig(databases={"test": {"handle": "duckdb:///:memory:"}})
client = Client().from_config(config)
```

### Usage with Dictionary
```python
config_dict = {"databases": {"test": {"handle": "duckdb:///:memory:"}}}
client = Client().from_config(config_dict)
```

### Usage with File Path
```python
# Assuming a config.yaml file exists with database configurations
client = Client().from_config("path/to/config.yaml")
```

### Auto-attaching Databases
```python
client = Client().from_config(config, auto_attach=True)
```

### Parameters
- `config` (Union[ClientConfig, dict, str, Path]): The configuration for the client.
- `base_dir` (Optional[str]): The base directory for the client.
- `auto_attach` (bool): If True, automatically attach databases defined in the config.
- `**kwargs`: Additional keyword arguments.
```

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

### Command Line Usage

Source: https://linkml.io/linkml/_modules/linkml/utils/execute_tutorial.html

Example of how to invoke the tutorial execution utility from the command line.

```bash
python -m linkml.utils.execute_tutorial -d /tmp/tutorial/ docs/intro/tutorial01.md
```

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

### Start linkml-store Web API

Source: https://linkml.io/linkml-store/faq.html

To start the web API, first create a configuration file (e.g., db/conf.yaml), then set the LINKML_STORE_CONFIG environment variable, and finally run the 'make api' command.

```bash
export LINKML_STORE_CONFIG=./db/conf.yaml
make api

```

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

### Docgen Initialization Logic

Source: https://linkml.io/linkml/_modules/linkml/generators/docgen.html

Post-initialization setup for the generator, including dialect resolution, example runner configuration, and SchemaView initialization.

```python
def __post_init__(self):
    dialect = self.dialect
    if dialect is not None:
        # TODO: simplify this
        if isinstance(dialect, str):
            if dialect == MarkdownDialect.myst.value:
                dialect = MarkdownDialect.myst
            elif dialect == MarkdownDialect.python.value:
                dialect = MarkdownDialect.python
            else:
                raise NotImplementedError(f"{dialect} not supported")
        self.dialect = dialect
    if isinstance(self.diagram_type, str):
        self.diagram_type = DiagramType[self.diagram_type]
    if self.example_directory:
        self.example_runner = ExampleRunner(input_directory=Path(self.example_directory))
    super().__post_init__()
    self.logger = logging.getLogger(__name__)
    # Forward importmap/base_dir; the call to ``super().__post_init__``
    # above built a ``self.schemaview`` with these honoured, and this
    # overwrite must not drop them or URI-style imports resolved via
    # ``--importmap`` will fall through to HTTP when ``mergeimports``
    # triggers ``imports_closure()``.
    self.schemaview = SchemaView(
        self.schema,
        merge_imports=self.mergeimports,
        base_dir=self.base_dir,
        importmap=self.importmap,
    )

    # Override schemaview's get_mappings to use preserved URIs when needed
    if self.preserve_names:
        original_get_mappings = self.schemaview.get_mappings

        def get_mappings_with_preserved_uris(element_name, **kwargs):
            mappings = original_get_mappings(element_name, **kwargs)
            if mappings and element_name:
                try:
                    element = self.schemaview.get_element(element_name)
                    if element:
                        preserved_uri = self.uri(element, expand=True)
                        # Fix self and native mappings to use preserved URI
                        for key in ("self", "native"):
                            if key in mappings:
                                mappings[key] = [preserved_uri]
                except Exception:
                    pass
            return mappings

        self.schemaview.get_mappings = get_mappings_with_preserved_uris
```

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

### Initialize Client and Attach Database

Source: https://linkml.io/linkml-store/reference/linkml_store.api.html

Demonstrates initializing the LinkML Store client and attaching to a DuckDB database with an alias. Shows how to create a collection and verify its existence.

```python
from linkml_store.api.client import Client
client = Client()
db = client.attach_database("duckdb", alias="test")
collection = db.create_collection("Person")
db.get_collection("Person") == collection

```

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

### Create Patient CSV File

Source: https://linkml.io/linkml-store/_sources/how-to/Check-Referential-Integrity.ipynb.txt

Write patient data to a CSV file named 'patients.csv'. This is a setup step for command-line examples.

```python
PATIENTS = """id,name,age

```

```python
p1,John Doe,34

```

```python
p2,Jane Doe,65

```

```python
"""

```

```python
with open("output/patients.csv", "w") as stream:

```

```python
    stream.write(PATIENTS)
```

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

### LinkML Schema Definition

Source: https://linkml.io/linkml-store/_sources/how-to/Perform-LLM-Inference.ipynb.txt

Define a LinkML schema with enums, permissible values, descriptions, and examples. This schema can be used to guide LLM inference.

```yaml
name: uniprot-comments
id: http://example.org/uniprot-comments
imports:
- linkml: types
prefixes:
  linkml:
    prefix_prefix: linkml
    prefix_reference: https://w3id.org/linkml/
  up:
    prefix_prefix: up
    prefix_reference: http://example.org/tuniprot-comments
default_prefix: up
default_range: string
enums:
  CommentCategory:
    name: CommentCategory
    permissible_values:
      FUNCTION_DISPUTED:
        text: FUNCTION_DISPUTED
        description: A caution indicating that a previously reported function has
          been challenged or disproven in subsequent studies; may warrant GO NOT annotation
        examples:
        - value: FUNCTION_DISPUTED
          description: Originally described for its in vitro hydrolytic activity towards
            dGMP, dAMP and dIMP. However, this was not confirmed in vivo
      FUNCTION_PREDICTION_ONLY:
        text: FUNCTION_PREDICTION_ONLY
        description: A caution indicating function is based only on computational
          prediction or sequence similarity
        examples:
        - value: FUNCTION_PREDICTION_ONLY
          description: Predicted to be involved in X based on sequence similarity
      FUNCTION_LACKS_EVIDENCE:
        text: FUNCTION_LACKS_EVIDENCE
        description: A caution indicating insufficient experimental evidence to support
          predicted function
        examples:
        - value: FUNCTION_LACKS_EVIDENCE
          description: In contrast to other Macro-domain containing proteins, lacks

```

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

### Set Up LinkML Project Environment

Source: https://linkml.io/linkml/_sources/howtos/linkml-project-copier.md.txt

Run this command after creating your project to install dependencies and configure the development environment.

```bash
just setup
```

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

### Database Initialization and Usage

Source: https://linkml.io/linkml-store/_modules/linkml_store/api/database.html

Demonstrates how to attach a database, create collections, insert data, and query collections.

```APIDOC
## Database Initialization and Usage

### Description
This section illustrates the basic usage of the Database class, including attaching to a database, creating collections, inserting data, and performing queries.

### Example Usage
```python
from linkml_store.api.client import Client

# Attach a database (using duckdb in-memory for example)
client = Client()
db = client.attach_database("duckdb:///:memory:", alias="test")

# Check the handle and alias
print(f"Database Handle: {db.handle}")
assert db == client.get_database("test")

# Create a collection
collection = db.create_collection("Person")
print(f"Number of collections: {len(db.list_collections())}")
assert db.get_collection("Person") == collection

# Insert data into the collection
objs = [{"id": "P1", "name": "John", "age_in_years": 30}, {"id": "P2", "name": "Alice", "age_in_years": 25}]
collection.insert(objs)

# Find all objects in the collection
qr_all = collection.find()
print(f"Found {len(qr_all.rows)} objects.")
print(f"First object ID: {qr_all.rows[0]['id']}")
print(f"Second object name: {qr_all.rows[1]['name']}")

# Find objects with a specific filter
qr_filtered = collection.find({"name": "John"})
print(f"Found {len(qr_filtered.rows)} objects matching name 'John'.")
print(f"Filtered object name: {qr_filtered.rows[0]['name']}")
```
```

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

### Induce Schema View Example

Source: https://linkml.io/linkml-store/_modules/linkml_store/api/database.html

Demonstrates how to get a schema view for a collection and inspect class attributes. If no explicit schema is provided, one will be generalized.

```python
>>> from linkml_store.api.client import Client
>>> client = Client()
>>> db = client.attach_database("duckdb", alias="test", recreate_if_exists=True)
>>> collection = db.create_collection("Person", alias="persons")
>>> collection.insert([{"id": "P1", "name": "John", "age_in_years": 25}])
>>> schema_view = db.schema_view
>>> cd = schema_view.get_class("Person")
>>> cd.attributes["id"].range
'string'
>>> cd.attributes["age_in_years"].range
'integer'

We can reuse the same class:

>>> collection2 = db.create_collection("Person", alias="other_persons")
>>> collection2.class_definition().attributes["age_in_years"].range
'integer'
```

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

### Python: Fetching Data with Monarch-API

Source: https://linkml.io/linkml-store/_sources/how-to/Query-the-Monarch-KG.ipynb.txt

Demonstrates how to use the Monarch-API Python client to fetch data. Requires installation of the `monarch-api` package. This example retrieves classes and their labels.

```python
from monarch_api import MonarchService

service = MonarchService()

# Fetch classes and their labels
response = service.get_classes(limit=10)

for cls in response.classes:
    print(f"ID: {cls.id}, Label: {cls.label}")
```

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

### Neo4j Cypher APOC Library Function

Source: https://linkml.io/linkml-store/_sources/how-to/Use-Neo4j.ipynb.txt

Example using a function from the APOC (Awesome Procedures On Cypher) library for text manipulation. Ensure APOC is installed and configured.

```cypher
MATCH (n:Person) RETURN n.name, apoc.text.capitalize(n.title) AS capitalized_title
```

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

### Create Sample CSV File

Source: https://linkml.io/linkml-store/_sources/how-to/Check-Referential-Integrity.ipynb.txt

Write sample data to a CSV file named 'samples.csv', including a foreign key to the patient data. This is a setup step for command-line examples.

```python
SAMPLES = """id,patient

```

```python
s1,p1

```

```python
s2,p2

```

```python
s3,p2

```

```python
"""

```

```python
with open("output/samples.csv", "w") as stream:

```

```python
    stream.write(SAMPLES)
```

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

### Set configuration and start linkml-store web UI

Source: https://linkml.io/linkml-store/_sources/faq.rst.txt

To launch the linkml-store web UI, set the LINKML_STORE_CONFIG environment variable to your configuration file's location and then run 'make app'.

```bash
export LINKML_STORE_CONFIG=./db/conf.yaml
make app
```

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

### Install LLM Claude 3 Model

Source: https://linkml.io/linkml-store/_sources/tutorials/Command-Line-Tutorial.ipynb.txt

Installs the llm-claude-3 model using the 'llm install' command. Ensure you have the 'llm' tool installed.

```bash
llm install llm-claude-3
```

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

### Verify Python Installation

Source: https://linkml.io/linkml/_sources/intro/install.md.txt

Check if Python is installed and view its version information. This is a prerequisite for local LinkML installation.

```bash
python
```

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

### Install linkml-store from source using Poetry

Source: https://linkml.io/linkml-store/faq.html

For developers, clone the repository, navigate to the directory, and use Poetry to install the project. This is the standard procedure for linkml projects.

```bash
git clone <URL>
cd linkml-store
make install

```

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

### LLM Installation Output

Source: https://linkml.io/linkml-store/tutorials/Command-Line-Tutorial.html

This output confirms the successful installation of the `llm-claude-3` package and its dependencies. It shows that the requirements are already satisfied, indicating the package is installed.

```text
Requirement already satisfied: llm-claude-3 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (0.4)
Requirement already satisfied: llm in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from llm-claude-3) (0.15)
Requirement already satisfied: anthropic>=0.17.0 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from llm-claude-3) (0.32.0)
Requirement already satisfied: anyio<5,>=3.5.0 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from anthropic>=0.17.0->llm-claude-3) (4.4.0)
Requirement already satisfied: distro<2,>=1.7.0 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from anthropic>=0.17.0->llm-claude-3) (1.9.0)
Requirement already satisfied: httpx<1,>=0.23.0 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from anthropic>=0.17.0->llm-claude-3) (0.27.0)
Requirement already satisfied: jiter<1,>=0.4.0 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from anthropic>=0.17.0->llm-claude-3) (0.5.0)
Requirement already satisfied: pydantic<3,>=1.9.0 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from anthropic>=0.17.0->llm-claude-3) (2.8.2)
Requirement already satisfied: sniffio in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from anthropic>=0.17.0->llm-claude-3) (1.3.1)
Requirement already satisfied: tokenizers>=0.13.0 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from anthropic>=0.17.0->llm-claude-3) (0.19.1)
Requirement already satisfied: typing-extensions<5,>=4.7 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from anthropic>=0.17.0->llm-claude-3) (4.12.2)
Requirement already satisfied: click in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from llm->llm-claude-3) (8.1.7)
Requirement already satisfied: openai>=1.0 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from llm->llm-claude-3) (1.40.1)
Requirement already satisfied: click-default-group>=1.2.3 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from llm->llm-claude-3) (1.2.4)
Requirement already satisfied: sqlite-utils>=3.37 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from llm->llm-claude-3) (3.37)
Requirement already satisfied: sqlite-migrate>=0.1a2 in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from llm->llm-claude-3) (0.1b0)
Requirement already satisfied: PyYAML in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from llm->llm-claude-3) (6.0.2)
Requirement already satisfied: pluggy in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from llm->llm-claude-3) (1.5.0)
Requirement already satisfied: python-ulid in /Users/cjm/Library/Caches/pypoetry/virtualenvs/linkml-store-8ZYO4kTy-py3.10/lib/python3.10/site-packages (from llm->llm-claude-3) (2.7.0)
```

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

### Run linkml-store CLI Help

Source: https://linkml.io/linkml-store/faq.html

Use this command to see all available options for the linkml-store command-line interface. Note that some options may change before version 1.0.0.

```bash
linkml-store --help

```

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

### Create a LinkML-Store Client

Source: https://linkml.io/linkml-store/how-to/Index-Phenopackets.html

Initialize a LinkML-Store client. This is the entry point for interacting with the store.

```python
from linkml_store import Client

client = Client()

```

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

### Convert LinkML Examples to JSON Schema Format

Source: https://linkml.io/linkml/_modules/linkml/generators/jsonschemagen.html

Transforms LinkML Example objects into a list compatible with the JSON Schema 'examples' keyword, handling scalar and array-valued slot coercion.

```python
def _slot_examples_for_json_schema(
    examples: dict | Example | list[dict | Example] | None,
    *,
    json_schema_type: list[str] | str | None = None,
    is_array_valued: bool,
) -> list:
    """Convert a list of LinkML :class:`~linkml_runtime.linkml_model.meta.Example` objects
    into a list suitable for the JSON Schema ``examples`` keyword.

    In the LinkML metamodel ``Example.value`` is typed as ``str``, so any non-string
    value written in YAML (integer, boolean, list, …) is coerced to its Python ``str()``
    representation on load. ``Example.object`` holds a single structured dict/object.

    Since ``Example.value`` is coerced to ``str`` in the LinkML metamodel, the values
    are coerced back to their original basic scalar type if json_schema_type is provided
    ("integer", "number", and "boolean" are supported). If ``is_array_valued`` is ``True``,
    values are coerced back to list (using ``ast.literal_eval()``).

    After coercion, the cardinality of the ``Example`` objects are mapped to the JSON
    Schema ``examples`` property according to the following rules:

    **Single-valued slots or class-level examples** (``is_array_valued=False``): each
    ``Example`` contributes one independent entry.

    **Array-valued slots** (``is_array_valued=True``): because the enclosing JSON Schema
    property is ``type: array``, every entry in ``examples`` must itself be an array so
    that it validates against the property schema. Two authoring styles are supported:

    1.  If ``Example.value`` is a basic scalar (either originally a str, or coerced to
        str) or if ``Example.object`` is defined, it is considered an example of an array
        item and not of the full array. Hence, all such scalar examples are merged into
        an array that together comprise a full entry in the JSON Schema ``examples`` array.

    2.  If ``Example.value`` is a list (coerced to str), it is considered a full entry
        in the JSON Schema ``examples`` array and returned as is (after coercion back
        to list).

    If examples of multiple types are present simultaneously, the merged entry is returned
    first, e.g.::

```

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

### Run tests with snapshot generation

Source: https://linkml.io/linkml/maintainers/contributing.html

Command line examples for running tests with snapshot generation and specific markers.

```bash
uv run pytest tests/linkml/test_scripts/test_gen_owl.py --with-slow --generate-snapshots
```

```bash
uv run pytest tests/linkml/test_scripts/test_gen_shex.py --generate-snapshots --with-network
```

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

### Valid Data Example

Source: https://linkml.io/linkml-term-validator/binding-validation

Example of data that conforms to the defined schema bindings.

```yaml
gene_id: BRCA1
process:
  id: GO:0007049                  # cell cycle - is a biological process
  label: cell cycle
location:
  id: GO:0005634                  # nucleus - is a cellular component
  label: nucleus
```

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

### Create Collection and Inspect Schema

Source: https://linkml.io/linkml-store/reference/linkml_store.api.html

Shows how to create a client, attach a database, create a collection with specific data, and then inspect the induced schema view for class attributes. Useful for understanding data structure after insertion.

```python
from linkml_store.api.client import Client
client = Client()
db = client.attach_database("duckdb", alias="test", recreate_if_exists=True)
collection = db.create_collection("Person", alias="persons")
collection.insert([{"id": "P1", "name": "John", "age_in_years": 25}])
schema_view = db.schema_view
cd = schema_view.get_class("Person")
cd.attributes["id"].range
cd.attributes["age_in_years"].range
```

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

### Create Client from Configuration File

Source: https://linkml.io/linkml-store/_modules/linkml_store/api/client.html

Initialize a client by loading configuration from a YAML file. The `base_dir` can be specified to resolve relative paths within the configuration. `auto_attach` controls whether databases are automatically initialized.

```python
client = Client().from_config("path/to/config.yaml", base_dir=Path("data/"), auto_attach=True)
```

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

### Verify Python installation

Source: https://linkml.io/linkml/intro/install.html

Check the installed Python version and environment via the shell.

```shell
Python 3.13.11 (tags/v3.13.11:6278944, Dec  5 2025, 16:26:58) [MSC v.1944 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

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

### Show linkml-store query help

Source: https://linkml.io/linkml-store/_sources/tutorials/Command-Line-Tutorial.ipynb.txt

Displays the available options and usage for the `linkml-store query` command.

```bash
linkml-store query --help
```

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

### Initialize Models with Various Array Backends

Source: https://linkml.io/linkml/schemas/arrays.html

Demonstrates initializing the model with different array types including numpy, dask, hdf5, zarr, and video files.

```python
import numpy as np
import dask.array as da
import zarr

# numpy
model = MyModel(array=np.zeros((3, 4, 5), dtype=int))
# dask
model = MyModel(array=da.zeros((3, 4, 5), dtype=int))
# hdf5 datasets
model = MyModel(array=('data.h5', '/nested/dataset'))
# zarr arrays
model = MyModel(array=zarr.zeros((3,4,5), dtype=int))
model = MyModel(array='data.zarr')
model = MyModel(array=('data.zarr', '/nested/dataset'))
# video files
model = MyModel(array="data.mp4")
```

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

### Initialize FileSystemCollection

Source: https://linkml.io/linkml-store/_modules/linkml_store/api/stores/filesystem/filesystem_collection.html

Initializes a FileSystemCollection, setting up the path and file format. If not provided, it defaults to 'json'.

```python
def __init__(self, **kwargs):
        super().__init__(**kwargs)
        parent: DatabaseType = self.parent
        if not self.path:
            if self.parent:
                self.path = Path(parent.directory_path)
        self._objects_list = []
        self._object_map = {}
        if not self.file_format:
            self.file_format = "json"
```

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

### Split Pattern Examples

Source: https://linkml.io/linkml/_modules/linkml/generators/pydanticgen/pydanticgen.html

Examples of how split_pattern templates are rendered into Python import statements.

```text
".{{ schema.name }}" (the default) becomes

from .example_schema import ClassA, ...

"...{{ schema.name }}.v{{ schema.version | replace('.', '_') }}" becomes

from ...example_schema.v1_2_3 import ClassA, ...
```

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

### Example Generation

Source: https://linkml.io/linkml/_modules/linkml/generators/jsonschemagen.html

Adds example values to the JSON Schema property if defined in the slot.

```python
        if slot.examples:
            prop.add_keyword(
                "examples",
                _slot_examples_for_json_schema(
                    slot.examples,
                    json_schema_type=typ,
                    is_array_valued=slot_is_multivalued,
                ),
            )

        return prop
```

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

### Client Initialization and Usage

Source: https://linkml.io/linkml-store/_modules/linkml_store/api/client.html

Demonstrates how to initialize a LinkML Store Client, attach databases, create collections, and perform basic data operations.

```APIDOC
## Client Class

### Description
A client is the top-level object for interacting with databases. It provides access to one or more `Database` objects, each of which consists of a number of `Collection` objects.

### Initialization
```python
client = Client()
```

### Attaching a Database
```python
db = client.attach_database("duckdb", alias="test")
```

### Creating a Collection and Inserting Data
```python
collection = db.create_collection("Person")
objs = [{"id": "P1", "name": "John", "age_in_years": 30}, {"id": "P2", "name": "Alice", "age_in_years": 25}]
collection.insert(objs)
```

### Querying Data
```python
qr = collection.find()
# qr.rows will contain the inserted objects

qr = collection.find({"name": "John"})
# qr.rows will contain objects where name is 'John'
```

### Client Handle
```python
print(db.handle) # Example: 'duckdb:///:memory:'
```

### Base Directory
```python
print(client.base_dir)
```
```

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

### Install TypeDB Dependencies

Source: https://linkml.io/linkml/generators/typedb.html

Install the optional typedb group required for running integration tests.

```bash
uv sync --group typedb
```

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

### Show linkml-store describe help

Source: https://linkml.io/linkml-store/_sources/tutorials/Command-Line-Tutorial.ipynb.txt

Displays the available options and usage for the `linkml-store describe` command, which provides an overview of the data set schema.

```bash
linkml-store describe --help
```

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

### Set configuration and start linkml-store API

Source: https://linkml.io/linkml-store/_sources/faq.rst.txt

To run the linkml-store web API, first set the LINKML_STORE_CONFIG environment variable to your configuration file path, then execute the 'make api' command.

```bash
export LINKML_STORE_CONFIG=./db/conf.yaml
make api
```

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

### Install linkml-term-validator

Source: https://linkml.io/linkml-term-validator

Install the package using pip. This is the first step to using the term validator.

```bash
pip install linkml-term-validator

```

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

### Load and Query Data in SolrCollection

Source: https://linkml.io/linkml-store/reference/linkml_store.api.stores.solr.solr_collection.html

Shows the initial steps to set up a collection by creating a client, attaching a database, creating a collection, and inserting objects, before running a query. The actual query execution part is marked as TODO.

```python
>>> from linkml_store import Client
>>> from linkml_store.utils.format_utils import load_objects
>>> client = Client()
>>> db = client.attach_database("duckdb")
>>> collection = db.create_collection("Country")
>>> objs = load_objects("tests/input/countries/countries.jsonl")
>>> collection.insert(objs)
```

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

### Install linkml-store with LLM extra

Source: https://linkml.io/linkml-store/tutorials/Command-Line-Tutorial.html

Installs the linkml-store package with the necessary extras for LLM functionality.

```bash
pip install linkml-store[llm]
```

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

### Class Instantiation Examples

Source: https://linkml.io/linkml/generators/python.html

Examples of constructing classes with single values versus dictionary inputs.

```python
my_entries = ListOfIntegers(17)
```

```python
my_entries = ListOfClasses(dict(name='element1', value=17))
```

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

### Example Project Listing Output

Source: https://linkml.io/linkml/_sources/intro/tutorial08.md.txt

This is an example of the file listing you might see after generating a project. It shows the various artifacts created by the `gen-project` script in the specified output directory.

```text
Makefile
personinfo
personinfo.json
personinfo.py
personinfo.shex
setup.py

```

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

### Local Testing Setup Configuration

Source: https://linkml.io/linkml-term-validator/configuration

Configure a local OBO file for fast, offline testing and include real ontologies for integration tests.

```yaml
# oak_config.yaml (for tests)
ontology_adapters:
  # Use local OBO file for fast, offline testing
  TEST: simpleobo:tests/data/test_ontology.obo

  # Real ontologies for integration tests
  GO: sqlite:obo:go

```
Tokens:
Raw