### OpenEBench Quality Metrics Example JSON

Source: https://context7.com/research-software-ecosystem/content/llms.txt

An example JSON object representing real quality metrics data for a tool, conforming to the OpenEBench Metrics Schema. It demonstrates the structure for reporting project and distribution metrics, including website operational status, licensing, and source code availability. This serves as a concrete illustration of the schema's application.

```json
[
  {
    "@id": "https://openebench.bsc.es/monitor/metrics/biotools:fastqc/app/github.com",
    "@type": "metrics",
    "project": {
      "documentation": {
        "general": true
      },
      "license": {
        "open_source": true,
        "osi": true
      },
      "website": {
        "bioschemas": true,
        "https": true,
        "ssl": true,
        "operational": 200
      }
    },
    "distribution": {
      "sourcecode": {
        "free": true,
        "public": true,
        "license": true,
        "readme": true,
        "repository": {
          "anonymous": true,
          "online": true
        }
      }
    }
  }
]
```

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

### Bioschemas Linked Data Format JSON Example

Source: https://context7.com/research-software-ecosystem/content/llms.txt

Example of Bioschemas linked data in JSON-LD format, compatible with Schema.org, for semantic web integration. It defines metadata for a software application, including its name, description, license, and associated topics and operations. Dependencies include Schema.org, EDAM, and biotools ontologies.

```json
{
  "@context": {
    "schema": "https://schema.org/",
    "edam": "http://edamontology.org/",
    "biotools": "https://bio.tools/ontology/"
  },
  "@graph": [
    {
      "@id": "https://bio.tools/fastqc",
      "@type": "schema:SoftwareApplication",
      "schema:name": "FastQC",
      "schema:description": "This tool aims to provide a QC report which can spot problems or biases...",
      "schema:license": "GPL-3.0",
      "schema:additionalType": ["Command-line tool", "Desktop application"],
      "schema:applicationSubCategory": [
        {"@id": "edam:topic_3168"},
        {"@id": "edam:topic_3572"}
      ],
      "schema:featureList": [
        {"@id": "edam:operation_2238"},
        {"@id": "edam:operation_3218"}
      ],
      "biotools:primaryContact": "Simon Andrews"
    }
  ]
}
```

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

### Python Scripts for Programmatic Data Access

Source: https://context7.com/research-software-ecosystem/content/llms.txt

Python functions utilizing standard libraries (json, yaml, pathlib) to programmatically load and parse metadata for tools from various sources such as bio.tools, bioconda, Galaxy, and OpenEBench. Includes example usage for accessing specific tool information.

```python
import json
import yaml
from pathlib import Path

# Read bio.tools metadata
def load_biotools_metadata(tool_name):
    path = Path(f"data/{tool_name}/{tool_name}.biotools.json")
    if path.exists():
        with open(path) as f:
            return json.load(f)
    return None

# Read bioconda metadata
def load_bioconda_metadata(tool_name):
    path = Path(f"data/{tool_name}/bioconda_{tool_name}.yaml")
    if path.exists():
        with open(path) as f:
            return yaml.safe_load(f)
    return None

# Read Galaxy metadata
def load_galaxy_metadata(tool_name):
    path = Path(f"data/{tool_name}/{tool_name}.galaxy.json")
    if path.exists():
        with open(path) as f:
            return json.load(f)
    return None

# Read OpenEBench metrics
def load_oeb_metrics(tool_name):
    path = Path(f"data/{tool_name}/{tool_name}.oeb.metrics.json")
    if path.exists():
        with open(path) as f:
            return json.load(f)
    return None

# Example usage
fastqc_biotools = load_biotools_metadata("fastqc")
print(f"Tool: {fastqc_biotools['name']}")
print(f"Description: {fastqc_biotools['description']}")

fastqc_bioconda = load_bioconda_metadata("fastqc")
print(f"Version: {fastqc_bioconda['package']['version']}")
print(f"License: {fastqc_bioconda['about']['license']}")

fastqc_galaxy = load_galaxy_metadata("fastqc")
print(f"Galaxy deployments on UseGalaxy.eu: {fastqc_galaxy['Number_of_tools_on_UseGalaxy.eu']}")

fastqc_metrics = load_oeb_metrics("fastqc")
print(f"Open source: {fastqc_metrics[0]['project']['license']['open_source']}")
```

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

### Bioconda Package Metadata (YAML)

Source: https://context7.com/research-software-ecosystem/content/llms.txt

Specifies the metadata format for Bioconda packages, detailing software name, version, build configuration, runtime dependencies, source URL, checksum, testing commands, and licensing information. This enables reproducible software installation via conda.

```yaml
package:
  name: fastqc
  version: 0.12.1

build:
  number: 0
  noarch: generic

requirements:
  run:
    - openjdk >=8.0.144
    - perl
    - fontconfig

source:
  url: https://www.bioinformatics.babraham.ac.uk/projects/fastqc/fastqc_v0.12.1.zip
  sha256: 5f4dba8780231a25a6b8e11ab2c238601920c9704caa5458d9de559575d58aa7

test:
  commands:
    - fastqc -h
    - fastqc --version

about:
  home: http://www.bioinformatics.babraham.ac.uk/projects/fastqc/
  license: GPL >=3
  summary: A quality control tool for high throughput sequence data.

extra:
  identifiers:
    - biotools:fastqc
    - usegalaxy-eu:fastqc
```

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

### List Tool Metadata Files (Bash)

Source: https://context7.com/research-software-ecosystem/content/llms.txt

Demonstrates how to list all metadata files for a specific tool within the RSEc repository's directory structure. This is useful for understanding the different metadata sources available for a given software package.

```bash
# Example directory structure for the 'fastqc' tool
data/fastqc/
├── fastqc.biotools.json          # bio.tools registry metadata
├── bioconda_fastqc.yaml          # Bioconda package metadata
├── biocontainers.yaml            # BioContainers image metadata (legacy)
├── fastqc.biocontainers.yaml     # BioContainers image metadata (current)
├── fastqc.bioschemas.jsonld      # Bioschemas semantic annotations
├── fastqc.debian.yaml            # Debian Med package metadata
├── fastqc.galaxy.json            # Galaxy tool deployment metadata
└── fastqc.oeb.metrics.json       # OpenEBench quality metrics

# List all metadata files for a specific tool
ls data/fastqc/
```

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

### Google Analytics Configuration (JavaScript)

Source: https://github.com/research-software-ecosystem/content/blob/master/imports/bioconductor/apalyzer.bioconductor.citation.html

This snippet configures Google Analytics by initializing the data layer and setting up the tracking configuration. It is a standard practice for website analytics.

```javascript
window.dataLayer = window.dataLayer || [];
function gtag() {
  dataLayer.push(arguments);
}
gtag("js", new Date());
gtag("config", "G-WJMEEH1J58");
```

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

### SPARQL Query for Tools, Operations, Definitions, and Synonyms

Source: https://github.com/research-software-ecosystem/content/blob/master/doc/bioschemas.md

This SPARQL query selects the first 100 software applications, their names, features (operations), associated EDAM definitions, and synonyms. It targets specific schema.org and GO terms. Requires a SPARQL endpoint with linked data.

```sparql
SELECT  * WHERE {
?x rdf:type <http://schema.org/SoftwareApplication> ;
   <http://schema.org/name> ?name ; 
   <http://schema.org/featureList> ?feature .

?feature  <http://www.geneontology.org/formats/oboInOwl#hasDefinition> ?def ;
         <http://www.geneontology.org/formats/oboInOwl#hasExactSynonym> ?syn .
} limit 100
```

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

### Count Software Licenses (SPARQL)

Source: https://github.com/research-software-ecosystem/content/blob/master/doc/bioschemas.md

This query counts the occurrences of each software license within the dataset. It identifies software applications by their schema.org type and extracts their licenses. The results are grouped by license and ordered in descending order of count.

```sparql
SELECT  ?license (COUNT(?license) as ?c) WHERE {
?x rdf:type <http://schema.org/SoftwareApplication> ;
   <http://schema.org/name> ?name ; 
   <http://schema.org/license> ?license .
} GROUP BY ?license
ORDER BY DESC(?c)
```

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

### Shell Commands for Accessing Import Data and Reports

Source: https://context7.com/research-software-ecosystem/content/llms.txt

Shell commands to navigate and inspect files within the research software ecosystem repository. This includes listing files in import directories (bioconda, debian-med, galaxy, bioconductor) and viewing coverage reports for tool presence across different ecosystems.

```bash
# List bioconda import files
ls imports/bioconda/ | head -10
```

```bash
# List debian-med imports
ls imports/debian-med/
```

```bash
# List galaxy tool imports
ls imports/galaxy/
```

```bash
# List bioconductor imports
ls imports/bioconductor/
```

```bash
# View ecosystem coverage summary
cat report/summary.md
```

```bash
# View detailed tool-by-tool ecosystem presence
cat report/ecosystem.md | grep -E "biotools|bioconda|biocontainers" | head -20
```

```bash
# Count tools by ecosystem presence
grep "✓" report/ecosystem.md | wc -l
```

```bash
# Find tools available in all ecosystems
cat report/ecosystem.md | grep "✓.*✓.*✓.*✓.*✓.*✓.*✓.*✓"
```

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

### SPARQL Queries for Bio.tools Metadata

Source: https://context7.com/research-software-ecosystem/content/llms.txt

A collection of SPARQL queries to extract and analyze metadata from the bio.tools registry. These queries focus on listing properties, retrieving tool details with definitions and synonyms, identifying popular licenses, and finding the most frequent EDAM operations.

```sparql
SELECT ?p (COUNT(?s) AS ?count)
WHERE {
  ?s ?p ?o
}
GROUP BY ?p
ORDER BY DESC(?count)
```

```sparql
SELECT * WHERE {
  ?x rdf:type <http://schema.org/SoftwareApplication> ;
     <http://schema.org/name> ?name ;
     <http://schema.org/featureList> ?feature .

  ?feature <http://www.geneontology.org/formats/oboInOwl#hasDefinition> ?def ;
           <http://www.geneontology.org/formats/oboInOwl#hasExactSynonym> ?syn .
} LIMIT 100
```

```sparql
SELECT ?license (COUNT(?license) as ?count) WHERE {
  ?x rdf:type <http://schema.org/SoftwareApplication> ;
     <http://schema.org/name> ?name ;
     <http://schema.org/license> ?license .
}
GROUP BY ?license
ORDER BY DESC(?count)
```

```sparql
SELECT ?operation (COUNT(?operation) as ?count) ?label WHERE {
  ?x rdf:type <http://schema.org/SoftwareApplication> ;
     <http://schema.org/name> ?name ;
     <http://schema.org/featureList> ?operation .
  ?operation rdfs:label ?label .
}
GROUP BY ?operation ?label
ORDER BY DESC(?count)
LIMIT 3
```

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

### Galaxy Tool Metadata (JSON)

Source: https://context7.com/research-software-ecosystem/content/llms.txt

Describes metadata for Galaxy tool deployments, including descriptions, associated EDAM operations and topics, homepage URLs, versioning information, and counts of deployments across different Galaxy instances. This aids in tracking and managing tool availability within the Galaxy ecosystem.

```json
{
  "Description": "Read QC reports using FastQC",
  "EDAM_operations": [
    "Sequence composition calculation",
    "Sequencing quality control",
    "Statistical calculation"
  ],
  "EDAM_topics": [
    "Sequencing",
    "Data quality management",
    "Sequence analysis"
  ],
  "Homepage": "http://www.bioinformatics.babraham.ac.uk/projects/fastqc/",
  "Latest_suite_conda_package_version": "0.12.1",
  "Number_of_tools_on_UseGalaxy.eu": 1,
  "Number_of_tools_on_Galaxy@Pasteur": 1,
  "Number_of_tools_on_GalaxyTrakr": 1,
  "Suite": "suite_fastqc",
  "ToolShed_categories": [
    "Fastq Manipulation",
    "Sequence Analysis"
  ],
  "bio.tool_id": "fastqc",
  "bio.tool_name": "FastQC"
}
```

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

### Google Analytics Configuration (JavaScript)

Source: https://github.com/research-software-ecosystem/content/blob/master/imports/bioconductor/branchpointer.bioconductor.citation.html

This snippet configures Google Analytics for the Bioconductor website. It initializes the data layer and sets up the tracking configuration with a specific measurement ID. This is used for website analytics and user behavior tracking.

```javascript
window.dataLayer = window.dataLayer || [];
function gtag() {
  dataLayer.push(arguments);
} gtag("js", new Date());
 gtag("config", "G-WJMEEH1J58");
```

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

### Google Analytics Configuration (JavaScript)

Source: https://github.com/research-software-ecosystem/content/blob/master/imports/bioconductor/biodbncbi.bioconductor.citation.html

This JavaScript snippet configures Google Analytics for the Bioconductor website. It initializes the dataLayer and sets up the tracking configuration with a specific measurement ID. This is used for website analytics.

```javascript
window.dataLayer = window.dataLayer || [];
function gtag() {
  dataLayer.push(arguments);
}
gtag("js", new Date());
gtag("config", "G-WJMEH1J58");
```

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

### Website Analytics Configuration (JavaScript)

Source: https://github.com/research-software-ecosystem/content/blob/master/imports/bioconductor/cispath.bioconductor.citation.html

This JavaScript code snippet configures Google Analytics for the Bioconductor website. It initializes the dataLayer and sends an event to track the page view. This is standard practice for website analytics to monitor user engagement and site performance.

```javascript
window.dataLayer = window.dataLayer || [];
function gtag() {
  dataLayer.push(arguments);
} gtag("js", new Date());

gtag("config", "G-WJMEEH1J58");
```

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

### Google Analytics Configuration (JavaScript)

Source: https://github.com/research-software-ecosystem/content/blob/master/imports/bioconductor/lute.bioconductor.citation.html

This JavaScript snippet initializes and configures Google Analytics for the Bioconductor website. It ensures that the dataLayer is available and then sends a 'js' event with the current date, followed by a 'config' event to set the tracking ID.

```javascript
window.dataLayer = window.dataLayer || [];
function gtag() {
  dataLayer.push(arguments);
}
gt
```

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

### GitHub Actions Workflow for BioContainers Import

Source: https://context7.com/research-software-ecosystem/content/llms.txt

A GitHub Actions workflow written in YAML to automate the import of container metadata from the BioContainers registry. It utilizes two `actions/checkout` steps to fetch the necessary repositories and then executes a Python script to perform the import and commit changes. Environment variables and specific script paths are crucial for its operation.

```yaml
name: biocontainers import

on:
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-20.04

    steps:
    - uses: actions/checkout@v4
      with:
        repository: bio-tools/content-ecosystem-utils
        path: content-ecosystem-utils
        ref: 'biocontainers-annotation-import'

    - uses: actions/checkout@v4
      with:
        path: content

    - name: import biocontainers annotations
      env:
        BIOCONTAINERS_URL: https://raw.githubusercontent.com/BioContainers/tools-metadata/master/annotations.yaml
      run: |
        cd ${{ github.workspace }}/content/data

        # Check if PR exists
        if ${{ github.workspace }}/content-ecosystem-utils/scripts/git-utils/checkout-pr-if-exist.sh biocontainers-import; then
          IS_PR_CREATED=true
        else
          IS_PR_CREATED=false
        fi

        # Setup Python environment
        sudo pip3 install virtualenv
        virtualenv -p python3 venv
        . venv/bin/activate
        pip3 install setuptools wheel jinja2 pyyaml requests

        # Run import script
        python3 ${{ github.workspace }}/content-ecosystem-utils/scripts/biocontainers-annotations-import/biocontainers-importer.py \
          ${{ github.workspace }}/content/data/ $BIOCONTAINERS_URL

        # Commit changes
        ${{ github.workspace }}/content-ecosystem-utils/scripts/git-utils/import-changes.sh $IS_PR_CREATED biocontainers-import

```

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

### Google Analytics Configuration

Source: https://github.com/research-software-ecosystem/content/blob/master/imports/bioconductor/bioconcotk.bioconductor.citation.html

This JavaScript snippet initializes Google Analytics tracking for the Bioconductor website. It ensures that the dataLayer is available and then sends the initial 'js' command with the current date and the 'config' command with the measurement ID 'G-WJMEEH1J58'.

```javascript
window.dataLayer = window.dataLayer || [];
function gtag() {
  dataLayer.push(arguments);
} gtag("js", new Date());
gtag("config", "G-WJMEEH1J58");
```

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

### Bio.tools Metadata Structure (JSON)

Source: https://context7.com/research-software-ecosystem/content/llms.txt

Defines the structure for metadata from the bio.tools registry, including tool identification, description, function with EDAM ontology annotations for inputs and operations, and contributor information. This format is crucial for semantic interoperability.

```json
{
  "biotoolsID": "fastqc",
  "biotoolsCURIE": "biotools:fastqc",
  "name": "FastQC",
  "description": "This tool aims to provide a QC report which can spot problems or biases which originate either in the sequencer or in the starting library material.",
  "function": [
    {
      "input": [
        {
          "data": {
            "term": "Raw sequence",
            "uri": "http://edamontology.org/data_0848"
          },
          "format": [
            {
              "term": "FASTQ",
              "uri": "http://edamontology.org/format_1930"
            }
          ]
        }
      ],
      "operation": [
        {
          "term": "Sequencing quality control",
          "uri": "http://edamontology.org/operation_3218"
        }
      ]
    }
  ],
  "credit": [
    {
      "email": "simon.andrews@bbsrc.ac.uk",
      "name": "Simon Andrews",
      "typeRole": ["Primary contact"]
    }
  ]
}
```

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

### SPARQL Query for Tool Types by Contributor Count

Source: https://github.com/research-software-ecosystem/content/blob/master/doc/bioschemas.md

This SPARQL query categorizes tools by their additionalType and counts the number of distinct contributors for each type, presenting the results sorted by contributor count in descending order. Requires a SPARQL endpoint with contributor data.

```sparql
SELECT  ?type (COUNT(?c) as ?contributors) WHERE {
?x rdf:type <http://schema.org/SoftwareApplication> ;
   <http://schema.org/name> ?name ;
   <http://schema.org/additionalType> ?type ;
   <http://schema.org/contributor> ?c .
}
GROUP BY ?type
ORDER BY DESC(?contributors)
```

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

### SPARQL Query for Tool Metadata

Source: https://context7.com/research-software-ecosystem/content/llms.txt

A SPARQL query designed to access bioschemas annotations via a SPARQL endpoint. This query enables semantic analysis of tool metadata stored in a structured format. The specific query details are not provided in the input text, but its purpose is to retrieve bioschemas data.

```sparql

```

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

### OpenEBench Quality Metrics Schema JSON

Source: https://context7.com/research-software-ecosystem/content/llms.txt

The JSON schema defining the structure for OpenEBench tool quality metrics. It specifies properties for project, distribution, and their sub-properties, including details on website operational status, licensing, and source code availability. This schema is used to standardize the reporting of tool quality metrics.

```json
{
  "$schema": "http://json-schema.org/draft-04/hyper-schema#",
  "title": "OpenEBench Tools Monitoring Quality Metrics Schema",
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "@id": {"type": "string", "format": "uri"},
      "project": {
        "properties": {
          "identity": {
            "domain": {"type": "boolean"},
            "logo": {"type": "boolean"},
            "trademark": {"type": "boolean"}
          },
          "website": {
            "operational": {"type": "integer"},
            "ssl": {"type": "boolean"},
            "https": {"type": "boolean"},
            "access_time": {"type": "integer"},
            "bioschemas": {"type": "boolean"}
          },
          "documentation": {
            "api": {"type": "boolean"},
            "tutorial": {"type": "boolean"},
            "manual": {"type": "boolean"}
          },
          "license": {
            "open_source": {"type": "boolean"},
            "osi": {"type": "boolean"}
          }
        }
      },
      "distribution": {
        "properties": {
          "sourcecode": {
            "free": {"type": "boolean"},
            "public": {"type": "boolean"},
            "license": {"type": "boolean"}
          }
        }
      }
    }
  }
}
```

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

### Top EDAM Operations (SPARQL)

Source: https://github.com/research-software-ecosystem/content/blob/master/doc/bioschemas.md

This query identifies the top 3 most represented EDAM operations (data processing types) among software applications. It links software applications to their feature lists (operations) and retrieves the human-readable labels for these operations. Results are grouped by operation and label, ordered by count, and limited to the top 3.

```sparql
SELECT  ?operation (COUNT(?operation) as ?count) ?label WHERE {
?x rdf:type <http://schema.org/SoftwareApplication> ;
   <http://schema.org/name> ?name ;
   <http://schema.org/featureList> ?operation .
   ?operation rdfs:label ?label .
} GROUP BY ?operation ?label
ORDER BY DESC(?count)
LIMIT 3
```

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

### SPARQL Query for Tool Types by Citation Count

Source: https://github.com/research-software-ecosystem/content/blob/master/doc/bioschemas.md

This SPARQL query groups tools by their additionalType (tool type) and counts the number of citations associated with each type, ordered from most to least cited. It requires a SPARQL endpoint with citation information.

```sparql
SELECT  ?type (COUNT(?c) AS ?citations) WHERE {
?x rdf:type <http://schema.org/SoftwareApplication> ;
   <http://schema.org/name> ?name ;
   <http://schema.org/additionalType> ?type ;
   <http://schema.org/citation> ?c .
}
GROUP BY ?type
ORDER BY DESC(?citations)
```

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

### Google Analytics Tracking

Source: https://github.com/research-software-ecosystem/content/blob/master/imports/bioconductor/cellscore.bioconductor.citation.html

This JavaScript snippet configures Google Analytics for the Bioconductor website. It initializes the data layer and sets up tracking for website usage.

```javascript
window.dataLayer = window.dataLayer || []; function gtag() { dataLayer.push(arguments); } gtag("js", new Date()); gtag("config", "G-WJMEEH1J58");
```

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

### SPARQL Query for Bioschemas Properties

Source: https://github.com/research-software-ecosystem/content/blob/master/doc/bioschemas.md

This SPARQL query retrieves all properties used in the Bioschemas dataset within _bio.tools_ and counts their occurrences, sorted by frequency. It requires access to a SPARQL endpoint containing the Bioschemas data.

```sparql
SELECT ?p (COUNT(?s) AS ?count ) {
  ?s ?p ?o 
}
GROUP BY ?p
ORDER BY DESC(?count)
```

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

### Python Script for Bio.tools to Bioschemas Conversion

Source: https://github.com/research-software-ecosystem/content/blob/master/doc/bioschemas.md

This Python script is the core component for transforming _bio.tools_ data into Bioschemas markup. It leverages the Bioschemas Tool profile. It requires Python and potentially external libraries for web scraping or API interaction.

```python
import json

def biotools_to_bioschemas(tool_data):
    """Converts _bio.tools_ data to Bioschemas Tool profile format."""
    bioschemas_entry = {
        "@context": "https://schema.org/",
        "@type": "SoftwareApplication",
        "name": tool_data.get("name"),
        "description": tool_data.get("description"),
        "url": tool_data.get("webpage"),
        "applicationCategory": tool_data.get("topic"),
        "featureList": [],
        "citation": tool_data.get("citation"),
        "contributor": tool_data.get("contributor")
        # Add more mappings as needed based on the Bioschemas Tool profile
    }

    # Example of mapping additional properties if available
    if "operations" in tool_data:
        for op in tool_data["operations"]:
            bioschemas_entry["featureList"].append({
                "@type": "HowToDirection",
                "name": op.get("name"),
                "description": op.get("description")
            })

    return bioschemas_entry

# Example usage:
# Assuming tool_data is a dictionary fetched from _bio.tools_
# converted_data = biotools_to_bioschemas(tool_data)
# print(json.dumps(converted_data, indent=2))

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.